blockly 9.0.0-beta.0 → 9.0.0-beta.2

package/core/positionable_helpers.d.ts

@@ -9,6 +9,7 @@ import type { Size } from './utils/size.js';
 import type { WorkspaceSvg } from './workspace_svg.js';
 /**
  * Enum for vertical positioning.
+ *
  * @alias Blockly.uiPosition.verticalPosition
  * @internal
  */
@@ -18,6 +19,7 @@ export declare enum verticalPosition {
 }
 /**
  * Enum for horizontal positioning.
+ *
  * @alias Blockly.uiPosition.horizontalPosition
  * @internal
  */
@@ -27,6 +29,7 @@ export declare enum horizontalPosition {
 }
 /**
  * An object defining a horizontal and vertical positioning.
+ *
  * @alias Blockly.uiPosition.Position
  * @internal
  */
@@ -36,6 +39,7 @@ export interface Position {
 }
 /**
  * Enum for bump rules to use for dealing with collisions.
+ *
  * @alias Blockly.uiPosition.bumpDirection
  * @internal
  */
@@ -48,13 +52,14 @@ export declare enum bumpDirection {
  * element of the specified size given the restraints and locations of the
  * scrollbars. This method does not take into account any already placed UI
  * elements.
+ *
  * @param position The starting horizontal and vertical position.
  * @param size the size of the UI element to get a start position for.
  * @param horizontalPadding The horizontal padding to use.
  * @param verticalPadding The vertical padding to use.
  * @param metrics The workspace UI metrics.
  * @param workspace The workspace.
- * @return The suggested start position.
+ * @returns The suggested start position.
  * @alias Blockly.uiPosition.getStartPositionRect
  * @internal
  */
@@ -64,9 +69,10 @@ export declare function getStartPositionRect(position: Position, size: Size, hor
  * the toolbox.
  * If in horizontal orientation, defaults to the bottom corner. If in vertical
  * orientation, defaults to the right corner.
+ *
  * @param workspace The workspace.
  * @param metrics The workspace metrics.
- * @return The suggested corner position.
+ * @returns The suggested corner position.
  * @alias Blockly.uiPosition.getCornerOppositeToolbox
  * @internal
  */
@@ -75,14 +81,16 @@ export declare function getCornerOppositeToolbox(workspace: WorkspaceSvg, metric
  * Returns a position Rect based on a starting position that is bumped
  * so that it doesn't intersect with any of the provided savedPositions. This
  * method does not check that the bumped position is still within bounds.
+ *
  * @param startRect The starting position to use.
  * @param margin The margin to use between elements when bumping.
  * @param bumpDir The direction to bump if there is a collision with an existing
  *     UI element.
  * @param savedPositions List of rectangles that represent the positions of UI
  *     elements already placed.
- * @return The suggested position rectangle.
+ * @returns The suggested position rectangle.
  * @alias Blockly.uiPosition.bumpPositionRect
  * @internal
  */
 export declare function bumpPositionRect(startRect: Rect, margin: number, bumpDir: bumpDirection, savedPositions: Rect[]): Rect;
+//# sourceMappingURL=positionable_helpers.d.ts.map

package/core/procedures.d.ts

@@ -15,69 +15,82 @@ import type { WorkspaceSvg } from './workspace_svg.js';
  * procedure blocks.
  * See also Blockly.Variables.CATEGORY_NAME and
  * Blockly.VariablesDynamic.CATEGORY_NAME.
+ *
  * @alias Blockly.Procedures.CATEGORY_NAME
  */
 export declare const CATEGORY_NAME = "PROCEDURE";
 /**
  * The default argument for a procedures_mutatorarg block.
+ *
  * @alias Blockly.Procedures.DEFAULT_ARG
  */
 export declare const DEFAULT_ARG = "x";
+export declare type ProcedureTuple = [string, string[], boolean];
 /**
  * Procedure block type.
+ *
  * @alias Blockly.Procedures.ProcedureBlock
  */
 export interface ProcedureBlock {
     getProcedureCall: () => string;
-    renameProcedure: (p1: string, p2: string) => any;
-    getProcedureDef: () => any[];
+    renameProcedure: (p1: string, p2: string) => void;
+    getProcedureDef: () => ProcedureTuple;
 }
 /**
  * Find all user-created procedure definitions in a workspace.
+ *
  * @param root Root workspace.
- * @return Pair of arrays, the first contains procedures without return
+ * @returns Pair of arrays, the first contains procedures without return
  *     variables, the second with. Each procedure is defined by a three-element
  *     list of name, parameter list, and return value boolean.
  * @alias Blockly.Procedures.allProcedures
  */
-export declare function allProcedures(root: Workspace): any[][][];
+export declare function allProcedures(root: Workspace): [
+    ProcedureTuple[],
+    ProcedureTuple[]
+];
 /**
  * Ensure two identically-named procedures don't exist.
  * Take the proposed procedure name, and return a legal name i.e. one that
  * is not empty and doesn't collide with other procedures.
+ *
  * @param name Proposed procedure name.
  * @param block Block to disambiguate.
- * @return Non-colliding name.
+ * @returns Non-colliding name.
  * @alias Blockly.Procedures.findLegalName
  */
 export declare function findLegalName(name: string, block: Block): string;
 /**
  * Return if the given name is already a procedure name.
+ *
  * @param name The questionable name.
  * @param workspace The workspace to scan for collisions.
  * @param opt_exclude Optional block to exclude from comparisons (one doesn't
  *     want to collide with oneself).
- * @return True if the name is used, otherwise return false.
+ * @returns True if the name is used, otherwise return false.
  * @alias Blockly.Procedures.isNameUsed
  */
 export declare function isNameUsed(name: string, workspace: Workspace, opt_exclude?: Block): boolean;
 /**
  * Rename a procedure.  Called by the editable field.
+ *
  * @param name The proposed new name.
- * @return The accepted name.
+ * @returns The accepted name.
  * @alias Blockly.Procedures.rename
  */
 export declare function rename(this: Field, name: string): string;
 /**
  * Construct the blocks required by the flyout for the procedure category.
+ *
  * @param workspace The workspace containing procedures.
- * @return Array of XML block elements.
+ * @returns Array of XML block elements.
  * @alias Blockly.Procedures.flyoutCategory
  */
 export declare function flyoutCategory(workspace: WorkspaceSvg): Element[];
 /**
  * Listens for when a procedure mutator is opened. Then it triggers a flyout
  * update and adds a mutator change listener to the mutator workspace.
+ *
  * @param e The event that triggered this listener.
  * @alias Blockly.Procedures.mutatorOpenListener
  * @internal
@@ -85,24 +98,28 @@ export declare function flyoutCategory(workspace: WorkspaceSvg): Element[];
 export declare function mutatorOpenListener(e: Abstract): void;
 /**
  * Find all the callers of a named procedure.
+ *
  * @param name Name of procedure.
  * @param workspace The workspace to find callers in.
- * @return Array of caller blocks.
+ * @returns Array of caller blocks.
  * @alias Blockly.Procedures.getCallers
  */
 export declare function getCallers(name: string, workspace: Workspace): Block[];
 /**
  * When a procedure definition changes its parameters, find and edit all its
  * callers.
+ *
  * @param defBlock Procedure definition block.
  * @alias Blockly.Procedures.mutateCallers
  */
 export declare function mutateCallers(defBlock: Block): void;
 /**
  * Find the definition block for the named procedure.
+ *
  * @param name Name of procedure.
  * @param workspace The workspace to search.
- * @return The procedure definition block, or null not found.
+ * @returns The procedure definition block, or null not found.
  * @alias Blockly.Procedures.getDefinition
  */
 export declare function getDefinition(name: string, workspace: Workspace): Block | null;
+//# sourceMappingURL=procedures.d.ts.map

package/core/registry.d.ts

@@ -25,20 +25,23 @@ export declare const TEST_ONLY: {
 };
 /**
  * The string used to register the default class for a type of plugin.
+ *
  * @alias Blockly.registry.DEFAULT
  */
 export declare const DEFAULT = "default";
 /**
  * A name with the type of the element stored in the generic.
+ *
  * @alias Blockly.registry.Type
  */
-export declare class Type<T> {
+export declare class Type<_T> {
     private readonly name;
     /** @param name The name of the registry type. */
     constructor(name: string);
     /**
      * Returns the name of the type.
-     * @return The name.
+     *
+     * @returns The name.
      */
     toString(): string;
     static CONNECTION_CHECKER: Type<IConnectionChecker>;
@@ -58,6 +61,7 @@ export declare class Type<T> {
 }
 /**
  * Registers a class based on a type and name.
+ *
  * @param type The type of the plugin.
  *     (e.g. Field, Renderer)
  * @param name The plugin's name. (Ex. field_angle, geras)
@@ -72,6 +76,7 @@ export declare class Type<T> {
 export declare function register<T>(type: string | Type<T>, name: string, registryItem: (new (...p1: any[]) => T) | null | any, opt_allowOverrides?: boolean): void;
 /**
  * Unregisters the registry item with the given type and name.
+ *
  * @param type The type of the plugin.
  *     (e.g. Field, Renderer)
  * @param name The plugin's name. (Ex. field_angle, geras)
@@ -81,57 +86,63 @@ export declare function unregister<T>(type: string | Type<T>, name: string): voi
 /**
  * Returns whether or not the registry contains an item with the given type and
  * name.
+ *
  * @param type The type of the plugin.
  *     (e.g. Field, Renderer)
  * @param name The plugin's name. (Ex. field_angle, geras)
- * @return True if the registry has an item with the given type and name, false
+ * @returns True if the registry has an item with the given type and name, false
  *     otherwise.
  * @alias Blockly.registry.hasItem
  */
 export declare function hasItem<T>(type: string | Type<T>, name: string): boolean;
 /**
  * Gets the class for the given name and type.
+ *
  * @param type The type of the plugin.
  *     (e.g. Field, Renderer)
  * @param name The plugin's name. (Ex. field_angle, geras)
  * @param opt_throwIfMissing Whether or not to throw an error if we are unable
  *     to find the plugin.
- * @return The class with the given name and type or null if none exists.
+ * @returns The class with the given name and type or null if none exists.
  * @alias Blockly.registry.getClass
  */
 export declare function getClass<T>(type: string | Type<T>, name: string, opt_throwIfMissing?: boolean): (new (...p1: any[]) => T) | null;
 /**
  * Gets the object for the given name and type.
+ *
  * @param type The type of the plugin.
  *     (e.g. Category)
  * @param name The plugin's name. (Ex. logic_category)
  * @param opt_throwIfMissing Whether or not to throw an error if we are unable
  *     to find the object.
- * @return The object with the given name and type or null if none exists.
+ * @returns The object with the given name and type or null if none exists.
  * @alias Blockly.registry.getObject
  */
 export declare function getObject<T>(type: string | Type<T>, name: string, opt_throwIfMissing?: boolean): T | null;
 /**
  * Returns a map of items registered with the given type.
+ *
  * @param type The type of the plugin. (e.g. Category)
  * @param opt_cased Whether or not to return a map with cased keys (rather than
  *     caseless keys). False by default.
  * @param opt_throwIfMissing Whether or not to throw an error if we are unable
  *     to find the object. False by default.
- * @return A map of objects with the given type, or null if none exists.
+ * @returns A map of objects with the given type, or null if none exists.
  * @alias Blockly.registry.getAllItems
  */
-export declare function getAllItems<T>(type: string | Type<T>, opt_cased: boolean, opt_throwIfMissing?: boolean): {
+export declare function getAllItems<T>(type: string | Type<T>, opt_cased?: boolean, opt_throwIfMissing?: boolean): {
     [key: string]: T | null | (new (...p1: any[]) => T);
 } | null;
 /**
  * Gets the class from Blockly options for the given type.
  * This is used for plugins that override a built in feature. (e.g. Toolbox)
+ *
  * @param type The type of the plugin.
  * @param options The option object to check for the given plugin.
  * @param opt_throwIfMissing Whether or not to throw an error if we are unable
  *     to find the plugin.
- * @return The class for the plugin.
+ * @returns The class for the plugin.
  * @alias Blockly.registry.getClassFromOptions
  */
 export declare function getClassFromOptions<T>(type: Type<T>, options: Options, opt_throwIfMissing?: boolean): (new (...p1: any[]) => T) | null;
+//# sourceMappingURL=registry.d.ts.map

package/core/rendered_connection.d.ts

@@ -9,6 +9,7 @@ import { Connection } from './connection.js';
 import { Coordinate } from './utils/coordinate.js';
 /**
  * Class for a connection between blocks that may be rendered on screen.
+ *
  * @alias Blockly.RenderedConnection
  */
 export declare class RenderedConnection extends Connection {
@@ -17,6 +18,7 @@ export declare class RenderedConnection extends Connection {
     private readonly dbOpposite_;
     private readonly offsetInBlock_;
     private trackedState_;
+    private highlightPath;
     /** Connection this connection connects to.  Null if not connected. */
     targetConnection: RenderedConnection | null;
     /**
@@ -27,41 +29,48 @@ export declare class RenderedConnection extends Connection {
     /**
      * Dispose of this connection. Remove it from the database (if it is
      * tracked) and call the super-function to deal with connected blocks.
+     *
      * @internal
      */
     dispose(): void;
     /**
      * Get the source block for this connection.
-     * @return The source block.
+     *
+     * @returns The source block.
      */
     getSourceBlock(): BlockSvg;
     /**
      * Returns the block that this connection connects to.
-     * @return The connected block or null if none is connected.
+     *
+     * @returns The connected block or null if none is connected.
      */
     targetBlock(): BlockSvg | null;
     /**
      * Returns the distance between this connection and another connection in
      * workspace units.
+     *
      * @param otherConnection The other connection to measure the distance to.
-     * @return The distance between connections, in workspace units.
+     * @returns The distance between connections, in workspace units.
      */
     distanceFrom(otherConnection: Connection): number;
     /**
      * Move the block(s) belonging to the connection to a point where they don't
      * visually interfere with the specified connection.
+     *
      * @param staticConnection The connection to move away from.
      * @internal
      */
     bumpAwayFrom(staticConnection: RenderedConnection): void;
     /**
      * Change the connection's coordinates.
+     *
      * @param x New absolute x coordinate, in workspace coordinates.
      * @param y New absolute y coordinate, in workspace coordinates.
      */
     moveTo(x: number, y: number): void;
     /**
      * Change the connection's coordinates.
+     *
      * @param dx Change to x coordinate, in workspace units.
      * @param dy Change to y coordinate, in workspace units.
      */
@@ -69,34 +78,39 @@ export declare class RenderedConnection extends Connection {
     /**
      * Move this connection to the location given by its offset within the block
      * and the location of the block's top left corner.
+     *
      * @param blockTL The location of the top left corner of the block, in
      *     workspace coordinates.
      */
     moveToOffset(blockTL: Coordinate): void;
     /**
      * Set the offset of this connection relative to the top left of its block.
+     *
      * @param x The new relative x, in workspace units.
      * @param y The new relative y, in workspace units.
      */
     setOffsetInBlock(x: number, y: number): void;
     /**
      * Get the offset of this connection relative to the top left of its block.
-     * @return The offset of the connection.
+     *
+     * @returns The offset of the connection.
      * @internal
      */
     getOffsetInBlock(): Coordinate;
     /**
      * Move the blocks on either side of this connection right next to each other.
+     *
      * @internal
      */
     tighten(): void;
     /**
      * Find the closest compatible connection to this connection.
      * All parameters are in workspace units.
+     *
      * @param maxLimit The maximum radius to another connection.
      * @param dxy Offset between this connection's location in the database and
      *     the current location (as a result of dragging).
-     * @return Contains two properties: 'connection' which is either another
+     * @returns Contains two properties: 'connection' which is either another
      *     connection or null, and 'radius' which is the distance.
      */
     closest(maxLimit: number, dxy: Coordinate): {
@@ -109,6 +123,7 @@ export declare class RenderedConnection extends Connection {
     unhighlight(): void;
     /**
      * Set whether this connections is tracked in the database or not.
+     *
      * @param doTracking If true, start tracking. If false, stop tracking.
      * @internal
      */
@@ -119,6 +134,7 @@ export declare class RenderedConnection extends Connection {
      * collapsed.
      *
      * Also closes down-stream icons/bubbles.
+     *
      * @internal
      */
     stopTrackingAll(): void;
@@ -126,13 +142,15 @@ export declare class RenderedConnection extends Connection {
      * Start tracking this connection, as well as all down-stream connections on
      * any block attached to this connection. This happens when a block is
      * expanded.
-     * @return List of blocks to render.
+     *
+     * @returns List of blocks to render.
      */
     startTrackingAll(): Block[];
     /**
      * Behavior after a connection attempt fails.
      * Bumps this connection away from the other connection. Called when an
      * attempted connection fails.
+     *
      * @param otherConnection Connection that this connection failed to connect
      *     to.
      * @internal
@@ -140,6 +158,7 @@ export declare class RenderedConnection extends Connection {
     onFailedConnect(otherConnection: Connection): void;
     /**
      * Disconnect two blocks that are connected by this connection.
+     *
      * @param parentBlock The superior block.
      * @param childBlock The inferior block.
      */
@@ -152,15 +171,17 @@ export declare class RenderedConnection extends Connection {
     /**
      * Find all nearby compatible connections to this connection.
      * Type checking does not apply, since this function is used for bumping.
+     *
      * @param maxLimit The maximum radius to another connection, in workspace
      *     units.
-     * @return List of connections.
+     * @returns List of connections.
      * @internal
      */
     neighbours(maxLimit: number): Connection[];
     /**
      * Connect two connections together.  This is the connection on the superior
      * block.  Rerender blocks as needed.
+     *
      * @param childConnection Connection on inferior block.
      */
     protected connect_(childConnection: Connection): void;
@@ -189,3 +210,4 @@ export declare namespace RenderedConnection {
 }
 export declare type TrackedState = RenderedConnection.TrackedState;
 export declare const TrackedState: typeof RenderedConnection.TrackedState;
+//# sourceMappingURL=rendered_connection.d.ts.map

package/core/renderers/common/block_rendering.d.ts

@@ -36,7 +36,8 @@ import { PathObject } from './path_object.js';
 import { Renderer } from './renderer.js';
 /**
  * Returns whether the debugger is turned on.
- * @return Whether the debugger is turned on.
+ *
+ * @returns Whether the debugger is turned on.
  * @alias Blockly.blockRendering.isDebuggerEnabled
  * @deprecated
  * @internal
@@ -44,6 +45,7 @@ import { Renderer } from './renderer.js';
 export declare function isDebuggerEnabled(): boolean;
 /**
  * Registers a new renderer.
+ *
  * @param name The name of the renderer.
  * @param rendererClass The new renderer class to register.
  * @throws {Error} if a renderer with the same name has already been registered.
@@ -51,12 +53,14 @@ export declare function isDebuggerEnabled(): boolean;
 export declare function register(name: string, rendererClass: Function): void;
 /**
  * Unregisters the renderer registered with the given name.
+ *
  * @param name The name of the renderer.
  * @alias Blockly.blockRendering.unregister
  */
 export declare function unregister(name: string): void;
 /**
  * Turn on the blocks debugger.
+ *
  * @alias Blockly.blockRendering.startDebugger
  * @deprecated
  * @internal
@@ -64,6 +68,7 @@ export declare function unregister(name: string): void;
 export declare function startDebugger(): void;
 /**
  * Turn off the blocks debugger.
+ *
  * @alias Blockly.blockRendering.stopDebugger
  * @deprecated
  * @internal
@@ -71,10 +76,11 @@ export declare function startDebugger(): void;
 export declare function stopDebugger(): void;
 /**
  * Initialize anything needed for rendering (constants, etc).
+ *
  * @param name Name of the renderer to initialize.
  * @param theme The workspace theme object.
  * @param opt_rendererOverrides Rendering constant overrides.
- * @return The new instance of a renderer.
+ * @returns The new instance of a renderer.
  *     Already initialized.
  * @alias Blockly.blockRendering.init
  * @internal
@@ -112,3 +118,4 @@ export { SquareCorner };
 export { StatementInput };
 export { TopRow };
 export { Types };
+//# sourceMappingURL=block_rendering.d.ts.map