nodeskini 1.0.1 → 1.0.2

package/blocklySkini/blockly/core/interfaces/i_accessibility.js

@@ -0,0 +1,72 @@
+/**
+ * @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.IBlocklyActionable');
+
+/**
+ * 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 Blockly actions when keyboard
+ * navigation is enabled.
+ * @interface
+ */
+Blockly.IBlocklyActionable = function() {};
+
+/**
+ * Handles the given action.
+ * @param {!Blockly.Action} action The action to be handled.
+ * @return {boolean} True if the action has been handled, false otherwise.
+ */
+Blockly.IBlocklyActionable.prototype.onBlocklyAction;

package/blocklySkini/blockly/core/interfaces/i_bounded_element.js

@@ -0,0 +1,31 @@
+/**
+ * @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;

package/blocklySkini/blockly/core/interfaces/i_bubble.js

@@ -0,0 +1,83 @@
+/**
+ * @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.requireType('Blockly.IContextMenu');
+goog.requireType('Blockly.IDeletable');
+
+
+/**
+ * A bubble interface.
+ * @interface
+ * @extends {Blockly.IDeletable}
+ * @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;

package/blocklySkini/blockly/core/interfaces/i_connection_checker.js

@@ -0,0 +1,94 @@
+/**
+ * @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');
+
+
+/**
+ * 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;

package/blocklySkini/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;

package/blocklySkini/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;

package/blocklySkini/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;

package/blocklySkini/blockly/core/interfaces/i_deletearea.js

@@ -0,0 +1,28 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview The interface for a component that can delete a block that is
+ *   dropped on top of it.
+ * @author aschmiedt@google.com (Abby Schmiedt)
+ */
+
+'use strict';
+
+goog.provide('Blockly.IDeleteArea');
+
+
+/**
+ * Interface for a component that can delete a block that is dropped on top of it.
+ * @interface
+ */
+Blockly.IDeleteArea = function() {};
+
+/**
+ * Return the deletion rectangle.
+ * @return {Blockly.utils.Rect} Rectangle in which to delete.
+ */
+Blockly.IDeleteArea.prototype.getClientRect;

package/blocklySkini/blockly/core/interfaces/i_flyout.js

@@ -0,0 +1,178 @@
+/**
+ * @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.dom');
+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;
+
+/**
+ * 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;

package/blocklySkini/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;

package/blocklySkini/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() {};

package/blocklySkini/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;