blockly 7.20211209.4 → 8.0.1

package/core/connection_db.js

@@ -34,276 +34,281 @@ 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.
- * @param {!IConnectionChecker} checker The workspace's
- *     connection type checker, used to decide if connections are valid during a
- *     drag.
- * @constructor
  * @alias Blockly.ConnectionDB
  */
-const ConnectionDB = function(checker) {
+class ConnectionDB {
   /**
-   * Array of connections sorted by y position in workspace units.
-   * @type {!Array<!RenderedConnection>}
-   * @private
+   * @param {!IConnectionChecker} checker The workspace's
+   *     connection type checker, used to decide if connections are valid during
+   * a drag.
    */
-  this.connections_ = [];
+  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;
+  }
+
   /**
-   * The workspace's connection type checker, used to decide if connections are
-   * valid during a drag.
-   * @type {!IConnectionChecker}
-   * @private
+   * 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
    */
-  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
- */
-ConnectionDB.prototype.addConnection = function(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
- */
-ConnectionDB.prototype.findIndexOfConnection_ = function(conn, yPos) {
-  if (!this.connections_.length) {
-    return -1;
+  addConnection(connection, yPos) {
+    const index = this.calculateIndexForYPos_(yPos);
+    this.connections_.splice(index, 0, connection);
   }
 
-  const bestGuess = this.calculateIndexForYPos_(yPos);
-  if (bestGuess >= this.connections_.length) {
-    // Not in list
-    return -1;
-  }
+  /**
+   * 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;
+    }
 
-  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;
+    const bestGuess = this.calculateIndexForYPos_(yPos);
+    if (bestGuess >= this.connections_.length) {
+      // Not in list
+      return -1;
     }
-    pointer--;
-  }
 
-  pointer = bestGuess;
-  while (pointer < this.connections_.length &&
-         this.connections_[pointer].y === yPos) {
-    if (this.connections_[pointer] === conn) {
-      return pointer;
+    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++;
-  }
-  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
- */
-ConnectionDB.prototype.calculateIndexForYPos_ = function(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;
+    pointer = bestGuess;
+    while (pointer < this.connections_.length &&
+           this.connections_[pointer].y === yPos) {
+      if (this.connections_[pointer] === conn) {
+        return pointer;
+      }
+      pointer++;
     }
+    return -1;
   }
-  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.
- */
-ConnectionDB.prototype.removeConnection = function(connection, yPos) {
-  const index = this.findIndexOfConnection_(connection, yPos);
-  if (index === -1) {
-    throw Error('Unable to find connection in 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
+   */
+  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;
   }
-  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.
- */
-ConnectionDB.prototype.getNeighbours = function(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;
+  /**
+   * 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.');
     }
-    pointerMid = Math.floor((pointerMin + pointerMax) / 2);
+    this.connections_.splice(index, 1);
   }
 
-  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.
+   * 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.
    */
-  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]);
+  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);
     }
-    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--;
+    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;
     }
-    do {
-      pointerMax++;
-    } while (pointerMax < db.length && checkConnection_(pointerMax));
-  }
 
-  return neighbours;
-};
+    // 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));
+    }
 
-/**
- * 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
- */
-ConnectionDB.prototype.isInYRange_ = function(index, baseY, maxRadius) {
-  return (Math.abs(this.connections_[index].y - baseY) <= maxRadius);
-};
+    return neighbours;
+  }
 
-/**
- * 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.
- */
-ConnectionDB.prototype.searchForClosest = function(conn, maxRadius, dxy) {
-  if (!this.connections_.length) {
-    // Don't bother.
-    return {connection: null, radius: maxRadius};
+  /**
+   * 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);
   }
 
-  // Stash the values of x and y from before the drag.
-  const baseY = conn.y;
-  const baseX = conn.x;
+  /**
+   * 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;
+    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);
+    // 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;
+    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);
+    // 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--;
     }
-    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);
+    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++;
     }
-    pointerMax++;
-  }
 
-  // Reset the values of x and y.
-  conn.x = baseX;
-  conn.y = baseY;
+    // 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};
-};
+    // 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.
- */
-ConnectionDB.init = function(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;
-};
+  /**
+   * 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/contextmenu.js

@@ -23,11 +23,13 @@ const clipboard = goog.require('Blockly.clipboard');
 const deprecation = goog.require('Blockly.utils.deprecation');
 const dom = goog.require('Blockly.utils.dom');
 const eventUtils = goog.require('Blockly.Events.utils');
-const internalConstants = goog.require('Blockly.internalConstants');
 const userAgent = goog.require('Blockly.utils.userAgent');
 const svgMath = goog.require('Blockly.utils.svgMath');
 /* eslint-disable-next-line no-unused-vars */
 const {Block} = goog.requireType('Blockly.Block');
+/* eslint-disable-next-line no-unused-vars */
+const {BlockSvg} = goog.requireType('Blockly.BlockSvg');
+const {config} = goog.require('Blockly.config');
 const {Coordinate} = goog.require('Blockly.utils.Coordinate');
 const {MenuItem} = goog.require('Blockly.MenuItem');
 const {Menu} = goog.require('Blockly.Menu');
@@ -262,15 +264,16 @@ const callbackFactory = function(block, xml) {
     eventUtils.disable();
     let newBlock;
     try {
-      newBlock = Xml.domToBlock(xml, block.workspace);
+      newBlock =
+          /** @type {!BlockSvg} */ (Xml.domToBlock(xml, block.workspace));
       // Move the new block next to the old block.
       const xy = block.getRelativeToSurfaceXY();
       if (block.RTL) {
-        xy.x -= internalConstants.SNAP_RADIUS;
+        xy.x -= config.snapRadius;
       } else {
-        xy.x += internalConstants.SNAP_RADIUS;
+        xy.x += config.snapRadius;
       }
-      xy.y += internalConstants.SNAP_RADIUS * 2;
+      xy.y += config.snapRadius * 2;
       newBlock.moveBy(xy.x, xy.y);
     } finally {
       eventUtils.enable();
@@ -339,7 +342,7 @@ exports.commentDuplicateOption = commentDuplicateOption;
  * @alias Blockly.ContextMenu.workspaceCommentOption
  */
 const workspaceCommentOption = function(ws, e) {
-  const WorkspaceCommentSvg = goog.module.get('Blockly.WorkspaceCommentSvg');
+  const {WorkspaceCommentSvg} = goog.module.get('Blockly.WorkspaceCommentSvg');
   if (!WorkspaceCommentSvg) {
     throw Error('Missing require for Blockly.WorkspaceCommentSvg');
   }

package/core/contextmenu_items.js

@@ -239,8 +239,7 @@ const addDeletableBlocks_ = function(block, deleteList) {
   if (block.isDeletable()) {
     Array.prototype.push.apply(deleteList, block.getDescendants(false));
   } else {
-    const children = /* eslint-disable-next-line indent */
-        /** @type {!Array<!BlockSvg>} */ (block.getChildren(false));
+    const children = block.getChildren(false);
     for (let i = 0; i < children.length; i++) {
       addDeletableBlocks_(children[i], deleteList);
     }