@grafloria/element 0.4.53 → 0.4.54

package/package.json

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

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

@@ -411,9 +411,17 @@ export interface DashboardHandle {
     /**
      * Add a widget to a view. CREATES the node (you do not pre-build one), wires
      * its metadata, and commits node + membership as ONE undoable step.
-     * Auto-positions when the spec names no cell.
-     */
-    addWidget(spec: DashboardWidgetSpec, viewId?: string): WidgetHandle | undefined;
+     * Auto-positions when the spec names no cell. `opts.displaced`: the
+     * commands a palette drop handed `onDropIn` for the tiles the placeholder
+     * pushed aside — folded into the same step, so the widget lands on the cell
+     * the drop showed and undo puts the pushed tiles back with it. Left out,
+     * the board is re-read from the model and the push is forgotten: the new
+     * widget then auto-positions into whatever hole is left (Quantia's "lands
+     * on the cell it was aimed at", element 0.4.54).
+     */
+    addWidget(spec: DashboardWidgetSpec, viewId?: string, opts?: {
+        displaced?: Command[];
+    }): WidgetHandle | undefined;
     /**
      * Re-read every board from the model — call after undo/redo, or any
      * out-of-band mutation, so the grid and the projection agree again.

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

@@ -1575,8 +1575,8 @@ export function createDashboardHandle(ctx) {
             (_a = ctx.apiRef) === null || _a === void 0 ? void 0 : _a.renderNow();
         },
         getDragHandle: () => { var _a, _b, _c; return (_b = (_a = binders.get(ctx.active)) === null || _a === void 0 ? void 0 : _a.getDragHandle()) !== null && _b !== void 0 ? _b : ((_c = ctx.optionsBase.dragHandle) !== null && _c !== void 0 ? _c : false); },
-        addWidget(spec, viewId) {
-            var _a, _b, _c, _d, _e, _f;
+        addWidget(spec, viewId, opts) {
+            var _a, _b, _c, _d, _e, _f, _g;
             const vid = viewId !== null && viewId !== void 0 ? viewId : ctx.active;
             // `vid` may name a view OR a container — both are boards with a group,
             // a binder and an authored array.
@@ -1601,10 +1601,15 @@ export function createDashboardHandle(ctx) {
             const node = existing !== null && existing !== void 0 ? existing : buildWidgetNode(w, ctx.rowHeight);
             if (w.pinned)
                 node.setState({ locked: true });
-            // ONE undoable step, registration included (see AddWidgetCommand).
-            execCommand(new AddWidgetCommand(node, group.id, registry, !!existing));
-            (_e = binders.get(vid)) === null || _e === void 0 ? void 0 : _e.sync();
-            (_f = ctx.apiRef) === null || _f === void 0 ? void 0 : _f.renderNow();
+            // ONE undoable step, registration included (see AddWidgetCommand). The
+            // tiles a drop pushed aside ride in front of it, in a SEQUENCE: a batch
+            // runs its members across awaits, and the board is re-read right after
+            // this call — the pushed cells must be in the model by then.
+            const add = new AddWidgetCommand(node, group.id, registry, !!existing);
+            const displaced = (_e = opts === null || opts === void 0 ? void 0 : opts.displaced) !== null && _e !== void 0 ? _e : [];
+            execCommand(displaced.length > 0 ? new SequenceCommand('Add widget', [...displaced, add]) : add);
+            (_f = binders.get(vid)) === null || _f === void 0 ? void 0 : _f.sync();
+            (_g = ctx.apiRef) === null || _g === void 0 ? void 0 : _g.renderNow();
             return makeWidgetHandle(w.id);
         },
         refresh() {

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

@@ -947,23 +947,38 @@ export function bindDashboardGrid(api, group, options = {}) {
      */
     let pendingDrop = null;
     const onMemberAdded = (id) => {
-        var _a, _b;
+        var _a, _b, _c;
         if (disposed)
             return;
-        if (pendingDrop && pendingDrop !== id && engine.getItem(pendingDrop) && !((_a = group.members) !== null && _a !== void 0 ? _a : new Set()).has(pendingDrop)) {
-            engine.remove(pendingDrop);
+        // The cell a waiting tile held for an arriving member of ANOTHER id. The
+        // removal settles the board — the tiles the drop pushed float back into
+        // the hole — so the member cannot simply be added there: it collided and
+        // auto-positioned to the left edge (Quantia's "lands on the cell it was
+        // aimed at"). It enters at the bottom edge instead and takes the cell
+        // gatelessly, pushing them down again, all inside this one call.
+        let claim = null;
+        if (pendingDrop && pendingDrop !== id) {
+            const ph = engine.getItem(pendingDrop);
+            if (ph && !((_a = group.members) !== null && _a !== void 0 ? _a : new Set()).has(pendingDrop)) {
+                claim = { x: ph.x, y: ph.y };
+                engine.remove(pendingDrop);
+            }
         }
         pendingDrop = null;
         if (!engine.getItem(id)) {
             const item = itemFor(id);
-            let placed = engine.add(item);
+            let placed = claim ? engine.add(Object.assign(Object.assign({}, item), { x: 0, y: engine.rows(), autoPosition: false })) : engine.add(item);
+            if (placed && claim) {
+                engine.moveCheck(id, claim.x, claim.y, { gate: false, pushSolid: !!placed.solid });
+                placed = (_b = engine.getItem(id)) !== null && _b !== void 0 ? _b : placed;
+            }
             if (!placed && capacity !== undefined) {
                 // Membership is a document fact (an undo just restored it, say); a
                 // bounded board must not strand the node invisible. Lift the capacity
                 // for this adoption — it floors at the content on the next refresh.
                 capacity = undefined;
                 engine = engineFrom([...engine.getItems().map((i) => (Object.assign({}, i))), item]);
-                placed = (_b = engine.getItem(id)) !== null && _b !== void 0 ? _b : null;
+                placed = (_c = engine.getItem(id)) !== null && _c !== void 0 ? _c : null;
                 refreshCapacity();
             }
             if (placed)