blockly 8.0.4 → 8.0.5-beta.0

package/core/{connection_db.js → connection_db.ts}

@@ -9,7 +9,6 @@
  *    possibly be connected to (i.e. not collapsed, etc).
  *    Sorted by y coordinate.
  */
-'use strict';
 
 /**
  * A database of all the rendered connections that could
@@ -17,17 +16,16 @@
  *    Sorted by y coordinate.
  * @class
  */
-goog.module('Blockly.ConnectionDB');
+import * as goog from '../closure/goog/goog.js';
+goog.declareModuleId('Blockly.ConnectionDB');
 
-const {ConnectionType} = goog.require('Blockly.ConnectionType');
-/* eslint-disable-next-line no-unused-vars */
-const {Coordinate} = goog.requireType('Blockly.utils.Coordinate');
-/* eslint-disable-next-line no-unused-vars */
-const {IConnectionChecker} = goog.requireType('Blockly.IConnectionChecker');
-/* eslint-disable-next-line no-unused-vars */
-const {RenderedConnection} = goog.requireType('Blockly.RenderedConnection');
-/** @suppress {extraRequire} */
-goog.require('Blockly.constants');
+// Unused import preserved for side-effects. Remove if unneeded.
+// import './constants.js';
+
+import {ConnectionType} from './connection_type.js';
+import type {IConnectionChecker} from './interfaces/i_connection_checker.js';
+import type {RenderedConnection} from './rendered_connection.js';
+import type {Coordinate} from './utils/coordinate.js';
 
 
 /**
@@ -36,36 +34,23 @@ goog.require('Blockly.constants');
  * connections in an area may be looked up quickly using a binary search.
  * @alias Blockly.ConnectionDB
  */
-class ConnectionDB {
+export class ConnectionDB {
+  /** Array of connections sorted by y position in workspace units. */
+  private readonly connections_: RenderedConnection[] = [];
+
   /**
-   * @param {!IConnectionChecker} checker The workspace's
-   *     connection type checker, used to decide if connections are valid during
-   * a drag.
+   * @param connectionChecker The workspace's connection type checker, used to
+   *     decide if connections are valid during a drag.
    */
-  constructor(checker) {
-    /**
-     * Array of connections sorted by y position in workspace units.
-     * @type {!Array<!RenderedConnection>}
-     * @private
-     */
-    this.connections_ = [];
-    /**
-     * The workspace's connection type checker, used to decide if connections
-     * are valid during a drag.
-     * @type {!IConnectionChecker}
-     * @private
-     */
-    this.connectionChecker_ = checker;
-  }
+  constructor(private readonly connectionChecker: IConnectionChecker) {}
 
   /**
    * Add a connection to the database. Should not already exist in the database.
-   * @param {!RenderedConnection} connection The connection to be added.
-   * @param {number} yPos The y position used to decide where to insert the
-   *    connection.
-   * @package
+   * @param connection The connection to be added.
+   * @param yPos The y position used to decide where to insert the connection.
+   * @internal
    */
-  addConnection(connection, yPos) {
+  addConnection(connection: RenderedConnection, yPos: number) {
     const index = this.calculateIndexForYPos_(yPos);
     this.connections_.splice(index, 0, connection);
   }
@@ -75,14 +60,12 @@ class ConnectionDB {
    *
    * Starts by doing a binary search to find the approximate location, then
    * linearly searches nearby for the exact connection.
-   * @param {!RenderedConnection} conn The connection to find.
-   * @param {number} yPos The y position used to find the index of the
-   *     connection.
-   * @return {number} The index of the connection, or -1 if the connection was
-   *     not found.
-   * @private
+   * @param conn The connection to find.
+   * @param yPos The y position used to find the index of the connection.
+   * @return The index of the connection, or -1 if the connection was not found.
    */
-  findIndexOfConnection_(conn, yPos) {
+  private findIndexOfConnection_(conn: RenderedConnection, yPos: number):
+      number {
     if (!this.connections_.length) {
       return -1;
     }
@@ -116,12 +99,10 @@ class ConnectionDB {
 
   /**
    * Finds the correct index for the given y position.
-   * @param {number} yPos The y position used to decide where to
-   *    insert the connection.
-   * @return {number} The candidate index.
-   * @private
+   * @param yPos The y position used to decide where to insert the connection.
+   * @return The candidate index.
    */
-  calculateIndexForYPos_(yPos) {
+  private calculateIndexForYPos_(yPos: number): number {
     if (!this.connections_.length) {
       return 0;
     }
@@ -143,12 +124,11 @@ class ConnectionDB {
 
   /**
    * Remove a connection from the database.  Must already exist in DB.
-   * @param {!RenderedConnection} connection The connection to be removed.
-   * @param {number} yPos The y position used to find the index of the
-   *     connection.
+   * @param connection The connection to be removed.
+   * @param yPos The y position used to find the index of the connection.
    * @throws {Error} If the connection cannot be found in the database.
    */
-  removeConnection(connection, yPos) {
+  removeConnection(connection: RenderedConnection, yPos: number) {
     const index = this.findIndexOfConnection_(connection, yPos);
     if (index === -1) {
       throw Error('Unable to find connection in connectionDB.');
@@ -159,12 +139,12 @@ class ConnectionDB {
   /**
    * Find all nearby connections to the given connection.
    * Type checking does not apply, since this function is used for bumping.
-   * @param {!RenderedConnection} connection The connection whose
-   *     neighbours should be returned.
-   * @param {number} maxRadius The maximum radius to another connection.
-   * @return {!Array<!RenderedConnection>} List of connections.
+   * @param connection The connection whose neighbours should be returned.
+   * @param maxRadius The maximum radius to another connection.
+   * @return List of connections.
    */
-  getNeighbours(connection, maxRadius) {
+  getNeighbours(connection: RenderedConnection, maxRadius: number):
+      RenderedConnection[] {
     const db = this.connections_;
     const currentX = connection.x;
     const currentY = connection.y;
@@ -182,16 +162,16 @@ class ConnectionDB {
       pointerMid = Math.floor((pointerMin + pointerMax) / 2);
     }
 
-    const neighbours = [];
+    const neighbours: RenderedConnection[] = [];
     /**
      * Computes if the current connection is within the allowed radius of
      * another connection. This function is a closure and has access to outside
      * variables.
-     * @param {number} yIndex The other connection's index in the database.
-     * @return {boolean} True if the current connection's vertical distance from
-     *     the other connection is less than the allowed radius.
+     * @param yIndex The other connection's index in the database.
+     * @return True if the current connection's vertical distance from the other
+     *     connection is less than the allowed radius.
      */
-    function checkConnection_(yIndex) {
+    function checkConnection_(yIndex: number): boolean {
       const dx = currentX - db[yIndex].x;
       const dy = currentY - db[yIndex].y;
       const r = Math.sqrt(dx * dx + dy * dy);
@@ -219,29 +199,28 @@ class ConnectionDB {
   /**
    * Is the candidate connection close to the reference connection.
    * Extremely fast; only looks at Y distance.
-   * @param {number} index Index in database of candidate connection.
-   * @param {number} baseY Reference connection's Y value.
-   * @param {number} maxRadius The maximum radius to another connection.
-   * @return {boolean} True if connection is in range.
-   * @private
+   * @param index Index in database of candidate connection.
+   * @param baseY Reference connection's Y value.
+   * @param maxRadius The maximum radius to another connection.
+   * @return True if connection is in range.
    */
-  isInYRange_(index, baseY, maxRadius) {
-    return (Math.abs(this.connections_[index].y - baseY) <= maxRadius);
+  private isInYRange_(index: number, baseY: number, maxRadius: number):
+      boolean {
+    return Math.abs(this.connections_[index].y - baseY) <= maxRadius;
   }
 
   /**
    * Find the closest compatible connection to this connection.
-   * @param {!RenderedConnection} conn The connection searching for a compatible
-   *     mate.
-   * @param {number} maxRadius The maximum radius to another connection.
-   * @param {!Coordinate} dxy Offset between this connection's
-   *     location in the database and the current location (as a result of
-   *     dragging).
-   * @return {!{connection: RenderedConnection, radius: number}}
-   *     Contains two properties: 'connection' which is either another
+   * @param conn The connection searching for a compatible mate.
+   * @param maxRadius The maximum radius to another connection.
+   * @param dxy Offset between this connection's location in the database and
+   *     the current location (as a result of dragging).
+   * @return Contains two properties: 'connection' which is either another
    *     connection or null, and 'radius' which is the distance.
    */
-  searchForClosest(conn, maxRadius, dxy) {
+  searchForClosest(
+      conn: RenderedConnection, maxRadius: number,
+      dxy: Coordinate): {connection: RenderedConnection|null, radius: number} {
     if (!this.connections_.length) {
       // Don't bother.
       return {connection: null, radius: maxRadius};
@@ -267,7 +246,7 @@ class ConnectionDB {
     let pointerMin = closestIndex - 1;
     while (pointerMin >= 0 && this.isInYRange_(pointerMin, conn.y, maxRadius)) {
       temp = this.connections_[pointerMin];
-      if (this.connectionChecker_.canConnect(conn, temp, true, bestRadius)) {
+      if (this.connectionChecker.canConnect(conn, temp, true, bestRadius)) {
         bestConnection = temp;
         bestRadius = temp.distanceFrom(conn);
       }
@@ -278,7 +257,7 @@ class ConnectionDB {
     while (pointerMax < this.connections_.length &&
            this.isInYRange_(pointerMax, conn.y, maxRadius)) {
       temp = this.connections_[pointerMax];
-      if (this.connectionChecker_.canConnect(conn, temp, true, bestRadius)) {
+      if (this.connectionChecker.canConnect(conn, temp, true, bestRadius)) {
         bestConnection = temp;
         bestRadius = temp.distanceFrom(conn);
       }
@@ -288,19 +267,17 @@ class ConnectionDB {
     // Reset the values of x and y.
     conn.x = baseX;
     conn.y = baseY;
-
     // If there were no valid connections, bestConnection will be null.
     return {connection: bestConnection, radius: bestRadius};
   }
 
   /**
    * Initialize a set of connection DBs for a workspace.
-   * @param {!IConnectionChecker} checker The workspace's
-   *     connection checker, used to decide if connections are valid during a
-   *     drag.
-   * @return {!Array<!ConnectionDB>} Array of databases.
+   * @param checker The workspace's connection checker, used to decide if
+   *     connections are valid during a drag.
+   * @return Array of databases.
    */
-  static init(checker) {
+  static init(checker: IConnectionChecker): ConnectionDB[] {
     // Create four databases, one for each connection type.
     const dbList = [];
     dbList[ConnectionType.INPUT_VALUE] = new ConnectionDB(checker);
@@ -310,5 +287,3 @@ class ConnectionDB {
     return dbList;
   }
 }
-
-exports.ConnectionDB = ConnectionDB;

package/core/connection_type.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Enum for the type of a connection or input.
+ * @alias Blockly.ConnectionType
+ */
+export declare enum ConnectionType {
+    INPUT_VALUE = 1,
+    OUTPUT_VALUE = 2,
+    NEXT_STATEMENT = 3,
+    PREVIOUS_STATEMENT = 4
+}

package/core/{connection_type.js → connection_type.ts}

@@ -8,29 +8,25 @@
  * @fileoverview An enum for the possible types of connections.
  */
 
-'use strict';
-
 /**
  * An enum for the possible types of connections.
  * @namespace Blockly.ConnectionType
  */
-goog.module('Blockly.ConnectionType');
+import * as goog from '../closure/goog/goog.js';
+goog.declareModuleId('Blockly.ConnectionType');
 
 
 /**
  * Enum for the type of a connection or input.
- * @enum {number}
  * @alias Blockly.ConnectionType
  */
-const ConnectionType = {
+export enum ConnectionType {
   // A right-facing value input.  E.g. 'set item to' or 'return'.
-  INPUT_VALUE: 1,
+  INPUT_VALUE = 1,
   // A left-facing value output.  E.g. 'random fraction'.
-  OUTPUT_VALUE: 2,
+  OUTPUT_VALUE,
   // A down-facing block stack.  E.g. 'if-do' or 'else'.
-  NEXT_STATEMENT: 3,
+  NEXT_STATEMENT,
   // An up-facing block stack.  E.g. 'break out of loop'.
-  PREVIOUS_STATEMENT: 4,
-};
-
-exports.ConnectionType = ConnectionType;
+  PREVIOUS_STATEMENT
+}

package/core/constants.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * The language-neutral ID given to the collapsed input.
+ * @alias Blockly.constants.COLLAPSED_INPUT_NAME
+ */
+export declare const COLLAPSED_INPUT_NAME = "_TEMP_COLLAPSED_INPUT";
+/**
+ * The language-neutral ID given to the collapsed field.
+ * @alias Blockly.constants.COLLAPSED_FIELD_NAME
+ */
+export declare const COLLAPSED_FIELD_NAME = "_TEMP_COLLAPSED_FIELD";

package/core/{constants.js → constants.ts}

@@ -7,27 +7,23 @@
 /**
  * @fileoverview Blockly constants.
  */
-'use strict';
 
 /**
  * Blockly constants.
  * @namespace Blockly.constants
  */
-goog.module('Blockly.constants');
+import * as goog from '../closure/goog/goog.js';
+goog.declareModuleId('Blockly.constants');
 
 
 /**
  * The language-neutral ID given to the collapsed input.
- * @const {string}
  * @alias Blockly.constants.COLLAPSED_INPUT_NAME
  */
-const COLLAPSED_INPUT_NAME = '_TEMP_COLLAPSED_INPUT';
-exports.COLLAPSED_INPUT_NAME = COLLAPSED_INPUT_NAME;
+export const COLLAPSED_INPUT_NAME = '_TEMP_COLLAPSED_INPUT';
 
 /**
  * The language-neutral ID given to the collapsed field.
- * @const {string}
  * @alias Blockly.constants.COLLAPSED_FIELD_NAME
  */
-const COLLAPSED_FIELD_NAME = '_TEMP_COLLAPSED_FIELD';
-exports.COLLAPSED_FIELD_NAME = COLLAPSED_FIELD_NAME;
+export const COLLAPSED_FIELD_NAME = '_TEMP_COLLAPSED_FIELD';

package/core/contextmenu.d.ts

@@ -0,0 +1,80 @@
+/**
+ * @license
+ * Copyright 2011 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Block } from './block.js';
+import type { ContextMenuOption, LegacyContextMenuOption } from './contextmenu_registry.js';
+import { WorkspaceCommentSvg } from './workspace_comment_svg.js';
+import type { WorkspaceSvg } from './workspace_svg.js';
+/**
+ * Gets the block the context menu is currently attached to.
+ * @return The block the context menu is attached to.
+ * @alias Blockly.ContextMenu.getCurrentBlock
+ */
+export declare function getCurrentBlock(): Block | null;
+/**
+ * Sets the block the context menu is currently attached to.
+ * @param block The block the context menu is attached to.
+ * @alias Blockly.ContextMenu.setCurrentBlock
+ */
+export declare function setCurrentBlock(block: Block | null): void;
+/**
+ * Construct the menu based on the list of options and show the menu.
+ * @param e Mouse event.
+ * @param options Array of menu options.
+ * @param rtl True if RTL, false if LTR.
+ * @alias Blockly.ContextMenu.show
+ */
+export declare function show(e: Event, options: (ContextMenuOption | LegacyContextMenuOption)[], rtl: boolean): void;
+/**
+ * Hide the context menu.
+ * @alias Blockly.ContextMenu.hide
+ */
+export declare function hide(): void;
+/**
+ * Dispose of the menu.
+ * @alias Blockly.ContextMenu.dispose
+ */
+export declare function dispose(): void;
+/**
+ * Create a callback function that creates and configures a block,
+ *   then places the new block next to the original.
+ * @param block Original block.
+ * @param xml XML representation of new block.
+ * @return Function that creates a block.
+ * @alias Blockly.ContextMenu.callbackFactory
+ */
+export declare function callbackFactory(block: Block, xml: Element): Function;
+/**
+ * Make a context menu option for deleting the current workspace comment.
+ * @param comment The workspace comment where the
+ *     right-click originated.
+ * @return A menu option,
+ *     containing text, enabled, and a callback.
+ * @alias Blockly.ContextMenu.commentDeleteOption
+ * @internal
+ */
+export declare function commentDeleteOption(comment: WorkspaceCommentSvg): LegacyContextMenuOption;
+/**
+ * Make a context menu option for duplicating the current workspace comment.
+ * @param comment The workspace comment where the
+ *     right-click originated.
+ * @return A menu option,
+ *     containing text, enabled, and a callback.
+ * @alias Blockly.ContextMenu.commentDuplicateOption
+ * @internal
+ */
+export declare function commentDuplicateOption(comment: WorkspaceCommentSvg): LegacyContextMenuOption;
+/**
+ * Make a context menu option for adding a comment on the workspace.
+ * @param ws The workspace where the right-click
+ *     originated.
+ * @param e The right-click mouse event.
+ * @return A menu option, containing text, enabled, and a callback.
+ * @suppress {strictModuleDepCheck,checkTypes} Suppress checks while workspace
+ *     comments are not bundled in.
+ * @alias Blockly.ContextMenu.workspaceCommentOption
+ * @internal
+ */
+export declare function workspaceCommentOption(ws: WorkspaceSvg, e: Event): ContextMenuOption;