blockly 12.5.1 → 13.0.0-beta.1

package/core/interfaces/i_focusable_tree.d.ts

@@ -3,6 +3,7 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import type { Navigator } from '../keyboard_nav/navigators/navigator';
 import type { IFocusableNode } from './i_focusable_node.js';
 /**
  * Represents a tree of focusable elements with its own active/passive focus
@@ -113,6 +114,13 @@ export interface IFocusableTree {
      *     as in the case that Blockly is entirely losing DOM focus).
      */
     onTreeBlur(nextTree: IFocusableTree | null): void;
+    /**
+     * Returns a Navigator instance to be used to determine the navigation order
+     * between IFocusableNodes contained within this IFocusableTree. Generally
+     * this can just be an instance of Navigator, but trees may choose to return a
+     * subclass to customize navigation behavior within their context.
+     */
+    getNavigator(): Navigator;
 }
 /**
  * Determines whether the provided object fulfills the contract of

package/core/interfaces/i_json_block_definition.d.ts

@@ -0,0 +1,102 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FieldCheckboxFromJsonConfig } from '../field_checkbox.js';
+import { FieldDropdownFromJsonConfig } from '../field_dropdown';
+import { FieldImageFromJsonConfig } from '../field_image';
+import { FieldNumberFromJsonConfig } from '../field_number';
+import { FieldTextInputFromJsonConfig } from '../field_textinput';
+import { FieldVariableFromJsonConfig } from '../field_variable';
+import { Align } from '../inputs/align.js';
+/**
+ * Defines the JSON structure for a block definition.
+ *
+ * @example
+ * ```typescript
+ * const blockDef:  JsonBlockDefinition = {
+ *   type: 'custom_block',
+ *   message0: 'move %1 steps',
+ *   args0: [
+ *     {
+ *       'type': 'field_number',
+ *       'name': 'INPUT',
+ *     },
+ *   ],
+ *   previousStatement: null,
+ *   nextStatement: null,
+ * };
+ * ```
+ */
+export interface JsonBlockDefinition {
+    type: string;
+    style?: string | null;
+    colour?: string | number;
+    output?: string | string[] | null;
+    previousStatement?: string | string[] | null;
+    nextStatement?: string | string[] | null;
+    outputShape?: number;
+    inputsInline?: boolean;
+    tooltip?: string;
+    helpUrl?: string;
+    extensions?: string[];
+    mutator?: string;
+    enableContextMenu?: boolean;
+    suppressPrefixSuffix?: boolean;
+    [key: `message${number}`]: string | undefined;
+    [key: `args${number}`]: JsonBlockArg[] | undefined;
+    [key: `implicitAlign${number}`]: string | undefined;
+}
+export type JsonBlockArg = InputValueArg | InputStatementArg | InputDummyArg | InputEndRowArg | FieldInputArg | FieldNumberArg | FieldDropdownArg | FieldCheckboxArg | FieldImageArg | FieldVariableArg | UnknownArg;
+interface UnknownArg {
+    type: string;
+    [key: string]: unknown;
+}
+/** Input args */
+interface InputValueArg {
+    type: 'input_value';
+    name?: string;
+    check?: string | string[];
+    align?: Align;
+}
+interface InputStatementArg {
+    type: 'input_statement';
+    name?: string;
+    check?: string | string[];
+}
+interface InputDummyArg {
+    type: 'input_dummy';
+    name?: string;
+}
+interface InputEndRowArg {
+    type: 'input_end_row';
+    name?: string;
+}
+/** Field args */
+interface FieldInputArg extends FieldTextInputFromJsonConfig {
+    type: 'field_input';
+    name?: string;
+}
+interface FieldNumberArg extends FieldNumberFromJsonConfig {
+    type: 'field_number';
+    name?: string;
+}
+interface FieldDropdownArg extends FieldDropdownFromJsonConfig {
+    type: 'field_dropdown';
+    name?: string;
+}
+interface FieldCheckboxArg extends FieldCheckboxFromJsonConfig {
+    type: 'field_checkbox';
+    name?: string;
+}
+interface FieldImageArg extends FieldImageFromJsonConfig {
+    type: 'field_image';
+    name?: string;
+}
+interface FieldVariableArg extends FieldVariableFromJsonConfig {
+    type: 'field_variable';
+    name?: string;
+}
+export {};
+//# sourceMappingURL=i_json_block_definition.d.ts.map

package/core/interfaces/i_navigation_policy.d.ts

@@ -38,6 +38,18 @@ export interface INavigationPolicy<T> {
      *     there is none.
      */
     getPreviousSibling(current: T): IFocusableNode | null;
+    /**
+     * Returns an ID corresponding to the visual "row" the given element is part
+     * of. All elements on the same visual row should share the same ID. For
+     * example, icons share their parent block's row ID, as do inline connected
+     * blocks or value inputs. Statement inputs, external inputs, or blocks
+     * connected to one another's previous or next connections form distinct
+     * visual rows and should have distinct row IDs.
+     *
+     * @param current The element to return the row ID of.
+     * @returns The row ID of the given element.
+     */
+    getRowId(current: T): string;
     /**
      * Returns whether or not the given instance should be reachable via keyboard
      * navigation.

package/core/interfaces/i_selectable.d.ts

@@ -3,7 +3,7 @@
  * Copyright 2019 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import type { Workspace } from '../workspace.js';
+import type { WorkspaceSvg } from '../workspace_svg.js';
 import { IFocusableNode } from './i_focusable_node.js';
 /**
  * The interface for an object that is selectable.
@@ -15,7 +15,7 @@ import { IFocusableNode } from './i_focusable_node.js';
  */
 export interface ISelectable extends IFocusableNode {
     id: string;
-    workspace: Workspace;
+    workspace: WorkspaceSvg;
     /** Select this.  Highlight it visually. */
     select(): void;
     /** Unselect this.  Unhighlight it visually. */

package/core/interfaces/i_selectable_toolbox_item.d.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import type { FlyoutItemInfoArray } from '../utils/toolbox';
-import type { IToolboxItem } from './i_toolbox_item.js';
+import { type IToolboxItem } from './i_toolbox_item.js';
 /**
  * Interface for an item in the toolbox that can be selected.
  */
@@ -45,7 +45,7 @@ export interface ISelectableToolboxItem extends IToolboxItem {
     onClick(_e: Event): void;
 }
 /**
- * Type guard that checks whether an IToolboxItem is an ISelectableToolboxItem.
+ * Type guard that checks whether an object is an ISelectableToolboxItem.
  */
-export declare function isSelectableToolboxItem(toolboxItem: IToolboxItem): toolboxItem is ISelectableToolboxItem;
+export declare function isSelectableToolboxItem(obj: any): obj is ISelectableToolboxItem;
 //# sourceMappingURL=i_selectable_toolbox_item.d.ts.map

package/core/interfaces/i_toolbox.d.ts

@@ -98,5 +98,9 @@ export interface IToolbox extends IRegistrable, IFocusableTree {
     setSelectedItem(item: IToolboxItem | null): void;
     /** Disposes of this toolbox. */
     dispose(): void;
+    /**
+     * Returns a list of items in this toolbox.
+     */
+    getToolboxItems(): IToolboxItem[];
 }
 //# sourceMappingURL=i_toolbox.d.ts.map

package/core/interfaces/i_toolbox_item.d.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import type { IFocusableNode } from './i_focusable_node.js';
+import type { IToolbox } from './i_toolbox.js';
 /**
  * Interface for an item in the toolbox.
  */
@@ -67,5 +68,10 @@ export interface IToolboxItem extends IFocusableNode {
      * @param isVisible True if category should be visible.
      */
     setVisible_(isVisible: boolean): void;
+    getParentToolbox(): IToolbox;
 }
+/**
+ * Type guard that checks whether an object is an IToolboxItem.
+ */
+export declare function isToolboxItem(obj: any): obj is IToolboxItem;
 //# sourceMappingURL=i_toolbox_item.d.ts.map

package/core/keyboard_nav/keyboard_mover.d.ts

@@ -0,0 +1,149 @@
+import type { IDraggable } from '../interfaces/i_draggable.js';
+/**
+ * Cardinal directions in which a move can proceed.
+ */
+export declare enum Direction {
+    NONE = 0,
+    UP = 1,
+    DOWN = 2,
+    LEFT = 3,
+    RIGHT = 4
+}
+/**
+ * Class responsible for coordinating keyboard-driven moves with the workspace
+ * and dragging system.
+ */
+export declare class KeyboardMover {
+    /**
+     * Object responsible for dragging workspace elements in response to move
+     * commands.
+     */
+    private dragger?;
+    /**
+     * The object that is currently being moved.
+     */
+    private draggable?;
+    /**
+     * Workspace coordinate that the current move started from.
+     */
+    private startLocation?;
+    /**
+     * The total distance, in workspace coordinates, that the element being moved
+     * has been moved since the movement process started.
+     */
+    private totalDelta;
+    /**
+     * The distance to move an item in workspace coordinates.
+     */
+    private stepDistance;
+    /**
+     * Symbol attached to the item being moved to indicate it is in move mode.
+     */
+    private moveIndicator?;
+    private allowedShortcuts;
+    private readonly blurListener;
+    static mover: KeyboardMover;
+    private constructor();
+    /**
+     * Returns true iff the given draggable is allowed to be moved.
+     *
+     * @param draggable The draggable element to try to move.
+     * @returns True iff movement is allowed.
+     */
+    canMove(draggable: IDraggable): boolean;
+    /**
+     * Returns true iff this Mover is currently moving an element.
+     *
+     * @returns True iff a workspace element is being moved.
+     */
+    isMoving(): boolean;
+    /**
+     * Start moving the currently-focused item on workspace, if possible.
+     *
+     * @param draggable The element to start moving.
+     * @param event The keyboard event that triggered this move.
+     * @returns True iff a move has successfully begun.
+     */
+    startMove(draggable: IDraggable, event?: KeyboardEvent): boolean;
+    /**
+     * Moves the current element in the given direction.
+     *
+     * @param direction The direction to move the currently-moving element.
+     * @param event The event that triggered this move, if any.
+     * @returns True iff this action applies and has been performed.
+     */
+    move(direction: Direction, event?: KeyboardEvent | PointerEvent): boolean;
+    /**
+     * Finish moving the item that is currently being moved.
+     *
+     * @param event The event that triggered the end of the move, if any.
+     * @returns True iff move successfully finished.
+     */
+    finishMove(event?: KeyboardEvent | PointerEvent): boolean;
+    /**
+     * Abort moving the currently-focused item on workspace.
+     *
+     * @param event The event that triggered the end of the move, if any.
+     * @returns True iff move successfully aborted.
+     */
+    abortMove(event?: KeyboardEvent | PointerEvent): boolean;
+    /**
+     * Sets the distance by which an object will be moved.
+     *
+     * @param stepDistance The distance in workspace coordinates that each move
+     *     should move elements on the workspace by.
+     */
+    setMoveDistance(stepDistance: number): void;
+    /**
+     * Returns a list of the names of shortcuts that are allowed to be run while
+     * a keyboard-driven move is in progress.
+     */
+    getAllowedShortcuts(): string[];
+    /**
+     * Adds shortcuts with the given names to the list of shortcuts that are
+     * allowed to be run while a keyboard-driven move is in progress.
+     */
+    setAllowedShortcuts(shortcutNames: string[]): void;
+    /**
+     * Repositions the move indicator to the corner of the item being moved.
+     */
+    private repositionMoveIndicator;
+    /**
+     * Returns a bounding box used for positioning the move indicator on a block.
+     * Blocks require special treatment because `BlockSvg.getBoundingRectangle()`
+     * includes the bounds of nested and subsequent blocks. Since the move
+     * indicator is positioned at the top right corner of the bounds, this can
+     * result in it appearing to float in empty space when e.g. a small block has
+     * a much wider block nested inside a statement input. BlockSvg also provides
+     * `getBoundingRectangleWithoutChildren()`, which addresses that case, but is
+     * insufficient because in the case of nested *value* blocks in a row, the
+     * child blocks' bounds should contribute to the bounding box.
+     *
+     * @param block The block to retrieve an adjusted bounding box for.
+     * @returns A bounding box for the given block whose top-right corner
+     *     corresponds to the maximum visual extent of the given block's row.
+     */
+    private positionForBlockMoveIndicator;
+    /**
+     * Common clean-up for finish/abort run before terminating the move.
+     */
+    private preDragEndCleanup;
+    /**
+     * Common clean-up for finish/abort run after terminating the move.
+     */
+    private postDragEndCleanup;
+    /**
+     * Returns the total distance current element has moved in pixels.
+     */
+    private totalPixelDelta;
+    /**
+     * Scrolls the current element into view.
+     */
+    private scrollCurrentElementIntoView;
+    /**
+     * Recalculates the total movement delta from the starting location and the
+     * current position of the item being moved.
+     */
+    private updateTotalDelta;
+}
+//# sourceMappingURL=keyboard_mover.d.ts.map

package/core/keyboard_nav/move_indicator.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @license
+ * Copyright 2026 Raspberry Pi Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { WorkspaceSvg } from '../workspace_svg.js';
+/**
+ * Four-way arrow indicator attached to a workspace element to indicate that it
+ * is being moved.
+ */
+export declare class MoveIndicator {
+    private workspace;
+    /**
+     * Root SVG element for the indicator.
+     */
+    svgRoot: SVGGElement;
+    /**
+     * Creates a new move indicator.
+     *
+     * @param workspace The workspace the indicator should be displayed on.
+     */
+    constructor(workspace: WorkspaceSvg);
+    /**
+     * Moves this indicator to the specified location.
+     *
+     * @param x The location on the X axis to move to.
+     * @param y The location on the Y axis to move to.
+     */
+    moveTo(x: number, y: number): void;
+    /**
+     * Disposes of this move indicator.
+     */
+    dispose(): void;
+}
+//# sourceMappingURL=move_indicator.d.ts.map

package/core/keyboard_nav/{block_navigation_policy.d.ts → navigation_policies/block_navigation_policy.d.ts}

@@ -3,13 +3,9 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { BlockSvg } from '../block_svg.js';
-import type { Field } from '../field.js';
-import type { Icon } from '../icons/icon.js';
-import type { IFocusableNode } from '../interfaces/i_focusable_node.js';
-import type { INavigationPolicy } from '../interfaces/i_navigation_policy.js';
-import type { ISelectable } from '../interfaces/i_selectable.js';
-import { RenderedConnection } from '../rendered_connection.js';
+import { BlockSvg } from '../../block_svg.js';
+import type { IFocusableNode } from '../../interfaces/i_focusable_node.js';
+import type { INavigationPolicy } from '../../interfaces/i_navigation_policy.js';
 /**
  * Set of rules controlling keyboard navigation from a block.
  */
@@ -18,7 +14,7 @@ export declare class BlockNavigationPolicy implements INavigationPolicy<BlockSvg
      * Returns the first child of the given block.
      *
      * @param current The block to return the first child of.
-     * @returns The first field or input of the given block, if any.
+     * @returns The first icon, field, or input of the given block, if any.
      */
     getFirstChild(current: BlockSvg): IFocusableNode | null;
     /**
@@ -33,18 +29,25 @@ export declare class BlockNavigationPolicy implements INavigationPolicy<BlockSvg
      * Returns the next peer node of the given block.
      *
      * @param current The block to find the following element of.
-     * @returns The first node of the next input/stack if the given block is a terminal
-     *     block, or its next connection.
+     * @returns The block's next connection, or the next peer on its parent block,
+     *     otherwise null.
      */
     getNextSibling(current: BlockSvg): IFocusableNode | null;
     /**
      * Returns the previous peer node of the given block.
      *
      * @param current The block to find the preceding element of.
-     * @returns The block's previous/output connection, or the last
-     *     connection/block of the previous block stack if it is a root block.
+     * @returns The block's previous connection, or the previous peer on its
+     *     parent block, otherwise null.
      */
     getPreviousSibling(current: BlockSvg): IFocusableNode | null;
+    /**
+     * Returns the visual row ID of the given block.
+     *
+     * @param current The block to retrieve the row ID of.
+     * @returns The row ID of the given block.
+     */
+    getRowId(current: BlockSvg): string;
     /**
      * Returns whether or not the given block can be navigated to.
      *
@@ -60,25 +63,14 @@ export declare class BlockNavigationPolicy implements INavigationPolicy<BlockSvg
      */
     isApplicable(current: any): current is BlockSvg;
 }
-/**
- * Returns the next/previous stack relative to the given element's stack.
- *
- * @param current The element whose stack will be navigated relative to.
- * @param delta The difference in index to navigate; positive values navigate
- *     to the nth next stack, while negative values navigate to the nth previous
- *     stack.
- * @returns The first element in the stack offset by `delta` relative to the
- *     current element's stack, or the last element in the stack offset by
- * `delta` relative to the current element's stack when navigating backwards.
- */
-export declare function navigateStacks(current: ISelectable, delta: number): IFocusableNode | null;
 /**
  * Returns the next navigable item relative to the provided block child.
  *
+ * @param block The block whose children should be navigated.
  * @param current The navigable block child item to navigate relative to.
  * @param delta The difference in index to navigate; positive values navigate
  *     forward by n, while negative values navigate backwards by n.
  * @returns The navigable block child offset by `delta` relative to `current`.
  */
-export declare function navigateBlock(current: Icon | Field | RenderedConnection | BlockSvg, delta: number): IFocusableNode | null;
+export declare function navigateBlock(block: BlockSvg, current: IFocusableNode, delta: number): IFocusableNode | null;
 //# sourceMappingURL=block_navigation_policy.d.ts.map

package/core/keyboard_nav/navigation_policies/bubble_navigation_policy.d.ts

@@ -0,0 +1,63 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Bubble } from '../../bubbles/bubble.js';
+import type { IFocusableNode } from '../../interfaces/i_focusable_node.js';
+import type { INavigationPolicy } from '../../interfaces/i_navigation_policy.js';
+/**
+ * Set of rules controlling keyboard navigation from a Bubble.
+ */
+export declare class BubbleNavigationPolicy implements INavigationPolicy<Bubble> {
+    /**
+     * Returns the first child of the given bubble.
+     *
+     * @param _current The bubble to return the first child of.
+     * @returns Null.
+     */
+    getFirstChild(_current: Bubble): IFocusableNode | null;
+    /**
+     * Returns the parent of the given bubble.
+     *
+     * @param current The bubble to return the parent of.
+     * @returns The parent block of the given bubble.
+     */
+    getParent(current: Bubble): IFocusableNode | null;
+    /**
+     * Returns the next peer node of the given bubble.
+     *
+     * @param current The bubble to find the following element of.
+     * @returns The next navigable item on the bubble's icon's parent block.
+     */
+    getNextSibling(current: Bubble): IFocusableNode | null;
+    /**
+     * Returns the previous peer node of the given bubble.
+     *
+     * @param current The bubble to find the preceding element of.
+     * @returns The previous navigable item on the bubble's icon's parent block.
+     */
+    getPreviousSibling(current: Bubble): IFocusableNode | null;
+    /**
+     * Returns the row ID of the given bubble.
+     *
+     * @param current The bubble to retrieve the row ID of.
+     * @returns The row ID of the given bubble.
+     */
+    getRowId(current: Bubble): string;
+    /**
+     * Returns whether or not the given bubble can be navigated to.
+     *
+     * @param current The instance to check for navigability.
+     * @returns True if the given bubble can be focused.
+     */
+    isNavigable(current: Bubble): boolean;
+    /**
+     * Returns whether the given object can be navigated from by this policy.
+     *
+     * @param current The object to check if this policy applies to.
+     * @returns True if the object is an Bubble.
+     */
+    isApplicable(current: any): current is Bubble;
+}
+//# sourceMappingURL=bubble_navigation_policy.d.ts.map

package/core/keyboard_nav/{comment_bar_button_navigation_policy.d.ts → navigation_policies/comment_bar_button_navigation_policy.d.ts}

@@ -3,9 +3,9 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { CommentBarButton } from '../comments/comment_bar_button.js';
-import type { IFocusableNode } from '../interfaces/i_focusable_node.js';
-import type { INavigationPolicy } from '../interfaces/i_navigation_policy.js';
+import { CommentBarButton } from '../../comments/comment_bar_button.js';
+import type { IFocusableNode } from '../../interfaces/i_focusable_node.js';
+import type { INavigationPolicy } from '../../interfaces/i_navigation_policy.js';
 /**
  * Set of rules controlling keyboard navigation from a CommentBarButton.
  */
@@ -38,6 +38,13 @@ export declare class CommentBarButtonNavigationPolicy implements INavigationPoli
      * @returns The CommentBarButton's previous CommentBarButton, if any.
      */
     getPreviousSibling(current: CommentBarButton): IFocusableNode | null;
+    /**
+     * Returns the row ID of the given CommentBarButton.
+     *
+     * @param current The CommentBarButton to retrieve the row ID of.
+     * @returns The row ID of the given CommentBarButton.
+     */
+    getRowId(current: CommentBarButton): string;
     /**
      * Returns whether or not the given CommentBarButton can be navigated to.
      *

package/core/keyboard_nav/{comment_editor_navigation_policy.d.ts → navigation_policies/comment_editor_navigation_policy.d.ts}

@@ -3,9 +3,9 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { CommentEditor } from '../comments/comment_editor.js';
-import type { IFocusableNode } from '../interfaces/i_focusable_node.js';
-import type { INavigationPolicy } from '../interfaces/i_navigation_policy.js';
+import { CommentEditor } from '../../comments/comment_editor.js';
+import type { IFocusableNode } from '../../interfaces/i_focusable_node.js';
+import type { INavigationPolicy } from '../../interfaces/i_navigation_policy.js';
 /**
  * Set of rules controlling keyboard navigation from a comment editor.
  * This is a no-op placeholder (other than isNavigable/isApplicable) since
@@ -16,6 +16,13 @@ export declare class CommentEditorNavigationPolicy implements INavigationPolicy<
     getParent(_current: CommentEditor): IFocusableNode | null;
     getNextSibling(_current: CommentEditor): IFocusableNode | null;
     getPreviousSibling(_current: CommentEditor): IFocusableNode | null;
+    /**
+     * Returns the row ID of the given comment editor.
+     *
+     * @param current The comment editor to retrieve the row ID of.
+     * @returns The row ID of the given comment editor.
+     */
+    getRowId(current: CommentEditor): string;
     /**
      * Returns whether or not the given comment editor can be navigated to.
      *

package/core/keyboard_nav/{connection_navigation_policy.d.ts → navigation_policies/connection_navigation_policy.d.ts}

@@ -3,26 +3,24 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import type { BlockSvg } from '../block_svg.js';
-import type { IFocusableNode } from '../interfaces/i_focusable_node.js';
-import type { INavigationPolicy } from '../interfaces/i_navigation_policy.js';
-import { RenderedConnection } from '../rendered_connection.js';
+import type { IFocusableNode } from '../../interfaces/i_focusable_node.js';
+import type { INavigationPolicy } from '../../interfaces/i_navigation_policy.js';
+import { RenderedConnection } from '../../rendered_connection.js';
 /**
  * Set of rules controlling keyboard navigation from a connection.
  */
 export declare class ConnectionNavigationPolicy implements INavigationPolicy<RenderedConnection> {
     /**
-     * Returns the first child of the given connection.
+     * Returns the first child of a connection.
      *
-     * @param current The connection to return the first child of.
-     * @returns The connection's first child element, or null if not none.
+     * @returns Null, as connections do not have children.
      */
-    getFirstChild(current: RenderedConnection): IFocusableNode | null;
+    getFirstChild(): IFocusableNode | null;
     /**
      * Returns the parent of the given connection.
      *
      * @param current The connection to return the parent of.
-     * @returns The given connection's parent connection or block.
+     * @returns The given connection's parent block.
      */
     getParent(current: RenderedConnection): IFocusableNode | null;
     /**
@@ -40,15 +38,12 @@ export declare class ConnectionNavigationPolicy implements INavigationPolicy<Ren
      */
     getPreviousSibling(current: RenderedConnection): IFocusableNode | null;
     /**
-     * Gets the parent connection on a block.
-     * This is either an output connection, previous connection or undefined.
-     * If both connections exist return the one that is actually connected
-     * to another block.
+     * Returns the row ID of the given connection.
      *
-     * @param block The block to find the parent connection on.
-     * @returns The connection connecting to the parent of the block.
+     * @param current The connection to retrieve the row ID of.
+     * @returns The row ID of the given connection.
      */
-    protected getParentConnection(block: BlockSvg): RenderedConnection;
+    getRowId(current: RenderedConnection): string;
     /**
      * Returns whether or not the given connection can be navigated to.
      *