blockly 12.5.1 → 13.0.0-beta.1

package/core/flyout_base.d.ts

@@ -3,43 +3,23 @@
  * Copyright 2011 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-/**
- * Flyout tray containing blocks which may be created.
- *
- * @class
- */
-import { BlockSvg } from './block_svg.js';
 import { DeleteArea } from './delete_area.js';
 import { FlyoutItem } from './flyout_item.js';
 import { IAutoHideable } from './interfaces/i_autohideable.js';
 import type { IFlyout } from './interfaces/i_flyout.js';
 import type { IFlyoutInflater } from './interfaces/i_flyout_inflater.js';
-import { IFocusableNode } from './interfaces/i_focusable_node.js';
-import type { IFocusableTree } from './interfaces/i_focusable_tree.js';
 import type { Options } from './options.js';
-import * as blocks from './serialization/blocks.js';
-import { Coordinate } from './utils/coordinate.js';
 import { Svg } from './utils/svg.js';
 import * as toolbox from './utils/toolbox.js';
 import { WorkspaceSvg } from './workspace_svg.js';
 /**
  * Class for a flyout.
  */
-export declare abstract class Flyout extends DeleteArea implements IAutoHideable, IFlyout, IFocusableNode {
+export declare abstract class Flyout extends DeleteArea implements IAutoHideable, IFlyout {
     /**
      * Position the flyout.
      */
     abstract position(): void;
-    /**
-     * Determine if a drag delta is toward the workspace, based on the position
-     * and orientation of the flyout. This is used in determineDragIntention_ to
-     * determine if a new block should be created or if the flyout should scroll.
-     *
-     * @param currentDragDeltaXY How far the pointer has
-     *     moved from the position at mouse down, in pixel units.
-     * @returns True if the drag is toward the workspace.
-     */
-    abstract isDragTowardWorkspace(currentDragDeltaXY: Coordinate): boolean;
     /**
      * Sets the translation of the flyout to match the scrollbars.
      *
@@ -151,27 +131,6 @@ export declare abstract class Flyout extends DeleteArea implements IAutoHideable
      * Height of flyout.
      */
     protected height_: number;
-    /**
-     * Range of a drag angle from a flyout considered "dragging toward
-     * workspace". Drags that are within the bounds of this many degrees from
-     * the orthogonal line to the flyout edge are considered to be "drags toward
-     * the workspace".
-     *
-     * @example
-     *
-     * ```
-     * Flyout                                                 Edge   Workspace
-     * [block] /  <-within this angle, drags "toward workspace" |
-     * [block] ---- orthogonal to flyout boundary ----          |
-     * [block] \                                                |
-     * ```
-     *
-     * The angle is given in degrees from the orthogonal.
-     *
-     * This is used to know when to create a new block and when to scroll the
-     * flyout. Setting it to 360 means that all drags create a new block.
-     */
-    protected dragAngleRange_: number;
     /**
      * The path around the background of the flyout, which will be filled with a
      * background colour.
@@ -348,25 +307,6 @@ export declare abstract class Flyout extends DeleteArea implements IAutoHideable
      * @param e Pointer down event.
      */
     private onMouseDown;
-    /**
-     * Does this flyout allow you to create a new instance of the given block?
-     * Used for deciding if a block can be "dragged out of" the flyout.
-     *
-     * @param block The block to copy from the flyout.
-     * @returns True if you can create a new instance of the block, false
-     *    otherwise.
-     * @internal
-     */
-    isBlockCreatable(block: BlockSvg): boolean;
-    /**
-     * Create a copy of this block on the workspace.
-     *
-     * @param originalBlock The block to copy from the flyout.
-     * @returns The newly created block.
-     * @throws {Error} if something went wrong with deserialization.
-     * @internal
-     */
-    createBlock(originalBlock: BlockSvg): BlockSvg;
     /**
      * Reflow flyout contents.
      */
@@ -377,20 +317,6 @@ export declare abstract class Flyout extends DeleteArea implements IAutoHideable
      * @internal
      */
     isScrollable(): boolean;
-    /**
-     * Serialize a block to JSON.
-     *
-     * @param block The block to serialize.
-     * @returns A serialized representation of the block.
-     */
-    protected serializeBlock(block: BlockSvg): blocks.State;
-    /**
-     * Positions a block on the target workspace.
-     *
-     * @param oldBlock The flyout block being copied.
-     * @param block The block to posiiton.
-     */
-    private positionNewBlock;
     /**
      * Returns the inflater responsible for constructing items of the given type.
      *
@@ -399,55 +325,5 @@ export declare abstract class Flyout extends DeleteArea implements IAutoHideable
      *     is registered for that type.
      */
     protected getInflaterForType(type: string): IFlyoutInflater | null;
-    /**
-     * See IFocusableNode.getFocusableElement.
-     *
-     * @deprecated v12: Use the Flyout's workspace for focus operations, instead.
-     */
-    getFocusableElement(): HTMLElement | SVGElement;
-    /**
-     * See IFocusableNode.getFocusableTree.
-     *
-     * @deprecated v12: Use the Flyout's workspace for focus operations, instead.
-     */
-    getFocusableTree(): IFocusableTree;
-    /** See IFocusableNode.onNodeFocus. */
-    onNodeFocus(): void;
-    /** See IFocusableNode.onNodeBlur. */
-    onNodeBlur(): void;
-    /** See IFocusableNode.canBeFocused. */
-    canBeFocused(): boolean;
-    /**
-     * See IFocusableNode.getRootFocusableNode.
-     *
-     * @deprecated v12: Use the Flyout's workspace for focus operations, instead.
-     */
-    getRootFocusableNode(): IFocusableNode;
-    /**
-     * See IFocusableNode.getRestoredFocusableNode.
-     *
-     * @deprecated v12: Use the Flyout's workspace for focus operations, instead.
-     */
-    getRestoredFocusableNode(_previousNode: IFocusableNode | null): IFocusableNode | null;
-    /**
-     * See IFocusableNode.getNestedTrees.
-     *
-     * @deprecated v12: Use the Flyout's workspace for focus operations, instead.
-     */
-    getNestedTrees(): Array<IFocusableTree>;
-    /**
-     * See IFocusableNode.lookUpFocusableNode.
-     *
-     * @deprecated v12: Use the Flyout's workspace for focus operations, instead.
-     */
-    lookUpFocusableNode(_id: string): IFocusableNode | null;
-    /** See IFocusableTree.onTreeFocus. */
-    onTreeFocus(_node: IFocusableNode, _previousTree: IFocusableTree | null): void;
-    /**
-     * See IFocusableNode.onTreeBlur.
-     *
-     * @deprecated v12: Use the Flyout's workspace for focus operations, instead.
-     */
-    onTreeBlur(_nextTree: IFocusableTree | null): void;
 }
 //# sourceMappingURL=flyout_base.d.ts.map

package/core/flyout_button.d.ts

@@ -136,5 +136,14 @@ export declare class FlyoutButton implements IBoundedElement, IRenderedElement,
     onNodeBlur(): void;
     /** See IFocusableNode.canBeFocused. */
     canBeFocused(): boolean;
+    /**
+     * Returns the ID of this FlyoutButton.
+     */
+    getId(): string;
+    /**
+     * Handles the user acting on this button via keyboard navigation.
+     * Invokes the click handler callback.
+     */
+    performAction(): void;
 }
 //# sourceMappingURL=flyout_button.d.ts.map

package/core/flyout_horizontal.d.ts

@@ -6,7 +6,6 @@
 import { Flyout } from './flyout_base.js';
 import type { FlyoutItem } from './flyout_item.js';
 import type { Options } from './options.js';
-import type { Coordinate } from './utils/coordinate.js';
 import { Rect } from './utils/rect.js';
 /**
  * Class for a flyout.
@@ -60,16 +59,6 @@ export declare class HorizontalFlyout extends Flyout {
      * @param contents The flyout items to lay out.
      */
     protected layout_(contents: FlyoutItem[]): void;
-    /**
-     * Determine if a drag delta is toward the workspace, based on the position
-     * and orientation of the flyout. This is used in determineDragIntention_ to
-     * determine if a new block should be created or if the flyout should scroll.
-     *
-     * @param currentDragDeltaXY How far the pointer has moved from the position
-     *     at mouse down, in pixel units.
-     * @returns True if the drag is toward the workspace.
-     */
-    isDragTowardWorkspace(currentDragDeltaXY: Coordinate): boolean;
     /**
      * Returns the bounding rectangle of the drag target area in pixel units
      * relative to viewport.

package/core/flyout_vertical.d.ts

@@ -6,7 +6,6 @@
 import { Flyout } from './flyout_base.js';
 import type { FlyoutItem } from './flyout_item.js';
 import type { Options } from './options.js';
-import type { Coordinate } from './utils/coordinate.js';
 import { Rect } from './utils/rect.js';
 /**
  * Class for a flyout.
@@ -61,16 +60,6 @@ export declare class VerticalFlyout extends Flyout {
      * @param contents The flyout items to lay out.
      */
     protected layout_(contents: FlyoutItem[]): void;
-    /**
-     * Determine if a drag delta is toward the workspace, based on the position
-     * and orientation of the flyout. This is used in determineDragIntention_ to
-     * determine if a new block should be created or if the flyout should scroll.
-     *
-     * @param currentDragDeltaXY How far the pointer has moved from the position
-     *     at mouse down, in pixel units.
-     * @returns True if the drag is toward the workspace.
-     */
-    isDragTowardWorkspace(currentDragDeltaXY: Coordinate): boolean;
     /**
      * Returns the bounding rectangle of the drag target area in pixel units
      * relative to viewport.

package/core/focus_manager.d.ts

@@ -7,11 +7,15 @@ import type { IFocusableNode } from './interfaces/i_focusable_node.js';
 import type { IFocusableTree } from './interfaces/i_focusable_tree.js';
 /**
  * Type declaration for returning focus to FocusManager upon completing an
- * ephemeral UI flow (such as a dialog).
+ * ephemeral UI flow (such as a dialog). Normally, the FocusManager will refocus
+ * the previously-focused element. If callers do not wish for the FocusManager
+ * to do so, they may call this method with `restoreFocus` set to false to
+ * prevent automatic refocusing and leave focus where it is.
+ *
  *
  * See FocusManager.takeEphemeralFocus for more details.
  */
-export type ReturnEphemeralFocus = () => void;
+export type ReturnEphemeralFocus = (restoreFocus?: boolean) => void;
 /**
  * A per-page singleton that manages Blockly focus across one or more
  * IFocusableTrees, and bidirectionally synchronizes this focus with the DOM.
@@ -56,6 +60,20 @@ export declare class FocusManager {
     private lockFocusStateChanges;
     private recentlyLostAllFocus;
     private isUpdatingFocusedNode;
+    /**
+     * Root element in which popovers (WidgetDiv, DropDownDiv) currently live.
+     */
+    private popoverFocusRoot?;
+    /**
+     * Set of callbacks to invoke if the popover focus root loses focus.
+     */
+    private popoverFocusLossHandlers;
+    /**
+     * Handler for focusout in the popover focus root that selectively
+     * invokes the popover focus loss handlers if focus has truly transitioned
+     * outside of the focus root, and not e.g. to a different popover.
+     */
+    private popoverFocusOutHandler;
     constructor(addGlobalEventListener: (type: string, listener: EventListener) => void);
     /**
      * Registers a new IFocusableTree for automatic focus management.
@@ -260,6 +278,33 @@ export declare class FocusManager {
      * but may change across page loads.
      */
     static getFocusManager(): FocusManager;
+    /**
+     * Sets the current popover focus root. Generally this is active
+     * workspace's injection div or the explicitly specified parent container for
+     * the WidgetDiv, DropDownDiv, etc.
+     *
+     * @internal
+     * @param newRoot The new element that contains all popovers.
+     */
+    setPopoverFocusRoot(newRoot: HTMLElement): void;
+    /**
+     * Registers a callback to be invoked if the popover focus root loses
+     * focus. This should only be called by popovers that need to react to
+     * focus changes by e.g. hiding themselves and resigning ephemeral focus.
+     *
+     * @internal
+     * @param handler A callback function.
+     */
+    registerPopoverFocusLossHandler(handler: () => void): void;
+    /**
+     * Unregisters a previously-registered popover focus loss handler. This
+     * should only be invoked by popovers when they no longer need to be
+     * notified of focus loss, typically when they are hidden.
+     *
+     * @internal
+     * @param handler A previously-registered callback function.
+     */
+    unregisterPopoverFocusLossHandler(handler: () => void): void;
 }
 /** Convenience function for FocusManager.getFocusManager. */
 export declare function getFocusManager(): FocusManager;

package/core/gesture.d.ts

@@ -149,18 +149,6 @@ export declare class Gesture {
      * @returns True if the drag just exceeded the drag radius for the first time.
      */
     private updateDragDelta;
-    /**
-     * Update this gesture to record whether a block is being dragged from the
-     * flyout.
-     * This function should be called on a pointermove event the first time
-     * the drag radius is exceeded.  It should be called no more than once per
-     * gesture. If a block should be dragged from the flyout this function creates
-     * the new block on the main workspace and updates targetBlock_ and
-     * startWorkspace_.
-     *
-     * @returns True if a block is being dragged from the flyout.
-     */
-    private updateIsDraggingFromFlyout;
     /**
      * Check whether to start a workspace drag. If a workspace is being dragged,
      * create the necessary WorkspaceDragger and start the drag.

package/core/hints.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @license
+ * Copyright 2026 Raspberry Pi Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { WorkspaceSvg } from './workspace_svg.js';
+/**
+ * Nudge the user to use unconstrained movement.
+ *
+ * @param workspace Workspace.
+ * @param force Set to show it even if previously shown.
+ */
+export declare function showUnconstrainedMoveHint(workspace: WorkspaceSvg, force?: boolean): void;
+/**
+ * Nudge the user to move a block that's in move mode.
+ *
+ * @param workspace Workspace.
+ */
+export declare function showConstrainedMovementHint(workspace: WorkspaceSvg): void;
+/**
+ * Clear active move-related hints, if any.
+ *
+ * @param workspace The workspace.
+ */
+export declare function clearMoveHints(workspace: WorkspaceSvg): void;
+/**
+ * Nudge the user to open the help.
+ *
+ * @param workspace The workspace.
+ */
+export declare function showHelpHint(workspace: WorkspaceSvg): void;
+/**
+ * Tell the user how to navigate inside blocks.
+ *
+ * @param workspace The workspace.
+ */
+export declare function showBlockNavigationHint(workspace: WorkspaceSvg): void;
+/**
+ * Tell the user how to navigate inside the workspace.
+ *
+ * @param workspace The workspace.
+ */
+export declare function showWorkspaceNavigationHint(workspace: WorkspaceSvg): void;
+//# sourceMappingURL=hints.d.ts.map

package/core/icons/icon.d.ts

@@ -73,6 +73,12 @@ export declare abstract class Icon implements IIcon, IContextMenu {
     onNodeBlur(): void;
     /** See IFocusableNode.canBeFocused. */
     canBeFocused(): boolean;
+    /**
+     * Handles the user acting on this icon via keyboard navigation.
+     * Performs the same action as a click would, and focuses this icon's bubble
+     * if it has one.
+     */
+    performAction(): void;
     /**
      * Returns the block that this icon is attached to.
      *

package/core/inputs/input.d.ts

@@ -12,8 +12,9 @@ import '../field_label.js';
 import type { Block } from '../block.js';
 import type { BlockSvg } from '../block_svg.js';
 import type { Connection } from '../connection.js';
-import type { ConnectionType } from '../connection_type.js';
+import { ConnectionType } from '../connection_type.js';
 import type { Field } from '../field.js';
+import { Verbosity } from '../utils/aria.js';
 import { Align } from './align.js';
 import { inputTypes } from './input_types.js';
 /** Class for an input with optional fields. */
@@ -143,5 +144,25 @@ export declare class Input {
      *     or rendered connection, based on the type of this input's source block.
      */
     protected makeConnection(type: ConnectionType): Connection;
+    /**
+     * Returns an ID for the visual "row" this input is part of.
+     *
+     * @internal
+     */
+    getRowId(): string;
+    /**
+     * Returns an accessibility label describing this input, including the labels
+     * of any fields on the input and the labels of any connected blocks, to help
+     * disambiguate this input from others on the same block.
+     *
+     * @internal
+     */
+    getLabel(verbosity?: Verbosity): string;
+    /**
+     * Returns the index of this input on its source block.
+     *
+     * @internal
+     */
+    getIndex(): number;
 }
 //# sourceMappingURL=input.d.ts.map

package/core/interfaces/i_bounded_element.d.ts

@@ -24,4 +24,11 @@ export interface IBoundedElement {
      */
     moveBy(dx: number, dy: number, reason?: string[]): void;
 }
+/**
+ * Returns whether or not the given object conforms to IBoundedElement.
+ *
+ * @param object The object to test for conformance.
+ * @returns True if the object conforms to IBoundedElement, otherwise false.
+ */
+export declare function isBoundedElement(object: any): object is IBoundedElement;
 //# sourceMappingURL=i_bounded_element.d.ts.map

package/core/interfaces/i_bubble.d.ts

@@ -4,13 +4,14 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import type { Coordinate } from '../utils/coordinate.js';
+import { IBoundedElement } from './i_bounded_element.js';
 import type { IContextMenu } from './i_contextmenu.js';
 import type { IDraggable } from './i_draggable.js';
-import { IFocusableNode } from './i_focusable_node.js';
+import { ISelectable } from './i_selectable.js';
 /**
  * A bubble interface.
  */
-export interface IBubble extends IDraggable, IContextMenu, IFocusableNode {
+export interface IBubble extends IDraggable, IContextMenu, ISelectable, IBoundedElement {
     /**
      * Return the coordinates of the top-left corner of this bubble's body
      * relative to the drawing surface's origin (0,0), in workspace units.

package/core/interfaces/i_collapsible_toolbox_item.d.ts

@@ -3,7 +3,7 @@
  * Copyright 2020 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import type { ISelectableToolboxItem } from './i_selectable_toolbox_item.js';
+import { type ISelectableToolboxItem } from './i_selectable_toolbox_item.js';
 import type { IToolboxItem } from './i_toolbox_item.js';
 /**
  * Interface for an item in the toolbox that can be collapsed.
@@ -25,4 +25,8 @@ export interface ICollapsibleToolboxItem extends ISelectableToolboxItem {
     /** Toggles whether or not the toolbox item is expanded. */
     toggleExpanded(): void;
 }
+/**
+ * Type guard that checks whether an object is an ICollapsibleToolboxItem.
+ */
+export declare function isCollapsibleToolboxItem(obj: any): obj is ICollapsibleToolboxItem;
 //# sourceMappingURL=i_collapsible_toolbox_item.d.ts.map

package/core/interfaces/i_draggable.d.ts

@@ -3,14 +3,20 @@
  * Copyright 2021 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { Coordinate } from '../utils/coordinate';
+import type { Coordinate } from '../utils/coordinate.js';
+import type { IBoundedElement } from './i_bounded_element.js';
+import type { ISelectable } from './i_selectable.js';
+export declare enum DragDisposition {
+    COMMIT = 1,
+    DELETE = 2,
+    REVERT = 3
+}
 /**
  * Represents an object that can be dragged.
  */
-export interface IDraggable extends IDragStrategy {
+export interface IDraggable extends IDragStrategy, IBoundedElement, ISelectable {
     /**
-     * Returns the current location of the draggable in workspace
-     * coordinates.
+     * Returns the current location of the draggable in workspace coordinates.
      *
      * @returns Coordinate of current location on workspace.
      */
@@ -23,31 +29,30 @@ export interface IDragStrategy {
      * Handles any drag startup (e.g moving elements to the front of the
      * workspace).
      *
-     * @param e PointerEvent that started the drag; can be used to
-     *     check modifier keys, etc.  May be missing when dragging is
-     *     triggered programatically rather than by user.
+     * @param e Event that started the drag; can be used to check modifier keys,
+     *     etc. May be missing when dragging is triggered programmatically rather
+     *     than by user.
      */
-    startDrag(e?: PointerEvent): void;
+    startDrag(e?: PointerEvent | KeyboardEvent): IDraggable;
     /**
      * Handles moving elements to the new location, and updating any
      * visuals based on that (e.g connection previews for blocks).
      *
      * @param newLoc Workspace coordinate to which the draggable has
      *     been dragged.
-     * @param e PointerEvent that continued the drag.  Can be
-     *     used to check modifier keys, etc.
+     * @param e Event that continued the drag.  Can be used to check modifier
+     *     keys, etc.
      */
-    drag(newLoc: Coordinate, e?: PointerEvent): void;
+    drag(newLoc: Coordinate, e?: PointerEvent | KeyboardEvent): void;
     /**
-     * Handles any drag cleanup, including e.g. connecting or deleting
-     * blocks.
+     * Handles any drag cleanup, including e.g. connecting or deleting blocks.
      *
      * @param newLoc Workspace coordinate at which the drag finished.
-     *     been dragged.
-     * @param e PointerEvent that finished the drag.  Can be
-     *     used to check modifier keys, etc.
+     * @param e Event that finished the drag. Can be used to check modifier keys,
+     *     etc.
+     * @param disposition The end result of the drag.
      */
-    endDrag(e?: PointerEvent): void;
+    endDrag(e: PointerEvent | KeyboardEvent | undefined, disposition: DragDisposition): void;
     /** Moves the draggable back to where it was at the start of the drag. */
     revertDrag(): void;
 }

package/core/interfaces/i_dragger.d.ts

@@ -3,30 +3,39 @@
  * Copyright 2024 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { Coordinate } from '../utils/coordinate';
+import type { Coordinate } from '../utils/coordinate';
+import type { IDraggable } from './i_draggable';
 export interface IDragger {
     /**
      * Handles any drag startup.
      *
-     * @param e PointerEvent that started the drag.
+     * @param e Event that started the drag.
      */
-    onDragStart(e: PointerEvent): void;
+    onDragStart(e?: PointerEvent | KeyboardEvent): IDraggable;
     /**
      * Handles dragging, including calculating where the element should
      * actually be moved to.
      *
-     * @param e PointerEvent that continued the drag.
-     * @param totalDelta The total distance, in pixels, that the mouse
+     * @param e Event that continued the drag.
+     * @param totalDelta The total distance, in pixels, that the draggable
      *     has moved since the start of the drag.
      */
-    onDrag(e: PointerEvent, totalDelta: Coordinate): void;
+    onDrag(e: PointerEvent | KeyboardEvent | undefined, totalDelta: Coordinate): void;
     /**
-     * Handles any drag cleanup.
+     * Handles any drag cleanup when a drag finishes normally.
      *
-     * @param e PointerEvent that finished the drag.
-     * @param totalDelta The total distance, in pixels, that the mouse
+     * @param e Event that finished the drag.
+     * @param totalDelta The total distance, in pixels, that the draggable
      *     has moved since the start of the drag.
      */
-    onDragEnd(e: PointerEvent, totalDelta: Coordinate): void;
+    onDragEnd(e: PointerEvent | KeyboardEvent | undefined, totalDelta: Coordinate): void;
+    /**
+     * Handles any drag cleanup when a drag is reverted.
+     *
+     * @param e Event that finished the drag.
+     * @param totalDelta The total distance, in pixels, that the draggable
+     *     has moved since the start of the drag.
+     */
+    onDragRevert(e: PointerEvent | KeyboardEvent | undefined, totalDelta: Coordinate): void;
 }
 //# sourceMappingURL=i_dragger.d.ts.map

package/core/interfaces/i_flyout.d.ts

@@ -3,18 +3,15 @@
  * Copyright 2020 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import type { BlockSvg } from '../block_svg.js';
 import type { FlyoutItem } from '../flyout_item.js';
-import type { Coordinate } from '../utils/coordinate.js';
 import type { Svg } from '../utils/svg.js';
 import type { FlyoutDefinition } from '../utils/toolbox.js';
 import type { WorkspaceSvg } from '../workspace_svg.js';
-import { IFocusableTree } from './i_focusable_tree.js';
 import type { IRegistrable } from './i_registrable.js';
 /**
  * Interface for a flyout.
  */
-export interface IFlyout extends IRegistrable, IFocusableTree {
+export interface IFlyout extends IRegistrable {
     /** Whether the flyout is laid out horizontally or not. */
     horizontalLayout: boolean;
     /** Is RTL vs LTR. */
@@ -105,14 +102,6 @@ export interface IFlyout extends IRegistrable, IFocusableTree {
      * @returns List of flyout items.
      */
     getContents(): FlyoutItem[];
-    /**
-     * Create a copy of this block on the workspace.
-     *
-     * @param originalBlock The block to copy from the flyout.
-     * @returns The newly created block.
-     * @throws {Error} if something went wrong with deserialization.
-     */
-    createBlock(originalBlock: BlockSvg): BlockSvg;
     /** Reflow blocks and their mats. */
     reflow(): void;
     /**
@@ -134,25 +123,6 @@ export interface IFlyout extends IRegistrable, IFocusableTree {
     getY(): number;
     /** Position the flyout. */
     position(): void;
-    /**
-     * Determine if a drag delta is toward the workspace, based on the position
-     * and orientation of the flyout. This is used in determineDragIntention_ to
-     * determine if a new block should be created or if the flyout should scroll.
-     *
-     * @param currentDragDeltaXY How far the pointer has moved from the position
-     *     at mouse down, in pixel units.
-     * @returns True if the drag is toward the workspace.
-     */
-    isDragTowardWorkspace(currentDragDeltaXY: Coordinate): boolean;
-    /**
-     * Does this flyout allow you to create a new instance of the given block?
-     * Used for deciding if a block can be "dragged out of" the flyout.
-     *
-     * @param block The block to copy from the flyout.
-     * @returns True if you can create a new instance of the block, false
-     *     otherwise.
-     */
-    isBlockCreatable(block: BlockSvg): boolean;
     /** Scroll the flyout to the beginning of its contents. */
     scrollToStart(): void;
 }

package/core/interfaces/i_focusable_node.d.ts

@@ -93,6 +93,14 @@ export interface IFocusableNode {
      * @returns Whether this node can be focused by FocusManager.
      */
     canBeFocused(): boolean;
+    /**
+     * Optional method invoked when this node has focus and the user acts on it by
+     * pressing Enter or Space. Behavior should generally be similar to the node
+     * being clicked on.
+     *
+     * @param e The event that triggered this action, if any.
+     */
+    performAction?(e?: Event): void;
 }
 /**
  * Determines whether the provided object fulfills the contract of