CodingPirates/blockly
1
0
Fork 0
mirror of https://github.com/google/blockly.git synced 2025-12-15 13:50:08 +01:00
Code Issues Packages Projects Releases Wiki Activity

refactor: convert some js block generators to goog.module (#5756)

Browse Source 
* refactor: convert generators/javascript/colour.js to goog.module

* refactor: convert generators/javascript/colour.js to named requires

* chore: run clang-format

* refactor: convert generators/javascript/lists.js to goog.module

* refactor: convert generators/javascript/lists.js to named requires

* chore: run clang-format

* refactor: convert generators/javascript/logic.js to goog.module

* refactor: convert generators/javascript/logic.js to named requires

* chore: run clang-format

* refactor: convert genereators/javascript/math.js to goog.module

* refactor: convert generators/javascript/math.js to named requires

* chore: rebuild deps.js
This commit is contained in:
Rachel Fenichel
2021-11-30 17:31:55 -08:00
committed by GitHub
parent d9991516cc
commit e11fe348b2
5 changed files with 361 additions and 367 deletions
Download Patch File Download Diff File Expand all files Collapse all files

114
generators/javascript/colour.js
View File

@@ -9,80 +9,74 @@
*/
'use strict';
goog.provide('Blockly.JavaScript.colour');
goog.module('Blockly.JavaScript.colour');
goog.require('Blockly.JavaScript');
const JavaScript = goog.require('Blockly.JavaScript');
Blockly.JavaScript['colour_picker'] = function(block) {
JavaScript['colour_picker'] = function(block) {
// Colour picker.
const code = Blockly.JavaScript.quote_(block.getFieldValue('COLOUR'));
return [code, Blockly.JavaScript.ORDER_ATOMIC];
const code = JavaScript.quote_(block.getFieldValue('COLOUR'));
return [code, JavaScript.ORDER_ATOMIC];
};
Blockly.JavaScript['colour_random'] = function(block) {
JavaScript['colour_random'] = function(block) {
// Generate a random colour.
const functionName = Blockly.JavaScript.provideFunction_(
'colourRandom',
['function ' + Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_ + '() {',
' var num = Math.floor(Math.random() * Math.pow(2, 24));',
' return \'#\' + (\'00000\' + num.toString(16)).substr(-6);',
'}']);
const functionName = JavaScript.provideFunction_('colourRandom', [
'function ' + JavaScript.FUNCTION_NAME_PLACEHOLDER_ + '() {',
' var num = Math.floor(Math.random() * Math.pow(2, 24));',
' return \'#\' + (\'00000\' + num.toString(16)).substr(-6);', '}'
]);
const code = functionName + '()';
return [code, Blockly.JavaScript.ORDER_FUNCTION_CALL];
return [code, JavaScript.ORDER_FUNCTION_CALL];
};
Blockly.JavaScript['colour_rgb'] = function(block) {
JavaScript['colour_rgb'] = function(block) {
// Compose a colour from RGB components expressed as percentages.
const red = Blockly.JavaScript.valueToCode(block, 'RED',
Blockly.JavaScript.ORDER_NONE) || 0;
const green = Blockly.JavaScript.valueToCode(block, 'GREEN',
Blockly.JavaScript.ORDER_NONE) || 0;
const blue = Blockly.JavaScript.valueToCode(block, 'BLUE',
Blockly.JavaScript.ORDER_NONE) || 0;
const functionName = Blockly.JavaScript.provideFunction_(
'colourRgb',
['function ' + Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_ +
'(r, g, b) {',
' r = Math.max(Math.min(Number(r), 100), 0) * 2.55;',
' g = Math.max(Math.min(Number(g), 100), 0) * 2.55;',
' b = Math.max(Math.min(Number(b), 100), 0) * 2.55;',
' r = (\'0\' + (Math.round(r) || 0).toString(16)).slice(-2);',
' g = (\'0\' + (Math.round(g) || 0).toString(16)).slice(-2);',
' b = (\'0\' + (Math.round(b) || 0).toString(16)).slice(-2);',
' return \'#\' + r + g + b;',
'}']);
const red = JavaScript.valueToCode(block, 'RED', JavaScript.ORDER_NONE) || 0;
const green =
JavaScript.valueToCode(block, 'GREEN', JavaScript.ORDER_NONE) || 0;
const blue =
JavaScript.valueToCode(block, 'BLUE', JavaScript.ORDER_NONE) || 0;
const functionName = JavaScript.provideFunction_('colourRgb', [
'function ' + JavaScript.FUNCTION_NAME_PLACEHOLDER_ + '(r, g, b) {',
' r = Math.max(Math.min(Number(r), 100), 0) * 2.55;',
' g = Math.max(Math.min(Number(g), 100), 0) * 2.55;',
' b = Math.max(Math.min(Number(b), 100), 0) * 2.55;',
' r = (\'0\' + (Math.round(r) || 0).toString(16)).slice(-2);',
' g = (\'0\' + (Math.round(g) || 0).toString(16)).slice(-2);',
' b = (\'0\' + (Math.round(b) || 0).toString(16)).slice(-2);',
' return \'#\' + r + g + b;', '}'
]);
const code = functionName + '(' + red + ', ' + green + ', ' + blue + ')';
return [code, Blockly.JavaScript.ORDER_FUNCTION_CALL];
return [code, JavaScript.ORDER_FUNCTION_CALL];
};
Blockly.JavaScript['colour_blend'] = function(block) {
JavaScript['colour_blend'] = function(block) {
// Blend two colours together.
const c1 = Blockly.JavaScript.valueToCode(block, 'COLOUR1',
Blockly.JavaScript.ORDER_NONE) || '\'#000000\'';
const c2 = Blockly.JavaScript.valueToCode(block, 'COLOUR2',
Blockly.JavaScript.ORDER_NONE) || '\'#000000\'';
const ratio = Blockly.JavaScript.valueToCode(block, 'RATIO',
Blockly.JavaScript.ORDER_NONE) || 0.5;
const functionName = Blockly.JavaScript.provideFunction_(
'colourBlend',
['function ' + Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_ +
'(c1, c2, ratio) {',
' ratio = Math.max(Math.min(Number(ratio), 1), 0);',
' var r1 = parseInt(c1.substring(1, 3), 16);',
' var g1 = parseInt(c1.substring(3, 5), 16);',
' var b1 = parseInt(c1.substring(5, 7), 16);',
' var r2 = parseInt(c2.substring(1, 3), 16);',
' var g2 = parseInt(c2.substring(3, 5), 16);',
' var b2 = parseInt(c2.substring(5, 7), 16);',
' var r = Math.round(r1 * (1 - ratio) + r2 * ratio);',
' var g = Math.round(g1 * (1 - ratio) + g2 * ratio);',
' var b = Math.round(b1 * (1 - ratio) + b2 * ratio);',
' r = (\'0\' + (r || 0).toString(16)).slice(-2);',
' g = (\'0\' + (g || 0).toString(16)).slice(-2);',
' b = (\'0\' + (b || 0).toString(16)).slice(-2);',
' return \'#\' + r + g + b;',
'}']);
const c1 = JavaScript.valueToCode(block, 'COLOUR1', JavaScript.ORDER_NONE) ||
'\'#000000\'';
const c2 = JavaScript.valueToCode(block, 'COLOUR2', JavaScript.ORDER_NONE) ||
'\'#000000\'';
const ratio =
JavaScript.valueToCode(block, 'RATIO', JavaScript.ORDER_NONE) || 0.5;
const functionName = JavaScript.provideFunction_('colourBlend', [
'function ' + JavaScript.FUNCTION_NAME_PLACEHOLDER_ + '(c1, c2, ratio) {',
' ratio = Math.max(Math.min(Number(ratio), 1), 0);',
' var r1 = parseInt(c1.substring(1, 3), 16);',
' var g1 = parseInt(c1.substring(3, 5), 16);',
' var b1 = parseInt(c1.substring(5, 7), 16);',
' var r2 = parseInt(c2.substring(1, 3), 16);',
' var g2 = parseInt(c2.substring(3, 5), 16);',
' var b2 = parseInt(c2.substring(5, 7), 16);',
' var r = Math.round(r1 * (1 - ratio) + r2 * ratio);',
' var g = Math.round(g1 * (1 - ratio) + g2 * ratio);',
' var b = Math.round(b1 * (1 - ratio) + b2 * ratio);',
' r = (\'0\' + (r || 0).toString(16)).slice(-2);',
' g = (\'0\' + (g || 0).toString(16)).slice(-2);',
' b = (\'0\' + (b || 0).toString(16)).slice(-2);',
' return \'#\' + r + g + b;', '}'
]);
const code = functionName + '(' + c1 + ', ' + c2 + ', ' + ratio + ')';
return [code, Blockly.JavaScript.ORDER_FUNCTION_CALL];
return [code, JavaScript.ORDER_FUNCTION_CALL];
};

284
generators/javascript/lists.js
View File

@@ -10,93 +10,90 @@
*/
'use strict';
goog.provide('Blockly.JavaScript.lists');
goog.module('Blockly.JavaScript.lists');
goog.require('Blockly.JavaScript');
const JavaScript = goog.require('Blockly.JavaScript');
const {NameType} = goog.require('Blockly.Names');
Blockly.JavaScript['lists_create_empty'] = function(block) {
JavaScript['lists_create_empty'] = function(block) {
// Create an empty list.
return ['[]', Blockly.JavaScript.ORDER_ATOMIC];
return ['[]', JavaScript.ORDER_ATOMIC];
};
Blockly.JavaScript['lists_create_with'] = function(block) {
JavaScript['lists_create_with'] = function(block) {
// Create a list with any number of elements of any type.
const elements = new Array(block.itemCount_);
for (let i = 0; i < block.itemCount_; i++) {
elements[i] = Blockly.JavaScript.valueToCode(block, 'ADD' + i,
Blockly.JavaScript.ORDER_NONE) || 'null';
elements[i] =
JavaScript.valueToCode(block, 'ADD' + i, JavaScript.ORDER_NONE) ||
'null';
}
const code = '[' + elements.join(', ') + ']';
return [code, Blockly.JavaScript.ORDER_ATOMIC];
return [code, JavaScript.ORDER_ATOMIC];
};
Blockly.JavaScript['lists_repeat'] = function(block) {
JavaScript['lists_repeat'] = function(block) {
// Create a list with one element repeated.
const functionName = Blockly.JavaScript.provideFunction_(
'listsRepeat',
['function ' + Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_ +
'(value, n) {',
' var array = [];',
' for (var i = 0; i < n; i++) {',
' array[i] = value;',
' }',
' return array;',
'}']);
const element = Blockly.JavaScript.valueToCode(block, 'ITEM',
Blockly.JavaScript.ORDER_NONE) || 'null';
const repeatCount = Blockly.JavaScript.valueToCode(block, 'NUM',
Blockly.JavaScript.ORDER_NONE) || '0';
const functionName = JavaScript.provideFunction_('listsRepeat', [
'function ' + JavaScript.FUNCTION_NAME_PLACEHOLDER_ + '(value, n) {',
' var array = [];', ' for (var i = 0; i < n; i++) {',
' array[i] = value;', ' }', ' return array;', '}'
]);
const element =
JavaScript.valueToCode(block, 'ITEM', JavaScript.ORDER_NONE) || 'null';
const repeatCount =
JavaScript.valueToCode(block, 'NUM', JavaScript.ORDER_NONE) || '0';
const code = functionName + '(' + element + ', ' + repeatCount + ')';
return [code, Blockly.JavaScript.ORDER_FUNCTION_CALL];
return [code, JavaScript.ORDER_FUNCTION_CALL];
};
Blockly.JavaScript['lists_length'] = function(block) {
JavaScript['lists_length'] = function(block) {
// String or array length.
const list = Blockly.JavaScript.valueToCode(block, 'VALUE',
Blockly.JavaScript.ORDER_MEMBER) || '[]';
return [list + '.length', Blockly.JavaScript.ORDER_MEMBER];
const list =
JavaScript.valueToCode(block, 'VALUE', JavaScript.ORDER_MEMBER) || '[]';
return [list + '.length', JavaScript.ORDER_MEMBER];
};
Blockly.JavaScript['lists_isEmpty'] = function(block) {
JavaScript['lists_isEmpty'] = function(block) {
// Is the string null or array empty?
const list = Blockly.JavaScript.valueToCode(block, 'VALUE',
Blockly.JavaScript.ORDER_MEMBER) || '[]';
return ['!' + list + '.length', Blockly.JavaScript.ORDER_LOGICAL_NOT];
const list =
JavaScript.valueToCode(block, 'VALUE', JavaScript.ORDER_MEMBER) || '[]';
return ['!' + list + '.length', JavaScript.ORDER_LOGICAL_NOT];
};
Blockly.JavaScript['lists_indexOf'] = function(block) {
JavaScript['lists_indexOf'] = function(block) {
// Find an item in the list.
const operator = block.getFieldValue('END') === 'FIRST' ?
'indexOf' : 'lastIndexOf';
const item = Blockly.JavaScript.valueToCode(block, 'FIND',
Blockly.JavaScript.ORDER_NONE) || '\'\'';
const list = Blockly.JavaScript.valueToCode(block, 'VALUE',
Blockly.JavaScript.ORDER_MEMBER) || '[]';
const operator =
block.getFieldValue('END') === 'FIRST' ? 'indexOf' : 'lastIndexOf';
const item =
JavaScript.valueToCode(block, 'FIND', JavaScript.ORDER_NONE) || '\'\'';
const list =
JavaScript.valueToCode(block, 'VALUE', JavaScript.ORDER_MEMBER) || '[]';
const code = list + '.' + operator + '(' + item + ')';
if (block.workspace.options.oneBasedIndex) {
return [code + ' + 1', Blockly.JavaScript.ORDER_ADDITION];
return [code + ' + 1', JavaScript.ORDER_ADDITION];
}
return [code, Blockly.JavaScript.ORDER_FUNCTION_CALL];
return [code, JavaScript.ORDER_FUNCTION_CALL];
};
Blockly.JavaScript['lists_getIndex'] = function(block) {
JavaScript['lists_getIndex'] = function(block) {
// Get element at index.
// Note: Until January 2013 this block did not have MODE or WHERE inputs.
const mode = block.getFieldValue('MODE') || 'GET';
const where = block.getFieldValue('WHERE') || 'FROM_START';
const listOrder = (where === 'RANDOM') ? Blockly.JavaScript.ORDER_NONE :
Blockly.JavaScript.ORDER_MEMBER;
const list = Blockly.JavaScript.valueToCode(block, 'VALUE', listOrder) || '[]';
const listOrder =
(where === 'RANDOM') ? JavaScript.ORDER_NONE : JavaScript.ORDER_MEMBER;
const list = JavaScript.valueToCode(block, 'VALUE', listOrder) || '[]';
switch (where) {
case ('FIRST'):
if (mode === 'GET') {
const code = list + '[0]';
return [code, Blockly.JavaScript.ORDER_MEMBER];
return [code, JavaScript.ORDER_MEMBER];
} else if (mode === 'GET_REMOVE') {
const code = list + '.shift()';
return [code, Blockly.JavaScript.ORDER_MEMBER];
return [code, JavaScript.ORDER_MEMBER];
} else if (mode === 'REMOVE') {
return list + '.shift();\n';
}
@@ -104,55 +101,51 @@ Blockly.JavaScript['lists_getIndex'] = function(block) {
case ('LAST'):
if (mode === 'GET') {
const code = list + '.slice(-1)[0]';
return [code, Blockly.JavaScript.ORDER_MEMBER];
return [code, JavaScript.ORDER_MEMBER];
} else if (mode === 'GET_REMOVE') {
const code = list + '.pop()';
return [code, Blockly.JavaScript.ORDER_MEMBER];
return [code, JavaScript.ORDER_MEMBER];
} else if (mode === 'REMOVE') {
return list + '.pop();\n';
}
break;
case ('FROM_START'): {
const at = Blockly.JavaScript.getAdjusted(block, 'AT');
const at = JavaScript.getAdjusted(block, 'AT');
if (mode === 'GET') {
const code = list + '[' + at + ']';
return [code, Blockly.JavaScript.ORDER_MEMBER];
return [code, JavaScript.ORDER_MEMBER];
} else if (mode === 'GET_REMOVE') {
const code = list + '.splice(' + at + ', 1)[0]';
return [code, Blockly.JavaScript.ORDER_FUNCTION_CALL];
return [code, JavaScript.ORDER_FUNCTION_CALL];
} else if (mode === 'REMOVE') {
return list + '.splice(' + at + ', 1);\n';
}
break;
}
case ('FROM_END'): {
const at = Blockly.JavaScript.getAdjusted(block, 'AT', 1, true);
const at = JavaScript.getAdjusted(block, 'AT', 1, true);
if (mode === 'GET') {
const code = list + '.slice(' + at + ')[0]';
return [code, Blockly.JavaScript.ORDER_FUNCTION_CALL];
return [code, JavaScript.ORDER_FUNCTION_CALL];
} else if (mode === 'GET_REMOVE') {
const code = list + '.splice(' + at + ', 1)[0]';
return [code, Blockly.JavaScript.ORDER_FUNCTION_CALL];
return [code, JavaScript.ORDER_FUNCTION_CALL];
} else if (mode === 'REMOVE') {
return list + '.splice(' + at + ', 1);';
}
break;
}
case ('RANDOM'): {
const functionName = Blockly.JavaScript.provideFunction_(
'listsGetRandomItem',
['function ' + Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_ +
'(list, remove) {',
' var x = Math.floor(Math.random() * list.length);',
' if (remove) {',
' return list.splice(x, 1)[0];',
' } else {',
' return list[x];',
' }',
'}']);
const functionName = JavaScript.provideFunction_('listsGetRandomItem', [
'function ' + JavaScript.FUNCTION_NAME_PLACEHOLDER_ +
'(list, remove) {',
' var x = Math.floor(Math.random() * list.length);', ' if (remove) {',
' return list.splice(x, 1)[0];', ' } else {', ' return list[x];',
' }', '}'
]);
const code = functionName + '(' + list + ', ' + (mode !== 'GET') + ')';
if (mode === 'GET' || mode === 'GET_REMOVE') {
return [code, Blockly.JavaScript.ORDER_FUNCTION_CALL];
return [code, JavaScript.ORDER_FUNCTION_CALL];
} else if (mode === 'REMOVE') {
return code + ';\n';
}
@@ -162,23 +155,24 @@ Blockly.JavaScript['lists_getIndex'] = function(block) {
throw Error('Unhandled combination (lists_getIndex).');
};
Blockly.JavaScript['lists_setIndex'] = function(block) {
JavaScript['lists_setIndex'] = function(block) {
// Set element at index.
// Note: Until February 2013 this block did not have MODE or WHERE inputs.
let list = Blockly.JavaScript.valueToCode(block, 'LIST',
Blockly.JavaScript.ORDER_MEMBER) || '[]';
let list =
JavaScript.valueToCode(block, 'LIST', JavaScript.ORDER_MEMBER) || '[]';
const mode = block.getFieldValue('MODE') || 'GET';
const where = block.getFieldValue('WHERE') || 'FROM_START';
const value = Blockly.JavaScript.valueToCode(block, 'TO',
Blockly.JavaScript.ORDER_ASSIGNMENT) || 'null';
const value =
JavaScript.valueToCode(block, 'TO', JavaScript.ORDER_ASSIGNMENT) ||
'null';
// Cache non-trivial values to variables to prevent repeated look-ups.
// Closure, which accesses and modifies 'list'.
function cacheList() {
if (list.match(/^\w+$/)) {
return '';
}
const listVar = Blockly.JavaScript.nameDB_.getDistinctName(
'tmpList', Blockly.VARIABLE_CATEGORY_NAME);
const listVar =
JavaScript.nameDB_.getDistinctName('tmpList', NameType.VARIABLE);
const code = 'var ' + listVar + ' = ' + list + ';\n';
list = listVar;
return code;
@@ -201,7 +195,7 @@ Blockly.JavaScript['lists_setIndex'] = function(block) {
}
break;
case ('FROM_START'): {
const at = Blockly.JavaScript.getAdjusted(block, 'AT');
const at = JavaScript.getAdjusted(block, 'AT');
if (mode === 'SET') {
return list + '[' + at + '] = ' + value + ';\n';
} else if (mode === 'INSERT') {
@@ -210,8 +204,8 @@ Blockly.JavaScript['lists_setIndex'] = function(block) {
break;
}
case ('FROM_END'): {
const at = Blockly.JavaScript.getAdjusted(block, 'AT', 1, false,
Blockly.JavaScript.ORDER_SUBTRACTION);
const at = JavaScript.getAdjusted(
block, 'AT', 1, false, JavaScript.ORDER_SUBTRACTION);
let code = cacheList();
if (mode === 'SET') {
code += list + '[' + list + '.length - ' + at + '] = ' + value + ';\n';
@@ -225,8 +219,8 @@ Blockly.JavaScript['lists_setIndex'] = function(block) {
}
case ('RANDOM'): {
let code = cacheList();
const xVar = Blockly.JavaScript.nameDB_.getDistinctName(
'tmpX', Blockly.VARIABLE_CATEGORY_NAME);
const xVar =
JavaScript.nameDB_.getDistinctName('tmpX', NameType.VARIABLE);
code += 'var ' + xVar + ' = Math.floor(Math.random() * ' + list +
'.length);\n';
if (mode === 'SET') {
@@ -248,9 +242,8 @@ Blockly.JavaScript['lists_setIndex'] = function(block) {
* @param {string} where The method of indexing, selected by dropdown in Blockly
* @param {string=} opt_at The optional offset when indexing from start/end.
* @return {string|undefined} Index expression.
* @private
*/
Blockly.JavaScript.lists.getIndex_ = function(listName, where, opt_at) {
const getSubstringIndex = function(listName, where, opt_at) {
if (where === 'FIRST') {
return '0';
} else if (where === 'FROM_END') {
@@ -262,27 +255,28 @@ Blockly.JavaScript.lists.getIndex_ = function(listName, where, opt_at) {
}
};
Blockly.JavaScript['lists_getSublist'] = function(block) {
JavaScript['lists_getSublist'] = function(block) {
// Get sublist.
const list = Blockly.JavaScript.valueToCode(block, 'LIST',
Blockly.JavaScript.ORDER_MEMBER) || '[]';
const list =
JavaScript.valueToCode(block, 'LIST', JavaScript.ORDER_MEMBER) || '[]';
const where1 = block.getFieldValue('WHERE1');
const where2 = block.getFieldValue('WHERE2');
let code;
if (where1 === 'FIRST' && where2 === 'LAST') {
code = list + '.slice(0)';
} else if (list.match(/^\w+$/) ||
} else if (
list.match(/^\w+$/) ||
(where1 !== 'FROM_END' && where2 === 'FROM_START')) {
// If the list is a variable or doesn't require a call for length, don't
// generate a helper function.
let at1;
switch (where1) {
case 'FROM_START':
at1 = Blockly.JavaScript.getAdjusted(block, 'AT1');
at1 = JavaScript.getAdjusted(block, 'AT1');
break;
case 'FROM_END':
at1 = Blockly.JavaScript.getAdjusted(block, 'AT1', 1, false,
Blockly.JavaScript.ORDER_SUBTRACTION);
at1 = JavaScript.getAdjusted(
block, 'AT1', 1, false, JavaScript.ORDER_SUBTRACTION);
at1 = list + '.length - ' + at1;
break;
case 'FIRST':
@@ -294,11 +288,11 @@ Blockly.JavaScript['lists_getSublist'] = function(block) {
let at2;
switch (where2) {
case 'FROM_START':
at2 = Blockly.JavaScript.getAdjusted(block, 'AT2', 1);
at2 = JavaScript.getAdjusted(block, 'AT2', 1);
break;
case 'FROM_END':
at2 = Blockly.JavaScript.getAdjusted(block, 'AT2', 0, false,
Blockly.JavaScript.ORDER_SUBTRACTION);
at2 = JavaScript.getAdjusted(
block, 'AT2', 0, false, JavaScript.ORDER_SUBTRACTION);
at2 = list + '.length - ' + at2;
break;
case 'LAST':
@@ -309,24 +303,29 @@ Blockly.JavaScript['lists_getSublist'] = function(block) {
}
code = list + '.slice(' + at1 + ', ' + at2 + ')';
} else {
const at1 = Blockly.JavaScript.getAdjusted(block, 'AT1');
const at2 = Blockly.JavaScript.getAdjusted(block, 'AT2');
const getIndex_ = Blockly.JavaScript.lists.getIndex_;
const wherePascalCase = {'FIRST': 'First', 'LAST': 'Last',
'FROM_START': 'FromStart', 'FROM_END': 'FromEnd'};
const functionName = Blockly.JavaScript.provideFunction_(
'subsequence' + wherePascalCase[where1] + wherePascalCase[where2],
['function ' + Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_ +
'(sequence' +
// The value for 'FROM_END' and'FROM_START' depends on `at` so
// we add it as a parameter.
((where1 === 'FROM_END' || where1 === 'FROM_START') ? ', at1' : '') +
((where2 === 'FROM_END' || where2 === 'FROM_START') ? ', at2' : '') +
') {',
' var start = ' + getIndex_('sequence', where1, 'at1') + ';',
' var end = ' + getIndex_('sequence', where2, 'at2') + ' + 1;',
' return sequence.slice(start, end);',
'}']);
const at1 = JavaScript.getAdjusted(block, 'AT1');
const at2 = JavaScript.getAdjusted(block, 'AT2');
const wherePascalCase = {
'FIRST': 'First',
'LAST': 'Last',
'FROM_START': 'FromStart',
'FROM_END': 'FromEnd'
};
const functionName = JavaScript.provideFunction_(
'subsequence' + wherePascalCase[where1] + wherePascalCase[where2], [
'function ' + JavaScript.FUNCTION_NAME_PLACEHOLDER_ + '(sequence' +
// The value for 'FROM_END' and'FROM_START' depends on `at` so
// we add it as a parameter.
((where1 === 'FROM_END' || where1 === 'FROM_START') ? ', at1' :
'') +
((where2 === 'FROM_END' || where2 === 'FROM_START') ? ', at2' :
'') +
') {',
getSubstringIndex('sequence', where1, 'at1') + ';',
' var end = ' + getSubstringIndex('sequence', where2, 'at2') +
' + 1;',
' return sequence.slice(start, end);', '}'
]);
code = functionName + '(' + list +
// The value for 'FROM_END' and 'FROM_START' depends on `at` so we
// pass it.
@@ -334,42 +333,42 @@ Blockly.JavaScript['lists_getSublist'] = function(block) {
((where2 === 'FROM_END' || where2 === 'FROM_START') ? ', ' + at2 : '') +
')';
}
return [code, Blockly.JavaScript.ORDER_FUNCTION_CALL];
return [code, JavaScript.ORDER_FUNCTION_CALL];
};
Blockly.JavaScript['lists_sort'] = function(block) {
JavaScript['lists_sort'] = function(block) {
// Block for sorting a list.
const list = Blockly.JavaScript.valueToCode(block, 'LIST',
Blockly.JavaScript.ORDER_FUNCTION_CALL) || '[]';
const list =
JavaScript.valueToCode(block, 'LIST', JavaScript.ORDER_FUNCTION_CALL) ||
'[]';
const direction = block.getFieldValue('DIRECTION') === '1' ? 1 : -1;
const type = block.getFieldValue('TYPE');
const getCompareFunctionName = Blockly.JavaScript.provideFunction_(
'listsGetSortCompare',
['function ' + Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_ +
'(type, direction) {',
' var compareFuncs = {',
' "NUMERIC": function(a, b) {',
' return Number(a) - Number(b); },',
' "TEXT": function(a, b) {',
' return a.toString() > b.toString() ? 1 : -1; },',
' "IGNORE_CASE": function(a, b) {',
' return a.toString().toLowerCase() > ' +
'b.toString().toLowerCase() ? 1 : -1; },',
' };',
' var compare = compareFuncs[type];',
' return function(a, b) { return compare(a, b) * direction; }',
'}']);
return [list + '.slice().sort(' +
getCompareFunctionName + '("' + type + '", ' + direction + '))',
Blockly.JavaScript.ORDER_FUNCTION_CALL];
const getCompareFunctionName =
JavaScript.provideFunction_('listsGetSortCompare', [
'function ' + JavaScript.FUNCTION_NAME_PLACEHOLDER_ +
'(type, direction) {',
' var compareFuncs = {', ' "NUMERIC": function(a, b) {',
' return Number(a) - Number(b); },',
' "TEXT": function(a, b) {',
' return a.toString() > b.toString() ? 1 : -1; },',
' "IGNORE_CASE": function(a, b) {',
' return a.toString().toLowerCase() > ' +
'b.toString().toLowerCase() ? 1 : -1; },',
' };', ' var compare = compareFuncs[type];',
' return function(a, b) { return compare(a, b) * direction; }', '}'
]);
return [
list + '.slice().sort(' + getCompareFunctionName + '("' + type + '", ' +
direction + '))',
JavaScript.ORDER_FUNCTION_CALL
];
};
Blockly.JavaScript['lists_split'] = function(block) {
JavaScript['lists_split'] = function(block) {
// Block for splitting text into a list, or joining a list into text.
let input = Blockly.JavaScript.valueToCode(block, 'INPUT',
Blockly.JavaScript.ORDER_MEMBER);
const delimiter = Blockly.JavaScript.valueToCode(block, 'DELIM',
Blockly.JavaScript.ORDER_NONE) || '\'\'';
let input = JavaScript.valueToCode(block, 'INPUT', JavaScript.ORDER_MEMBER);
const delimiter =
JavaScript.valueToCode(block, 'DELIM', JavaScript.ORDER_NONE) || '\'\'';
const mode = block.getFieldValue('MODE');
let functionName;
if (mode === 'SPLIT') {
@@ -386,13 +385,14 @@ Blockly.JavaScript['lists_split'] = function(block) {
throw Error('Unknown mode: ' + mode);
}
const code = input + '.' + functionName + '(' + delimiter + ')';
return [code, Blockly.JavaScript.ORDER_FUNCTION_CALL];
return [code, JavaScript.ORDER_FUNCTION_CALL];
};
Blockly.JavaScript['lists_reverse'] = function(block) {
JavaScript['lists_reverse'] = function(block) {
// Block for reversing a list.
const list = Blockly.JavaScript.valueToCode(block, 'LIST',
Blockly.JavaScript.ORDER_FUNCTION_CALL) || '[]';
const list =
JavaScript.valueToCode(block, 'LIST', JavaScript.ORDER_FUNCTION_CALL) ||
'[]';
const code = list + '.slice().reverse()';
return [code, Blockly.JavaScript.ORDER_FUNCTION_CALL];
return [code, JavaScript.ORDER_FUNCTION_CALL];
};

109
generators/javascript/logic.js
View File

@@ -9,74 +9,71 @@
*/
'use strict';
goog.provide('Blockly.JavaScript.logic');
goog.module('Blockly.JavaScript.logic');
goog.require('Blockly.JavaScript');
const JavaScript = goog.require('Blockly.JavaScript');
Blockly.JavaScript['controls_if'] = function(block) {
JavaScript['controls_if'] = function(block) {
// If/elseif/else condition.
let n = 0;
let code = '';
if (Blockly.JavaScript.STATEMENT_PREFIX) {
if (JavaScript.STATEMENT_PREFIX) {
// Automatic prefix insertion is switched off for this block. Add manually.
code += Blockly.JavaScript.injectId(Blockly.JavaScript.STATEMENT_PREFIX,
block);
code += JavaScript.injectId(JavaScript.STATEMENT_PREFIX, block);
}
do {
const conditionCode = Blockly.JavaScript.valueToCode(block, 'IF' + n,
Blockly.JavaScript.ORDER_NONE) || 'false';
let branchCode = Blockly.JavaScript.statementToCode(block, 'DO' + n);
if (Blockly.JavaScript.STATEMENT_SUFFIX) {
branchCode = Blockly.JavaScript.prefixLines(
Blockly.JavaScript.injectId(Blockly.JavaScript.STATEMENT_SUFFIX,
block), Blockly.JavaScript.INDENT) + branchCode;
const conditionCode =
JavaScript.valueToCode(block, 'IF' + n, JavaScript.ORDER_NONE) ||
'false';
let branchCode = JavaScript.statementToCode(block, 'DO' + n);
if (JavaScript.STATEMENT_SUFFIX) {
branchCode = JavaScript.prefixLines(
JavaScript.injectId(JavaScript.STATEMENT_SUFFIX, block),
JavaScript.INDENT) +
branchCode;
}
code += (n > 0 ? ' else ' : '') +
'if (' + conditionCode + ') {\n' + branchCode + '}';
code += (n > 0 ? ' else ' : '') + 'if (' + conditionCode + ') {\n' +
branchCode + '}';
n++;
} while (block.getInput('IF' + n));
if (block.getInput('ELSE') || Blockly.JavaScript.STATEMENT_SUFFIX) {
let branchCode = Blockly.JavaScript.statementToCode(block, 'ELSE');
if (Blockly.JavaScript.STATEMENT_SUFFIX) {
branchCode = Blockly.JavaScript.prefixLines(
Blockly.JavaScript.injectId(Blockly.JavaScript.STATEMENT_SUFFIX,
block), Blockly.JavaScript.INDENT) + branchCode;
if (block.getInput('ELSE') || JavaScript.STATEMENT_SUFFIX) {
let branchCode = JavaScript.statementToCode(block, 'ELSE');
if (JavaScript.STATEMENT_SUFFIX) {
branchCode = JavaScript.prefixLines(
JavaScript.injectId(JavaScript.STATEMENT_SUFFIX, block),
JavaScript.INDENT) +
branchCode;
}
code += ' else {\n' + branchCode + '}';
}
return code + '\n';
};
Blockly.JavaScript['controls_ifelse'] = Blockly.JavaScript['controls_if'];
JavaScript['controls_ifelse'] = JavaScript['controls_if'];
Blockly.JavaScript['logic_compare'] = function(block) {
JavaScript['logic_compare'] = function(block) {
// Comparison operator.
const OPERATORS = {
'EQ': '==',
'NEQ': '!=',
'LT': '<',
'LTE': '<=',
'GT': '>',
'GTE': '>='
};
const OPERATORS =
{'EQ': '==', 'NEQ': '!=', 'LT': '<', 'LTE': '<=', 'GT': '>', 'GTE': '>='};
const operator = OPERATORS[block.getFieldValue('OP')];
const order = (operator === '==' || operator === '!=') ?
Blockly.JavaScript.ORDER_EQUALITY : Blockly.JavaScript.ORDER_RELATIONAL;
const argument0 = Blockly.JavaScript.valueToCode(block, 'A', order) || '0';
const argument1 = Blockly.JavaScript.valueToCode(block, 'B', order) || '0';
JavaScript.ORDER_EQUALITY :
JavaScript.ORDER_RELATIONAL;
const argument0 = JavaScript.valueToCode(block, 'A', order) || '0';
const argument1 = JavaScript.valueToCode(block, 'B', order) || '0';
const code = argument0 + ' ' + operator + ' ' + argument1;
return [code, order];
};
Blockly.JavaScript['logic_operation'] = function(block) {
JavaScript['logic_operation'] = function(block) {
// Operations 'and', 'or'.
const operator = (block.getFieldValue('OP') === 'AND') ? '&&' : '||';
const order = (operator === '&&') ? Blockly.JavaScript.ORDER_LOGICAL_AND :
Blockly.JavaScript.ORDER_LOGICAL_OR;
let argument0 = Blockly.JavaScript.valueToCode(block, 'A', order);
let argument1 = Blockly.JavaScript.valueToCode(block, 'B', order);
const order = (operator === '&&') ? JavaScript.ORDER_LOGICAL_AND :
JavaScript.ORDER_LOGICAL_OR;
let argument0 = JavaScript.valueToCode(block, 'A', order);
let argument1 = JavaScript.valueToCode(block, 'B', order);
if (!argument0 && !argument1) {
// If there are no arguments, then the return value is false.
argument0 = 'false';
@@ -95,34 +92,36 @@ Blockly.JavaScript['logic_operation'] = function(block) {
return [code, order];
};
Blockly.JavaScript['logic_negate'] = function(block) {
JavaScript['logic_negate'] = function(block) {
// Negation.
const order = Blockly.JavaScript.ORDER_LOGICAL_NOT;
const argument0 = Blockly.JavaScript.valueToCode(block, 'BOOL', order) ||
'true';
const order = JavaScript.ORDER_LOGICAL_NOT;
const argument0 = JavaScript.valueToCode(block, 'BOOL', order) || 'true';
const code = '!' + argument0;
return [code, order];
};
Blockly.JavaScript['logic_boolean'] = function(block) {
JavaScript['logic_boolean'] = function(block) {
// Boolean values true and false.
const code = (block.getFieldValue('BOOL') === 'TRUE') ? 'true' : 'false';
return [code, Blockly.JavaScript.ORDER_ATOMIC];
return [code, JavaScript.ORDER_ATOMIC];
};
Blockly.JavaScript['logic_null'] = function(block) {
JavaScript['logic_null'] = function(block) {
// Null data type.
return ['null', Blockly.JavaScript.ORDER_ATOMIC];
return ['null', JavaScript.ORDER_ATOMIC];
};
Blockly.JavaScript['logic_ternary'] = function(block) {
JavaScript['logic_ternary'] = function(block) {
// Ternary operator.
const value_if = Blockly.JavaScript.valueToCode(block, 'IF',
Blockly.JavaScript.ORDER_CONDITIONAL) || 'false';
const value_then = Blockly.JavaScript.valueToCode(block, 'THEN',
Blockly.JavaScript.ORDER_CONDITIONAL) || 'null';
const value_else = Blockly.JavaScript.valueToCode(block, 'ELSE',
Blockly.JavaScript.ORDER_CONDITIONAL) || 'null';
const value_if =
JavaScript.valueToCode(block, 'IF', JavaScript.ORDER_CONDITIONAL) ||
'false';
const value_then =
JavaScript.valueToCode(block, 'THEN', JavaScript.ORDER_CONDITIONAL) ||
'null';
const value_else =
JavaScript.valueToCode(block, 'ELSE', JavaScript.ORDER_CONDITIONAL) ||
'null';
const code = value_if + ' ? ' + value_then + ' : ' + value_else;
return [code, Blockly.JavaScript.ORDER_CONDITIONAL];
return [code, JavaScript.ORDER_CONDITIONAL];
};

211
generators/javascript/math.js
View File

@@ -10,65 +10,66 @@
*/
'use strict';
goog.provide('Blockly.JavaScript.math');
goog.module('Blockly.JavaScript.math');
goog.require('Blockly.JavaScript');
const JavaScript = goog.require('Blockly.JavaScript');
const {NameType} = goog.require('Blockly.Names');
Blockly.JavaScript['math_number'] = function(block) {
JavaScript['math_number'] = function(block) {
// Numeric value.
const code = Number(block.getFieldValue('NUM'));
const order = code >= 0 ? Blockly.JavaScript.ORDER_ATOMIC :
Blockly.JavaScript.ORDER_UNARY_NEGATION;
const order = code >= 0 ? JavaScript.ORDER_ATOMIC :
JavaScript.ORDER_UNARY_NEGATION;
return [code, order];
};
Blockly.JavaScript['math_arithmetic'] = function(block) {
JavaScript['math_arithmetic'] = function(block) {
// Basic arithmetic operators, and power.
const OPERATORS = {
'ADD': [' + ', Blockly.JavaScript.ORDER_ADDITION],
'MINUS': [' - ', Blockly.JavaScript.ORDER_SUBTRACTION],
'MULTIPLY': [' * ', Blockly.JavaScript.ORDER_MULTIPLICATION],
'DIVIDE': [' / ', Blockly.JavaScript.ORDER_DIVISION],
'POWER': [null, Blockly.JavaScript.ORDER_NONE] // Handle power separately.
'ADD': [' + ', JavaScript.ORDER_ADDITION],
'MINUS': [' - ', JavaScript.ORDER_SUBTRACTION],
'MULTIPLY': [' * ', JavaScript.ORDER_MULTIPLICATION],
'DIVIDE': [' / ', JavaScript.ORDER_DIVISION],
'POWER': [null, JavaScript.ORDER_NONE] // Handle power separately.
};
const tuple = OPERATORS[block.getFieldValue('OP')];
const operator = tuple[0];
const order = tuple[1];
const argument0 = Blockly.JavaScript.valueToCode(block, 'A', order) || '0';
const argument1 = Blockly.JavaScript.valueToCode(block, 'B', order) || '0';
const argument0 = JavaScript.valueToCode(block, 'A', order) || '0';
const argument1 = JavaScript.valueToCode(block, 'B', order) || '0';
let code;
// Power in JavaScript requires a special case since it has no operator.
if (!operator) {
code = 'Math.pow(' + argument0 + ', ' + argument1 + ')';
return [code, Blockly.JavaScript.ORDER_FUNCTION_CALL];
return [code, JavaScript.ORDER_FUNCTION_CALL];
}
code = argument0 + operator + argument1;
return [code, order];
};
Blockly.JavaScript['math_single'] = function(block) {
JavaScript['math_single'] = function(block) {
// Math operators with single operand.
const operator = block.getFieldValue('OP');
let code;
let arg;
if (operator === 'NEG') {
// Negation is a special case given its different operator precedence.
arg = Blockly.JavaScript.valueToCode(block, 'NUM',
Blockly.JavaScript.ORDER_UNARY_NEGATION) || '0';
arg = JavaScript.valueToCode(block, 'NUM',
JavaScript.ORDER_UNARY_NEGATION) || '0';
if (arg[0] === '-') {
// --3 is not legal in JS.
arg = ' ' + arg;
}
code = '-' + arg;
return [code, Blockly.JavaScript.ORDER_UNARY_NEGATION];
return [code, JavaScript.ORDER_UNARY_NEGATION];
}
if (operator === 'SIN' || operator === 'COS' || operator === 'TAN') {
arg = Blockly.JavaScript.valueToCode(block, 'NUM',
Blockly.JavaScript.ORDER_DIVISION) || '0';
arg = JavaScript.valueToCode(block, 'NUM',
JavaScript.ORDER_DIVISION) || '0';
} else {
arg = Blockly.JavaScript.valueToCode(block, 'NUM',
Blockly.JavaScript.ORDER_NONE) || '0';
arg = JavaScript.valueToCode(block, 'NUM',
JavaScript.ORDER_NONE) || '0';
}
// First, handle cases which generate values that don't need parentheses
// wrapping the code.
@@ -108,7 +109,7 @@ Blockly.JavaScript['math_single'] = function(block) {
break;
}
if (code) {
return [code, Blockly.JavaScript.ORDER_FUNCTION_CALL];
return [code, JavaScript.ORDER_FUNCTION_CALL];
}
// Second, handle cases which generate values that may need parentheses
// wrapping the code.
@@ -128,35 +129,35 @@ Blockly.JavaScript['math_single'] = function(block) {
default:
throw Error('Unknown math operator: ' + operator);
}
return [code, Blockly.JavaScript.ORDER_DIVISION];
return [code, JavaScript.ORDER_DIVISION];
};
Blockly.JavaScript['math_constant'] = function(block) {
JavaScript['math_constant'] = function(block) {
// Constants: PI, E, the Golden Ratio, sqrt(2), 1/sqrt(2), INFINITY.
const CONSTANTS = {
'PI': ['Math.PI', Blockly.JavaScript.ORDER_MEMBER],
'E': ['Math.E', Blockly.JavaScript.ORDER_MEMBER],
'PI': ['Math.PI', JavaScript.ORDER_MEMBER],
'E': ['Math.E', JavaScript.ORDER_MEMBER],
'GOLDEN_RATIO':
['(1 + Math.sqrt(5)) / 2', Blockly.JavaScript.ORDER_DIVISION],
'SQRT2': ['Math.SQRT2', Blockly.JavaScript.ORDER_MEMBER],
'SQRT1_2': ['Math.SQRT1_2', Blockly.JavaScript.ORDER_MEMBER],
'INFINITY': ['Infinity', Blockly.JavaScript.ORDER_ATOMIC]
['(1 + Math.sqrt(5)) / 2', JavaScript.ORDER_DIVISION],
'SQRT2': ['Math.SQRT2', JavaScript.ORDER_MEMBER],
'SQRT1_2': ['Math.SQRT1_2', JavaScript.ORDER_MEMBER],
'INFINITY': ['Infinity', JavaScript.ORDER_ATOMIC]
};
return CONSTANTS[block.getFieldValue('CONSTANT')];
};
Blockly.JavaScript['math_number_property'] = function(block) {
JavaScript['math_number_property'] = function(block) {
// Check if a number is even, odd, prime, whole, positive, or negative
// or if it is divisible by certain number. Returns true or false.
const number_to_check = Blockly.JavaScript.valueToCode(block, 'NUMBER_TO_CHECK',
Blockly.JavaScript.ORDER_MODULUS) || '0';
const number_to_check = JavaScript.valueToCode(block, 'NUMBER_TO_CHECK',
JavaScript.ORDER_MODULUS) || '0';
const dropdown_property = block.getFieldValue('PROPERTY');
let code;
if (dropdown_property === 'PRIME') {
// Prime is a special case as it is not a one-liner test.
const functionName = Blockly.JavaScript.provideFunction_(
const functionName = JavaScript.provideFunction_(
'mathIsPrime',
['function ' + Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_ + '(n) {',
['function ' + JavaScript.FUNCTION_NAME_PLACEHOLDER_ + '(n) {',
' // https://en.wikipedia.org/wiki/Primality_test#Naive_methods',
' if (n == 2 || n == 3) {',
' return true;',
@@ -176,7 +177,7 @@ Blockly.JavaScript['math_number_property'] = function(block) {
' return true;',
'}']);
code = functionName + '(' + number_to_check + ')';
return [code, Blockly.JavaScript.ORDER_FUNCTION_CALL];
return [code, JavaScript.ORDER_FUNCTION_CALL];
}
switch (dropdown_property) {
case 'EVEN':
@@ -195,70 +196,70 @@ Blockly.JavaScript['math_number_property'] = function(block) {
code = number_to_check + ' < 0';
break;
case 'DIVISIBLE_BY': {
const divisor = Blockly.JavaScript.valueToCode(block, 'DIVISOR',
Blockly.JavaScript.ORDER_MODULUS) || '0';
const divisor = JavaScript.valueToCode(block, 'DIVISOR',
JavaScript.ORDER_MODULUS) || '0';
code = number_to_check + ' % ' + divisor + ' === 0';
break;
}
}
return [code, Blockly.JavaScript.ORDER_EQUALITY];
return [code, JavaScript.ORDER_EQUALITY];
};
Blockly.JavaScript['math_change'] = function(block) {
JavaScript['math_change'] = function(block) {
// Add to a variable in place.
const argument0 = Blockly.JavaScript.valueToCode(block, 'DELTA',
Blockly.JavaScript.ORDER_ADDITION) || '0';
const varName = Blockly.JavaScript.nameDB_.getName(
block.getFieldValue('VAR'), Blockly.VARIABLE_CATEGORY_NAME);
const argument0 = JavaScript.valueToCode(block, 'DELTA',
JavaScript.ORDER_ADDITION) || '0';
const varName = JavaScript.nameDB_.getName(
block.getFieldValue('VAR'), NameType.VARIABLE);
return varName + ' = (typeof ' + varName + ' === \'number\' ? ' + varName +
' : 0) + ' + argument0 + ';\n';
};
// Rounding functions have a single operand.
Blockly.JavaScript['math_round'] = Blockly.JavaScript['math_single'];
JavaScript['math_round'] = JavaScript['math_single'];
// Trigonometry functions have a single operand.
Blockly.JavaScript['math_trig'] = Blockly.JavaScript['math_single'];
JavaScript['math_trig'] = JavaScript['math_single'];
Blockly.JavaScript['math_on_list'] = function(block) {
JavaScript['math_on_list'] = function(block) {
// Math functions for lists.
const func = block.getFieldValue('OP');
let list;
let code;
switch (func) {
case 'SUM':
list = Blockly.JavaScript.valueToCode(block, 'LIST',
Blockly.JavaScript.ORDER_MEMBER) || '[]';
list = JavaScript.valueToCode(block, 'LIST',
JavaScript.ORDER_MEMBER) || '[]';
code = list + '.reduce(function(x, y) {return x + y;})';
break;
case 'MIN':
list = Blockly.JavaScript.valueToCode(block, 'LIST',
Blockly.JavaScript.ORDER_NONE) || '[]';
list = JavaScript.valueToCode(block, 'LIST',
JavaScript.ORDER_NONE) || '[]';
code = 'Math.min.apply(null, ' + list + ')';
break;
case 'MAX':
list = Blockly.JavaScript.valueToCode(block, 'LIST',
Blockly.JavaScript.ORDER_NONE) || '[]';
list = JavaScript.valueToCode(block, 'LIST',
JavaScript.ORDER_NONE) || '[]';
code = 'Math.max.apply(null, ' + list + ')';
break;
case 'AVERAGE': {
// mathMean([null,null,1,3]) === 2.0.
const functionName = Blockly.JavaScript.provideFunction_(
const functionName = JavaScript.provideFunction_(
'mathMean',
['function ' + Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_ +
['function ' + JavaScript.FUNCTION_NAME_PLACEHOLDER_ +
'(myList) {',
' return myList.reduce(function(x, y) {return x + y;}) / ' +
'myList.length;',
'}']);
list = Blockly.JavaScript.valueToCode(block, 'LIST',
Blockly.JavaScript.ORDER_NONE) || '[]';
list = JavaScript.valueToCode(block, 'LIST',
JavaScript.ORDER_NONE) || '[]';
code = functionName + '(' + list + ')';
break;
}
case 'MEDIAN': {
// mathMedian([null,null,1,3]) === 2.0.
const functionName = Blockly.JavaScript.provideFunction_(
const functionName = JavaScript.provideFunction_(
'mathMedian',
['function ' + Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_ +
['function ' + JavaScript.FUNCTION_NAME_PLACEHOLDER_ +
'(myList) {',
' var localList = myList.filter(function (x) ' +
'{return typeof x === \'number\';});',
@@ -271,8 +272,8 @@ Blockly.JavaScript['math_on_list'] = function(block) {
' return localList[(localList.length - 1) / 2];',
' }',
'}']);
list = Blockly.JavaScript.valueToCode(block, 'LIST',
Blockly.JavaScript.ORDER_NONE) || '[]';
list = JavaScript.valueToCode(block, 'LIST',
JavaScript.ORDER_NONE) || '[]';
code = functionName + '(' + list + ')';
break;
}
@@ -280,9 +281,9 @@ Blockly.JavaScript['math_on_list'] = function(block) {
// As a list of numbers can contain more than one mode,
// the returned result is provided as an array.
// Mode of [3, 'x', 'x', 1, 1, 2, '3'] -> ['x', 1].
const functionName = Blockly.JavaScript.provideFunction_(
const functionName = JavaScript.provideFunction_(
'mathModes',
['function ' + Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_ +
['function ' + JavaScript.FUNCTION_NAME_PLACEHOLDER_ +
'(values) {',
' var modes = [];',
' var counts = [];',
@@ -311,15 +312,15 @@ Blockly.JavaScript['math_on_list'] = function(block) {
' }',
' return modes;',
'}']);
list = Blockly.JavaScript.valueToCode(block, 'LIST',
Blockly.JavaScript.ORDER_NONE) || '[]';
list = JavaScript.valueToCode(block, 'LIST',
JavaScript.ORDER_NONE) || '[]';
code = functionName + '(' + list + ')';
break;
}
case 'STD_DEV': {
const functionName = Blockly.JavaScript.provideFunction_(
const functionName = JavaScript.provideFunction_(
'mathStandardDeviation',
['function ' + Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_ +
['function ' + JavaScript.FUNCTION_NAME_PLACEHOLDER_ +
'(numbers) {',
' var n = numbers.length;',
' if (!n) return null;',
@@ -331,62 +332,62 @@ Blockly.JavaScript['math_on_list'] = function(block) {
' variance = variance / n;',
' return Math.sqrt(variance);',
'}']);
list = Blockly.JavaScript.valueToCode(block, 'LIST',
Blockly.JavaScript.ORDER_NONE) || '[]';
list = JavaScript.valueToCode(block, 'LIST',
JavaScript.ORDER_NONE) || '[]';
code = functionName + '(' + list + ')';
break;
}
case 'RANDOM': {
const functionName = Blockly.JavaScript.provideFunction_(
const functionName = JavaScript.provideFunction_(
'mathRandomList',
['function ' + Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_ +
['function ' + JavaScript.FUNCTION_NAME_PLACEHOLDER_ +
'(list) {',
' var x = Math.floor(Math.random() * list.length);',
' return list[x];',
'}']);
list = Blockly.JavaScript.valueToCode(block, 'LIST',
Blockly.JavaScript.ORDER_NONE) || '[]';
list = JavaScript.valueToCode(block, 'LIST',
JavaScript.ORDER_NONE) || '[]';
code = functionName + '(' + list + ')';
break;
}
default:
throw Error('Unknown operator: ' + func);
}
return [code, Blockly.JavaScript.ORDER_FUNCTION_CALL];
return [code, JavaScript.ORDER_FUNCTION_CALL];
};
Blockly.JavaScript['math_modulo'] = function(block) {
JavaScript['math_modulo'] = function(block) {
// Remainder computation.
const argument0 = Blockly.JavaScript.valueToCode(block, 'DIVIDEND',
Blockly.JavaScript.ORDER_MODULUS) || '0';
const argument1 = Blockly.JavaScript.valueToCode(block, 'DIVISOR',
Blockly.JavaScript.ORDER_MODULUS) || '0';
const argument0 = JavaScript.valueToCode(block, 'DIVIDEND',
JavaScript.ORDER_MODULUS) || '0';
const argument1 = JavaScript.valueToCode(block, 'DIVISOR',
JavaScript.ORDER_MODULUS) || '0';
const code = argument0 + ' % ' + argument1;
return [code, Blockly.JavaScript.ORDER_MODULUS];
return [code, JavaScript.ORDER_MODULUS];
};
Blockly.JavaScript['math_constrain'] = function(block) {
JavaScript['math_constrain'] = function(block) {
// Constrain a number between two limits.
const argument0 = Blockly.JavaScript.valueToCode(block, 'VALUE',
Blockly.JavaScript.ORDER_NONE) || '0';
const argument1 = Blockly.JavaScript.valueToCode(block, 'LOW',
Blockly.JavaScript.ORDER_NONE) || '0';
const argument2 = Blockly.JavaScript.valueToCode(block, 'HIGH',
Blockly.JavaScript.ORDER_NONE) || 'Infinity';
const argument0 = JavaScript.valueToCode(block, 'VALUE',
JavaScript.ORDER_NONE) || '0';
const argument1 = JavaScript.valueToCode(block, 'LOW',
JavaScript.ORDER_NONE) || '0';
const argument2 = JavaScript.valueToCode(block, 'HIGH',
JavaScript.ORDER_NONE) || 'Infinity';
const code = 'Math.min(Math.max(' + argument0 + ', ' + argument1 + '), ' +
argument2 + ')';
return [code, Blockly.JavaScript.ORDER_FUNCTION_CALL];
return [code, JavaScript.ORDER_FUNCTION_CALL];
};
Blockly.JavaScript['math_random_int'] = function(block) {
JavaScript['math_random_int'] = function(block) {
// Random integer between [X] and [Y].
const argument0 = Blockly.JavaScript.valueToCode(block, 'FROM',
Blockly.JavaScript.ORDER_NONE) || '0';
const argument1 = Blockly.JavaScript.valueToCode(block, 'TO',
Blockly.JavaScript.ORDER_NONE) || '0';
const functionName = Blockly.JavaScript.provideFunction_(
const argument0 = JavaScript.valueToCode(block, 'FROM',
JavaScript.ORDER_NONE) || '0';
const argument1 = JavaScript.valueToCode(block, 'TO',
JavaScript.ORDER_NONE) || '0';
const functionName = JavaScript.provideFunction_(
'mathRandomInt',
['function ' + Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_ +
['function ' + JavaScript.FUNCTION_NAME_PLACEHOLDER_ +
'(a, b) {',
' if (a > b) {',
' // Swap a and b to ensure a is smaller.',
@@ -397,20 +398,20 @@ Blockly.JavaScript['math_random_int'] = function(block) {
' return Math.floor(Math.random() * (b - a + 1) + a);',
'}']);
const code = functionName + '(' + argument0 + ', ' + argument1 + ')';
return [code, Blockly.JavaScript.ORDER_FUNCTION_CALL];
return [code, JavaScript.ORDER_FUNCTION_CALL];
};
Blockly.JavaScript['math_random_float'] = function(block) {
JavaScript['math_random_float'] = function(block) {
// Random fraction between 0 and 1.
return ['Math.random()', Blockly.JavaScript.ORDER_FUNCTION_CALL];
return ['Math.random()', JavaScript.ORDER_FUNCTION_CALL];
};
Blockly.JavaScript['math_atan2'] = function(block) {
JavaScript['math_atan2'] = function(block) {
// Arctangent of point (X, Y) in degrees from -180 to 180.
const argument0 = Blockly.JavaScript.valueToCode(block, 'X',
Blockly.JavaScript.ORDER_NONE) || '0';
const argument1 = Blockly.JavaScript.valueToCode(block, 'Y',
Blockly.JavaScript.ORDER_NONE) || '0';
const argument0 = JavaScript.valueToCode(block, 'X',
JavaScript.ORDER_NONE) || '0';
const argument1 = JavaScript.valueToCode(block, 'Y',
JavaScript.ORDER_NONE) || '0';
return ['Math.atan2(' + argument1 + ', ' + argument0 + ') / Math.PI * 180',
Blockly.JavaScript.ORDER_DIVISION];
JavaScript.ORDER_DIVISION];
};

10
tests/deps.js
View File

@@ -2,7 +2,7 @@ goog.addDependency('../../blocks/all.js', ['Blockly.blocks.all'], ['Blockly.bloc
goog.addDependency('../../blocks/colour.js', ['Blockly.blocks.colour'], ['Blockly.common'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('../../blocks/lists.js', ['Blockly.blocks.lists'], ['Blockly.ConnectionType', 'Blockly.FieldDropdown', 'Blockly.Input', 'Blockly.Msg', 'Blockly.Mutator', 'Blockly.blocks', 'Blockly.common', 'Blockly.utils.xml'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('../../blocks/logic.js', ['Blockly.blocks.logic'], ['Blockly.Events', 'Blockly.Extensions', 'Blockly.FieldDropdown', 'Blockly.FieldLabel', 'Blockly.Msg', 'Blockly.Mutator', 'Blockly.common', 'Blockly.utils.xml'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('../../blocks/loops.js', ['Blockly.blocks.loops'], ['Blockly.Block', 'Blockly.ContextMenu', 'Blockly.Events', 'Blockly.Events.Abstract', 'Blockly.Extensions', 'Blockly.FieldDropdown', 'Blockly.FieldLabel', 'Blockly.FieldNumber', 'Blockly.FieldVariable', 'Blockly.Msg', 'Blockly.Variables', 'Blockly.Warning', 'Blockly.common', 'Blockly.utils.xml'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('../../blocks/loops.js', ['Blockly.blocks.loops'], ['Blockly.ContextMenu', 'Blockly.Events', 'Blockly.Extensions', 'Blockly.FieldDropdown', 'Blockly.FieldLabel', 'Blockly.FieldNumber', 'Blockly.FieldVariable', 'Blockly.Msg', 'Blockly.Variables', 'Blockly.Warning', 'Blockly.common', 'Blockly.utils.xml'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('../../blocks/math.js', ['Blockly.Constants.Math', 'Blockly.blocks.math'], ['Blockly', 'Blockly.FieldDropdown', 'Blockly.FieldLabel', 'Blockly.FieldNumber', 'Blockly.FieldVariable'], {'lang': 'es6'});
goog.addDependency('../../blocks/procedures.js', ['Blockly.blocks.procedures'], ['Blockly.Comment', 'Blockly.ContextMenu', 'Blockly.Events', 'Blockly.FieldCheckbox', 'Blockly.FieldLabel', 'Blockly.FieldTextInput', 'Blockly.Input', 'Blockly.Msg', 'Blockly.Mutator', 'Blockly.Names', 'Blockly.Procedures', 'Blockly.Variables', 'Blockly.Warning', 'Blockly.Xml', 'Blockly.blocks', 'Blockly.internalConstants', 'Blockly.utils.xml'], {'lang': 'es9', 'module': 'goog'});
goog.addDependency('../../blocks/text.js', ['Blockly.Constants.Text', 'Blockly.blocks.texts'], ['Blockly', 'Blockly.FieldDropdown', 'Blockly.FieldImage', 'Blockly.FieldMultilineInput', 'Blockly.FieldTextInput', 'Blockly.FieldVariable', 'Blockly.Mutator'], {'lang': 'es6'});
@@ -278,11 +278,11 @@ goog.addDependency('../../generators/dart/variables.js', ['Blockly.Dart.variable
goog.addDependency('../../generators/dart/variables_dynamic.js', ['Blockly.Dart.variablesDynamic'], ['Blockly.Dart', 'Blockly.Dart.variables']);
goog.addDependency('../../generators/javascript.js', ['Blockly.JavaScript'], ['Blockly.Generator', 'Blockly.Names', 'Blockly.Variables', 'Blockly.inputTypes', 'Blockly.utils.global', 'Blockly.utils.object', 'Blockly.utils.string'], {'lang': 'es6'});
goog.addDependency('../../generators/javascript/all.js', ['Blockly.JavaScript.all'], ['Blockly.JavaScript.colour', 'Blockly.JavaScript.lists', 'Blockly.JavaScript.logic', 'Blockly.JavaScript.loops', 'Blockly.JavaScript.math', 'Blockly.JavaScript.procedures', 'Blockly.JavaScript.texts', 'Blockly.JavaScript.variables', 'Blockly.JavaScript.variablesDynamic'], {'module': 'goog'});
goog.addDependency('../../generators/javascript/colour.js', ['Blockly.JavaScript.colour'], ['Blockly.JavaScript'], {'lang': 'es6'});
goog.addDependency('../../generators/javascript/lists.js', ['Blockly.JavaScript.lists'], ['Blockly.JavaScript'], {'lang': 'es6'});
goog.addDependency('../../generators/javascript/logic.js', ['Blockly.JavaScript.logic'], ['Blockly.JavaScript'], {'lang': 'es6'});
goog.addDependency('../../generators/javascript/colour.js', ['Blockly.JavaScript.colour'], ['Blockly.JavaScript'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('../../generators/javascript/lists.js', ['Blockly.JavaScript.lists'], ['Blockly.JavaScript', 'Blockly.Names'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('../../generators/javascript/logic.js', ['Blockly.JavaScript.logic'], ['Blockly.JavaScript'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('../../generators/javascript/loops.js', ['Blockly.JavaScript.loops'], ['Blockly.JavaScript', 'Blockly.utils.string'], {'lang': 'es6'});
goog.addDependency('../../generators/javascript/math.js', ['Blockly.JavaScript.math'], ['Blockly.JavaScript'], {'lang': 'es6'});
goog.addDependency('../../generators/javascript/math.js', ['Blockly.JavaScript.math'], ['Blockly.JavaScript', 'Blockly.Names'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('../../generators/javascript/procedures.js', ['Blockly.JavaScript.procedures'], ['Blockly.JavaScript', 'Blockly.Names'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('../../generators/javascript/text.js', ['Blockly.JavaScript.texts'], ['Blockly.JavaScript', 'Blockly.Names'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('../../generators/javascript/variables.js', ['Blockly.JavaScript.variables'], ['Blockly.JavaScript', 'Blockly.Names'], {'lang': 'es6', 'module': 'goog'});