nodeskini 1.0.0 → 1.0.2

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

@@ -0,0 +1,391 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Utility methods for DOM 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.dom
+ * @namespace
+ */
+goog.provide('Blockly.utils.dom');
+
+goog.require('Blockly.utils.Svg');
+goog.require('Blockly.utils.userAgent');
+
+
+/**
+ * Required name space for SVG elements.
+ * @const
+ */
+Blockly.utils.dom.SVG_NS = 'http://www.w3.org/2000/svg';
+
+/**
+ * Required name space for HTML elements.
+ * @const
+ */
+Blockly.utils.dom.HTML_NS = 'http://www.w3.org/1999/xhtml';
+
+/**
+ * Required name space for XLINK elements.
+ * @const
+ */
+Blockly.utils.dom.XLINK_NS = 'http://www.w3.org/1999/xlink';
+
+/**
+ * Node type constants.
+ * https://developer.mozilla.org/en-US/docs/Web/API/Node/nodeType
+ * @enum {number}
+ */
+Blockly.utils.dom.NodeType = {
+  ELEMENT_NODE: 1,
+  TEXT_NODE: 3,
+  COMMENT_NODE: 8,
+  DOCUMENT_POSITION_CONTAINED_BY: 16
+};
+
+/**
+ * Temporary cache of text widths.
+ * @type {Object}
+ * @private
+ */
+Blockly.utils.dom.cacheWidths_ = null;
+
+/**
+ * Number of current references to cache.
+ * @type {number}
+ * @private
+ */
+Blockly.utils.dom.cacheReference_ = 0;
+
+/**
+ * A HTML canvas context used for computing text width.
+ * @type {CanvasRenderingContext2D}
+ * @private
+ */
+Blockly.utils.dom.canvasContext_ = null;
+
+/**
+ * Helper method for creating SVG elements.
+ * @param {string|Blockly.utils.Svg<T>} name Element's tag name.
+ * @param {!Object} attrs Dictionary of attribute names and values.
+ * @param {Element=} opt_parent Optional parent on which to append the element.
+ * @return {T} Newly created SVG element.  The return type is {!SVGElement} if
+ *     name is a string or a more specific type if it a member of
+ *     Blockly.utils.Svg
+ * @template T
+ */
+Blockly.utils.dom.createSvgElement = function(name, attrs, opt_parent) {
+  var e = /** @type {T} */
+      (document.createElementNS(Blockly.utils.dom.SVG_NS, String(name)));
+  for (var key in attrs) {
+    e.setAttribute(key, attrs[key]);
+  }
+  // IE defines a unique attribute "runtimeStyle", it is NOT applied to
+  // elements created with createElementNS. However, Closure checks for IE
+  // and assumes the presence of the attribute and crashes.
+  if (document.body.runtimeStyle) {  // Indicates presence of IE-only attr.
+    e.runtimeStyle = e.currentStyle = e.style;
+  }
+  if (opt_parent) {
+    opt_parent.appendChild(e);
+  }
+  return e;
+};
+
+/**
+ * Add a CSS class to a element.
+ * Similar to Closure's goog.dom.classes.add, except it handles SVG elements.
+ * @param {!Element} element DOM element to add class to.
+ * @param {string} className Name of class to add.
+ * @return {boolean} True if class was added, false if already present.
+ */
+Blockly.utils.dom.addClass = function(element, className) {
+  var classes = element.getAttribute('class') || '';
+  if ((' ' + classes + ' ').indexOf(' ' + className + ' ') != -1) {
+    return false;
+  }
+  if (classes) {
+    classes += ' ';
+  }
+  element.setAttribute('class', classes + className);
+  return true;
+};
+
+/**
+ * Removes multiple calsses from an element.
+ * @param {!Element} element DOM element to remove classes from.
+ * @param {string} classNames A string of one or multiple class names for an
+ *    element.
+ */
+Blockly.utils.dom.removeClasses = function(element, classNames) {
+  var classList = classNames.split(' ');
+  for (var i = 0; i < classList.length; i++) {
+    var cssName = classList[i];
+    Blockly.utils.dom.removeClass(element, cssName);
+  }
+};
+
+/**
+ * Remove a CSS class from a element.
+ * Similar to Closure's goog.dom.classes.remove, except it handles SVG elements.
+ * @param {!Element} element DOM element to remove class from.
+ * @param {string} className Name of class to remove.
+ * @return {boolean} True if class was removed, false if never present.
+ */
+Blockly.utils.dom.removeClass = function(element, className) {
+  var classes = element.getAttribute('class');
+  if ((' ' + classes + ' ').indexOf(' ' + className + ' ') == -1) {
+    return false;
+  }
+  var classList = classes.split(/\s+/);
+  for (var i = 0; i < classList.length; i++) {
+    if (!classList[i] || classList[i] == className) {
+      classList.splice(i, 1);
+      i--;
+    }
+  }
+  if (classList.length) {
+    element.setAttribute('class', classList.join(' '));
+  } else {
+    element.removeAttribute('class');
+  }
+  return true;
+};
+
+/**
+ * Checks if an element has the specified CSS class.
+ * Similar to Closure's goog.dom.classes.has, except it handles SVG elements.
+ * @param {!Element} element DOM element to check.
+ * @param {string} className Name of class to check.
+ * @return {boolean} True if class exists, false otherwise.
+ */
+Blockly.utils.dom.hasClass = function(element, className) {
+  var classes = element.getAttribute('class');
+  return (' ' + classes + ' ').indexOf(' ' + className + ' ') != -1;
+};
+
+/**
+ * Removes a node from its parent. No-op if not attached to a parent.
+ * @param {Node} node The node to remove.
+ * @return {Node} The node removed if removed; else, null.
+ */
+// Copied from Closure goog.dom.removeNode
+Blockly.utils.dom.removeNode = function(node) {
+  return node && node.parentNode ? node.parentNode.removeChild(node) : null;
+};
+
+/**
+ * Insert a node after a reference node.
+ * Contrast with node.insertBefore function.
+ * @param {!Element} newNode New element to insert.
+ * @param {!Element} refNode Existing element to precede new node.
+ */
+Blockly.utils.dom.insertAfter = function(newNode, refNode) {
+  var siblingNode = refNode.nextSibling;
+  var parentNode = refNode.parentNode;
+  if (!parentNode) {
+    throw Error('Reference node has no parent.');
+  }
+  if (siblingNode) {
+    parentNode.insertBefore(newNode, siblingNode);
+  } else {
+    parentNode.appendChild(newNode);
+  }
+};
+
+/**
+ * Whether a node contains another node.
+ * @param {!Node} parent The node that should contain the other node.
+ * @param {!Node} descendant The node to test presence of.
+ * @return {boolean} Whether the parent node contains the descendant node.
+ */
+Blockly.utils.dom.containsNode = function(parent, descendant) {
+  return !!(parent.compareDocumentPosition(descendant) &
+            Blockly.utils.dom.NodeType.DOCUMENT_POSITION_CONTAINED_BY);
+};
+
+/**
+ * Sets the CSS transform property on an element. This function sets the
+ * non-vendor-prefixed and vendor-prefixed versions for backwards compatibility
+ * with older browsers. See https://caniuse.com/#feat=transforms2d
+ * @param {!Element} element Element to which the CSS transform will be applied.
+ * @param {string} transform The value of the CSS `transform` property.
+ */
+Blockly.utils.dom.setCssTransform = function(element, transform) {
+  element.style['transform'] = transform;
+  element.style['-webkit-transform'] = transform;
+};
+
+/**
+ * Start caching text widths. Every call to this function MUST also call
+ * stopTextWidthCache. Caches must not survive between execution threads.
+ */
+Blockly.utils.dom.startTextWidthCache = function() {
+  Blockly.utils.dom.cacheReference_++;
+  if (!Blockly.utils.dom.cacheWidths_) {
+    Blockly.utils.dom.cacheWidths_ = {};
+  }
+};
+
+/**
+ * Stop caching field widths. Unless caching was already on when the
+ * corresponding call to startTextWidthCache was made.
+ */
+Blockly.utils.dom.stopTextWidthCache = function() {
+  Blockly.utils.dom.cacheReference_--;
+  if (!Blockly.utils.dom.cacheReference_) {
+    Blockly.utils.dom.cacheWidths_ = null;
+  }
+};
+
+/**
+ * Gets the width of a text element, caching it in the process.
+ * @param {!Element} textElement An SVG 'text' element.
+ * @return {number} Width of element.
+ */
+Blockly.utils.dom.getTextWidth = function(textElement) {
+  var key = textElement.textContent + '\n' + textElement.className.baseVal;
+  var width;
+
+  // Return the cached width if it exists.
+  if (Blockly.utils.dom.cacheWidths_) {
+    width = Blockly.utils.dom.cacheWidths_[key];
+    if (width) {
+      return width;
+    }
+  }
+
+  // Attempt to compute fetch the width of the SVG text element.
+  try {
+    if (Blockly.utils.userAgent.IE || Blockly.utils.userAgent.EDGE) {
+      width = textElement.getBBox().width;
+    } else {
+      width = textElement.getComputedTextLength();
+    }
+  } catch (e) {
+    // In other cases where we fail to get the computed text. Instead, use an
+    // approximation and do not cache the result. At some later point in time
+    // when the block is inserted into the visible DOM, this method will be
+    // called again and, at that point in time, will not throw an exception.
+    return textElement.textContent.length * 8;
+  }
+
+  // Cache the computed width and return.
+  if (Blockly.utils.dom.cacheWidths_) {
+    Blockly.utils.dom.cacheWidths_[key] = width;
+  }
+  return width;
+};
+
+/**
+ * Gets the width of a text element using a faster method than `getTextWidth`.
+ * This method requires that we know the text element's font family and size in
+ * advance. Similar to `getTextWidth`, we cache the width we compute.
+ * @param {!Element} textElement An SVG 'text' element.
+ * @param {number} fontSize The font size to use.
+ * @param {string} fontWeight The font weight to use.
+ * @param {string} fontFamily The font family to use.
+ * @return {number} Width of element.
+ */
+Blockly.utils.dom.getFastTextWidth = function(textElement,
+    fontSize, fontWeight, fontFamily) {
+  return Blockly.utils.dom.getFastTextWidthWithSizeString(textElement,
+      fontSize + 'pt', fontWeight, fontFamily);
+};
+
+/**
+ * Gets the width of a text element using a faster method than `getTextWidth`.
+ * This method requires that we know the text element's font family and size in
+ * advance. Similar to `getTextWidth`, we cache the width we compute.
+ * This method is similar to ``getFastTextWidth`` but expects the font size
+ * parameter to be a string.
+ * @param {!Element} textElement An SVG 'text' element.
+ * @param {string} fontSize The font size to use.
+ * @param {string} fontWeight The font weight to use.
+ * @param {string} fontFamily The font family to use.
+ * @return {number} Width of element.
+ */
+Blockly.utils.dom.getFastTextWidthWithSizeString = function(textElement,
+    fontSize, fontWeight, fontFamily) {
+  var text = textElement.textContent;
+  var key = text + '\n' + textElement.className.baseVal;
+  var width;
+
+  // Return the cached width if it exists.
+  if (Blockly.utils.dom.cacheWidths_) {
+    width = Blockly.utils.dom.cacheWidths_[key];
+    if (width) {
+      return width;
+    }
+  }
+
+  if (!Blockly.utils.dom.canvasContext_) {
+    // Inject the canvas element used for computing text widths.
+    var computeCanvas = document.createElement('canvas');
+    computeCanvas.className = 'blocklyComputeCanvas';
+    document.body.appendChild(computeCanvas);
+
+    // Initialize the HTML canvas context and set the font.
+    // The context font must match blocklyText's fontsize and font-family
+    // set in CSS.
+    Blockly.utils.dom.canvasContext_ = computeCanvas.getContext('2d');
+  }
+  // Set the desired font size and family.
+  Blockly.utils.dom.canvasContext_.font =
+      fontWeight + ' ' + fontSize + ' ' + fontFamily;
+
+  // Measure the text width using the helper canvas context.
+  width = Blockly.utils.dom.canvasContext_.measureText(text).width;
+
+  // Cache the computed width and return.
+  if (Blockly.utils.dom.cacheWidths_) {
+    Blockly.utils.dom.cacheWidths_[key] = width;
+  }
+  return width;
+};
+
+/**
+ * Measure a font's metrics. The height and baseline values.
+ * @param {string} text Text to measure the font dimensions of.
+ * @param {string} fontSize The font size to use.
+ * @param {string} fontWeight The font weight to use.
+ * @param {string} fontFamily The font family to use.
+ * @return {{height: number, baseline: number}} Font measurements.
+ */
+Blockly.utils.dom.measureFontMetrics = function(text, fontSize, fontWeight,
+    fontFamily) {
+
+  var span = document.createElement('span');
+  span.style.font = fontWeight + ' ' + fontSize + ' ' + fontFamily;
+  span.textContent = text;
+
+  var block = document.createElement('div');
+  block.style.width = '1px';
+  block.style.height = '0px';
+
+  var div = document.createElement('div');
+  div.setAttribute('style', 'position: fixed; top: 0; left: 0; display: flex;');
+  div.appendChild(span);
+  div.appendChild(block);
+
+  document.body.appendChild(div);
+  try {
+    var result = {};
+    div.style.alignItems = 'baseline';
+    result.baseline = block.offsetTop - span.offsetTop;
+    div.style.alignItems = 'flex-end';
+    result.height = block.offsetTop - span.offsetTop;
+  } finally {
+    document.body.removeChild(div);
+  }
+  return result;
+};

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

@@ -0,0 +1,37 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Provides a reference to the global object.
+ * @author samelh@google.com (Sam El-Husseini)
+ */
+'use strict';
+
+/**
+ * @name Blockly.utils.global
+ * @namespace
+ */
+goog.provide('Blockly.utils.global');
+
+
+/**
+ * Reference to the global object.
+ *
+ * More info on this implementation here:
+ * https://docs.google.com/document/d/1NAeW4Wk7I7FV0Y2tcUFvQdGMc89k2vdgSXInw8_nvCI/edit
+ */
+Blockly.utils.global = function() {
+  if (typeof self === 'object') {
+    return self;
+  }
+  if (typeof window === 'object') {
+    return window;
+  }
+  if (typeof global === 'object') {
+    return global;
+  }
+  return this;
+}();

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

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Generator for unique element IDs.
+ * For UUIDs use Blockly.utils.genUid. The ID generator should primarily be
+ * used for IDs that end up in the DOM.
+ * @author samelh@google.com (Sam El-Husseini)
+ */
+'use strict';
+
+goog.provide('Blockly.utils.IdGenerator');
+
+
+/**
+ * Next unique ID to use.
+ * @type {number}
+ * @private
+ */
+Blockly.utils.IdGenerator.nextId_ = 0;
+
+/**
+ * Gets the next unique ID.
+ * IDs are compatible with the HTML4 id attribute restrictions:
+ * Use only ASCII letters, digits, '_', '-' and '.'
+ * @return {string} The next unique identifier.
+ */
+Blockly.utils.IdGenerator.getNextUniqueId = function() {
+  return 'blockly-' + (Blockly.utils.IdGenerator.nextId_++).toString(36);
+};

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

@@ -0,0 +1,164 @@
+/**
+ * @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.KeyCodes');
+
+
+/**
+ * Key codes for common characters.
+ *
+ * Copied from Closure's goog.events.KeyCodes
+ *
+ * This list is not localized and therefore some of the key codes are not
+ * correct for non US keyboard layouts. See comments below.
+ *
+ * @enum {number}
+ */
+Blockly.utils.KeyCodes = {
+  WIN_KEY_FF_LINUX: 0,
+  MAC_ENTER: 3,
+  BACKSPACE: 8,
+  TAB: 9,
+  NUM_CENTER: 12,  // NUMLOCK on FF/Safari Mac
+  ENTER: 13,
+  SHIFT: 16,
+  CTRL: 17,
+  ALT: 18,
+  PAUSE: 19,
+  CAPS_LOCK: 20,
+  ESC: 27,
+  SPACE: 32,
+  PAGE_UP: 33,    // also NUM_NORTH_EAST
+  PAGE_DOWN: 34,  // also NUM_SOUTH_EAST
+  END: 35,        // also NUM_SOUTH_WEST
+  HOME: 36,       // also NUM_NORTH_WEST
+  LEFT: 37,       // also NUM_WEST
+  UP: 38,         // also NUM_NORTH
+  RIGHT: 39,      // also NUM_EAST
+  DOWN: 40,       // also NUM_SOUTH
+  PLUS_SIGN: 43,  // NOT numpad plus
+  PRINT_SCREEN: 44,
+  INSERT: 45,  // also NUM_INSERT
+  DELETE: 46,  // also NUM_DELETE
+  ZERO: 48,
+  ONE: 49,
+  TWO: 50,
+  THREE: 51,
+  FOUR: 52,
+  FIVE: 53,
+  SIX: 54,
+  SEVEN: 55,
+  EIGHT: 56,
+  NINE: 57,
+  FF_SEMICOLON: 59,  // Firefox (Gecko) fires this for semicolon instead of 186
+  FF_EQUALS: 61,     // Firefox (Gecko) fires this for equals instead of 187
+  FF_DASH: 173,      // Firefox (Gecko) fires this for dash instead of 189
+  // Firefox (Gecko) fires this for # on UK keyboards, rather than
+  // Shift+SINGLE_QUOTE.
+  FF_HASH: 163,
+  QUESTION_MARK: 63,  // needs localization
+  AT_SIGN: 64,
+  A: 65,
+  B: 66,
+  C: 67,
+  D: 68,
+  E: 69,
+  F: 70,
+  G: 71,
+  H: 72,
+  I: 73,
+  J: 74,
+  K: 75,
+  L: 76,
+  M: 77,
+  N: 78,
+  O: 79,
+  P: 80,
+  Q: 81,
+  R: 82,
+  S: 83,
+  T: 84,
+  U: 85,
+  V: 86,
+  W: 87,
+  X: 88,
+  Y: 89,
+  Z: 90,
+  META: 91,  // WIN_KEY_LEFT
+  WIN_KEY_RIGHT: 92,
+  CONTEXT_MENU: 93,
+  NUM_ZERO: 96,
+  NUM_ONE: 97,
+  NUM_TWO: 98,
+  NUM_THREE: 99,
+  NUM_FOUR: 100,
+  NUM_FIVE: 101,
+  NUM_SIX: 102,
+  NUM_SEVEN: 103,
+  NUM_EIGHT: 104,
+  NUM_NINE: 105,
+  NUM_MULTIPLY: 106,
+  NUM_PLUS: 107,
+  NUM_MINUS: 109,
+  NUM_PERIOD: 110,
+  NUM_DIVISION: 111,
+  F1: 112,
+  F2: 113,
+  F3: 114,
+  F4: 115,
+  F5: 116,
+  F6: 117,
+  F7: 118,
+  F8: 119,
+  F9: 120,
+  F10: 121,
+  F11: 122,
+  F12: 123,
+  NUMLOCK: 144,
+  SCROLL_LOCK: 145,
+
+  // OS-specific media keys like volume controls and browser controls.
+  FIRST_MEDIA_KEY: 166,
+  LAST_MEDIA_KEY: 183,
+
+  SEMICOLON: 186,             // needs localization
+  DASH: 189,                  // needs localization
+  EQUALS: 187,                // needs localization
+  COMMA: 188,                 // needs localization
+  PERIOD: 190,                // needs localization
+  SLASH: 191,                 // needs localization
+  APOSTROPHE: 192,            // needs localization
+  TILDE: 192,                 // needs localization
+  SINGLE_QUOTE: 222,          // needs localization
+  OPEN_SQUARE_BRACKET: 219,   // needs localization
+  BACKSLASH: 220,             // needs localization
+  CLOSE_SQUARE_BRACKET: 221,  // needs localization
+  WIN_KEY: 224,
+  MAC_FF_META:
+      224,  // Firefox (Gecko) fires this for the meta key instead of 91
+  MAC_WK_CMD_LEFT: 91,   // WebKit Left Command key fired, same as META
+  MAC_WK_CMD_RIGHT: 93,  // WebKit Right Command key fired, different from META
+  WIN_IME: 229,
+
+  // "Reserved for future use". Some programs (e.g. the SlingPlayer 2.4 ActiveX
+  // control) fire this as a hacky way to disable screensavers.
+  VK_NONAME: 252,
+
+  // We've seen users whose machines fire this keycode at regular one
+  // second intervals. The common thread among these users is that
+  // they're all using Dell Inspiron laptops, so we suspect that this
+  // indicates a hardware/bios problem.
+  // http://en.community.dell.com/support-forums/laptop/f/3518/p/19285957/19523128.aspx
+  PHANTOM: 255
+};

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

@@ -0,0 +1,56 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Utility methods for math.
+ * 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.math
+ * @namespace
+ */
+goog.provide('Blockly.utils.math');
+
+
+/**
+ * Converts degrees to radians.
+ * Copied from Closure's goog.math.toRadians.
+ * @param {number} angleDegrees Angle in degrees.
+ * @return {number} Angle in radians.
+ */
+Blockly.utils.math.toRadians = function(angleDegrees) {
+  return angleDegrees * Math.PI / 180;
+};
+
+/**
+ * Converts radians to degrees.
+ * Copied from Closure's goog.math.toDegrees.
+ * @param {number} angleRadians Angle in radians.
+ * @return {number} Angle in degrees.
+ */
+Blockly.utils.math.toDegrees = function(angleRadians) {
+  return angleRadians * 180 / Math.PI;
+};
+
+/**
+ * Clamp the provided number between the lower bound and the upper bound.
+ * @param {number} lowerBound The desired lower bound.
+ * @param {number} number The number to clamp.
+ * @param {number} upperBound The desired upper bound.
+ * @return {number} The clamped number.
+ */
+Blockly.utils.math.clamp = function(lowerBound, number, upperBound) {
+  if (upperBound < lowerBound) {
+    var temp = upperBound;
+    upperBound = lowerBound;
+    lowerBound = temp;
+  }
+  return Math.max(lowerBound, Math.min(number, upperBound));
+};