scratch-blocks 1.1.206 → 2.0.0-beta.1

package/blockly-rc/generators/javascript/lists.ts

@@ -0,0 +1,465 @@
+/**
+ * @license
+ * Copyright 2012 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @file Generating JavaScript for list blocks.
+ */
+
+// Former goog.module ID: Blockly.JavaScript.lists
+
+import type {Block} from '../../core/block.js';
+import type {CreateWithBlock} from '../../blocks/lists.js';
+import type {JavascriptGenerator} from './javascript_generator.js';
+import {NameType} from '../../core/names.js';
+import {Order} from './javascript_generator.js';
+
+export function lists_create_empty(
+  block: Block,
+  generator: JavascriptGenerator,
+): [string, Order] {
+  // Create an empty list.
+  return ['[]', Order.ATOMIC];
+}
+
+export function lists_create_with(
+  block: Block,
+  generator: JavascriptGenerator,
+): [string, Order] {
+  // Create a list with any number of elements of any type.
+  const createWithBlock = block as CreateWithBlock;
+  const elements = new Array(createWithBlock.itemCount_);
+  for (let i = 0; i < createWithBlock.itemCount_; i++) {
+    elements[i] = generator.valueToCode(block, 'ADD' + i, Order.NONE) || 'null';
+  }
+  const code = '[' + elements.join(', ') + ']';
+  return [code, Order.ATOMIC];
+}
+
+export function lists_repeat(
+  block: Block,
+  generator: JavascriptGenerator,
+): [string, Order] {
+  // Create a list with one element repeated.
+  const functionName = generator.provideFunction_(
+    'listsRepeat',
+    `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(value, n) {
+  var array = [];
+  for (var i = 0; i < n; i++) {
+    array[i] = value;
+  }
+  return array;
+}
+`,
+  );
+  const element = generator.valueToCode(block, 'ITEM', Order.NONE) || 'null';
+  const repeatCount = generator.valueToCode(block, 'NUM', Order.NONE) || '0';
+  const code = functionName + '(' + element + ', ' + repeatCount + ')';
+  return [code, Order.FUNCTION_CALL];
+}
+
+export function lists_length(
+  block: Block,
+  generator: JavascriptGenerator,
+): [string, Order] {
+  // String or array length.
+  const list = generator.valueToCode(block, 'VALUE', Order.MEMBER) || '[]';
+  return [list + '.length', Order.MEMBER];
+}
+
+export function lists_isEmpty(
+  block: Block,
+  generator: JavascriptGenerator,
+): [string, Order] {
+  // Is the string null or array empty?
+  const list = generator.valueToCode(block, 'VALUE', Order.MEMBER) || '[]';
+  return ['!' + list + '.length', Order.LOGICAL_NOT];
+}
+
+export function lists_indexOf(
+  block: Block,
+  generator: JavascriptGenerator,
+): [string, Order] {
+  // Find an item in the list.
+  const operator =
+    block.getFieldValue('END') === 'FIRST' ? 'indexOf' : 'lastIndexOf';
+  const item = generator.valueToCode(block, 'FIND', Order.NONE) || "''";
+  const list = generator.valueToCode(block, 'VALUE', Order.MEMBER) || '[]';
+  const code = list + '.' + operator + '(' + item + ')';
+  if (block.workspace.options.oneBasedIndex) {
+    return [code + ' + 1', Order.ADDITION];
+  }
+  return [code, Order.FUNCTION_CALL];
+}
+
+export function lists_getIndex(
+  block: Block,
+  generator: JavascriptGenerator,
+): [string, Order] | string {
+  // 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' ? Order.NONE : Order.MEMBER;
+  const list = generator.valueToCode(block, 'VALUE', listOrder) || '[]';
+
+  switch (where) {
+    case 'FIRST':
+      if (mode === 'GET') {
+        const code = list + '[0]';
+        return [code, Order.MEMBER];
+      } else if (mode === 'GET_REMOVE') {
+        const code = list + '.shift()';
+        return [code, Order.MEMBER];
+      } else if (mode === 'REMOVE') {
+        return list + '.shift();\n';
+      }
+      break;
+    case 'LAST':
+      if (mode === 'GET') {
+        const code = list + '.slice(-1)[0]';
+        return [code, Order.MEMBER];
+      } else if (mode === 'GET_REMOVE') {
+        const code = list + '.pop()';
+        return [code, Order.MEMBER];
+      } else if (mode === 'REMOVE') {
+        return list + '.pop();\n';
+      }
+      break;
+    case 'FROM_START': {
+      const at = generator.getAdjusted(block, 'AT');
+      if (mode === 'GET') {
+        const code = list + '[' + at + ']';
+        return [code, Order.MEMBER];
+      } else if (mode === 'GET_REMOVE') {
+        const code = list + '.splice(' + at + ', 1)[0]';
+        return [code, Order.FUNCTION_CALL];
+      } else if (mode === 'REMOVE') {
+        return list + '.splice(' + at + ', 1);\n';
+      }
+      break;
+    }
+    case 'FROM_END': {
+      const at = generator.getAdjusted(block, 'AT', 1, true);
+      if (mode === 'GET') {
+        const code = list + '.slice(' + at + ')[0]';
+        return [code, Order.FUNCTION_CALL];
+      } else if (mode === 'GET_REMOVE') {
+        const code = list + '.splice(' + at + ', 1)[0]';
+        return [code, Order.FUNCTION_CALL];
+      } else if (mode === 'REMOVE') {
+        return list + '.splice(' + at + ', 1);';
+      }
+      break;
+    }
+    case 'RANDOM': {
+      const functionName = generator.provideFunction_(
+        'listsGetRandomItem',
+        `
+function ${generator.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, Order.FUNCTION_CALL];
+      } else if (mode === 'REMOVE') {
+        return code + ';\n';
+      }
+      break;
+    }
+  }
+  throw Error('Unhandled combination (lists_getIndex).');
+}
+
+export function lists_setIndex(block: Block, generator: JavascriptGenerator) {
+  // Set element at index.
+  // Note: Until February 2013 this block did not have MODE or WHERE inputs.
+  let list = generator.valueToCode(block, 'LIST', Order.MEMBER) || '[]';
+  const mode = block.getFieldValue('MODE') || 'GET';
+  const where = block.getFieldValue('WHERE') || 'FROM_START';
+  const value = generator.valueToCode(block, 'TO', 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 = generator.nameDB_!.getDistinctName(
+      'tmpList',
+      NameType.VARIABLE,
+    )!;
+    const 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') {
+        let code = cacheList();
+        code += list + '[' + list + '.length - 1] = ' + value + ';\n';
+        return code;
+      } else if (mode === 'INSERT') {
+        return list + '.push(' + value + ');\n';
+      }
+      break;
+    case 'FROM_START': {
+      const at = generator.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': {
+      const at = generator.getAdjusted(
+        block,
+        'AT',
+        1,
+        false,
+        Order.SUBTRACTION,
+      );
+      let 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': {
+      let code = cacheList();
+      const xVar = generator.nameDB_!.getDistinctName(
+        'tmpX',
+        NameType.VARIABLE,
+      );
+      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 listName Name of the list, used to calculate length.
+ * @param where The method of indexing, selected by dropdown in Blockly
+ * @param opt_at The optional offset when indexing from start/end.
+ * @returns Index expression.
+ */
+const getSubstringIndex = function (
+  listName: string,
+  where: string,
+  opt_at?: string,
+): string | undefined {
+  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;
+  }
+};
+
+export function lists_getSublist(
+  block: Block,
+  generator: JavascriptGenerator,
+): [string, Order] {
+  // Get sublist.
+  // Dictionary of WHEREn field choices and their CamelCase equivalents.
+  const wherePascalCase = {
+    'FIRST': 'First',
+    'LAST': 'Last',
+    'FROM_START': 'FromStart',
+    'FROM_END': 'FromEnd',
+  };
+  type WhereOption = keyof typeof wherePascalCase;
+  const list = generator.valueToCode(block, 'LIST', Order.MEMBER) || '[]';
+  const where1 = block.getFieldValue('WHERE1') as WhereOption;
+  const where2 = block.getFieldValue('WHERE2') as WhereOption;
+  let code;
+  if (where1 === 'FIRST' && where2 === 'LAST') {
+    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.
+    let at1;
+    switch (where1) {
+      case 'FROM_START':
+        at1 = generator.getAdjusted(block, 'AT1');
+        break;
+      case 'FROM_END':
+        at1 = generator.getAdjusted(block, 'AT1', 1, false, Order.SUBTRACTION);
+        at1 = list + '.length - ' + at1;
+        break;
+      case 'FIRST':
+        at1 = '0';
+        break;
+      default:
+        throw Error('Unhandled option (lists_getSublist).');
+    }
+    let at2;
+    switch (where2) {
+      case 'FROM_START':
+        at2 = generator.getAdjusted(block, 'AT2', 1);
+        break;
+      case 'FROM_END':
+        at2 = generator.getAdjusted(block, 'AT2', 0, false, Order.SUBTRACTION);
+        at2 = list + '.length - ' + at2;
+        break;
+      case 'LAST':
+        at2 = list + '.length';
+        break;
+      default:
+        throw Error('Unhandled option (lists_getSublist).');
+    }
+    code = list + '.slice(' + at1 + ', ' + at2 + ')';
+  } else {
+    const at1 = generator.getAdjusted(block, 'AT1');
+    const at2 = generator.getAdjusted(block, 'AT2');
+    // The value for 'FROM_END' and'FROM_START' depends on `at` so
+    // we add it as a parameter.
+    const at1Param =
+      where1 === 'FROM_END' || where1 === 'FROM_START' ? ', at1' : '';
+    const at2Param =
+      where2 === 'FROM_END' || where2 === 'FROM_START' ? ', at2' : '';
+    const functionName = generator.provideFunction_(
+      'subsequence' + wherePascalCase[where1] + wherePascalCase[where2],
+      `
+function ${
+        generator.FUNCTION_NAME_PLACEHOLDER_
+      }(sequence${at1Param}${at2Param}) {
+  var start = ${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.
+      (where1 === 'FROM_END' || where1 === 'FROM_START' ? ', ' + at1 : '') +
+      (where2 === 'FROM_END' || where2 === 'FROM_START' ? ', ' + at2 : '') +
+      ')';
+  }
+  return [code, Order.FUNCTION_CALL];
+}
+
+export function lists_sort(
+  block: Block,
+  generator: JavascriptGenerator,
+): [string, Order] {
+  // Block for sorting a list.
+  const list =
+    generator.valueToCode(block, 'LIST', Order.FUNCTION_CALL) || '[]';
+  const direction = block.getFieldValue('DIRECTION') === '1' ? 1 : -1;
+  const type = block.getFieldValue('TYPE');
+  const getCompareFunctionName = generator.provideFunction_(
+    'listsGetSortCompare',
+    `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(type, direction) {
+  var compareFuncs = {
+    'NUMERIC': function(a, b) {
+        return Number(a) - Number(b); },
+    'TEXT': function(a, b) {
+        return String(a) > String(b) ? 1 : -1; },
+    'IGNORE_CASE': function(a, b) {
+        return String(a).toLowerCase() > String(b).toLowerCase() ? 1 : -1; },
+  };
+  var compare = compareFuncs[type];
+  return function(a, b) { return compare(a, b) * direction; };
+}
+      `,
+  );
+  return [
+    list +
+      '.slice().sort(' +
+      getCompareFunctionName +
+      '("' +
+      type +
+      '", ' +
+      direction +
+      '))',
+    Order.FUNCTION_CALL,
+  ];
+}
+
+export function lists_split(
+  block: Block,
+  generator: JavascriptGenerator,
+): [string, Order] {
+  // Block for splitting text into a list, or joining a list into text.
+  let input = generator.valueToCode(block, 'INPUT', Order.MEMBER);
+  const delimiter = generator.valueToCode(block, 'DELIM', Order.NONE) || "''";
+  const mode = block.getFieldValue('MODE');
+  let functionName;
+  if (mode === 'SPLIT') {
+    if (!input) {
+      input = "''";
+    }
+    functionName = 'split';
+  } else if (mode === 'JOIN') {
+    if (!input) {
+      input = '[]';
+    }
+    functionName = 'join';
+  } else {
+    throw Error('Unknown mode: ' + mode);
+  }
+  const code = input + '.' + functionName + '(' + delimiter + ')';
+  return [code, Order.FUNCTION_CALL];
+}
+
+export function lists_reverse(
+  block: Block,
+  generator: JavascriptGenerator,
+): [string, Order] {
+  // Block for reversing a list.
+  const list =
+    generator.valueToCode(block, 'LIST', Order.FUNCTION_CALL) || '[]';
+  const code = list + '.slice().reverse()';
+  return [code, Order.FUNCTION_CALL];
+}

package/blockly-rc/generators/javascript/logic.ts

@@ -0,0 +1,153 @@
+/**
+ * @license
+ * Copyright 2012 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @file Generating JavaScript for logic blocks.
+ */
+
+// Former goog.module ID: Blockly.JavaScript.logic
+
+import type {Block} from '../../core/block.js';
+import type {JavascriptGenerator} from './javascript_generator.js';
+import {Order} from './javascript_generator.js';
+
+export function controls_if(block: Block, generator: JavascriptGenerator) {
+  // If/elseif/else condition.
+  let n = 0;
+  let code = '';
+  if (generator.STATEMENT_PREFIX) {
+    // Automatic prefix insertion is switched off for this block.  Add manually.
+    code += generator.injectId(generator.STATEMENT_PREFIX, block);
+  }
+  do {
+    const conditionCode =
+      generator.valueToCode(block, 'IF' + n, Order.NONE) || 'false';
+    let branchCode = generator.statementToCode(block, 'DO' + n);
+    if (generator.STATEMENT_SUFFIX) {
+      branchCode =
+        generator.prefixLines(
+          generator.injectId(generator.STATEMENT_SUFFIX, block),
+          generator.INDENT,
+        ) + branchCode;
+    }
+    code +=
+      (n > 0 ? ' else ' : '') +
+      'if (' +
+      conditionCode +
+      ') {\n' +
+      branchCode +
+      '}';
+    n++;
+  } while (block.getInput('IF' + n));
+
+  if (block.getInput('ELSE') || generator.STATEMENT_SUFFIX) {
+    let branchCode = generator.statementToCode(block, 'ELSE');
+    if (generator.STATEMENT_SUFFIX) {
+      branchCode =
+        generator.prefixLines(
+          generator.injectId(generator.STATEMENT_SUFFIX, block),
+          generator.INDENT,
+        ) + branchCode;
+    }
+    code += ' else {\n' + branchCode + '}';
+  }
+  return code + '\n';
+}
+
+export const controls_ifelse = controls_if;
+
+export function logic_compare(
+  block: Block,
+  generator: JavascriptGenerator,
+): [string, Order] {
+  // Comparison operator.
+  const OPERATORS = {
+    'EQ': '==',
+    'NEQ': '!=',
+    'LT': '<',
+    'LTE': '<=',
+    'GT': '>',
+    'GTE': '>=',
+  };
+  type OperatorOption = keyof typeof OPERATORS;
+  const operator = OPERATORS[block.getFieldValue('OP') as OperatorOption];
+  const order =
+    operator === '==' || operator === '!=' ? Order.EQUALITY : Order.RELATIONAL;
+  const argument0 = generator.valueToCode(block, 'A', order) || '0';
+  const argument1 = generator.valueToCode(block, 'B', order) || '0';
+  const code = argument0 + ' ' + operator + ' ' + argument1;
+  return [code, order];
+}
+
+export function logic_operation(
+  block: Block,
+  generator: JavascriptGenerator,
+): [string, Order] {
+  // Operations 'and', 'or'.
+  const operator = block.getFieldValue('OP') === 'AND' ? '&&' : '||';
+  const order = operator === '&&' ? Order.LOGICAL_AND : Order.LOGICAL_OR;
+  let argument0 = generator.valueToCode(block, 'A', order);
+  let argument1 = generator.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.
+    const defaultArgument = operator === '&&' ? 'true' : 'false';
+    if (!argument0) {
+      argument0 = defaultArgument;
+    }
+    if (!argument1) {
+      argument1 = defaultArgument;
+    }
+  }
+  const code = argument0 + ' ' + operator + ' ' + argument1;
+  return [code, order];
+}
+
+export function logic_negate(
+  block: Block,
+  generator: JavascriptGenerator,
+): [string, Order] {
+  // Negation.
+  const order = Order.LOGICAL_NOT;
+  const argument0 = generator.valueToCode(block, 'BOOL', order) || 'true';
+  const code = '!' + argument0;
+  return [code, order];
+}
+
+export function logic_boolean(
+  block: Block,
+  generator: JavascriptGenerator,
+): [string, Order] {
+  // Boolean values true and false.
+  const code = block.getFieldValue('BOOL') === 'TRUE' ? 'true' : 'false';
+  return [code, Order.ATOMIC];
+}
+
+export function logic_null(
+  block: Block,
+  generator: JavascriptGenerator,
+): [string, Order] {
+  // Null data type.
+  return ['null', Order.ATOMIC];
+}
+
+export function logic_ternary(
+  block: Block,
+  generator: JavascriptGenerator,
+): [string, Order] {
+  // Ternary operator.
+  const value_if =
+    generator.valueToCode(block, 'IF', Order.CONDITIONAL) || 'false';
+  const value_then =
+    generator.valueToCode(block, 'THEN', Order.CONDITIONAL) || 'null';
+  const value_else =
+    generator.valueToCode(block, 'ELSE', Order.CONDITIONAL) || 'null';
+  const code = value_if + ' ? ' + value_then + ' : ' + value_else;
+  return [code, Order.CONDITIONAL];
+}