blockly 8.0.4 → 8.0.5-beta.0

package/core/{variable_map.js → variable_map.ts}

@@ -7,30 +7,28 @@
 /**
  * @fileoverview Object representing a map of variables and their types.
  */
-'use strict';
 
 /**
  * Object representing a map of variables and their types.
  * @class
  */
-goog.module('Blockly.VariableMap');
+import * as goog from '../closure/goog/goog.js';
+goog.declareModuleId('Blockly.VariableMap');
 
-const arrayUtils = goog.require('Blockly.utils.array');
-const dialog = goog.require('Blockly.dialog');
-const eventUtils = goog.require('Blockly.Events.utils');
-const idGenerator = goog.require('Blockly.utils.idGenerator');
-const object = goog.require('Blockly.utils.object');
-/* eslint-disable-next-line no-unused-vars */
-const {Block} = goog.requireType('Blockly.Block');
-const {Msg} = goog.require('Blockly.Msg');
-const {Names} = goog.require('Blockly.Names');
-const {VariableModel} = goog.require('Blockly.VariableModel');
-/* eslint-disable-next-line no-unused-vars */
-const {Workspace} = goog.requireType('Blockly.Workspace');
-/** @suppress {extraRequire} */
-goog.require('Blockly.Events.VarDelete');
-/** @suppress {extraRequire} */
-goog.require('Blockly.Events.VarRename');
+// Unused import preserved for side-effects. Remove if unneeded.
+import './events/events_var_delete.js';
+// Unused import preserved for side-effects. Remove if unneeded.
+import './events/events_var_rename.js';
+
+import type {Block} from './block.js';
+import * as dialog from './dialog.js';
+import * as eventUtils from './events/utils.js';
+import {Msg} from './msg.js';
+import {Names} from './names.js';
+import * as arrayUtils from './utils/array.js';
+import * as idGenerator from './utils/idgenerator.js';
+import {VariableModel} from './variable_model.js';
+import type {Workspace} from './workspace.js';
 
 
 /**
@@ -39,40 +37,29 @@ goog.require('Blockly.Events.VarRename');
  * variables are the type indicated by the key.
  * @alias Blockly.VariableMap
  */
-class VariableMap {
+export class VariableMap {
   /**
-   * @param {!Workspace} workspace The workspace this map belongs to.
+   * A map from variable type to list of variable names.  The lists contain
+   * all of the named variables in the workspace, including variables that are
+   * not currently in use.
    */
-  constructor(workspace) {
-    /**
-     * A map from variable type to list of variable names.  The lists contain
-     * all of the named variables in the workspace, including variables that are
-     * not currently in use.
-     * @type {!Object<string, !Array<VariableModel>>}
-     * @private
-     */
-    this.variableMap_ = Object.create(null);
+  private variableMap = new Map<string, VariableModel[]>();
 
-    /**
-     * The workspace this map belongs to.
-     * @type {!Workspace}
-     */
-    this.workspace = workspace;
-  }
-  /**
-   * Clear the variable map.
-   */
+  /** @param workspace The workspace this map belongs to. */
+  constructor(public workspace: Workspace) {}
+
+  /** Clear the variable map. */
   clear() {
-    this.variableMap_ = Object.create(null);
+    this.variableMap.clear();
   }
   /* Begin functions for renaming variables. */
   /**
    * Rename the given variable by updating its name in the variable map.
-   * @param {!VariableModel} variable Variable to rename.
-   * @param {string} newName New variable name.
-   * @package
+   * @param variable Variable to rename.
+   * @param newName New variable name.
+   * @internal
    */
-  renameVariable(variable, newName) {
+  renameVariable(variable: VariableModel, newName: string) {
     const type = variable.type;
     const conflictVar = this.getVariable(newName, type);
     const blocks = this.workspace.getAllBlocks(false);
@@ -90,13 +77,14 @@ class VariableMap {
       eventUtils.setGroup(false);
     }
   }
+
   /**
    * Rename a variable by updating its name in the variable map. Identify the
    * variable to rename with the given ID.
-   * @param {string} id ID of the variable to rename.
-   * @param {string} newName New variable name.
+   * @param id ID of the variable to rename.
+   * @param newName New variable name.
    */
-  renameVariableById(id, newName) {
+  renameVariableById(id: string, newName: string) {
     const variable = this.getVariableById(id);
     if (!variable) {
       throw Error('Tried to rename a variable that didn\'t exist. ID: ' + id);
@@ -104,37 +92,37 @@ class VariableMap {
 
     this.renameVariable(variable, newName);
   }
+
   /**
    * Update the name of the given variable and refresh all references to it.
    * The new name must not conflict with any existing variable names.
-   * @param {!VariableModel} variable Variable to rename.
-   * @param {string} newName New variable name.
-   * @param {!Array<!Block>} blocks The list of all blocks in the
-   *     workspace.
-   * @private
+   * @param variable Variable to rename.
+   * @param newName New variable name.
+   * @param blocks The list of all blocks in the workspace.
    */
-  renameVariableAndUses_(variable, newName, blocks) {
-    eventUtils.fire(
-        new (eventUtils.get(eventUtils.VAR_RENAME))(variable, newName));
+  private renameVariableAndUses_(
+      variable: VariableModel, newName: string, blocks: Block[]) {
+    eventUtils.fire(new (eventUtils.get(eventUtils.VAR_RENAME))!
+                    (variable, newName));
     variable.name = newName;
     for (let i = 0; i < blocks.length; i++) {
       blocks[i].updateVarName(variable);
     }
   }
+
   /**
    * Update the name of the given variable to the same name as an existing
    * variable.  The two variables are coalesced into a single variable with the
    * ID of the existing variable that was already using newName. Refresh all
    * references to the variable.
-   * @param {!VariableModel} variable Variable to rename.
-   * @param {string} newName New variable name.
-   * @param {!VariableModel} conflictVar The variable that was already
-   *     using newName.
-   * @param {!Array<!Block>} blocks The list of all blocks in the
-   *     workspace.
-   * @private
+   * @param variable Variable to rename.
+   * @param newName New variable name.
+   * @param conflictVar The variable that was already using newName.
+   * @param blocks The list of all blocks in the workspace.
    */
-  renameVariableWithConflict_(variable, newName, conflictVar, blocks) {
+  private renameVariableWithConflict_(
+      variable: VariableModel, newName: string, conflictVar: VariableModel,
+      blocks: Block[]) {
     const type = variable.type;
     const oldCase = conflictVar.name;
 
@@ -148,25 +136,24 @@ class VariableMap {
     for (let i = 0; i < blocks.length; i++) {
       blocks[i].renameVarById(variable.getId(), conflictVar.getId());
     }
-
     // Finally delete the original variable, which is now unreferenced.
-    eventUtils.fire(new (eventUtils.get(eventUtils.VAR_DELETE))(variable));
+    eventUtils.fire(new (eventUtils.get(eventUtils.VAR_DELETE))!(variable));
     // And remove it from the list.
-    arrayUtils.removeElem(this.variableMap_[type], variable);
+    arrayUtils.removeElem(this.variableMap.get(type)!, variable);
   }
   /* End functions for renaming variables. */
   /**
    * Create a variable with a given name, optional type, and optional ID.
-   * @param {string} name The name of the variable. This must be unique across
-   *     variables and procedures.
-   * @param {?string=} opt_type The type of the variable like 'int' or 'string'.
+   * @param name The name of the variable. This must be unique across variables
+   *     and procedures.
+   * @param opt_type The type of the variable like 'int' or 'string'.
    *     Does not need to be unique. Field_variable can filter variables based
    * on their type. This will default to '' which is a specific type.
-   * @param {?string=} opt_id The unique ID of the variable. This will default
-   *     to a UUID.
-   * @return {!VariableModel} The newly created variable.
+   * @param opt_id The unique ID of the variable. This will default to a UUID.
+   * @return The newly created variable.
    */
-  createVariable(name, opt_type, opt_id) {
+  createVariable(name: string, opt_type?: string|null, opt_id?: string|null):
+      VariableModel {
     let variable = this.getVariable(name, opt_type);
     if (variable) {
       if (opt_id && variable.getId() !== opt_id) {
@@ -185,46 +172,50 @@ class VariableMap {
     const type = opt_type || '';
     variable = new VariableModel(this.workspace, name, type, id);
 
-    const variables = this.variableMap_[type] || [];
+    const variables = this.variableMap.get(type) || [];
     variables.push(variable);
     // Delete the list of variables of this type, and re-add it so that
     // the most recent addition is at the end.
     // This is used so the toolbox's set block is set to the most recent
     // variable.
-    delete this.variableMap_[type];
-    this.variableMap_[type] = variables;
+    this.variableMap.delete(type);
+    this.variableMap.set(type, variables);
 
     return variable;
   }
   /* Begin functions for variable deletion. */
   /**
    * Delete a variable.
-   * @param {!VariableModel} variable Variable to delete.
+   * @param variable Variable to delete.
    */
-  deleteVariable(variable) {
+  deleteVariable(variable: VariableModel) {
     const variableId = variable.getId();
-    const variableList = this.variableMap_[variable.type];
-    for (let i = 0; i < variableList.length; i++) {
-      const tempVar = variableList[i];
-      if (tempVar.getId() === variableId) {
-        variableList.splice(i, 1);
-        eventUtils.fire(new (eventUtils.get(eventUtils.VAR_DELETE))(variable));
-        return;
+    const variableList = this.variableMap.get(variable.type);
+    if (variableList) {
+      for (let i = 0; i < variableList.length; i++) {
+        const tempVar = variableList[i];
+        if (tempVar.getId() === variableId) {
+          variableList.splice(i, 1);
+          eventUtils.fire(new (eventUtils.get(eventUtils.VAR_DELETE))!
+                          (variable));
+          return;
+        }
       }
     }
   }
+
   /**
    * Delete a variables by the passed in ID and all of its uses from this
    * workspace. May prompt the user for confirmation.
-   * @param {string} id ID of variable to delete.
+   * @param id ID of variable to delete.
    */
-  deleteVariableById(id) {
+  deleteVariableById(id: string) {
     const variable = this.getVariableById(id);
     if (variable) {
       // Check whether this variable is a function parameter before deleting.
       const variableName = variable.name;
       const uses = this.getVariableUsesById(id);
-      for (let i = 0, block; (block = uses[i]); i++) {
+      for (let i = 0, block; block = uses[i]; i++) {
         if (block.type === 'procedures_defnoreturn' ||
             block.type === 'procedures_defreturn') {
           const procedureName = String(block.getFieldValue('NAME'));
@@ -255,14 +246,15 @@ class VariableMap {
       console.warn('Can\'t delete non-existent variable: ' + id);
     }
   }
+
   /**
    * Deletes a variable and all of its uses from this workspace without asking
    * the user for confirmation.
-   * @param {!VariableModel} variable Variable to delete.
-   * @param {!Array<!Block>} uses An array of uses of the variable.
-   * @package
+   * @param variable Variable to delete.
+   * @param uses An array of uses of the variable.
+   * @internal
    */
-  deleteVariableInternal(variable, uses) {
+  deleteVariableInternal(variable: VariableModel, uses: Block[]) {
     const existingGroup = eventUtils.getGroup();
     if (!existingGroup) {
       eventUtils.setGroup(true);
@@ -282,17 +274,16 @@ class VariableMap {
   /**
    * Find the variable by the given name and type and return it.  Return null if
    *     it is not found.
-   * @param {string} name The name to check for.
-   * @param {?string=} opt_type The type of the variable.  If not provided it
-   *     defaults to the empty string, which is a specific type.
-   * @return {?VariableModel} The variable with the given name, or null if
-   *     it was not found.
+   * @param name The name to check for.
+   * @param opt_type The type of the variable.  If not provided it defaults to
+   *     the empty string, which is a specific type.
+   * @return The variable with the given name, or null if it was not found.
    */
-  getVariable(name, opt_type) {
+  getVariable(name: string, opt_type?: string|null): VariableModel|null {
     const type = opt_type || '';
-    const list = this.variableMap_[type];
+    const list = this.variableMap.get(type);
     if (list) {
-      for (let j = 0, variable; (variable = list[j]); j++) {
+      for (let j = 0, variable; variable = list[j]; j++) {
         if (Names.equals(variable.name, name)) {
           return variable;
         }
@@ -300,16 +291,15 @@ class VariableMap {
     }
     return null;
   }
+
   /**
    * Find the variable by the given ID and return it.  Return null if not found.
-   * @param {string} id The ID to check for.
-   * @return {?VariableModel} The variable with the given ID.
+   * @param id The ID to check for.
+   * @return The variable with the given ID.
    */
-  getVariableById(id) {
-    const keys = Object.keys(this.variableMap_);
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i];
-      for (let j = 0, variable; (variable = this.variableMap_[key][j]); j++) {
+  getVariableById(id: string): VariableModel|null {
+    for (const [key, variables] of this.variableMap) {
+      for (const variable of variables) {
         if (variable.getId() === id) {
           return variable;
         }
@@ -317,79 +307,73 @@ class VariableMap {
     }
     return null;
   }
+
   /**
    * Get a list containing all of the variables of a specified type. If type is
    *     null, return list of variables with empty string type.
-   * @param {?string} type Type of the variables to find.
-   * @return {!Array<!VariableModel>} The sought after variables of the
-   *     passed in type. An empty array if none are found.
+   * @param type Type of the variables to find.
+   * @return The sought after variables of the passed in type. An empty array if
+   *     none are found.
    */
-  getVariablesOfType(type) {
+  getVariablesOfType(type: string|null): VariableModel[] {
     type = type || '';
-    const variableList = this.variableMap_[type];
+    const variableList = this.variableMap.get(type);
     if (variableList) {
       return variableList.slice();
     }
     return [];
   }
+
   /**
    * Return all variable and potential variable types.  This list always
    * contains the empty string.
-   * @param {?Workspace} ws The workspace used to look for potential
-   * variables. This can be different than the workspace stored on this object
-   * if the passed in ws is a flyout workspace.
-   * @return {!Array<string>} List of variable types.
-   * @package
+   * @param ws The workspace used to look for potential variables. This can be
+   *     different than the workspace stored on this object if the passed in ws
+   *     is a flyout workspace.
+   * @return List of variable types.
+   * @internal
    */
-  getVariableTypes(ws) {
-    const variableMap = {};
-    object.mixin(variableMap, this.variableMap_);
+  getVariableTypes(ws: Workspace|null): string[] {
+    const variableTypes = new Set<string>(this.variableMap.keys());
     if (ws && ws.getPotentialVariableMap()) {
-      object.mixin(variableMap, ws.getPotentialVariableMap().variableMap_);
-    }
-    const types = Object.keys(variableMap);
-    let hasEmpty = false;
-    for (let i = 0; i < types.length; i++) {
-      if (types[i] === '') {
-        hasEmpty = true;
+      for (const key of ws.getPotentialVariableMap()!.variableMap.keys()) {
+        variableTypes.add(key);
       }
     }
-    if (!hasEmpty) {
-      types.push('');
+    if (!variableTypes.has('')) {
+      variableTypes.add('');
     }
-    return types;
+    return Array.from(variableTypes.values());
   }
+
   /**
    * Return all variables of all types.
-   * @return {!Array<!VariableModel>} List of variable models.
+   * @return List of variable models.
    */
-  getAllVariables() {
-    let allVariables = [];
-    for (const key in this.variableMap_) {
-      allVariables = allVariables.concat(this.variableMap_[key]);
+  getAllVariables(): VariableModel[] {
+    let allVariables: VariableModel[] = [];
+    for (const variables of this.variableMap.values()) {
+      allVariables = allVariables.concat(variables);
     }
     return allVariables;
   }
+
   /**
    * Returns all of the variable names of all types.
-   * @return {!Array<string>} All of the variable names of all types.
+   * @return All of the variable names of all types.
    */
-  getAllVariableNames() {
-    const allNames = [];
-    for (const key in this.variableMap_) {
-      const variables = this.variableMap_[key];
-      for (let i = 0, variable; (variable = variables[i]); i++) {
-        allNames.push(variable.name);
-      }
-    }
-    return allNames;
+  getAllVariableNames(): string[] {
+    return Array.from(this.variableMap.values())
+        .flat()
+        .map(variable => variable.name);
   }
+
   /**
    * Find all the uses of a named variable.
-   * @param {string} id ID of the variable to find.
-   * @return {!Array<!Block>} Array of block usages.
+   * @param id ID of the variable to find.
+   * @return Array of block usages.
    */
-  getVariableUsesById(id) {
+  getVariableUsesById(id: string): Block[] {
     const uses = [];
     const blocks = this.workspace.getAllBlocks(false);
     // Iterate through every block and check the name.
@@ -406,5 +390,3 @@ class VariableMap {
     return uses;
   }
 }
-
-exports.VariableMap = VariableMap;

package/core/variable_model.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import './events/events_var_create.js';
+import type { Workspace } from './workspace.js';
+/**
+ * Class for a variable model.
+ * Holds information for the variable including name, ID, and type.
+ * @see {Blockly.FieldVariable}
+ * @alias Blockly.VariableModel
+ */
+export declare class VariableModel {
+    workspace: Workspace;
+    name: string;
+    type: string;
+    private readonly id_;
+    /**
+     * @param workspace The variable's workspace.
+     * @param name The name of the variable.  This is the user-visible name (e.g.
+     *     'my var' or '私の変数'), not the generated name.
+     * @param opt_type The type of the variable like 'int' or 'string'.
+     *     Does not need to be unique. Field_variable can filter variables based
+     * on their type. This will default to '' which is a specific type.
+     * @param opt_id The unique ID of the variable. This will default to a UUID.
+     */
+    constructor(workspace: Workspace, name: string, opt_type?: string, opt_id?: string);
+    /** @return The ID for the variable. */
+    getId(): string;
+    /**
+     * A custom compare function for the VariableModel objects.
+     * @param var1 First variable to compare.
+     * @param var2 Second variable to compare.
+     * @return -1 if name of var1 is less than name of var2, 0 if equal, and 1 if
+     *     greater.
+     * @internal
+     */
+    static compareByName(var1: VariableModel, var2: VariableModel): number;
+}

package/core/variable_model.ts

@@ -0,0 +1,82 @@
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Components for the variable model.
+ */
+
+/**
+ * Components for the variable model.
+ * @class
+ */
+import * as goog from '../closure/goog/goog.js';
+goog.declareModuleId('Blockly.VariableModel');
+
+// Unused import preserved for side-effects. Remove if unneeded.
+import './events/events_var_create.js';
+
+import * as eventUtils from './events/utils.js';
+import * as idGenerator from './utils/idgenerator.js';
+import type {Workspace} from './workspace.js';
+
+
+/**
+ * Class for a variable model.
+ * Holds information for the variable including name, ID, and type.
+ * @see {Blockly.FieldVariable}
+ * @alias Blockly.VariableModel
+ */
+export class VariableModel {
+  type: string;
+  private readonly id_: string;
+
+  /**
+   * @param workspace The variable's workspace.
+   * @param name The name of the variable.  This is the user-visible name (e.g.
+   *     'my var' or '私の変数'), not the generated name.
+   * @param opt_type The type of the variable like 'int' or 'string'.
+   *     Does not need to be unique. Field_variable can filter variables based
+   * on their type. This will default to '' which is a specific type.
+   * @param opt_id The unique ID of the variable. This will default to a UUID.
+   */
+  constructor(
+      public workspace: Workspace, public name: string, opt_type?: string,
+      opt_id?: string) {
+    /**
+     * The type of the variable, such as 'int' or 'sound_effect'. This may be
+     * used to build a list of variables of a specific type. By default this is
+     * the empty string '', which is a specific type.
+     * @see {Blockly.FieldVariable}
+     */
+    this.type = opt_type || '';
+
+    /**
+     * A unique ID for the variable. This should be defined at creation and
+     * not change, even if the name changes. In most cases this should be a
+     * UUID.
+     */
+    this.id_ = opt_id || idGenerator.genUid();
+
+    eventUtils.fire(new (eventUtils.get(eventUtils.VAR_CREATE))!(this));
+  }
+
+  /** @return The ID for the variable. */
+  getId(): string {
+    return this.id_;
+  }
+
+  /**
+   * A custom compare function for the VariableModel objects.
+   * @param var1 First variable to compare.
+   * @param var2 Second variable to compare.
+   * @return -1 if name of var1 is less than name of var2, 0 if equal, and 1 if
+   *     greater.
+   * @internal
+   */
+  static compareByName(var1: VariableModel, var2: VariableModel): number {
+    return var1.name.localeCompare(var2.name, undefined, {sensitivity: 'base'});
+  }
+}