nodeskini 1.0.1 → 1.0.3

package/blocklySkini/blockly/generators/javascript/lists.js

@@ -0,0 +1,388 @@
+/**
+ * @license
+ * Copyright 2012 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Generating JavaScript for list blocks.
+ * @author fraser@google.com (Neil Fraser)
+ */
+'use strict';
+
+goog.provide('Blockly.JavaScript.lists');
+
+goog.require('Blockly.JavaScript');
+
+
+Blockly.JavaScript['lists_create_empty'] = function(block) {
+  // Create an empty list.
+  return ['[]', Blockly.JavaScript.ORDER_ATOMIC];
+};
+
+Blockly.JavaScript['lists_create_with'] = function(block) {
+  // Create a list with any number of elements of any type.
+  var elements = new Array(block.itemCount_);
+  for (var i = 0; i < block.itemCount_; i++) {
+    elements[i] = Blockly.JavaScript.valueToCode(block, 'ADD' + i,
+        Blockly.JavaScript.ORDER_COMMA) || 'null';
+  }
+  var code = '[' + elements.join(', ') + ']';
+  return [code, Blockly.JavaScript.ORDER_ATOMIC];
+};
+
+Blockly.JavaScript['lists_repeat'] = function(block) {
+  // Create a list with one element repeated.
+  var 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;',
+       '}']);
+  var element = Blockly.JavaScript.valueToCode(block, 'ITEM',
+      Blockly.JavaScript.ORDER_COMMA) || 'null';
+  var repeatCount = Blockly.JavaScript.valueToCode(block, 'NUM',
+      Blockly.JavaScript.ORDER_COMMA) || '0';
+  var code = functionName + '(' + element + ', ' + repeatCount + ')';
+  return [code, Blockly.JavaScript.ORDER_FUNCTION_CALL];
+};
+
+Blockly.JavaScript['lists_length'] = function(block) {
+  // String or array length.
+  var list = Blockly.JavaScript.valueToCode(block, 'VALUE',
+      Blockly.JavaScript.ORDER_MEMBER) || '[]';
+  return [list + '.length', Blockly.JavaScript.ORDER_MEMBER];
+};
+
+Blockly.JavaScript['lists_isEmpty'] = function(block) {
+  // Is the string null or array empty?
+  var list = Blockly.JavaScript.valueToCode(block, 'VALUE',
+      Blockly.JavaScript.ORDER_MEMBER) || '[]';
+  return ['!' + list + '.length', Blockly.JavaScript.ORDER_LOGICAL_NOT];
+};
+
+Blockly.JavaScript['lists_indexOf'] = function(block) {
+  // Find an item in the list.
+  var operator = block.getFieldValue('END') == 'FIRST' ?
+      'indexOf' : 'lastIndexOf';
+  var item = Blockly.JavaScript.valueToCode(block, 'FIND',
+      Blockly.JavaScript.ORDER_NONE) || '\'\'';
+  var list = Blockly.JavaScript.valueToCode(block, 'VALUE',
+      Blockly.JavaScript.ORDER_MEMBER) || '[]';
+  var code = list + '.' + operator + '(' + item + ')';
+  if (block.workspace.options.oneBasedIndex) {
+    return [code + ' + 1', Blockly.JavaScript.ORDER_ADDITION];
+  }
+  return [code, Blockly.JavaScript.ORDER_FUNCTION_CALL];
+};
+
+Blockly.JavaScript['lists_getIndex'] = function(block) {
+  // Get element at index.
+  // Note: Until January 2013 this block did not have MODE or WHERE inputs.
+  var mode = block.getFieldValue('MODE') || 'GET';
+  var where = block.getFieldValue('WHERE') || 'FROM_START';
+  var listOrder = (where == 'RANDOM') ? Blockly.JavaScript.ORDER_COMMA :
+      Blockly.JavaScript.ORDER_MEMBER;
+  var list = Blockly.JavaScript.valueToCode(block, 'VALUE', listOrder) || '[]';
+
+  switch (where) {
+    case ('FIRST'):
+      if (mode == 'GET') {
+        var code = list + '[0]';
+        return [code, Blockly.JavaScript.ORDER_MEMBER];
+      } else if (mode == 'GET_REMOVE') {
+        var code = list + '.shift()';
+        return [code, Blockly.JavaScript.ORDER_MEMBER];
+      } else if (mode == 'REMOVE') {
+        return list + '.shift();\n';
+      }
+      break;
+    case ('LAST'):
+      if (mode == 'GET') {
+        var code = list + '.slice(-1)[0]';
+        return [code, Blockly.JavaScript.ORDER_MEMBER];
+      } else if (mode == 'GET_REMOVE') {
+        var code = list + '.pop()';
+        return [code, Blockly.JavaScript.ORDER_MEMBER];
+      } else if (mode == 'REMOVE') {
+        return list + '.pop();\n';
+      }
+      break;
+    case ('FROM_START'):
+      var at = Blockly.JavaScript.getAdjusted(block, 'AT');
+      if (mode == 'GET') {
+        var code = list + '[' + at + ']';
+        return [code, Blockly.JavaScript.ORDER_MEMBER];
+      } else if (mode == 'GET_REMOVE') {
+        var code = list + '.splice(' + at + ', 1)[0]';
+        return [code, Blockly.JavaScript.ORDER_FUNCTION_CALL];
+      } else if (mode == 'REMOVE') {
+        return list + '.splice(' + at + ', 1);\n';
+      }
+      break;
+    case ('FROM_END'):
+      var at = Blockly.JavaScript.getAdjusted(block, 'AT', 1, true);
+      if (mode == 'GET') {
+        var code = list + '.slice(' + at + ')[0]';
+        return [code, Blockly.JavaScript.ORDER_FUNCTION_CALL];
+      } else if (mode == 'GET_REMOVE') {
+        var code = list + '.splice(' + at + ', 1)[0]';
+        return [code, Blockly.JavaScript.ORDER_FUNCTION_CALL];
+      } else if (mode == 'REMOVE') {
+        return list + '.splice(' + at + ', 1);';
+      }
+      break;
+    case ('RANDOM'):
+      var 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];',
+           '  }',
+           '}']);
+      code = functionName + '(' + list + ', ' + (mode != 'GET') + ')';
+      if (mode == 'GET' || mode == 'GET_REMOVE') {
+        return [code, Blockly.JavaScript.ORDER_FUNCTION_CALL];
+      } else if (mode == 'REMOVE') {
+        return code + ';\n';
+      }
+      break;
+  }
+  throw Error('Unhandled combination (lists_getIndex).');
+};
+
+Blockly.JavaScript['lists_setIndex'] = function(block) {
+  // Set element at index.
+  // Note: Until February 2013 this block did not have MODE or WHERE inputs.
+  var list = Blockly.JavaScript.valueToCode(block, 'LIST',
+      Blockly.JavaScript.ORDER_MEMBER) || '[]';
+  var mode = block.getFieldValue('MODE') || 'GET';
+  var where = block.getFieldValue('WHERE') || 'FROM_START';
+  var value = Blockly.JavaScript.valueToCode(block, 'TO',
+      Blockly.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 '';
+    }
+    var listVar = Blockly.JavaScript.variableDB_.getDistinctName(
+        'tmpList', Blockly.VARIABLE_CATEGORY_NAME);
+    var code = 'var ' + listVar + ' = ' + list + ';\n';
+    list = listVar;
+    return code;
+  }
+  switch (where) {
+    case ('FIRST'):
+      if (mode == 'SET') {
+        return list + '[0] = ' + value + ';\n';
+      } else if (mode == 'INSERT') {
+        return list + '.unshift(' + value + ');\n';
+      }
+      break;
+    case ('LAST'):
+      if (mode == 'SET') {
+        var code = cacheList();
+        code += list + '[' + list + '.length - 1] = ' + value + ';\n';
+        return code;
+      } else if (mode == 'INSERT') {
+        return list + '.push(' + value + ');\n';
+      }
+      break;
+    case ('FROM_START'):
+      var at = Blockly.JavaScript.getAdjusted(block, 'AT');
+      if (mode == 'SET') {
+        return list + '[' + at + '] = ' + value + ';\n';
+      } else if (mode == 'INSERT') {
+        return list + '.splice(' + at + ', 0, ' + value + ');\n';
+      }
+      break;
+    case ('FROM_END'):
+      var at = Blockly.JavaScript.getAdjusted(block, 'AT', 1, false,
+          Blockly.JavaScript.ORDER_SUBTRACTION);
+      var code = cacheList();
+      if (mode == 'SET') {
+        code += list + '[' + list + '.length - ' + at + '] = ' + value + ';\n';
+        return code;
+      } else if (mode == 'INSERT') {
+        code += list + '.splice(' + list + '.length - ' + at + ', 0, ' + value +
+            ');\n';
+        return code;
+      }
+      break;
+    case ('RANDOM'):
+      var code = cacheList();
+      var xVar = Blockly.JavaScript.variableDB_.getDistinctName(
+          'tmpX', Blockly.VARIABLE_CATEGORY_NAME);
+      code += 'var ' + xVar + ' = Math.floor(Math.random() * ' + list +
+          '.length);\n';
+      if (mode == 'SET') {
+        code += list + '[' + xVar + '] = ' + value + ';\n';
+        return code;
+      } else if (mode == 'INSERT') {
+        code += list + '.splice(' + xVar + ', 0, ' + value + ');\n';
+        return code;
+      }
+      break;
+  }
+  throw Error('Unhandled combination (lists_setIndex).');
+};
+
+/**
+ * Returns an expression calculating the index into a list.
+ * @param {string} listName Name of the list, used to calculate length.
+ * @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) {
+  if (where == 'FIRST') {
+    return '0';
+  } else if (where == 'FROM_END') {
+    return listName + '.length - 1 - ' + opt_at;
+  } else if (where == 'LAST') {
+    return listName + '.length - 1';
+  } else {
+    return opt_at;
+  }
+};
+
+Blockly.JavaScript['lists_getSublist'] = function(block) {
+  // Get sublist.
+  var list = Blockly.JavaScript.valueToCode(block, 'LIST',
+      Blockly.JavaScript.ORDER_MEMBER) || '[]';
+  var where1 = block.getFieldValue('WHERE1');
+  var where2 = block.getFieldValue('WHERE2');
+  if (where1 == 'FIRST' && where2 == 'LAST') {
+    var code = list + '.slice(0)';
+  } 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.
+    switch (where1) {
+      case 'FROM_START':
+        var at1 = Blockly.JavaScript.getAdjusted(block, 'AT1');
+        break;
+      case 'FROM_END':
+        var at1 = Blockly.JavaScript.getAdjusted(block, 'AT1', 1, false,
+            Blockly.JavaScript.ORDER_SUBTRACTION);
+        at1 = list + '.length - ' + at1;
+        break;
+      case 'FIRST':
+        var at1 = '0';
+        break;
+      default:
+        throw Error('Unhandled option (lists_getSublist).');
+    }
+    switch (where2) {
+      case 'FROM_START':
+        var at2 = Blockly.JavaScript.getAdjusted(block, 'AT2', 1);
+        break;
+      case 'FROM_END':
+        var at2 = Blockly.JavaScript.getAdjusted(block, 'AT2', 0, false,
+            Blockly.JavaScript.ORDER_SUBTRACTION);
+        at2 = list + '.length - ' + at2;
+        break;
+      case 'LAST':
+        var at2 = list + '.length';
+        break;
+      default:
+        throw Error('Unhandled option (lists_getSublist).');
+    }
+    code = list + '.slice(' + at1 + ', ' + at2 + ')';
+  } else {
+    var at1 = Blockly.JavaScript.getAdjusted(block, 'AT1');
+    var at2 = Blockly.JavaScript.getAdjusted(block, 'AT2');
+    var getIndex_ = Blockly.JavaScript.lists.getIndex_;
+    var wherePascalCase = {'FIRST': 'First', 'LAST': 'Last',
+        'FROM_START': 'FromStart', 'FROM_END': 'FromEnd'};
+    var 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);',
+          '}']);
+    var code = functionName + '(' + list +
+        // The value for 'FROM_END' and 'FROM_START' depends on `at` so we
+        // pass it.
+        ((where1 == 'FROM_END' || where1 == 'FROM_START') ? ', ' + at1 : '') +
+        ((where2 == 'FROM_END' || where2 == 'FROM_START') ? ', ' + at2 : '') +
+        ')';
+  }
+  return [code, Blockly.JavaScript.ORDER_FUNCTION_CALL];
+};
+
+Blockly.JavaScript['lists_sort'] = function(block) {
+  // Block for sorting a list.
+  var list = Blockly.JavaScript.valueToCode(block, 'LIST',
+      Blockly.JavaScript.ORDER_FUNCTION_CALL) || '[]';
+  var direction = block.getFieldValue('DIRECTION') === '1' ? 1 : -1;
+  var type = block.getFieldValue('TYPE');
+  var 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];
+};
+
+Blockly.JavaScript['lists_split'] = function(block) {
+  // Block for splitting text into a list, or joining a list into text.
+  var input = Blockly.JavaScript.valueToCode(block, 'INPUT',
+      Blockly.JavaScript.ORDER_MEMBER);
+  var delimiter = Blockly.JavaScript.valueToCode(block, 'DELIM',
+      Blockly.JavaScript.ORDER_NONE) || '\'\'';
+  var mode = block.getFieldValue('MODE');
+  if (mode == 'SPLIT') {
+    if (!input) {
+      input = '\'\'';
+    }
+    var functionName = 'split';
+  } else if (mode == 'JOIN') {
+    if (!input) {
+      input = '[]';
+    }
+    var functionName = 'join';
+  } else {
+    throw Error('Unknown mode: ' + mode);
+  }
+  var code = input + '.' + functionName + '(' + delimiter + ')';
+  return [code, Blockly.JavaScript.ORDER_FUNCTION_CALL];
+};
+
+Blockly.JavaScript['lists_reverse'] = function(block) {
+  // Block for reversing a list.
+  var list = Blockly.JavaScript.valueToCode(block, 'LIST',
+      Blockly.JavaScript.ORDER_FUNCTION_CALL) || '[]';
+  var code = list + '.slice().reverse()';
+  return [code, Blockly.JavaScript.ORDER_FUNCTION_CALL];
+};

package/blocklySkini/blockly/generators/javascript/logic.js

@@ -0,0 +1,129 @@
+/**
+ * @license
+ * Copyright 2012 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Generating JavaScript for logic blocks.
+ * @author q.neutron@gmail.com (Quynh Neutron)
+ */
+'use strict';
+
+goog.provide('Blockly.JavaScript.logic');
+
+goog.require('Blockly.JavaScript');
+
+
+Blockly.JavaScript['controls_if'] = function(block) {
+  // If/elseif/else condition.
+  var n = 0;
+  var code = '', branchCode, conditionCode;
+  if (Blockly.JavaScript.STATEMENT_PREFIX) {
+    // Automatic prefix insertion is switched off for this block.  Add manually.
+    code += Blockly.JavaScript.injectId(Blockly.JavaScript.STATEMENT_PREFIX,
+        block);
+  }
+  do {
+    conditionCode = Blockly.JavaScript.valueToCode(block, 'IF' + n,
+        Blockly.JavaScript.ORDER_NONE) || 'false';
+    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;
+    }
+    code += (n > 0 ? ' else ' : '') +
+        'if (' + conditionCode + ') {\n' + branchCode + '}';
+    ++n;
+  } while (block.getInput('IF' + n));
+
+  if (block.getInput('ELSE') || Blockly.JavaScript.STATEMENT_SUFFIX) {
+    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;
+    }
+    code += ' else {\n' + branchCode + '}';
+  }
+  return code + '\n';
+};
+
+Blockly.JavaScript['controls_ifelse'] = Blockly.JavaScript['controls_if'];
+
+Blockly.JavaScript['logic_compare'] = function(block) {
+  // Comparison operator.
+  var OPERATORS = {
+    'EQ': '==',
+    'NEQ': '!=',
+    'LT': '<',
+    'LTE': '<=',
+    'GT': '>',
+    'GTE': '>='
+  };
+  var operator = OPERATORS[block.getFieldValue('OP')];
+  var order = (operator == '==' || operator == '!=') ?
+      Blockly.JavaScript.ORDER_EQUALITY : Blockly.JavaScript.ORDER_RELATIONAL;
+  var argument0 = Blockly.JavaScript.valueToCode(block, 'A', order) || '0';
+  var argument1 = Blockly.JavaScript.valueToCode(block, 'B', order) || '0';
+  var code = argument0 + ' ' + operator + ' ' + argument1;
+  return [code, order];
+};
+
+Blockly.JavaScript['logic_operation'] = function(block) {
+  // Operations 'and', 'or'.
+  var operator = (block.getFieldValue('OP') == 'AND') ? '&&' : '||';
+  var order = (operator == '&&') ? Blockly.JavaScript.ORDER_LOGICAL_AND :
+      Blockly.JavaScript.ORDER_LOGICAL_OR;
+  var argument0 = Blockly.JavaScript.valueToCode(block, 'A', order);
+  var argument1 = Blockly.JavaScript.valueToCode(block, 'B', order);
+  if (!argument0 && !argument1) {
+    // If there are no arguments, then the return value is false.
+    argument0 = 'false';
+    argument1 = 'false';
+  } else {
+    // Single missing arguments have no effect on the return value.
+    var defaultArgument = (operator == '&&') ? 'true' : 'false';
+    if (!argument0) {
+      argument0 = defaultArgument;
+    }
+    if (!argument1) {
+      argument1 = defaultArgument;
+    }
+  }
+  var code = argument0 + ' ' + operator + ' ' + argument1;
+  return [code, order];
+};
+
+Blockly.JavaScript['logic_negate'] = function(block) {
+  // Negation.
+  var order = Blockly.JavaScript.ORDER_LOGICAL_NOT;
+  var argument0 = Blockly.JavaScript.valueToCode(block, 'BOOL', order) ||
+      'true';
+  var code = '!' + argument0;
+  return [code, order];
+};
+
+Blockly.JavaScript['logic_boolean'] = function(block) {
+  // Boolean values true and false.
+  var code = (block.getFieldValue('BOOL') == 'TRUE') ? 'true' : 'false';
+  return [code, Blockly.JavaScript.ORDER_ATOMIC];
+};
+
+Blockly.JavaScript['logic_null'] = function(block) {
+  // Null data type.
+  return ['null', Blockly.JavaScript.ORDER_ATOMIC];
+};
+
+Blockly.JavaScript['logic_ternary'] = function(block) {
+  // Ternary operator.
+  var value_if = Blockly.JavaScript.valueToCode(block, 'IF',
+      Blockly.JavaScript.ORDER_CONDITIONAL) || 'false';
+  var value_then = Blockly.JavaScript.valueToCode(block, 'THEN',
+      Blockly.JavaScript.ORDER_CONDITIONAL) || 'null';
+  var value_else = Blockly.JavaScript.valueToCode(block, 'ELSE',
+      Blockly.JavaScript.ORDER_CONDITIONAL) || 'null';
+  var code = value_if + ' ? ' + value_then + ' : ' + value_else;
+  return [code, Blockly.JavaScript.ORDER_CONDITIONAL];
+};