@grafloria/element 0.4.25 → 0.4.26

package/package.json

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

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

@@ -1733,10 +1733,13 @@ export function bindDashboardGrid(api, group, options = {}) {
         // commit and for Escape.
         // NESTED ESCALATION — a section is a board one level down, and a pull
         // inside it can need rows the section does not hold. Two shapes:
-        //  · a tile spanning the section's FULL HEIGHT (every tile of a one-row
-        //    KPI strip): the section gains a row and every full-height tile grows
-        //    with it — a row of tiles pulled taller stays a row (s21) — and gives
-        //    it back when pulled up, never below the design;
+        //  · a tile spanning the section's FULL HEIGHT (any tile of a one-row KPI
+        //    strip): the section gains a row and THE DRAGGED TILE takes it; its
+        //    siblings keep their own cells, and the row goes back when the tile is
+        //    pulled up again, never below the design. (Until 0.4.26 every
+        //    full-height tile grew together — "a row stays a row" — but that
+        //    resized the widget NEXT to the one under the pointer, which is not
+        //    what a grid resize means.)
         //  · a PARTIAL tile (a one-row control in a 14-row panel): it pushes what
         //    is below it; a row the pushed layout needs and the section does not
         //    hold is asked of the board, one per pointer step, and rows the
@@ -1801,22 +1804,25 @@ export function bindDashboardGrid(api, group, options = {}) {
                 const effWant = fullHeight ? stripRows : wantRows;
                 const wantsMore = effWant > pulled.h;
                 const wantsLess = effWant < pulled.h;
-                const fullOnes = engine.getItems().filter((i) => i.y === 0 && i.h >= inner).map((i) => i.id);
-                const resizeAll = (ids, rowsTo) => {
-                    for (const id of ids) {
-                        const it = engine.getItem(id);
-                        if (it)
-                            engine.resizeCheck(id, it.w, rowsTo);
-                    }
-                };
                 let touched = false;
                 if (wantsMore) {
-                    if (fullHeight) {
+                    if (fullHeight && !E.s) {
+                        // A tile that already starts at row 0 has nothing above it, so a
+                        // TOP-edge pull has nowhere to go: refuse it rather than growing
+                        // the tile downwards, away from the edge under the pointer. Same
+                        // rule the partial path follows (0.4.20).
+                    }
+                    else if (fullHeight) {
                         const res = parent.resizeMemberBy(group.id, +1);
                         if (res.changed) {
                             record(res, +1);
                             setInnerRows(inner + 1);
-                            resizeAll(fullOnes, inner + 1);
+                            // ONLY THE TILE UNDER THE POINTER CHANGES. The section grows to
+                            // hold it and its siblings keep their own cells — a grid resize
+                            // adjusts what you grabbed, nothing else. (This board used to
+                            // grow EVERY full-height tile together, so pulling one KPI of a
+                            // strip silently resized its neighbour too.)
+                            engine.resizeCheck(g.id, pulled.w, pulled.h + 1);
                             touched = true;
                         }
                     }
@@ -1840,14 +1846,21 @@ export function bindDashboardGrid(api, group, options = {}) {
                 else if (wantsLess) {
                     if (fullHeight) {
                         if (slabRows > designRows && inner > 1) {
-                            resizeAll(fullOnes, inner - 1);
-                            const res = parent.resizeMemberBy(group.id, -1);
-                            if (res.changed) {
+                            // Shrink the dragged tile, then hand back only the rows the
+                            // section no longer needs — a sibling still using them keeps
+                            // them (the extent floor below).
+                            engine.resizeCheck(g.id, pulled.w, Math.max(1, effWant));
+                            const floor = Math.max(designRows, extentOf(engine.getItems()));
+                            let slab = slabRows;
+                            let bound = inner;
+                            while (slab > floor) {
+                                const res = parent.resizeMemberBy(group.id, -1);
+                                if (!res.changed)
+                                    break;
                                 record(res, -1);
-                                setInnerRows(inner - 1);
-                            }
-                            else {
-                                resizeAll(fullOnes, inner);
+                                slab -= 1;
+                                bound -= 1;
+                                setInnerRows(bound);
                             }
                             touched = true;
                         }