nodeskini 1.0.1 → 1.0.2

package/blocklySkini/blockly/core/names.js

@@ -0,0 +1,186 @@
+/**
+ * @license
+ * Copyright 2012 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Utility functions for handling variables and procedure names.
+ * @author fraser@google.com (Neil Fraser)
+ */
+'use strict';
+
+goog.provide('Blockly.Names');
+
+goog.require('Blockly.Msg');
+
+
+/**
+ * Class for a database of entity names (variables, functions, etc).
+ * @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.
+ * @constructor
+ */
+Blockly.Names = function(reservedWords, opt_variablePrefix) {
+  this.variablePrefix_ = opt_variablePrefix || '';
+  this.reservedDict_ = Object.create(null);
+  if (reservedWords) {
+    var splitWords = reservedWords.split(',');
+    for (var i = 0; i < splitWords.length; i++) {
+      this.reservedDict_[splitWords[i]] = true;
+    }
+  }
+  this.reset();
+};
+
+/**
+ * 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.
+ */
+Blockly.Names.DEVELOPER_VARIABLE_TYPE = 'DEVELOPER_VARIABLE';
+
+/**
+ * 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 type name to disambiguate.
+ * getName('foo', 'variable') -> 'foo'
+ * getName('foo', 'procedure') -> 'foo2'
+ */
+
+/**
+ * Empty the database and start from scratch.  The reserved words are kept.
+ */
+Blockly.Names.prototype.reset = function() {
+  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 {!Blockly.VariableMap} map The map to track.
+ */
+Blockly.Names.prototype.setVariableMap = function(map) {
+  this.variableMap_ = map;
+};
+
+/**
+ * Get the name for a user-defined variable, based on its ID.
+ * This should only be used for variables of type
+ * Blockly.VARIABLE_CATEGORY_NAME.
+ * @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
+ */
+Blockly.Names.prototype.getNameForUserVariable_ = function(id) {
+  if (!this.variableMap_) {
+    console.log('Deprecated call to Blockly.Names.prototype.getName without ' +
+        'defining a variable map. To fix, add the following code in your ' +
+        'generator\'s init() function:\n' +
+        'Blockly.YourGeneratorName.variableDB_.setVariableMap(' +
+        'workspace.getVariableMap());');
+    return null;
+  }
+  var variable = this.variableMap_.getVariableById(id);
+  if (variable) {
+    return variable.name;
+  } else {
+    return null;
+  }
+};
+
+/**
+ * Convert a Blockly entity name to a legal exportable entity name.
+ * @param {string} name The Blockly entity name (no constraints).
+ * @param {string} type The type of entity in Blockly
+ *     ('VARIABLE', 'PROCEDURE', 'BUILTIN', etc...).
+ * @return {string} An entity name that is legal in the exported language.
+ */
+Blockly.Names.prototype.getName = function(name, type) {
+  if (type == Blockly.VARIABLE_CATEGORY_NAME) {
+    var varName = this.getNameForUserVariable_(name);
+    if (varName) {
+      name = varName;
+    }
+  }
+  var normalized = name.toLowerCase() + '_' + type;
+
+  var isVarType = type == Blockly.VARIABLE_CATEGORY_NAME ||
+      type == Blockly.Names.DEVELOPER_VARIABLE_TYPE;
+
+  var prefix = isVarType ? this.variablePrefix_ : '';
+  if (normalized in this.db_) {
+    return prefix + this.db_[normalized];
+  }
+  var safeName = this.getDistinctName(name, type);
+  this.db_[normalized] = safeName.substr(prefix.length);
+  return safeName;
+};
+
+/**
+ * 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 {string} type The type of entity in Blockly
+ *     ('VARIABLE', 'PROCEDURE', 'BUILTIN', etc...).
+ * @return {string} An entity name that is legal in the exported language.
+ */
+Blockly.Names.prototype.getDistinctName = function(name, type) {
+  var safeName = this.safeName_(name);
+  var 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;
+  var isVarType = type == Blockly.VARIABLE_CATEGORY_NAME ||
+      type == Blockly.Names.DEVELOPER_VARIABLE_TYPE;
+  var prefix = isVarType ? 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
+ * variables.
+ * @param {string} name Potentially illegal entity name.
+ * @return {string} Safe entity name.
+ * @private
+ */
+Blockly.Names.prototype.safeName_ = function(name) {
+  if (!name) {
+    name = Blockly.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.
+ */
+Blockly.Names.equals = function(name1, name2) {
+  return name1.toLowerCase() == name2.toLowerCase();
+};

package/blocklySkini/blockly/core/options.js

@@ -0,0 +1,365 @@
+/**
+ * @license
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Object that controls settings for the workspace.
+ * @author fenichel@google.com (Rachel Fenichel)
+ */
+'use strict';
+
+goog.provide('Blockly.Options');
+
+goog.require('Blockly.Theme');
+goog.require('Blockly.Themes.Classic');
+goog.require('Blockly.registry');
+goog.require('Blockly.user.keyMap');
+goog.require('Blockly.utils.IdGenerator');
+goog.require('Blockly.utils.Metrics');
+goog.require('Blockly.utils.toolbox');
+goog.require('Blockly.utils.userAgent');
+goog.require('Blockly.Xml');
+
+goog.requireType('Blockly.WorkspaceSvg');
+
+
+/**
+ * Parse the user-specified options, using reasonable defaults where behaviour
+ * is unspecified.
+ * @param {!Blockly.BlocklyOptions} options Dictionary of options.
+ *     Specification: https://developers.google.com/blockly/guides/get-started/web#configuration
+ * @constructor
+ */
+Blockly.Options = function(options) {
+  var readOnly = !!options['readOnly'];
+  if (readOnly) {
+    var toolboxJsonDef = null;
+    var hasCategories = false;
+    var hasTrashcan = false;
+    var hasCollapse = false;
+    var hasComments = false;
+    var hasDisable = false;
+    var hasSounds = false;
+  } else {
+    var toolboxJsonDef = Blockly.utils.toolbox.convertToolboxDefToJson(options['toolbox']);
+    var hasCategories = Blockly.utils.toolbox.hasCategories(toolboxJsonDef);
+    var hasTrashcan = options['trashcan'];
+    if (hasTrashcan === undefined) {
+      hasTrashcan = hasCategories;
+    }
+    var maxTrashcanContents = options['maxTrashcanContents'];
+    if (hasTrashcan) {
+      if (maxTrashcanContents === undefined) {
+        maxTrashcanContents = 32;
+      }
+    } else {
+      maxTrashcanContents = 0;
+    }
+    var hasCollapse = options['collapse'];
+    if (hasCollapse === undefined) {
+      hasCollapse = hasCategories;
+    }
+    var hasComments = options['comments'];
+    if (hasComments === undefined) {
+      hasComments = hasCategories;
+    }
+    var hasDisable = options['disable'];
+    if (hasDisable === undefined) {
+      hasDisable = hasCategories;
+    }
+    var hasSounds = options['sounds'];
+    if (hasSounds === undefined) {
+      hasSounds = true;
+    }
+  }
+  var rtl = !!options['rtl'];
+  var horizontalLayout = options['horizontalLayout'];
+  if (horizontalLayout === undefined) {
+    horizontalLayout = false;
+  }
+  var toolboxAtStart = options['toolboxPosition'];
+  toolboxAtStart = toolboxAtStart !== 'end';
+
+  /** @type {!Blockly.utils.toolbox.Position} */
+  var toolboxPosition;
+  if (horizontalLayout) {
+    toolboxPosition = toolboxAtStart ?
+        Blockly.utils.toolbox.Position.TOP : Blockly.utils.toolbox.Position.BOTTOM;
+  } else {
+    toolboxPosition = (toolboxAtStart == rtl) ?
+        Blockly.utils.toolbox.Position.RIGHT : Blockly.utils.toolbox.Position.LEFT;
+  }
+
+  var hasCss = options['css'];
+  if (hasCss === undefined) {
+    hasCss = true;
+  }
+  var pathToMedia = 'https://blockly-demo.appspot.com/static/media/';
+  if (options['media']) {
+    pathToMedia = options['media'];
+  } else if (options['path']) {
+    // 'path' is a deprecated option which has been replaced by 'media'.
+    pathToMedia = options['path'] + 'media/';
+  }
+  if (options['oneBasedIndex'] === undefined) {
+    var oneBasedIndex = true;
+  } else {
+    var oneBasedIndex = !!options['oneBasedIndex'];
+  }
+  var keyMap = options['keyMap'] || Blockly.user.keyMap.createDefaultKeyMap();
+
+  var renderer = options['renderer'] || 'geras';
+
+  var plugins = options['plugins'] || {};
+
+  /** @type {boolean} */
+  this.RTL = rtl;
+  /** @type {boolean} */
+  this.oneBasedIndex = oneBasedIndex;
+  /** @type {boolean} */
+  this.collapse = hasCollapse;
+  /** @type {boolean} */
+  this.comments = hasComments;
+  /** @type {boolean} */
+  this.disable = hasDisable;
+  /** @type {boolean} */
+  this.readOnly = readOnly;
+  /** @type {number} */
+  this.maxBlocks = options['maxBlocks'] || Infinity;
+  /** @type {?Object.<string, number>} */
+  this.maxInstances = options['maxInstances'];
+  /** @type {string} */
+  this.pathToMedia = pathToMedia;
+  /** @type {boolean} */
+  this.hasCategories = hasCategories;
+  /** @type {!Blockly.Options.MoveOptions} */
+  this.moveOptions = Blockly.Options.parseMoveOptions_(options, hasCategories);
+  /** @deprecated  January 2019 */
+  this.hasScrollbars = this.moveOptions.scrollbars;
+  /** @type {boolean} */
+  this.hasTrashcan = hasTrashcan;
+  /** @type {number} */
+  this.maxTrashcanContents = maxTrashcanContents;
+  /** @type {boolean} */
+  this.hasSounds = hasSounds;
+  /** @type {boolean} */
+  this.hasCss = hasCss;
+  /** @type {boolean} */
+  this.horizontalLayout = horizontalLayout;
+  /** @type {?Blockly.utils.toolbox.ToolboxInfo} */
+  this.languageTree = toolboxJsonDef;
+  /** @type {!Blockly.Options.GridOptions} */
+  this.gridOptions = Blockly.Options.parseGridOptions_(options);
+  /** @type {!Blockly.Options.ZoomOptions} */
+  this.zoomOptions = Blockly.Options.parseZoomOptions_(options);
+  /** @type {!Blockly.utils.toolbox.Position} */
+  this.toolboxPosition = toolboxPosition;
+  /** @type {!Blockly.Theme} */
+  this.theme = Blockly.Options.parseThemeOptions_(options);
+  /** @type {!Object<string,Blockly.Action>} */
+  this.keyMap = keyMap;
+  /** @type {string} */
+  this.renderer = renderer;
+  /** @type {?Object} */
+  this.rendererOverrides = options['rendererOverrides'];
+
+  /**
+   * The SVG element for the grid pattern.
+   * Created during injection.
+   * @type {?SVGElement}
+   */
+  this.gridPattern = null;
+
+  /**
+   * The parent of the current workspace, or null if there is no parent
+   * workspace.  We can assert that this is of type WorkspaceSvg as opposed to
+   * Workspace as this is only used in a rendered workspace.
+   * @type {Blockly.WorkspaceSvg}
+   */
+  this.parentWorkspace = options['parentWorkspace'];
+
+  /**
+   * Map of plugin type to name of registered plugin or plugin class.
+   * @type {!Object.<string, (function(new:?, ...?)|string)>}
+   */
+  this.plugins = plugins;
+};
+
+/**
+ * Blockly options.
+ * This interface is further described in
+ * `typings/parts/blockly-interfaces.d.ts`.
+ * @interface
+ */
+Blockly.BlocklyOptions = function() {};
+
+/**
+ * Grid Options.
+ * @typedef {{
+ *     colour: string,
+ *     length: number,
+ *     snap: boolean,
+ *     spacing: number
+ * }}
+ */
+Blockly.Options.GridOptions;
+
+/**
+ * Move Options.
+ * @typedef {{
+ *     drag: boolean,
+ *     scrollbars: boolean,
+ *     wheel: boolean
+ * }}
+ */
+Blockly.Options.MoveOptions;
+
+/**
+ * Zoom Options.
+ * @typedef {{
+ *     controls: boolean,
+ *     maxScale: number,
+ *     minScale: number,
+ *     pinch: boolean,
+ *     scaleSpeed: number,
+ *     startScale: number,
+ *     wheel: boolean
+ * }}
+ */
+Blockly.Options.ZoomOptions;
+
+/**
+ * If set, sets the translation of the workspace to match the scrollbars.
+ * @param {!{x:number,y:number}} xyRatio Contains an x and/or y property which
+ *     is a float between 0 and 1 specifying the degree of scrolling.
+ * @return {void}
+ */
+Blockly.Options.prototype.setMetrics;
+
+/**
+ * Return an object with the metrics required to size the workspace.
+ * @return {!Blockly.utils.Metrics} Contains size and position metrics.
+ */
+Blockly.Options.prototype.getMetrics;
+
+/**
+ * Parse the user-specified move options, using reasonable defaults where
+ *    behaviour is unspecified.
+ * @param {!Object} options Dictionary of options.
+ * @param {boolean} hasCategories Whether the workspace has categories or not.
+ * @return {!Blockly.Options.MoveOptions} Normalized move options.
+ * @private
+ */
+Blockly.Options.parseMoveOptions_ = function(options, hasCategories) {
+  var move = options['move'] || {};
+  var moveOptions = {};
+  if (move['scrollbars'] === undefined && options['scrollbars'] === undefined) {
+    moveOptions.scrollbars = hasCategories;
+  } else {
+    moveOptions.scrollbars = !!move['scrollbars'] || !!options['scrollbars'];
+  }
+  if (!moveOptions.scrollbars || move['wheel'] === undefined) {
+    // Defaults to false so that developers' settings don't appear to change.
+    moveOptions.wheel = false;
+  } else {
+    moveOptions.wheel = !!move['wheel'];
+  }
+  if (!moveOptions.scrollbars) {
+    moveOptions.drag = false;
+  } else if (move['drag'] === undefined) {
+    // Defaults to true if scrollbars is true.
+    moveOptions.drag = true;
+  } else {
+    moveOptions.drag = !!move['drag'];
+  }
+  return moveOptions;
+};
+
+/**
+ * Parse the user-specified zoom options, using reasonable defaults where
+ * behaviour is unspecified.  See zoom documentation:
+ *   https://developers.google.com/blockly/guides/configure/web/zoom
+ * @param {!Object} options Dictionary of options.
+ * @return {!Blockly.Options.ZoomOptions} Normalized zoom options.
+ * @private
+ */
+Blockly.Options.parseZoomOptions_ = function(options) {
+  var zoom = options['zoom'] || {};
+  var zoomOptions = {};
+  if (zoom['controls'] === undefined) {
+    zoomOptions.controls = false;
+  } else {
+    zoomOptions.controls = !!zoom['controls'];
+  }
+  if (zoom['wheel'] === undefined) {
+    zoomOptions.wheel = false;
+  } else {
+    zoomOptions.wheel = !!zoom['wheel'];
+  }
+  if (zoom['startScale'] === undefined) {
+    zoomOptions.startScale = 1;
+  } else {
+    zoomOptions.startScale = Number(zoom['startScale']);
+  }
+  if (zoom['maxScale'] === undefined) {
+    zoomOptions.maxScale = 3;
+  } else {
+    zoomOptions.maxScale = Number(zoom['maxScale']);
+  }
+  if (zoom['minScale'] === undefined) {
+    zoomOptions.minScale = 0.3;
+  } else {
+    zoomOptions.minScale = Number(zoom['minScale']);
+  }
+  if (zoom['scaleSpeed'] === undefined) {
+    zoomOptions.scaleSpeed = 1.2;
+  } else {
+    zoomOptions.scaleSpeed = Number(zoom['scaleSpeed']);
+  }
+  if (zoom['pinch'] === undefined) {
+    zoomOptions.pinch = zoomOptions.wheel || zoomOptions.controls;
+  } else {
+    zoomOptions.pinch = !!zoom['pinch'];
+  }
+  return zoomOptions;
+};
+
+/**
+ * Parse the user-specified grid options, using reasonable defaults where
+ * behaviour is unspecified. See grid documentation:
+ *   https://developers.google.com/blockly/guides/configure/web/grid
+ * @param {!Object} options Dictionary of options.
+ * @return {!Blockly.Options.GridOptions} Normalized grid options.
+ * @private
+ */
+Blockly.Options.parseGridOptions_ = function(options) {
+  var grid = options['grid'] || {};
+  var gridOptions = {};
+  gridOptions.spacing = Number(grid['spacing']) || 0;
+  gridOptions.colour = grid['colour'] || '#888';
+  gridOptions.length =
+      (grid['length'] === undefined) ? 1 : Number(grid['length']);
+  gridOptions.snap = gridOptions.spacing > 0 && !!grid['snap'];
+  return gridOptions;
+};
+
+/**
+ * Parse the user-specified theme options, using the classic theme as a default.
+ *   https://developers.google.com/blockly/guides/configure/web/themes
+ * @param {!Object} options Dictionary of options.
+ * @return {!Blockly.Theme} A Blockly Theme.
+ * @private
+ */
+Blockly.Options.parseThemeOptions_ = function(options) {
+  var theme = options['theme'] || Blockly.Themes.Classic;
+  if (typeof theme == 'string') {
+    return /** @type {!Blockly.Theme} */ (
+      Blockly.registry.getObject(Blockly.registry.Type.THEME, theme));
+  } else if (theme instanceof Blockly.Theme) {
+    return /** @type {!Blockly.Theme} */ (theme);
+  }
+  return Blockly.Theme.defineTheme(theme.name ||
+      ('builtin' + Blockly.utils.IdGenerator.getNextUniqueId()), theme);
+};