blockly 8.0.4-beta.0 → 8.0.5-beta.0

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

@@ -7,108 +7,89 @@
 /**
  * @fileoverview Components for creating connections between blocks.
  */
-'use strict';
 
 /**
  * Components for creating connections between blocks.
  * @class
  */
-goog.module('Blockly.Connection');
-
-const Xml = goog.require('Blockly.Xml');
-const blocks = goog.require('Blockly.serialization.blocks');
-const eventUtils = goog.require('Blockly.Events.utils');
-/* eslint-disable-next-line no-unused-vars */
-const {Block} = goog.requireType('Blockly.Block');
-/* eslint-disable-next-line no-unused-vars */
-const {BlockMove} = goog.requireType('Blockly.Events.BlockMove');
-const {ConnectionType} = goog.require('Blockly.ConnectionType');
-/* eslint-disable-next-line no-unused-vars */
-const {IASTNodeLocationWithBlock} = goog.require('Blockly.IASTNodeLocationWithBlock');
-/* eslint-disable-next-line no-unused-vars */
-const {IConnectionChecker} = goog.requireType('Blockly.IConnectionChecker');
-/* eslint-disable-next-line no-unused-vars */
-const {Input} = goog.requireType('Blockly.Input');
-/** @suppress {extraRequire} */
-goog.require('Blockly.Events.BlockMove');
-/** @suppress {extraRequire} */
-goog.require('Blockly.constants');
+import * as goog from '../closure/goog/goog.js';
+goog.declareModuleId('Blockly.Connection');
+
+// Unused import preserved for side-effects. Remove if unneeded.
+// import './constants.js';
+
+import type {Block} from './block.js';
+import {ConnectionType} from './connection_type.js';
+import type {BlockMove} from './events/events_block_move.js';
+import * as eventUtils from './events/utils.js';
+import type {Input} from './input.js';
+import type {IASTNodeLocationWithBlock} from './interfaces/i_ast_node_location_with_block.js';
+import type {IConnectionChecker} from './interfaces/i_connection_checker.js';
+import * as blocks from './serialization/blocks.js';
+import * as Xml from './xml.js';
 
 
 /**
  * Class for a connection between blocks.
- * @implements {IASTNodeLocationWithBlock}
  * @alias Blockly.Connection
  */
-class Connection {
+export class Connection implements IASTNodeLocationWithBlock {
+  /** Constants for checking whether two connections are compatible. */
+  static CAN_CONNECT = 0;
+  static REASON_SELF_CONNECTION = 1;
+  static REASON_WRONG_TYPE = 2;
+  static REASON_TARGET_NULL = 3;
+  static REASON_CHECKS_FAILED = 4;
+  static REASON_DIFFERENT_WORKSPACES = 5;
+  static REASON_SHADOW_PARENT = 6;
+  static REASON_DRAG_CHECKS_FAILED = 7;
+  static REASON_PREVIOUS_AND_OUTPUT = 8;
+
+  protected sourceBlock_: Block;
+
+  /** Connection this connection connects to.  Null if not connected. */
+  targetConnection: Connection|null = null;
+
   /**
-   * @param {!Block} source The block establishing this connection.
-   * @param {number} type The type of the connection.
+   * Has this connection been disposed of?
+   * @internal
    */
-  constructor(source, type) {
-    /**
-     * @type {!Block}
-     * @protected
-     */
-    this.sourceBlock_ = source;
-    /** @type {number} */
-    this.type = type;
+  disposed = false;
 
-    /**
-     * Connection this connection connects to.  Null if not connected.
-     * @type {Connection}
-     */
-    this.targetConnection = null;
+  /** List of compatible value types.  Null if all types are compatible. */
+  private check_: string[]|null = null;
 
-    /**
-     * Has this connection been disposed of?
-     * @type {boolean}
-     * @package
-     */
-    this.disposed = false;
-
-    /**
-     * List of compatible value types.  Null if all types are compatible.
-     * @type {Array}
-     * @private
-     */
-    this.check_ = null;
-
-    /**
-     * DOM representation of a shadow block, or null if none.
-     * @type {Element}
-     * @private
-     */
-    this.shadowDom_ = null;
+  /** DOM representation of a shadow block, or null if none. */
+  private shadowDom_: Element|null = null;
 
-    /**
-     * Horizontal location of this connection.
-     * @type {number}
-     * @package
-     */
-    this.x = 0;
-
-    /**
-     * Vertical location of this connection.
-     * @type {number}
-     * @package
-     */
-    this.y = 0;
-
-    /**
-     * @type {?blocks.State}
-     * @private
-     */
-    this.shadowState_ = null;
+  /**
+   * Horizontal location of this connection.
+   * @internal
+   */
+  x = 0;
+
+  /**
+   * Vertical location of this connection.
+   * @internal
+   */
+  y = 0;
+
+  private shadowState_: blocks.State|null = null;
+
+  /**
+   * @param source The block establishing this connection.
+   * @param type The type of the connection.
+   */
+  constructor(source: Block, public type: number) {
+    this.sourceBlock_ = source;
   }
 
   /**
    * Connect two connections together.  This is the connection on the superior
    * block.
-   * @param {!Connection} childConnection Connection on inferior block.
-   * @protected
+   * @param childConnection Connection on inferior block.
    */
-  connect_(childConnection) {
+  protected connect_(childConnection: Connection) {
     const INPUT = ConnectionType.INPUT_VALUE;
     const parentConnection = this;
     const parentBlock = parentConnection.getSourceBlock();
@@ -124,8 +105,8 @@ class Connection {
     if (parentConnection.isConnected()) {
       const shadowState = parentConnection.stashShadowState_();
       const target = parentConnection.targetBlock();
-      if (target.isShadow()) {
-        target.dispose(false);
+      if (target!.isShadow()) {
+        target!.dispose(false);
       } else {
         parentConnection.disconnect();
         orphan = target;
@@ -136,8 +117,8 @@ class Connection {
     // Connect the new connection to the parent.
     let event;
     if (eventUtils.isEnabled()) {
-      event = /** @type {!BlockMove} */
-          (new (eventUtils.get(eventUtils.BLOCK_MOVE))(childBlock));
+      event =
+          new (eventUtils.get(eventUtils.BLOCK_MOVE))!(childBlock) as BlockMove;
     }
     connectReciprocally(parentConnection, childConnection);
     childBlock.setParent(parentBlock);
@@ -152,7 +133,7 @@ class Connection {
           orphan.outputConnection :
           orphan.previousConnection;
       const connection = Connection.getConnectionForOrphanedConnection(
-          childBlock, /** @type {!Connection} */ (orphanConnection));
+          childBlock, (orphanConnection));
       if (connection) {
         orphanConnection.connect(connection);
       } else {
@@ -163,7 +144,7 @@ class Connection {
 
   /**
    * Dispose of this connection and deal with connected blocks.
-   * @package
+   * @internal
    */
   dispose() {
     // isConnected returns true for shadows and non-shadows.
@@ -183,57 +164,55 @@ class Connection {
 
   /**
    * Get the source block for this connection.
-   * @return {!Block} The source block.
+   * @return The source block.
    */
-  getSourceBlock() {
+  getSourceBlock(): Block {
     return this.sourceBlock_;
   }
 
   /**
    * Does the connection belong to a superior block (higher in the source
    * stack)?
-   * @return {boolean} True if connection faces down or right.
+   * @return True if connection faces down or right.
    */
-  isSuperior() {
+  isSuperior(): boolean {
     return this.type === ConnectionType.INPUT_VALUE ||
         this.type === ConnectionType.NEXT_STATEMENT;
   }
 
   /**
    * Is the connection connected?
-   * @return {boolean} True if connection is connected to another connection.
+   * @return True if connection is connected to another connection.
    */
-  isConnected() {
+  isConnected(): boolean {
     return !!this.targetConnection;
   }
 
   /**
    * Get the workspace's connection type checker object.
-   * @return {!IConnectionChecker} The connection type checker for the
-   *     source block's workspace.
-   * @package
+   * @return The connection type checker for the source block's workspace.
+   * @internal
    */
-  getConnectionChecker() {
+  getConnectionChecker(): IConnectionChecker {
     return this.sourceBlock_.workspace.connectionChecker;
   }
 
   /**
    * Called when an attempted connection fails. NOP by default (i.e. for
    * headless workspaces).
-   * @param {!Connection} _otherConnection Connection that this connection
-   *     failed to connect to.
-   * @package
+   * @param _otherConnection Connection that this connection failed to connect
+   *     to.
+   * @internal
    */
-  onFailedConnect(_otherConnection) {
-    // NOP
-  }
+  onFailedConnect(_otherConnection: Connection) {}
+  // NOP
 
   /**
    * Connect this connection to another connection.
-   * @param {!Connection} otherConnection Connection to connect to.
-   * @return {boolean} Whether the the blocks are now connected or not.
+   * @param otherConnection Connection to connect to.
+   * @return Whether the the blocks are now connected or not.
    */
-  connect(otherConnection) {
+  connect(otherConnection: Connection): boolean {
     if (this.targetConnection === otherConnection) {
       // Already connected together.  NOP.
       return true;
@@ -261,9 +240,7 @@ class Connection {
     return this.isConnected();
   }
 
-  /**
-   * Disconnect this connection.
-   */
+  /** Disconnect this connection. */
   disconnect() {
     const otherConnection = this.targetConnection;
     if (!otherConnection) {
@@ -303,18 +280,19 @@ class Connection {
 
   /**
    * Disconnect two blocks that are connected by this connection.
-   * @param {!Block} parentBlock The superior block.
-   * @param {!Block} childBlock The inferior block.
-   * @protected
+   * @param parentBlock The superior block.
+   * @param childBlock The inferior block.
    */
-  disconnectInternal_(parentBlock, childBlock) {
+  protected disconnectInternal_(parentBlock: Block, childBlock: Block) {
     let event;
     if (eventUtils.isEnabled()) {
-      event = /** @type {!BlockMove} */
-          (new (eventUtils.get(eventUtils.BLOCK_MOVE))(childBlock));
+      event =
+          new (eventUtils.get(eventUtils.BLOCK_MOVE))!(childBlock) as BlockMove;
     }
     const otherConnection = this.targetConnection;
-    otherConnection.targetConnection = null;
+    if (otherConnection) {
+      otherConnection.targetConnection = null;
+    }
     this.targetConnection = null;
     childBlock.setParent(null);
     if (event) {
@@ -325,49 +303,45 @@ class Connection {
 
   /**
    * Respawn the shadow block if there was one connected to the this connection.
-   * @protected
    */
-  respawnShadow_() {
+  protected respawnShadow_() {
     // Have to keep respawnShadow_ for backwards compatibility.
     this.createShadowBlock_(true);
   }
 
   /**
    * Returns the block that this connection connects to.
-   * @return {?Block} The connected block or null if none is connected.
+   * @return The connected block or null if none is connected.
    */
-  targetBlock() {
+  targetBlock(): Block|null {
     if (this.isConnected()) {
-      return this.targetConnection.getSourceBlock();
+      return this.targetConnection?.getSourceBlock() ?? null;
     }
     return null;
   }
 
   /**
    * Function to be called when this connection's compatible types have changed.
-   * @protected
    */
-  onCheckChanged_() {
+  protected onCheckChanged_() {
     // The new value type may not be compatible with the existing connection.
     if (this.isConnected() &&
         (!this.targetConnection ||
          !this.getConnectionChecker().canConnect(
              this, this.targetConnection, false))) {
       const child = this.isSuperior() ? this.targetBlock() : this.sourceBlock_;
-      child.unplug();
+      child!.unplug();
     }
   }
 
   /**
    * Change a connection's compatibility.
-   * @param {?(string|!Array<string>)} check Compatible value type or list of
-   *     value types. Null if all types are compatible.
-   * @return {!Connection} The connection being modified
-   *     (to allow chaining).
+   * @param check Compatible value type or list of value types. Null if all
+   *     types are compatible.
+   * @return The connection being modified (to allow chaining).
    */
-  setCheck(check) {
+  setCheck(check: string|string[]|null): Connection {
     if (check) {
-      // Ensure that check is in an array.
       if (!Array.isArray(check)) {
         check = [check];
       }
@@ -381,59 +355,55 @@ class Connection {
 
   /**
    * Get a connection's compatibility.
-   * @return {?Array} List of compatible value types.
+   * @return List of compatible value types.
    *     Null if all types are compatible.
-   * @public
    */
-  getCheck() {
+  getCheck(): string[]|null {
     return this.check_;
   }
 
   /**
    * Changes the connection's shadow block.
-   * @param {?Element} shadowDom DOM representation of a block or null.
+   * @param shadowDom DOM representation of a block or null.
    */
-  setShadowDom(shadowDom) {
-    this.setShadowStateInternal_({shadowDom: shadowDom});
+  setShadowDom(shadowDom: Element|null) {
+    this.setShadowStateInternal_({shadowDom});
   }
 
   /**
    * Returns the xml representation of the connection's shadow block.
-   * @param {boolean=} returnCurrent If true, and the shadow block is currently
-   *     attached to this connection, this serializes the state of that block
-   *     and returns it (so that field values are correct). Otherwise the saved
-   *     shadowDom is just returned.
-   * @return {?Element} Shadow DOM representation of a block or null.
+   * @param returnCurrent If true, and the shadow block is currently attached to
+   *     this connection, this serializes the state of that block and returns it
+   *     (so that field values are correct). Otherwise the saved shadowDom is
+   *     just returned.
+   * @return Shadow DOM representation of a block or null.
    */
-  getShadowDom(returnCurrent) {
-    return (returnCurrent && this.targetBlock().isShadow()) ?
-        /** @type {!Element} */ (Xml.blockToDom(
-            /** @type {!Block} */ (this.targetBlock()))) :
+  getShadowDom(returnCurrent?: boolean): Element|null {
+    return returnCurrent && this.targetBlock()!.isShadow() ?
+        Xml.blockToDom((this.targetBlock() as Block)) as Element :
         this.shadowDom_;
   }
 
   /**
    * Changes the connection's shadow block.
-   * @param {?blocks.State} shadowState An state represetation of the block or
-   *     null.
+   * @param shadowState An state represetation of the block or null.
    */
-  setShadowState(shadowState) {
-    this.setShadowStateInternal_({shadowState: shadowState});
+  setShadowState(shadowState: blocks.State|null) {
+    this.setShadowStateInternal_({shadowState});
   }
 
   /**
    * Returns the serialized object representation of the connection's shadow
    * block.
-   * @param {boolean=} returnCurrent If true, and the shadow block is currently
-   *     attached to this connection, this serializes the state of that block
-   *     and returns it (so that field values are correct). Otherwise the saved
-   *     state is just returned.
-   * @return {?blocks.State} Serialized object representation of the block, or
-   *     null.
+   * @param returnCurrent If true, and the shadow block is currently attached to
+   *     this connection, this serializes the state of that block and returns it
+   *     (so that field values are correct). Otherwise the saved state is just
+   *     returned.
+   * @return Serialized object representation of the block, or null.
    */
-  getShadowState(returnCurrent) {
-    if (returnCurrent && this.targetBlock() && this.targetBlock().isShadow()) {
-      return blocks.save(/** @type {!Block} */ (this.targetBlock()));
+  getShadowState(returnCurrent?: boolean): blocks.State|null {
+    if (returnCurrent && this.targetBlock() && this.targetBlock()!.isShadow()) {
+      return blocks.save(this.targetBlock() as Block);
     }
     return this.shadowState_;
   }
@@ -446,21 +416,21 @@ class Connection {
    * and always return an empty list (the default).
    * {@link Blockly.RenderedConnection} overrides this behavior with a list
    * computed from the rendered positioning.
-   * @param {number} _maxLimit The maximum radius to another connection.
-   * @return {!Array<!Connection>} List of connections.
-   * @package
+   * @param _maxLimit The maximum radius to another connection.
+   * @return List of connections.
+   * @internal
    */
-  neighbours(_maxLimit) {
+  neighbours(_maxLimit: number): Connection[] {
     return [];
   }
 
   /**
    * Get the parent input of a connection.
-   * @return {?Input} The input that the connection belongs to or null if
-   *     no parent exists.
-   * @package
+   * @return The input that the connection belongs to or null if no parent
+   *     exists.
+   * @internal
    */
-  getParentInput() {
+  getParentInput(): Input|null {
     let parentInput = null;
     const inputs = this.sourceBlock_.inputList;
     for (let i = 0; i < inputs.length; i++) {
@@ -475,9 +445,9 @@ class Connection {
   /**
    * This method returns a string describing this Connection in developer terms
    * (English only). Intended to on be used in console logs and errors.
-   * @return {string} The description.
+   * @return The description.
    */
-  toString() {
+  toString(): string {
     const block = this.sourceBlock_;
     if (!block) {
       return 'Orphan Connection';
@@ -491,7 +461,7 @@ class Connection {
       msg = 'Next Connection of ';
     } else {
       let parentInput = null;
-      for (let i = 0, input; (input = block.inputList[i]); i++) {
+      for (let i = 0, input; input = block.inputList[i]; i++) {
         if (input.connection === this) {
           parentInput = input;
           break;
@@ -510,11 +480,10 @@ class Connection {
   /**
    * Returns the state of the shadowDom_ and shadowState_ properties, then
    * temporarily sets those properties to null so no shadow respawns.
-   * @return {{shadowDom: ?Element, shadowState: ?blocks.State}} The state of
-   *     both the shadowDom_ and shadowState_ properties.
-   * @private
+   * @return The state of both the shadowDom_ and shadowState_ properties.
    */
-  stashShadowState_() {
+  private stashShadowState_():
+      {shadowDom: Element|null, shadowState: blocks.State|null} {
     const shadowDom = this.getShadowDom(true);
     const shadowState = this.getShadowState(true);
     // Set to null so it doesn't respawn.
@@ -525,23 +494,25 @@ class Connection {
 
   /**
    * Reapplies the stashed state of the shadowDom_ and shadowState_ properties.
-   * @param {{shadowDom: ?Element, shadowState: ?blocks.State}} param0 The state
-   *     to reapply to the shadowDom_ and shadowState_ properties.
-   * @private
+   * @param param0 The state to reapply to the shadowDom_ and shadowState_
+   *     properties.
    */
-  applyShadowState_({shadowDom, shadowState}) {
+  private applyShadowState_({shadowDom, shadowState}: {
+    shadowDom: Element|null,
+    shadowState: blocks.State|null
+  }) {
     this.shadowDom_ = shadowDom;
     this.shadowState_ = shadowState;
   }
 
   /**
    * Sets the state of the shadow of this connection.
-   * @param {{shadowDom: (?Element|undefined), shadowState:
-   *     (?blocks.State|undefined)}=} param0 The state to set the shadow of this
-   *     connection to.
-   * @private
+   * @param param0 The state to set the shadow of this connection to.
    */
-  setShadowStateInternal_({shadowDom = null, shadowState = null} = {}) {
+  private setShadowStateInternal_({shadowDom = null, shadowState = null}: {
+    shadowDom?: Element|null,
+    shadowState?: blocks.State|null
+  } = {}) {
     // One or both of these should always be null.
     // If neither is null, the shadowState will get priority.
     this.shadowDom_ = shadowDom;
@@ -550,13 +521,13 @@ class Connection {
     const target = this.targetBlock();
     if (!target) {
       this.respawnShadow_();
-      if (this.targetBlock() && this.targetBlock().isShadow()) {
+      if (this.targetBlock() && this.targetBlock()!.isShadow()) {
         this.serializeShadow_(this.targetBlock());
       }
     } else if (target.isShadow()) {
       target.dispose(false);
       this.respawnShadow_();
-      if (this.targetBlock() && this.targetBlock().isShadow()) {
+      if (this.targetBlock() && this.targetBlock()!.isShadow()) {
         this.serializeShadow_(this.targetBlock());
       }
     } else {
@@ -571,17 +542,16 @@ class Connection {
   /**
    * Creates a shadow block based on the current shadowState_ or shadowDom_.
    * shadowState_ gets priority.
-   * @param {boolean} attemptToConnect Whether to try to connect the shadow
-   *     block to this connection or not.
-   * @return {?Block} The shadow block that was created, or null if both the
-   *     shadowState_ and shadowDom_ are null.
-   * @private
+   * @param attemptToConnect Whether to try to connect the shadow block to this
+   *     connection or not.
+   * @return The shadow block that was created, or null if both the shadowState_
+   *     and shadowDom_ are null.
    */
-  createShadowBlock_(attemptToConnect) {
+  private createShadowBlock_(attemptToConnect: boolean): Block|null {
     const parentBlock = this.getSourceBlock();
     const shadowState = this.getShadowState();
     const shadowDom = this.getShadowDom();
-    if (!parentBlock.workspace || (!shadowState && !shadowDom)) {
+    if (parentBlock.disposed || !shadowState && !shadowDom) {
       return null;
     }
 
@@ -625,14 +595,13 @@ class Connection {
   /**
    * Saves the given shadow block to both the shadowDom_ and shadowState_
    * properties, in their respective serialized forms.
-   * @param {?Block} shadow The shadow to serialize, or null.
-   * @private
+   * @param shadow The shadow to serialize, or null.
    */
-  serializeShadow_(shadow) {
+  private serializeShadow_(shadow: Block|null) {
     if (!shadow) {
       return;
     }
-    this.shadowDom_ = /** @type {!Element} */ (Xml.blockToDom(shadow));
+    this.shadowDom_ = Xml.blockToDom(shadow) as Element;
     this.shadowState_ = blocks.save(shadow);
   }
 
@@ -640,13 +609,12 @@ class Connection {
    * Returns the connection (starting at the startBlock) which will accept
    * the given connection. This includes compatible connection types and
    * connection checks.
-   * @param {!Block} startBlock The block on which to start the search.
-   * @param {!Connection} orphanConnection The connection that is looking
-   *     for a home.
-   * @return {?Connection} The suitable connection point on the chain of
-   *     blocks, or null.
+   * @param startBlock The block on which to start the search.
+   * @param orphanConnection The connection that is looking for a home.
+   * @return The suitable connection point on the chain of blocks, or null.
    */
-  static getConnectionForOrphanedConnection(startBlock, orphanConnection) {
+  static getConnectionForOrphanedConnection(
+      startBlock: Block, orphanConnection: Connection): Connection|null {
     if (orphanConnection.type === ConnectionType.OUTPUT_VALUE) {
       return getConnectionForOrphanedOutput(
           startBlock, orphanConnection.getSourceBlock());
@@ -661,48 +629,34 @@ class Connection {
   }
 }
 
-/**
- * Constants for checking whether two connections are compatible.
- */
-Connection.CAN_CONNECT = 0;
-Connection.REASON_SELF_CONNECTION = 1;
-Connection.REASON_WRONG_TYPE = 2;
-Connection.REASON_TARGET_NULL = 3;
-Connection.REASON_CHECKS_FAILED = 4;
-Connection.REASON_DIFFERENT_WORKSPACES = 5;
-Connection.REASON_SHADOW_PARENT = 6;
-Connection.REASON_DRAG_CHECKS_FAILED = 7;
-Connection.REASON_PREVIOUS_AND_OUTPUT = 8;
-
 /**
  * Update two connections to target each other.
- * @param {Connection} first The first connection to update.
- * @param {Connection} second The second connection to update.
+ * @param first The first connection to update.
+ * @param second The second connection to update.
  */
-const connectReciprocally = function(first, second) {
+function connectReciprocally(first: Connection, second: Connection) {
   if (!first || !second) {
     throw Error('Cannot connect null connections.');
   }
   first.targetConnection = second;
   second.targetConnection = first;
-};
-
+}
 /**
  * Returns the single connection on the block that will accept the orphaned
  * block, if one can be found. If the block has multiple compatible connections
  * (even if they are filled) this returns null. If the block has no compatible
  * connections, this returns null.
- * @param {!Block} block The superior block.
- * @param {!Block} orphanBlock The inferior block.
- * @return {?Connection} The suitable connection point on 'block',
- *     or null.
+ * @param block The superior block.
+ * @param orphanBlock The inferior block.
+ * @return The suitable connection point on 'block', or null.
  */
-const getSingleConnection = function(block, orphanBlock) {
+function getSingleConnection(block: Block, orphanBlock: Block): Connection|
+    null {
   let foundConnection = null;
   const output = orphanBlock.outputConnection;
   const typeChecker = output.getConnectionChecker();
 
-  for (let i = 0, input; (input = block.inputList[i]); i++) {
+  for (let i = 0, input; input = block.inputList[i]; i++) {
     const connection = input.connection;
     if (connection && typeChecker.canConnect(output, connection, false)) {
       if (foundConnection) {
@@ -712,7 +666,7 @@ const getSingleConnection = function(block, orphanBlock) {
     }
   }
   return foundConnection;
-};
+}
 
 /**
  * Walks down a row a blocks, at each stage checking if there are any
@@ -720,23 +674,19 @@ const getSingleConnection = function(block, orphanBlock) {
  * are zero or multiple eligible connections, returns null.  Otherwise
  * returns the only input on the last block in the chain.
  * Terminates early for shadow blocks.
- * @param {!Block} startBlock The block on which to start the search.
- * @param {!Block} orphanBlock The block that is looking for a home.
- * @return {?Connection} The suitable connection point on the chain
- *     of blocks, or null.
+ * @param startBlock The block on which to start the search.
+ * @param orphanBlock The block that is looking for a home.
+ * @return The suitable connection point on the chain of blocks, or null.
  */
-const getConnectionForOrphanedOutput = function(startBlock, orphanBlock) {
-  let newBlock = startBlock;
+function getConnectionForOrphanedOutput(
+    startBlock: Block, orphanBlock: Block): Connection|null {
+  let newBlock: Block|null = startBlock;
   let connection;
-  while (
-      (connection = getSingleConnection(
-           /** @type {!Block} */ (newBlock), orphanBlock))) {
+  while (connection = getSingleConnection(newBlock, orphanBlock)) {
     newBlock = connection.targetBlock();
     if (!newBlock || newBlock.isShadow()) {
       return connection;
     }
   }
   return null;
-};
-
-exports.Connection = Connection;
+}