nodeskini 1.0.1 → 1.0.2

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

@@ -0,0 +1,124 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Workspace metrics definitions.
+ * @author samelh@google.com (Sam El-Husseini)
+ */
+'use strict';
+
+goog.provide('Blockly.utils.Metrics');
+
+
+/**
+ * @record
+ */
+Blockly.utils.Metrics = function() {};
+
+/**
+ * Height of the visible portion of the workspace.
+ * @type {number}
+ */
+Blockly.utils.Metrics.prototype.viewHeight;
+
+/**
+ * Width of the visible portion of the workspace.
+ * @type {number}
+ */
+Blockly.utils.Metrics.prototype.viewWidth;
+
+/**
+ * Height of the content.
+ * @type {number}
+ */
+Blockly.utils.Metrics.prototype.contentHeight;
+
+/**
+ * Width of the content.
+ * @type {number}
+ */
+Blockly.utils.Metrics.prototype.contentWidth;
+
+/**
+ * Top-edge of the visible portion of the workspace, relative to the workspace
+ * origin.
+ * @type {number}
+ */
+Blockly.utils.Metrics.prototype.viewTop;
+
+/**
+ * Left-edge of the visible portion of the workspace, relative to the workspace
+ * origin.
+ * @type {number}
+ */
+Blockly.utils.Metrics.prototype.viewLeft;
+
+/**
+ * Top-edge of the content, relative to the workspace origin.
+ * @type {number}
+ */
+Blockly.utils.Metrics.prototype.contentTop;
+
+/**
+ * Left-edge of the content relative to the workspace origin.
+ * @type {number}
+ */
+Blockly.utils.Metrics.prototype.contentLeft;
+
+/**
+ * Top-edge of the visible portion of the workspace, relative to the blocklyDiv.
+ * @type {number}
+ */
+Blockly.utils.Metrics.prototype.absoluteTop;
+
+/**
+ * Left-edge of the visible portion of the workspace, relative to the
+ * blocklyDiv.
+ * @type {number}
+ */
+Blockly.utils.Metrics.prototype.absoluteLeft;
+
+/**
+ * Height of the Blockly div (the view + the toolbox, simple of otherwise).
+ * @type {number|undefined}
+ */
+Blockly.utils.Metrics.prototype.svgHeight;
+
+/**
+ * Width of the Blockly div (the view + the toolbox, simple or otherwise).
+ * @type {number|undefined}
+ */
+Blockly.utils.Metrics.prototype.svgWidth;
+
+/**
+ * Width of the toolbox, if it exists.  Otherwise zero.
+ * @type {number|undefined}
+ */
+Blockly.utils.Metrics.prototype.toolboxWidth;
+
+/**
+ * Height of the toolbox, if it exists.  Otherwise zero.
+ * @type {number|undefined}
+ */
+Blockly.utils.Metrics.prototype.toolboxHeight;
+
+/**
+ * Top, bottom, left or right. Use TOOLBOX_AT constants to compare.
+ * @type {number|undefined}
+ */
+Blockly.utils.Metrics.prototype.toolboxPosition;
+
+/**
+ * Width of the flyout if it is always open.  Otherwise zero.
+ * @type {number|undefined}
+ */
+Blockly.utils.Metrics.prototype.flyoutWidth;
+
+/**
+ * Height of the flyout if it is always open.  Otherwise zero.
+ * @type {number|undefined}
+ */
+Blockly.utils.Metrics.prototype.flyoutHeight;

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

@@ -0,0 +1,73 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Utility methods for objects.
+ * @author samelh@google.com (Sam El-Husseini)
+ */
+'use strict';
+
+goog.provide('Blockly.utils.object');
+
+
+/**
+ * Inherit the prototype methods from one constructor into another.
+ *
+ * @param {!Function} childCtor Child class.
+ * @param {!Function} parentCtor Parent class.
+ * @suppress {strictMissingProperties} superClass_ is not defined on Function.
+ */
+Blockly.utils.object.inherits = function(childCtor, parentCtor) {
+  childCtor.superClass_ = parentCtor.prototype;
+  childCtor.prototype = Object.create(parentCtor.prototype);
+  childCtor.prototype.constructor = childCtor;
+};
+
+/**
+ * Copies all the members of a source object to a target object.
+ * @param {!Object} target Target.
+ * @param {!Object} source Source.
+ */
+Blockly.utils.object.mixin = function(target, source) {
+  for (var x in source) {
+    target[x] = source[x];
+  }
+};
+
+/**
+ * Complete a deep merge of all members of a source object with a target object.
+ * @param {!Object} target Target.
+ * @param {!Object} source Source.
+ * @return {!Object} The resulting object.
+ */
+Blockly.utils.object.deepMerge = function(target, source) {
+  for (var x in source) {
+    if (source[x] != null && typeof source[x] === 'object') {
+      target[x] = Blockly.utils.object.deepMerge(
+          target[x] || Object.create(null), source[x]);
+    } else {
+      target[x] = source[x];
+    }
+  }
+  return target;
+};
+
+/**
+ * Returns an array of a given object's own enumerable property values.
+ * @param {!Object} obj Object containing values.
+ * @return {!Array} Array of values.
+ */
+Blockly.utils.object.values = function(obj) {
+  if (Object.values) {
+    /* eslint-disable es5/no-es6-methods */
+    return Object.values(obj);
+    /* eslint-enable es5/no-es6-methods */
+  }
+  // Fallback for IE.
+  return Object.keys(obj).map(function(e) {
+    return obj[e];
+  });
+};

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

@@ -0,0 +1,54 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Utility methods for rectangle 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.Rect
+ * @namespace
+ */
+goog.provide('Blockly.utils.Rect');
+
+
+/**
+ * Class for representing rectangular regions.
+ * @param {number} top Top.
+ * @param {number} bottom Bottom.
+ * @param {number} left Left.
+ * @param {number} right Right.
+ * @struct
+ * @constructor
+ */
+Blockly.utils.Rect = function(top, bottom, left, right) {
+  /** @type {number} */
+  this.top = top;
+
+  /** @type {number} */
+  this.bottom = bottom;
+
+  /** @type {number} */
+  this.left = left;
+
+  /** @type {number} */
+  this.right = right;
+};
+
+/**
+ * Tests whether this rectangle contains a x/y coordinate.
+ *
+ * @param {number} x The x coordinate to test for containment.
+ * @param {number} y The y coordinate to test for containment.
+ * @return {boolean} Whether this rectangle contains given coordinate.
+ */
+Blockly.utils.Rect.prototype.contains = function(x, y) {
+  return x >= this.left && x <= this.right && y >= this.top && y <= this.bottom;
+};

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

@@ -0,0 +1,58 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Utility methods for size calculation.
+ * 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';
+
+/**
+ * @name Blockly.utils.Size
+ * @namespace
+ */
+goog.provide('Blockly.utils.Size');
+
+
+/**
+ * Class for representing sizes consisting of a width and height.
+ * @param {number} width Width.
+ * @param {number} height Height.
+ * @struct
+ * @constructor
+ */
+Blockly.utils.Size = function(width, height) {
+  /**
+   * Width
+   * @type {number}
+   */
+  this.width = width;
+
+  /**
+   * Height
+   * @type {number}
+   */
+  this.height = height;
+};
+
+/**
+ * Compares sizes for equality.
+ * @param {Blockly.utils.Size} a A Size.
+ * @param {Blockly.utils.Size} b A Size.
+ * @return {boolean} True iff the sizes have equal widths and equal
+ *     heights, or if both are null.
+ */
+Blockly.utils.Size.equals = function(a, b) {
+  if (a == b) {
+    return true;
+  }
+  if (!a || !b) {
+    return false;
+  }
+  return a.width == b.width && a.height == b.height;
+};

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

@@ -0,0 +1,284 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Utility methods for string 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.string
+ * @namespace
+ */
+goog.provide('Blockly.utils.string');
+
+
+/**
+ * Fast prefix-checker.
+ * Copied from Closure's goog.string.startsWith.
+ * @param {string} str The string to check.
+ * @param {string} prefix A string to look for at the start of `str`.
+ * @return {boolean} True if `str` begins with `prefix`.
+ */
+Blockly.utils.string.startsWith = function(str, prefix) {
+  return str.lastIndexOf(prefix, 0) == 0;
+};
+
+/**
+ * Given an array of strings, return the length of the shortest one.
+ * @param {!Array.<string>} array Array of strings.
+ * @return {number} Length of shortest string.
+ */
+Blockly.utils.string.shortestStringLength = function(array) {
+  if (!array.length) {
+    return 0;
+  }
+  return array.reduce(function(a, b) {
+    return a.length < b.length ? a : b;
+  }).length;
+};
+
+/**
+ * Given an array of strings, return the length of the common prefix.
+ * Words may not be split.  Any space after a word is included in the length.
+ * @param {!Array.<string>} array Array of strings.
+ * @param {number=} opt_shortest Length of shortest string.
+ * @return {number} Length of common prefix.
+ */
+Blockly.utils.string.commonWordPrefix = function(array, opt_shortest) {
+  if (!array.length) {
+    return 0;
+  } else if (array.length == 1) {
+    return array[0].length;
+  }
+  var wordPrefix = 0;
+  var max = opt_shortest || Blockly.utils.string.shortestStringLength(array);
+  for (var len = 0; len < max; len++) {
+    var letter = array[0][len];
+    for (var i = 1; i < array.length; i++) {
+      if (letter != array[i][len]) {
+        return wordPrefix;
+      }
+    }
+    if (letter == ' ') {
+      wordPrefix = len + 1;
+    }
+  }
+  for (var i = 1; i < array.length; i++) {
+    var letter = array[i][len];
+    if (letter && letter != ' ') {
+      return wordPrefix;
+    }
+  }
+  return max;
+};
+
+/**
+ * Given an array of strings, return the length of the common suffix.
+ * Words may not be split.  Any space after a word is included in the length.
+ * @param {!Array.<string>} array Array of strings.
+ * @param {number=} opt_shortest Length of shortest string.
+ * @return {number} Length of common suffix.
+ */
+Blockly.utils.string.commonWordSuffix = function(array, opt_shortest) {
+  if (!array.length) {
+    return 0;
+  } else if (array.length == 1) {
+    return array[0].length;
+  }
+  var wordPrefix = 0;
+  var max = opt_shortest || Blockly.utils.string.shortestStringLength(array);
+  for (var len = 0; len < max; len++) {
+    var letter = array[0].substr(-len - 1, 1);
+    for (var i = 1; i < array.length; i++) {
+      if (letter != array[i].substr(-len - 1, 1)) {
+        return wordPrefix;
+      }
+    }
+    if (letter == ' ') {
+      wordPrefix = len + 1;
+    }
+  }
+  for (var i = 1; i < array.length; i++) {
+    var letter = array[i].charAt(array[i].length - len - 1);
+    if (letter && letter != ' ') {
+      return wordPrefix;
+    }
+  }
+  return max;
+};
+
+/**
+ * Wrap text to the specified width.
+ * @param {string} text Text to wrap.
+ * @param {number} limit Width to wrap each line.
+ * @return {string} Wrapped text.
+ */
+Blockly.utils.string.wrap = function(text, limit) {
+  var lines = text.split('\n');
+  for (var i = 0; i < lines.length; i++) {
+    lines[i] = Blockly.utils.string.wrapLine_(lines[i], limit);
+  }
+  return lines.join('\n');
+};
+
+/**
+ * Wrap single line of text to the specified width.
+ * @param {string} text Text to wrap.
+ * @param {number} limit Width to wrap each line.
+ * @return {string} Wrapped text.
+ * @private
+ */
+Blockly.utils.string.wrapLine_ = function(text, limit) {
+  if (text.length <= limit) {
+    // Short text, no need to wrap.
+    return text;
+  }
+  // Split the text into words.
+  var words = text.trim().split(/\s+/);
+  // Set limit to be the length of the largest word.
+  for (var i = 0; i < words.length; i++) {
+    if (words[i].length > limit) {
+      limit = words[i].length;
+    }
+  }
+
+  var lastScore;
+  var score = -Infinity;
+  var lastText;
+  var lineCount = 1;
+  do {
+    lastScore = score;
+    lastText = text;
+    // Create a list of booleans representing if a space (false) or
+    // a break (true) appears after each word.
+    var wordBreaks = [];
+    // Seed the list with evenly spaced linebreaks.
+    var steps = words.length / lineCount;
+    var insertedBreaks = 1;
+    for (var i = 0; i < words.length - 1; i++) {
+      if (insertedBreaks < (i + 1.5) / steps) {
+        insertedBreaks++;
+        wordBreaks[i] = true;
+      } else {
+        wordBreaks[i] = false;
+      }
+    }
+    wordBreaks = Blockly.utils.string.wrapMutate_(words, wordBreaks, limit);
+    score = Blockly.utils.string.wrapScore_(words, wordBreaks, limit);
+    text = Blockly.utils.string.wrapToText_(words, wordBreaks);
+    lineCount++;
+  } while (score > lastScore);
+  return lastText;
+};
+
+/**
+ * Compute a score for how good the wrapping is.
+ * @param {!Array.<string>} words Array of each word.
+ * @param {!Array.<boolean>} wordBreaks Array of line breaks.
+ * @param {number} limit Width to wrap each line.
+ * @return {number} Larger the better.
+ * @private
+ */
+Blockly.utils.string.wrapScore_ = function(words, wordBreaks, limit) {
+  // If this function becomes a performance liability, add caching.
+  // Compute the length of each line.
+  var lineLengths = [0];
+  var linePunctuation = [];
+  for (var i = 0; i < words.length; i++) {
+    lineLengths[lineLengths.length - 1] += words[i].length;
+    if (wordBreaks[i] === true) {
+      lineLengths.push(0);
+      linePunctuation.push(words[i].charAt(words[i].length - 1));
+    } else if (wordBreaks[i] === false) {
+      lineLengths[lineLengths.length - 1]++;
+    }
+  }
+  var maxLength = Math.max.apply(Math, lineLengths);
+
+  var score = 0;
+  for (var i = 0; i < lineLengths.length; i++) {
+    // Optimize for width.
+    // -2 points per char over limit (scaled to the power of 1.5).
+    score -= Math.pow(Math.abs(limit - lineLengths[i]), 1.5) * 2;
+    // Optimize for even lines.
+    // -1 point per char smaller than max (scaled to the power of 1.5).
+    score -= Math.pow(maxLength - lineLengths[i], 1.5);
+    // Optimize for structure.
+    // Add score to line endings after punctuation.
+    if ('.?!'.indexOf(linePunctuation[i]) != -1) {
+      score += limit / 3;
+    } else if (',;)]}'.indexOf(linePunctuation[i]) != -1) {
+      score += limit / 4;
+    }
+  }
+  // All else being equal, the last line should not be longer than the
+  // previous line.  For example, this looks wrong:
+  // aaa bbb
+  // ccc ddd eee
+  if (lineLengths.length > 1 && lineLengths[lineLengths.length - 1] <=
+      lineLengths[lineLengths.length - 2]) {
+    score += 0.5;
+  }
+  return score;
+};
+
+/**
+ * Mutate the array of line break locations until an optimal solution is found.
+ * No line breaks are added or deleted, they are simply moved around.
+ * @param {!Array.<string>} words Array of each word.
+ * @param {!Array.<boolean>} wordBreaks Array of line breaks.
+ * @param {number} limit Width to wrap each line.
+ * @return {!Array.<boolean>} New array of optimal line breaks.
+ * @private
+ */
+Blockly.utils.string.wrapMutate_ = function(words, wordBreaks, limit) {
+  var bestScore = Blockly.utils.string.wrapScore_(words, wordBreaks, limit);
+  var bestBreaks;
+  // Try shifting every line break forward or backward.
+  for (var i = 0; i < wordBreaks.length - 1; i++) {
+    if (wordBreaks[i] == wordBreaks[i + 1]) {
+      continue;
+    }
+    var mutatedWordBreaks = [].concat(wordBreaks);
+    mutatedWordBreaks[i] = !mutatedWordBreaks[i];
+    mutatedWordBreaks[i + 1] = !mutatedWordBreaks[i + 1];
+    var mutatedScore =
+        Blockly.utils.string.wrapScore_(words, mutatedWordBreaks, limit);
+    if (mutatedScore > bestScore) {
+      bestScore = mutatedScore;
+      bestBreaks = mutatedWordBreaks;
+    }
+  }
+  if (bestBreaks) {
+    // Found an improvement.  See if it may be improved further.
+    return Blockly.utils.string.wrapMutate_(words, bestBreaks, limit);
+  }
+  // No improvements found.  Done.
+  return wordBreaks;
+};
+
+/**
+ * Reassemble the array of words into text, with the specified line breaks.
+ * @param {!Array.<string>} words Array of each word.
+ * @param {!Array.<boolean>} wordBreaks Array of line breaks.
+ * @return {string} Plain text.
+ * @private
+ */
+Blockly.utils.string.wrapToText_ = function(words, wordBreaks) {
+  var text = [];
+  for (var i = 0; i < words.length; i++) {
+    text.push(words[i]);
+    if (wordBreaks[i] !== undefined) {
+      text.push(wordBreaks[i] ? '\n' : ' ');
+    }
+  }
+  return text.join('');
+};
+