From fc62fed33c94564449d521644bc0d44dbca739f9 Mon Sep 17 00:00:00 2001 From: Aaron Dodson Date: Fri, 16 Jul 2021 13:55:08 -0700 Subject: [PATCH] Migrate core/connection.js to goog.module --- core/connection.js | 141 +++++++++++++++++++++++---------------------- tests/deps.js | 2 +- 2 files changed, 73 insertions(+), 70 deletions(-) diff --git a/core/connection.js b/core/connection.js index 23d2193bd..be9a08eb9 100644 --- a/core/connection.js +++ b/core/connection.js @@ -10,7 +10,8 @@ */ 'use strict'; -goog.provide('Blockly.Connection'); +goog.module('Blockly.Connection'); +goog.module.declareLegacyNamespace(); goog.require('Blockly.connectionTypes'); /** @suppress {extraRequire} */ @@ -34,7 +35,7 @@ goog.requireType('Blockly.Input'); * @constructor * @implements {Blockly.IASTNodeLocationWithBlock} */ -Blockly.Connection = function(source, type) { +const Connection = function(source, type) { /** * @type {!Blockly.Block} * @protected @@ -47,63 +48,63 @@ Blockly.Connection = function(source, type) { /** * Constants for checking whether two connections are compatible. */ -Blockly.Connection.CAN_CONNECT = 0; -Blockly.Connection.REASON_SELF_CONNECTION = 1; -Blockly.Connection.REASON_WRONG_TYPE = 2; -Blockly.Connection.REASON_TARGET_NULL = 3; -Blockly.Connection.REASON_CHECKS_FAILED = 4; -Blockly.Connection.REASON_DIFFERENT_WORKSPACES = 5; -Blockly.Connection.REASON_SHADOW_PARENT = 6; -Blockly.Connection.REASON_DRAG_CHECKS_FAILED = 7; +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 this connection connects to. Null if not connected. - * @type {Blockly.Connection} + * @type {Connection} */ -Blockly.Connection.prototype.targetConnection = null; +Connection.prototype.targetConnection = null; /** * Has this connection been disposed of? * @type {boolean} * @package */ -Blockly.Connection.prototype.disposed = false; +Connection.prototype.disposed = false; /** * List of compatible value types. Null if all types are compatible. * @type {Array} * @private */ -Blockly.Connection.prototype.check_ = null; +Connection.prototype.check_ = null; /** * DOM representation of a shadow block, or null if none. * @type {Element} * @private */ -Blockly.Connection.prototype.shadowDom_ = null; +Connection.prototype.shadowDom_ = null; /** * Horizontal location of this connection. * @type {number} * @package */ -Blockly.Connection.prototype.x = 0; +Connection.prototype.x = 0; /** * Vertical location of this connection. * @type {number} * @package */ -Blockly.Connection.prototype.y = 0; +Connection.prototype.y = 0; /** * Connect two connections together. This is the connection on the superior * block. - * @param {!Blockly.Connection} childConnection Connection on inferior block. + * @param {!Connection} childConnection Connection on inferior block. * @protected */ -Blockly.Connection.prototype.connect_ = function(childConnection) { +Connection.prototype.connect_ = function(childConnection) { const INPUT = Blockly.connectionTypes.INPUT_VALUE; const parentConnection = this; const parentBlock = parentConnection.getSourceBlock(); @@ -134,7 +135,7 @@ Blockly.Connection.prototype.connect_ = function(childConnection) { if (Blockly.Events.isEnabled()) { event = new (Blockly.Events.get(Blockly.Events.BLOCK_MOVE))(childBlock); } - Blockly.Connection.connectReciprocally_(parentConnection, childConnection); + Connection.connectReciprocally_(parentConnection, childConnection); childBlock.setParent(parentBlock); if (event) { event.recordNew(); @@ -145,8 +146,8 @@ Blockly.Connection.prototype.connect_ = function(childConnection) { if (orphan) { const orphanConnection = parentConnection.type === INPUT ? orphan.outputConnection : orphan.previousConnection; - const connection = Blockly.Connection.getConnectionForOrphanedConnection( - childBlock, /** @type {!Blockly.Connection} */ (orphanConnection)); + const connection = Connection.getConnectionForOrphanedConnection( + childBlock, /** @type {!Connection} */ (orphanConnection)); if (connection) { orphanConnection.connect(connection); } else { @@ -160,7 +161,7 @@ Blockly.Connection.prototype.connect_ = function(childConnection) { * Dispose of this connection and deal with connected blocks. * @package */ -Blockly.Connection.prototype.dispose = function() { +Connection.prototype.dispose = function() { // isConnected returns true for shadows and non-shadows. if (this.isConnected()) { @@ -181,7 +182,7 @@ Blockly.Connection.prototype.dispose = function() { * Get the source block for this connection. * @return {!Blockly.Block} The source block. */ -Blockly.Connection.prototype.getSourceBlock = function() { +Connection.prototype.getSourceBlock = function() { return this.sourceBlock_; }; @@ -189,7 +190,7 @@ Blockly.Connection.prototype.getSourceBlock = function() { * Does the connection belong to a superior block (higher in the source stack)? * @return {boolean} True if connection faces down or right. */ -Blockly.Connection.prototype.isSuperior = function() { +Connection.prototype.isSuperior = function() { return this.type == Blockly.connectionTypes.INPUT_VALUE || this.type == Blockly.connectionTypes.NEXT_STATEMENT; }; @@ -198,20 +199,20 @@ Blockly.Connection.prototype.isSuperior = function() { * Is the connection connected? * @return {boolean} True if connection is connected to another connection. */ -Blockly.Connection.prototype.isConnected = function() { +Connection.prototype.isConnected = function() { return !!this.targetConnection; }; /** * Checks whether the current connection can connect with the target * connection. - * @param {Blockly.Connection} target Connection to check compatibility with. - * @return {number} Blockly.Connection.CAN_CONNECT if the connection is legal, + * @param {Connection} target Connection to check compatibility with. + * @return {number} Connection.CAN_CONNECT if the connection is legal, * an error code otherwise. * @deprecated July 2020. Will be deleted July 2021. Use the workspace's * connectionChecker instead. */ -Blockly.Connection.prototype.canConnectWithReason = function(target) { +Connection.prototype.canConnectWithReason = function(target) { Blockly.utils.deprecation.warn( 'Connection.prototype.canConnectWithReason', 'July 2020', @@ -224,13 +225,13 @@ Blockly.Connection.prototype.canConnectWithReason = function(target) { /** * Checks whether the current connection and target connection are compatible * and throws an exception if they are not. - * @param {Blockly.Connection} target The connection to check compatibility + * @param {Connection} target The connection to check compatibility * with. * @package * @deprecated July 2020. Will be deleted July 2021. Use the workspace's * connectionChecker instead. */ -Blockly.Connection.prototype.checkConnection = function(target) { +Connection.prototype.checkConnection = function(target) { Blockly.utils.deprecation.warn( 'Connection.prototype.checkConnection', 'July 2020', @@ -238,7 +239,7 @@ Blockly.Connection.prototype.checkConnection = function(target) { 'the workspace\'s connection checker'); const checker = this.getConnectionChecker(); const reason = checker.canConnectWithReason(this, target, false); - if (reason != Blockly.Connection.CAN_CONNECT) { + if (reason != Connection.CAN_CONNECT) { throw new Error(checker.getErrorMessage(reason, this, target)); } }; @@ -249,18 +250,18 @@ Blockly.Connection.prototype.checkConnection = function(target) { * source block's workspace. * @package */ -Blockly.Connection.prototype.getConnectionChecker = function() { +Connection.prototype.getConnectionChecker = function() { return this.sourceBlock_.workspace.connectionChecker; }; /** * Check if the two connections can be dragged to connect to each other. - * @param {!Blockly.Connection} candidate A nearby connection to check. + * @param {!Connection} candidate A nearby connection to check. * @return {boolean} True if the connection is allowed, false otherwise. * @deprecated July 2020. Will be deleted July 2021. Use the workspace's * connectionChecker instead. */ -Blockly.Connection.prototype.isConnectionAllowed = function(candidate) { +Connection.prototype.isConnectionAllowed = function(candidate) { Blockly.utils.deprecation.warn( 'Connection.prototype.isConnectionAllowed', 'July 2020', @@ -272,19 +273,19 @@ Blockly.Connection.prototype.isConnectionAllowed = function(candidate) { /** * Called when an attempted connection fails. NOP by default (i.e. for headless * workspaces). - * @param {!Blockly.Connection} _otherConnection Connection that this connection + * @param {!Connection} _otherConnection Connection that this connection * failed to connect to. * @package */ -Blockly.Connection.prototype.onFailedConnect = function(_otherConnection) { +Connection.prototype.onFailedConnect = function(_otherConnection) { // NOP }; /** * Connect this connection to another connection. - * @param {!Blockly.Connection} otherConnection Connection to connect to. + * @param {!Connection} otherConnection Connection to connect to. */ -Blockly.Connection.prototype.connect = function(otherConnection) { +Connection.prototype.connect = function(otherConnection) { if (this.targetConnection == otherConnection) { // Already connected together. NOP. return; @@ -312,11 +313,11 @@ Blockly.Connection.prototype.connect = function(otherConnection) { /** * Update two connections to target each other. - * @param {Blockly.Connection} first The first connection to update. - * @param {Blockly.Connection} second The second connection to update. + * @param {Connection} first The first connection to update. + * @param {Connection} second The second connection to update. * @private */ -Blockly.Connection.connectReciprocally_ = function(first, second) { +Connection.connectReciprocally_ = function(first, second) { if (!first || !second) { throw Error('Cannot connect null connections.'); } @@ -331,11 +332,11 @@ Blockly.Connection.connectReciprocally_ = function(first, second) { * connections, this returns null. * @param {!Blockly.Block} block The superior block. * @param {!Blockly.Block} orphanBlock The inferior block. - * @return {?Blockly.Connection} The suitable connection point on 'block', + * @return {?Connection} The suitable connection point on 'block', * or null. * @private */ -Blockly.Connection.getSingleConnection_ = function(block, orphanBlock) { +Connection.getSingleConnection_ = function(block, orphanBlock) { let foundConnection = null; const output = orphanBlock.outputConnection; const typeChecker = output.getConnectionChecker(); @@ -360,15 +361,15 @@ Blockly.Connection.getSingleConnection_ = function(block, orphanBlock) { * Terminates early for shadow blocks. * @param {!Blockly.Block} startBlock The block on which to start the search. * @param {!Blockly.Block} orphanBlock The block that is looking for a home. - * @return {?Blockly.Connection} The suitable connection point on the chain + * @return {?Connection} The suitable connection point on the chain * of blocks, or null. * @private */ -Blockly.Connection.getConnectionForOrphanedOutput_ = +Connection.getConnectionForOrphanedOutput_ = function(startBlock, orphanBlock) { let newBlock = startBlock; let connection; - while ((connection = Blockly.Connection.getSingleConnection_( + while ((connection = Connection.getSingleConnection_( /** @type {!Blockly.Block} */ (newBlock), orphanBlock))) { newBlock = connection.targetBlock(); if (!newBlock || newBlock.isShadow()) { @@ -383,15 +384,15 @@ Blockly.Connection.getConnectionForOrphanedOutput_ = * the given connection. This includes compatible connection types and * connection checks. * @param {!Blockly.Block} startBlock The block on which to start the search. - * @param {!Blockly.Connection} orphanConnection The connection that is looking + * @param {!Connection} orphanConnection The connection that is looking * for a home. - * @return {?Blockly.Connection} The suitable connection point on the chain of + * @return {?Connection} The suitable connection point on the chain of * blocks, or null. */ -Blockly.Connection.getConnectionForOrphanedConnection = +Connection.getConnectionForOrphanedConnection = function(startBlock, orphanConnection) { if (orphanConnection.type === Blockly.connectionTypes.OUTPUT_VALUE) { - return Blockly.Connection.getConnectionForOrphanedOutput_( + return Connection.getConnectionForOrphanedOutput_( startBlock, orphanConnection.getSourceBlock()); } // Otherwise we're dealing with a stack. @@ -407,7 +408,7 @@ Blockly.Connection.getConnectionForOrphanedConnection = /** * Disconnect this connection. */ -Blockly.Connection.prototype.disconnect = function() { +Connection.prototype.disconnect = function() { const otherConnection = this.targetConnection; if (!otherConnection) { throw Error('Source connection not connected.'); @@ -448,7 +449,7 @@ Blockly.Connection.prototype.disconnect = function() { * @param {!Blockly.Block} childBlock The inferior block. * @protected */ -Blockly.Connection.prototype.disconnectInternal_ = function(parentBlock, +Connection.prototype.disconnectInternal_ = function(parentBlock, childBlock) { let event; if (Blockly.Events.isEnabled()) { @@ -468,7 +469,7 @@ Blockly.Connection.prototype.disconnectInternal_ = function(parentBlock, * Respawn the shadow block if there was one connected to the this connection. * @protected */ -Blockly.Connection.prototype.respawnShadow_ = function() { +Connection.prototype.respawnShadow_ = function() { const parentBlock = this.getSourceBlock(); const shadow = this.getShadowDom(); if (parentBlock.workspace && shadow) { @@ -487,7 +488,7 @@ Blockly.Connection.prototype.respawnShadow_ = function() { * Returns the block that this connection connects to. * @return {?Blockly.Block} The connected block or null if none is connected. */ -Blockly.Connection.prototype.targetBlock = function() { +Connection.prototype.targetBlock = function() { if (this.isConnected()) { return this.targetConnection.getSourceBlock(); } @@ -497,12 +498,12 @@ Blockly.Connection.prototype.targetBlock = function() { /** * Is this connection compatible with another connection with respect to the * value type system. E.g. square_root("Hello") is not compatible. - * @param {!Blockly.Connection} otherConnection Connection to compare against. + * @param {!Connection} otherConnection Connection to compare against. * @return {boolean} True if the connections share a type. * @deprecated July 2020. Will be deleted July 2021. Use the workspace's * connectionChecker instead. */ -Blockly.Connection.prototype.checkType = function(otherConnection) { +Connection.prototype.checkType = function(otherConnection) { Blockly.utils.deprecation.warn( 'Connection.prototype.checkType', 'October 2019', @@ -515,14 +516,14 @@ Blockly.Connection.prototype.checkType = function(otherConnection) { /** * Is this connection compatible with another connection with respect to the * value type system. E.g. square_root("Hello") is not compatible. - * @param {!Blockly.Connection} otherConnection Connection to compare against. + * @param {!Connection} otherConnection Connection to compare against. * @return {boolean} True if the connections share a type. * @private * @deprecated October 2019. Will be deleted January 2021. Use the workspace's * connectionChecker instead. * @suppress {unusedPrivateMembers} */ -Blockly.Connection.prototype.checkType_ = function(otherConnection) { +Connection.prototype.checkType_ = function(otherConnection) { Blockly.utils.deprecation.warn( 'Connection.prototype.checkType_', 'October 2019', @@ -535,7 +536,7 @@ Blockly.Connection.prototype.checkType_ = function(otherConnection) { * Function to be called when this connection's compatible types have changed. * @protected */ -Blockly.Connection.prototype.onCheckChanged_ = function() { +Connection.prototype.onCheckChanged_ = function() { // The new value type may not be compatible with the existing connection. if (this.isConnected() && (!this.targetConnection || !this.getConnectionChecker().canConnect( @@ -549,10 +550,10 @@ Blockly.Connection.prototype.onCheckChanged_ = function() { * Change a connection's compatibility. * @param {?(string|!Array)} check Compatible value type or list of * value types. Null if all types are compatible. - * @return {!Blockly.Connection} The connection being modified + * @return {!Connection} The connection being modified * (to allow chaining). */ -Blockly.Connection.prototype.setCheck = function(check) { +Connection.prototype.setCheck = function(check) { if (check) { // Ensure that check is in an array. if (!Array.isArray(check)) { @@ -572,7 +573,7 @@ Blockly.Connection.prototype.setCheck = function(check) { * Null if all types are compatible. * @public */ -Blockly.Connection.prototype.getCheck = function() { +Connection.prototype.getCheck = function() { return this.check_; }; @@ -580,7 +581,7 @@ Blockly.Connection.prototype.getCheck = function() { * Changes the connection's shadow block. * @param {?Element} shadow DOM representation of a block or null. */ -Blockly.Connection.prototype.setShadowDom = function(shadow) { +Connection.prototype.setShadowDom = function(shadow) { this.shadowDom_ = shadow; const target = this.targetBlock(); if (!target) { @@ -600,7 +601,7 @@ Blockly.Connection.prototype.setShadowDom = function(shadow) { * shadowDom is just returned. * @return {?Element} Shadow DOM representation of a block or null. */ -Blockly.Connection.prototype.getShadowDom = function(returnCurrent) { +Connection.prototype.getShadowDom = function(returnCurrent) { return (returnCurrent && this.targetBlock().isShadow()) ? /** @type {!Element} */ (Blockly.Xml.blockToDom( /** @type {!Blockly.Block} */ (this.targetBlock()))) : @@ -616,10 +617,10 @@ Blockly.Connection.prototype.getShadowDom = function(returnCurrent) { * {@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} List of connections. + * @return {!Array} List of connections. * @package */ -Blockly.Connection.prototype.neighbours = function(_maxLimit) { +Connection.prototype.neighbours = function(_maxLimit) { return []; }; @@ -629,7 +630,7 @@ Blockly.Connection.prototype.neighbours = function(_maxLimit) { * no parent exists. * @package */ -Blockly.Connection.prototype.getParentInput = function() { +Connection.prototype.getParentInput = function() { let parentInput = null; const inputs = this.sourceBlock_.inputList; for (let i = 0; i < inputs.length; i++) { @@ -646,7 +647,7 @@ Blockly.Connection.prototype.getParentInput = function() { * (English only). Intended to on be used in console logs and errors. * @return {string} The description. */ -Blockly.Connection.prototype.toString = function() { +Connection.prototype.toString = function() { const block = this.sourceBlock_; if (!block) { return 'Orphan Connection'; @@ -675,3 +676,5 @@ Blockly.Connection.prototype.toString = function() { } return msg + block.toDevString(); }; + +exports = Connection; diff --git a/tests/deps.js b/tests/deps.js index ed2af0dc9..b435a26ba 100644 --- a/tests/deps.js +++ b/tests/deps.js @@ -19,7 +19,7 @@ goog.addDependency('../../core/bubble.js', ['Blockly.Bubble'], ['Blockly.IBubble goog.addDependency('../../core/bubble_dragger.js', ['Blockly.BubbleDragger'], ['Blockly.Bubble', 'Blockly.ComponentManager', 'Blockly.Events', 'Blockly.Events.CommentMove', 'Blockly.constants', 'Blockly.utils', 'Blockly.utils.Coordinate']); goog.addDependency('../../core/comment.js', ['Blockly.Comment'], ['Blockly.Bubble', 'Blockly.Css', 'Blockly.Events', 'Blockly.Events.BlockChange', 'Blockly.Events.BubbleOpen', 'Blockly.Icon', 'Blockly.Warning', 'Blockly.browserEvents', 'Blockly.utils.Svg', 'Blockly.utils.dom', 'Blockly.utils.object', 'Blockly.utils.userAgent']); goog.addDependency('../../core/component_manager.js', ['Blockly.ComponentManager'], [], {'lang': 'es6', 'module': 'goog'}); -goog.addDependency('../../core/connection.js', ['Blockly.Connection'], ['Blockly.Events', 'Blockly.Events.BlockMove', 'Blockly.IASTNodeLocationWithBlock', 'Blockly.Xml', 'Blockly.connectionTypes', 'Blockly.constants', 'Blockly.utils.deprecation']); +goog.addDependency('../../core/connection.js', ['Blockly.Connection'], ['Blockly.Events', 'Blockly.Events.BlockMove', 'Blockly.IASTNodeLocationWithBlock', 'Blockly.Xml', 'Blockly.connectionTypes', 'Blockly.constants', 'Blockly.utils.deprecation'], {'lang': 'es6', 'module': 'goog'}); goog.addDependency('../../core/connection_checker.js', ['Blockly.ConnectionChecker'], ['Blockly.Connection', 'Blockly.IConnectionChecker', 'Blockly.connectionTypes', 'Blockly.constants', 'Blockly.registry']); goog.addDependency('../../core/connection_db.js', ['Blockly.ConnectionDB'], ['Blockly.RenderedConnection', 'Blockly.connectionTypes', 'Blockly.constants']); goog.addDependency('../../core/connection_types.js', ['Blockly.connectionTypes'], [], {'lang': 'es6', 'module': 'goog'});