blockly 12.4.0 → 12.5.0

package/core/utils/rect.ts

@@ -1,142 +0,0 @@
-/**
- * @license
- * Copyright 2019 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * Utility methods for rectangle manipulation.
- * These methods are not specific to Blockly, and could be factored out into
- * a JavaScript framework such as Closure.
- *
- * @class
- */
-// Former goog.module ID: Blockly.utils.Rect
-
-import {Coordinate} from './coordinate.js';
-
-/**
- * Class for representing rectangular regions.
- */
-export class Rect {
-  /**
-   * @param top Top.
-   * @param bottom Bottom.
-   * @param left Left.
-   * @param right Right.
-   */
-  constructor(
-    public top: number,
-    public bottom: number,
-    public left: number,
-    public right: number,
-  ) {}
-
-  /**
-   * Converts a DOM or SVG Rect to a Blockly Rect.
-   *
-   * @param rect The rectangle to convert.
-   * @returns A representation of the same rectangle as a Blockly Rect.
-   */
-  static from(rect: DOMRect | SVGRect): Rect {
-    return new Rect(rect.y, rect.y + rect.height, rect.x, rect.x + rect.width);
-  }
-
-  /**
-   * Creates a new copy of this rectangle.
-   *
-   * @returns A copy of this Rect.
-   */
-  clone(): Rect {
-    return new Rect(this.top, this.bottom, this.left, this.right);
-  }
-
-  /** Returns the height of this rectangle. */
-  getHeight(): number {
-    return this.bottom - this.top;
-  }
-
-  /** Returns the width of this rectangle. */
-  getWidth(): number {
-    return this.right - this.left;
-  }
-
-  /** Returns the top left coordinate of this rectangle. */
-  getOrigin(): Coordinate {
-    return new Coordinate(this.left, this.top);
-  }
-
-  /**
-   * Tests whether this rectangle contains a x/y coordinate.
-   *
-   * @param x The x coordinate to test for containment.
-   * @param y The y coordinate to test for containment.
-   * @returns Whether this rectangle contains given coordinate.
-   */
-  contains(x: number, y: number): boolean {
-    return (
-      x >= this.left && x <= this.right && y >= this.top && y <= this.bottom
-    );
-  }
-
-  /**
-   * Tests whether this rectangle intersects the provided rectangle.
-   * Assumes that the coordinate system increases going down and left.
-   *
-   * @param other The other rectangle to check for intersection with.
-   * @returns Whether this rectangle intersects the provided rectangle.
-   */
-  intersects(other: Rect): boolean {
-    // The following logic can be derived and then simplified from a longer form symmetrical check
-    // of verifying each rectangle's borders with the other rectangle by checking if either end of
-    // the border's line segment is contained within the other rectangle. The simplified version
-    // used here can be logically interpreted as ensuring that each line segment of 'this' rectangle
-    // is not outside the bounds of the 'other' rectangle (proving there's an intersection).
-    return (
-      this.left <= other.right &&
-      this.right >= other.left &&
-      this.bottom >= other.top &&
-      this.top <= other.bottom
-    );
-  }
-
-  /**
-   * Compares bounding rectangles for equality.
-   *
-   * @param a A Rect.
-   * @param b A Rect.
-   * @returns True iff the bounding rectangles are equal, or if both are null.
-   */
-  static equals(a?: Rect | null, b?: Rect | null): boolean {
-    if (a === b) {
-      return true;
-    }
-    if (!a || !b) {
-      return false;
-    }
-    return (
-      a.top === b.top &&
-      a.bottom === b.bottom &&
-      a.left === b.left &&
-      a.right === b.right
-    );
-  }
-
-  /**
-   * Creates a new Rect using a position and supplied dimensions.
-   *
-   * @param position The upper left coordinate of the new rectangle.
-   * @param width The width of the rectangle, in pixels.
-   * @param height The height of the rectangle, in pixels.
-   * @returns A newly created Rect using the provided Coordinate and dimensions.
-   */
-  static createFromPoint(
-    position: Coordinate,
-    width: number,
-    height: number,
-  ): Rect {
-    const left = position.x;
-    const top = position.y;
-    return new Rect(top, top + height, left, left + width);
-  }
-}

package/core/utils/size.ts

@@ -1,62 +0,0 @@
-/**
- * @license
- * Copyright 2019 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * Utility methods for size calculation.
- * These methods are not specific to Blockly, and could be factored out into
- * a JavaScript framework such as Closure.
- *
- * @class
- */
-// Former goog.module ID: Blockly.utils.Size
-
-/**
- * Class for representing sizes consisting of a width and height.
- */
-export class Size {
-  /**
-   * @param width Width.
-   * @param height Height.
-   */
-  constructor(
-    public width: number,
-    public height: number,
-  ) {}
-
-  /**
-   * Compares sizes for equality.
-   *
-   * @param a A Size.
-   * @param b A Size.
-   * @returns True iff the sizes have equal widths and equal heights, or if both
-   *     are null.
-   */
-  static equals(a?: Size | null, b?: Size | null): boolean {
-    if (a === b) {
-      return true;
-    }
-    if (!a || !b) {
-      return false;
-    }
-    return a.width === b.width && a.height === b.height;
-  }
-
-  /**
-   * Returns a new size with the maximum width and height values out of both
-   * sizes.
-   */
-  static max(a: Size, b: Size): Size {
-    return new Size(Math.max(a.width, b.width), Math.max(a.height, b.height));
-  }
-
-  /**
-   * Returns a new size with the minimum width and height values out of both
-   * sizes.
-   */
-  static min(a: Size, b: Size): Size {
-    return new Size(Math.min(a.width, b.width), Math.min(a.height, b.height));
-  }
-}

package/core/utils/string.ts

@@ -1,289 +0,0 @@
-/**
- * @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/core/utils/style.ts

@@ -1,219 +0,0 @@
-/**
- * @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,
-};