blockly 9.0.0-beta.0 → 9.0.0-beta.1

package/core/variable_map.ts

@@ -1,392 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @fileoverview Object representing a map of variables and their types.
- */
-
-/**
- * Object representing a map of variables and their types.
- * @class
- */
-import * as goog from '../closure/goog/goog.js';
-goog.declareModuleId('Blockly.VariableMap');
-
-// 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';
-
-
-/**
- * Class for a variable map.  This contains a dictionary data structure with
- * variable types as keys and lists of variables as values.  The list of
- * variables are the type indicated by the key.
- * @alias Blockly.VariableMap
- */
-export class VariableMap {
-  /**
-   * 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.
-   */
-  private variableMap = new Map<string, VariableModel[]>();
-
-  /** @param workspace The workspace this map belongs to. */
-  constructor(public workspace: Workspace) {}
-
-  /** Clear the variable map. */
-  clear() {
-    this.variableMap.clear();
-  }
-  /* Begin functions for renaming variables. */
-  /**
-   * Rename the given variable by updating its name in the variable map.
-   * @param variable Variable to rename.
-   * @param newName New variable name.
-   * @internal
-   */
-  renameVariable(variable: VariableModel, newName: string) {
-    const type = variable.type;
-    const conflictVar = this.getVariable(newName, type);
-    const blocks = this.workspace.getAllBlocks(false);
-    eventUtils.setGroup(true);
-    try {
-      // The IDs may match if the rename is a simple case change (name1 ->
-      // Name1).
-      if (!conflictVar || conflictVar.getId() === variable.getId()) {
-        this.renameVariableAndUses_(variable, newName, blocks);
-      } else {
-        this.renameVariableWithConflict_(
-            variable, newName, conflictVar, blocks);
-      }
-    } finally {
-      eventUtils.setGroup(false);
-    }
-  }
-
-  /**
-   * Rename a variable by updating its name in the variable map. Identify the
-   * variable to rename with the given ID.
-   * @param id ID of the variable to rename.
-   * @param newName New variable name.
-   */
-  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);
-    }
-
-    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 variable Variable to rename.
-   * @param newName New variable name.
-   * @param blocks The list of all blocks in the workspace.
-   */
-  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 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.
-   */
-  private renameVariableWithConflict_(
-      variable: VariableModel, newName: string, conflictVar: VariableModel,
-      blocks: Block[]) {
-    const type = variable.type;
-    const oldCase = conflictVar.name;
-
-    if (newName !== oldCase) {
-      // Simple rename to change the case and update references.
-      this.renameVariableAndUses_(conflictVar, newName, blocks);
-    }
-
-    // These blocks now refer to a different variable.
-    // These will fire change events.
-    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));
-    // And remove it from the list.
-    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 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 opt_id The unique ID of the variable. This will default to a UUID.
-   * @return The newly created variable.
-   */
-  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) {
-        throw Error(
-            'Variable "' + name + '" is already in use and its id is "' +
-            variable.getId() + '" which conflicts with the passed in ' +
-            'id, "' + opt_id + '".');
-      }
-      // The variable already exists and has the same ID.
-      return variable;
-    }
-    if (opt_id && this.getVariableById(opt_id)) {
-      throw Error('Variable id, "' + opt_id + '", is already in use.');
-    }
-    const id = opt_id || idGenerator.genUid();
-    const type = opt_type || '';
-    variable = new VariableModel(this.workspace, name, type, id);
-
-    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.
-    this.variableMap.delete(type);
-    this.variableMap.set(type, variables);
-
-    return variable;
-  }
-  /* Begin functions for variable deletion. */
-  /**
-   * Delete a variable.
-   * @param variable Variable to delete.
-   */
-  deleteVariable(variable: VariableModel) {
-    const variableId = variable.getId();
-    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 id ID of variable to delete.
-   */
-  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++) {
-        if (block.type === 'procedures_defnoreturn' ||
-            block.type === 'procedures_defreturn') {
-          const procedureName = String(block.getFieldValue('NAME'));
-          const deleteText = Msg['CANNOT_DELETE_VARIABLE_PROCEDURE']
-                                 .replace('%1', variableName)
-                                 .replace('%2', procedureName);
-          dialog.alert(deleteText);
-          return;
-        }
-      }
-
-      const map = this;
-      if (uses.length > 1) {
-        // Confirm before deleting multiple blocks.
-        const confirmText = Msg['DELETE_VARIABLE_CONFIRMATION']
-                                .replace('%1', String(uses.length))
-                                .replace('%2', variableName);
-        dialog.confirm(confirmText, function(ok) {
-          if (ok && variable) {
-            map.deleteVariableInternal(variable, uses);
-          }
-        });
-      } else {
-        // No confirmation necessary for a single block.
-        map.deleteVariableInternal(variable, uses);
-      }
-    } else {
-      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 variable Variable to delete.
-   * @param uses An array of uses of the variable.
-   * @internal
-   */
-  deleteVariableInternal(variable: VariableModel, uses: Block[]) {
-    const existingGroup = eventUtils.getGroup();
-    if (!existingGroup) {
-      eventUtils.setGroup(true);
-    }
-    try {
-      for (let i = 0; i < uses.length; i++) {
-        uses[i].dispose(true);
-      }
-      this.deleteVariable(variable);
-    } finally {
-      if (!existingGroup) {
-        eventUtils.setGroup(false);
-      }
-    }
-  }
-  /* End functions for variable deletion. */
-  /**
-   * Find the variable by the given name and type and return it.  Return null if
-   *     it is 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: string, opt_type?: string|null): VariableModel|null {
-    const type = opt_type || '';
-    const list = this.variableMap.get(type);
-    if (list) {
-      for (let j = 0, variable; variable = list[j]; j++) {
-        if (Names.equals(variable.name, name)) {
-          return variable;
-        }
-      }
-    }
-    return null;
-  }
-
-  /**
-   * Find the variable by the given ID and return it.  Return null if not found.
-   * @param id The ID to check for.
-   * @return The variable with the given ID.
-   */
-  getVariableById(id: string): VariableModel|null {
-    for (const [key, variables] of this.variableMap) {
-      for (const variable of variables) {
-        if (variable.getId() === id) {
-          return variable;
-        }
-      }
-    }
-    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 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: string|null): VariableModel[] {
-    type = 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 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: Workspace|null): string[] {
-    const variableTypes = new Set<string>(this.variableMap.keys());
-    if (ws && ws.getPotentialVariableMap()) {
-      for (const key of ws.getPotentialVariableMap()!.variableMap.keys()) {
-        variableTypes.add(key);
-      }
-    }
-    if (!variableTypes.has('')) {
-      variableTypes.add('');
-    }
-    return Array.from(variableTypes.values());
-  }
-
-  /**
-   * Return all variables of all types.
-   * @return List of variable models.
-   */
-  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 All of the variable names of all types.
-   */
-  getAllVariableNames(): string[] {
-    return Array.from(this.variableMap.values())
-        .flat()
-        .map(variable => variable.name);
-  }
-
-  /**
-   * Find all the uses of a named variable.
-   * @param id ID of the variable to find.
-   * @return Array of block usages.
-   */
-  getVariableUsesById(id: string): Block[] {
-    const uses = [];
-    const blocks = this.workspace.getAllBlocks(false);
-    // Iterate through every block and check the name.
-    for (let i = 0; i < blocks.length; i++) {
-      const blockVariables = blocks[i].getVarModels();
-      if (blockVariables) {
-        for (let j = 0; j < blockVariables.length; j++) {
-          if (blockVariables[j].getId() === id) {
-            uses.push(blocks[i]);
-          }
-        }
-      }
-    }
-    return uses;
-  }
-}

package/core/variable_model.ts

@@ -1,82 +0,0 @@
-/**
- * @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'});
-  }
-}