nodeskini 1.0.1 → 1.0.3

package/blocklySkini/blockly/core/ui_events.js

@@ -0,0 +1,85 @@
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Events fired as a result of UI actions in Blockly's editor.
+ * @author fraser@google.com (Neil Fraser)
+ */
+'use strict';
+
+goog.provide('Blockly.Events.Ui');
+
+goog.require('Blockly.Events');
+goog.require('Blockly.Events.Abstract');
+goog.require('Blockly.registry');
+goog.require('Blockly.utils.object');
+
+
+/**
+ * Class for a UI event.
+ * UI events are events that don't need to be sent over the wire for multi-user
+ * editing to work (e.g. scrolling the workspace, zooming, opening toolbox
+ * categories).
+ * UI events do not undo or redo.
+ * @param {?Blockly.Block=} opt_block The affected block.  Null for UI events
+ *     that do not have an associated block.  Undefined for a blank event.
+ * @param {string=} opt_element One of 'selected', 'comment', 'mutatorOpen',
+ *     etc.
+ * @param {*=} opt_oldValue Previous value of element.
+ * @param {*=} opt_newValue New value of element.
+ * @extends {Blockly.Events.Abstract}
+ * @constructor
+ */
+Blockly.Events.Ui = function(opt_block, opt_element, opt_oldValue,
+    opt_newValue) {
+  Blockly.Events.Ui.superClass_.constructor.call(this);
+  this.isBlank = typeof opt_block == 'undefined';
+
+  this.blockId = opt_block ? opt_block.id : null;
+  this.workspaceId = opt_block ? opt_block.workspace.id : undefined;
+  this.element = typeof opt_element == 'undefined' ? '' : opt_element;
+  this.oldValue = typeof opt_oldValue == 'undefined' ? '' : opt_oldValue;
+  this.newValue = typeof opt_newValue == 'undefined' ? '' : opt_newValue;
+  // UI events do not undo or redo.
+  this.recordUndo = false;
+};
+Blockly.utils.object.inherits(Blockly.Events.Ui, Blockly.Events.Abstract);
+
+/**
+ * Type of this event.
+ * @type {string}
+ */
+Blockly.Events.Ui.prototype.type = Blockly.Events.UI;
+
+/**
+ * Encode the event as JSON.
+ * @return {!Object} JSON representation.
+ */
+Blockly.Events.Ui.prototype.toJson = function() {
+  var json = Blockly.Events.Ui.superClass_.toJson.call(this);
+  json['element'] = this.element;
+  if (this.newValue !== undefined) {
+    json['newValue'] = this.newValue;
+  }
+  if (this.blockId) {
+    json['blockId'] = this.blockId;
+  }
+  return json;
+};
+
+/**
+ * Decode the JSON event.
+ * @param {!Object} json JSON representation.
+ */
+Blockly.Events.Ui.prototype.fromJson = function(json) {
+  Blockly.Events.Ui.superClass_.fromJson.call(this, json);
+  this.element = json['element'];
+  this.newValue = json['newValue'];
+  this.blockId = json['blockId'];
+};
+
+Blockly.registry.register(Blockly.registry.Type.EVENT, Blockly.Events.UI,
+    Blockly.Events.Ui);

package/blocklySkini/blockly/core/utils/aria.js

@@ -0,0 +1,167 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Constant declarations for common key codes.
+ * These methods are not specific to Blockly, and could be factored out into
+ * a JavaScript framework such as Closure.
+ * @author samelh@google.com (Sam El-Husseini)
+ */
+'use strict';
+
+goog.provide('Blockly.utils.aria');
+
+
+/**
+ * ARIA states/properties prefix.
+ * @private
+ */
+Blockly.utils.aria.ARIA_PREFIX_ = 'aria-';
+
+/**
+ * ARIA role attribute.
+ * @private
+ */
+Blockly.utils.aria.ROLE_ATTRIBUTE_ = 'role';
+
+/**
+ * ARIA role values.
+ * Copied from Closure's goog.a11y.aria.Role
+ * @enum {string}
+ */
+Blockly.utils.aria.Role = {
+  // ARIA role for an interactive control of tabular data.
+  GRID: 'grid',
+
+  // ARIA role for a cell in a grid.
+  GRIDCELL: 'gridcell',
+
+  // ARIA role for a group of related elements like tree item siblings.
+  GROUP: 'group',
+
+  // ARIA role for a listbox.
+  LISTBOX: 'listbox',
+
+  // ARIA role for a popup menu.
+  MENU: 'menu',
+
+  // ARIA role for menu item elements.
+  MENUITEM: 'menuitem',
+
+  // ARIA role for a checkbox box element inside a menu.
+  MENUITEMCHECKBOX: 'menuitemcheckbox',
+
+  // ARIA role for option items that are  children of combobox, listbox, menu,
+  // radiogroup, or tree elements.
+  OPTION: 'option',
+
+  // ARIA role for ignorable cosmetic elements with no semantic significance.
+  PRESENTATION: 'presentation',
+
+  // ARIA role for a row of cells in a grid.
+  ROW: 'row',
+
+  // ARIA role for a tree.
+  TREE: 'tree',
+
+  // ARIA role for a tree item that sometimes may be expanded or collapsed.
+  TREEITEM: 'treeitem'
+};
+
+/**
+ * ARIA states and properties.
+ * Copied from Closure's goog.a11y.aria.State
+ * @enum {string}
+ */
+Blockly.utils.aria.State = {
+  // ARIA property for setting the currently active descendant of an element,
+  // for example the selected item in a list box. Value: ID of an element.
+  ACTIVEDESCENDANT: 'activedescendant',
+
+  // ARIA property defines the total number of columns in a table, grid, or
+  // treegrid.
+  // Value: integer.
+  COLCOUNT: 'colcount',
+
+  // ARIA state for a disabled item. Value: one of {true, false}.
+  DISABLED: 'disabled',
+
+  // ARIA state for setting whether the element like a tree node is expanded.
+  // Value: one of {true, false, undefined}.
+  EXPANDED: 'expanded',
+
+  // ARIA state indicating that the entered value does not conform. Value:
+  // one of {false, true, 'grammar', 'spelling'}
+  INVALID: 'invalid',
+
+  // ARIA property that provides a label to override any other text, value, or
+  // contents used to describe this element. Value: string.
+  LABEL: 'label',
+
+  // ARIA property for setting the element which labels another element.
+  // Value: space-separated IDs of elements.
+  LABELLEDBY: 'labelledby',
+
+  // ARIA property for setting the level of an element in the hierarchy.
+  // Value: integer.
+  LEVEL: 'level',
+
+  // ARIA property indicating if the element is horizontal or vertical.
+  // Value: one of {'vertical', 'horizontal'}.
+  ORIENTATION: 'orientation',
+
+  // ARIA property that defines an element's number of position in a list.
+  // Value: integer.
+  POSINSET: 'posinset',
+
+  // ARIA property defines the total number of rows in a table, grid, or
+  // treegrid.
+  // Value: integer.
+  ROWCOUNT: 'rowcount',
+
+  // ARIA state for setting the currently selected item in the list.
+  // Value: one of {true, false, undefined}.
+  SELECTED: 'selected',
+
+  // ARIA property defining the number of items in a list. Value: integer.
+  SETSIZE: 'setsize',
+
+  // ARIA property for slider maximum value. Value: number.
+  VALUEMAX: 'valuemax',
+
+  // ARIA property for slider minimum value. Value: number.
+  VALUEMIN: 'valuemin'
+};
+
+/**
+ * Sets the role of an element.
+ *
+ * Similar to Closure's goog.a11y.aria
+ *
+ * @param {!Element} element DOM node to set role of.
+ * @param {!Blockly.utils.aria.Role} roleName Role name.
+ */
+Blockly.utils.aria.setRole = function(element, roleName) {
+  element.setAttribute(Blockly.utils.aria.ROLE_ATTRIBUTE_, roleName);
+};
+
+/**
+ * Sets the state or property of an element.
+ * Copied from Closure's goog.a11y.aria
+ * @param {!Element} element DOM node where we set state.
+ * @param {!Blockly.utils.aria.State} stateName State attribute being set.
+ *     Automatically adds prefix 'aria-' to the state name if the attribute is
+ *     not an extra attribute.
+ * @param {string|boolean|number|!Array.<string>} value Value
+ * for the state attribute.
+ */
+Blockly.utils.aria.setState = function(element, stateName, value) {
+  if (Array.isArray(value)) {
+    value = value.join(' ');
+  }
+  var attrStateName = Blockly.utils.aria.ARIA_PREFIX_ + stateName;
+  element.setAttribute(attrStateName, value);
+};

package/blocklySkini/blockly/core/utils/colour.js

@@ -0,0 +1,208 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Utility methods for colour manipulation.
+ * These methods are not specific to Blockly, and could be factored out into
+ * a JavaScript framework such as Closure.
+ * @author fraser@google.com (Neil Fraser)
+ */
+'use strict';
+
+/**
+ * @name Blockly.utils.colour
+ * @namespace
+ */
+goog.provide('Blockly.utils.colour');
+
+
+/**
+ * Parses a colour from a string.
+ * .parse('red') -> '#ff0000'
+ * .parse('#f00') -> '#ff0000'
+ * .parse('#ff0000') -> '#ff0000'
+ * .parse('0xff0000') -> '#ff0000'
+ * .parse('rgb(255, 0, 0)') -> '#ff0000'
+ * @param {string|number} str Colour in some CSS format.
+ * @return {?string} A string containing a hex representation of the colour,
+ *   or null if can't be parsed.
+ */
+Blockly.utils.colour.parse = function(str) {
+  str = String(str).toLowerCase().trim();
+  var hex = Blockly.utils.colour.names[str];
+  if (hex) {
+    // e.g. 'red'
+    return hex;
+  }
+  hex = str.substring(0, 2) == '0x' ? '#' + str.substring(2) : str;
+  hex = hex[0] == '#' ? hex : '#' + hex;
+  if (/^#[0-9a-f]{6}$/.test(hex)) {
+    // e.g. '#00ff88'
+    return hex;
+  }
+  if (/^#[0-9a-f]{3}$/.test(hex)) {
+    // e.g. '#0f8'
+    return ['#', hex[1], hex[1], hex[2], hex[2], hex[3], hex[3]].join('');
+  }
+  var rgb = str.match(/^(?:rgb)?\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$/);
+  if (rgb) {
+    // e.g. 'rgb(0, 128, 255)'
+    var r = Number(rgb[1]);
+    var g = Number(rgb[2]);
+    var b = Number(rgb[3]);
+    if (r >= 0 && r < 256 && g >= 0 && g < 256 && b >= 0 && b < 256) {
+      return Blockly.utils.colour.rgbToHex(r, g, b);
+    }
+  }
+  return null;
+};
+
+/**
+ * Converts a colour from RGB to hex representation.
+ * @param {number} r Amount of red, int between 0 and 255.
+ * @param {number} g Amount of green, int between 0 and 255.
+ * @param {number} b Amount of blue, int between 0 and 255.
+ * @return {string} Hex representation of the colour.
+ */
+Blockly.utils.colour.rgbToHex = function(r, g, b) {
+  var rgb = (r << 16) | (g << 8) | b;
+  if (r < 0x10) {
+    return '#' + (0x1000000 | rgb).toString(16).substr(1);
+  }
+  return '#' + rgb.toString(16);
+};
+
+/**
+ * Converts a colour to RGB.
+ * @param {string} colour String representing colour in any
+ *     colour format ('#ff0000', 'red', '0xff000', etc).
+ * @return {!Array.<number>} RGB representation of the colour.
+ */
+Blockly.utils.colour.hexToRgb = function(colour) {
+  var hex = Blockly.utils.colour.parse(colour);
+  if (!hex) {
+    return [0, 0, 0];
+  }
+
+  var rgb = parseInt(hex.substr(1), 16);
+  var r = rgb >> 16;
+  var g = (rgb >> 8) & 255;
+  var b = rgb & 255;
+
+  return [r, g, b];
+};
+
+/**
+ * Converts an HSV triplet to hex representation.
+ * @param {number} h Hue value in [0, 360].
+ * @param {number} s Saturation value in [0, 1].
+ * @param {number} v Brightness in [0, 255].
+ * @return {string} Hex representation of the colour.
+ */
+Blockly.utils.colour.hsvToHex = function(h, s, v) {
+  var red = 0;
+  var green = 0;
+  var blue = 0;
+  if (s == 0) {
+    red = v;
+    green = v;
+    blue = v;
+  } else {
+    var sextant = Math.floor(h / 60);
+    var remainder = (h / 60) - sextant;
+    var val1 = v * (1 - s);
+    var val2 = v * (1 - (s * remainder));
+    var val3 = v * (1 - (s * (1 - remainder)));
+    switch (sextant) {
+      case 1:
+        red = val2;
+        green = v;
+        blue = val1;
+        break;
+      case 2:
+        red = val1;
+        green = v;
+        blue = val3;
+        break;
+      case 3:
+        red = val1;
+        green = val2;
+        blue = v;
+        break;
+      case 4:
+        red = val3;
+        green = val1;
+        blue = v;
+        break;
+      case 5:
+        red = v;
+        green = val1;
+        blue = val2;
+        break;
+      case 6:
+      case 0:
+        red = v;
+        green = val3;
+        blue = val1;
+        break;
+    }
+  }
+  return Blockly.utils.colour.rgbToHex(
+      Math.floor(red), Math.floor(green), Math.floor(blue));
+};
+
+/**
+ * Blend two colours together, using the specified factor to indicate the
+ * weight given to the first colour.
+ * @param {string} colour1 First colour.
+ * @param {string} colour2 Second colour.
+ * @param {number} factor The weight to be given to colour1 over colour2.
+ *     Values should be in the range [0, 1].
+ * @return {?string} Combined colour represented in hex.
+ */
+Blockly.utils.colour.blend = function(colour1, colour2, factor) {
+  var hex1 = Blockly.utils.colour.parse(colour1);
+  if (!hex1) {
+    return null;
+  }
+  var hex2 = Blockly.utils.colour.parse(colour2);
+  if (!hex2) {
+    return null;
+  }
+  var rgb1 = Blockly.utils.colour.hexToRgb(hex1);
+  var rgb2 = Blockly.utils.colour.hexToRgb(hex2);
+  var r = Math.round(rgb2[0] + factor * (rgb1[0] - rgb2[0]));
+  var g = Math.round(rgb2[1] + factor * (rgb1[1] - rgb2[1]));
+  var b = Math.round(rgb2[2] + factor * (rgb1[2] - rgb2[2]));
+  return Blockly.utils.colour.rgbToHex(r, g, b);
+};
+
+/**
+ * A map that contains the 16 basic colour keywords as defined by W3C:
+ * https://www.w3.org/TR/2018/REC-css-color-3-20180619/#html4
+ * The keys of this map are the lowercase "readable" names of the colours,
+ * while the values are the "hex" values.
+ *
+ * @type {!Object<string, string>}
+ */
+Blockly.utils.colour.names = {
+  'aqua': '#00ffff',
+  'black': '#000000',
+  'blue': '#0000ff',
+  'fuchsia': '#ff00ff',
+  'gray': '#808080',
+  'green': '#008000',
+  'lime': '#00ff00',
+  'maroon': '#800000',
+  'navy': '#000080',
+  'olive': '#808000',
+  'purple': '#800080',
+  'red': '#ff0000',
+  'silver': '#c0c0c0',
+  'teal': '#008080',
+  'white': '#ffffff',
+  'yellow': '#ffff00'
+};

package/blocklySkini/blockly/core/utils/coordinate.js

@@ -0,0 +1,125 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Utility methods for coordinate manipulation.
+ * These methods are not specific to Blockly, and could be factored out into
+ * a JavaScript framework such as Closure.
+ * @author fraser@google.com (Neil Fraser)
+ */
+'use strict';
+
+/**
+ * @name Blockly.utils.Coordinate
+ * @namespace
+ */
+goog.provide('Blockly.utils.Coordinate');
+
+
+/**
+ * Class for representing coordinates and positions.
+ * @param {number} x Left.
+ * @param {number} y Top.
+ * @struct
+ * @constructor
+ */
+Blockly.utils.Coordinate = function(x, y) {
+  /**
+   * X-value
+   * @type {number}
+   */
+  this.x = x;
+
+  /**
+   * Y-value
+   * @type {number}
+   */
+  this.y = y;
+};
+
+/**
+ * Compares coordinates for equality.
+ * @param {Blockly.utils.Coordinate} a A Coordinate.
+ * @param {Blockly.utils.Coordinate} b A Coordinate.
+ * @return {boolean} True iff the coordinates are equal, or if both are null.
+ */
+Blockly.utils.Coordinate.equals = function(a, b) {
+  if (a == b) {
+    return true;
+  }
+  if (!a || !b) {
+    return false;
+  }
+  return a.x == b.x && a.y == b.y;
+};
+
+/**
+ * Returns the distance between two coordinates.
+ * @param {!Blockly.utils.Coordinate} a A Coordinate.
+ * @param {!Blockly.utils.Coordinate} b A Coordinate.
+ * @return {number} The distance between `a` and `b`.
+ */
+Blockly.utils.Coordinate.distance = function(a, b) {
+  var dx = a.x - b.x;
+  var dy = a.y - b.y;
+  return Math.sqrt(dx * dx + dy * dy);
+};
+
+/**
+ * Returns the magnitude of a coordinate.
+ * @param {!Blockly.utils.Coordinate} a A Coordinate.
+ * @return {number} The distance between the origin and `a`.
+ */
+Blockly.utils.Coordinate.magnitude = function(a) {
+  return Math.sqrt(a.x * a.x + a.y * a.y);
+};
+
+/**
+ * Returns the difference between two coordinates as a new
+ * Blockly.utils.Coordinate.
+ * @param {!Blockly.utils.Coordinate|!SVGPoint} a An x/y coordinate.
+ * @param {!Blockly.utils.Coordinate|!SVGPoint} b An x/y coordinate.
+ * @return {!Blockly.utils.Coordinate} A Coordinate representing the difference
+ *     between `a` and `b`.
+ */
+Blockly.utils.Coordinate.difference = function(a, b) {
+  return new Blockly.utils.Coordinate(a.x - b.x, a.y - b.y);
+};
+
+/**
+ * Returns the sum of two coordinates as a new Blockly.utils.Coordinate.
+ * @param {!Blockly.utils.Coordinate|!SVGPoint} a An x/y coordinate.
+ * @param {!Blockly.utils.Coordinate|!SVGPoint} b An x/y coordinate.
+ * @return {!Blockly.utils.Coordinate} A Coordinate representing the sum of
+ *     the two coordinates.
+ */
+Blockly.utils.Coordinate.sum = function(a, b) {
+  return new Blockly.utils.Coordinate(a.x + b.x, a.y + b.y);
+};
+
+/**
+ * Scales this coordinate by the given scale factor.
+ * @param {number} s The scale factor to use for both x and y dimensions.
+ * @return {!Blockly.utils.Coordinate} This coordinate after scaling.
+ */
+Blockly.utils.Coordinate.prototype.scale = function(s) {
+  this.x *= s;
+  this.y *= s;
+  return this;
+};
+
+/**
+ * Translates this coordinate by the given offsets.
+ * respectively.
+ * @param {number} tx The value to translate x by.
+ * @param {number} ty The value to translate y by.
+ * @return {!Blockly.utils.Coordinate} This coordinate after translating.
+ */
+Blockly.utils.Coordinate.prototype.translate = function(tx, ty) {
+  this.x += tx;
+  this.y += ty;
+  return this;
+};

package/blocklySkini/blockly/core/utils/deprecation.js

@@ -0,0 +1,34 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Helper function for warning developers about deprecations.
+ * This method is not specific to Blockly.
+ * @author fenichel@google.com (Rachel Fenichel);
+ */
+'use strict';
+
+goog.provide('Blockly.utils.deprecation');
+
+/**
+ * Warn developers that a function is deprecated.
+ * @param {string} functionName The name of the function.
+ * @param {string} deprecationDate The date when the function was deprecated.
+ *     Prefer 'month yyyy' or 'quarter yyyy' format.
+ * @param {string} deletionDate The date when the function will be deleted, in
+ *     the same format as the deprecation date.
+ * @param {string=} opt_use The name of a function to use instead, if any.
+ * @package
+ */
+Blockly.utils.deprecation.warn = function(
+    functionName, deprecationDate, deletionDate, opt_use) {
+  var msg = functionName + ' was deprecated on ' + deprecationDate +
+        ' and will be deleted on ' + deletionDate + '.';
+  if (opt_use) {
+    msg += '\nUse ' + opt_use + ' instead.';
+  }
+  console.warn(msg);
+};