blockly 9.0.0-beta.0 → 9.0.0-beta.1

package/core/utils/string.ts

@@ -1,308 +0,0 @@
-/**
- * @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.
- */
-
-/**
- * Utility methods for string manipulation.
- * These methods are not specific to Blockly, and could be factored out into
- * a JavaScript framework such as Closure.
- * @namespace Blockly.utils.string
- */
-import * as goog from '../../closure/goog/goog.js';
-goog.declareModuleId('Blockly.utils.string');
-
-import * as deprecation from './deprecation.js';
-
-
-/**
- * Fast prefix-checker.
- * Copied from Closure's goog.string.startsWith.
- * @param str The string to check.
- * @param prefix A string to look for at the start of `str`.
- * @return True if `str` begins with `prefix`.
- * @alias Blockly.utils.string.startsWith
- * @deprecated April 2022. Use built-in string.startsWith.
- */
-export function startsWith(str: string, prefix: string): boolean {
-  deprecation.warn(
-      'Blockly.utils.string.startsWith()', 'April 2022', 'April 2023',
-      'Use built-in string.startsWith');
-  return str.startsWith(prefix);
-}
-
-/**
- * Given an array of strings, return the length of the shortest one.
- * @param array Array of strings.
- * @return Length of shortest string.
- * @alias Blockly.utils.string.shortestStringLength
- */
-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.
- * @return Length of common prefix.
- * @alias Blockly.utils.string.commonWordPrefix
- */
-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.
- * @return Length of common suffix.
- * @alias Blockly.utils.string.commonWordSuffix
- */
-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.
- * @return Wrapped text.
- * @alias Blockly.utils.string.wrap
- */
-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.
- * @return 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.
- * @return 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.apply(Math, 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 ('.?!'.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 words Array of each word.
- * @param wordBreaks Array of line breaks.
- * @param limit Width to wrap each line.
- * @return 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.
- * @return 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.
- * @return True if number, false otherwise.
- * @alias Blockly.utils.string.isNumber
- */
-export function isNumber(str: string): boolean {
-  return /^\s*-?\d+(\.\d+)?\s*$/.test(str);
-}

package/core/utils/style.ts

@@ -1,306 +0,0 @@
-/**
- * @license
- * Copyright 2019 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @fileoverview Utilities for element styles.
- * These methods are not specific to Blockly, and could be factored out into
- * a JavaScript framework such as Closure.
- */
-
-/**
- * Utilities for element styles.
- * These methods are not specific to Blockly, and could be factored out into
- * a JavaScript framework such as Closure.
- * @namespace Blockly.utils.style
- */
-import * as goog from '../../closure/goog/goog.js';
-goog.declareModuleId('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.
- * @return Object with width/height properties.
- * @alias Blockly.utils.style.getSize
- */
-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 (getStyle(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.
- * @return 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);
-}
-
-/**
- * Cross-browser pseudo get computed style. It returns the computed style where
- * available. If not available it tries the cascaded style value (IE
- * currentStyle) and in worst case the inline style value.  It shouldn't be
- * called directly, see http://wiki/Main/ComputedStyleVsCascadedStyle for
- * discussion.
- *
- * Copied from Closure's goog.style.getStyle_
- *
- * @param element Element to get style of.
- * @param style Property to get (must be camelCase, not CSS-style).
- * @return Style value.
- */
-function getStyle(element: Element, style: string): string {
-  // AnyDuringMigration because:  Property 'style' does not exist on type
-  // 'Element'. AnyDuringMigration because:  Property 'style' does not exist on
-  // type 'Element'.
-  return getComputedStyle(element, style) || getCascadedStyle(element, style) ||
-      (element as AnyDuringMigration).style &&
-      (element as AnyDuringMigration).style[style];
-}
-
-/**
- * Retrieves a computed style value of a node. It returns empty string if the
- * value cannot be computed (which will be the case in Internet Explorer) or
- * "none" 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).
- * @return Style value.
- * @alias Blockly.utils.style.getComputedStyle
- */
-export function getComputedStyle(element: Element, property: string): string {
-  if (document.defaultView && document.defaultView.getComputedStyle) {
-    const styles = document.defaultView.getComputedStyle(element, null);
-    if (styles) {
-      // element.style[..] is undefined for browser specific styles
-      // as 'filter'.
-      return (styles as AnyDuringMigration)[property] ||
-          styles.getPropertyValue(property) || '';
-    }
-  }
-
-  return '';
-}
-
-/**
- * Gets the cascaded style value of a node, or null if the value cannot be
- * computed (only Internet Explorer can do this).
- *
- * Copied from Closure's goog.style.getCascadedStyle
- *
- * @param element Element to get style of.
- * @param style Property to get (camel-case).
- * @return Style value.
- * @alias Blockly.utils.style.getCascadedStyle
- */
-export function getCascadedStyle(element: Element, style: string): string {
-  // AnyDuringMigration because:  Property 'currentStyle' does not exist on type
-  // 'Element'. AnyDuringMigration because:  Property 'currentStyle' does not
-  // exist on type 'Element'.
-  return (element as AnyDuringMigration).currentStyle ?
-      (element as AnyDuringMigration).currentStyle[style] :
-      '' as string;
-}
-
-/**
- * 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.
- * @return The page offset.
- * @alias Blockly.utils.style.getPageOffset
- */
-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
- * @return The page offset of the viewport.
- * @alias Blockly.utils.style.getViewportPageOffset
- */
-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);
-}
-
-/**
- * Shows or hides an element from the page. Hiding the element is done by
- * setting the display property to "none", removing the element from the
- * rendering hierarchy so it takes up no space. To show the element, the default
- * inherited display property is restored (defined either in stylesheets or by
- * the browser's default style rules).
- * Copied from Closure's goog.style.getViewportPageOffset
- *
- * @param el Element to show or hide.
- * @param isShown True to render the element in its default style, false to
- *     disable rendering the element.
- * @alias Blockly.utils.style.setElementShown
- */
-export function setElementShown(el: Element, isShown: AnyDuringMigration) {
-  // AnyDuringMigration because:  Property 'style' does not exist on type
-  // 'Element'.
-  (el as AnyDuringMigration).style.display = isShown ? '' : 'none';
-}
-
-/**
- * Returns true if the element is using right to left (RTL) direction.
- * Copied from Closure's goog.style.isRightToLeft
- *
- * @param el The element to test.
- * @return True for right to left, false for left to right.
- * @alias Blockly.utils.style.isRightToLeft
- */
-export function isRightToLeft(el: Element): boolean {
-  return 'rtl' === getStyle(el, 'direction');
-}
-
-/**
- * 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.
- * @return The computed border widths.
- * @alias Blockly.utils.style.getBorderBox
- */
-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.
- * @alias Blockly.utils.style.scrollIntoContainerView
- */
-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.
- * @return The new scroll position of the container.
- * @alias Blockly.utils.style.getContainerOffsetToScrollInto
- */
-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/core/utils/svg.ts

@@ -1,88 +0,0 @@
-/**
- * @license
- * Copyright 2020 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @fileoverview Defines the Svg class. Its constants enumerate
- * all SVG tag names used by Blockly.
- */
-
-/**
- * Defines the Svg class. Its constants enumerate
- * all SVG tag names used by Blockly.
- * @class
- */
-import * as goog from '../../closure/goog/goog.js';
-goog.declareModuleId('Blockly.utils.Svg');
-
-
-/**
- * A name with the type of the SVG element stored in the generic.
- * @alias Blockly.utils.Svg
- */
-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.
-   * @return The name.
-   */
-  toString(): string {
-    return this.tagName;
-  }
-}