@grafloria/element 0.4.53 → 0.4.55

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

@@ -0,0 +1,37 @@
+/** The drag handle — the caption strip, a selector, or a painted grip — and the press test for it (tile first, step 4b-i: out of the binder). */
+/** A painted grip: the only drag zone, placed along the card's top edge. */
+export interface DragGripOptions {
+    grip: true;
+    /** Where along the top edge. Default 'left'. */
+    position?: 'left' | 'center' | 'right';
+    /** In the header band, or a tab above the card. Default 'inside'. */
+    placement?: 'inside' | 'outside';
+}
+export type DragHandleOption = boolean | string | DragGripOptions;
+/** The class of the painted grip element (a child of the node host). */
+export declare const GRIP_CLASS = "axdb-grip";
+/** The container class that turns the caption strip's grip dots on. */
+export declare const DRAG_HANDLE_CLASS = "axdb-drag-handle";
+/** The caption strip of a host with no kit header, px from the card's top. */
+export declare const CAPTION_BAND = 28;
+/** A `dragHandle` value with its defaults filled in — the form the handle reports. */
+export declare const normalizeDragHandle: (v: DragHandleOption | undefined) => DragHandleOption;
+/** The selector a `dragHandle` value names — `null` when the whole card is the handle. */
+export declare const dragHandleSelector: (v: DragHandleOption) => string | null;
+/** The grip config of a value, or null when it paints no grip. */
+export declare const gripOf: (v: DragHandleOption) => DragGripOptions | null;
+export declare const sameDragHandle: (a: DragHandleOption, b: DragHandleOption) => boolean;
+/**
+ * Paint (or remove) the grip on one host, and stamp the host with the grip's
+ * placement so the header can make room for it. `movable` false = no grip.
+ */
+export declare function syncGrip(host: HTMLElement, cfg: DragGripOptions | null, movable: boolean): void;
+/** The member host a press on a painted grip belongs to (the grip may sit OUTSIDE the host's box). */
+export declare function gripHostOf(target: Element | null): HTMLElement | null;
+/**
+ * Did a press land on the drag handle? A press INSIDE the handle element
+ * always does. The default handle is a CAPTION BAR the DevExpress way: the
+ * strip from the card's top edge down to the header's bottom, padding
+ * included — so the pointer need not hit the header's text to grab the tile.
+ */
+export declare function pressOnDragHandle(sel: string, target: Element | null, hostEl: HTMLElement | null, clientX: number, clientY: number): boolean;

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

@@ -0,0 +1,67 @@
+/** The drag handle — the caption strip, a selector, or a painted grip — and the press test for it (tile first, step 4b-i: out of the binder). */
+/** The class of the painted grip element (a child of the node host). */
+export const GRIP_CLASS = 'axdb-grip';
+/** The container class that turns the caption strip's grip dots on. */
+export const DRAG_HANDLE_CLASS = 'axdb-drag-handle';
+/** The caption strip of a host with no kit header, px from the card's top. */
+export const CAPTION_BAND = 28;
+/** A `dragHandle` value with its defaults filled in — the form the handle reports. */
+export const normalizeDragHandle = (v) => {
+    var _a, _b;
+    return typeof v === 'object' && v !== null && v.grip
+        ? { grip: true, position: (_a = v.position) !== null && _a !== void 0 ? _a : 'left', placement: (_b = v.placement) !== null && _b !== void 0 ? _b : 'inside' }
+        : v === true ? true : typeof v === 'string' && v.length > 0 ? v : false;
+};
+/** The selector a `dragHandle` value names — `null` when the whole card is the handle. */
+export const dragHandleSelector = (v) => v === true ? '.axdb-widget-h' : typeof v === 'string' ? v : typeof v === 'object' ? '.' + GRIP_CLASS : null;
+/** The grip config of a value, or null when it paints no grip. */
+export const gripOf = (v) => (typeof v === 'object' ? v : null);
+export const sameDragHandle = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+/**
+ * Paint (or remove) the grip on one host, and stamp the host with the grip's
+ * placement so the header can make room for it. `movable` false = no grip.
+ */
+export function syncGrip(host, cfg, movable) {
+    var _a, _b, _c, _d, _e;
+    const existing = host.querySelector(':scope > .' + GRIP_CLASS);
+    host.classList.remove('axdb-gp-inside', 'axdb-gp-outside', 'axdb-gp-left', 'axdb-gp-center', 'axdb-gp-right');
+    if (!cfg || !movable) {
+        existing === null || existing === void 0 ? void 0 : existing.remove();
+        return;
+    }
+    const el = (_a = existing) !== null && _a !== void 0 ? _a : host.ownerDocument.createElement('div');
+    if (!existing) {
+        el.setAttribute('aria-hidden', 'true');
+        el.setAttribute('title', 'Drag');
+        host.appendChild(el);
+    }
+    el.className = `${GRIP_CLASS} ${GRIP_CLASS}--${(_b = cfg.position) !== null && _b !== void 0 ? _b : 'left'} ${GRIP_CLASS}--${(_c = cfg.placement) !== null && _c !== void 0 ? _c : 'inside'}`;
+    host.classList.add(`axdb-gp-${(_d = cfg.placement) !== null && _d !== void 0 ? _d : 'inside'}`, `axdb-gp-${(_e = cfg.position) !== null && _e !== void 0 ? _e : 'left'}`);
+}
+/** The member host a press on a painted grip belongs to (the grip may sit OUTSIDE the host's box). */
+export function gripHostOf(target) {
+    var _a, _b;
+    const grip = (_a = target === null || target === void 0 ? void 0 : target.closest) === null || _a === void 0 ? void 0 : _a.call(target, '.' + GRIP_CLASS);
+    return (_b = grip === null || grip === void 0 ? void 0 : grip.closest('.grafloria-node-host')) !== null && _b !== void 0 ? _b : null;
+}
+/**
+ * Did a press land on the drag handle? A press INSIDE the handle element
+ * always does. The default handle is a CAPTION BAR the DevExpress way: the
+ * strip from the card's top edge down to the header's bottom, padding
+ * included — so the pointer need not hit the header's text to grab the tile.
+ */
+export function pressOnDragHandle(sel, target, hostEl, clientX, clientY) {
+    var _a, _b;
+    const grip = (_b = (_a = target === null || target === void 0 ? void 0 : target.closest) === null || _a === void 0 ? void 0 : _a.call(target, sel)) !== null && _b !== void 0 ? _b : null;
+    if (grip && (!hostEl || hostEl.contains(grip)))
+        return true;
+    if (sel !== '.axdb-widget-h' || !hostEl)
+        return false;
+    const hr = hostEl.getBoundingClientRect();
+    const header = hostEl.querySelector('.axdb-widget-h');
+    // A host painting its own content has no kit header: its caption is the top
+    // band of the card, so `dragHandle: true` still means something there.
+    const bottom = header ? header.getBoundingClientRect().bottom : hr.top + CAPTION_BAND;
+    return clientX >= hr.left && clientX <= hr.right && clientY >= hr.top && clientY <= bottom;
+}
+//# sourceMappingURL=grip.js.map

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

@@ -0,0 +1,41 @@
+/**
+ * KEYBOARD OPERATION (tile first, step 4b-i: out of the binder). WCAG 2.1.1,
+ * and the non-drag alternative 2.5.7 asks for: on a focused member, arrows
+ * move it one cell, Shift+arrows resize it one cell, Home/End jump to the
+ * first/last member. Every move and resize is the same programmatic gesture
+ * the API uses — one undoable step, reported through onLayoutChange — and
+ * every outcome is spoken: the tile's new cell, each neighbour it displaced,
+ * or why it was refused. Handled keys stop here so the renderer's own pixel
+ * nudge never fights the grid.
+ */
+import type { NodeModel } from '@grafloria/engine';
+import { LiveRegionController } from '@grafloria/renderer';
+import type { CellRect } from './grid-mapping.js';
+import type { BoardCtx } from './board-ctx.js';
+export declare function liveRegionFor(container: HTMLElement): LiveRegionController;
+export declare function directionName(dx: number, dy: number): string;
+/** "column 4, row 2, 3 by 1" — the cell as a person hears it (1-based). */
+export declare function describeCell(c: CellRect): string;
+export interface KeyboardDeps {
+    /** The board's handle — its programmatic move, resize and focus; read late, it exists after the binder is built. */
+    handle(): {
+        moveTo(id: string, x: number, y: number): Promise<boolean>;
+        resizeTo(id: string, w: number, h: number): Promise<boolean>;
+        focusWidget(id: string): boolean;
+    };
+    live: LiveRegionController;
+    /** The accessible name of a widget: its title, else its kind, else its id. */
+    nameOf(node: NodeModel): string;
+    focusedId(): string | undefined;
+    setFocusedId(id: string): void;
+    selectedId(): string | undefined;
+    selectWidget(id: string): void;
+    syncA11y(): void;
+    /** A tile gesture is live: the keys stay out of its way. */
+    gestureRunning(): boolean;
+}
+export interface Keyboard {
+    onFocusIn(e: FocusEvent): void;
+    onKey(e: KeyboardEvent): void;
+}
+export declare function createKeyboard(ctx: BoardCtx, deps: KeyboardDeps): Keyboard;

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

@@ -0,0 +1,145 @@
+import { __awaiter } from "tslib";
+import { LiveRegionController } from '@grafloria/renderer';
+/**
+ * ONE aria-live region per canvas, shared by every board on it — the
+ * renderer's own controller (coalescing, de-duplicating), so a dashboard
+ * announces through the same channel a diagram does. WeakMap: the region
+ * follows the container out of memory.
+ */
+const LIVE_REGIONS = new WeakMap();
+export function liveRegionFor(container) {
+    let live = LIVE_REGIONS.get(container);
+    if (!live) {
+        live = new LiveRegionController(container);
+        LIVE_REGIONS.set(container, live);
+    }
+    return live;
+}
+export function directionName(dx, dy) {
+    return dx < 0 ? 'left' : dx > 0 ? 'right' : dy < 0 ? 'up' : 'down';
+}
+/** "column 4, row 2, 3 by 1" — the cell as a person hears it (1-based). */
+export function describeCell(c) {
+    return `column ${c.x + 1}, row ${c.y + 1}, ${c.w} by ${c.h}`;
+}
+export function createKeyboard(ctx, deps) {
+    const { group, diagram } = ctx;
+    const memberHostAt = (target) => {
+        var _a, _b, _c;
+        const host = (_a = target === null || target === void 0 ? void 0 : target.closest) === null || _a === void 0 ? void 0 : _a.call(target, '.grafloria-node-host');
+        if (!host)
+            return null;
+        const id = (_b = host.getAttribute('data-node-id')) !== null && _b !== void 0 ? _b : '';
+        if (!((_c = group.members) !== null && _c !== void 0 ? _c : new Set()).has(id) || !diagram.getNode(id))
+            return null;
+        return { id, host };
+    };
+    const onFocusIn = (e) => {
+        const hit = memberHostAt(e.target);
+        if (!hit || ctx.disposed())
+            return;
+        if (deps.focusedId() !== hit.id || deps.selectedId() !== hit.id) {
+            deps.setFocusedId(hit.id);
+            deps.selectWidget(hit.id);
+            deps.syncA11y();
+        }
+    };
+    const onKey = (e) => {
+        var _a, _b, _c, _d, _e, _f, _g;
+        if (ctx.disposed() || deps.gestureRunning())
+            return;
+        const handle = deps.handle();
+        const hit = memberHostAt(e.target);
+        if (!hit) {
+            const el = e.target;
+            const onRoot = !!el && ((_a = el.tagName) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === 'svg' && ((_b = el.classList) === null || _b === void 0 ? void 0 : _b.contains('grafloria-diagram'));
+            if (onRoot && (e.key.startsWith('Arrow') || e.key === 'Enter' || e.key === ' ')) {
+                const members = [...((_c = group.members) !== null && _c !== void 0 ? _c : [])].filter((id) => !!diagram.getNode(id) && !!ctx.hostOf(id));
+                const focused = deps.focusedId();
+                const target = focused && members.includes(focused) ? focused : members[0];
+                if (target && handle.focusWidget(target)) {
+                    e.preventDefault();
+                    e.stopPropagation();
+                }
+            }
+            return;
+        }
+        const members = [...((_d = group.members) !== null && _d !== void 0 ? _d : [])].filter((id) => !!diagram.getNode(id) && !!ctx.hostOf(id));
+        if (e.key === 'Home' || e.key === 'End') {
+            const id = e.key === 'Home' ? members[0] : members[members.length - 1];
+            if (id)
+                handle.focusWidget(id);
+            e.preventDefault();
+            e.stopPropagation();
+            return;
+        }
+        const arrow = { ArrowLeft: [-1, 0], ArrowRight: [1, 0], ArrowUp: [0, -1], ArrowDown: [0, 1] }[e.key];
+        if (!arrow)
+            return;
+        e.preventDefault();
+        e.stopPropagation();
+        if (ctx.isStatic())
+            return; // readable, not editable
+        const engine = ctx.engine();
+        const node = diagram.getNode(hit.id);
+        const item = engine.getItem(hit.id);
+        if (!node || !item)
+            return;
+        const name = deps.nameOf(node);
+        const live = deps.live;
+        if (((_e = node.state) === null || _e === void 0 ? void 0 : _e.locked) === true) {
+            live.announceError(`${name} is pinned`);
+            return;
+        }
+        const [dx, dy] = arrow;
+        const before = new Map(engine.getItems().map((i) => [i.id, { x: i.x, y: i.y, w: i.w, h: i.h }]));
+        const resize = e.shiftKey;
+        if (resize && ((_f = node.getMetadata) === null || _f === void 0 ? void 0 : _f.call(node, 'widgetResizable')) === false) {
+            live.announceError(`${name} cannot be resized`);
+            return;
+        }
+        if (!resize && ((_g = node.getMetadata) === null || _g === void 0 ? void 0 : _g.call(node, 'widgetMovable')) === false) {
+            live.announceError(`${name} cannot be moved`);
+            return;
+        }
+        const stepOrSwap = () => __awaiter(this, void 0, void 0, function* () {
+            if (yield handle.moveTo(hit.id, item.x + dx, item.y + dy))
+                return true;
+            const probe = { x: item.x + dx, y: item.y + dy, w: item.w, h: item.h };
+            const c = engine
+                .getItems()
+                .find((o) => o.id !== hit.id && probe.x < o.x + o.w && o.x < probe.x + probe.w && probe.y < o.y + o.h && o.y < probe.y + probe.h);
+            if (!c)
+                return false;
+            const tx = dx > 0 ? c.x + c.w - item.w : dx < 0 ? c.x : item.x;
+            const ty = dy > 0 ? c.y + c.h - item.h : dy < 0 ? c.y : item.y;
+            return handle.moveTo(hit.id, tx, ty);
+        });
+        const op = resize ? handle.resizeTo(hit.id, item.w + dx, item.h + dy) : stepOrSwap();
+        void op.then((ok) => {
+            var _a, _b;
+            if (ctx.disposed())
+                return;
+            const after = ctx.engine().getItem(hit.id);
+            if (!ok || !after) {
+                live.announceError(resize ? `Cannot resize ${name} that way` : `Cannot move ${name} ${directionName(dx, dy)}`);
+                return;
+            }
+            const parts = [`${name} ${resize ? 'resized' : 'moved'} to ${describeCell(after)}`];
+            for (const other of ctx.engine().getItems()) {
+                if (other.id === hit.id)
+                    continue;
+                const was = before.get(other.id);
+                if (!was || (was.x === other.x && was.y === other.y))
+                    continue;
+                const o = diagram.getNode(other.id);
+                parts.push(`${o ? deps.nameOf(o) : other.id} moved to ${describeCell(other)}`);
+            }
+            live.announce(parts.join('. '), 'polite', true);
+            deps.syncA11y();
+            (_b = (_a = ctx.hostOf(hit.id)) === null || _a === void 0 ? void 0 : _a.focus) === null || _b === void 0 ? void 0 : _b.call(_a, { preventScroll: true });
+        });
+    };
+    return { onFocusIn, onKey };
+}
+//# sourceMappingURL=keyboard.js.map

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

@@ -0,0 +1,30 @@
+/**
+ * THE PROJECTION (tile first, step 4b-i): cells to pixels, and the chrome that
+ * rides on the projection — the board's own height, the placeholder under a
+ * ghost, the ghost's transition exemption, the glide every pushed tile gets.
+ * Moved out of the binder unchanged in behaviour; the binder keeps calling
+ * these by the same names.
+ */
+import type { WorldRect } from './grid-mapping.js';
+import type { BoardCtx } from './board-ctx.js';
+export interface Projection {
+    /** Write one member's projected rect (derived state → system write). */
+    writeRect(id: string, r: WorldRect): void;
+    /** Enforce the board-frame height the sizing mode implies. */
+    enforceBoardHeight(): void;
+    /** Project every member from its engine cells (the ghost is exempt). */
+    project(): void;
+    /** The placeholder follows the ghost's cell; gone when there is no ghost on this board. */
+    syncPlaceholder(): void;
+    /** Take the placeholder down now (an accent overlay says which half; the grey cell under it is noise). */
+    hidePlaceholder(): void;
+    armGlide(): void;
+    disarmGlideSoon(): void;
+    /** Lift a pending ghost NOW. */
+    flushGhost(): void;
+    setGhost(id: string, on: boolean): void;
+    dispose(): void;
+}
+export declare function createProjection(ctx: BoardCtx, deps: {
+    afterProject(): void;
+}): Projection;

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

@@ -0,0 +1,177 @@
+import { cellToRect } from './grid-mapping.js';
+const GLIDE_OFF_DELAY = 400;
+export function createProjection(ctx, deps) {
+    const { api, group, diagram } = ctx;
+    let placeholder = null;
+    let glideTimer = null;
+    let ghostTimer = null;
+    /** The host whose ghost class the pending timer will lift. */
+    let ghostHost = null;
+    const writeRect = (id, r) => {
+        const node = diagram.getNode(id);
+        if (node) {
+            if (Math.abs(node.position.x - r.x) > 0.25 ||
+                Math.abs(node.position.y - r.y) > 0.25 ||
+                Math.abs(node.size.width - r.width) > 0.25 ||
+                Math.abs(node.size.height - r.height) > 0.25) {
+                diagram.runSystemWrite(() => {
+                    var _a;
+                    node.setPosition(r.x, r.y);
+                    node.setSize(r.width, r.height, (_a = node.size.depth) !== null && _a !== void 0 ? _a : 0);
+                });
+            }
+            return;
+        }
+        const grp = diagram.getGroup(id);
+        if (grp) {
+            const p = grp.position;
+            const s = ctx.sizeOf(grp);
+            if (Math.abs(p.x - r.x) > 0.25 ||
+                Math.abs(p.y - r.y) > 0.25 ||
+                Math.abs(s.width - r.width) > 0.25 ||
+                Math.abs(s.height - r.height) > 0.25) {
+                diagram.runSystemWrite(() => grp.setFrame(Object.assign({}, r)));
+            }
+        }
+    };
+    const enforceBoardHeight = () => {
+        const designH = ctx.designH();
+        if (designH <= 0)
+            return;
+        const r = ctx.rows();
+        // FIT keeps its design height, full stop — the user's rule: "the board
+        // stays the same and the widgets change size so all of them fit". Only
+        // overflow:'scroll' lets the frame EXTEND to hold the rows at the floor
+        // height (and the canvas pan). Grow extends at the base row height.
+        const target = ctx.sizing() === 'fit'
+            ? ctx.overflow === 'scroll'
+                ? Math.max(designH, 2 * ctx.padding + r * ctx.minRowHeight + (r - 1) * ctx.gap)
+                : designH
+            : Math.max(designH, 2 * ctx.padding + r * ctx.baseRowHeight + (r - 1) * ctx.gap);
+        const f = ctx.frame();
+        if (Math.abs(f.height - target) > 0.5) {
+            ctx.write(() => diagram.runSystemWrite(() => group.setFrame({ x: f.x, y: f.y, width: f.width, height: target })));
+        }
+    };
+    /** The placeholder exists ONLY while a gesture is live — so at any moment
+     *  the DOM holds at most one `.axdb-ph` per active gesture, not one idle
+     *  div per bound board. */
+    const syncPlaceholder = () => {
+        const ghostId = ctx.ghostId();
+        const item = ghostId ? ctx.engine().getItem(ghostId) : undefined;
+        if (!item) {
+            placeholder === null || placeholder === void 0 ? void 0 : placeholder.remove();
+            placeholder = null;
+            return;
+        }
+        const layer = ctx.htmlLayer();
+        if (!layer)
+            return;
+        if (!placeholder || placeholder.parentElement !== layer) {
+            placeholder === null || placeholder === void 0 ? void 0 : placeholder.remove();
+            placeholder = document.createElement('div');
+            placeholder.className = 'axdb-ph';
+            layer.prepend(placeholder);
+        }
+        const r = cellToRect(item, ctx.frame(), ctx.geom(), ctx.rows());
+        placeholder.style.display = 'block';
+        placeholder.style.left = `${r.x}px`;
+        placeholder.style.top = `${r.y}px`;
+        placeholder.style.width = `${r.width}px`;
+        placeholder.style.height = `${r.height}px`;
+    };
+    const hidePlaceholder = () => {
+        placeholder === null || placeholder === void 0 ? void 0 : placeholder.remove();
+        placeholder = null;
+    };
+    const project = () => {
+        enforceBoardHeight();
+        ctx.write(() => {
+            const f = ctx.frame();
+            const g = ctx.geom();
+            const r = ctx.rows();
+            const ghost = ctx.ghostId();
+            for (const item of ctx.engine().getItems()) {
+                if (item.id === ghost)
+                    continue; // the ghost — this board's own, or one adopted from another binder
+                writeRect(item.id, cellToRect(item, f, g, r));
+            }
+        });
+        syncPlaceholder();
+        // The section overlays are projected chrome like the placeholder: they
+        // follow every frame write, not only a rebuild. Painted at bind time only,
+        // a section two levels down kept the geometry of its parent's placeholder
+        // frame (100 × 34) after the view board had laid the parent out (the kit
+        // lab's L47, 2026-09-08).
+        deps.afterProject();
+    };
+    const armGlide = () => {
+        var _a;
+        (_a = ctx.htmlLayer()) === null || _a === void 0 ? void 0 : _a.classList.add('axdb-glide');
+        if (glideTimer)
+            clearTimeout(glideTimer);
+    };
+    const disarmGlideSoon = () => {
+        if (glideTimer)
+            clearTimeout(glideTimer);
+        glideTimer = setTimeout(() => { var _a; return (_a = ctx.htmlLayer()) === null || _a === void 0 ? void 0 : _a.classList.remove('axdb-glide'); }, GLIDE_OFF_DELAY);
+    };
+    /**
+     * Lift a pending ghost NOW. One timer serves every host, so superseding it
+     * (a new gesture within 60 ms of the last drop — ③ then ④ in the
+     * nested-containers checks — or a dispose on a rebind) used to clear the
+     * timer and leave the previous tile lifted for good: a permanent drop
+     * shadow the visual gate finally caught.
+     */
+    const flushGhost = () => {
+        if (ghostTimer)
+            clearTimeout(ghostTimer);
+        ghostTimer = null;
+        ghostHost === null || ghostHost === void 0 ? void 0 : ghostHost.classList.remove('axdb-ghost', 'axdb-out');
+        ghostHost = null;
+    };
+    const setGhost = (id, on) => {
+        const host = ctx.hostOf(id);
+        if (!host)
+            return;
+        if (ghostHost && ghostHost !== host)
+            flushGhost();
+        if (on) {
+            if (ghostTimer)
+                clearTimeout(ghostTimer);
+            ghostTimer = null;
+            host.classList.add('axdb-ghost');
+            host.classList.remove('axdb-out');
+            ghostHost = host;
+        }
+        else {
+            host.classList.remove('axdb-out');
+            // Keep transition-exemption through the drop write so the snap into the
+            // placeholder is INSTANT (gridstack-style), then let glides resume.
+            if (ghostTimer)
+                clearTimeout(ghostTimer);
+            ghostHost = host;
+            ghostTimer = setTimeout(() => {
+                host.classList.remove('axdb-ghost');
+                ghostTimer = null;
+                if (ghostHost === host)
+                    ghostHost = null;
+            }, 60);
+        }
+    };
+    const dispose = () => {
+        var _a;
+        hidePlaceholder();
+        if (glideTimer)
+            clearTimeout(glideTimer);
+        glideTimer = null;
+        // A rebind inside the 60 ms window (a layout switch right after an undo)
+        // disposed this binder with the timer pending — the host kept its
+        // lifted ghost for good (visual gate, nested-containers ⑤).
+        flushGhost();
+        (_a = ctx.htmlLayer()) === null || _a === void 0 ? void 0 : _a.classList.remove('axdb-glide');
+        void api;
+    };
+    return { writeRect, enforceBoardHeight, project, syncPlaceholder, hidePlaceholder, armGlide, disarmGlideSoon, flushGhost, setGhost, dispose };
+}
+//# sourceMappingURL=project.js.map