scratch-blocks 1.1.206 → 2.0.0-beta.1

package/blockly-rc/core/utils/string.ts

@@ -0,0 +1,289 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// Former goog.module ID: Blockly.utils.string
+
+/**
+ * Given an array of strings, return the length of the shortest one.
+ *
+ * @param array Array of strings.
+ * @returns Length of shortest string.
+ */
+export function shortestStringLength(array: string[]): number {
+  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 Array of strings.
+ * @param opt_shortest Length of shortest string.
+ * @returns Length of common prefix.
+ */
+export function commonWordPrefix(
+  array: string[],
+  opt_shortest?: number,
+): number {
+  if (!array.length) {
+    return 0;
+  } else if (array.length === 1) {
+    return array[0].length;
+  }
+  let wordPrefix = 0;
+  const max = opt_shortest || shortestStringLength(array);
+  let len;
+  for (len = 0; len < max; len++) {
+    const letter = array[0][len];
+    for (let i = 1; i < array.length; i++) {
+      if (letter !== array[i][len]) {
+        return wordPrefix;
+      }
+    }
+    if (letter === ' ') {
+      wordPrefix = len + 1;
+    }
+  }
+  for (let i = 1; i < array.length; i++) {
+    const 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 Array of strings.
+ * @param opt_shortest Length of shortest string.
+ * @returns Length of common suffix.
+ */
+export function commonWordSuffix(
+  array: string[],
+  opt_shortest?: number,
+): number {
+  if (!array.length) {
+    return 0;
+  } else if (array.length === 1) {
+    return array[0].length;
+  }
+  let wordPrefix = 0;
+  const max = opt_shortest || shortestStringLength(array);
+  let len;
+  for (len = 0; len < max; len++) {
+    const letter = array[0].substr(-len - 1, 1);
+    for (let i = 1; i < array.length; i++) {
+      if (letter !== array[i].substr(-len - 1, 1)) {
+        return wordPrefix;
+      }
+    }
+    if (letter === ' ') {
+      wordPrefix = len + 1;
+    }
+  }
+  for (let i = 1; i < array.length; i++) {
+    const letter = array[i].charAt(array[i].length - len - 1);
+    if (letter && letter !== ' ') {
+      return wordPrefix;
+    }
+  }
+  return max;
+}
+
+/**
+ * Wrap text to the specified width.
+ *
+ * @param text Text to wrap.
+ * @param limit Width to wrap each line.
+ * @returns Wrapped text.
+ */
+export function wrap(text: string, limit: number): string {
+  const lines = text.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    lines[i] = wrapLine(lines[i], limit);
+  }
+  return lines.join('\n');
+}
+
+/**
+ * Wrap single line of text to the specified width.
+ *
+ * @param text Text to wrap.
+ * @param limit Width to wrap each line.
+ * @returns Wrapped text.
+ */
+function wrapLine(text: string, limit: number): string {
+  if (text.length <= limit) {
+    // Short text, no need to wrap.
+    return text;
+  }
+  // Split the text into words.
+  const words = text.trim().split(/\s+/);
+  // Set limit to be the length of the largest word.
+  for (let i = 0; i < words.length; i++) {
+    if (words[i].length > limit) {
+      limit = words[i].length;
+    }
+  }
+
+  let lastScore;
+  let score = -Infinity;
+  let lastText;
+  let 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.
+    let wordBreaks = [];
+    // Seed the list with evenly spaced linebreaks.
+    const steps = words.length / lineCount;
+    let insertedBreaks = 1;
+    for (let i = 0; i < words.length - 1; i++) {
+      if (insertedBreaks < (i + 1.5) / steps) {
+        insertedBreaks++;
+        wordBreaks[i] = true;
+      } else {
+        wordBreaks[i] = false;
+      }
+    }
+    wordBreaks = wrapMutate(words, wordBreaks, limit);
+    score = wrapScore(words, wordBreaks, limit);
+    text = wrapToText(words, wordBreaks);
+    lineCount++;
+  } while (score > lastScore);
+  return lastText;
+}
+
+/**
+ * Compute a score for how good the wrapping is.
+ *
+ * @param words Array of each word.
+ * @param wordBreaks Array of line breaks.
+ * @param limit Width to wrap each line.
+ * @returns Larger the better.
+ */
+function wrapScore(
+  words: string[],
+  wordBreaks: boolean[],
+  limit: number,
+): number {
+  // If this function becomes a performance liability, add caching.
+  // Compute the length of each line.
+  const lineLengths = [0];
+  const linePunctuation = [];
+  for (let 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]++;
+    }
+  }
+  const maxLength = Math.max(...lineLengths);
+
+  let score = 0;
+  for (let 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 ('.?!'.includes(linePunctuation[i])) {
+      score += limit / 3;
+    } else if (',;)]}'.includes(linePunctuation[i])) {
+      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 words Array of each word.
+ * @param wordBreaks Array of line breaks.
+ * @param limit Width to wrap each line.
+ * @returns New array of optimal line breaks.
+ */
+function wrapMutate(
+  words: string[],
+  wordBreaks: boolean[],
+  limit: number,
+): boolean[] {
+  let bestScore = wrapScore(words, wordBreaks, limit);
+  let bestBreaks;
+  // Try shifting every line break forward or backward.
+  for (let i = 0; i < wordBreaks.length - 1; i++) {
+    if (wordBreaks[i] === wordBreaks[i + 1]) {
+      continue;
+    }
+    const mutatedWordBreaks = new Array<boolean>().concat(wordBreaks);
+    mutatedWordBreaks[i] = !mutatedWordBreaks[i];
+    mutatedWordBreaks[i + 1] = !mutatedWordBreaks[i + 1];
+    const mutatedScore = wrapScore(words, mutatedWordBreaks, limit);
+    if (mutatedScore > bestScore) {
+      bestScore = mutatedScore;
+      bestBreaks = mutatedWordBreaks;
+    }
+  }
+  if (bestBreaks) {
+    // Found an improvement.  See if it may be improved further.
+    return wrapMutate(words, bestBreaks, limit);
+  }
+  // No improvements found.  Done.
+  return wordBreaks;
+}
+
+/**
+ * Reassemble the array of words into text, with the specified line breaks.
+ *
+ * @param words Array of each word.
+ * @param wordBreaks Array of line breaks.
+ * @returns Plain text.
+ */
+function wrapToText(words: string[], wordBreaks: boolean[]): string {
+  const text = [];
+  for (let i = 0; i < words.length; i++) {
+    text.push(words[i]);
+    if (wordBreaks[i] !== undefined) {
+      text.push(wordBreaks[i] ? '\n' : ' ');
+    }
+  }
+  return text.join('');
+}
+
+/**
+ * Is the given string a number (includes negative and decimals).
+ *
+ * @param str Input string.
+ * @returns True if number, false otherwise.
+ */
+export function isNumber(str: string): boolean {
+  return /^\s*-?\d+(\.\d+)?\s*$/.test(str);
+}

package/blockly-rc/core/utils/style.ts

@@ -0,0 +1,219 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// Former goog.module ID: Blockly.utils.style
+
+import {Coordinate} from './coordinate.js';
+import {Rect} from './rect.js';
+import {Size} from './size.js';
+
+/**
+ * Gets the height and width of an element.
+ * Similar to Closure's goog.style.getSize
+ *
+ * @param element Element to get size of.
+ * @returns Object with width/height properties.
+ */
+export function getSize(element: Element): Size {
+  return TEST_ONLY.getSizeInternal(element);
+}
+
+/**
+ * Private version of getSize for stubbing in tests.
+ */
+function getSizeInternal(element: Element): Size {
+  if (getComputedStyle(element, 'display') !== 'none') {
+    return getSizeWithDisplay(element);
+  }
+
+  // Evaluate size with a temporary element.
+  // AnyDuringMigration because:  Property 'style' does not exist on type
+  // 'Element'.
+  const style = (element as AnyDuringMigration).style;
+  const originalDisplay = style.display;
+  const originalVisibility = style.visibility;
+  const originalPosition = style.position;
+
+  style.visibility = 'hidden';
+  style.position = 'absolute';
+  style.display = 'inline';
+
+  const offsetWidth = (element as HTMLElement).offsetWidth;
+  const offsetHeight = (element as HTMLElement).offsetHeight;
+
+  style.display = originalDisplay;
+  style.position = originalPosition;
+  style.visibility = originalVisibility;
+
+  return new Size(offsetWidth, offsetHeight);
+}
+
+/**
+ * Gets the height and width of an element when the display is not none.
+ *
+ * @param element Element to get size of.
+ * @returns Object with width/height properties.
+ */
+function getSizeWithDisplay(element: Element): Size {
+  const offsetWidth = (element as HTMLElement).offsetWidth;
+  const offsetHeight = (element as HTMLElement).offsetHeight;
+  return new Size(offsetWidth, offsetHeight);
+}
+
+/**
+ * Retrieves a computed style value of a node. It returns empty string
+ * if the property requested is an SVG one and it has not been
+ * explicitly set (firefox and webkit).
+ *
+ * Copied from Closure's goog.style.getComputedStyle
+ *
+ * @param element Element to get style of.
+ * @param property Property to get (camel-case).
+ * @returns Style value.
+ */
+export function getComputedStyle(element: Element, property: string): string {
+  const styles = window.getComputedStyle(element);
+  // element.style[..] is undefined for browser specific styles
+  // as 'filter'.
+  return (
+    (styles as AnyDuringMigration)[property] ||
+    styles.getPropertyValue(property)
+  );
+}
+
+/**
+ * Returns a Coordinate object relative to the top-left of the HTML document.
+ * Similar to Closure's goog.style.getPageOffset
+ *
+ * @param el Element to get the page offset for.
+ * @returns The page offset.
+ */
+export function getPageOffset(el: Element): Coordinate {
+  const pos = new Coordinate(0, 0);
+  const box = el.getBoundingClientRect();
+  const documentElement = document.documentElement;
+  // Must add the scroll coordinates in to get the absolute page offset
+  // of element since getBoundingClientRect returns relative coordinates to
+  // the viewport.
+  const scrollCoord = new Coordinate(
+    window.pageXOffset || documentElement.scrollLeft,
+    window.pageYOffset || documentElement.scrollTop,
+  );
+  pos.x = box.left + scrollCoord.x;
+  pos.y = box.top + scrollCoord.y;
+
+  return pos;
+}
+
+/**
+ * Calculates the viewport coordinates relative to the document.
+ * Similar to Closure's goog.style.getViewportPageOffset
+ *
+ * @returns The page offset of the viewport.
+ */
+export function getViewportPageOffset(): Coordinate {
+  const body = document.body;
+  const documentElement = document.documentElement;
+  const scrollLeft = body.scrollLeft || documentElement.scrollLeft;
+  const scrollTop = body.scrollTop || documentElement.scrollTop;
+  return new Coordinate(scrollLeft, scrollTop);
+}
+
+/**
+ * Gets the computed border widths (on all sides) in pixels
+ * Copied from Closure's goog.style.getBorderBox
+ *
+ * @param element  The element to get the border widths for.
+ * @returns The computed border widths.
+ */
+export function getBorderBox(element: Element): Rect {
+  const left = parseFloat(getComputedStyle(element, 'borderLeftWidth'));
+  const right = parseFloat(getComputedStyle(element, 'borderRightWidth'));
+  const top = parseFloat(getComputedStyle(element, 'borderTopWidth'));
+  const bottom = parseFloat(getComputedStyle(element, 'borderBottomWidth'));
+
+  return new Rect(top, bottom, left, right);
+}
+
+/**
+ * Changes the scroll position of `container` with the minimum amount so
+ * that the content and the borders of the given `element` become visible.
+ * If the element is bigger than the container, its top left corner will be
+ * aligned as close to the container's top left corner as possible.
+ * Copied from Closure's goog.style.scrollIntoContainerView
+ *
+ * @param element The element to make visible.
+ * @param container The container to scroll. If not set, then the document
+ *     scroll element will be used.
+ * @param opt_center Whether to center the element in the container.
+ *     Defaults to false.
+ */
+export function scrollIntoContainerView(
+  element: Element,
+  container: Element,
+  opt_center?: boolean,
+) {
+  const offset = getContainerOffsetToScrollInto(element, container, opt_center);
+  container.scrollLeft = offset.x;
+  container.scrollTop = offset.y;
+}
+
+/**
+ * Calculate the scroll position of `container` with the minimum amount so
+ * that the content and the borders of the given `element` become visible.
+ * If the element is bigger than the container, its top left corner will be
+ * aligned as close to the container's top left corner as possible.
+ * Copied from Closure's goog.style.getContainerOffsetToScrollInto
+ *
+ * @param element The element to make visible.
+ * @param container The container to scroll. If not set, then the document
+ *     scroll element will be used.
+ * @param opt_center Whether to center the element in the container.
+ *     Defaults to false.
+ * @returns The new scroll position of the container.
+ */
+export function getContainerOffsetToScrollInto(
+  element: Element,
+  container: Element,
+  opt_center?: boolean,
+): Coordinate {
+  // Absolute position of the element's border's top left corner.
+  const elementPos = getPageOffset(element);
+  // Absolute position of the container's border's top left corner.
+  const containerPos = getPageOffset(container);
+  const containerBorder = getBorderBox(container);
+  // Relative pos. of the element's border box to the container's content box.
+  const relX = elementPos.x - containerPos.x - containerBorder.left;
+  const relY = elementPos.y - containerPos.y - containerBorder.top;
+  // How much the element can move in the container, i.e. the difference between
+  // the element's bottom-right-most and top-left-most position where it's
+  // fully visible.
+  const elementSize = getSizeWithDisplay(element);
+  const spaceX = container.clientWidth - elementSize.width;
+  const spaceY = container.clientHeight - elementSize.height;
+  let scrollLeft = container.scrollLeft;
+  let scrollTop = container.scrollTop;
+  if (opt_center) {
+    // All browsers round non-integer scroll positions down.
+    scrollLeft += relX - spaceX / 2;
+    scrollTop += relY - spaceY / 2;
+  } else {
+    // This formula was designed to give the correct scroll values in the
+    // following cases:
+    // - element is higher than container (spaceY < 0) => scroll down by relY
+    // - element is not higher that container (spaceY >= 0):
+    //   - it is above container (relY < 0) => scroll up by abs(relY)
+    //   - it is below container (relY > spaceY) => scroll down by relY - spaceY
+    //   - it is in the container => don't scroll
+    scrollLeft += Math.min(relX, Math.max(relX - spaceX, 0));
+    scrollTop += Math.min(relY, Math.max(relY - spaceY, 0));
+  }
+  return new Coordinate(scrollLeft, scrollTop);
+}
+
+export const TEST_ONLY = {
+  getSizeInternal,
+};

package/blockly-rc/core/utils/svg.ts

@@ -0,0 +1,84 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Defines the Svg class. Its constants enumerate
+ * all SVG tag names used by Blockly.
+ *
+ * @class
+ */
+// Former goog.module ID: Blockly.utils.Svg
+
+/**
+ * A name with the type of the SVG element stored in the generic.
+ */
+export class Svg<_T> {
+  /** @internal */
+  static ANIMATE = new Svg<SVGAnimateElement>('animate');
+  /** @internal */
+  static CIRCLE = new Svg<SVGCircleElement>('circle');
+  /** @internal */
+  static CLIPPATH = new Svg<SVGClipPathElement>('clipPath');
+  /** @internal */
+  static DEFS = new Svg<SVGDefsElement>('defs');
+  /** @internal */
+  static FECOMPOSITE = new Svg<SVGFECompositeElement>('feComposite');
+  /** @internal */
+  static FECOMPONENTTRANSFER = new Svg<SVGFEComponentTransferElement>(
+    'feComponentTransfer',
+  );
+  /** @internal */
+  static FEFLOOD = new Svg<SVGFEFloodElement>('feFlood');
+  /** @internal */
+  static FEFUNCA = new Svg<SVGFEFuncAElement>('feFuncA');
+  /** @internal */
+  static FEGAUSSIANBLUR = new Svg<SVGFEGaussianBlurElement>('feGaussianBlur');
+  /** @internal */
+  static FEPOINTLIGHT = new Svg<SVGFEPointLightElement>('fePointLight');
+  /** @internal */
+  static FESPECULARLIGHTING = new Svg<SVGFESpecularLightingElement>(
+    'feSpecularLighting',
+  );
+  /** @internal */
+  static FILTER = new Svg<SVGFilterElement>('filter');
+  /** @internal */
+  static FOREIGNOBJECT = new Svg<SVGForeignObjectElement>('foreignObject');
+  /** @internal */
+  static G = new Svg<SVGGElement>('g');
+  /** @internal */
+  static IMAGE = new Svg<SVGImageElement>('image');
+  /** @internal */
+  static LINE = new Svg<SVGLineElement>('line');
+  /** @internal */
+  static PATH = new Svg<SVGPathElement>('path');
+  /** @internal */
+  static PATTERN = new Svg<SVGPatternElement>('pattern');
+  /** @internal */
+  static POLYGON = new Svg<SVGPolygonElement>('polygon');
+  /** @internal */
+  static RECT = new Svg<SVGRectElement>('rect');
+  /** @internal */
+  static SVG = new Svg<SVGSVGElement>('svg');
+  /** @internal */
+  static TEXT = new Svg<SVGTextElement>('text');
+  /** @internal */
+  static TSPAN = new Svg<SVGTSpanElement>('tspan');
+
+  /**
+   * @param tagName The SVG element tag name.
+   * @internal
+   */
+  constructor(private readonly tagName: string) {}
+
+  /**
+   * Returns the SVG element tag name.
+   *
+   * @returns The name.
+   */
+  toString(): string {
+    return this.tagName;
+  }
+}