mixio 1.10.0

blockly/core/interfaces/i_accessibility.js

@@ -0,0 +1,75 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview AST Node and keyboard navigation interfaces.
+ * @author samelh@google.com (Sam El-Husseini)
+ */
+
+'use strict';
+
+goog.provide('Blockly.IASTNodeLocation');
+goog.provide('Blockly.IASTNodeLocationSvg');
+goog.provide('Blockly.IASTNodeLocationWithBlock');
+goog.provide('Blockly.IKeyboardAccessible');
+
+goog.requireType('Blockly.Block');
+goog.requireType('Blockly.ShortcutRegistry');
+
+
+/**
+ * An AST node location interface.
+ * @interface
+ */
+Blockly.IASTNodeLocation = function() {};
+
+/**
+ * An AST node location SVG interface.
+ * @interface
+ * @extends {Blockly.IASTNodeLocation}
+ */
+Blockly.IASTNodeLocationSvg = function() {};
+
+/**
+ * Add the marker SVG to this node's SVG group.
+ * @param {SVGElement} markerSvg The SVG root of the marker to be added to the
+ *     SVG group.
+ */
+Blockly.IASTNodeLocationSvg.prototype.setMarkerSvg;
+
+/**
+ * Add the cursor SVG to this node's SVG group.
+ * @param {SVGElement} cursorSvg The SVG root of the cursor to be added to the
+ *     SVG group.
+ */
+Blockly.IASTNodeLocationSvg.prototype.setCursorSvg;
+
+/**
+ * An AST node location that has an associated block.
+ * @interface
+ * @extends {Blockly.IASTNodeLocation}
+ */
+Blockly.IASTNodeLocationWithBlock = function() {};
+
+/**
+ * Get the source block associated with this node.
+ * @return {Blockly.Block} The source block.
+ */
+Blockly.IASTNodeLocationWithBlock.prototype.getSourceBlock;
+
+
+/**
+ * An interface for an object that handles keyboard shortcuts.
+ * @interface
+ */
+Blockly.IKeyboardAccessible = function() {};
+
+/**
+ * Handles the given keyboard shortcut.
+ * @param {!Blockly.ShortcutRegistry.KeyboardShortcut} shortcut The shortcut to be handled.
+ * @return {boolean} True if the shortcut has been handled, false otherwise.
+ */
+Blockly.IKeyboardAccessible.prototype.onShortcut;

blockly/core/interfaces/i_autohideable.js

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview The interface for a component that is automatically hidden
+ * when Blockly.hideChaff is called.
+ * @author kozbial@google.com (Monica Kozbial)
+ */
+
+'use strict';
+
+goog.provide('Blockly.IAutoHideable');
+
+goog.require('Blockly.IComponent');
+
+
+/**
+ * Interface for a component that can be automatically hidden.
+ * @extends {Blockly.IComponent}
+ * @interface
+ */
+Blockly.IAutoHideable = function() {};
+
+/**
+ * Hides the component. Called in Blockly.hideChaff.
+ * @param {boolean} onlyClosePopups Whether only popups should be closed.
+ *   Flyouts should not be closed if this is true.
+ */
+Blockly.IAutoHideable.prototype.autoHide;

blockly/core/interfaces/i_block_dragger.js

@@ -0,0 +1,58 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview The interface for a block dragger.
+ * @author aschmiedt@google.com (Abby Schmiedt)
+ */
+
+'use strict';
+
+goog.provide('Blockly.IBlockDragger');
+
+goog.requireType('Blockly.BlockSvg');
+goog.requireType('Blockly.utils.Coordinate');
+
+
+/**
+ * A block dragger interface.
+ * @interface
+ */
+Blockly.IBlockDragger = function() {};
+
+/**
+ * Start dragging a block.  This includes moving it to the drag surface.
+ * @param {!Blockly.utils.Coordinate} currentDragDeltaXY How far the pointer has
+ *     moved from the position at mouse down, in pixel units.
+ * @param {boolean} healStack Whether or not to heal the stack after
+ *     disconnecting.
+ */
+Blockly.IBlockDragger.prototype.startDrag;
+
+/**
+ * Execute a step of block dragging, based on the given event.  Update the
+ * display accordingly.
+ * @param {!Event} e The most recent move event.
+ * @param {!Blockly.utils.Coordinate} currentDragDeltaXY How far the pointer has
+ *     moved from the position at the start of the drag, in pixel units.
+ */
+Blockly.IBlockDragger.prototype.drag;
+
+/**
+ * Finish a block drag and put the block back on the workspace.
+ * @param {!Event} e The mouseup/touchend event.
+ * @param {!Blockly.utils.Coordinate} currentDragDeltaXY How far the pointer has
+ *     moved from the position at the start of the drag, in pixel units.
+ */
+Blockly.IBlockDragger.prototype.endDrag;
+
+/**
+ * Get a list of the insertion markers that currently exist.  Drags have 0, 1,
+ * or 2 insertion markers.
+ * @return {!Array.<!Blockly.BlockSvg>} A possibly empty list of insertion
+ *     marker blocks.
+ */
+Blockly.IBlockDragger.prototype.getInsertionMarkers;

blockly/core/interfaces/i_bounded_element.js

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview The interface for a bounded element.
+ * @author samelh@google.com (Sam El-Husseini)
+ */
+
+'use strict';
+
+goog.provide('Blockly.IBoundedElement');
+
+goog.requireType('Blockly.utils.Rect');
+
+
+/**
+ * A bounded element interface.
+ * @interface
+ */
+Blockly.IBoundedElement = function() {};
+
+/**
+ * Returns the coordinates of a bounded element describing the dimensions of the
+ * element.
+ * Coordinate system: workspace coordinates.
+ * @return {!Blockly.utils.Rect} Object with coordinates of the bounded element.
+ */
+Blockly.IBoundedElement.prototype.getBoundingRectangle;
+
+/**
+ * Move the element by a relative offset.
+ * @param {number} dx Horizontal offset in workspace units.
+ * @param {number} dy Vertical offset in workspace units.
+ */
+Blockly.IBoundedElement.prototype.moveBy;

blockly/core/interfaces/i_bubble.js

@@ -0,0 +1,86 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview The interface for a bubble.
+ * @author samelh@google.com (Sam El-Husseini)
+ */
+
+'use strict';
+
+goog.provide('Blockly.IBubble');
+
+goog.require('Blockly.IContextMenu');
+goog.require('Blockly.IDraggable');
+
+goog.requireType('Blockly.BlockDragSurfaceSvg');
+goog.requireType('Blockly.utils.Coordinate');
+
+
+/**
+ * A bubble interface.
+ * @interface
+ * @extends {Blockly.IDraggable}
+ * @extends {Blockly.IContextMenu}
+ */
+Blockly.IBubble = function() {};
+
+/**
+ * Return the coordinates of the top-left corner of this bubble's body relative
+ * to the drawing surface's origin (0,0), in workspace units.
+ * @return {!Blockly.utils.Coordinate} Object with .x and .y properties.
+ */
+Blockly.IBubble.prototype.getRelativeToSurfaceXY;
+
+/**
+ * Return the root node of the bubble's SVG group.
+ * @return {!SVGElement} The root SVG node of the bubble's group.
+ */
+Blockly.IBubble.prototype.getSvgRoot;
+
+/**
+ * Set whether auto-layout of this bubble is enabled.  The first time a bubble
+ * is shown it positions itself to not cover any blocks.  Once a user has
+ * dragged it to reposition, it renders where the user put it.
+ * @param {boolean} enable True if auto-layout should be enabled, false
+ *     otherwise.
+ */
+Blockly.IBubble.prototype.setAutoLayout;
+
+/**
+ * Triggers a move callback if one exists at the end of a drag.
+ * @param {boolean} adding True if adding, false if removing.
+ */
+Blockly.IBubble.prototype.setDragging;
+
+/**
+ * Move this bubble during a drag, taking into account whether or not there is
+ * a drag surface.
+ * @param {Blockly.BlockDragSurfaceSvg} dragSurface The surface that carries
+ *     rendered items during a drag, or null if no drag surface is in use.
+ * @param {!Blockly.utils.Coordinate} newLoc The location to translate to, in
+ *     workspace coordinates.
+ */
+Blockly.IBubble.prototype.moveDuringDrag;
+
+/**
+ * Move the bubble to the specified location in workspace coordinates.
+ * @param {number} x The x position to move to.
+ * @param {number} y The y position to move to.
+ */
+Blockly.IBubble.prototype.moveTo;
+
+/**
+ * Update the style of this bubble when it is dragged over a delete area.
+ * @param {boolean} enable True if the bubble is about to be deleted, false
+ *     otherwise.
+ */
+Blockly.IBubble.prototype.setDeleteStyle;
+
+/**
+ * Dispose of this bubble.
+ */
+Blockly.IBubble.prototype.dispose;

blockly/core/interfaces/i_component.js

@@ -0,0 +1,30 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Interface for a workspace component that can be registered with
+ * the ComponentManager.
+ * @author kozbial@google.com (Monica Kozbial)
+ */
+
+'use strict';
+
+goog.provide('Blockly.IComponent');
+
+
+/**
+ * The interface for a workspace component that can be registered with the
+ * ComponentManager.
+ * @interface
+ */
+Blockly.IComponent = function() {};
+
+/**
+ * The unique id for this component that is used to register with the
+ * ComponentManager.
+ * @type {string}
+ */
+Blockly.IComponent.id;

blockly/core/interfaces/i_connection_checker.js

@@ -0,0 +1,95 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview The interface for 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.IConnectionChecker');
+
+goog.requireType('Blockly.Connection');
+goog.requireType('Blockly.RenderedConnection');
+
+
+/**
+ * Class for connection type checking logic.
+ * @interface
+ */
+Blockly.IConnectionChecker = 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.IConnectionChecker.prototype.canConnect;
+
+/**
+ * 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.IConnectionChecker.prototype.canConnectWithReason;
+
+/**
+ * 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.IConnectionChecker.prototype.getErrorMessage;
+
+/**
+ * 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.IConnectionChecker.prototype.doSafetyChecks;
+
+/**
+ * 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.IConnectionChecker.prototype.doTypeChecks;
+
+/**
+ * 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.IConnectionChecker.prototype.doDragChecks;

blockly/core/interfaces/i_contextmenu.js

@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview The interface for an object that supports a right-click.
+ * @author samelh@google.com (Sam El-Husseini)
+ */
+
+'use strict';
+
+goog.provide('Blockly.IContextMenu');
+
+
+/**
+ * @interface
+ */
+Blockly.IContextMenu = function() {};
+
+/**
+ * Show the context menu for this object.
+ * @param {!Event} e Mouse event.
+ */
+Blockly.IContextMenu.prototype.showContextMenu;

blockly/core/interfaces/i_copyable.js

@@ -0,0 +1,40 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview The interface for an object that is copyable.
+ * @author samelh@google.com (Sam El-Husseini)
+ */
+
+'use strict';
+
+goog.provide('Blockly.ICopyable');
+
+goog.requireType('Blockly.ISelectable');
+goog.requireType('Blockly.WorkspaceSvg');
+
+
+/**
+ * @extends {Blockly.ISelectable}
+ * @interface
+ */
+Blockly.ICopyable = function() {};
+
+/**
+ * Encode for copying.
+ * @return {?Blockly.ICopyable.CopyData} Copy metadata.
+ */
+Blockly.ICopyable.prototype.toCopyData;
+
+/**
+ * Copy Metadata.
+ * @typedef {{
+ *            xml:!Element,
+ *            source:Blockly.WorkspaceSvg,
+ *            typeCounts:?Object
+ *          }}
+ */
+Blockly.ICopyable.CopyData;

blockly/core/interfaces/i_deletable.js

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview The interface for an object that is deletable.
+ * @author samelh@google.com (Sam El-Husseini)
+ */
+
+'use strict';
+
+goog.provide('Blockly.IDeletable');
+
+
+/**
+ * The interface for an object that can be deleted.
+ * @interface
+ */
+Blockly.IDeletable = function() {};
+
+/**
+ * Get whether this object is deletable or not.
+ * @return {boolean} True if deletable.
+ */
+Blockly.IDeletable.prototype.isDeletable;

blockly/core/interfaces/i_delete_area.js

@@ -0,0 +1,42 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview The interface for a component that can delete a block or bubble
+ * that is dropped on top of it.
+ * @author kozbial@google.com (Monica Kozbial)
+ */
+
+'use strict';
+
+goog.provide('Blockly.IDeleteArea');
+
+goog.require('Blockly.IDragTarget');
+
+goog.requireType('Blockly.IDraggable');
+
+
+/**
+ * Interface for a component that can delete a block or bubble that is dropped
+ * on top of it.
+ * @extends {Blockly.IDragTarget}
+ * @interface
+ */
+Blockly.IDeleteArea = function() {};
+
+/**
+ * Returns whether the provided block or bubble would be deleted if dropped on
+ * this area.
+ * This method should check if the element is deletable and is always called
+ * before onDragEnter/onDragOver/onDragExit.
+ * @param {!Blockly.IDraggable} element The block or bubble currently being
+ *   dragged.
+ * @param {boolean} couldConnect Whether the element could could connect to
+ *     another.
+ * @return {boolean} Whether the element provided would be deleted if dropped on
+ *     this area.
+ */
+Blockly.IDeleteArea.prototype.wouldDelete;

blockly/core/interfaces/i_drag_target.js

@@ -0,0 +1,78 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview The interface for a component that has a handler for when a
+ * block is dropped on top of it.
+ * @author kozbial@google.com (Monica Kozbial)
+ */
+
+'use strict';
+
+goog.provide('Blockly.IDragTarget');
+
+goog.require('Blockly.IComponent');
+
+goog.requireType('Blockly.IDraggable');
+goog.requireType('Blockly.utils.Rect');
+
+/**
+ * Interface for a component with custom behaviour when a block or bubble is
+ * dragged over or dropped on top of it.
+ * @extends {Blockly.IComponent}
+ * @interface
+ */
+Blockly.IDragTarget = function() {};
+
+/**
+ * Returns the bounding rectangle of the drag target area in pixel units
+ * relative to viewport.
+ * @return {?Blockly.utils.Rect} The component's bounding box. Null if drag
+ *   target area should be ignored.
+ */
+Blockly.IDragTarget.prototype.getClientRect;
+
+/**
+ * Handles when a cursor with a block or bubble enters this drag target.
+ * @param {!Blockly.IDraggable} dragElement The block or bubble currently being
+ *   dragged.
+ */
+Blockly.IDragTarget.prototype.onDragEnter;
+
+/**
+ * Handles when a cursor with a block or bubble is dragged over this drag
+ * target.
+ * @param {!Blockly.IDraggable} dragElement The block or bubble currently being
+ *   dragged.
+ */
+Blockly.IDragTarget.prototype.onDragOver;
+
+
+/**
+ * Handles when a cursor with a block or bubble exits this drag target.
+ * @param {!Blockly.IDraggable} dragElement The block or bubble currently being
+ *   dragged.
+ */
+Blockly.IDragTarget.prototype.onDragExit;
+
+/**
+ * Handles when a block or bubble is dropped on this component.
+ * Should not handle delete here.
+ * @param {!Blockly.IDraggable} dragElement The block or bubble currently being
+ *   dragged.
+ */
+Blockly.IDragTarget.prototype.onDrop;
+
+/**
+ * Returns whether the provided block or bubble should not be moved after being
+ * dropped on this component. If true, the element will return to where it was
+ * when the drag started.
+ * @param {!Blockly.IDraggable} dragElement The block or bubble currently being
+ *   dragged.
+ * @return {boolean} Whether the block or bubble provided should be returned to
+ *     drag start.
+ */
+Blockly.IDragTarget.prototype.shouldPreventMove;

blockly/core/interfaces/i_draggable.js

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview The interface for an object that is draggable.
+ * @author kozbial@google.com (Monica Kozbial)
+ */
+
+'use strict';
+
+goog.provide('Blockly.IDraggable');
+
+goog.require('Blockly.IDeletable');
+
+
+/**
+ * The interface for an object that can be dragged.
+ * @extends {Blockly.IDeletable}
+ * @interface
+ */
+Blockly.IDraggable = function() {};

blockly/core/interfaces/i_flyout.js

@@ -0,0 +1,189 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview The interface for a flyout.
+ * @author aschmiedt@google.com (Abby Schmiedt)
+ */
+
+'use strict';
+
+goog.provide('Blockly.IFlyout');
+
+goog.requireType('Blockly.BlockSvg');
+goog.requireType('Blockly.IRegistrable');
+goog.requireType('Blockly.utils.Coordinate');
+goog.requireType('Blockly.utils.Svg');
+goog.requireType('Blockly.utils.toolbox');
+goog.requireType('Blockly.WorkspaceSvg');
+
+
+/**
+ * Interface for a flyout.
+ * @extends {Blockly.IRegistrable}
+ * @interface
+ */
+Blockly.IFlyout = function() {};
+
+/**
+ * Whether the flyout is laid out horizontally or not.
+ * @type {boolean}
+ */
+Blockly.IFlyout.prototype.horizontalLayout;
+
+/**
+ * Is RTL vs LTR.
+ * @type {boolean}
+ */
+Blockly.IFlyout.prototype.RTL;
+
+/**
+ * The target workspace
+ * @type {?Blockly.WorkspaceSvg}
+ */
+Blockly.IFlyout.prototype.targetWorkspace;
+
+/**
+ * Margin around the edges of the blocks in the flyout.
+ * @type {number}
+ * @const
+ */
+Blockly.IFlyout.prototype.MARGIN;
+
+/**
+ * Does the flyout automatically close when a block is created?
+ * @type {boolean}
+ */
+Blockly.IFlyout.prototype.autoClose;
+
+/**
+ * Corner radius of the flyout background.
+ * @type {number}
+ * @const
+ */
+Blockly.IFlyout.prototype.CORNER_RADIUS;
+
+/**
+ * Creates the flyout's DOM.  Only needs to be called once.  The flyout can
+ * either exist as its own svg element or be a g element nested inside a
+ * separate svg element.
+ * @param {string|
+ * !Blockly.utils.Svg<!SVGSVGElement>|
+ * !Blockly.utils.Svg<!SVGGElement>} tagName The type of tag to
+ *     put the flyout in. This should be <svg> or <g>.
+ * @return {!SVGElement} The flyout's SVG group.
+ */
+Blockly.IFlyout.prototype.createDom;
+
+/**
+ * Initializes the flyout.
+ * @param {!Blockly.WorkspaceSvg} targetWorkspace The workspace in which to
+ *     create new blocks.
+ */
+Blockly.IFlyout.prototype.init;
+
+/**
+ * Dispose of this flyout.
+ * Unlink from all DOM elements to prevent memory leaks.
+ */
+Blockly.IFlyout.prototype.dispose;
+
+/**
+ * Get the width of the flyout.
+ * @return {number} The width of the flyout.
+ */
+Blockly.IFlyout.prototype.getWidth;
+
+/**
+ * Get the height of the flyout.
+ * @return {number} The width of the flyout.
+ */
+Blockly.IFlyout.prototype.getHeight;
+
+/**
+ * Get the workspace inside the flyout.
+ * @return {!Blockly.WorkspaceSvg} The workspace inside the flyout.
+ */
+Blockly.IFlyout.prototype.getWorkspace;
+
+/**
+ * Is the flyout visible?
+ * @return {boolean} True if visible.
+ */
+Blockly.IFlyout.prototype.isVisible;
+
+/**
+ * Set whether the flyout is visible. A value of true does not necessarily mean
+ * that the flyout is shown. It could be hidden because its container is hidden.
+ * @param {boolean} visible True if visible.
+ */
+Blockly.IFlyout.prototype.setVisible;
+
+/**
+ * Set whether this flyout's container is visible.
+ * @param {boolean} visible Whether the container is visible.
+ */
+Blockly.IFlyout.prototype.setContainerVisible;
+
+/**
+ * Hide and empty the flyout.
+ */
+Blockly.IFlyout.prototype.hide;
+
+/**
+ * Show and populate the flyout.
+ * @param {!Blockly.utils.toolbox.FlyoutDefinition|string} flyoutDef Contents to
+ *     display in the flyout. This is either an array of Nodes, a NodeList, a
+ *     toolbox definition, or a string with the name of the dynamic category.
+ */
+Blockly.IFlyout.prototype.show;
+
+/**
+ * Create a copy of this block on the workspace.
+ * @param {!Blockly.BlockSvg} originalBlock The block to copy from the flyout.
+ * @return {!Blockly.BlockSvg} The newly created block.
+ * @throws {Error} if something went wrong with deserialization.
+ */
+Blockly.IFlyout.prototype.createBlock;
+
+/**
+ * Reflow blocks and their mats.
+ */
+Blockly.IFlyout.prototype.reflow;
+
+/**
+ * @return {boolean} True if this flyout may be scrolled with a scrollbar or by
+ *     dragging.
+ */
+Blockly.IFlyout.prototype.isScrollable;
+
+/**
+ * Calculates the x coordinate for the flyout position.
+ * @return {number} X coordinate.
+ */
+Blockly.IFlyout.prototype.getX;
+
+/**
+ * Calculates the y coordinate for the flyout position.
+ * @return {number} Y coordinate.
+ */
+Blockly.IFlyout.prototype.getY;
+
+/**
+ * Position the flyout.
+ * @return {void}
+ */
+Blockly.IFlyout.prototype.position;
+
+/**
+ * Determine if a drag delta is toward the workspace, based on the position
+ * and orientation of the flyout. This is used in determineDragIntention_ to
+ * determine if a new block should be created or if the flyout should scroll.
+ * @param {!Blockly.utils.Coordinate} currentDragDeltaXY How far the pointer has
+ *     moved from the position at mouse down, in pixel units.
+ * @return {boolean} True if the drag is toward the workspace.
+ */
+Blockly.IFlyout.prototype.isDragTowardWorkspace;

blockly/core/interfaces/i_metrics_manager.js

@@ -0,0 +1,145 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview The interface for a metrics manager.
+ * @author aschmiedt@google.com (Abby Schmiedt)
+ */
+
+'use strict';
+
+goog.provide('Blockly.IMetricsManager');
+
+goog.requireType('Blockly.MetricsManager');
+goog.requireType('Blockly.utils.Metrics');
+goog.requireType('Blockly.utils.Size');
+
+
+/**
+ * Interface for a metrics manager.
+ * @interface
+ */
+Blockly.IMetricsManager = function() {};
+
+/**
+ * Returns whether the scroll area has fixed edges.
+ * @return {boolean} Whether the scroll area has fixed edges.
+ * @package
+ */
+Blockly.IMetricsManager.prototype.hasFixedEdges;
+
+/**
+ * Returns the metrics for the scroll area of the workspace.
+ * @param {boolean=} opt_getWorkspaceCoordinates True to get the scroll metrics
+ *     in workspace coordinates, false to get them in pixel coordinates.
+ * @param {!Blockly.MetricsManager.ContainerRegion=} opt_viewMetrics The view
+ *     metrics if they have been previously computed. Passing in null may cause
+ *     the view metrics to be computed again, if it is needed.
+ * @param {!Blockly.MetricsManager.ContainerRegion=} opt_contentMetrics The
+ *     content metrics if they have been previously computed. Passing in null
+ *     may cause the content metrics to be computed again, if it is needed.
+ * @return {!Blockly.MetricsManager.ContainerRegion} The metrics for the scroll
+ *    container
+ */
+Blockly.IMetricsManager.prototype.getScrollMetrics;
+
+/**
+ * Gets the width and the height of the flyout on the workspace in pixel
+ * coordinates. Returns 0 for the width and height if the workspace has a
+ * category toolbox instead of a simple toolbox.
+ * @param {boolean=} opt_own Whether to only return the workspace's own flyout.
+ * @return {!Blockly.MetricsManager.ToolboxMetrics} The width and height of the
+ *     flyout.
+ * @public
+ */
+Blockly.IMetricsManager.prototype.getFlyoutMetrics;
+
+/**
+ * Gets the width, height and position of the toolbox on the workspace in pixel
+ * coordinates. Returns 0 for the width and height if the workspace has a simple
+ * toolbox instead of a category toolbox. To get the width and height of a
+ * simple toolbox @see {@link getFlyoutMetrics}.
+ * @return {!Blockly.MetricsManager.ToolboxMetrics} The object with the width,
+ *     height and position of the toolbox.
+ * @public
+ */
+Blockly.IMetricsManager.prototype.getToolboxMetrics;
+
+/**
+ * Gets the width and height of the workspace's parent SVG element in pixel
+ * coordinates. This area includes the toolbox and the visible workspace area.
+ * @return {!Blockly.utils.Size} The width and height of the workspace's parent
+ *     SVG element.
+ * @public
+ */
+Blockly.IMetricsManager.prototype.getSvgMetrics;
+
+/**
+ * Gets the absolute left and absolute top in pixel coordinates.
+ * This is where the visible workspace starts in relation to the SVG container.
+ * @return {!Blockly.MetricsManager.AbsoluteMetrics} The absolute metrics for
+ *     the workspace.
+ * @public
+ */
+Blockly.IMetricsManager.prototype.getAbsoluteMetrics;
+
+/**
+ * Gets the metrics for the visible workspace in either pixel or workspace
+ * coordinates. The visible workspace does not include the toolbox or flyout.
+ * @param {boolean=} opt_getWorkspaceCoordinates True to get the view metrics in
+ *     workspace coordinates, false to get them in pixel coordinates.
+ * @return {!Blockly.MetricsManager.ContainerRegion} The width, height, top and
+ *     left of the viewport in either workspace coordinates or pixel
+ *     coordinates.
+ * @public
+ */
+Blockly.IMetricsManager.prototype.getViewMetrics;
+
+/**
+ * Gets content metrics in either pixel or workspace coordinates.
+ * The content area is a rectangle around all the top bounded elements on the
+ * workspace (workspace comments and blocks).
+ * @param {boolean=} opt_getWorkspaceCoordinates True to get the content metrics
+ *     in workspace coordinates, false to get them in pixel coordinates.
+ * @return {!Blockly.MetricsManager.ContainerRegion} The
+ *     metrics for the content container.
+ * @public
+ */
+Blockly.IMetricsManager.prototype.getContentMetrics;
+
+/**
+ * Returns an object with all the metrics required to size scrollbars for a
+ * top level workspace.  The following properties are computed:
+ * Coordinate system: pixel coordinates, -left, -up, +right, +down
+ * .viewHeight: Height of the visible portion of the workspace.
+ * .viewWidth: Width of the visible portion of the workspace.
+ * .contentHeight: Height of the content.
+ * .contentWidth: Width of the content.
+ * .svgHeight: Height of the Blockly div (the view + the toolbox,
+ *    simple or otherwise),
+ * .svgWidth: Width of the Blockly div (the view + the toolbox,
+ *    simple or otherwise),
+ * .viewTop: Top-edge of the visible portion of the workspace, relative to
+ *     the workspace origin.
+ * .viewLeft: Left-edge of the visible portion of the workspace, relative to
+ *     the workspace origin.
+ * .contentTop: Top-edge of the content, relative to the workspace origin.
+ * .contentLeft: Left-edge of the content relative to the workspace origin.
+ * .absoluteTop: Top-edge of the visible portion of the workspace, relative
+ *     to the blocklyDiv.
+ * .absoluteLeft: Left-edge of the visible portion of the workspace, relative
+ *     to the blocklyDiv.
+ * .toolboxWidth: Width of the toolbox, if it exists.  Otherwise zero.
+ * .toolboxHeight: Height of the toolbox, if it exists.  Otherwise zero.
+ * .flyoutWidth: Width of the flyout if it is always open.  Otherwise zero.
+ * .flyoutHeight: Height of the flyout if it is always open.  Otherwise zero.
+ * .toolboxPosition: Top, bottom, left or right. Use TOOLBOX_AT constants to
+ *     compare.
+ * @return {!Blockly.utils.Metrics} Contains size and position metrics of a top
+ *     level workspace.
+ * @public
+ */
+Blockly.IMetricsManager.prototype.getMetrics;

blockly/core/interfaces/i_movable.js

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview The interface for an object that is movable.
+ * @author samelh@google.com (Sam El-Husseini)
+ */
+
+'use strict';
+
+goog.provide('Blockly.IMovable');
+
+
+/**
+ * The interface for an object that is movable.
+ * @interface
+ */
+Blockly.IMovable = function() {};
+
+/**
+ * Get whether this is movable or not.
+ * @return {boolean} True if movable.
+ */
+Blockly.IMovable.prototype.isMovable;

blockly/core/interfaces/i_positionable.js

@@ -0,0 +1,43 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview The interface for a positionable UI element.
+ * @author kozbial@google.com (Monica Kozbial)
+ */
+
+'use strict';
+
+goog.provide('Blockly.IPositionable');
+
+goog.require('Blockly.IComponent');
+
+goog.requireType('Blockly.MetricsManager');
+goog.requireType('Blockly.utils.Rect');
+
+
+/**
+ * Interface for a component that is positioned on top of the workspace.
+ * @extends {Blockly.IComponent}
+ * @interface
+ */
+Blockly.IPositionable = function() {};
+
+/**
+ * Positions the element. Called when the window is resized.
+ * @param {!Blockly.MetricsManager.UiMetrics} metrics The workspace metrics.
+ * @param {!Array<!Blockly.utils.Rect>} savedPositions List of rectangles that
+ *     are already on the workspace.
+ */
+Blockly.IPositionable.prototype.position;
+
+/**
+ * Returns the bounding rectangle of the UI element in pixel units relative to
+ * the Blockly injection div.
+ * @return {?Blockly.utils.Rect} The UI elements’s bounding box. Null if
+ *   bounding box should be ignored by other UI elements.
+ */
+Blockly.IPositionable.prototype.getBoundingRectangle;

blockly/core/interfaces/i_registrable.js

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview The interface for a Blockly component that can be registered.
+ *    (Ex. Toolbox, Fields, Renderers)
+ * @author aschmiedt@google.com (Abby Schmiedt)
+ */
+
+'use strict';
+
+goog.provide('Blockly.IRegistrable');
+
+
+/**
+ * The interface for a Blockly component that can be registered.
+ * @interface
+ */
+Blockly.IRegistrable = function() {};

blockly/core/interfaces/i_registrable_field.js

@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview The interface for a Blockly field that can be registered.
+ * @author samelh@google.com (Sam El-Husseini)
+ */
+
+'use strict';
+
+goog.provide('Blockly.IRegistrableField');
+
+goog.requireType('Blockly.Field');
+
+/**
+ * A registrable field.
+ * Note: We are not using an interface here as we are interested in defining the
+ * static methods of a field rather than the instance methods.
+ * @typedef {{
+ *     fromJson:Blockly.IRegistrableField.fromJson
+ * }}
+ */
+Blockly.IRegistrableField;
+
+/**
+ * @typedef {function(!Object): Blockly.Field}
+ */
+Blockly.IRegistrableField.fromJson;

blockly/core/interfaces/i_selectable.js

@@ -0,0 +1,43 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview The interface for an object that is selectable.
+ * @author samelh@google.com (Sam El-Husseini)
+ */
+
+'use strict';
+
+goog.provide('Blockly.ISelectable');
+
+goog.requireType('Blockly.IDeletable');
+goog.requireType('Blockly.IMovable');
+
+
+/**
+ * The interface for an object that is selectable.
+ * @extends {Blockly.IDeletable}
+ * @extends {Blockly.IMovable}
+ * @interface
+ */
+Blockly.ISelectable = function() {};
+
+/**
+ * @type {string}
+ */
+Blockly.ISelectable.prototype.id;
+
+/**
+ * Select this.  Highlight it visually.
+ * @return {void}
+ */
+Blockly.ISelectable.prototype.select;
+
+/**
+ * Unselect this.  Unhighlight it visually.
+ * @return {void}
+ */
+Blockly.ISelectable.prototype.unselect;

blockly/core/interfaces/i_styleable.js

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview The interface for an object that a style can be added to.
+ * @author aschmiedt@google.com (Abby Schmiedt)
+ */
+
+'use strict';
+
+goog.provide('Blockly.IStyleable');
+
+
+/**
+ * Interface for an object that a style can be added to.
+ * @interface
+ */
+Blockly.IStyleable = function() {};
+
+/**
+ * Adds a style on the toolbox. Usually used to change the cursor.
+ * @param {string} style The name of the class to add.
+ */
+Blockly.IStyleable.prototype.addStyle;
+
+/**
+ * Removes a style from the toolbox. Usually used to change the cursor.
+ * @param {string} style The name of the class to remove.
+ */
+Blockly.IStyleable.prototype.removeStyle;

blockly/core/interfaces/i_toolbox.js

@@ -0,0 +1,131 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview The interface for a toolbox.
+ * @author aschmiedt@google.com (Abby Schmiedt)
+ */
+
+'use strict';
+
+goog.provide('Blockly.IToolbox');
+
+goog.requireType('Blockly.IFlyout');
+goog.requireType('Blockly.IRegistrable');
+goog.requireType('Blockly.IToolboxItem');
+goog.requireType('Blockly.utils.toolbox');
+goog.requireType('Blockly.WorkspaceSvg');
+
+
+/**
+ * Interface for a toolbox.
+ * @extends {Blockly.IRegistrable}
+ * @interface
+ */
+Blockly.IToolbox = function() {};
+
+/**
+ * Initializes the toolbox.
+ * @return {void}
+ */
+Blockly.IToolbox.prototype.init;
+
+/**
+ * Fills the toolbox with new toolbox items and removes any old contents.
+ * @param {!Blockly.utils.toolbox.ToolboxInfo} toolboxDef Object holding information
+ *     for creating a toolbox.
+ */
+Blockly.IToolbox.prototype.render;
+
+/**
+ * Gets the width of the toolbox.
+ * @return {number} The width of the toolbox.
+ */
+Blockly.IToolbox.prototype.getWidth;
+
+/**
+ * Gets the height of the toolbox.
+ * @return {number} The width of the toolbox.
+ */
+Blockly.IToolbox.prototype.getHeight;
+
+/**
+ * Gets the toolbox flyout.
+ * @return {?Blockly.IFlyout} The toolbox flyout.
+ */
+Blockly.IToolbox.prototype.getFlyout;
+
+/**
+ * Gets the workspace for the toolbox.
+ * @return {!Blockly.WorkspaceSvg} The parent workspace for the toolbox.
+ */
+Blockly.IToolbox.prototype.getWorkspace;
+
+/**
+ * Gets whether or not the toolbox is horizontal.
+ * @return {boolean} True if the toolbox is horizontal, false if the toolbox is
+ *     vertical.
+ */
+Blockly.IToolbox.prototype.isHorizontal;
+
+/**
+ * Positions the toolbox based on whether it is a horizontal toolbox and whether
+ * the workspace is in rtl.
+ * @return {void}
+ */
+Blockly.IToolbox.prototype.position;
+
+/**
+ * Handles resizing the toolbox when a toolbox item resizes.
+ * @return {void}
+ */
+Blockly.IToolbox.prototype.handleToolboxItemResize;
+
+/**
+ * Unhighlights any previously selected item.
+ * @return {void}
+ */
+Blockly.IToolbox.prototype.clearSelection;
+
+/**
+ * Updates the category colours and background colour of selected categories.
+ * @return {void}
+ */
+Blockly.IToolbox.prototype.refreshTheme;
+
+/**
+ * Updates the flyout's content without closing it.  Should be used in response
+ * to a change in one of the dynamic categories, such as variables or
+ * procedures.
+ * @return {void}
+ */
+Blockly.IToolbox.prototype.refreshSelection;
+
+/**
+ * Sets the visibility of the toolbox.
+ * @param {boolean} isVisible True if toolbox should be visible.
+ */
+Blockly.IToolbox.prototype.setVisible;
+
+/**
+ * Selects the toolbox item by it's position in the list of toolbox items.
+ * @param {number} position The position of the item to select.
+ * @return {void}
+ */
+Blockly.IToolbox.prototype.selectItemByPosition;
+
+/**
+ * Gets the selected item.
+ * @return {?Blockly.IToolboxItem} The selected item, or null if no item is
+ *     currently selected.
+ */
+Blockly.IToolbox.prototype.getSelectedItem;
+
+/**
+ * Disposes of this toolbox.
+ * @return {void}
+ */
+Blockly.IToolbox.prototype.dispose;

blockly/core/interfaces/i_toolbox_item.js

@@ -0,0 +1,157 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview The interface for a toolbox item.
+ * @author aschmiedt@google.com (Abby Schmiedt)
+ */
+
+'use strict';
+
+goog.provide('Blockly.ICollapsibleToolboxItem');
+goog.provide('Blockly.ISelectableToolboxItem');
+goog.provide('Blockly.IToolboxItem');
+
+goog.requireType('Blockly.utils.toolbox');
+
+
+/**
+ * Interface for an item in the toolbox.
+ * @interface
+ */
+Blockly.IToolboxItem = function() {};
+
+/**
+ * Initializes the toolbox item.
+ * This includes creating the DOM and updating the state of any items based
+ * on the info object.
+ * @return {void}
+ * @public
+ */
+Blockly.IToolboxItem.prototype.init;
+
+/**
+ * Gets the div for the toolbox item.
+ * @return {?Element} The div for the toolbox item.
+ * @public
+ */
+Blockly.IToolboxItem.prototype.getDiv;
+
+/**
+ * Gets a unique identifier for this toolbox item.
+ * @return {string} The ID for the toolbox item.
+ * @public
+ */
+Blockly.IToolboxItem.prototype.getId;
+
+/**
+ * Gets the parent if the toolbox item is nested.
+ * @return {?Blockly.IToolboxItem} The parent toolbox item, or null if
+ *     this toolbox item is not nested.
+ * @public
+ */
+Blockly.IToolboxItem.prototype.getParent;
+
+/**
+ * Gets the nested level of the category.
+ * @return {number} The nested level of the category.
+ * @package
+ */
+Blockly.IToolboxItem.prototype.getLevel;
+
+/**
+ * Whether the toolbox item is selectable.
+ * @return {boolean} True if the toolbox item can be selected.
+ * @public
+ */
+Blockly.IToolboxItem.prototype.isSelectable;
+
+/**
+ * Whether the toolbox item is collapsible.
+ * @return {boolean} True if the toolbox item is collapsible.
+ * @public
+ */
+Blockly.IToolboxItem.prototype.isCollapsible;
+
+/**
+ * Dispose of this toolbox item. No-op by default.
+ * @public
+ */
+Blockly.IToolboxItem.prototype.dispose;
+
+/**
+ * Interface for an item in the toolbox that can be selected.
+ * @extends {Blockly.IToolboxItem}
+ * @interface
+ */
+Blockly.ISelectableToolboxItem = function() {};
+
+/**
+ * Gets the name of the toolbox item. Used for emitting events.
+ * @return {string} The name of the toolbox item.
+ * @public
+ */
+Blockly.ISelectableToolboxItem.prototype.getName;
+
+/**
+ * Gets the contents of the toolbox item. These are items that are meant to be
+ * displayed in the flyout.
+ * @return {!Blockly.utils.toolbox.FlyoutItemInfoArray|string} The definition
+ *     of items to be displayed in the flyout.
+ * @public
+ */
+Blockly.ISelectableToolboxItem.prototype.getContents;
+
+/**
+ * Sets the current toolbox item as selected.
+ * @param {boolean} _isSelected True if this category is selected, false
+ *     otherwise.
+ * @public
+ */
+Blockly.ISelectableToolboxItem.prototype.setSelected;
+
+/**
+ * Gets the HTML element that is clickable.
+ * The parent toolbox element receives clicks. The parent toolbox will add an ID
+ * to this element so it can pass the onClick event to the correct toolboxItem.
+ * @return {!Element} The HTML element that receives clicks.
+ * @public
+ */
+Blockly.ISelectableToolboxItem.prototype.getClickTarget;
+
+/**
+ * Handles when the toolbox item is clicked.
+ * @param {!Event} _e Click event to handle.
+ * @public
+ */
+Blockly.ISelectableToolboxItem.prototype.onClick;
+
+/**
+ * Interface for an item in the toolbox that can be collapsed.
+ * @extends {Blockly.ISelectableToolboxItem}
+ * @interface
+ */
+Blockly.ICollapsibleToolboxItem = function() {};
+
+/**
+ * Gets any children toolbox items. (ex. Gets the subcategories)
+ * @return {!Array<!Blockly.IToolboxItem>} The child toolbox items.
+ */
+Blockly.ICollapsibleToolboxItem.prototype.getChildToolboxItems;
+
+/**
+ * Whether the toolbox item is expanded to show its child subcategories.
+ * @return {boolean} True if the toolbox item shows its children, false if it
+ *     is collapsed.
+ * @public
+ */
+Blockly.ICollapsibleToolboxItem.prototype.isExpanded;
+
+/**
+ * Toggles whether or not the toolbox item is expanded.
+ * @public
+ */
+Blockly.ICollapsibleToolboxItem.prototype.toggleExpanded;