scratch-blocks 2.0.0-beta.1 → 2.0.0-spork.1

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

@@ -1,28 +0,0 @@
-/**
- * @license
- * Copyright 2019 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-// Former goog.module ID: Blockly.utils.object
-
-/**
- * Complete a deep merge of all members of a source object with a target object.
- *
- * @param target Target.
- * @param source Source.
- * @returns The resulting object.
- */
-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;
-}

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

@@ -1,287 +0,0 @@
-/**
- * @license
- * Copyright 2021 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-// Former goog.module ID: 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.
- * @param tokenizeNewlines Split individual newline characters into separate
- *     tokens when true.
- * @returns Array of strings and numbers.
- */
-function tokenizeInterpolationInternal(
-  message: string,
-  parseInterpolationTokens: boolean,
-  tokenizeNewlines: 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 if (tokenizeNewlines && c === '\n') {
-        // Output newline characters as single-character tokens, to be replaced
-        // with endOfRow dummies during interpolation.
-        const text = buffer.join('');
-        if (text) {
-          tokens.push(text);
-        }
-        buffer.length = 0;
-        tokens.push(c);
-      } 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,
-                  tokenizeNewlines,
-                ),
-              );
-            } else if (parseInterpolationTokens) {
-              // When parsing interpolation tokens, numbers are special
-              // placeholders (%1, %2, etc). Make sure all other values are
-              // strings.
-              tokens.push(`${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 (but if newlines should be
-  // tokenized, don't merge those with adjacent text).
-  const mergedTokens = [];
-  buffer.length = 0;
-  for (let i = 0; i < tokens.length; i++) {
-    if (
-      typeof tokens[i] === 'string' &&
-      !(tokenizeNewlines && tokens[i] === '\n')
-    ) {
-      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., '%%'). Newline characters will also be output as string tokens
- * containing a single newline character.
- *
- * @param message Text which might contain string table references and
- *     interpolation tokens.
- * @returns Array of strings and numbers.
- */
-export function tokenizeInterpolation(message: string): (string | number)[] {
-  return tokenizeInterpolationInternal(message, true, 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.
- * @returns String with message references replaced.
- */
-export function replaceMessageReferences(message: string | any): string {
-  if (typeof message !== 'string') {
-    return message;
-  }
-  const interpolatedResult = tokenizeInterpolationInternal(
-    message,
-    false,
-    false,
-  );
-  // When parseInterpolationTokens and tokenizeNewlines are 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.
- * @returns True if all message references have matching values.
- *     Otherwise, false.
- */
-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*}/gi);
-  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.
- * @returns 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.
- */
-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/blockly-rc/core/utils/rect.ts

@@ -1,69 +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
-
-/**
- * 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,
-  ) {}
-
-  getHeight(): number {
-    return this.bottom - this.top;
-  }
-
-  getWidth(): number {
-    return this.right - this.left;
-  }
-
-  /**
-   * 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 {
-    return !(
-      this.left > other.right ||
-      this.right < other.left ||
-      this.top > other.bottom ||
-      this.bottom < other.top
-    );
-  }
-}

package/blockly-rc/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));
-  }
-}