@grafloria/element 0.4.30 → 0.4.32

package/src/lib/dashboard-kit/grid-binder.d.ts

@@ -188,6 +188,14 @@ export interface DashboardGridOptions {
      * command path, folding `displaced` into the same batch.
      */
     onDropIn?: (node: NodeModel, cell: CellRect, displaced: Command[]) => void | Promise<void>;
+    /**
+     * A member is about to LEAVE this board through a gesture (moved into
+     * another board, made a tab of its own). Answers the commands that follow
+     * it in the same batch — a tab page emptied by the move closes.
+     */
+    onMemberLeaving?: (memberId: string) => Command[];
+    /** A widget dragged over a tab STRIP becomes a new tab there: the hooks that hit-test, mark and commit it. */
+    tabDrop?: TabDropHooks;
     /** Fires after commits/cancels/removals so the page can refocus/refit/flash. */
     onGesture?: (e: {
         type: 'commit' | 'cancel' | 'remove' | 'drop-in';
@@ -500,6 +508,14 @@ interface BinderPeer {
      * it, so the strip can leave the press alone.
      */
     tearOutMember(pageId: string, fromGroupId: string, ev: PointerEvent, plan: TearOutPlan): boolean;
+    /**
+     * Drag member section `id` by a press that did not go through this board's
+     * tool (a tab container's strip is a DOM overlay): the board runs the move
+     * from the pointer sequence itself. Answers false when it cannot.
+     */
+    dragMember(id: string, ev: PointerEvent): boolean;
+    /** Start a MOVE of member section `id` from a press this board's tool routed here. */
+    beginSlabMove?(id: string, ev: ToolPointerEvent): boolean;
 }
 /**
  * What a torn-out page becomes, decided by the dashboard handle (which owns
@@ -538,9 +554,74 @@ export interface TearOutPlan {
         move: Command[];
         collapse: Command[];
     };
+    /**
+     * The tab containers the page may JOIN instead of forming a group of its
+     * own — VS Code's editor dragged from one group into another. Every one it
+     * may legally enter (not the container it left, none inside itself); the
+     * board hit-tests them against the pointer, and a release over one joins.
+     */
+    joinTargets: string[];
+    /** The tab index a release at this CLIENT point means for `targetId`: over the strip, between the tabs there; over the body, the end. */
+    dropIndex(targetId: string, clientX: number, clientY: number): number;
+    /** Paint (or, with null, clear) the insertion mark on `targetId`'s strip. */
+    markDrop(targetId: string | null, index: number | null): void;
+    /** The tab index a CLIENT point means along `targetId`'s strip — null when the point is not over that strip. */
+    stripIndex(targetId: string, clientX: number, clientY: number): number | null;
+    /** The commands that REORDER the page to `index` along its own strip. Empty when nothing changes. */
+    reorder(index: number): Command[];
+    /**
+     * The commands for joining `targetId` at `index`: the page becomes its tab
+     * — and the active one — and the container it left closes when it was the
+     * last page. No cell is taken on any board.
+     */
+    join(targetId: string, index: number, boardId: string): {
+        move: Command[];
+        collapse: Command[];
+    };
 }
 /** A torn-out page never arrives shorter than this: a strip with no room under it is not a group. */
 export declare const TEAR_OUT_MIN_ROWS = 2;
+/**
+ * Steps that depend on each other's RESULT — create a group, then move a page
+ * into it, then place the group on the board; or remove a member and then the
+ * group it emptied — run as one history step. A batch checks every member's
+ * `canExecute` before running any of them and every member's `canUndo` before
+ * undoing any, and a membership command's precondition (its group exists) is
+ * exactly what a neighbouring step creates or removes. This runs the chain in
+ * order and reverses it on undo, judging nothing up front.
+ */
+export declare class SequenceCommand extends Command {
+    private steps;
+    constructor(name: string, steps: Command[]);
+    execute(context: Parameters<Command['execute']>[0]): void;
+    undo(context: Parameters<Command['undo']>[0]): void;
+    canExecute(): boolean;
+    canUndo(): boolean;
+    serialize(): {
+        id: string;
+        name: string;
+        timestamp: number;
+        data: {
+            steps: import("@grafloria/engine").SerializedCommand[];
+        };
+    };
+}
+/**
+ * A WIDGET dropped on a tab strip becomes a new tab there (a tab dropped on
+ * one joins; a widget wraps into a page of its own first). The dashboard
+ * handle owns the strips and the registry; the binder owns the gesture.
+ */
+export interface TabDropHooks {
+    /** The strip under a CLIENT point, and the tab index that point means along it. */
+    stripAt(clientX: number, clientY: number): {
+        containerId: string;
+        index: number;
+    } | null;
+    /** Paint (or, with null, clear) the insertion mark on a strip. */
+    markDrop(containerId: string | null, index: number | null): void;
+    /** The commands that make `widgetId` a new tab of `containerId` at `index`; `displaced` are this board's survivors. Empty = refused. */
+    dropIntoStrip(widgetId: string, containerId: string, index: number, sourceBoardId: string, displaced: Command[]): Command[];
+}
 interface AdoptOptions {
     /**
      * 'shrink': take the cell under the pointer at the height that FITS there
@@ -559,6 +640,16 @@ interface AdoptedLeg {
         x: number;
         y: number;
     }): void;
+    /**
+     * Take the tile OFF the board while the pointer is somewhere the board is
+     * not the target (over a group the page will join instead); the tiles it
+     * displaced come home. `enter` puts it back at the pointer.
+     */
+    leave(): void;
+    enter(world: {
+        x: number;
+        y: number;
+    }): void;
     /** Undo the adoption: target board back to its pre-entry layout. */
     abort(): void;
     /**