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

package/core/connection_checker.js

@@ -1,312 +0,0 @@
-/**
- * @license
- * Copyright 2020 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @fileoverview An object that encapsulates logic for checking whether a
- * potential connection is safe and valid.
- */
-'use strict';
-
-/**
- * An object that encapsulates logic for checking whether a
- * potential connection is safe and valid.
- * @class
- */
-goog.module('Blockly.ConnectionChecker');
-
-const common = goog.require('Blockly.common');
-const internalConstants = goog.require('Blockly.internalConstants');
-const registry = goog.require('Blockly.registry');
-const {ConnectionType} = goog.require('Blockly.ConnectionType');
-const {Connection} = goog.require('Blockly.Connection');
-/* eslint-disable-next-line no-unused-vars */
-const {IConnectionChecker} = goog.require('Blockly.IConnectionChecker');
-/* eslint-disable-next-line no-unused-vars */
-const {RenderedConnection} = goog.requireType('Blockly.RenderedConnection');
-
-
-/**
- * Class for connection type checking logic.
- * @implements {IConnectionChecker}
- * @alias Blockly.ConnectionChecker
- */
-class ConnectionChecker {
-  /**
-   * Check whether the current connection can connect with the target
-   * connection.
-   * @param {Connection} a Connection to check compatibility with.
-   * @param {Connection} b Connection to check compatibility with.
-   * @param {boolean} isDragging True if the connection is being made by
-   *     dragging a block.
-   * @param {number=} opt_distance The max allowable distance between the
-   *     connections for drag checks.
-   * @return {boolean} Whether the connection is legal.
-   * @public
-   */
-  canConnect(a, b, isDragging, opt_distance) {
-    return this.canConnectWithReason(a, b, isDragging, opt_distance) ===
-        Connection.CAN_CONNECT;
-  }
-
-  /**
-   * Checks whether the current connection can connect with the target
-   * connection, and return an error code if there are problems.
-   * @param {Connection} a Connection to check compatibility with.
-   * @param {Connection} b Connection to check compatibility with.
-   * @param {boolean} isDragging True if the connection is being made by
-   *     dragging a block.
-   * @param {number=} opt_distance The max allowable distance between the
-   *     connections for drag checks.
-   * @return {number} Connection.CAN_CONNECT if the connection is legal,
-   *    an error code otherwise.
-   * @public
-   */
-  canConnectWithReason(a, b, isDragging, opt_distance) {
-    const safety = this.doSafetyChecks(a, b);
-    if (safety !== Connection.CAN_CONNECT) {
-      return safety;
-    }
-
-    // If the safety checks passed, both connections are non-null.
-    const connOne = /** @type {!Connection} **/ (a);
-    const connTwo = /** @type {!Connection} **/ (b);
-    if (!this.doTypeChecks(connOne, connTwo)) {
-      return Connection.REASON_CHECKS_FAILED;
-    }
-
-    if (isDragging &&
-        !this.doDragChecks(
-            /** @type {!RenderedConnection} **/ (a),
-            /** @type {!RenderedConnection} **/ (b), opt_distance || 0)) {
-      return Connection.REASON_DRAG_CHECKS_FAILED;
-    }
-
-    return Connection.CAN_CONNECT;
-  }
-
-  /**
-   * Helper method that translates a connection error code into a string.
-   * @param {number} errorCode The error code.
-   * @param {Connection} a One of the two connections being checked.
-   * @param {Connection} b The second of the two connections being
-   *     checked.
-   * @return {string} A developer-readable error string.
-   * @public
-   */
-  getErrorMessage(errorCode, a, b) {
-    switch (errorCode) {
-      case Connection.REASON_SELF_CONNECTION:
-        return 'Attempted to connect a block to itself.';
-      case Connection.REASON_DIFFERENT_WORKSPACES:
-        // Usually this means one block has been deleted.
-        return 'Blocks not on same workspace.';
-      case Connection.REASON_WRONG_TYPE:
-        return 'Attempt to connect incompatible types.';
-      case Connection.REASON_TARGET_NULL:
-        return 'Target connection is null.';
-      case Connection.REASON_CHECKS_FAILED: {
-        const connOne = /** @type {!Connection} **/ (a);
-        const connTwo = /** @type {!Connection} **/ (b);
-        let msg = 'Connection checks failed. ';
-        msg += connOne + ' expected ' + connOne.getCheck() + ', found ' +
-            connTwo.getCheck();
-        return msg;
-      }
-      case Connection.REASON_SHADOW_PARENT:
-        return 'Connecting non-shadow to shadow block.';
-      case Connection.REASON_DRAG_CHECKS_FAILED:
-        return 'Drag checks failed.';
-      case Connection.REASON_PREVIOUS_AND_OUTPUT:
-        return 'Block would have an output and a previous connection.';
-      default:
-        return 'Unknown connection failure: this should never happen!';
-    }
-  }
-
-  /**
-   * Check that connecting the given connections is safe, meaning that it would
-   * not break any of Blockly's basic assumptions (e.g. no self connections).
-   * @param {Connection} a The first of the connections to check.
-   * @param {Connection} b The second of the connections to check.
-   * @return {number} An enum with the reason this connection is safe or unsafe.
-   * @public
-   */
-  doSafetyChecks(a, b) {
-    if (!a || !b) {
-      return Connection.REASON_TARGET_NULL;
-    }
-    let superiorBlock;
-    let inferiorBlock;
-    let superiorConnection;
-    let inferiorConnection;
-    if (a.isSuperior()) {
-      superiorBlock = a.getSourceBlock();
-      inferiorBlock = b.getSourceBlock();
-      superiorConnection = a;
-      inferiorConnection = b;
-    } else {
-      inferiorBlock = a.getSourceBlock();
-      superiorBlock = b.getSourceBlock();
-      inferiorConnection = a;
-      superiorConnection = b;
-    }
-    if (superiorBlock === inferiorBlock) {
-      return Connection.REASON_SELF_CONNECTION;
-    } else if (
-        inferiorConnection.type !==
-        internalConstants.OPPOSITE_TYPE[superiorConnection.type]) {
-      return Connection.REASON_WRONG_TYPE;
-    } else if (superiorBlock.workspace !== inferiorBlock.workspace) {
-      return Connection.REASON_DIFFERENT_WORKSPACES;
-    } else if (superiorBlock.isShadow() && !inferiorBlock.isShadow()) {
-      return Connection.REASON_SHADOW_PARENT;
-    } else if (
-        inferiorConnection.type === ConnectionType.OUTPUT_VALUE &&
-        inferiorBlock.previousConnection &&
-        inferiorBlock.previousConnection.isConnected()) {
-      return Connection.REASON_PREVIOUS_AND_OUTPUT;
-    } else if (
-        inferiorConnection.type === ConnectionType.PREVIOUS_STATEMENT &&
-        inferiorBlock.outputConnection &&
-        inferiorBlock.outputConnection.isConnected()) {
-      return Connection.REASON_PREVIOUS_AND_OUTPUT;
-    }
-    return Connection.CAN_CONNECT;
-  }
-
-  /**
-   * Check whether this connection is compatible with another connection with
-   * respect to the value type system.  E.g. square_root("Hello") is not
-   * compatible.
-   * @param {!Connection} a Connection to compare.
-   * @param {!Connection} b Connection to compare against.
-   * @return {boolean} True if the connections share a type.
-   * @public
-   */
-  doTypeChecks(a, b) {
-    const checkArrayOne = a.getCheck();
-    const checkArrayTwo = b.getCheck();
-
-    if (!checkArrayOne || !checkArrayTwo) {
-      // One or both sides are promiscuous enough that anything will fit.
-      return true;
-    }
-    // Find any intersection in the check lists.
-    for (let i = 0; i < checkArrayOne.length; i++) {
-      if (checkArrayTwo.indexOf(checkArrayOne[i]) !== -1) {
-        return true;
-      }
-    }
-    // No intersection.
-    return false;
-  }
-
-  /**
-   * Check whether this connection can be made by dragging.
-   * @param {!RenderedConnection} a Connection to compare.
-   * @param {!RenderedConnection} b Connection to compare against.
-   * @param {number} distance The maximum allowable distance between
-   *     connections.
-   * @return {boolean} True if the connection is allowed during a drag.
-   * @public
-   */
-  doDragChecks(a, b, distance) {
-    if (a.distanceFrom(b) > distance) {
-      return false;
-    }
-
-    // Don't consider insertion markers.
-    if (b.getSourceBlock().isInsertionMarker()) {
-      return false;
-    }
-
-    switch (b.type) {
-      case ConnectionType.PREVIOUS_STATEMENT:
-        return this.canConnectToPrevious_(a, b);
-      case ConnectionType.OUTPUT_VALUE: {
-        // Don't offer to connect an already connected left (male) value plug to
-        // an available right (female) value plug.
-        if ((b.isConnected() && !b.targetBlock().isInsertionMarker()) ||
-            a.isConnected()) {
-          return false;
-        }
-        break;
-      }
-      case ConnectionType.INPUT_VALUE: {
-        // Offering to connect the left (male) of a value block to an already
-        // connected value pair is ok, we'll splice it in.
-        // However, don't offer to splice into an immovable block.
-        if (b.isConnected() && !b.targetBlock().isMovable() &&
-            !b.targetBlock().isShadow()) {
-          return false;
-        }
-        break;
-      }
-      case ConnectionType.NEXT_STATEMENT: {
-        // Don't let a block with no next connection bump other blocks out of
-        // the stack.  But covering up a shadow block or stack of shadow blocks
-        // is fine.  Similarly, replacing a terminal statement with another
-        // terminal statement is allowed.
-        if (b.isConnected() && !a.getSourceBlock().nextConnection &&
-            !b.targetBlock().isShadow() && b.targetBlock().nextConnection) {
-          return false;
-        }
-        break;
-      }
-      default:
-        // Unexpected connection type.
-        return false;
-    }
-
-    // Don't let blocks try to connect to themselves or ones they nest.
-    if (common.draggingConnections.indexOf(b) !== -1) {
-      return false;
-    }
-
-    return true;
-  }
-
-  /**
-   * Helper function for drag checking.
-   * @param {!Connection} a The connection to check, which must be a
-   *     statement input or next connection.
-   * @param {!Connection} b A nearby connection to check, which
-   *     must be a previous connection.
-   * @return {boolean} True if the connection is allowed, false otherwise.
-   * @protected
-   */
-  canConnectToPrevious_(a, b) {
-    if (a.targetConnection) {
-      // This connection is already occupied.
-      // A next connection will never disconnect itself mid-drag.
-      return false;
-    }
-
-    // Don't let blocks try to connect to themselves or ones they nest.
-    if (common.draggingConnections.indexOf(b) !== -1) {
-      return false;
-    }
-
-    if (!b.targetConnection) {
-      return true;
-    }
-
-    const targetBlock = b.targetBlock();
-    // If it is connected to a real block, game over.
-    if (!targetBlock.isInsertionMarker()) {
-      return false;
-    }
-    // If it's connected to an insertion marker but that insertion marker
-    // is the first block in a stack, it's still fine.  If that insertion
-    // marker is in the middle of a stack, it won't work.
-    return !targetBlock.getPreviousBlock();
-  }
-}
-
-registry.register(
-    registry.Type.CONNECTION_CHECKER, registry.DEFAULT, ConnectionChecker);
-
-exports.ConnectionChecker = ConnectionChecker;

package/core/connection_db.js

@@ -1,314 +0,0 @@
-/**
- * @license
- * Copyright 2011 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @fileoverview A database of all the rendered connections that could
- *    possibly be connected to (i.e. not collapsed, etc).
- *    Sorted by y coordinate.
- */
-'use strict';
-
-/**
- * A database of all the rendered connections that could
- *    possibly be connected to (i.e. not collapsed, etc).
- *    Sorted by y coordinate.
- * @class
- */
-goog.module('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');
-
-
-/**
- * Database of connections.
- * Connections are stored in order of their vertical component.  This way
- * connections in an area may be looked up quickly using a binary search.
- * @alias Blockly.ConnectionDB
- */
-class ConnectionDB {
-  /**
-   * @param {!IConnectionChecker} checker 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;
-  }
-
-  /**
-   * 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
-   */
-  addConnection(connection, yPos) {
-    const index = this.calculateIndexForYPos_(yPos);
-    this.connections_.splice(index, 0, connection);
-  }
-
-  /**
-   * Finds the index of the given connection.
-   *
-   * 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
-   */
-  findIndexOfConnection_(conn, yPos) {
-    if (!this.connections_.length) {
-      return -1;
-    }
-
-    const bestGuess = this.calculateIndexForYPos_(yPos);
-    if (bestGuess >= this.connections_.length) {
-      // Not in list
-      return -1;
-    }
-
-    yPos = conn.y;
-    // Walk forward and back on the y axis looking for the connection.
-    let pointer = bestGuess;
-    while (pointer >= 0 && this.connections_[pointer].y === yPos) {
-      if (this.connections_[pointer] === conn) {
-        return pointer;
-      }
-      pointer--;
-    }
-
-    pointer = bestGuess;
-    while (pointer < this.connections_.length &&
-           this.connections_[pointer].y === yPos) {
-      if (this.connections_[pointer] === conn) {
-        return pointer;
-      }
-      pointer++;
-    }
-    return -1;
-  }
-
-  /**
-   * 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
-   */
-  calculateIndexForYPos_(yPos) {
-    if (!this.connections_.length) {
-      return 0;
-    }
-    let pointerMin = 0;
-    let pointerMax = this.connections_.length;
-    while (pointerMin < pointerMax) {
-      const pointerMid = Math.floor((pointerMin + pointerMax) / 2);
-      if (this.connections_[pointerMid].y < yPos) {
-        pointerMin = pointerMid + 1;
-      } else if (this.connections_[pointerMid].y > yPos) {
-        pointerMax = pointerMid;
-      } else {
-        pointerMin = pointerMid;
-        break;
-      }
-    }
-    return pointerMin;
-  }
-
-  /**
-   * 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.
-   * @throws {Error} If the connection cannot be found in the database.
-   */
-  removeConnection(connection, yPos) {
-    const index = this.findIndexOfConnection_(connection, yPos);
-    if (index === -1) {
-      throw Error('Unable to find connection in connectionDB.');
-    }
-    this.connections_.splice(index, 1);
-  }
-
-  /**
-   * 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.
-   */
-  getNeighbours(connection, maxRadius) {
-    const db = this.connections_;
-    const currentX = connection.x;
-    const currentY = connection.y;
-
-    // Binary search to find the closest y location.
-    let pointerMin = 0;
-    let pointerMax = db.length - 2;
-    let pointerMid = pointerMax;
-    while (pointerMin < pointerMid) {
-      if (db[pointerMid].y < currentY) {
-        pointerMin = pointerMid;
-      } else {
-        pointerMax = pointerMid;
-      }
-      pointerMid = Math.floor((pointerMin + pointerMax) / 2);
-    }
-
-    const neighbours = [];
-    /**
-     * 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.
-     */
-    function checkConnection_(yIndex) {
-      const dx = currentX - db[yIndex].x;
-      const dy = currentY - db[yIndex].y;
-      const r = Math.sqrt(dx * dx + dy * dy);
-      if (r <= maxRadius) {
-        neighbours.push(db[yIndex]);
-      }
-      return dy < maxRadius;
-    }
-
-    // Walk forward and back on the y axis looking for the closest x,y point.
-    pointerMin = pointerMid;
-    pointerMax = pointerMid;
-    if (db.length) {
-      while (pointerMin >= 0 && checkConnection_(pointerMin)) {
-        pointerMin--;
-      }
-      do {
-        pointerMax++;
-      } while (pointerMax < db.length && checkConnection_(pointerMax));
-    }
-
-    return neighbours;
-  }
-
-  /**
-   * 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
-   */
-  isInYRange_(index, baseY, maxRadius) {
-    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
-   *     connection or null, and 'radius' which is the distance.
-   */
-  searchForClosest(conn, maxRadius, dxy) {
-    if (!this.connections_.length) {
-      // Don't bother.
-      return {connection: null, radius: maxRadius};
-    }
-
-    // Stash the values of x and y from before the drag.
-    const baseY = conn.y;
-    const baseX = conn.x;
-
-    conn.x = baseX + dxy.x;
-    conn.y = baseY + dxy.y;
-
-    // calculateIndexForYPos_ finds an index for insertion, which is always
-    // after any block with the same y index.  We want to search both forward
-    // and back, so search on both sides of the index.
-    const closestIndex = this.calculateIndexForYPos_(conn.y);
-
-    let bestConnection = null;
-    let bestRadius = maxRadius;
-    let temp;
-
-    // Walk forward and back on the y axis looking for the closest x,y point.
-    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)) {
-        bestConnection = temp;
-        bestRadius = temp.distanceFrom(conn);
-      }
-      pointerMin--;
-    }
-
-    let pointerMax = closestIndex;
-    while (pointerMax < this.connections_.length &&
-           this.isInYRange_(pointerMax, conn.y, maxRadius)) {
-      temp = this.connections_[pointerMax];
-      if (this.connectionChecker_.canConnect(conn, temp, true, bestRadius)) {
-        bestConnection = temp;
-        bestRadius = temp.distanceFrom(conn);
-      }
-      pointerMax++;
-    }
-
-    // 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.
-   */
-  static init(checker) {
-    // Create four databases, one for each connection type.
-    const dbList = [];
-    dbList[ConnectionType.INPUT_VALUE] = new ConnectionDB(checker);
-    dbList[ConnectionType.OUTPUT_VALUE] = new ConnectionDB(checker);
-    dbList[ConnectionType.NEXT_STATEMENT] = new ConnectionDB(checker);
-    dbList[ConnectionType.PREVIOUS_STATEMENT] = new ConnectionDB(checker);
-    return dbList;
-  }
-}
-
-exports.ConnectionDB = ConnectionDB;

package/core/connection_type.js

@@ -1,36 +0,0 @@
-/**
- * @license
- * Copyright 2021 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @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');
-
-
-/**
- * Enum for the type of a connection or input.
- * @enum {number}
- * @alias Blockly.ConnectionType
- */
-const ConnectionType = {
-  // A right-facing value input.  E.g. 'set item to' or 'return'.
-  INPUT_VALUE: 1,
-  // A left-facing value output.  E.g. 'random fraction'.
-  OUTPUT_VALUE: 2,
-  // A down-facing block stack.  E.g. 'if-do' or 'else'.
-  NEXT_STATEMENT: 3,
-  // An up-facing block stack.  E.g. 'break out of loop'.
-  PREVIOUS_STATEMENT: 4,
-};
-
-exports.ConnectionType = ConnectionType;

package/core/constants.js

@@ -1,33 +0,0 @@
-/**
- * @license
- * Copyright 2016 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @fileoverview Blockly constants.
- */
-'use strict';
-
-/**
- * Blockly constants.
- * @namespace Blockly.constants
- */
-goog.module('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;
-
-/**
- * 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;