@cp949/phyx-blockly 12.5.1-p1 → 13.4.0-patch.1

package/core/connection_db.d.ts

@@ -15,6 +15,11 @@ export declare class ConnectionDB {
     private readonly connectionChecker;
     /** Array of connections sorted by y position in workspace units. */
     private readonly connections;
+    /**
+     * Count of how many times bulk updates have been enabled. When reaching 0,
+     * the connection DB will be resorted.
+     */
+    private bulkCounter;
     /**
      * @param connectionChecker The workspace's connection type checker, used to
      *     decide if connections are valid during a drag.
@@ -55,6 +60,17 @@ export declare class ConnectionDB {
      * @throws {Error} If the connection cannot be found in the database.
      */
     removeConnection(connection: RenderedConnection, yPos: number): void;
+    /**
+     * Moves the given connection in the connection DB to reflect its new Y
+     * position. For performance, this will be deferred if the connection DB is in
+     * the middle of a bulk update.
+     *
+     * @param connection The connection that is moving. Should be provided before
+     *     its `Connection.y` field has been updated.
+     * @param newYPos The y coordinate (in workspace units) to which the
+     *     connection will move.
+     */
+    reorderConnection(connection: RenderedConnection, newYPos: number): void;
     /**
      * Find all nearby connections to the given connection.
      * Type checking does not apply, since this function is used for bumping.
@@ -88,6 +104,30 @@ export declare class ConnectionDB {
         connection: RenderedConnection | null;
         radius: number;
     };
+    /**
+     * Notifies the connection DB that a series of connection moves is about to
+     * begin. May be called multiple times, and must be paired with a
+     * corresponding call to `endBulkUpdates()`.
+     *
+     * @internal
+     */
+    beginBulkUpdates(): void;
+    /**
+     * Notifies the connection DB that the most recent bulk series of connection
+     * moves has ended. Must be called after the corresponding
+     * `beginBulkUpdates()`. If all in-flight bulk updates have ended, this method
+     * will reorder the connection DB to reflect the current state of the
+     * connections.
+     *
+     * @internal
+     */
+    endBulkUpdates(): void;
+    /**
+     * Sorts the connections in the connection DB to reflect the current
+     * coordinates of the connections to allow for quick and correct connection
+     * lookups. Run automatically when a bulk update finishes.
+     */
+    private reorderConnections;
     /**
      * Initialize a set of connection DBs for a workspace.
      *

package/core/contextmenu_registry.d.ts

@@ -9,9 +9,9 @@
  * @class
  */
 import type { BlockSvg } from './block_svg.js';
-import { RenderedWorkspaceComment } from './comments/rendered_workspace_comment.js';
+import type { RenderedWorkspaceComment } from './comments/rendered_workspace_comment.js';
 import type { IFocusableNode } from './interfaces/i_focusable_node.js';
-import { Coordinate } from './utils/coordinate.js';
+import type { Coordinate } from './utils/coordinate.js';
 import type { WorkspaceSvg } from './workspace_svg.js';
 /**
  * Class for the registry of context menu items. This is intended to be a
@@ -103,6 +103,13 @@ export declare namespace ContextMenuRegistry {
         displayText: ((p1: Scope) => string | HTMLElement) | string | HTMLElement;
         separator?: never;
         preconditionFn: (p1: Scope, menuOpenEvent: Event) => string;
+        /**
+         * Identifier used to associate this context menu item with a keyboard
+         * shortcut  which will be displayed in the menu as a hint. Should
+         * correspond to the name under which a keyboard shortcut that performs the
+         * same action as this menu item is registered.
+         */
+        associatedKeyboardShortcut?: string;
     }
     /**
      * A representation of a menu separator item in the registry.
@@ -120,8 +127,10 @@ export declare namespace ContextMenuRegistry {
      * Fields common to all context menu items as used by contextmenu.ts.
      */
     export interface CoreContextMenuOption {
+        id: string;
         scope: Scope;
         weight: number;
+        associatedKeyboardShortcut?: string;
     }
     /**
      * A representation of a normal, clickable menu item in contextmenu.ts.
@@ -170,4 +179,5 @@ export type Scope = ContextMenuRegistry.Scope;
 export type RegistryItem = ContextMenuRegistry.RegistryItem;
 export type ContextMenuOption = ContextMenuRegistry.ContextMenuOption;
 export type LegacyContextMenuOption = ContextMenuRegistry.LegacyContextMenuOption;
+export type ActionContextMenuOption = ContextMenuRegistry.ActionContextMenuOption;
 //# sourceMappingURL=contextmenu_registry.d.ts.map

package/core/css.d.ts

@@ -17,9 +17,10 @@ export declare function register(cssContent: string): void;
  * b) It speeds up loading by not blocking on a separate HTTP transfer.
  * c) The CSS content may be made dynamic depending on init options.
  *
+ * @param container The div or other HTML element into which Blockly was injected.
  * @param hasCss If false, don't inject CSS (providing CSS becomes the
  *     document's responsibility).
  * @param pathToMedia Path from page to the Blockly media directory.
  */
-export declare function inject(hasCss: boolean, pathToMedia: string): void;
+export declare function inject(container: HTMLElement, hasCss: boolean, pathToMedia: string): void;
 //# sourceMappingURL=css.d.ts.map

package/core/dragging/block_drag_strategy.d.ts

@@ -3,12 +3,37 @@
  * Copyright 2024 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { BlockSvg } from '../block_svg.js';
-import { IDragStrategy } from '../interfaces/i_draggable.js';
+import type { BlockSvg } from '../block_svg.js';
+import type { IConnectionPreviewer } from '../interfaces/i_connection_previewer.js';
+import type { IDragStrategy } from '../interfaces/i_draggable.js';
+import { DragDisposition } from '../interfaces/i_draggable.js';
+import type { RenderedConnection } from '../rendered_connection.js';
 import { Coordinate } from '../utils.js';
+import type { WorkspaceSvg } from '../workspace_svg.js';
+/** Represents a valid pair of connections between the dragging block and a block on the workspace. */
+interface ConnectionPair {
+    /** A connection on the dragging stack that is compatible with neighbour. */
+    local: RenderedConnection;
+    /** A nearby connection that is compatible with local. */
+    neighbour: RenderedConnection;
+}
+/** Represents a nearby valid connection. */
+interface ConnectionCandidate extends ConnectionPair {
+    /** The distance between the local connection and the neighbour connection. */
+    distance: number;
+}
+/**
+ * Represents a block movement paradigm; constrained moves only to valid
+ * connections, while unconstrained allows free movement to anywhere on the
+ * workspace.
+ */
+declare enum MoveMode {
+    CONSTRAINED = 1,
+    UNCONSTRAINED = 2
+}
 export declare class BlockDragStrategy implements IDragStrategy {
-    private block;
-    private workspace;
+    protected block: BlockSvg;
+    protected workspace: WorkspaceSvg;
     /** The parent block at the start of the drag. */
     private startParentConn;
     /**
@@ -16,25 +41,76 @@ export declare class BlockDragStrategy implements IDragStrategy {
      * `healStack` is true.
      */
     private startChildConn;
-    private startLoc;
+    protected startLoc: Coordinate | null;
     private connectionCandidate;
-    private connectionPreviewer;
+    protected connectionPreviewer: IConnectionPreviewer | null;
     private dragging;
-    /**
-     * If this is a shadow block, the offset between this block and the parent
-     * block, to add to the drag location. In workspace units.
-     */
-    private dragOffset;
+    /** List of all connections available on the workspace. */
+    private allConnectionPairs;
+    /** The current movement mode. */
+    protected moveMode: MoveMode;
     /** Used to persist an event group when snapping is done async. */
     private originalEventGroup;
+    /**
+     * Half of the connection of the last announced candidate, or null if that
+     * announcement was for the workspace. Undefined if nothing has been
+     * announced yet this drag.
+     */
+    private lastAnnouncedLocal;
+    private lastAnnouncedNeighbour;
+    /**
+     * Map from block IDs to reason(s) why it was disabled, used to restore
+     * disabled state post-drag.
+     */
+    private lastBlockDisabledReasons;
+    protected readonly BLOCK_CONNECTION_OFFSET = 10;
+    /**
+     * How far in from the edges of the workspace to position newly placed blocks.
+     */
+    protected readonly WORKSPACE_MARGIN = 10;
     constructor(block: BlockSvg);
     /** Returns true if the block is currently movable. False otherwise. */
     isMovable(): boolean;
+    /**
+     * Positions a cloned block on its new workspace.
+     *
+     * @param oldBlock The flyout block that was cloned.
+     * @param newBlock The new block to position.
+     */
+    protected positionNewBlock(oldBlock: BlockSvg, newBlock: BlockSvg): void;
+    /**
+     * Returns the block to use for the current drag operation. This may create
+     * and return a newly instantiated block when e.g. dragging from a flyout.
+     */
+    protected getTargetBlock(): BlockSvg;
+    /**
+     * Announces a move on the ARIA live region for assistive technologies.
+     *
+     * @param isMoveStart Whether this announcement is for the start of a move. If false,
+     * skip announcing the block label since it should have already been announced at the
+     * start of the move.
+     */
+    private announceMove;
+    /**
+     * Checks if there are multiple compatible connections for the specified side of the pair.
+     *
+     * @param forLocal Whether we are considering the local or neighbour side of the pair
+     * @returns True if there are multiple compatible connections, false otherwise
+     */
+    private hasMultipleCompatibleConnections;
     /**
      * Handles any setup for starting the drag, including disconnecting the block
      * from any parent blocks.
      */
-    startDrag(e?: PointerEvent): void;
+    startDrag(e?: PointerEvent | KeyboardEvent): import("../blockly.js").IDraggable;
+    /**
+     * Caches a list of all valid connection pairs between the dragging block
+     * and any other blocks on the workspace. This is used to determine the
+     * closest valid connection during keyboard-driven moves and to determine
+     * the need to disambiguate between multiple compatible connections when
+     * announcing moves to assistive technologies.
+     */
+    cacheAllConnectionPairs(): void;
     /**
      * Returns an array of visible bubbles attached to the given block or its
      * descendants.
@@ -47,20 +123,18 @@ export declare class BlockDragStrategy implements IDragStrategy {
     /**
      * Get whether the drag should act on a single block or a block stack.
      *
-     * @param e The instigating pointer event, if any.
+     * @param e The instigating pointer or keyboard event, if any.
      * @returns True if just the initial block should be dragged out, false
      *     if all following blocks should also be dragged.
      */
-    protected shouldHealStack(e: PointerEvent | undefined): boolean;
-    /** Starts a drag on a shadow, recording the drag offset. */
-    private startDraggingShadow;
+    protected shouldHealStack(e: PointerEvent | KeyboardEvent | undefined): boolean;
     /**
      * Whether or not we should disconnect the block when a drag is started.
      *
      * @param healStack Whether or not to heal the stack after disconnecting.
      * @returns True to disconnect the block, false otherwise.
      */
-    private shouldDisconnect;
+    protected shouldDisconnect(healStack: boolean): boolean;
     /**
      * Disconnects the block from any parents. If `healStack` is true and this is
      * a stack block, we also disconnect from any next blocks and attempt to
@@ -69,6 +143,12 @@ export declare class BlockDragStrategy implements IDragStrategy {
      * @param healStack Whether or not to heal the stack after disconnecting.
      */
     private disconnectBlock;
+    /**
+     * Stores the dragging block's current parent or child connection before
+     * unplugging. This allows us to revert the drag cleanly. In keyboard move mode,
+     * the initial connection pair is also used as the first connection candidate.
+     */
+    private storeInitialConnections;
     /** Fire a UI event at the start of a block drag. */
     private fireDragStartEvent;
     /** Fire a UI event at the end of a block drag. */
@@ -76,11 +156,24 @@ export declare class BlockDragStrategy implements IDragStrategy {
     /** Fire a move event at the end of a block drag. */
     private fireMoveEvent;
     /** Moves the block and updates any connection previews. */
-    drag(newLoc: Coordinate): void;
+    drag(newLoc: Coordinate, e?: PointerEvent | KeyboardEvent): void;
     /**
+     * Determines the offset to apply to the dragged block's position
+     * based on the current connection candidate.
+     *
+     * @returns coordinates representing the offset
+     */
+    private determineConnectionOffset;
+    /**
+     * Renders the connection preview indicator.
+     *
      * @param draggingBlock The block being dragged.
      * @param delta How far the pointer has moved from the position
      *     at the start of the drag, in workspace units.
+     * @param initialCandidate If provided, a connection candidate that the
+     *     connection preview indicator will be attached to.
+     * @returns The neighbouring connection to which the connection preview will
+     *     be attached.
      */
     private updateConnectionPreview;
     /**
@@ -101,6 +194,14 @@ export declare class BlockDragStrategy implements IDragStrategy {
      * compatible type (input, output, etc) and connection check.
      */
     private getConnectionCandidate;
+    /**
+     * Returns the closest connection candidate for the given block.
+     *
+     * @param block The block to find a connection for.
+     * @param delta The distance the block has traveled since dragging began.
+     * @returns The closest available connection candidate, if any.
+     */
+    private getClosestCandidate;
     /**
      * Get the radius to use when searching for a nearby valid connection.
      */
@@ -116,7 +217,7 @@ export declare class BlockDragStrategy implements IDragStrategy {
      * Cleans up any state at the end of the drag. Applies any pending
      * connections.
      */
-    endDrag(e?: PointerEvent): void;
+    endDrag(_e: PointerEvent | KeyboardEvent | undefined, disposition: DragDisposition): void;
     /** Disposes of any state at the end of the drag. */
     private disposeStep;
     /** Connects the given candidate connections. */
@@ -126,5 +227,81 @@ export declare class BlockDragStrategy implements IDragStrategy {
      * including reconnecting connections.
      */
     revertDrag(): void;
+    /**
+     * Get the nearest valid candidate connection in traversal order.
+     *
+     * @param delta The distance the block has moved since this drag began.
+     * @returns A candidate connection and radius, or null if none was found.
+     */
+    findTraversalCandidate(delta: Coordinate): ConnectionCandidate | null;
+    /**
+     * Returns whether or not the given block is at a terminal position (start or
+     * end) of the blocks on the workspace. This helps distinguish between a block
+     * that is at the end of the line because all valid connections have been
+     * visited and the proposed constrained move destination is now to drop it on
+     * the workspace as a top-level block (in which case it will be in a terminal
+     * position), and a block that just entered move mode as a top-level block,
+     * and should therefore still be able to move to another connection point
+     * even if looping is disabled.
+     *
+     * @param block The block to check.
+     * @param direction The current dragging direction.
+     * @returns True if the block is at the start or end of its possible positions
+     *     on the workspace.
+     */
+    private isInTerminalPosition;
+    /**
+     * Converts a connection pair to a connection candidate with a default
+     * distance of 0.
+     */
+    private pairToCandidate;
+    /**
+     * Returns the cardinal direction that the block being dragged would have to
+     * move in to reach the given location.
+     * The given coordinate should differ from the current location on only one
+     * axis.
+     *
+     * @param newLocation The intended destination for the block.
+     * @returns The direction the block would need to travel to reach the new
+     *     location.
+     */
+    private getDirectionToNewLocation;
+    /**
+     * Returns all navigable connections on the given block and its children.
+     * Omits connections on shadow blocks, collapsed blocks, or those that are
+     * associated with a hidden input.
+     *
+     * @param block The block to use as a starting point for retrieving
+     *     connections.
+     * @returns All connections on the block and its children.
+     */
+    private getAllConnections;
+    /**
+     * Returns a connection candidate to move the dragged block to at the start of
+     * a drag. If the passively focused node is a connection and the dragged block
+     * can connect to it, the connection will be returned. Otherwise, the first
+     * compatible connection on the passively focused node's block, if any, will
+     * be returned. Returns null if the workspace does not have passive focus.
+     */
+    private getInitialCandidate;
+    /**
+     * Updates the current move mode based on the most recent drag-related event.
+     */
+    private updateMoveMode;
+    /**
+     * Enables the given block and its children.
+     * Stores the reasons each block was disabled so they can be restored.
+     *
+     * @param block The block to enable.
+     */
+    private enableAllDraggedBlocks;
+    /**
+     * Re-disables the given block and its children using their original
+     * disabled reasons.
+     *
+     * @param block The block to re-disable, if applicable.
+     */
+    private redisableAllDraggedBlocks;
 }
+export {};
 //# sourceMappingURL=block_drag_strategy.d.ts.map

package/core/dragging/bubble_drag_strategy.d.ts

@@ -3,16 +3,17 @@
  * Copyright 2024 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { IBubble, WorkspaceSvg } from '../blockly.js';
-import { IDragStrategy } from '../interfaces/i_draggable.js';
-import { Coordinate } from '../utils.js';
+import type { IBubble } from '../interfaces/i_bubble.js';
+import type { IDragStrategy } from '../interfaces/i_draggable.js';
+import type { Coordinate } from '../utils.js';
+import type { WorkspaceSvg } from '../workspace_svg.js';
 export declare class BubbleDragStrategy implements IDragStrategy {
     private bubble;
     private workspace;
     private startLoc;
     constructor(bubble: IBubble, workspace: WorkspaceSvg);
     isMovable(): boolean;
-    startDrag(): void;
+    startDrag(): IBubble;
     drag(newLoc: Coordinate): void;
     endDrag(): void;
     revertDrag(): void;

package/core/dragging/comment_drag_strategy.d.ts

@@ -3,16 +3,16 @@
  * Copyright 2024 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { RenderedWorkspaceComment } from '../comments.js';
-import { IDragStrategy } from '../interfaces/i_draggable.js';
-import { Coordinate } from '../utils.js';
+import type { RenderedWorkspaceComment } from '../comments.js';
+import type { IDragStrategy } from '../interfaces/i_draggable.js';
+import type { Coordinate } from '../utils.js';
 export declare class CommentDragStrategy implements IDragStrategy {
     private comment;
     private startLoc;
     private workspace;
     constructor(comment: RenderedWorkspaceComment);
     isMovable(): boolean;
-    startDrag(): void;
+    startDrag(): RenderedWorkspaceComment;
     drag(newLoc: Coordinate): void;
     endDrag(): void;
     /** Fire a UI event at the start of a comment drag. */

package/core/dragging/dragger.d.ts

@@ -3,29 +3,28 @@
  * Copyright 2024 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { IDeletable } from '../interfaces/i_deletable.js';
-import { IDragTarget } from '../interfaces/i_drag_target.js';
-import { IDraggable } from '../interfaces/i_draggable.js';
-import { IDragger } from '../interfaces/i_dragger.js';
+import type { IDeletable } from '../interfaces/i_deletable.js';
+import type { IDragTarget } from '../interfaces/i_drag_target.js';
+import { type IDraggable } from '../interfaces/i_draggable.js';
+import type { IDragger } from '../interfaces/i_dragger.js';
 import { Coordinate } from '../utils/coordinate.js';
-import { WorkspaceSvg } from '../workspace_svg.js';
 export declare class Dragger implements IDragger {
     protected draggable: IDraggable;
-    protected workspace: WorkspaceSvg;
     protected startLoc: Coordinate;
     protected dragTarget: IDragTarget | null;
-    constructor(draggable: IDraggable, workspace: WorkspaceSvg);
+    protected revertShouldDelete: boolean;
+    constructor(draggable: IDraggable);
     /** Handles any drag startup. */
-    onDragStart(e: PointerEvent): void;
+    onDragStart(e?: PointerEvent | KeyboardEvent): IDraggable;
     /**
      * Handles calculating where the element should actually be moved to.
      *
      * @param totalDelta The total amount in pixel coordinates the mouse has moved
      *     since the start of the drag.
      */
-    onDrag(e: PointerEvent, totalDelta: Coordinate): void;
+    onDrag(e: PointerEvent | KeyboardEvent | undefined, totalDelta: Coordinate): void;
     /** Updates the drag target under the pointer (if there is one). */
-    protected updateDragTarget(e: PointerEvent): void;
+    protected updateDragTarget(coordinate: Coordinate): void;
     /**
      * Calculates the correct workspace coordinate for the movable and tells
      * the draggable to go to that location.
@@ -35,15 +34,16 @@ export declare class Dragger implements IDragger {
      * Returns true if we would delete the draggable if it was dropped
      * at the current location.
      */
-    protected wouldDeleteDraggable(e: PointerEvent, rootDraggable: IDraggable & IDeletable): boolean;
+    protected wouldDeleteDraggable(coordinate: Coordinate, rootDraggable: IDraggable & IDeletable): boolean;
     /** Handles any drag cleanup. */
-    onDragEnd(e: PointerEvent): void;
-    private getRoot;
+    onDragEnd(e?: PointerEvent | KeyboardEvent): void;
+    /** Handles a drag being reverted. */
+    onDragRevert(e?: PointerEvent | KeyboardEvent): void;
     /**
      * Returns true if we should return the draggable to its original location
      * at the end of the drag.
      */
-    protected shouldReturnToStart(e: PointerEvent, rootDraggable: IDraggable): boolean;
+    protected shouldReturnToStart(coordinate: Coordinate, rootDraggable: IDraggable): boolean;
     protected pixelsToWorkspaceUnits(pixelCoord: Coordinate): Coordinate;
 }
 //# sourceMappingURL=dragger.d.ts.map

package/core/events/events_block_base.d.ts

@@ -10,7 +10,8 @@
  */
 import type { Block } from '../block.js';
 import type { Workspace } from '../workspace.js';
-import { Abstract as AbstractEvent, AbstractEventJson } from './events_abstract.js';
+import type { AbstractEventJson } from './events_abstract.js';
+import { Abstract as AbstractEvent } from './events_abstract.js';
 /**
  * Abstract class for any event related to blocks.
  */

package/core/events/events_block_change.d.ts

@@ -10,8 +10,9 @@
  */
 import type { Block } from '../block.js';
 import type { BlockSvg } from '../block_svg.js';
-import { Workspace } from '../workspace.js';
-import { BlockBase, BlockBaseJson } from './events_block_base.js';
+import type { Workspace } from '../workspace.js';
+import type { BlockBaseJson } from './events_block_base.js';
+import { BlockBase } from './events_block_base.js';
 import { EventType } from './type.js';
 /**
  * Notifies listeners when some element of a block has changed (e.g.

package/core/events/events_block_create.d.ts

@@ -10,8 +10,9 @@
  */
 import type { Block } from '../block.js';
 import * as blocks from '../serialization/blocks.js';
-import { Workspace } from '../workspace.js';
-import { BlockBase, BlockBaseJson } from './events_block_base.js';
+import type { Workspace } from '../workspace.js';
+import type { BlockBaseJson } from './events_block_base.js';
+import { BlockBase } from './events_block_base.js';
 import { EventType } from './type.js';
 /**
  * Notifies listeners when a block (or connected stack of blocks) is
@@ -19,8 +20,6 @@ import { EventType } from './type.js';
  */
 export declare class BlockCreate extends BlockBase {
     type: EventType;
-    /** The XML representation of the created block(s). */
-    xml?: Element | DocumentFragment;
     /** The JSON respresentation of the created block(s). */
     json?: blocks.State;
     /** All of the IDs of created blocks. */
@@ -51,7 +50,6 @@ export declare class BlockCreate extends BlockBase {
     run(forward: boolean): void;
 }
 export interface BlockCreateJson extends BlockBaseJson {
-    xml: string;
     ids: string[];
     json: object;
     recordUndo?: boolean;

package/core/events/events_block_delete.d.ts

@@ -10,16 +10,15 @@
  */
 import type { Block } from '../block.js';
 import * as blocks from '../serialization/blocks.js';
-import { Workspace } from '../workspace.js';
-import { BlockBase, BlockBaseJson } from './events_block_base.js';
+import type { Workspace } from '../workspace.js';
+import type { BlockBaseJson } from './events_block_base.js';
+import { BlockBase } from './events_block_base.js';
 import { EventType } from './type.js';
 /**
  * Notifies listeners when a block (or connected stack of blocks) is
  * deleted.
  */
 export declare class BlockDelete extends BlockBase {
-    /** The XML representation of the deleted block(s). */
-    oldXml?: Element | DocumentFragment;
     /** The JSON respresentation of the deleted block(s). */
     oldJson?: blocks.State;
     /** All of the IDs of deleted blocks. */
@@ -53,7 +52,6 @@ export declare class BlockDelete extends BlockBase {
     run(forward: boolean): void;
 }
 export interface BlockDeleteJson extends BlockBaseJson {
-    oldXml: string;
     ids: string[];
     wasShadow: boolean;
     oldJson: blocks.State;

package/core/events/events_block_drag.d.ts

@@ -9,8 +9,8 @@
  * @class
  */
 import type { Block } from '../block.js';
-import { Workspace } from '../workspace.js';
-import { AbstractEventJson } from './events_abstract.js';
+import type { Workspace } from '../workspace.js';
+import type { AbstractEventJson } from './events_abstract.js';
 import { UiBase } from './events_ui_base.js';
 import { EventType } from './type.js';
 /**

package/core/events/events_block_field_intermediate_change.d.ts

@@ -10,8 +10,9 @@
  * @class
  */
 import type { Block } from '../block.js';
-import { Workspace } from '../workspace.js';
-import { BlockBase, BlockBaseJson } from './events_block_base.js';
+import type { Workspace } from '../workspace.js';
+import type { BlockBaseJson } from './events_block_base.js';
+import { BlockBase } from './events_block_base.js';
 import { EventType } from './type.js';
 /**
  * Notifies listeners when the value of a block's field has changed but the

package/core/events/events_block_move.d.ts

@@ -11,7 +11,8 @@
 import type { Block } from '../block.js';
 import { Coordinate } from '../utils/coordinate.js';
 import type { Workspace } from '../workspace.js';
-import { BlockBase, BlockBaseJson } from './events_block_base.js';
+import type { BlockBaseJson } from './events_block_base.js';
+import { BlockBase } from './events_block_base.js';
 import { EventType } from './type.js';
 /**
  * Notifies listeners when a block is moved. This could be from one

package/core/events/events_click.d.ts

@@ -9,8 +9,8 @@
  * @class
  */
 import type { Block } from '../block.js';
-import { Workspace } from '../workspace.js';
-import { AbstractEventJson } from './events_abstract.js';
+import type { Workspace } from '../workspace.js';
+import type { AbstractEventJson } from './events_abstract.js';
 import { UiBase } from './events_ui_base.js';
 import { EventType } from './type.js';
 /**

package/core/events/events_comment_base.d.ts

@@ -10,7 +10,8 @@
  */
 import type { WorkspaceComment } from '../comments/workspace_comment.js';
 import type { Workspace } from '../workspace.js';
-import { Abstract as AbstractEvent, AbstractEventJson } from './events_abstract.js';
+import type { AbstractEventJson } from './events_abstract.js';
+import { Abstract as AbstractEvent } from './events_abstract.js';
 import type { CommentCreate } from './events_comment_create.js';
 import type { CommentDelete } from './events_comment_delete.js';
 /**