@grafloria/element 0.4.45 → 0.4.47

package/package.json

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

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

@@ -1264,105 +1264,158 @@ export function bindDashboardGrid(api, group, options = {}) {
     const TAB_FRAME_GRIP = 3;
     const edgeGripFor = (grp) => (isTabsGroup(grp) ? TAB_FRAME_GRIP : EDGE_GRIP);
     const BESIDE_BAND = 0.2;
+    /** How much wider the band is for a pointer ALREADY in it — a hand resting on the boundary must not flicker between beside and into. */
+    const BESIDE_STAY = 0.05;
+    /** The outer band of a container FRAME the point is in — null in the strip, in the middle, or outside. */
+    const bandOf = (f, wx, wy, band = BESIDE_BAND) => {
+        if (wx < f.x || wx > f.x + f.width || wy < f.y || wy > f.y + f.height)
+            return null;
+        const bodyY = f.y + TAB_STRIP_HEIGHT;
+        const bodyH = Math.max(1, f.height - TAB_STRIP_HEIGHT);
+        const rx = (wx - f.x) / Math.max(1, f.width);
+        const ry = (wy - bodyY) / bodyH;
+        if (ry < 0)
+            return null; // the strip: a new tab, the strip's own business
+        if (rx < band)
+            return 'left'; // the sides first: they take the corners
+        if (rx > 1 - band)
+            return 'right';
+        if (ry < band)
+            return 'top';
+        if (ry > 1 - band)
+            return 'bottom';
+        return null; // the middle: into the page
+    };
     const besideZoneAt = (wx, wy) => {
         var _a;
         for (const id of (_a = group.members) !== null && _a !== void 0 ? _a : []) {
             const grp = diagram.getGroup(id);
             if (!grp || diagram.getNode(id) || !isTabsGroup(grp))
                 continue;
-            const p = grp.position;
-            const sz = sizeOf(grp);
-            if (wx < p.x || wx > p.x + sz.width || wy < p.y || wy > p.y + sz.height)
-                continue;
-            const bodyY = p.y + TAB_STRIP_HEIGHT;
-            const bodyH = Math.max(1, sz.height - TAB_STRIP_HEIGHT);
-            const rx = (wx - p.x) / Math.max(1, sz.width);
-            const ry = (wy - bodyY) / bodyH;
-            if (ry < 0)
-                return null; // the strip: a new tab, the strip's own business
-            if (rx >= BESIDE_BAND && rx <= 1 - BESIDE_BAND && ry >= BESIDE_BAND && ry <= 1 - BESIDE_BAND)
-                return null; // the middle: into the page
-            const d = [['left', rx], ['right', 1 - rx], ['top', ry], ['bottom', 1 - ry]];
-            d.sort((a, b) => a[1] - b[1]);
-            return { id, side: d[0][0] };
+            const side = bandOf(frameOfGroup(grp), wx, wy);
+            if (side)
+                return { id, side };
         }
         return null;
     };
-    /** The container a BESIDE drop unlocked (and maybe shifted): relocked, and put back if asked, when the zone or the gesture ends. */
+    /** The BESIDE promise the overlay shows: the cell the widget takes on release, and where the container shifts to make it (null: it is pushed, or has room). */
     let beside = null;
-    const endBeside = (restore) => {
+    let besideEl = null;
+    const showBesideOverlay = (r) => {
+        const layer = htmlLayer();
+        if (!layer)
+            return;
+        if (!besideEl || besideEl.parentElement !== layer) {
+            besideEl === null || besideEl === void 0 ? void 0 : besideEl.remove();
+            besideEl = document.createElement('div');
+            besideEl.className = 'axdb-join';
+            layer.prepend(besideEl);
+        }
+        besideEl.style.left = `${r.x}px`;
+        besideEl.style.top = `${r.y}px`;
+        besideEl.style.width = `${r.width}px`;
+        besideEl.style.height = `${r.height}px`;
+    };
+    const hideBesideOverlay = () => {
+        besideEl === null || besideEl === void 0 ? void 0 : besideEl.remove();
+        besideEl = null;
+    };
+    /** The promise withdrawn (the pointer left, the gesture ended) or kept (realized and committed): the overlay goes, the container and the others relock. */
+    const endBeside = () => {
         if (!beside)
             return;
         const it = engine.getItem(beside.id);
-        if (it && restore && (it.x !== beside.from.x || it.y !== beside.from.y))
-            engine.moveCheck(beside.id, beside.from.x, beside.from.y, { gate: false });
         if (it)
             it.locked = true;
+        relockOthersForSlab();
+        hideBesideOverlay();
         beside = null;
     };
-    const applyBeside = (g, z) => {
-        var _a;
-        const tc = engine.getItem(z.id);
-        if (!tc)
-            return;
-        if (g.leg) {
-            g.leg.adopted.abort();
-            g.leg = null;
-        }
-        const w = g.spans.w;
-        const h = g.spans.h;
-        if (g.removedFromBoard) {
-            g.removedFromBoard = false;
-            (_a = hostOf(g.id)) === null || _a === void 0 ? void 0 : _a.classList.remove('axdb-out');
-            engine.add({ id: g.id, x: 0, y: engine.rows(), w, h });
-        }
-        if (beside && beside.id !== z.id)
-            endBeside(true);
-        const from = beside ? beside.from : { x: tc.x, y: tc.y };
+    /** Where a widget of this span lands beside the container, and where the container goes to make room — from the layout AT REST, since nothing moves while held. */
+    const besidePlan = (tc, side, w) => {
         let cell;
         let shiftTo = null;
-        switch (z.side) {
+        switch (side) {
             case 'right':
-                cell = { x: from.x + tc.w, y: from.y };
+                cell = { x: tc.x + tc.w, y: tc.y };
                 if (cell.x + w > columns) {
-                    shiftTo = { x: columns - w - tc.w, y: from.y };
-                    cell = { x: columns - w, y: from.y };
+                    shiftTo = { x: columns - w - tc.w, y: tc.y };
+                    cell = { x: columns - w, y: tc.y };
                 }
                 break;
             case 'left':
-                cell = { x: from.x - w, y: from.y };
+                cell = { x: tc.x - w, y: tc.y };
                 if (cell.x < 0) {
-                    shiftTo = { x: w, y: from.y };
-                    cell = { x: 0, y: from.y };
+                    shiftTo = { x: w, y: tc.y };
+                    cell = { x: 0, y: tc.y };
                 }
                 break;
             case 'top':
-                cell = { x: Math.max(0, Math.min(from.x, columns - w)), y: from.y }; // the ghost takes the container's rows; the container is pushed down under it
+                cell = { x: Math.max(0, Math.min(tc.x, columns - w)), y: tc.y }; // the widget takes the container's rows; the container is pushed down under it
                 break;
             default:
-                cell = { x: Math.max(0, Math.min(from.x, columns - w)), y: from.y + tc.h };
+                cell = { x: Math.max(0, Math.min(tc.x, columns - w)), y: tc.y + tc.h };
         }
         if (shiftTo && shiftTo.x < 0)
             shiftTo = null; // no room even shifted: the widget goes where it can
+        return { cell, shiftTo };
+    };
+    const applyBeside = (g, z) => {
+        var _a;
+        const tc = engine.getItem(z.id);
+        if (!tc)
+            return;
+        if (g.leg) {
+            g.leg.adopted.abort();
+            g.leg = null;
+        }
+        // The ghost leaves the board, as it does over a strip: the survivors
+        // settle home and nothing under the hand moves until the release.
+        if (!g.removedFromBoard) {
+            g.removedFromBoard = true;
+            engine.remove(g.id);
+            project();
+        }
+        (_a = hostOf(g.id)) === null || _a === void 0 ? void 0 : _a.classList.remove('axdb-out');
+        const plan = besidePlan(tc, z.side, g.spans.w);
+        if (!beside || beside.id !== z.id || beside.side !== z.side || beside.cell.x !== plan.cell.x || beside.cell.y !== plan.cell.y) {
+            beside = { id: z.id, side: z.side, cell: plan.cell, shiftTo: plan.shiftTo };
+            showBesideOverlay(cellToRect({ x: plan.cell.x, y: plan.cell.y, w: g.spans.w, h: g.spans.h }, frame(), geom(), rows()));
+        }
+    };
+    /**
+     * The release: the container shifts (or is pushed) and the ghost takes the
+     * promised cell — for real now, so the commit's deltas carry both. The
+     * ghost steps back on at the bottom edge first: the engine will not push
+     * the dragged tile, so a chart as wide as the panel had its own cell as the
+     * panel's target and the shift was refused (lab L94).
+     */
+    const realizeBeside = (g) => {
+        var _a;
         if (!beside)
-            beside = { id: z.id, from, vacated: cell };
-        tc.locked = false; // for the gesture: it shifts, or the ghost pushes it
-        // The ghost steps off the board while the container shifts: on a bounded
-        // board a chart as wide as the panel had its own cell as the panel's
-        // target, could not be pushed down, and the shift was refused (lab L94).
-        // Then it takes the cell the shift vacated.
-        if (shiftTo && (tc.x !== shiftTo.x || tc.y !== shiftTo.y)) {
-            if (engine.getItem(g.id))
-                engine.remove(g.id);
-            engine.moveCheck(z.id, shiftTo.x, shiftTo.y, { gate: false });
+            return;
+        const tc = engine.getItem(beside.id);
+        if (!tc)
+            return;
+        const w = g.spans.w;
+        const h = g.spans.h;
+        // The other sections give way to the shift the way they give way to a
+        // moved group (0.4.44): on the demo the Operations section spans the
+        // row under the panel and a locked tile refused the shift outright.
+        unlockOthersForSlab(beside.id);
+        tc.locked = false; // it shifts, or the ghost pushes it
+        if (beside.shiftTo && (tc.x !== beside.shiftTo.x || tc.y !== beside.shiftTo.y))
+            engine.moveCheck(beside.id, beside.shiftTo.x, beside.shiftTo.y, { gate: false });
+        if (g.removedFromBoard) {
+            g.removedFromBoard = false;
+            (_a = hostOf(g.id)) === null || _a === void 0 ? void 0 : _a.classList.remove('axdb-out');
         }
-        beside.vacated = cell;
         if (!engine.getItem(g.id))
             engine.add({ id: g.id, x: 0, y: engine.rows(), w, h });
-        if (!engine.moveCheck(g.id, cell.x, cell.y, { gate: false }).changed) {
+        if (!engine.moveCheck(g.id, beside.cell.x, beside.cell.y, { gate: false }).changed) {
             const at = engine.getItem(g.id);
-            if (!at || at.x !== cell.x || at.y !== cell.y)
-                placeNear(g.id, cell.x, cell.y, w);
+            if (!at || at.x !== beside.cell.x || at.y !== beside.cell.y)
+                placeNear(g.id, beside.cell.x, beside.cell.y, w);
         }
         project();
     };
@@ -1909,7 +1962,7 @@ export function bindDashboardGrid(api, group, options = {}) {
         const deltas = deltasSince(g.startCells, g.startGeom);
         const commands = buildCommitCommands(deltas);
         commands.push(...groupCellCommands(deltas)); // a container a BESIDE drop shifted (0.4.45)
-        endBeside(false);
+        endBeside();
         if (g.esc && g.esc.rowsAdded !== 0) {
             commands.push(new SetGroupCellCommand(group.id, g.esc.cellBefore, g.esc.cellAfter, g.esc.frameBefore, g.esc.frameAfter));
         }
@@ -1948,7 +2001,7 @@ export function bindDashboardGrid(api, group, options = {}) {
             g.esc.peer.resizeMemberBy(group.id, -g.esc.rowsAdded); // slab back down
             g.esc = null;
         }
-        endBeside(true);
+        endBeside();
         if (g.started) {
             if (g.removedFromBoard || g.kind === 'palette') {
                 // The engine cannot resurrect a removed item — rebuild from the
@@ -2048,6 +2101,7 @@ export function bindDashboardGrid(api, group, options = {}) {
                         g.leg.adopted.abort();
                         g.leg = null;
                     }
+                    endBeside(); // a band's promise gives way to the strip's
                     if (!g.removedFromBoard) {
                         g.removedFromBoard = true;
                         engine.remove(g.id);
@@ -2069,6 +2123,7 @@ export function bindDashboardGrid(api, group, options = {}) {
             }
             // BESIDE a tab container (0.4.45): its outer band puts the widget next
             // to it — at the board's edge the container shifts over to make room.
+            // Nothing moves while held (0.4.47): an overlay marks the cell.
             if (!isStatic) {
                 const z = besideZoneAt(ev.world.x, ev.world.y);
                 if (z) {
@@ -2077,19 +2132,16 @@ export function bindDashboardGrid(api, group, options = {}) {
                     return;
                 }
                 if (beside) {
-                    // Off the band: the container comes back unless the POINTER is
-                    // still over the cell it vacated — the widget's own landing, which
-                    // is what "beside" leaves under the pointer once the container has
-                    // shifted away (the ghost's wanted cell carries the grab offset and
-                    // read as "elsewhere" a move later, and the shift undid itself).
-                    const r = cellToRect({ x: beside.vacated.x, y: beside.vacated.y, w: g.spans.w, h: g.spans.h }, frame(), geom(), rows());
-                    const over = ev.world.x >= r.x - gap && ev.world.x <= r.x + r.width + gap && ev.world.y >= r.y - gap && ev.world.y <= r.y + r.height + gap;
-                    if (!over)
-                        endBeside(true);
-                    else {
+                    // Off the band — unless the hand is resting on its boundary: the
+                    // band is a little wider for a pointer already in it, so the
+                    // promise does not flicker against "into the page" at the line.
+                    const grp = diagram.getGroup(beside.id);
+                    const stay = !!grp && bandOf(frameOfGroup(grp), ev.world.x, ev.world.y, BESIDE_BAND + BESIDE_STAY) === beside.side;
+                    if (stay) {
                         syncPlaceholder();
                         return;
                     }
+                    endBeside(); // the overlay goes; the handoff below puts the ghost back on a board
                 }
             }
             // Deepest board under the pointer wins: the nested KPI strip beats the
@@ -2526,6 +2578,13 @@ export function bindDashboardGrid(api, group, options = {}) {
             (_b = options.onGesture) === null || _b === void 0 ? void 0 : _b.call(options, { type: 'commit', kind: g.kind, nodeId: g.id, changed: true });
             return;
         }
+        if (beside) {
+            // -- BESIDE A TAB CONTAINER (0.4.47): the shift or push the overlay
+            // promised happens now, and the commit below records both.
+            realizeBeside(g);
+            commitGesture(g);
+            return;
+        }
         if (g.leg) {
             // -- CROSS-CONTAINER COMMIT: one batch across both boards -----------
             const fin = g.leg.adopted.finalize();