scratch-blocks 1.1.205 → 1.2.0-beta.1

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

@@ -0,0 +1,356 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// Former goog.module ID: Blockly.utils.dom
+
+import type {Svg} from './svg.js';
+
+/**
+ * Required name space for SVG elements.
+ */
+export const SVG_NS = 'http://www.w3.org/2000/svg';
+
+/**
+ * Required name space for HTML elements.
+ */
+export const HTML_NS = 'http://www.w3.org/1999/xhtml';
+
+/**
+ * Required name space for XLINK elements.
+ */
+export const XLINK_NS = 'http://www.w3.org/1999/xlink';
+
+/**
+ * Node type constants.
+ * https://developer.mozilla.org/en-US/docs/Web/API/Node/nodeType
+ */
+export enum NodeType {
+  ELEMENT_NODE = 1,
+  TEXT_NODE = 3,
+  COMMENT_NODE = 8,
+}
+
+/** Temporary cache of text widths. */
+let cacheWidths: {[key: string]: number} | null = null;
+
+/** Number of current references to cache. */
+let cacheReference = 0;
+
+/** A HTML canvas context used for computing text width. */
+let canvasContext: CanvasRenderingContext2D | null = null;
+
+/**
+ * Helper method for creating SVG elements.
+ *
+ * @param name Element's tag name.
+ * @param attrs Dictionary of attribute names and values.
+ * @param opt_parent Optional parent on which to append the element.
+ * @returns if name is a string or a more specific type if it a member of Svg.
+ */
+export function createSvgElement<T extends SVGElement>(
+  name: string | Svg<T>,
+  attrs: {[key: string]: string | number},
+  opt_parent?: Element | null,
+): T {
+  const e = document.createElementNS(SVG_NS, `${name}`) as T;
+  for (const key in attrs) {
+    e.setAttribute(key, `${attrs[key]}`);
+  }
+  if (opt_parent) {
+    opt_parent.appendChild(e);
+  }
+  return e;
+}
+
+/**
+ * Add a CSS class to a element.
+ *
+ * Handles multiple space-separated classes for legacy reasons.
+ *
+ * @param element DOM element to add class to.
+ * @param className Name of class to add.
+ * @returns True if class was added, false if already present.
+ */
+export function addClass(element: Element, className: string): boolean {
+  const classNames = className.split(' ');
+  if (classNames.every((name) => element.classList.contains(name))) {
+    return false;
+  }
+  element.classList.add(...classNames);
+  return true;
+}
+
+/**
+ * Removes multiple classes from an element.
+ *
+ * @param element DOM element to remove classes from.
+ * @param classNames A string of one or multiple class names for an element.
+ */
+export function removeClasses(element: Element, classNames: string) {
+  element.classList.remove(...classNames.split(' '));
+}
+
+/**
+ * Remove a CSS class from a element.
+ *
+ * Handles multiple space-separated classes for legacy reasons.
+ *
+ * @param element DOM element to remove class from.
+ * @param className Name of class to remove.
+ * @returns True if class was removed, false if never present.
+ */
+export function removeClass(element: Element, className: string): boolean {
+  const classNames = className.split(' ');
+  if (classNames.every((name) => !element.classList.contains(name))) {
+    return false;
+  }
+  element.classList.remove(...classNames);
+  return true;
+}
+
+/**
+ * Checks if an element has the specified CSS class.
+ *
+ * @param element DOM element to check.
+ * @param className Name of class to check.
+ * @returns True if class exists, false otherwise.
+ */
+export function hasClass(element: Element, className: string): boolean {
+  return element.classList.contains(className);
+}
+
+/**
+ * Removes a node from its parent. No-op if not attached to a parent.
+ *
+ * @param node The node to remove.
+ * @returns The node removed if removed; else, null.
+ */
+// Copied from Closure goog.dom.removeNode
+export function removeNode(node: Node | null): Node | null {
+  return node && node.parentNode ? node.parentNode.removeChild(node) : null;
+}
+
+/**
+ * Insert a node after a reference node.
+ * Contrast with node.insertBefore function.
+ *
+ * @param newNode New element to insert.
+ * @param refNode Existing element to precede new node.
+ */
+export function insertAfter(newNode: Element, refNode: Element) {
+  const siblingNode = refNode.nextSibling;
+  const parentNode = refNode.parentNode;
+  if (!parentNode) {
+    throw Error('Reference node has no parent.');
+  }
+  if (siblingNode) {
+    parentNode.insertBefore(newNode, siblingNode);
+  } else {
+    parentNode.appendChild(newNode);
+  }
+}
+
+/**
+ * Sets the CSS transform property on an element. This function sets the
+ * non-vendor-prefixed and vendor-prefixed versions for backwards compatibility
+ * with older browsers. See https://caniuse.com/#feat=transforms2d
+ *
+ * @param element Element to which the CSS transform will be applied.
+ * @param transform The value of the CSS `transform` property.
+ */
+export function setCssTransform(
+  element: HTMLElement | SVGElement,
+  transform: string,
+) {
+  element.style['transform'] = transform;
+  element.style['-webkit-transform' as any] = transform;
+}
+
+/**
+ * Start caching text widths. Every call to this function MUST also call
+ * stopTextWidthCache. Caches must not survive between execution threads.
+ */
+export function startTextWidthCache() {
+  cacheReference++;
+  if (!cacheWidths) {
+    cacheWidths = Object.create(null);
+  }
+}
+
+/**
+ * Stop caching field widths. Unless caching was already on when the
+ * corresponding call to startTextWidthCache was made.
+ */
+export function stopTextWidthCache() {
+  cacheReference--;
+  if (!cacheReference) {
+    cacheWidths = null;
+  }
+}
+
+/**
+ * Gets the width of a text element, caching it in the process.
+ *
+ * @param textElement An SVG 'text' element.
+ * @returns Width of element.
+ */
+export function getTextWidth(textElement: SVGTextElement): number {
+  const key = textElement.textContent + '\n' + textElement.className.baseVal;
+  let width;
+  // Return the cached width if it exists.
+  if (cacheWidths) {
+    width = cacheWidths[key];
+    if (width) {
+      return width;
+    }
+  }
+
+  // Compute the width of the SVG text element.
+  const style = window.getComputedStyle(textElement);
+  width = getFastTextWidthWithSizeString(
+    textElement,
+    style.fontSize,
+    style.fontWeight,
+    style.fontFamily,
+  );
+
+  // Cache the computed width and return.
+  if (cacheWidths) {
+    cacheWidths[key] = width;
+  }
+  return width;
+}
+
+/**
+ * Gets the width of a text element using a faster method than `getTextWidth`.
+ * This method requires that we know the text element's font family and size in
+ * advance. Similar to `getTextWidth`, we cache the width we compute.
+ *
+ * @param textElement An SVG 'text' element.
+ * @param fontSize The font size to use.
+ * @param fontWeight The font weight to use.
+ * @param fontFamily The font family to use.
+ * @returns Width of element.
+ */
+export function getFastTextWidth(
+  textElement: SVGTextElement,
+  fontSize: number,
+  fontWeight: string,
+  fontFamily: string,
+): number {
+  return getFastTextWidthWithSizeString(
+    textElement,
+    fontSize + 'pt',
+    fontWeight,
+    fontFamily,
+  );
+}
+
+/**
+ * Gets the width of a text element using a faster method than `getTextWidth`.
+ * This method requires that we know the text element's font family and size in
+ * advance. Similar to `getTextWidth`, we cache the width we compute.
+ * This method is similar to `getFastTextWidth` but expects the font size
+ * parameter to be a string.
+ *
+ * @param textElement An SVG 'text' element.
+ * @param fontSize The font size to use.
+ * @param fontWeight The font weight to use.
+ * @param fontFamily The font family to use.
+ * @returns Width of element.
+ */
+export function getFastTextWidthWithSizeString(
+  textElement: SVGTextElement,
+  fontSize: string,
+  fontWeight: string,
+  fontFamily: string,
+): number {
+  const text = textElement.textContent;
+  const key = text + '\n' + textElement.className.baseVal;
+  let width;
+
+  // Return the cached width if it exists.
+  if (cacheWidths) {
+    width = cacheWidths[key];
+    if (width) {
+      return width;
+    }
+  }
+
+  if (!canvasContext) {
+    // Inject the canvas element used for computing text widths.
+    const computeCanvas = document.createElement('canvas');
+    computeCanvas.className = 'blocklyComputeCanvas';
+    document.body.appendChild(computeCanvas);
+
+    // Initialize the HTML canvas context and set the font.
+    // The context font must match blocklyText's fontsize and font-family
+    // set in CSS.
+    canvasContext = computeCanvas.getContext('2d') as CanvasRenderingContext2D;
+  }
+  // Set the desired font size and family.
+  canvasContext.font = fontWeight + ' ' + fontSize + ' ' + fontFamily;
+
+  // Measure the text width using the helper canvas context.
+  if (text) {
+    width = canvasContext.measureText(text).width;
+  } else {
+    width = 0;
+  }
+
+  // Cache the computed width and return.
+  if (cacheWidths) {
+    cacheWidths[key] = width;
+  }
+  return width;
+}
+
+/**
+ * Measure a font's metrics. The height and baseline values.
+ *
+ * @param text Text to measure the font dimensions of.
+ * @param fontSize The font size to use.
+ * @param fontWeight The font weight to use.
+ * @param fontFamily The font family to use.
+ * @returns Font measurements.
+ */
+export function measureFontMetrics(
+  text: string,
+  fontSize: string,
+  fontWeight: string,
+  fontFamily: string,
+): {height: number; baseline: number} {
+  const span = document.createElement('span');
+  span.style.font = fontWeight + ' ' + fontSize + ' ' + fontFamily;
+  span.textContent = text;
+
+  const block = document.createElement('div');
+  block.style.width = '1px';
+  block.style.height = '0';
+
+  const div = document.createElement('div');
+  div.style.display = 'flex';
+  div.style.position = 'fixed';
+  div.style.top = '0';
+  div.style.left = '0';
+  div.appendChild(span);
+  div.appendChild(block);
+
+  document.body.appendChild(div);
+  const result = {
+    height: 0,
+    baseline: 0,
+  };
+  try {
+    div.style.alignItems = 'baseline';
+    result.baseline = block.offsetTop - span.offsetTop;
+    div.style.alignItems = 'flex-end';
+    result.height = block.offsetTop - span.offsetTop;
+  } finally {
+    document.body.removeChild(div);
+  }
+  return result;
+}

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

@@ -0,0 +1,70 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// Former goog.module ID: Blockly.utils.idGenerator
+
+/**
+ * Legal characters for the universally unique IDs.  Should be all on
+ * a US keyboard.  No characters that conflict with XML or JSON.
+ * Requests to remove additional 'problematic' characters from this
+ * soup will be denied.  That's your failure to properly escape in
+ * your own environment.  Issues #251, #625, #682, #1304.
+ */
+const soup =
+  '!#$%()*+,-./:;=?@[]^_`{|}~' +
+  'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+
+/**
+ * Namespace object for internal implementations we want to be able to
+ * stub in tests. Do not use externally.
+ *
+ * @internal
+ */
+const internal = {
+  /**
+   * Generate a random unique ID.  This should be globally unique.
+   * 87 characters ^ 20 length is greater than 128 bits (better than a UUID).
+   *
+   * @returns A globally unique ID string.
+   */
+  genUid: () => {
+    const length = 20;
+    const soupLength = soup.length;
+    const id = [];
+    for (let i = 0; i < length; i++) {
+      id[i] = soup.charAt(Math.random() * soupLength);
+    }
+    return id.join('');
+  },
+};
+export const TEST_ONLY = internal;
+
+/** Next unique ID to use. */
+let nextId = 0;
+
+/**
+ * Generate the next unique element IDs.
+ * IDs are compatible with the HTML4 'id' attribute restrictions:
+ * Use only ASCII letters, digits, '_', '-' and '.'
+ *
+ * For UUIDs use genUid (below) instead; this ID generator should
+ * primarily be used for IDs that end up in the DOM.
+ *
+ * @returns The next unique identifier.
+ */
+export function getNextUniqueId(): string {
+  return 'blockly-' + (nextId++).toString(36);
+}
+
+/**
+ * Generate a random unique ID.
+ *
+ * @see internal.genUid
+ * @returns A globally unique ID string.
+ */
+export function genUid(): string {
+  return internal.genUid();
+}

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

@@ -0,0 +1,154 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// Former goog.module ID: Blockly.utils.KeyCodes
+
+/* eslint-disable @typescript-eslint/no-duplicate-enum-values */
+
+/**
+ * Key codes for common characters.
+ *
+ * Copied from Closure's goog.events.KeyCodes
+ *
+ * This list is not localized and therefore some of the key codes are not
+ * correct for non US keyboard layouts. See comments below.
+ */
+export enum KeyCodes {
+  WIN_KEY_FF_LINUX = 0,
+  MAC_ENTER = 3,
+  BACKSPACE = 8,
+  TAB = 9,
+  NUM_CENTER = 12, // NUMLOCK on FF/Safari Mac
+  ENTER = 13,
+  SHIFT = 16,
+  CTRL = 17,
+  ALT = 18,
+  PAUSE = 19,
+  CAPS_LOCK = 20,
+  ESC = 27,
+  SPACE = 32,
+  PAGE_UP = 33, // also NUM_NORTH_EAST
+  PAGE_DOWN = 34, // also NUM_SOUTH_EAST
+  END = 35, // also NUM_SOUTH_WEST
+  HOME = 36, // also NUM_NORTH_WEST
+  LEFT = 37, // also NUM_WEST
+  UP = 38, // also NUM_NORTH
+  RIGHT = 39, // also NUM_EAST
+  DOWN = 40, // also NUM_SOUTH
+  PLUS_SIGN = 43, // NOT numpad plus
+  PRINT_SCREEN = 44,
+  INSERT = 45, // also NUM_INSERT
+  DELETE = 46, // also NUM_DELETE
+  ZERO = 48,
+  ONE = 49,
+  TWO = 50,
+  THREE = 51,
+  FOUR = 52,
+  FIVE = 53,
+  SIX = 54,
+  SEVEN = 55,
+  EIGHT = 56,
+  NINE = 57,
+  FF_SEMICOLON = 59, // Firefox (Gecko) fires this for semicolon instead of 186
+  FF_EQUALS = 61, // Firefox (Gecko) fires this for equals instead of 187
+  FF_DASH = 173, // Firefox (Gecko) fires this for dash instead of 189
+  // Firefox (Gecko) fires this for # on UK keyboards, rather than
+  // Shift+SINGLE_QUOTE.
+  FF_HASH = 163,
+  QUESTION_MARK = 63, // needs localization
+  AT_SIGN = 64,
+  A = 65,
+  B = 66,
+  C = 67,
+  D = 68,
+  E = 69,
+  F = 70,
+  G = 71,
+  H = 72,
+  I = 73,
+  J = 74,
+  K = 75,
+  L = 76,
+  M = 77,
+  N = 78,
+  O = 79,
+  P = 80,
+  Q = 81,
+  R = 82,
+  S = 83,
+  T = 84,
+  U = 85,
+  V = 86,
+  W = 87,
+  X = 88,
+  Y = 89,
+  Z = 90,
+  META = 91, // WIN_KEY_LEFT
+  WIN_KEY_RIGHT = 92,
+  CONTEXT_MENU = 93,
+  NUM_ZERO = 96,
+  NUM_ONE = 97,
+  NUM_TWO = 98,
+  NUM_THREE = 99,
+  NUM_FOUR = 100,
+  NUM_FIVE = 101,
+  NUM_SIX = 102,
+  NUM_SEVEN = 103,
+  NUM_EIGHT = 104,
+  NUM_NINE = 105,
+  NUM_MULTIPLY = 106,
+  NUM_PLUS = 107,
+  NUM_MINUS = 109,
+  NUM_PERIOD = 110,
+  NUM_DIVISION = 111,
+  F1 = 112,
+  F2 = 113,
+  F3 = 114,
+  F4 = 115,
+  F5 = 116,
+  F6 = 117,
+  F7 = 118,
+  F8 = 119,
+  F9 = 120,
+  F10 = 121,
+  F11 = 122,
+  F12 = 123,
+  NUMLOCK = 144,
+  SCROLL_LOCK = 145,
+
+  // OS-specific media keys like volume controls and browser controls.
+  FIRST_MEDIA_KEY = 166,
+  LAST_MEDIA_KEY = 183,
+
+  SEMICOLON = 186, // needs localization
+  DASH = 189, // needs localization
+  EQUALS = 187, // needs localization
+  COMMA = 188, // needs localization
+  PERIOD = 190, // needs localization
+  SLASH = 191, // needs localization
+  APOSTROPHE = 192, // needs localization
+  TILDE = 192, // needs localization
+  SINGLE_QUOTE = 222, // needs localization
+  OPEN_SQUARE_BRACKET = 219, // needs localization
+  BACKSLASH = 220, // needs localization
+  CLOSE_SQUARE_BRACKET = 221, // needs localization
+  WIN_KEY = 224,
+  MAC_FF_META = 224, // Firefox (Gecko) fires this for the meta key instead of 91
+  MAC_WK_CMD_LEFT = 91, // WebKit Left Command key fired, same as META
+  MAC_WK_CMD_RIGHT = 93, // WebKit Right Command key fired, different from META
+  WIN_IME = 229,
+
+  // "Reserved for future use". Some programs (e.g. the SlingPlayer 2.4 ActiveX
+  // control) fire this as a hacky way to disable screensavers.
+  VK_NONAME = 252,
+
+  // We've seen users whose machines fire this keycode at regular one
+  // second intervals. The common thread among these users is that
+  // they're all using Dell Inspiron laptops, so we suspect that this
+  // indicates a hardware/bios problem.
+  // http://en.community.dell.com/support-forums/laptop/f/3518/p/19285957/19523128.aspx
+  PHANTOM = 255,
+}

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

@@ -0,0 +1,50 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// Former goog.module ID: Blockly.utils.math
+
+/**
+ * Converts degrees to radians.
+ * Copied from Closure's goog.math.toRadians.
+ *
+ * @param angleDegrees Angle in degrees.
+ * @returns Angle in radians.
+ */
+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.
+ * @returns Angle in degrees.
+ */
+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.
+ * @returns The clamped number.
+ */
+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/blockly-rc/core/utils/metrics.ts

@@ -0,0 +1,86 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// Former goog.module ID: 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;
+}