blockly 9.0.0 → 9.1.0-beta.0

package/core/interfaces/i_parameter_model.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * The interface for the data model of a procedure parameter.
+ *
+ * @namespace Blockly.IParameterModel
+ */
+/**
+ * A data model for a procedure.
+ */
+export interface IParameterModel {
+    /**
+     * Sets the name of this parameter to the given name.
+     */
+    setName(name: string): this;
+    /**
+     * Sets the types of this parameter to the given type.
+     */
+    setTypes(types: string[]): this;
+    /**
+     * Returns the name of this parameter.
+     */
+    getName(): string;
+    /**
+     * Return the types of this parameter.
+     */
+    getTypes(): string[];
+    /**
+     * Returns the unique language-neutral ID for the parameter.
+     *
+     * This represents the identify of the variable model which does not change
+     * over time.
+     */
+    getId(): string;
+}
+//# sourceMappingURL=i_parameter_model.d.ts.map

package/core/interfaces/i_procedure_block.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Block } from '../block.js';
+/** The interface for a block which models a procedure. */
+export interface IProcedureBlock {
+    doProcedureUpdate(): void;
+}
+/** A type guard which checks if the given block is a procedure block. */
+export declare function isProcedureBlock(block: Block | IProcedureBlock): block is IProcedureBlock;
+//# sourceMappingURL=i_procedure_block.d.ts.map

package/core/interfaces/i_procedure_map.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { IProcedureModel } from './i_procedure_model.js';
+export interface IProcedureMap extends Map<string, IProcedureModel> {
+    /**
+     * Adds the given ProcedureModel to the map of procedure models, so that
+     * blocks can find it.
+     */
+    add(proc: IProcedureModel): this;
+    /** Returns all of the procedures stored in this map. */
+    getProcedures(): IProcedureModel[];
+}
+//# sourceMappingURL=i_procedure_map.d.ts.map

package/core/interfaces/i_procedure_model.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * The interface for the data model of a procedure.
+ *
+ * @namespace Blockly.IProcedureModel
+ */
+import { IParameterModel } from './i_parameter_model.js';
+/**
+ * A data model for a procedure.
+ */
+export interface IProcedureModel {
+    /** Sets the human-readable name of the procedure. */
+    setName(name: string): this;
+    /**
+     * Inserts a parameter into the list of parameters.
+     *
+     * To move a parameter, first delete it, and then re-insert.
+     */
+    insertParameter(parameterModel: IParameterModel, index: number): this;
+    /** Removes the parameter at the given index from the parameter list. */
+    deleteParameter(index: number): this;
+    /**
+     * Sets the return type(s) of the procedure.
+     *
+     * Pass null to represent a procedure that does not return.
+     */
+    setReturnTypes(types: string[] | null): this;
+    /**
+     * Sets whether this procedure is enabled/disabled. If a procedure is disabled
+     * all procedure caller blocks should be disabled as well.
+     */
+    setEnabled(enabled: boolean): this;
+    /** Returns the unique language-neutral ID for the procedure. */
+    getId(): string;
+    /** Returns the human-readable name of the procedure. */
+    getName(): string;
+    /** Returns the parameter at the given index in the parameter list. */
+    getParameter(index: number): IParameterModel;
+    /** Returns an array of all of the parameters in the parameter list. */
+    getParameters(): IParameterModel[];
+    /**
+     * Returns the return type(s) of the procedure.
+     *
+     * Null represents a procedure that does not return a value.
+     */
+    getReturnTypes(): string[] | null;
+    /**
+     * Returns whether the procedure is enabled/disabled. If a procedure is
+     * disabled, all procedure caller blocks should be disabled as well.
+     */
+    getEnabled(): boolean;
+}
+//# sourceMappingURL=i_procedure_model.d.ts.map

package/core/menu.d.ts

@@ -18,7 +18,7 @@ export declare class Menu {
      * (Nulls are never in the array, but typing the array as nullable prevents
      * the compiler from objecting to .indexOf(null))
      */
-    private readonly menuItems_;
+    private readonly menuItems;
     /**
      * Coordinates of the mousedown event that caused this menu to open. Used to
      * prevent the consequent mouseup event due to a simple click from
@@ -29,21 +29,21 @@ export declare class Menu {
      * This is the element that we will listen to the real focus events on.
      * A value of null means no menu item is highlighted.
      */
-    private highlightedItem_;
+    private highlightedItem;
     /** Mouse over event data. */
-    private mouseOverHandler_;
+    private mouseOverHandler;
     /** Click event data. */
-    private clickHandler_;
+    private clickHandler;
     /** Mouse enter event data. */
-    private mouseEnterHandler_;
+    private mouseEnterHandler;
     /** Mouse leave event data. */
-    private mouseLeaveHandler_;
+    private mouseLeaveHandler;
     /** Key down event data. */
-    private onKeyDownHandler_;
+    private onKeyDownHandler;
     /** The menu's root DOM element. */
-    private element_;
+    private element;
     /** ARIA name for this menu. */
-    private roleName_;
+    private roleName;
     /** Constructs a new Menu instance. */
     constructor();
     /**
@@ -74,7 +74,7 @@ export declare class Menu {
      */
     focus(): void;
     /** Blur the menu element. */
-    private blur_;
+    private blur;
     /**
      * Set the menu accessibility role.
      *
@@ -91,7 +91,7 @@ export declare class Menu {
      * @param elem DOM element whose owner is to be returned.
      * @returns Menu item for which the DOM element belongs to.
      */
-    private getMenuItem_;
+    private getMenuItem;
     /**
      * Highlights the given menu item, or clears highlighting if null.
      *
@@ -114,9 +114,9 @@ export declare class Menu {
      */
     highlightPrevious(): void;
     /** Highlights the first highlightable item. */
-    private highlightFirst_;
+    private highlightFirst;
     /** Highlights the last highlightable item. */
-    private highlightLast_;
+    private highlightLast;
     /**
      * Helper function that manages the details of moving the highlight among
      * child menuitems in response to keyboard events.
@@ -124,31 +124,31 @@ export declare class Menu {
      * @param startIndex Start index.
      * @param delta Step direction: 1 to go down, -1 to go up.
      */
-    private highlightHelper_;
+    private highlightHelper;
     /**
      * Handles mouseover events. Highlight menuitems as the user hovers over them.
      *
      * @param e Mouse event to handle.
      */
-    private handleMouseOver_;
+    private handleMouseOver;
     /**
      * Handles click events. Pass the event onto the child menuitem to handle.
      *
      * @param e Click event to handle.
      */
-    private handleClick_;
+    private handleClick;
     /**
      * Handles mouse enter events. Focus the element.
      *
      * @param _e Mouse event to handle.
      */
-    private handleMouseEnter_;
+    private handleMouseEnter;
     /**
      * Handles mouse leave events. Blur and clear highlight.
      *
      * @param _e Mouse event to handle.
      */
-    private handleMouseLeave_;
+    private handleMouseLeave;
     /**
      * Attempts to handle a keyboard event, if the menu item is enabled, by
      * calling
@@ -156,7 +156,7 @@ export declare class Menu {
      *
      * @param e Key event to handle.
      */
-    private handleKeyEvent_;
+    private handleKeyEvent;
     /**
      * Get the size of a rendered menu.
      *

package/core/menuitem.d.ts

@@ -13,21 +13,21 @@ export declare class MenuItem {
     private readonly content;
     private readonly opt_value?;
     /** Is the menu item clickable, as opposed to greyed-out. */
-    private enabled_;
+    private enabled;
     /** The DOM element for the menu item. */
-    private element_;
+    private element;
     /** Whether the menu item is rendered right-to-left. */
-    private rightToLeft_;
+    private rightToLeft;
     /** ARIA name for this menu. */
-    private roleName_;
+    private roleName;
     /** Is this menu item checkable. */
-    private checkable_;
+    private checkable;
     /** Is this menu item currently checked. */
-    private checked_;
+    private checked;
     /** Is this menu item currently highlighted. */
-    private highlight_;
+    private highlight;
     /** Bound function to call when this menu item is clicked. */
-    private actionHandler_;
+    private actionHandler;
     /**
      * @param content Text caption to display as the content of the item, or a
      *     HTML element to display.

package/core/mutator.d.ts

@@ -17,33 +17,33 @@ import type { WorkspaceSvg } from './workspace_svg.js';
  * @alias Blockly.Mutator
  */
 export declare class Mutator extends Icon {
-    private quarkNames_;
+    private quarkNames;
     /** Workspace in the mutator's bubble. */
-    private workspace_;
+    private workspace;
     /** Width of workspace. */
-    private workspaceWidth_;
+    private workspaceWidth;
     /** Height of workspace. */
-    private workspaceHeight_;
+    private workspaceHeight;
     /**
      * The SVG element that is the parent of the mutator workspace, or null if
      * not created.
      */
-    private svgDialog_;
+    private svgDialog;
     /**
      * The root block of the mutator workspace, created by decomposing the
      * source block.
      */
-    private rootBlock_;
+    private rootBlock;
     /**
      * Function registered on the main workspace to update the mutator contents
      * when the main workspace changes.
      */
-    private sourceListener_;
+    private sourceListener;
     /**
      * The PID associated with the updateWorkpace_ timeout, or null if no timeout
      * is currently running.
      */
-    private updateWorkspacePid_;
+    private updateWorkspacePid;
     /** @param quarkNames List of names of sub-blocks for flyout. */
     constructor(quarkNames: string[], block?: BlockSvg);
     /**
@@ -79,7 +79,7 @@ export declare class Mutator extends Icon {
      *
      * @returns The top-level node of the editor.
      */
-    private createEditor_;
+    private createEditor;
     /**
      * @internal
      */
@@ -87,9 +87,9 @@ export declare class Mutator extends Icon {
     /** Add or remove the UI indicating if this icon may be clicked or not. */
     updateEditable(): void;
     /** Resize the bubble to match the size of the workspace. */
-    private resizeBubble_;
+    private resizeBubble;
     /** A method handler for when the bubble is moved. */
-    private onBubbleMove_;
+    private onBubbleMove;
     /**
      * Show or hide the mutator bubble.
      *
@@ -101,7 +101,7 @@ export declare class Mutator extends Icon {
      *
      * @param e Custom data for event.
      */
-    private workspaceChanged_;
+    private workspaceChanged;
     /**
      * Returns whether the given event in the mutator workspace should be ignored
      * when deciding whether to update the workspace and compose the block or not.
@@ -114,7 +114,7 @@ export declare class Mutator extends Icon {
      * Updates the source block when the mutator's blocks are changed.
      * Bump down any block that's too high.
      */
-    private updateWorkspace_;
+    private updateWorkspace;
     /** Dispose of this mutator. */
     dispose(): void;
     /** Update the styles on all blocks in the mutator. */

package/core/procedures/observable_parameter_model.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { IParameterModel } from '../interfaces/i_parameter_model.js';
+import type { VariableModel } from '../variable_model.js';
+import type { Workspace } from '../workspace.js';
+export declare class ObservableParameterModel implements IParameterModel {
+    private readonly workspace;
+    private id;
+    private variable;
+    constructor(workspace: Workspace, name: string, id?: string);
+    /**
+     * Sets the name of this parameter to the given name.
+     */
+    setName(name: string): this;
+    /**
+     * Unimplemented. The built-in ParameterModel does not support typing.
+     * If you want your procedure blocks to have typed parameters, you need to
+     * implement your own ParameterModel.
+     *
+     * @throws Throws for the ObservableParameterModel specifically because this
+     *     method is unimplemented.
+     */
+    setTypes(_types: string[]): this;
+    /**
+     * Returns the name of this parameter.
+     */
+    getName(): string;
+    /**
+     * Returns the types of this parameter.
+     */
+    getTypes(): string[];
+    /**
+     * Returns the unique language-neutral ID for the parameter.
+     *
+     * This represents the identify of the variable model which does not change
+     * over time.
+     */
+    getId(): string;
+    /** Returns the variable model associated with the parameter model. */
+    getVariableModel(): VariableModel;
+}
+//# sourceMappingURL=observable_parameter_model.d.ts.map

package/core/procedures/observable_procedure_map.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { IProcedureModel } from '../interfaces/i_procedure_model.js';
+import type { Workspace } from '../workspace.js';
+import { IProcedureMap } from '../interfaces/i_procedure_map.js';
+export declare class ObservableProcedureMap extends Map<string, IProcedureModel> implements IProcedureMap {
+    private readonly workspace;
+    constructor(workspace: Workspace);
+    /**
+     * Adds the given procedure model to the procedure map.
+     */
+    set(id: string, proc: IProcedureModel): this;
+    /**
+     * Deletes the ProcedureModel with the given ID from the procedure map (if it
+     * exists).
+     */
+    delete(id: string): boolean;
+    /**
+     * Removes all ProcedureModels from the procedure map.
+     */
+    clear(): void;
+    /**
+     * Adds the given ProcedureModel to the map of procedure models, so that
+     * blocks can find it.
+     */
+    add(proc: IProcedureModel): this;
+    /**
+     * Returns all of the procedures stored in this map.
+     */
+    getProcedures(): IProcedureModel[];
+}
+//# sourceMappingURL=observable_procedure_map.d.ts.map

package/core/procedures/observable_procedure_model.d.ts

@@ -0,0 +1,62 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { IParameterModel } from '../interfaces/i_parameter_model.js';
+import type { IProcedureModel } from '../interfaces/i_procedure_model.js';
+import type { Workspace } from '../workspace.js';
+export declare class ObservableProcedureModel implements IProcedureModel {
+    private readonly workspace;
+    private id;
+    private name;
+    private parameters;
+    private returnTypes;
+    private enabled;
+    constructor(workspace: Workspace, name: string, id?: string);
+    /** Sets the human-readable name of the procedure. */
+    setName(name: string): this;
+    /**
+     * Inserts a parameter into the list of parameters.
+     *
+     * To move a parameter, first delete it, and then re-insert.
+     */
+    insertParameter(parameterModel: IParameterModel, index: number): this;
+    /** Removes the parameter at the given index from the parameter list. */
+    deleteParameter(index: number): this;
+    /**
+     * Sets whether the procedure has a return value (empty array) or no return
+     * value (null).
+     *
+     * The built-in procedure model does not support procedures that have actual
+     * return types (i.e. non-empty arrays, e.g. ['number']). If you want your
+     * procedure block to have return types, you need to implement your own
+     * procedure model.
+     */
+    setReturnTypes(types: string[] | null): this;
+    /**
+     * Sets whether this procedure is enabled/disabled. If a procedure is disabled
+     * all procedure caller blocks should be disabled as well.
+     */
+    setEnabled(enabled: boolean): this;
+    /** Returns the unique language-neutral ID for the procedure. */
+    getId(): string;
+    /** Returns the human-readable name of the procedure. */
+    getName(): string;
+    /** Returns the parameter at the given index in the parameter list. */
+    getParameter(index: number): IParameterModel;
+    /** Returns an array of all of the parameters in the parameter list. */
+    getParameters(): IParameterModel[];
+    /**
+     * Returns the return type of the procedure.
+     *
+     * Null represents a procedure that does not return a value.
+     */
+    getReturnTypes(): string[] | null;
+    /**
+     * Returns whether the procedure is enabled/disabled. If a procedure is
+     * disabled, all procedure caller blocks should be disabled as well.
+     */
+    getEnabled(): boolean;
+}
+//# sourceMappingURL=observable_procedure_model.d.ts.map

package/core/procedures/update_procedures.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Workspace } from '../workspace.js';
+/**
+ * Calls the `doProcedureUpdate` method on all blocks which implement it.
+ *
+ * @internal
+ */
+export declare function triggerProceduresUpdate(workspace: Workspace): void;
+//# sourceMappingURL=update_procedures.d.ts.map

package/core/procedures.d.ts

@@ -6,7 +6,10 @@
 import './events/events_block_change.js';
 import type { Block } from './block.js';
 import type { Abstract } from './events/events_abstract.js';
-import type { Field } from './field.js';
+import { Field } from './field.js';
+import { ObservableProcedureMap } from './procedures/observable_procedure_map.js';
+import { ObservableProcedureModel } from './procedures/observable_procedure_model.js';
+import { ObservableParameterModel } from './procedures/observable_parameter_model.js';
 import type { Workspace } from './workspace.js';
 import type { WorkspaceSvg } from './workspace_svg.js';
 /**
@@ -122,4 +125,5 @@ export declare function mutateCallers(defBlock: Block): void;
  * @alias Blockly.Procedures.getDefinition
  */
 export declare function getDefinition(name: string, workspace: Workspace): Block | null;
+export { ObservableProcedureMap, ObservableProcedureModel, ObservableParameterModel, };
 //# sourceMappingURL=procedures.d.ts.map

package/core/rendered_connection.d.ts

@@ -177,7 +177,7 @@ export declare class RenderedConnection extends Connection {
      * @returns List of connections.
      * @internal
      */
-    neighbours(maxLimit: number): Connection[];
+    neighbours(maxLimit: number): RenderedConnection[];
     /**
      * Connect two connections together.  This is the connection on the superior
      * block.  Rerender blocks as needed.

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

@@ -393,12 +393,7 @@ export declare class ConstantProvider {
      * @param blockStyle A full or partial block style object.
      * @returns A full block style object, with all required properties populated.
      */
-    protected validatedBlockStyle_(blockStyle: {
-        colourPrimary: string;
-        colourSecondary?: string;
-        colourTertiary?: string;
-        hat?: string;
-    }): BlockStyle;
+    protected validatedBlockStyle_(blockStyle: Partial<BlockStyle>): BlockStyle;
     /**
      * Generate a secondary colour from the passed in primary colour.
      *