@grafloria/element 0.4.31 → 0.4.33

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
@@ -549,6 +565,12 @@ export interface TearOutPlan {
     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 strip's height on `targetId`, px — the band above its body. */
+    stripHeight(targetId: string): number;
+    /** 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
@@ -561,6 +583,47 @@ export interface TearOutPlan {
 }
 /** 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
@@ -589,17 +652,34 @@ interface AdoptedLeg {
         x: number;
         y: number;
     }): void;
+    /** Put the tile at a PRESCRIBED cell (a split's half, a docking band): sized to it, unlocked tiles pushed. Answers whether it sits there. */
+    place(cell: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    }): boolean;
+    /** Every other tile's cell before the ghost entered — the layout a row insert translates. */
+    baseline(): Map<string, CellRect>;
     /** Undo the adoption: target board back to its pre-entry layout. */
     abort(): void;
     /**
      * Close the leg for commit: returns the target-side displaced commands, the
-     * tile's final cell and its projected rect. Null when the tile is somehow
-     * gone (treat as abort).
+     * tile's final cell and its projected rect — and the member GROUPS the
+     * adoption moved (the node commands skip groups; a dock that pushed sections
+     * commits them through these). Null when the tile is somehow gone.
      */
     finalize(): {
         commands: Command[];
         cell: CellRect;
         rect: WorldRect;
+        groups: Array<{
+            id: string;
+            cellBefore: CellRect;
+            cellAfter: CellRect;
+            frameBefore: WorldRect;
+            frameAfter: WorldRect;
+        }>;
     } | null;
 }
 /**