blockly 9.0.0-beta.0 → 9.0.0-beta.1

package/core/toolbox/category.d.ts

@@ -10,6 +10,7 @@ import * as toolbox from '../utils/toolbox.js';
 import { ToolboxItem } from './toolbox_item.js';
 /**
  * Class for a category in a toolbox.
+ *
  * @alias Blockly.ToolboxCategory
  */
 export declare class ToolboxCategory extends ToolboxItem implements ISelectableToolboxItem {
@@ -64,73 +65,85 @@ export declare class ToolboxCategory extends ToolboxItem implements ISelectableT
     init(): void;
     /**
      * Creates an object holding the default classes for a category.
-     * @return The configuration object holding all the CSS classes for a
+     *
+     * @returns The configuration object holding all the CSS classes for a
      *     category.
      */
     protected makeDefaultCssConfig_(): CssConfig;
     /**
      * Parses the contents array depending on if the category is a dynamic
      * category, or if its contents are meant to be shown in the flyout.
+     *
      * @param categoryDef The information needed to create a category.
      */
     protected parseContents_(categoryDef: toolbox.CategoryInfo): void;
     /**
      * Parses the non-contents parts of the category def.
+     *
      * @param categoryDef The information needed to create a category.
      */
     protected parseCategoryDef_(categoryDef: toolbox.CategoryInfo): void;
     /**
      * Creates the DOM for the category.
-     * @return The parent element for the category.
+     *
+     * @returns The parent element for the category.
      */
     protected createDom_(): HTMLDivElement;
     /**
      * Creates the container that holds the row and any subcategories.
-     * @return The div that holds the icon and the label.
+     *
+     * @returns The div that holds the icon and the label.
      */
     protected createContainer_(): HTMLDivElement;
     /**
      * Creates the parent of the contents container. All clicks will happen on
      * this div.
-     * @return The div that holds the contents container.
+     *
+     * @returns The div that holds the contents container.
      */
     protected createRowContainer_(): HTMLDivElement;
     /**
      * Creates the container for the label and icon.
      * This is necessary so we can set all subcategory pointer events to none.
-     * @return The div that holds the icon and the label.
+     *
+     * @returns The div that holds the icon and the label.
      */
     protected createRowContentsContainer_(): HTMLDivElement;
     /**
      * Creates the span that holds the category icon.
-     * @return The span that holds the category icon.
+     *
+     * @returns The span that holds the category icon.
      */
     protected createIconDom_(): Element;
     /**
      * Creates the span that holds the category label.
      * This should have an ID for accessibility purposes.
+     *
      * @param name The name of the category.
-     * @return The span that holds the category label.
+     * @returns The span that holds the category label.
      */
     protected createLabelDom_(name: string): Element;
     /** Updates the colour for this category. */
     refreshTheme(): void;
     /**
      * Add the strip of colour to the toolbox category.
+     *
      * @param colour The category colour.
      */
     protected addColourBorder_(colour: string): void;
     /**
      * Gets either the colour or the style for a category.
+     *
      * @param categoryDef The object holding information on the category.
-     * @return The hex colour for the category.
+     * @returns The hex colour for the category.
      */
     protected getColour_(categoryDef: toolbox.CategoryInfo): string;
     /**
      * Sets the colour for the category using the style name and returns the new
      * colour as a hex string.
+     *
      * @param styleName Name of the style.
-     * @return The hex colour for the category.
+     * @returns The hex colour for the category.
      */
     private getColourfromStyle_;
     /**
@@ -138,29 +151,34 @@ export declare class ToolboxCategory extends ToolboxItem implements ISelectableT
      * 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 The HTML element that receives clicks.
+     *
+     * @returns The HTML element that receives clicks.
      */
     getClickTarget(): Element;
     /**
      * Parses the colour on the category.
+     *
      * @param colourValue HSV hue value (0 to 360), #RRGGBB string, or a message
      *     reference string pointing to one of those two values.
-     * @return The hex colour for the category.
+     * @returns The hex colour for the category.
      */
     private parseColour_;
     /**
      * Adds appropriate classes to display an open icon.
+     *
      * @param iconDiv The div that holds the icon.
      */
     protected openIcon_(iconDiv: Element | null): void;
     /**
      * Adds appropriate classes to display a closed icon.
+     *
      * @param iconDiv The div that holds the icon.
      */
     protected closeIcon_(iconDiv: Element | null): void;
     /**
      * Sets whether the category is visible or not.
      * For a category to be visible its parent category must also be expanded.
+     *
      * @param isVisible True if category should be visible.
      */
     setVisible_(isVisible: boolean): void;
@@ -175,34 +193,40 @@ export declare class ToolboxCategory extends ToolboxItem implements ISelectableT
      * Whether the category is visible.
      * A category is only visible if all of its ancestors are expanded and
      * isHidden_ is false.
-     * @return True if the category is visible, false otherwise.
+     *
+     * @returns True if the category is visible, false otherwise.
      */
     isVisible(): boolean;
     /**
      * Whether all ancestors of a category (parent and parent's parent, etc.) are
      * expanded.
-     * @return True only if every ancestor is expanded
+     *
+     * @returns True only if every ancestor is expanded
      */
     protected allAncestorsExpanded_(): boolean;
     isSelectable(): boolean;
     /**
      * Handles when the toolbox item is clicked.
+     *
      * @param _e Click event to handle.
      */
     onClick(_e: Event): void;
     /**
      * Sets the current category as selected.
+     *
      * @param isSelected True if this category is selected, false otherwise.
      */
     setSelected(isSelected: boolean): void;
     /**
      * Sets whether the category is disabled.
+     *
      * @param isDisabled True to disable the category, false otherwise.
      */
     setDisabled(isDisabled: boolean): void;
     /**
      * Gets the name of the category. Used for emitting events.
-     * @return The name of the toolbox item.
+     *
+     * @returns The name of the toolbox item.
      */
     getName(): string;
     getParent(): ICollapsibleToolboxItem | null;
@@ -210,13 +234,15 @@ export declare class ToolboxCategory extends ToolboxItem implements ISelectableT
     /**
      * Gets the contents of the category. These are items that are meant to be
      * displayed in the flyout.
-     * @return The definition of items to be displayed in the flyout.
+     *
+     * @returns The definition of items to be displayed in the flyout.
      */
     getContents(): toolbox.FlyoutItemInfoArray | string;
     /**
      * Updates the contents to be displayed in the flyout.
      * If the flyout is open when the contents are updated, refreshSelection on
      * the toolbox must also be called.
+     *
      * @param contents The contents to be displayed in the flyout. A string can be
      *     supplied to create a dynamic category.
      */
@@ -237,3 +263,4 @@ export declare namespace ToolboxCategory {
     }
 }
 export declare type CssConfig = ToolboxCategory.CssConfig;
+//# sourceMappingURL=category.d.ts.map

package/core/toolbox/collapsible_category.d.ts

@@ -10,6 +10,7 @@ import * as toolbox from '../utils/toolbox.js';
 import { ToolboxCategory } from './category.js';
 /**
  * Class for a category in a toolbox that can be collapsed.
+ *
  * @alias Blockly.CollapsibleToolboxCategory
  */
 export declare class CollapsibleToolboxCategory extends ToolboxCategory implements ICollapsibleToolboxItem {
@@ -35,6 +36,7 @@ export declare class CollapsibleToolboxCategory extends ToolboxCategory implemen
     parseContents_(categoryDef: toolbox.CategoryInfo): void;
     /**
      * Creates a toolbox item and adds it to the list of toolbox items.
+     *
      * @param itemDef The information needed to create a toolbox item.
      */
     private createToolboxItem_;
@@ -43,19 +45,22 @@ export declare class CollapsibleToolboxCategory extends ToolboxCategory implemen
     createIconDom_(): HTMLSpanElement;
     /**
      * Create the DOM for all subcategories.
+     *
      * @param subcategories The subcategories.
-     * @return The div holding all the subcategories.
+     * @returns The div holding all the subcategories.
      */
     protected createSubCategoriesDom_(subcategories: IToolboxItem[]): HTMLDivElement;
     /**
      * Opens or closes the current category.
+     *
      * @param isExpanded True to expand the category, false to close.
      */
     setExpanded(isExpanded: boolean): void;
     setVisible_(isVisible: boolean): void;
     /**
      * Whether the category is expanded to show its child subcategories.
-     * @return True if the toolbox item shows its children, false if it is
+     *
+     * @returns True if the toolbox item shows its children, false if it is
      *     collapsed.
      */
     isExpanded(): boolean;
@@ -66,7 +71,8 @@ export declare class CollapsibleToolboxCategory extends ToolboxCategory implemen
     getDiv(): HTMLDivElement | null;
     /**
      * Gets any children toolbox items. (ex. Gets the subcategories)
-     * @return The child toolbox items.
+     *
+     * @returns The child toolbox items.
      */
     getChildToolboxItems(): IToolboxItem[];
 }
@@ -89,3 +95,4 @@ export declare namespace CollapsibleToolboxCategory {
     }
 }
 export declare type CssConfig = CollapsibleToolboxCategory.CssConfig;
+//# sourceMappingURL=collapsible_category.d.ts.map

package/core/toolbox/separator.d.ts

@@ -9,6 +9,7 @@ import { ToolboxItem } from './toolbox_item.js';
 /**
  * Class for a toolbox separator. This is the thin visual line that appears on
  * the toolbox. This item is not interactable.
+ *
  * @alias Blockly.ToolboxSeparator
  */
 export declare class ToolboxSeparator extends ToolboxItem {
@@ -25,7 +26,8 @@ export declare class ToolboxSeparator extends ToolboxItem {
     init(): void;
     /**
      * Creates the DOM for a separator.
-     * @return The parent element for the separator.
+     *
+     * @returns The parent element for the separator.
      */
     protected createDom_(): HTMLDivElement;
     getDiv(): HTMLDivElement;
@@ -37,3 +39,4 @@ export declare namespace ToolboxSeparator {
     }
 }
 export declare type CssConfig = ToolboxSeparator.CssConfig;
+//# sourceMappingURL=separator.d.ts.map

package/core/toolbox/toolbox.d.ts

@@ -21,6 +21,7 @@ import type { WorkspaceSvg } from '../workspace_svg.js';
 /**
  * Class for a Toolbox.
  * Creates the toolbox's DOM.
+ *
  * @alias Blockly.Toolbox
  */
 export declare class Toolbox extends DeleteArea implements IAutoHideable, IKeyboardAccessible, IStyleable, IToolbox {
@@ -67,30 +68,35 @@ export declare class Toolbox extends DeleteArea implements IAutoHideable, IKeybo
     constructor(workspace: WorkspaceSvg);
     /**
      * Handles the given keyboard shortcut.
+     *
      * @param _shortcut The shortcut to be handled.
-     * @return True if the shortcut has been handled, false otherwise.
+     * @returns True if the shortcut has been handled, false otherwise.
      */
     onShortcut(_shortcut: KeyboardShortcut): boolean;
     /** Initializes the toolbox */
     init(): void;
     /**
      * Creates the DOM for the toolbox.
+     *
      * @param workspace The workspace this toolbox is on.
-     * @return The HTML container for the toolbox.
+     * @returns The HTML container for the toolbox.
      */
     protected createDom_(workspace: WorkspaceSvg): HTMLDivElement;
     /**
      * Creates the container div for the toolbox.
-     * @return The HTML container for the toolbox.
+     *
+     * @returns The HTML container for the toolbox.
      */
     protected createContainer_(): HTMLDivElement;
     /**
      * Creates the container for all the contents in the toolbox.
-     * @return The HTML container for the toolbox contents.
+     *
+     * @returns The HTML container for the toolbox contents.
      */
     protected createContentsContainer_(): HTMLDivElement;
     /**
      * Adds event listeners to the toolbox container div.
+     *
      * @param container The HTML container for the toolbox.
      * @param contentsContainer The HTML container for the contents of the
      *     toolbox.
@@ -98,35 +104,41 @@ export declare class Toolbox extends DeleteArea implements IAutoHideable, IKeybo
     protected attachEvents_(container: HTMLDivElement, contentsContainer: HTMLDivElement): void;
     /**
      * Handles on click events for when the toolbox or toolbox items are clicked.
+     *
      * @param e Click event to handle.
      */
     protected onClick_(e: MouseEvent): void;
     /**
      * Handles key down events for the toolbox.
+     *
      * @param e The key down event.
      */
     protected onKeyDown_(e: KeyboardEvent): void;
     /**
      * Creates the flyout based on the toolbox layout.
-     * @return The flyout for the toolbox.
+     *
+     * @returns The flyout for the toolbox.
      * @throws {Error} If missing a require for `Blockly.HorizontalFlyout`,
      *     `Blockly.VerticalFlyout`, and no flyout plugin is specified.
      */
     protected createFlyout_(): IFlyout;
     /**
      * Fills the toolbox with new toolbox items and removes any old contents.
+     *
      * @param toolboxDef Object holding information for creating a toolbox.
      * @internal
      */
     render(toolboxDef: toolbox.ToolboxInfo): void;
     /**
      * Adds all the toolbox items to the toolbox.
+     *
      * @param toolboxDef Array holding objects containing information on the
      *     contents of the toolbox.
      */
     protected renderContents_(toolboxDef: toolbox.ToolboxItemInfo[]): void;
     /**
      * Creates and renders the toolbox item.
+     *
      * @param toolboxItemDef Any information that can be used to create an item in
      *     the toolbox.
      * @param fragment The document fragment to add the child toolbox elements to.
@@ -134,22 +146,26 @@ export declare class Toolbox extends DeleteArea implements IAutoHideable, IKeybo
     private createToolboxItem_;
     /**
      * Adds an item to the toolbox.
+     *
      * @param toolboxItem The item in the toolbox.
      */
     protected addToolboxItem_(toolboxItem: IToolboxItem): void;
     /**
      * Gets the items in the toolbox.
-     * @return The list of items in the toolbox.
+     *
+     * @returns The list of items in the toolbox.
      */
     getToolboxItems(): IToolboxItem[];
     /**
      * Adds a style on the toolbox. Usually used to change the cursor.
+     *
      * @param style The name of the class to add.
      * @internal
      */
     addStyle(style: string): void;
     /**
      * Removes a style from the toolbox. Usually used to change the cursor.
+     *
      * @param style The name of the class to remove.
      * @internal
      */
@@ -157,7 +173,8 @@ export declare class Toolbox extends DeleteArea implements IAutoHideable, IKeybo
     /**
      * Returns the bounding rectangle of the drag target area in pixel units
      * relative to viewport.
-     * @return The component's bounding box. Null if drag target area should be
+     *
+     * @returns The component's bounding box. Null if drag target area should be
      *     ignored.
      */
     getClientRect(): Rect | null;
@@ -166,30 +183,35 @@ export declare class Toolbox extends DeleteArea implements IAutoHideable, IKeybo
      * this area.
      * This method should check if the element is deletable and is always called
      * before onDragEnter/onDragOver/onDragExit.
+     *
      * @param element The block or bubble currently being dragged.
      * @param _couldConnect Whether the element could could connect to another.
-     * @return Whether the element provided would be deleted if dropped on this
+     * @returns Whether the element provided would be deleted if dropped on this
      *     area.
      */
     wouldDelete(element: IDraggable, _couldConnect: boolean): boolean;
     /**
      * Handles when a cursor with a block or bubble enters this drag target.
+     *
      * @param _dragElement The block or bubble currently being dragged.
      */
     onDragEnter(_dragElement: IDraggable): void;
     /**
      * Handles when a cursor with a block or bubble exits this drag target.
+     *
      * @param _dragElement The block or bubble currently being dragged.
      */
     onDragExit(_dragElement: IDraggable): void;
     /**
      * Handles when a block or bubble is dropped on this component.
      * Should not handle delete here.
+     *
      * @param _dragElement The block or bubble currently being dragged.
      */
     onDrop(_dragElement: IDraggable): void;
     /**
      * Updates the internal wouldDelete_ state.
+     *
      * @param wouldDelete The new value for the wouldDelete state.
      */
     protected updateWouldDelete_(wouldDelete: boolean): void;
@@ -197,49 +219,58 @@ export declare class Toolbox extends DeleteArea implements IAutoHideable, IKeybo
      * Adds or removes the CSS style of the cursor over the toolbox based whether
      * the block or bubble over it is expected to be deleted if dropped (using the
      * internal this.wouldDelete_ property).
+     *
      * @param addStyle Whether the style should be added or removed.
      */
     protected updateCursorDeleteStyle_(addStyle: boolean): void;
     /**
      * Gets the toolbox item with the given ID.
+     *
      * @param id The ID of the toolbox item.
-     * @return The toolbox item with the given ID, or null if no item exists.
+     * @returns The toolbox item with the given ID, or null if no item exists.
      */
     getToolboxItemById(id: string): IToolboxItem | null;
     /**
      * Gets the width of the toolbox.
-     * @return The width of the toolbox.
+     *
+     * @returns The width of the toolbox.
      */
     getWidth(): number;
     /**
      * Gets the height of the toolbox.
-     * @return The width of the toolbox.
+     *
+     * @returns The width of the toolbox.
      */
     getHeight(): number;
     /**
      * Gets the toolbox flyout.
-     * @return The toolbox flyout.
+     *
+     * @returns The toolbox flyout.
      */
     getFlyout(): IFlyout | null;
     /**
      * Gets the workspace for the toolbox.
-     * @return The parent workspace for the toolbox.
+     *
+     * @returns The parent workspace for the toolbox.
      */
     getWorkspace(): WorkspaceSvg;
     /**
      * Gets the selected item.
-     * @return The selected item, or null if no item is currently selected.
+     *
+     * @returns The selected item, or null if no item is currently selected.
      */
     getSelectedItem(): ISelectableToolboxItem | null;
     /**
      * Gets the previously selected item.
-     * @return The previously selected item, or null if no item was previously
+     *
+     * @returns The previously selected item, or null if no item was previously
      *     selected.
      */
     getPreviouslySelectedItem(): ISelectableToolboxItem | null;
     /**
      * Gets whether or not the toolbox is horizontal.
-     * @return True if the toolbox is horizontal, false if the toolbox is
+     *
+     * @returns True if the toolbox is horizontal, false if the toolbox is
      *     vertical.
      */
     isHorizontal(): boolean;
@@ -250,6 +281,7 @@ export declare class Toolbox extends DeleteArea implements IAutoHideable, IKeybo
     position(): void;
     /**
      * Handles resizing the toolbox when a toolbox item resizes.
+     *
      * @internal
      */
     handleToolboxItemResize(): void;
@@ -257,6 +289,7 @@ export declare class Toolbox extends DeleteArea implements IAutoHideable, IKeybo
     clearSelection(): void;
     /**
      * Updates the category colours and background colour of selected categories.
+     *
      * @internal
      */
     refreshTheme(): void;
@@ -268,11 +301,13 @@ export declare class Toolbox extends DeleteArea implements IAutoHideable, IKeybo
     refreshSelection(): void;
     /**
      * Shows or hides the toolbox.
+     *
      * @param isVisible True if toolbox should be visible.
      */
     setVisible(isVisible: boolean): void;
     /**
      * Hides the component. Called in WorkspaceSvg.hideChaff.
+     *
      * @param onlyClosePopups Whether only popups should be closed.
      *     Flyouts should not be closed if this is true.
      */
@@ -280,73 +315,86 @@ export declare class Toolbox extends DeleteArea implements IAutoHideable, IKeybo
     /**
      * Sets the given item as selected.
      * No-op if the item is not selectable.
+     *
      * @param newItem The toolbox item to select.
      */
     setSelectedItem(newItem: IToolboxItem | null): void;
     /**
      * Decides whether the old item should be deselected.
+     *
      * @param oldItem The previously selected toolbox item.
      * @param newItem The newly selected toolbox item.
-     * @return True if the old item should be deselected, false otherwise.
+     * @returns True if the old item should be deselected, false otherwise.
      */
     protected shouldDeselectItem_(oldItem: ISelectableToolboxItem | null, newItem: ISelectableToolboxItem | null): boolean;
     /**
      * Decides whether the new item should be selected.
+     *
      * @param oldItem The previously selected toolbox item.
      * @param newItem The newly selected toolbox item.
-     * @return True if the new item should be selected, false otherwise.
+     * @returns True if the new item should be selected, false otherwise.
      */
     protected shouldSelectItem_(oldItem: ISelectableToolboxItem | null, newItem: ISelectableToolboxItem | null): boolean;
     /**
      * Deselects the given item, marks it as unselected, and updates aria state.
+     *
      * @param item The previously selected toolbox item which should be
      *     deselected.
      */
     protected deselectItem_(item: ISelectableToolboxItem): void;
     /**
      * Selects the given item, marks it selected, and updates aria state.
+     *
      * @param oldItem The previously selected toolbox item.
      * @param newItem The newly selected toolbox item.
      */
     protected selectItem_(oldItem: ISelectableToolboxItem | null, newItem: ISelectableToolboxItem): void;
     /**
      * Selects the toolbox item by its position in the list of toolbox items.
+     *
      * @param position The position of the item to select.
      */
     selectItemByPosition(position: number): void;
     /**
      * Decides whether to hide or show the flyout depending on the selected item.
+     *
      * @param oldItem The previously selected toolbox item.
      * @param newItem The newly selected toolbox item.
      */
     protected updateFlyout_(oldItem: ISelectableToolboxItem | null, newItem: ISelectableToolboxItem | null): void;
     /**
      * Emits an event when a new toolbox item is selected.
+     *
      * @param oldItem The previously selected toolbox item.
      * @param newItem The newly selected toolbox item.
      */
     private fireSelectEvent_;
     /**
      * Closes the current item if it is expanded, or selects the parent.
-     * @return True if a parent category was selected, false otherwise.
+     *
+     * @returns True if a parent category was selected, false otherwise.
      */
     private selectParent_;
     /**
      * Selects the first child of the currently selected item, or nothing if the
      * toolbox item has no children.
-     * @return True if a child category was selected, false otherwise.
+     *
+     * @returns True if a child category was selected, false otherwise.
      */
     private selectChild_;
     /**
      * Selects the next visible toolbox item.
-     * @return True if a next category was selected, false otherwise.
+     *
+     * @returns True if a next category was selected, false otherwise.
      */
     private selectNext_;
     /**
      * Selects the previous visible toolbox item.
-     * @return True if a previous category was selected, false otherwise.
+     *
+     * @returns True if a previous category was selected, false otherwise.
      */
     private selectPrevious_;
     /** Disposes of this toolbox. */
     dispose(): void;
 }
+//# sourceMappingURL=toolbox.d.ts.map