blockly 11.2.0-beta.2 → 12.0.0-beta.0

package/core/interfaces/i_variable_map.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { IVariableModel, IVariableState } from './i_variable_model.js';
+/**
+ * Variable maps are container objects responsible for storing and managing the
+ * set of variables referenced on a workspace.
+ *
+ * Any of these methods may define invariants about which names and types are
+ * legal, and throw if they are not met.
+ */
+export interface IVariableMap<T extends IVariableModel<IVariableState>> {
+    getVariableById(id: string): T | null;
+    /**
+     * Returns the variable with the given name, or null if not found. If `type`
+     * is provided, the variable's type must also match, or null should be
+     * returned.
+     */
+    getVariable(name: string, type?: string): T | null;
+    getAllVariables(): T[];
+    /**
+     * Returns a list of all of the variables of the given type managed by this
+     * variable map.
+     */
+    getVariablesOfType(type: string): T[];
+    /**
+     * Returns a list of the set of types of the variables managed by this
+     * variable map.
+     */
+    getTypes(): string[];
+    /**
+     * Creates a new variable with the given name. If ID is not specified, the
+     * variable map should create one. Returns the new variable.
+     */
+    createVariable(name: string, id?: string, type?: string | null): T;
+    addVariable(variable: T): void;
+    /**
+     * Changes the name of the given variable to the name provided and returns the
+     * renamed variable.
+     */
+    renameVariable(variable: T, newName: string): T;
+    changeVariableType(variable: T, newType: string): T;
+    deleteVariable(variable: T): void;
+    clear(): void;
+}
+//# sourceMappingURL=i_variable_map.d.ts.map

package/core/interfaces/i_variable_model.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Workspace } from '../workspace.js';
+export interface IVariableModel<T extends IVariableState> {
+    getId(): string;
+    getName(): string;
+    /**
+     * Returns the type of the variable like 'int' or 'string'.  Does not need to be
+     * unique. This will default to '' which is a specific type.
+     */
+    getType(): string;
+    setName(name: string): this;
+    setType(type: string): this;
+    getWorkspace(): Workspace;
+    save(): T;
+}
+export interface IVariableModelStatic<T extends IVariableState> {
+    new (workspace: Workspace, name: string, type?: string, id?: string): IVariableModel<T>;
+    /**
+     * Creates a new IVariableModel corresponding to the given state on the
+     * specified workspace. This method must be static in your implementation.
+     */
+    load(state: T, workspace: Workspace): IVariableModel<T>;
+}
+/**
+ * Represents the state of a given variable.
+ */
+export interface IVariableState {
+    name: string;
+    id: string;
+    type?: string;
+}
+//# sourceMappingURL=i_variable_model.d.ts.map

package/core/label_flyout_inflater.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { IBoundedElement } from './interfaces/i_bounded_element.js';
+import type { IFlyoutInflater } from './interfaces/i_flyout_inflater.js';
+import type { WorkspaceSvg } from './workspace_svg.js';
+/**
+ * Class responsible for creating labels for flyouts.
+ */
+export declare class LabelFlyoutInflater implements IFlyoutInflater {
+    /**
+     * Inflates a flyout label from the given state and adds it to the flyout.
+     *
+     * @param state A JSON representation of a flyout label.
+     * @param flyoutWorkspace The workspace to create the label on.
+     * @returns A FlyoutButton configured as a label.
+     */
+    load(state: object, flyoutWorkspace: WorkspaceSvg): IBoundedElement;
+    /**
+     * Returns the amount of space that should follow this label.
+     *
+     * @param state A JSON representation of a flyout label.
+     * @param defaultGap The default spacing for flyout items.
+     * @returns The amount of space that should follow this label.
+     */
+    gapForElement(state: object, defaultGap: number): number;
+    /**
+     * Disposes of the given label.
+     *
+     * @param element The flyout label to dispose of.
+     */
+    disposeElement(element: IBoundedElement): void;
+}
+//# sourceMappingURL=label_flyout_inflater.d.ts.map

package/core/menuitem.d.ts

@@ -95,13 +95,6 @@ export declare class MenuItem {
      * @internal
      */
     setChecked(checked: boolean): void;
-    /**
-     * Highlights or unhighlights the component.
-     *
-     * @param highlight Whether to highlight or unhighlight the component.
-     * @internal
-     */
-    setHighlighted(highlight: boolean): void;
     /**
      * Returns true if the menu item is enabled, false otherwise.
      *

package/core/names.d.ts

@@ -3,7 +3,13 @@
  * Copyright 2012 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import type { VariableMap } from './variable_map.js';
+/**
+ * Utility functions for handling variable and procedure names.
+ *
+ * @class
+ */
+import type { IVariableMap } from './interfaces/i_variable_map.js';
+import type { IVariableModel, IVariableState } from './interfaces/i_variable_model.js';
 import type { Workspace } from './workspace.js';
 /**
  * Class for a database of entity names (variables, procedures, etc).
@@ -40,7 +46,7 @@ export declare class Names {
      *
      * @param map The map to track.
      */
-    setVariableMap(map: VariableMap): void;
+    setVariableMap(map: IVariableMap<IVariableModel<IVariableState>>): void;
     /**
      * Get the name for a user-defined variable, based on its ID.
      * This should only be used for variables of NameType VARIABLE.

package/core/registry.d.ts

@@ -11,11 +11,14 @@ import type { IConnectionPreviewer } from './interfaces/i_connection_previewer.j
 import type { ICopyable } from './interfaces/i_copyable.js';
 import type { IDragger } from './interfaces/i_dragger.js';
 import type { IFlyout } from './interfaces/i_flyout.js';
+import type { IFlyoutInflater } from './interfaces/i_flyout_inflater.js';
 import type { IIcon } from './interfaces/i_icon.js';
 import type { IMetricsManager } from './interfaces/i_metrics_manager.js';
 import type { IPaster } from './interfaces/i_paster.js';
 import type { ISerializer } from './interfaces/i_serializer.js';
 import type { IToolbox } from './interfaces/i_toolbox.js';
+import type { IVariableMap } from './interfaces/i_variable_map.js';
+import type { IVariableModel, IVariableModelStatic, IVariableState } from './interfaces/i_variable_model.js';
 import type { Cursor } from './keyboard_nav/cursor.js';
 import type { Options } from './options.js';
 import type { Renderer } from './renderers/common/renderer.js';
@@ -57,6 +60,7 @@ export declare class Type<_T> {
     static TOOLBOX_ITEM: Type<ToolboxItem>;
     static FLYOUTS_VERTICAL_TOOLBOX: Type<IFlyout>;
     static FLYOUTS_HORIZONTAL_TOOLBOX: Type<IFlyout>;
+    static FLYOUT_INFLATER: Type<IFlyoutInflater>;
     static METRICS_MANAGER: Type<IMetricsManager>;
     /**
      * Type for an IDragger. Formerly behavior was mostly covered by
@@ -69,6 +73,8 @@ export declare class Type<_T> {
     static ICON: Type<IIcon>;
     /** @internal */
     static PASTER: Type<IPaster<ICopyable.ICopyData, ICopyable<ICopyable.ICopyData>>>;
+    static VARIABLE_MODEL: Type<IVariableModelStatic<IVariableState>>;
+    static VARIABLE_MAP: Type<IVariableMap<IVariableModel<IVariableState>>>;
 }
 /**
  * Registers a class based on a type and name.

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

@@ -424,8 +424,13 @@ export declare class ConstantProvider {
      * @param svg The root of the workspace's SVG.
      * @param tagName The name to use for the CSS style tag.
      * @param selector The CSS selector to use.
+     * @param injectionDivIfIsParent The div containing the parent workspace and
+     *   all related workspaces and block containers, if this renderer is for the
+     *   parent workspace. CSS variables representing SVG patterns will be scoped
+     *   to this container. Child workspaces should not override the CSS variables
+     *   created by the parent and thus do not need access to the injection div.
      */
-    createDom(svg: SVGElement, tagName: string, selector: string): void;
+    createDom(svg: SVGElement, tagName: string, selector: string, injectionDivIfIsParent?: HTMLElement): void;
     /**
      * Create a filter for highlighting the currently rendering block during
      * render debugging.

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

@@ -39,19 +39,6 @@ export interface IPathObject {
      * @param pathString The path.
      */
     setPath(pathString: string): void;
-    /**
-     * Apply the stored colours to the block's path, taking into account whether
-     * the paths belong to a shadow block.
-     *
-     * @param block The source block.
-     */
-    applyColour(block: BlockSvg): void;
-    /**
-     * Update the style.
-     *
-     * @param blockStyle The block style to use.
-     */
-    setStyle(blockStyle: BlockStyle): void;
     /**
      * Flip the SVG paths in RTL.
      */
@@ -104,9 +91,22 @@ export interface IPathObject {
     updateMovable(enabled: boolean): void;
     /** Adds the given path as a connection highlight for the given connection. */
     addConnectionHighlight?(connection: RenderedConnection, connectionPath: string, offset: Coordinate, rtl: boolean): void;
+    /**
+     * Apply the stored colours to the block's path, taking into account whether
+     * the paths belong to a shadow block.
+     *
+     * @param block The source block.
+     */
+    applyColour?(block: BlockSvg): void;
     /**
      * Removes any highlight associated with the given connection, if it exists.
      */
     removeConnectionHighlight?(connection: RenderedConnection): void;
+    /**
+     * Update the style.
+     *
+     * @param blockStyle The block style to use.
+     */
+    setStyle?(blockStyle: BlockStyle): void;
 }
 //# sourceMappingURL=i_path_object.d.ts.map

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

@@ -5,10 +5,8 @@
  */
 import type { BlockSvg } from '../../block_svg.js';
 import { Connection } from '../../connection.js';
-import { PreviewType } from '../../insertion_marker_manager.js';
 import type { IRegistrable } from '../../interfaces/i_registrable.js';
 import type { Marker } from '../../keyboard_nav/marker.js';
-import type { RenderedConnection } from '../../rendered_connection.js';
 import type { BlockStyle, Theme } from '../../theme.js';
 import type { WorkspaceSvg } from '../../workspace_svg.js';
 import { ConstantProvider } from './constants.js';
@@ -53,16 +51,26 @@ export declare class Renderer implements IRegistrable {
      *
      * @param svg The root of the workspace's SVG.
      * @param theme The workspace theme object.
+     * @param injectionDivIfIsParent The div containing the parent workspace and
+     *   all related workspaces and block containers, if this renderer is for the
+     *   parent workspace. CSS variables representing SVG patterns will be scoped
+     *   to this container. Child workspaces should not override the CSS variables
+     *   created by the parent and thus do not need access to the injection div.
      * @internal
      */
-    createDom(svg: SVGElement, theme: Theme): void;
+    createDom(svg: SVGElement, theme: Theme, injectionDivIfIsParent?: HTMLElement): void;
     /**
      * Refresh the renderer after a theme change.
      *
      * @param svg The root of the workspace's SVG.
      * @param theme The workspace theme object.
+     * @param injectionDivIfIsParent The div containing the parent workspace and
+     *   all related workspaces and block containers, if this renderer is for the
+     *   parent workspace. CSS variables representing SVG patterns will be scoped
+     *   to this container. Child workspaces should not override the CSS variables
+     *   created by the parent and thus do not need access to the injection div.
      */
-    refreshDom(svg: SVGElement, theme: Theme): void;
+    refreshDom(svg: SVGElement, theme: Theme, injectionDivIfIsParent?: HTMLElement): void;
     /**
      * Dispose of this renderer.
      * Delete all DOM elements that this renderer and its constants created.
@@ -133,19 +141,6 @@ export declare class Renderer implements IRegistrable {
      * @returns Whether there is a home for the orphan or not.
      */
     protected orphanCanConnectAtEnd(topBlock: BlockSvg, orphanBlock: BlockSvg, localType: number): boolean;
-    /**
-     * Chooses a connection preview method based on the available connection, the
-     * current dragged connection, and the block being dragged.
-     *
-     * @param closest The available connection.
-     * @param local The connection currently being dragged.
-     * @param topBlock The block currently being dragged.
-     * @returns The preview type to display.
-     *
-     * @deprecated v10 - This function is no longer respected. A custom
-     *    IConnectionPreviewer may be able to fulfill the functionality.
-     */
-    getConnectionPreviewMethod(closest: RenderedConnection, local: RenderedConnection, topBlock: BlockSvg): PreviewType;
     /**
      * Render the block.
      *

package/core/renderers/geras/renderer.d.ts

@@ -34,7 +34,7 @@ export declare class Renderer extends BaseRenderer {
     init(theme: Theme, opt_rendererOverrides?: {
         [rendererConstant: string]: any;
     }): void;
-    refreshDom(svg: SVGElement, theme: Theme): void;
+    refreshDom(svg: SVGElement, theme: Theme, injectionDiv: HTMLElement): void;
     makeConstants_(): ConstantProvider;
     /**
      * Create a new instance of the renderer's render info object.

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

@@ -102,7 +102,13 @@ export declare class ConstantProvider extends BaseConstantProvider {
      * rectangular reporter block. Null before init is called.
      */
     SQUARED: Shape | null;
-    constructor();
+    /**
+     * Creates a new ConstantProvider.
+     *
+     * @param gridUnit If set, defines the base unit used to calculate other
+     *     constants.
+     */
+    constructor(gridUnit?: number);
     setFontConstants_(theme: Theme): void;
     init(): void;
     setDynamicProperties_(theme: Theme): void;
@@ -153,7 +159,7 @@ export declare class ConstantProvider extends BaseConstantProvider {
     };
     generateSecondaryColour_(colour: string): string;
     generateTertiaryColour_(colour: string): string;
-    createDom(svg: SVGElement, tagName: string, selector: string): void;
+    createDom(svg: SVGElement, tagName: string, selector: string, injectionDivIfIsParent?: HTMLElement): void;
     getCSS_(selector: string): string[];
 }
 //# sourceMappingURL=constants.d.ts.map

package/core/renderers/zelos/renderer.d.ts

@@ -4,9 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import type { BlockSvg } from '../../block_svg.js';
-import { InsertionMarkerManager } from '../../insertion_marker_manager.js';
 import type { Marker } from '../../keyboard_nav/marker.js';
-import type { RenderedConnection } from '../../rendered_connection.js';
 import type { BlockStyle } from '../../theme.js';
 import type { WorkspaceSvg } from '../../workspace_svg.js';
 import type { RenderInfo as BaseRenderInfo } from '../common/info.js';
@@ -73,10 +71,5 @@ export declare class Renderer extends BaseRenderer {
      * @returns The constant provider.
      */
     getConstants(): ConstantProvider;
-    /**
-     * @deprecated v10 - This function is no longer respected. A custom
-     *    IConnectionPreviewer may be able to fulfill the functionality.
-     */
-    getConnectionPreviewMethod(closest: RenderedConnection, local: RenderedConnection, topBlock: BlockSvg): InsertionMarkerManager.PREVIEW_TYPE;
 }
 //# sourceMappingURL=renderer.d.ts.map

package/core/separator_flyout_inflater.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { IBoundedElement } from './interfaces/i_bounded_element.js';
+import type { IFlyoutInflater } from './interfaces/i_flyout_inflater.js';
+import type { WorkspaceSvg } from './workspace_svg.js';
+/**
+ * Class responsible for creating separators for flyouts.
+ */
+export declare class SeparatorFlyoutInflater implements IFlyoutInflater {
+    /**
+     * Inflates a dummy flyout separator.
+     *
+     * The flyout automatically creates separators between every element with a
+     * size determined by calling gapForElement on the relevant inflater.
+     * Additionally, users can explicitly add separators in the flyout definition.
+     * When separators (implicitly or explicitly created) follow one another, the
+     * gap of the last one propagates backwards and flattens to one separator.
+     * This flattening is not additive; if there are initially separators of 2, 3,
+     * and 4 pixels, after normalization there will be one separator of 4 pixels.
+     * Therefore, this method returns a zero-width separator, which will be
+     * replaced by the one implicitly created by the flyout based on the value
+     * returned by gapForElement, which knows the default gap, unlike this method.
+     *
+     * @param _state A JSON representation of a flyout separator.
+     * @param flyoutWorkspace The workspace the separator belongs to.
+     * @returns A newly created FlyoutSeparator.
+     */
+    load(_state: object, flyoutWorkspace: WorkspaceSvg): IBoundedElement;
+    /**
+     * Returns the size of the separator. See `load` for more details.
+     *
+     * @param state A JSON representation of a flyout separator.
+     * @param defaultGap The default spacing for flyout items.
+     * @returns The desired size of the separator.
+     */
+    gapForElement(state: object, defaultGap: number): number;
+    /**
+     * Disposes of the given separator. Intentional no-op.
+     *
+     * @param _element The flyout separator to dispose of.
+     */
+    disposeElement(_element: IBoundedElement): void;
+}
+//# sourceMappingURL=separator_flyout_inflater.d.ts.map

package/core/serialization/variables.d.ts

@@ -4,15 +4,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import type { ISerializer } from '../interfaces/i_serializer.js';
+import type { IVariableState } from '../interfaces/i_variable_model.js';
 import type { Workspace } from '../workspace.js';
-/**
- * Represents the state of a given variable.
- */
-export interface State {
-    name: string;
-    id: string;
-    type: string | undefined;
-}
 /**
  * Serializer for saving and loading variable state.
  */
@@ -26,7 +19,7 @@ export declare class VariableSerializer implements ISerializer {
      * @returns The state of the workspace's variables, or null if there are no
      *     variables.
      */
-    save(workspace: Workspace): State[] | null;
+    save(workspace: Workspace): IVariableState[] | null;
     /**
      * Deserializes the variable defined by the given state into the given
      * workspace.
@@ -34,7 +27,7 @@ export declare class VariableSerializer implements ISerializer {
      * @param state The state of the variables to deserialize.
      * @param workspace The workspace to deserialize into.
      */
-    load(state: State[], workspace: Workspace): void;
+    load(state: IVariableState[], workspace: Workspace): void;
     /**
      * Disposes of any variables that exist on the workspace.
      *

package/core/toolbox/toolbox.d.ts

@@ -36,8 +36,6 @@ export declare class Toolbox extends DeleteArea implements IAutoHideable, IKeybo
     protected contentsDiv_: HTMLDivElement | null;
     /** Whether the Toolbox is visible. */
     protected isVisible_: boolean;
-    /** The list of items in the toolbox. */
-    protected contents_: IToolboxItem[];
     /** The width of the toolbox. */
     protected width_: number;
     /** The height of the toolbox. */
@@ -45,9 +43,8 @@ export declare class Toolbox extends DeleteArea implements IAutoHideable, IKeybo
     RTL: boolean;
     /** The flyout for the toolbox. */
     private flyout;
-    protected contentMap_: {
-        [key: string]: IToolboxItem;
-    };
+    /** Map from ID to the corresponding toolbox item. */
+    protected contents: Map<string, IToolboxItem>;
     toolboxPosition: toolbox.Position;
     /** The currently selected item. */
     protected selectedItem_: ISelectableToolboxItem | null;

package/core/variable_map.d.ts

@@ -11,17 +11,18 @@
 import './events/events_var_delete.js';
 import './events/events_var_rename.js';
 import type { Block } from './block.js';
-import { VariableModel } from './variable_model.js';
+import type { IVariableMap } from './interfaces/i_variable_map.js';
+import { IVariableModel, IVariableState } from './interfaces/i_variable_model.js';
 import type { Workspace } from './workspace.js';
 /**
  * Class for a variable map.  This contains a dictionary data structure with
  * variable types as keys and lists of variables as values.  The list of
  * variables are the type indicated by the key.
  */
-export declare class VariableMap {
+export declare class VariableMap implements IVariableMap<IVariableModel<IVariableState>> {
     workspace: Workspace;
     /**
-     * A map from variable type to list of variable names.  The lists contain
+     * A map from variable type to map of IDs to variables. The maps contain
      * all of the named variables in the workspace, including variables that are
      * not currently in use.
      */
@@ -35,13 +36,15 @@ export declare class VariableMap {
      *
      * @param variable Variable to rename.
      * @param newName New variable name.
-     * @internal
+     * @returns The newly renamed variable.
      */
-    renameVariable(variable: VariableModel, newName: string): void;
+    renameVariable(variable: IVariableModel<IVariableState>, newName: string): IVariableModel<IVariableState>;
+    changeVariableType(variable: IVariableModel<IVariableState>, newType: string): IVariableModel<IVariableState>;
     /**
      * Rename a variable by updating its name in the variable map. Identify the
      * variable to rename with the given ID.
      *
+     * @deprecated v12, use VariableMap.renameVariable.
      * @param id ID of the variable to rename.
      * @param newName New variable name.
      */
@@ -78,29 +81,27 @@ export declare class VariableMap {
      * @param opt_id The unique ID of the variable. This will default to a UUID.
      * @returns The newly created variable.
      */
-    createVariable(name: string, opt_type?: string | null, opt_id?: string | null): VariableModel;
+    createVariable(name: string, opt_type?: string, opt_id?: string): IVariableModel<IVariableState>;
     /**
-     * Delete a variable.
+     * Adds the given variable to this variable map.
+     *
+     * @param variable The variable to add.
+     */
+    addVariable(variable: IVariableModel<IVariableState>): void;
+    /**
+     * Delete a variable and all of its uses without confirmation.
      *
      * @param variable Variable to delete.
      */
-    deleteVariable(variable: VariableModel): void;
+    deleteVariable(variable: IVariableModel<IVariableState>): void;
     /**
      * Delete a variables by the passed in ID and all of its uses from this
      * workspace. May prompt the user for confirmation.
      *
+     * @deprecated v12, use Blockly.Variables.deleteVariable.
      * @param id ID of variable to delete.
      */
     deleteVariableById(id: string): void;
-    /**
-     * Deletes a variable and all of its uses from this workspace without asking
-     * the user for confirmation.
-     *
-     * @param variable Variable to delete.
-     * @param uses An array of uses of the variable.
-     * @internal
-     */
-    deleteVariableInternal(variable: VariableModel, uses: Block[]): void;
     /**
      * Find the variable by the given name and type and return it.  Return null if
      *     it is not found.
@@ -110,14 +111,14 @@ export declare class VariableMap {
      *     the empty string, which is a specific type.
      * @returns The variable with the given name, or null if it was not found.
      */
-    getVariable(name: string, opt_type?: string | null): VariableModel | null;
+    getVariable(name: string, opt_type?: string): IVariableModel<IVariableState> | null;
     /**
      * Find the variable by the given ID and return it.  Return null if not found.
      *
      * @param id The ID to check for.
      * @returns The variable with the given ID.
      */
-    getVariableById(id: string): VariableModel | null;
+    getVariableById(id: string): IVariableModel<IVariableState> | null;
     /**
      * Get a list containing all of the variables of a specified type. If type is
      *     null, return list of variables with empty string type.
@@ -126,33 +127,30 @@ export declare class VariableMap {
      * @returns The sought after variables of the passed in type. An empty array
      *     if none are found.
      */
-    getVariablesOfType(type: string | null): VariableModel[];
+    getVariablesOfType(type: string | null): IVariableModel<IVariableState>[];
     /**
-     * Return all variable and potential variable types.  This list always
-     * contains the empty string.
+     * Returns a list of unique types of variables in this variable map.
      *
-     * @param ws The workspace used to look for potential variables. This can be
-     *     different than the workspace stored on this object if the passed in ws
-     *     is a flyout workspace.
-     * @returns List of variable types.
-     * @internal
+     * @returns A list of unique types of variables in this variable map.
      */
-    getVariableTypes(ws: Workspace | null): string[];
+    getTypes(): string[];
     /**
      * Return all variables of all types.
      *
      * @returns List of variable models.
      */
-    getAllVariables(): VariableModel[];
+    getAllVariables(): IVariableModel<IVariableState>[];
     /**
      * Returns all of the variable names of all types.
      *
+     * @deprecated v12, use Blockly.Variables.getAllVariables.
      * @returns All of the variable names of all types.
      */
     getAllVariableNames(): string[];
     /**
      * Find all the uses of a named variable.
      *
+     * @deprecated v12, use Blockly.Variables.getVariableUsesById.
      * @param id ID of the variable to find.
      * @returns Array of block usages.
      */