@grafloria/element 0.4.70 → 0.4.71

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grafloria/element",
-  "version": "0.4.70",
+  "version": "0.4.71",
   "type": "module",
   "main": "./src/index.js",
   "types": "./src/index.d.ts",

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

@@ -472,6 +472,13 @@ interface BinderPeer {
         cellAfter?: CellRect;
         frameBefore?: WorldRect;
         frameAfter?: WorldRect;
+        /**
+         * The parent's OWN commit for the growth so far, when a cell command
+         * cannot carry it — a SPLIT parent's tree with the pane's new share
+         * (0.4.71). Supersedes what an earlier ask answered; the arriving
+         * board's `finalize` carries it instead of a `SetGroupCellCommand`.
+         */
+        commands?: Command[];
     };
     containsWorld(x: number, y: number): boolean;
     /**

package/src/lib/dashboard-kit/grid-binder.js

@@ -2508,6 +2508,7 @@ export function bindDashboardGrid(api, group, options = {}) {
             let rowsAdded = 0;
             let firstBefore = null;
             let lastAfter = null;
+            let parentCommands;
             // At most the tile's own height in rows: past that the board is not
             // "full", it is smaller than the thing being dropped into it.
             for (let i = 0; parent && !entered && i < Math.max(1, span.h); i++) {
@@ -2517,11 +2518,13 @@ export function bindDashboardGrid(api, group, options = {}) {
                 rowsAdded += 1;
                 firstBefore = firstBefore !== null && firstBefore !== void 0 ? firstBefore : { cell: res.cellBefore, frame: res.frameBefore };
                 lastAfter = { cell: res.cellAfter, frame: res.frameAfter };
+                if (res.commands)
+                    parentCommands = res.commands; // the latest ask's answer carries every row so far
                 setLiveBound((maxRows !== null && maxRows !== void 0 ? maxRows : 0) + 1);
                 entered = engine.add({ id: node.id, x: 0, y: engine.rows(), w: span.w, h: span.h });
             }
             if (parent && rowsAdded > 0 && firstBefore && lastAfter) {
-                grown = { peer: parent, rows: rowsAdded, cellBefore: firstBefore.cell, frameBefore: firstBefore.frame, cellAfter: lastAfter.cell, frameAfter: lastAfter.frame };
+                grown = Object.assign({ peer: parent, rows: rowsAdded, cellBefore: firstBefore.cell, frameBefore: firstBefore.frame, cellAfter: lastAfter.cell, frameAfter: lastAfter.frame }, (parentCommands ? { commands: parentCommands } : {}));
             }
         }
         if (!entered) {
@@ -2663,6 +2666,7 @@ export function bindDashboardGrid(api, group, options = {}) {
                 syncPlaceholder();
             },
             finalize: () => {
+                var _a;
                 endBeside(false); // the shift stays: the deltas below carry it
                 const item = engine.getItem(node.id);
                 if (!item) {
@@ -2678,7 +2682,8 @@ export function bindDashboardGrid(api, group, options = {}) {
                 const commands = tileCommands(deltasSince(startCells, startGeom, node.id));
                 // …and the rows this board took from its parent to hold the arrival (D4).
                 if (grown) {
-                    commands.push(new SetGroupCellCommand(group.id, grown.cellBefore, grown.cellAfter, grown.frameBefore, grown.frameAfter));
+                    // A grid parent's rows are the section's cell; a split parent's are its tree (0.4.71).
+                    commands.push(...((_a = grown.commands) !== null && _a !== void 0 ? _a : [new SetGroupCellCommand(group.id, grown.cellBefore, grown.cellAfter, grown.frameBefore, grown.frameAfter)]));
                     grown = null;
                 }
                 engine.endGesture();

package/src/lib/dashboard-kit/split-binder.js

@@ -30,7 +30,7 @@ import { anyEdge, clearOtherSelections, clientPerWorldOf, dragHandleSelector, gr
 import { buildCommitCommands, cellFromGridItem } from './grid-mapping.js';
 import { SequenceCommand } from './commit.js';
 import { TAB_STRIP_HEIGHT } from './tabs.js';
-import { addSplitLeaf, cellsFromSplit, cloneSplit, dividersOf, groupRectsOf, insertSplitLeaf, moveSplitDivider, normalizeSplit, pathToLeaf, projectSplit, removeSplitLeaf, splitFromCells, splitLeaves, } from './split-layout.js';
+import { addSplitLeaf, cellsFromSplit, cloneSplit, dividersOf, groupRectsOf, insertSplitLeaf, isSplitGroup, moveSplitDivider, nodeAt, normalizeSplit, pathToLeaf, projectSplit, removeSplitLeaf, splitFromCells, splitLeaves, } from './split-layout.js';
 import { ensureDashboardKitStyles } from './styles.js';
 import { captionKey, captionOfGroup, captionPainted, paintCaptionBand, sectionCaptionReserve, sizeCaptionBand } from './caption.js';
 /** Group metadata key the tree persists under. */
@@ -243,8 +243,8 @@ export function bindDashboardSplit(api, group, options = {}) {
         if (grp)
             diagram.runSystemWrite(() => grp.setFrame(Object.assign({}, r)));
     };
-    /** The tree currently PAINTED — the gesture's live tree while one runs. */
-    const paintedTree = () => ((gesture === null || gesture === void 0 ? void 0 : gesture.started) ? gesture.liveTree : readTree());
+    /** The tree currently PAINTED — the gesture's live tree while one runs, else a pane grown for an arriving tile (0.4.71), else the persisted one. */
+    const paintedTree = () => { var _a; return ((gesture === null || gesture === void 0 ? void 0 : gesture.started) ? gesture.liveTree : ((_a = grown === null || grown === void 0 ? void 0 : grown.tree) !== null && _a !== void 0 ? _a : readTree())); };
     const project = (tree = paintedTree()) => {
         const rects = rectsOf(tree);
         for (const [id, r] of rects) {
@@ -729,6 +729,104 @@ export function bindDashboardSplit(api, group, options = {}) {
             },
         };
     };
+    // -- D4 on a split board (0.4.71): a section pane GROWS for a tile arriving by hand ------
+    /**
+     * The rows a nested GROW board asks its parent for (the grid binder's D4
+     * loop, one at a time). Measured live on 0.4.70: the fluid demo's
+     * Operations section refused a widget in split mode and the line beside it
+     * answered — a pane could not ask for rows. A pane's height is a share of
+     * its COLUMN, so the row comes from the divider above or below it: the
+     * pane's subtree in the nearest column ancestor grows by one row's pixels
+     * and that sibling gives them (never below the divider's floor — then the
+     * ask is refused, as a full grid parent refuses). The grown tree is painted
+     * live, so the section's frame follows and its board can take the tile;
+     * the commit is this board's own tree command, handed back for the
+     * arriving board's `finalize` to carry; a negative ask gives the rows
+     * back, and at zero the persisted tree paints again, exactly.
+     */
+    let grown = null;
+    class GrownTreeCommand extends SetSplitTreeCommand {
+        execute(context) {
+            super.execute(context);
+            grown = null;
+            if (!disposed)
+                project(readTree());
+            api.render();
+        }
+        undo(context) {
+            super.undo(context);
+            grown = null;
+            if (!disposed)
+                project(readTree());
+            api.render();
+        }
+    }
+    const resizePaneBy = (id, dRows) => {
+        var _a;
+        if (disposed || isStatic || !Number.isFinite(dRows) || dRows === 0)
+            return { changed: false };
+        const base = (grown === null || grown === void 0 ? void 0 : grown.id) === id ? grown.base : readTree();
+        if (!base)
+            return { changed: false };
+        const rowsNow = (grown === null || grown === void 0 ? void 0 : grown.id) === id ? grown.rows : 0;
+        const rowsNext = rowsNow + dRows;
+        const paintFor = (tree) => {
+            project(tree !== null && tree !== void 0 ? tree : readTree());
+            api.render();
+        };
+        const frameOf = (tree) => rectsOf(tree).get(id);
+        const cellOf = (tree) => cellsFromSplit(tree, columns, rowsGuess()).get(id);
+        if (rowsNext <= 0) {
+            // every row given back: the persisted tree, exactly
+            const before = (_a = grown === null || grown === void 0 ? void 0 : grown.tree) !== null && _a !== void 0 ? _a : base;
+            grown = null;
+            paintFor(null);
+            const fb = frameOf(before);
+            const fa = frameOf(base);
+            const cb = cellOf(before);
+            const ca = cellOf(base);
+            return rowsNow > 0 && fb && fa && cb && ca ? { changed: true, cellBefore: cb, cellAfter: ca, frameBefore: fb, frameAfter: fa } : { changed: false };
+        }
+        const path = pathToLeaf(base, id);
+        if (!path)
+            return { changed: false };
+        // the nearest COLUMN ancestor: the pane's subtree there is what grows
+        let groupPath = null;
+        let childIndex = -1;
+        for (let depth = path.length - 1; depth >= 0 && !groupPath; depth--) {
+            const gp = path.slice(0, depth);
+            const g = nodeAt(base, gp);
+            if (isSplitGroup(g) && g.dir === 'column' && g.children.length > 1) {
+                groupPath = gp;
+                childIndex = path[depth];
+            }
+        }
+        if (!groupPath)
+            return { changed: false }; // the pane already spans the board's height: nobody to take a row from
+        const group0 = nodeAt(base, groupPath);
+        if (!isSplitGroup(group0))
+            return { changed: false };
+        const key = groupPath.join('/');
+        const divider = dividersOf(base, frame(), gap, padding, rtl).find((d) => d.path.join('/') === key);
+        if (!divider || divider.length <= 0)
+            return { changed: false };
+        const px = rowsNext * (baseRowHeight + gap);
+        const fraction = px / divider.length;
+        const last = childIndex === group0.children.length - 1;
+        const tree = moveSplitDivider(base, groupPath, last ? childIndex - 1 : childIndex, last ? -fraction : fraction);
+        const fb = frameOf((grown === null || grown === void 0 ? void 0 : grown.id) === id ? grown.tree : base);
+        const f0 = frameOf(base);
+        const fa = frameOf(tree);
+        const cb = cellOf((grown === null || grown === void 0 ? void 0 : grown.id) === id ? grown.tree : base);
+        const ca = cellOf(tree);
+        if (!fb || !f0 || !fa || !cb || !ca)
+            return { changed: false };
+        if (fa.height < f0.height + px - 1)
+            return { changed: false }; // the sibling has no row to give (the divider's floor)
+        grown = { id, base, tree, rows: rowsNext };
+        paintFor(tree);
+        return { changed: true, cellBefore: cb, cellAfter: ca, frameBefore: fb, frameAfter: fa, commands: [new GrownTreeCommand(group.id, base, normalizeSplit(tree))] };
+    };
     // -- a11y -------------------------------------------------------------------
     const nameOf = (id) => {
         var _a, _b, _c, _d;
@@ -2125,7 +2223,8 @@ export function bindDashboardSplit(api, group, options = {}) {
         },
         hasItem: (id) => { var _a; return ((_a = group.members) !== null && _a !== void 0 ? _a : new Set()).has(id); },
         memberCell: (id) => handle.cellOf(id),
-        resizeMemberBy: () => ({ changed: false }),
+        // A section pane grows a row for a tile arriving by hand (D4 on a split board, 0.4.71) — see resizePaneBy.
+        resizeMemberBy: (id, dRows) => resizePaneBy(id, dRows),
         // A torn-out page becomes a PANE (0.4.37) — see beginTearOut.
         tearOutMember: (pageId, fromGroupId, ev, plan) => beginTearOut(pageId, fromGroupId, ev, plan),
         // A tab group (or a section) moved by its strip's empty space becomes a