nodeskini 1.0.0 → 1.0.2

package/blocklySkini/blockly/core/connection_checker.js

@@ -0,0 +1,285 @@
+/**
+ * @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.
+ * @author fenichel@google.com (Rachel Fenichel)
+ */
+'use strict';
+
+goog.provide('Blockly.ConnectionChecker');
+
+goog.require('Blockly.registry');
+
+goog.requireType('Blockly.Connection');
+goog.requireType('Blockly.IConnectionChecker');
+
+
+/**
+ * Class for connection type checking logic.
+ * @implements {Blockly.IConnectionChecker}
+ * @constructor
+ */
+Blockly.ConnectionChecker = function() {
+};
+
+/**
+ * Check whether the current connection can connect with the target
+ * connection.
+ * @param {Blockly.Connection} a Connection to check compatibility with.
+ * @param {Blockly.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
+ */
+Blockly.ConnectionChecker.prototype.canConnect = function(a, b,
+    isDragging, opt_distance) {
+  return this.canConnectWithReason(a, b, isDragging, opt_distance) ==
+      Blockly.Connection.CAN_CONNECT;
+};
+
+/**
+ * Checks whether the current connection can connect with the target
+ * connection, and return an error code if there are problems.
+ * @param {Blockly.Connection} a Connection to check compatibility with.
+ * @param {Blockly.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} Blockly.Connection.CAN_CONNECT if the connection is legal,
+ *    an error code otherwise.
+ * @public
+ */
+Blockly.ConnectionChecker.prototype.canConnectWithReason = function(
+    a, b, isDragging, opt_distance) {
+  var safety = this.doSafetyChecks(a, b);
+  if (safety != Blockly.Connection.CAN_CONNECT) {
+    return safety;
+  }
+
+  // If the safety checks passed, both connections are non-null.
+  var connOne = /** @type {!Blockly.Connection} **/ (a);
+  var connTwo = /** @type {!Blockly.Connection} **/ (b);
+  if (!this.doTypeChecks(connOne, connTwo)) {
+    return Blockly.Connection.REASON_CHECKS_FAILED;
+  }
+
+  if (isDragging &&
+      !this.doDragChecks(
+          /** @type {!Blockly.RenderedConnection} **/ (a),
+          /** @type {!Blockly.RenderedConnection} **/ (b),
+          opt_distance || 0)) {
+    return Blockly.Connection.REASON_DRAG_CHECKS_FAILED;
+  }
+
+  return Blockly.Connection.CAN_CONNECT;
+};
+
+/**
+ * Helper method that translates a connection error code into a string.
+ * @param {number} errorCode The error code.
+ * @param {Blockly.Connection} a One of the two connections being checked.
+ * @param {Blockly.Connection} b The second of the two connections being
+ *     checked.
+ * @return {string} A developer-readable error string.
+ * @public
+ */
+Blockly.ConnectionChecker.prototype.getErrorMessage = function(errorCode,
+    a, b) {
+  switch (errorCode) {
+    case Blockly.Connection.REASON_SELF_CONNECTION:
+      return 'Attempted to connect a block to itself.';
+    case Blockly.Connection.REASON_DIFFERENT_WORKSPACES:
+      // Usually this means one block has been deleted.
+      return 'Blocks not on same workspace.';
+    case Blockly.Connection.REASON_WRONG_TYPE:
+      return 'Attempt to connect incompatible types.';
+    case Blockly.Connection.REASON_TARGET_NULL:
+      return 'Target connection is null.';
+    case Blockly.Connection.REASON_CHECKS_FAILED:
+      var connOne = /** @type {!Blockly.Connection} **/ (a);
+      var connTwo = /** @type {!Blockly.Connection} **/ (b);
+      var msg = 'Connection checks failed. ';
+      msg += connOne + ' expected ' + connOne.getCheck() + ', found ' + connTwo.getCheck();
+      return msg;
+    case Blockly.Connection.REASON_SHADOW_PARENT:
+      return 'Connecting non-shadow to shadow block.';
+    case Blockly.Connection.REASON_DRAG_CHECKS_FAILED:
+      return 'Drag checks failed.';
+    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 {Blockly.Connection} a The first of the connections to check.
+ * @param {Blockly.Connection} b The second of the connections to check.
+ * @return {number} An enum with the reason this connection is safe or unsafe.
+ * @public
+ */
+Blockly.ConnectionChecker.prototype.doSafetyChecks = function(a, b) {
+  if (!a || !b) {
+    return Blockly.Connection.REASON_TARGET_NULL;
+  }
+  if (a.isSuperior()) {
+    var blockA = a.getSourceBlock();
+    var blockB = b.getSourceBlock();
+  } else {
+    var blockB = a.getSourceBlock();
+    var blockA = b.getSourceBlock();
+  }
+  if (blockA == blockB) {
+    return Blockly.Connection.REASON_SELF_CONNECTION;
+  } else if (b.type != Blockly.OPPOSITE_TYPE[a.type]) {
+    return Blockly.Connection.REASON_WRONG_TYPE;
+  } else if (blockA.workspace !== blockB.workspace) {
+    return Blockly.Connection.REASON_DIFFERENT_WORKSPACES;
+  } else if (blockA.isShadow() && !blockB.isShadow()) {
+    return Blockly.Connection.REASON_SHADOW_PARENT;
+  }
+  return Blockly.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 {!Blockly.Connection} a Connection to compare.
+ * @param {!Blockly.Connection} b Connection to compare against.
+ * @return {boolean} True if the connections share a type.
+ * @public
+ */
+Blockly.ConnectionChecker.prototype.doTypeChecks = function(a, b) {
+  var checkArrayOne = a.getCheck();
+  var 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 (var 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 {!Blockly.RenderedConnection} a Connection to compare.
+ * @param {!Blockly.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
+ */
+Blockly.ConnectionChecker.prototype.doDragChecks = function(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 Blockly.PREVIOUS_STATEMENT:
+      return this.canConnectToPrevious_(a, b);
+    case Blockly.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 Blockly.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 Blockly.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 (Blockly.draggingConnections.indexOf(b) != -1) {
+    return false;
+  }
+
+  return true;
+};
+
+/**
+ * Helper function for drag checking.
+ * @param {!Blockly.Connection} a The connection to check, which must be a
+ *     statement input or next connection.
+ * @param {!Blockly.Connection} b A nearby connection to check, which
+ *     must be a previous connection.
+ * @return {boolean} True if the connection is allowed, false otherwise.
+ * @protected
+ */
+Blockly.ConnectionChecker.prototype.canConnectToPrevious_ = function(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 (Blockly.draggingConnections.indexOf(b) != -1) {
+    return false;
+  }
+
+  if (!b.targetConnection) {
+    return true;
+  }
+
+  var 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();
+};
+
+Blockly.registry.register(Blockly.registry.Type.CONNECTION_CHECKER,
+    Blockly.registry.DEFAULT, Blockly.ConnectionChecker);

package/blocklySkini/blockly/core/connection_db.js

@@ -0,0 +1,295 @@
+/**
+ * @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.
+ * @author fraser@google.com (Neil Fraser)
+ */
+'use strict';
+
+goog.provide('Blockly.ConnectionDB');
+
+goog.require('Blockly.RenderedConnection');
+
+goog.requireType('Blockly.IConnectionChecker');
+
+
+/**
+ * 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 {!Blockly.IConnectionChecker} checker The workspace's
+ *     connection type checker, used to decide if connections are valid during a
+ *     drag.
+ * @constructor
+ */
+Blockly.ConnectionDB = function(checker) {
+  /**
+   * Array of connections sorted by y position in workspace units.
+   * @type {!Array.<!Blockly.RenderedConnection>}
+   * @private
+   */
+  this.connections_ = [];
+  /**
+   * The workspace's connection type checker, used to decide if connections are
+   * valid during a drag.
+   * @type {!Blockly.IConnectionChecker}
+   * @private
+   */
+  this.connectionChecker_ = checker;
+};
+
+/**
+ * Add a connection to the database. Should not already exist in the database.
+ * @param {!Blockly.RenderedConnection} connection The connection to be added.
+ * @param {number} yPos The y position used to decide where to insert the
+ *    connection.
+ * @package
+ */
+Blockly.ConnectionDB.prototype.addConnection = function(connection, yPos) {
+  var 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 {!Blockly.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
+ */
+Blockly.ConnectionDB.prototype.findIndexOfConnection_ = function(conn, yPos) {
+  if (!this.connections_.length) {
+    return -1;
+  }
+
+  var 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.
+  var pointerMin = bestGuess;
+  var pointerMax = bestGuess;
+  while (pointerMin >= 0 && this.connections_[pointerMin].y == yPos) {
+    if (this.connections_[pointerMin] == conn) {
+      return pointerMin;
+    }
+    pointerMin--;
+  }
+
+  while (pointerMax < this.connections_.length &&
+         this.connections_[pointerMax].y == yPos) {
+    if (this.connections_[pointerMax] == conn) {
+      return pointerMax;
+    }
+    pointerMax++;
+  }
+  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
+ */
+Blockly.ConnectionDB.prototype.calculateIndexForYPos_ = function(yPos) {
+  if (!this.connections_.length) {
+    return 0;
+  }
+  var pointerMin = 0;
+  var pointerMax = this.connections_.length;
+  while (pointerMin < pointerMax) {
+    var 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 {!Blockly.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.
+ */
+Blockly.ConnectionDB.prototype.removeConnection = function(connection, yPos) {
+  var 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 {!Blockly.RenderedConnection} connection The connection whose
+ *     neighbours should be returned.
+ * @param {number} maxRadius The maximum radius to another connection.
+ * @return {!Array.<!Blockly.RenderedConnection>} List of connections.
+ */
+Blockly.ConnectionDB.prototype.getNeighbours = function(connection, maxRadius) {
+  var db = this.connections_;
+  var currentX = connection.x;
+  var currentY = connection.y;
+
+  // Binary search to find the closest y location.
+  var pointerMin = 0;
+  var pointerMax = db.length - 2;
+  var pointerMid = pointerMax;
+  while (pointerMin < pointerMid) {
+    if (db[pointerMid].y < currentY) {
+      pointerMin = pointerMid;
+    } else {
+      pointerMax = pointerMid;
+    }
+    pointerMid = Math.floor((pointerMin + pointerMax) / 2);
+  }
+
+  var 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) {
+    var dx = currentX - db[yIndex].x;
+    var dy = currentY - db[yIndex].y;
+    var 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
+ */
+Blockly.ConnectionDB.prototype.isInYRange_ = function(index, baseY, maxRadius) {
+  return (Math.abs(this.connections_[index].y - baseY) <= maxRadius);
+};
+
+/**
+ * Find the closest compatible connection to this connection.
+ * @param {!Blockly.RenderedConnection} conn The connection searching for a compatible
+ *     mate.
+ * @param {number} maxRadius The maximum radius to another connection.
+ * @param {!Blockly.utils.Coordinate} dxy Offset between this connection's
+ *     location in the database and the current location (as a result of
+ *     dragging).
+ * @return {!{connection: Blockly.RenderedConnection, radius: number}}
+ *     Contains two properties: 'connection' which is either another
+ *     connection or null, and 'radius' which is the distance.
+ */
+Blockly.ConnectionDB.prototype.searchForClosest = function(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.
+  var baseY = conn.y;
+  var 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.
+  var closestIndex = this.calculateIndexForYPos_(conn.y);
+
+  var bestConnection = null;
+  var bestRadius = maxRadius;
+  var temp;
+
+  // Walk forward and back on the y axis looking for the closest x,y point.
+  var 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--;
+  }
+
+  var 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 {!Blockly.IConnectionChecker} checker The workspace's
+ *     connection checker, used to decide if connections are valid during a drag.
+ * @return {!Array.<!Blockly.ConnectionDB>} Array of databases.
+ */
+Blockly.ConnectionDB.init = function(checker) {
+  // Create four databases, one for each connection type.
+  var dbList = [];
+  dbList[Blockly.INPUT_VALUE] = new Blockly.ConnectionDB(checker);
+  dbList[Blockly.OUTPUT_VALUE] = new Blockly.ConnectionDB(checker);
+  dbList[Blockly.NEXT_STATEMENT] = new Blockly.ConnectionDB(checker);
+  dbList[Blockly.PREVIOUS_STATEMENT] = new Blockly.ConnectionDB(checker);
+  return dbList;
+};