blockly 8.0.5 → 9.0.0-beta.0

package/core/menuitem.js

@@ -1,292 +0,0 @@
-/**
- * @license
- * Copyright 2019 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @fileoverview Blockly menu item similar to Closure's goog.ui.MenuItem
- */
-'use strict';
-
-/**
- * Blockly menu item similar to Closure's goog.ui.MenuItem
- * @class
- */
-goog.module('Blockly.MenuItem');
-
-const aria = goog.require('Blockly.utils.aria');
-const dom = goog.require('Blockly.utils.dom');
-const idGenerator = goog.require('Blockly.utils.idGenerator');
-
-
-/**
- * Class representing an item in a menu.
- * @alias Blockly.MenuItem
- */
-const MenuItem = class {
-  /**
-   * @param {string|!HTMLElement} content Text caption to display as the content
-   *     of the item, or a HTML element to display.
-   * @param {string=} opt_value Data/model associated with the menu item.
-   */
-  constructor(content, opt_value) {
-    /**
-     * Human-readable text of this menu item, or the HTML element to display.
-     * @type {string|!HTMLElement}
-     * @private
-     */
-    this.content_ = content;
-
-    /**
-     * Machine-readable value of this menu item.
-     * @type {string|undefined}
-     * @private
-     */
-    this.value_ = opt_value;
-
-    /**
-     * Is the menu item clickable, as opposed to greyed-out.
-     * @type {boolean}
-     * @private
-     */
-    this.enabled_ = true;
-
-    /**
-     * The DOM element for the menu item.
-     * @type {?HTMLDivElement}
-     * @private
-     */
-    this.element_ = null;
-
-    /**
-     * Whether the menu item is rendered right-to-left.
-     * @type {boolean}
-     * @private
-     */
-    this.rightToLeft_ = false;
-
-    /**
-     * ARIA name for this menu.
-     * @type {?aria.Role}
-     * @private
-     */
-    this.roleName_ = null;
-
-    /**
-     * Is this menu item checkable.
-     * @type {boolean}
-     * @private
-     */
-    this.checkable_ = false;
-
-    /**
-     * Is this menu item currently checked.
-     * @type {boolean}
-     * @private
-     */
-    this.checked_ = false;
-
-    /**
-     * Is this menu item currently highlighted.
-     * @type {boolean}
-     * @private
-     */
-    this.highlight_ = false;
-
-    /**
-     * Bound function to call when this menu item is clicked.
-     * @type {?Function}
-     * @private
-     */
-    this.actionHandler_ = null;
-  }
-
-  /**
-   * Creates the menuitem's DOM.
-   * @return {!Element} Completed DOM.
-   */
-  createDom() {
-    const element =
-        /** @type {!HTMLDivElement} */ (document.createElement('div'));
-    element.id = idGenerator.getNextUniqueId();
-    this.element_ = element;
-
-    // Set class and style
-    // goog-menuitem* is deprecated, use blocklyMenuItem*.  May 2020.
-    element.className = 'blocklyMenuItem goog-menuitem ' +
-        (this.enabled_ ? '' :
-                         'blocklyMenuItemDisabled goog-menuitem-disabled ') +
-        (this.checked_ ? 'blocklyMenuItemSelected goog-option-selected ' : '') +
-        (this.highlight_ ? 'blocklyMenuItemHighlight goog-menuitem-highlight ' :
-                           '') +
-        (this.rightToLeft_ ? 'blocklyMenuItemRtl goog-menuitem-rtl ' : '');
-
-    const content =
-        /** @type {!HTMLDivElement} */ (document.createElement('div'));
-    content.className = 'blocklyMenuItemContent goog-menuitem-content';
-    // Add a checkbox for checkable menu items.
-    if (this.checkable_) {
-      const checkbox =
-          /** @type {!HTMLDivElement} */ (document.createElement('div'));
-      checkbox.className = 'blocklyMenuItemCheckbox goog-menuitem-checkbox';
-      content.appendChild(checkbox);
-    }
-
-    let contentDom = /** @type {!HTMLElement} */ (this.content_);
-    if (typeof this.content_ === 'string') {
-      contentDom = document.createTextNode(this.content_);
-    }
-    content.appendChild(contentDom);
-    element.appendChild(content);
-
-    // Initialize ARIA role and state.
-    if (this.roleName_) {
-      aria.setRole(element, this.roleName_);
-    }
-    aria.setState(
-        element, aria.State.SELECTED,
-        (this.checkable_ && this.checked_) || false);
-    aria.setState(element, aria.State.DISABLED, !this.enabled_);
-
-    return element;
-  }
-
-  /**
-   * Dispose of this menu item.
-   */
-  dispose() {
-    this.element_ = null;
-  }
-
-  /**
-   * Gets the menu item's element.
-   * @return {?Element} The DOM element.
-   * @package
-   */
-  getElement() {
-    return this.element_;
-  }
-
-  /**
-   * Gets the unique ID for this menu item.
-   * @return {string} Unique component ID.
-   * @package
-   */
-  getId() {
-    return this.element_.id;
-  }
-
-  /**
-   * Gets the value associated with the menu item.
-   * @return {*} value Value associated with the menu item.
-   * @package
-   */
-  getValue() {
-    return this.value_;
-  }
-
-  /**
-   * Set menu item's rendering direction.
-   * @param {boolean} rtl True if RTL, false if LTR.
-   * @package
-   */
-  setRightToLeft(rtl) {
-    this.rightToLeft_ = rtl;
-  }
-
-  /**
-   * Set the menu item's accessibility role.
-   * @param {!aria.Role} roleName Role name.
-   * @package
-   */
-  setRole(roleName) {
-    this.roleName_ = roleName;
-  }
-
-  /**
-   * Sets the menu item to be checkable or not. Set to true for menu items
-   * that represent checkable options.
-   * @param {boolean} checkable Whether the menu item is checkable.
-   * @package
-   */
-  setCheckable(checkable) {
-    this.checkable_ = checkable;
-  }
-
-  /**
-   * Checks or unchecks the component.
-   * @param {boolean} checked Whether to check or uncheck the component.
-   * @package
-   */
-  setChecked(checked) {
-    this.checked_ = checked;
-  }
-
-  /**
-   * Highlights or unhighlights the component.
-   * @param {boolean} highlight Whether to highlight or unhighlight the
-   *     component.
-   * @package
-   */
-  setHighlighted(highlight) {
-    this.highlight_ = highlight;
-
-    const el = this.getElement();
-    if (el && this.isEnabled()) {
-      // goog-menuitem-highlight is deprecated, use blocklyMenuItemHighlight.
-      // May 2020.
-      const name = 'blocklyMenuItemHighlight';
-      const nameDep = 'goog-menuitem-highlight';
-      if (highlight) {
-        dom.addClass(el, name);
-        dom.addClass(el, nameDep);
-      } else {
-        dom.removeClass(el, name);
-        dom.removeClass(el, nameDep);
-      }
-    }
-  }
-
-  /**
-   * Returns true if the menu item is enabled, false otherwise.
-   * @return {boolean} Whether the menu item is enabled.
-   * @package
-   */
-  isEnabled() {
-    return this.enabled_;
-  }
-
-  /**
-   * Enables or disables the menu item.
-   * @param {boolean} enabled Whether to enable or disable the menu item.
-   * @package
-   */
-  setEnabled(enabled) {
-    this.enabled_ = enabled;
-  }
-
-  /**
-   * Performs the appropriate action when the menu item is activated
-   * by the user.
-   * @package
-   */
-  performAction() {
-    if (this.isEnabled() && this.actionHandler_) {
-      this.actionHandler_(this);
-    }
-  }
-
-  /**
-   * Set the handler that's called when the menu item is activated by the user.
-   * `obj` will be used as the 'this' object in the function when called.
-   * @param {function(!MenuItem)} fn The handler.
-   * @param {!Object} obj Used as the 'this' object in fn when called.
-   * @package
-   */
-  onAction(fn, obj) {
-    this.actionHandler_ = fn.bind(obj);
-  }
-};
-
-exports.MenuItem = MenuItem;

package/core/names.js

@@ -1,293 +0,0 @@
-/**
- * @license
- * Copyright 2012 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @fileoverview Utility functions for handling variable and procedure names.
- */
-'use strict';
-
-/**
- * Utility functions for handling variable and procedure names.
- * @class
- */
-goog.module('Blockly.Names');
-
-const Variables = goog.require('Blockly.Variables');
-const {Msg} = goog.require('Blockly.Msg');
-/* eslint-disable-next-line no-unused-vars */
-const {VariableMap} = goog.requireType('Blockly.VariableMap');
-/* eslint-disable-next-line no-unused-vars */
-const {Workspace} = goog.requireType('Blockly.Workspace');
-/** @suppress {extraRequire} */
-goog.requireType('Blockly.Procedures');
-
-
-/**
- * Class for a database of entity names (variables, procedures, etc).
- * @alias Blockly.Names
- */
-const Names = class {
-  /**
-   * @param {string} reservedWords A comma-separated string of words that are
-   *     illegal for use as names in a language (e.g. 'new,if,this,...').
-   * @param {string=} opt_variablePrefix Some languages need a '$' or a
-   *     namespace before all variable names (but not procedure names).
-   */
-  constructor(reservedWords, opt_variablePrefix) {
-    /**
-     * The prefix to attach to variable names in generated code.
-     * @type {string}
-     * @private
-     */
-    this.variablePrefix_ = opt_variablePrefix || '';
-
-    /**
-     * A dictionary of reserved words.
-     * @type {Object}
-     * @private
-     */
-    this.reservedDict_ = Object.create(null);
-
-    /**
-     * A map from type (e.g. name, procedure) to maps from names to generated
-     * names.
-     * @type {Object<string, Object<string, string>>}
-     * @private
-     */
-    this.db_ = Object.create(null);
-
-    /**
-     * A map from used names to booleans to avoid collisions.
-     * @type {Object<string, boolean>}
-     * @private
-     */
-    this.dbReverse_ = Object.create(null);
-
-    /**
-     * The variable map from the workspace, containing Blockly variable models.
-     * @type {?VariableMap}
-     * @private
-     */
-    this.variableMap_ = null;
-
-    if (reservedWords) {
-      const splitWords = reservedWords.split(',');
-      for (let i = 0; i < splitWords.length; i++) {
-        this.reservedDict_[splitWords[i]] = true;
-      }
-    }
-    this.reset();
-  }
-
-  /**
-   * Empty the database and start from scratch.  The reserved words are kept.
-   */
-  reset() {
-    this.db_ = Object.create(null);
-    this.dbReverse_ = Object.create(null);
-    this.variableMap_ = null;
-  }
-
-  /**
-   * Set the variable map that maps from variable name to variable object.
-   * @param {!VariableMap} map The map to track.
-   */
-  setVariableMap(map) {
-    this.variableMap_ = map;
-  }
-
-  /**
-   * Get the name for a user-defined variable, based on its ID.
-   * This should only be used for variables of NameType VARIABLE.
-   * @param {string} id The ID to look up in the variable map.
-   * @return {?string} The name of the referenced variable, or null if there was
-   *     no variable map or the variable was not found in the map.
-   * @private
-   */
-  getNameForUserVariable_(id) {
-    if (!this.variableMap_) {
-      console.warn(
-          'Deprecated call to Names.prototype.getName without ' +
-          'defining a variable map. To fix, add the following code in your ' +
-          'generator\'s init() function:\n' +
-          'Blockly.YourGeneratorName.nameDB_.setVariableMap(' +
-          'workspace.getVariableMap());');
-      return null;
-    }
-    const variable = this.variableMap_.getVariableById(id);
-    if (variable) {
-      return variable.name;
-    }
-    return null;
-  }
-
-  /**
-   * Generate names for user variables, but only ones that are being used.
-   * @param {!Workspace} workspace Workspace to generate variables from.
-   */
-  populateVariables(workspace) {
-    const variables = Variables.allUsedVarModels(workspace);
-    for (let i = 0; i < variables.length; i++) {
-      this.getName(variables[i].getId(), NameType.VARIABLE);
-    }
-  }
-
-  /**
-   * Generate names for procedures.
-   * @param {!Workspace} workspace Workspace to generate procedures from.
-   */
-  populateProcedures(workspace) {
-    let procedures =
-        goog.module.get('Blockly.Procedures').allProcedures(workspace);
-    // Flatten the return vs no-return procedure lists.
-    procedures = procedures[0].concat(procedures[1]);
-    for (let i = 0; i < procedures.length; i++) {
-      this.getName(procedures[i][0], NameType.PROCEDURE);
-    }
-  }
-
-  /**
-   * Convert a Blockly entity name to a legal exportable entity name.
-   * @param {string} nameOrId The Blockly entity name (no constraints) or
-   *     variable ID.
-   * @param {NameType|string} type The type of the name in Blockly
-   *     ('VARIABLE', 'PROCEDURE', 'DEVELOPER_VARIABLE', etc...).
-   * @return {string} An entity name that is legal in the exported language.
-   */
-  getName(nameOrId, type) {
-    let name = nameOrId;
-    if (type === NameType.VARIABLE) {
-      const varName = this.getNameForUserVariable_(nameOrId);
-      if (varName) {
-        // Successful ID lookup.
-        name = varName;
-      }
-    }
-    const normalizedName = name.toLowerCase();
-
-    const isVar =
-        type === NameType.VARIABLE || type === NameType.DEVELOPER_VARIABLE;
-
-    const prefix = isVar ? this.variablePrefix_ : '';
-    if (!(type in this.db_)) {
-      this.db_[type] = Object.create(null);
-    }
-    const typeDb = this.db_[type];
-    if (normalizedName in typeDb) {
-      return prefix + typeDb[normalizedName];
-    }
-    const safeName = this.getDistinctName(name, type);
-    typeDb[normalizedName] = safeName.substr(prefix.length);
-    return safeName;
-  }
-
-  /**
-   * Return a list of all known user-created names of a specified name type.
-   * @param {NameType|string} type The type of entity in Blockly
-   *     ('VARIABLE', 'PROCEDURE', 'DEVELOPER_VARIABLE', etc...).
-   * @return {!Array<string>} A list of Blockly entity names (no constraints).
-   */
-  getUserNames(type) {
-    const typeDb = this.db_[type] || {};
-    return Object.keys(typeDb);
-  }
-
-  /**
-   * Convert a Blockly entity name to a legal exportable entity name.
-   * Ensure that this is a new name not overlapping any previously defined name.
-   * Also check against list of reserved words for the current language and
-   * ensure name doesn't collide.
-   * @param {string} name The Blockly entity name (no constraints).
-   * @param {NameType|string} type The type of entity in Blockly
-   *     ('VARIABLE', 'PROCEDURE', 'DEVELOPER_VARIABLE', etc...).
-   * @return {string} An entity name that is legal in the exported language.
-   */
-  getDistinctName(name, type) {
-    let safeName = this.safeName_(name);
-    let i = '';
-    while (this.dbReverse_[safeName + i] ||
-           (safeName + i) in this.reservedDict_) {
-      // Collision with existing name.  Create a unique name.
-      i = i ? i + 1 : 2;
-    }
-    safeName += i;
-    this.dbReverse_[safeName] = true;
-    const isVar =
-        type === NameType.VARIABLE || type === NameType.DEVELOPER_VARIABLE;
-    const prefix = isVar ? this.variablePrefix_ : '';
-    return prefix + safeName;
-  }
-
-  /**
-   * Given a proposed entity name, generate a name that conforms to the
-   * [_A-Za-z][_A-Za-z0-9]* format that most languages consider legal for
-   * variable and function names.
-   * @param {string} name Potentially illegal entity name.
-   * @return {string} Safe entity name.
-   * @private
-   */
-  safeName_(name) {
-    if (!name) {
-      name = Msg['UNNAMED_KEY'] || 'unnamed';
-    } else {
-      // Unfortunately names in non-latin characters will look like
-      // _E9_9F_B3_E4_B9_90 which is pretty meaningless.
-      // https://github.com/google/blockly/issues/1654
-      name = encodeURI(name.replace(/ /g, '_')).replace(/[^\w]/g, '_');
-      // Most languages don't allow names with leading numbers.
-      if ('0123456789'.indexOf(name[0]) !== -1) {
-        name = 'my_' + name;
-      }
-    }
-    return name;
-  }
-
-  /**
-   * Do the given two entity names refer to the same entity?
-   * Blockly names are case-insensitive.
-   * @param {string} name1 First name.
-   * @param {string} name2 Second name.
-   * @return {boolean} True if names are the same.
-   */
-  static equals(name1, name2) {
-    // name1.localeCompare(name2) is slower.
-    return name1.toLowerCase() === name2.toLowerCase();
-  }
-};
-
-/**
- * Enum for the type of a name. Different name types may have different rules
- * about collisions.
- * When JavaScript (or most other languages) is generated, variable 'foo' and
- * procedure 'foo' would collide.  However, Blockly has no such problems since
- * variable get 'foo' and procedure call 'foo' are unambiguous.
- * Therefore, Blockly keeps a separate name type to disambiguate.
- * getName('foo', 'VARIABLE') -> 'foo'
- * getName('foo', 'PROCEDURE') -> 'foo2'
- * @enum { string }
- * @alias Blockly.Names.NameType
- */
-const NameType = {
-  DEVELOPER_VARIABLE: 'DEVELOPER_VARIABLE',
-  VARIABLE: 'VARIABLE',
-  PROCEDURE: 'PROCEDURE',
-};
-exports.NameType = NameType;
-
-// We have to export NameType here so that it is accessible under the old name
-// `Blockly.Names.NameType`
-Names.NameType = NameType;
-
-/**
- * Constant to separate developer variable names from user-defined variable
- * names when running generators.
- * A developer variable will be declared as a global in the generated code, but
- * will never be shown to the user in the workspace or stored in the variable
- * map.
- */
-Names.DEVELOPER_VARIABLE_TYPE = NameType.DEVELOPER_VARIABLE;
-
-exports.Names = Names;