blockly 9.0.0-beta.0 → 9.0.0-beta.2

package/core/utils/math.ts

@@ -1,61 +0,0 @@
-/**
- * @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.
- */
-
-/**
- * Utility methods for math.
- * These methods are not specific to Blockly, and could be factored out into
- * a JavaScript framework such as Closure.
- * @namespace Blockly.utils.math
- */
-import * as goog from '../../closure/goog/goog.js';
-goog.declareModuleId('Blockly.utils.math');
-
-
-/**
- * Converts degrees to radians.
- * Copied from Closure's goog.math.toRadians.
- * @param angleDegrees Angle in degrees.
- * @return Angle in radians.
- * @alias Blockly.utils.math.toRadians
- */
-export function toRadians(angleDegrees: number): number {
-  return angleDegrees * Math.PI / 180;
-}
-
-/**
- * Converts radians to degrees.
- * Copied from Closure's goog.math.toDegrees.
- * @param angleRadians Angle in radians.
- * @return Angle in degrees.
- * @alias Blockly.utils.math.toDegrees
- */
-export function toDegrees(angleRadians: number): number {
-  return angleRadians * 180 / Math.PI;
-}
-
-/**
- * Clamp the provided number between the lower bound and the upper bound.
- * @param lowerBound The desired lower bound.
- * @param number The number to clamp.
- * @param upperBound The desired upper bound.
- * @return The clamped number.
- * @alias Blockly.utils.math.clamp
- */
-export function clamp(
-    lowerBound: number, number: number, upperBound: number): number {
-  if (upperBound < lowerBound) {
-    const temp = upperBound;
-    upperBound = lowerBound;
-    lowerBound = temp;
-  }
-  return Math.max(lowerBound, Math.min(number, upperBound));
-}

package/core/utils/metrics.ts

@@ -1,97 +0,0 @@
-/**
- * @license
- * Copyright 2020 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @fileoverview Workspace metrics definitions.
- */
-
-/**
- * Workspace metrics definitions.
- * @namespace Blockly.utils.Metrics
- */
-import * as goog from '../../closure/goog/goog.js';
-goog.declareModuleId('Blockly.utils.Metrics');
-
-
-/** @alias Blockly.utils.Metrics */
-export interface Metrics {
-  /** Height of the visible portion of the workspace. */
-  viewHeight: number;
-
-  /** Width of the visible portion of the workspace. */
-  viewWidth: number;
-
-  /** Height of the content. */
-  contentHeight: number;
-
-  /** Width of the content. */
-  contentWidth: number;
-
-  /** Height of the scroll area. */
-  scrollHeight: number;
-
-  /** Width of the scroll area. */
-  scrollWidth: number;
-
-  /**
-   * Top-edge of the visible portion of the workspace, relative to the workspace
-   * origin.
-   */
-  viewTop: number;
-
-  /**
-   * Left-edge of the visible portion of the workspace, relative to the
-   * workspace origin.
-   */
-  viewLeft: number;
-
-  /** Top-edge of the content, relative to the workspace origin. */
-  contentTop: number;
-
-  /** Left-edge of the content relative to the workspace origin. */
-  contentLeft: number;
-
-  /** Top-edge of the scroll area, relative to the workspace origin. */
-  scrollTop: number;
-
-  /** Left-edge of the scroll area relative to the workspace origin. */
-  scrollLeft: number;
-
-  /**
-   * Top-edge of the visible portion of the workspace, relative to the
-   * blocklyDiv.
-   */
-  absoluteTop: number;
-
-  /**
-   * Left-edge of the visible portion of the workspace, relative to the
-   * blocklyDiv.
-   */
-  absoluteLeft: number;
-
-  /**
-   * Height of the Blockly div (the view + the toolbox, simple of otherwise).
-   */
-  svgHeight: number;
-
-  /** Width of the Blockly div (the view + the toolbox, simple or otherwise). */
-  svgWidth: number;
-
-  /** Width of the toolbox, if it exists.  Otherwise zero. */
-  toolboxWidth: number;
-
-  /** Height of the toolbox, if it exists.  Otherwise zero. */
-  toolboxHeight: number;
-
-  /** Top, bottom, left or right. Use TOOLBOX_AT constants to compare. */
-  toolboxPosition: number;
-
-  /** Width of the flyout if it is always open.  Otherwise zero. */
-  flyoutWidth: number;
-
-  /** Height of the flyout if it is always open.  Otherwise zero. */
-  flyoutHeight: number;
-}

package/core/utils/object.ts

@@ -1,95 +0,0 @@
-/**
- * @license
- * Copyright 2019 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @fileoverview Utility methods for objects.
- */
-
-/**
- * Utility methods for objects.
- * @namespace Blockly.utils.object
- */
-import * as goog from '../../closure/goog/goog.js';
-goog.declareModuleId('Blockly.utils.object');
-
-import * as deprecation from './deprecation.js';
-
-
-/**
- * Inherit the prototype methods from one constructor into another.
- * @param childCtor Child class.
- * @param parentCtor Parent class.
- * @suppress {strictMissingProperties} superClass_ is not defined on Function.
- * @alias Blockly.utils.object.inherits
- */
-export function inherits(childCtor: Function, parentCtor: Function) {
-  // Set a .superClass_ property so that methods can call parent methods
-  // without hard-coding the parent class name.
-  // Could be replaced by ES6's super().
-  // AnyDuringMigration because:  Property 'superClass_' does not exist on type
-  // 'Function'.
-  (childCtor as AnyDuringMigration).superClass_ = parentCtor.prototype;
-
-  // Link the child class to the parent class so that static methods inherit.
-  Object.setPrototypeOf(childCtor, parentCtor);
-
-  // Replace the child constructor's prototype object with an instance
-  // of the parent class.
-  childCtor.prototype = Object.create(parentCtor.prototype);
-  childCtor.prototype.constructor = childCtor;
-}
-// Alternatively, one could use this instead:
-// Object.setPrototypeOf(childCtor.prototype, parentCtor.prototype);
-
-/**
- * Copies all the members of a source object to a target object.
- * @param target Target.
- * @param source Source.
- * @alias Blockly.utils.object.mixin
- */
-export function mixin(target: AnyDuringMigration, source: AnyDuringMigration) {
-  deprecation.warn(
-      'Blockly.utils.object.mixin', 'May 2022', 'May 2023', 'Object.assign');
-  for (const x in source) {
-    target[x] = source[x];
-  }
-}
-
-/**
- * Complete a deep merge of all members of a source object with a target object.
- * @param target Target.
- * @param source Source.
- * @return The resulting object.
- * @alias Blockly.utils.object.deepMerge
- */
-export function deepMerge(
-    target: AnyDuringMigration,
-    source: AnyDuringMigration): AnyDuringMigration {
-  for (const x in source) {
-    if (source[x] !== null && typeof source[x] === 'object') {
-      target[x] = 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 obj Object containing values.
- * @return Array of values.
- * @alias Blockly.utils.object.values
- */
-export function values(obj: AnyDuringMigration): AnyDuringMigration[] {
-  if (Object.values) {
-    return Object.values(obj);
-  }
-  // Fallback for IE.
-  return Object.keys(obj).map(function(e) {
-    return obj[e];
-  });
-}

package/core/utils/parsing.ts

@@ -1,261 +0,0 @@
-/**
- * @license
- * Copyright 2021 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @fileoverview Utility methods related to block and message parsing.
- */
-
-/**
- * @namespace Blockly.utils.parsing
- */
-import * as goog from '../../closure/goog/goog.js';
-goog.declareModuleId('Blockly.utils.parsing');
-
-import {Msg} from '../msg.js';
-
-import * as colourUtils from './colour.js';
-
-
-/**
- * Internal implementation of the message reference and interpolation token
- * parsing used by tokenizeInterpolation() and replaceMessageReferences().
- * @param message Text which might contain string table references and
- *     interpolation tokens.
- * @param parseInterpolationTokens Option to parse numeric
- *     interpolation tokens (%1, %2, ...) when true.
- * @return Array of strings and numbers.
- */
-function tokenizeInterpolationInternal(
-    message: string, parseInterpolationTokens: boolean): (string|number)[] {
-  const tokens = [];
-  const chars = message.split('');
-  chars.push(  // End marker.
-      '');
-  // Parse the message with a finite state machine.
-  // 0 - Base case.
-  // 1 - % found.
-  // 2 - Digit found.
-  // 3 - Message ref found.
-  let state = 0;
-  const buffer = new Array<string>();
-  let number = null;
-  for (let i = 0; i < chars.length; i++) {
-    const c = chars[i];
-    if (state === 0) {  // Start escape.
-      if (c === '%') {
-        const text = buffer.join('');
-        if (text) {
-          tokens.push(text);
-        }
-        buffer.length = 0;
-        state = 1;
-      } else {
-        buffer.push(c);  // Regular char.
-      }
-    } else if (state === 1) {
-      if (c === '%') {
-        buffer.push(c);  // Escaped %: %%
-        state = 0;
-      } else if (parseInterpolationTokens && '0' <= c && c <= '9') {
-        state = 2;
-        number = c;
-        const text = buffer.join('');
-        if (text) {
-          tokens.push(text);
-        }
-        buffer.length = 0;
-      } else if (c === '{') {
-        state = 3;
-      } else {
-        buffer.push('%', c);  // Not recognized. Return as literal.
-        state = 0;
-      }
-    } else if (state === 2) {
-      if ('0' <= c && c <= '9') {
-        number += c;  // Multi-digit number.
-      } else {
-        tokens.push(parseInt(number ?? '', 10));
-        i--;  // Parse this char again.
-        state = 0;
-      }
-    } else if (state === 3) {  // String table reference
-      if (c === '') {
-        // Premature end before closing '}'
-        buffer.splice(0, 0, '%{');  // Re-insert leading delimiter
-        i--;                        // Parse this char again.
-        state = 0;                  // and parse as string literal.
-      } else if (c !== '}') {
-        buffer.push(c);
-      } else {
-        const rawKey = buffer.join('');
-        if (/[A-Z]\w*/i.test(rawKey)) {  // Strict matching
-          // Found a valid string key. Attempt case insensitive match.
-          const keyUpper = rawKey.toUpperCase();
-
-          // BKY_ is the prefix used to namespace the strings used in
-          // Blockly core files and the predefined blocks in ../blocks/.
-          // These strings are defined in ../msgs/ files.
-          const bklyKey =
-              keyUpper.startsWith('BKY_') ? keyUpper.substring(4) : null;
-          if (bklyKey && bklyKey in Msg) {
-            const rawValue = Msg[bklyKey];
-            if (typeof rawValue === 'string') {
-              // Attempt to dereference substrings, too, appending to the
-              // end.
-              Array.prototype.push.apply(
-                  tokens,
-                  tokenizeInterpolationInternal(
-                      rawValue, parseInterpolationTokens));
-            } else if (parseInterpolationTokens) {
-              // When parsing interpolation tokens, numbers are special
-              // placeholders (%1, %2, etc). Make sure all other values are
-              // strings.
-              tokens.push(String(rawValue));
-            } else {
-              tokens.push(rawValue);
-            }
-          } else {
-            // No entry found in the string table. Pass reference as string.
-            tokens.push('%{' + rawKey + '}');
-          }
-          buffer.length = 0;  // Clear the array
-          state = 0;
-        } else {
-          tokens.push('%{' + rawKey + '}');
-          buffer.length = 0;
-          state = 0;  // and parse as string literal.
-        }
-      }
-    }
-  }
-  let text = buffer.join('');
-  if (text) {
-    tokens.push(text);
-  }
-
-  // Merge adjacent text tokens into a single string.
-  const mergedTokens = [];
-  buffer.length = 0;
-  for (let i = 0; i < tokens.length; i++) {
-    if (typeof tokens[i] === 'string') {
-      buffer.push(tokens[i] as string);
-    } else {
-      text = buffer.join('');
-      if (text) {
-        mergedTokens.push(text);
-      }
-      buffer.length = 0;
-      mergedTokens.push(tokens[i]);
-    }
-  }
-  text = buffer.join('');
-  if (text) {
-    mergedTokens.push(text);
-  }
-  buffer.length = 0;
-
-  return mergedTokens;
-}
-
-/**
- * Parse a string with any number of interpolation tokens (%1, %2, ...).
- * It will also replace string table references (e.g., %{bky_my_msg} and
- * %{BKY_MY_MSG} will both be replaced with the value in
- * Msg['MY_MSG']). Percentage sign characters '%' may be self-escaped
- * (e.g., '%%').
- * @param message Text which might contain string table references and
- *     interpolation tokens.
- * @return Array of strings and numbers.
- * @alias Blockly.utils.parsing.tokenizeInterpolation
- */
-export function tokenizeInterpolation(message: string): (string|number)[] {
-  return tokenizeInterpolationInternal(message, true);
-}
-
-/**
- * Replaces string table references in a message, if the message is a string.
- * For example, "%{bky_my_msg}" and "%{BKY_MY_MSG}" will both be replaced with
- * the value in Msg['MY_MSG'].
- * @param message Message, which may be a string that contains
- *     string table references.
- * @return String with message references replaced.
- * @alias Blockly.utils.parsing.replaceMessageReferences
- */
-export function replaceMessageReferences(message: string|
-                                         AnyDuringMigration): string {
-  if (typeof message !== 'string') {
-    return message;
-  }
-  const interpolatedResult = tokenizeInterpolationInternal(message, false);
-  // When parseInterpolationTokens === false, interpolatedResult should be at
-  // most length 1.
-  return interpolatedResult.length ? String(interpolatedResult[0]) : '';
-}
-
-/**
- * Validates that any %{MSG_KEY} references in the message refer to keys of
- * the Msg string table.
- * @param message Text which might contain string table references.
- * @return True if all message references have matching values.
- *     Otherwise, false.
- * @alias Blockly.utils.parsing.checkMessageReferences
- */
-export function checkMessageReferences(message: string): boolean {
-  let validSoFar = true;
-
-  const msgTable = Msg;
-  // TODO (#1169): Implement support for other string tables,
-  // prefixes other than BKY_.
-  const m = message.match(/%{BKY_[A-Z]\w*}/ig);
-  if (m) {
-    for (let i = 0; i < m.length; i++) {
-      const msgKey = m[i].toUpperCase();
-      if (msgTable[msgKey.slice(6, -1)] === undefined) {
-        console.warn('No message string for ' + m[i] + ' in ' + message);
-        validSoFar = false;  // Continue to report other errors.
-      }
-    }
-  }
-
-  return validSoFar;
-}
-
-/**
- * Parse a block colour from a number or string, as provided in a block
- * definition.
- * @param colour HSV hue value (0 to 360), #RRGGBB string,
- *     or a message reference string pointing to one of those two values.
- * @return An object containing the colour as
- *     a #RRGGBB string, and the hue if the input was an HSV hue value.
- * @throws {Error} If the colour cannot be parsed.
- * @alias Blockly.utils.parsing.parseBlockColour
- */
-export function parseBlockColour(colour: number|
-                                 string): {hue: number|null, hex: string} {
-  const dereferenced =
-      typeof colour === 'string' ? replaceMessageReferences(colour) : colour;
-
-  const hue = Number(dereferenced);
-  if (!isNaN(hue) && 0 <= hue && hue <= 360) {
-    return {
-      hue: hue,
-      hex: colourUtils.hsvToHex(
-          hue, colourUtils.getHsvSaturation(), colourUtils.getHsvValue() * 255),
-    };
-  } else {
-    const hex = colourUtils.parse(dereferenced);
-    if (hex) {
-      // Only store hue if colour is set as a hue.
-      return {hue: null, hex: hex};
-    } else {
-      let errorMsg = 'Invalid colour: "' + dereferenced + '"';
-      if (colour !== dereferenced) {
-        errorMsg += ' (from "' + colour + '")';
-      }
-      throw Error(errorMsg);
-    }
-  }
-}

package/core/utils/rect.ts

@@ -1,62 +0,0 @@
-/**
- * @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.
- */
-
-/**
- * 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
- */
-import * as goog from '../../closure/goog/goog.js';
-goog.declareModuleId('Blockly.utils.Rect');
-
-
-/**
- * Class for representing rectangular regions.
- * @alias Blockly.utils.Rect
- */
-export class Rect {
-  /**
-   * @param top Top.
-   * @param bottom Bottom.
-   * @param left Left.
-   * @param right Right.
-   * @struct
-   */
-  constructor(
-      public top: number, public bottom: number, public left: number,
-      public right: number) {}
-
-  /**
-   * 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.
-   * @return 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.
-   * @return Whether this rectangle intersects the provided rectangle.
-   */
-  intersects(other: Rect): boolean {
-    return !(
-        this.left > other.right || this.right < other.left ||
-        this.top > other.bottom || this.bottom < other.top);
-  }
-}

package/core/utils/sentinel.ts

@@ -1,23 +0,0 @@
-/**
- * @license
- * Copyright 2022 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @fileoverview A type used to create flag values (e.g. SKIP_SETUP).
- */
-
-/**
- * A type used to create flag values.
- * @class
- */
-import * as goog from '../../closure/goog/goog.js';
-goog.declareModuleId('Blockly.utils.Sentinel');
-
-
-/**
- * A type used to create flag values.
- * @alias Blockly.utils.Sentinel
- */
-export class Sentinel {}

package/core/utils/size.ts

@@ -1,51 +0,0 @@
-/**
- * @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.
- */
-
-/**
- * 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
- */
-import * as goog from '../../closure/goog/goog.js';
-goog.declareModuleId('Blockly.utils.Size');
-
-
-/**
- * Class for representing sizes consisting of a width and height.
- * @alias Blockly.utils.Size
- */
-export class Size {
-  /**
-   * @param width Width.
-   * @param height Height.
-   * @struct
-   */
-  constructor(public width: number, public height: number) {}
-
-  /**
-   * Compares sizes for equality.
-   * @param a A Size.
-   * @param b A Size.
-   * @return 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;
-  }
-}