@one-grid-core/angular 0.1.0-beta.5 → 0.2.0

package/esm2022/lib/core/services/one-grid-row-drag.service.mjs

@@ -0,0 +1,351 @@
+import { Injectable, NgZone, inject } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+/** Pointer distance before a press becomes a drag. */
+const DRAG_THRESHOLD_PX = 4;
+/** How close to an edge auto-scroll kicks in, and how fast it goes. */
+const EDGE_ZONE_PX = 36;
+const EDGE_SPEED_PX = 12;
+/**
+ * Owns one row-drag gesture at a time.
+ *
+ * Built on pointer events rather than HTML5 drag-and-drop or the CDK's
+ * drag-drop:
+ *
+ * - HTML5 DnD does not fire for touch at all, and its drag image cannot be
+ *   styled to match the grid.
+ * - `cdkDropList` assumes every item it manages is in the DOM. Inside a virtual
+ *   scroll viewport rows unmount as they leave the buffer, so the list it
+ *   thinks it is sorting is only ever the visible window.
+ * - Pointer events cover mouse, touch and pen in one path, and pointer capture
+ *   keeps the gesture alive when the finger leaves the row it started on.
+ *
+ * Because rows are a fixed `itemSize`, the drop target is arithmetic on the
+ * pointer's Y rather than a hit test against row elements — which is also why
+ * it stays correct for rows that are scrolled out and not rendered.
+ */
+export class OneGridRowDragService {
+    constructor() {
+        this.zone = inject(NgZone);
+        /** Live drag, for the body to render the handle state and the indicator. */
+        this.state$ = new BehaviorSubject(null);
+        /** Screen-reader narration for the keyboard path. */
+        this.announcement$ = new BehaviorSubject('');
+        this.context = null;
+        this.pointerId = null;
+        this.handle = null;
+        this.startY = 0;
+        this.armed = false;
+        this.lastClientY = 0;
+        this.scrollFrame = null;
+        /** A move already applied during this drag, so a cancel can undo it. */
+        this.appliedFrom = null;
+        this.handlePointerMove = (event) => {
+            if (this.pointerId === null || event.pointerId !== this.pointerId)
+                return;
+            if (!this.armed) {
+                if (Math.abs(event.clientY - this.startY) < DRAG_THRESHOLD_PX)
+                    return;
+                this.armed = true;
+                this.publish({ rowId: this.nodeAt(this.appliedFrom)?.rowId ?? '', fromIndex: this.appliedFrom, insertAt: this.appliedFrom, source: 'pointer' });
+            }
+            // Held so the auto-scroll loop can recompute the target as the viewport
+            // moves under a stationary finger.
+            this.lastClientY = event.clientY;
+            // Touch scrolling would otherwise pan the viewport out from under us.
+            event.preventDefault();
+            this.updateFromPointer();
+            this.updateAutoScroll();
+        };
+        this.handlePointerUp = (event) => {
+            if (this.pointerId === null || event.pointerId !== this.pointerId)
+                return;
+            const dragged = this.armed;
+            this.teardownPointer();
+            if (!dragged) {
+                this.reset();
+                return;
+            }
+            this.commit('pointer');
+        };
+        this.handlePointerCancel = () => {
+            this.teardownPointer();
+            this.cancel();
+        };
+        /** Escape aborts a pointer drag, the same as it does a keyboard one. */
+        this.handlePointerKeydown = (event) => {
+            if (event.key !== 'Escape')
+                return;
+            event.preventDefault();
+            this.teardownPointer();
+            this.cancel();
+        };
+    }
+    attach(context) {
+        this.context = context;
+    }
+    get state() {
+        return this.state$.value;
+    }
+    get dragging() {
+        return this.state$.value !== null;
+    }
+    // -------------------------------------------------------------------------
+    // Pointer
+    // -------------------------------------------------------------------------
+    /**
+     * Begin a pointer drag. Nothing visible happens until the pointer has moved
+     * {@link DRAG_THRESHOLD_PX}, so a click on the handle — which is also the
+     * keyboard affordance — is not swallowed by a zero-distance drag.
+     */
+    startPointerDrag(event, node, handlers = {}) {
+        if (!this.context || this.dragging || this.pointerId !== null)
+            return;
+        // Secondary buttons open context menus; they are not a drag.
+        if (event.button !== 0)
+            return;
+        const index = this.indexOf(node);
+        if (index === -1)
+            return;
+        this.pointerId = event.pointerId;
+        this.handle = event.target;
+        this.startY = event.clientY;
+        this.lastClientY = event.clientY;
+        this.armed = false;
+        this.appliedFrom = index;
+        this.onEnd = handlers.onEnd;
+        this.handle.setPointerCapture?.(event.pointerId);
+        // Outside Angular: pointermove fires at the display's refresh rate and
+        // every one of them would otherwise run change detection over the grid.
+        // The few that change the drop target re-enter through `publish`.
+        this.zone.runOutsideAngular(() => {
+            document.addEventListener('pointermove', this.handlePointerMove, { passive: false });
+            document.addEventListener('pointerup', this.handlePointerUp);
+            document.addEventListener('pointercancel', this.handlePointerCancel);
+            document.addEventListener('keydown', this.handlePointerKeydown);
+        });
+    }
+    /**
+     * Turn the pointer's Y into an insertion boundary.
+     *
+     * Boundaries, not rows: the value is where the row would be *inserted*, so
+     * 0 is above the first row and `length` is below the last. Rounding rather
+     * than flooring puts the split at the middle of each row, which is what
+     * makes the indicator flip when you cross the halfway point.
+     */
+    updateFromPointer() {
+        const current = this.state$.value;
+        if (!this.context || !current)
+            return;
+        const rect = this.context.viewport.getBoundingClientRect();
+        const offset = this.lastClientY - rect.top + this.context.viewport.scrollTop;
+        const insertAt = this.clamp(Math.round(offset / this.context.itemSize), 0, this.context.nodes().length);
+        if (insertAt === current.insertAt)
+            return;
+        this.publish({ ...current, insertAt });
+    }
+    /**
+     * Scroll when the pointer sits near an edge, so rows outside the viewport
+     * are reachable without letting go. Runs on rAF while the pointer is parked
+     * in the zone, and re-derives the target each frame because the content
+     * moves while the pointer does not.
+     */
+    updateAutoScroll() {
+        if (!this.context)
+            return;
+        const rect = this.context.viewport.getBoundingClientRect();
+        const distanceToTop = this.lastClientY - rect.top;
+        const distanceToBottom = rect.bottom - this.lastClientY;
+        let delta = 0;
+        if (distanceToTop < EDGE_ZONE_PX)
+            delta = -EDGE_SPEED_PX;
+        else if (distanceToBottom < EDGE_ZONE_PX)
+            delta = EDGE_SPEED_PX;
+        if (delta === 0) {
+            this.stopAutoScroll();
+            return;
+        }
+        if (this.scrollFrame !== null)
+            return;
+        const step = () => {
+            if (!this.context || !this.dragging) {
+                this.stopAutoScroll();
+                return;
+            }
+            const viewport = this.context.viewport;
+            const before = viewport.scrollTop;
+            viewport.scrollTop = before + delta;
+            // Hit the end — nothing more to reveal, so stop burning frames.
+            if (viewport.scrollTop === before) {
+                this.stopAutoScroll();
+                return;
+            }
+            this.updateFromPointer();
+            this.scrollFrame = requestAnimationFrame(step);
+        };
+        this.scrollFrame = requestAnimationFrame(step);
+    }
+    stopAutoScroll() {
+        if (this.scrollFrame === null)
+            return;
+        cancelAnimationFrame(this.scrollFrame);
+        this.scrollFrame = null;
+    }
+    teardownPointer() {
+        this.stopAutoScroll();
+        if (this.handle && this.pointerId !== null) {
+            this.handle.releasePointerCapture?.(this.pointerId);
+        }
+        document.removeEventListener('pointermove', this.handlePointerMove);
+        document.removeEventListener('pointerup', this.handlePointerUp);
+        document.removeEventListener('pointercancel', this.handlePointerCancel);
+        document.removeEventListener('keydown', this.handlePointerKeydown);
+        this.pointerId = null;
+        this.handle = null;
+        this.armed = false;
+    }
+    // -------------------------------------------------------------------------
+    // Keyboard
+    //
+    // WCAG 2.5.7 Dragging Movements: anything achievable by dragging needs a
+    // single-pointer, non-dragging alternative. Arrow-key moves are that, and
+    // they are also simply how a keyboard user reorders a list.
+    // -------------------------------------------------------------------------
+    /** Space/Enter on the handle: pick the row up, or put it down. */
+    toggleKeyboardDrag(node, handlers = {}) {
+        if (!this.context)
+            return;
+        if (this.state$.value?.source === 'keyboard') {
+            this.commit('keyboard');
+            return;
+        }
+        if (this.dragging)
+            return;
+        const index = this.indexOf(node);
+        if (index === -1)
+            return;
+        this.appliedFrom = index;
+        this.onEnd = handlers.onEnd;
+        this.publish({ rowId: node.rowId, fromIndex: index, insertAt: index, source: 'keyboard' });
+        this.announce(`${this.describe(node, index)} grabbed. Use the arrow keys to move it, space to drop, escape to cancel.`);
+    }
+    /**
+     * Arrow keys move the row a position at a time, applying as they go.
+     *
+     * Applied rather than previewed because the row has to be seen to move: a
+     * keyboard user gets no drag image, and a preview line alone tells someone
+     * relying on a screen reader nothing about where the row now sits. Escape
+     * still restores the original position.
+     */
+    moveKeyboard(delta) {
+        const current = this.state$.value;
+        if (!this.context || current?.source !== 'keyboard')
+            return false;
+        const nodes = this.context.nodes();
+        const from = current.insertAt;
+        const to = this.clamp(from + delta, 0, nodes.length - 1);
+        if (to === from) {
+            this.announce(to === 0 ? 'Already at the top.' : 'Already at the bottom.');
+            return true;
+        }
+        if (!this.context.move(from, to))
+            return true;
+        this.publish({ ...current, insertAt: to });
+        const node = this.nodeAt(to);
+        this.announce(node ? `Moved to position ${to + 1} of ${nodes.length}.` : '');
+        return true;
+    }
+    // -------------------------------------------------------------------------
+    // Commit / cancel
+    // -------------------------------------------------------------------------
+    commit(source) {
+        const current = this.state$.value;
+        if (!this.context || !current) {
+            this.reset();
+            return;
+        }
+        const nodes = this.context.nodes();
+        // Pointer drags apply once, at the end. A boundary index becomes a row
+        // index by dropping one when the row travelled downwards, since lifting
+        // it out first shifts everything below it up.
+        if (source === 'pointer') {
+            const from = current.fromIndex;
+            const to = this.clamp(current.insertAt > from ? current.insertAt - 1 : current.insertAt, 0, nodes.length - 1);
+            const node = this.nodeAt(from);
+            if (node && to !== from && this.context.move(from, to)) {
+                this.finish({ node, fromIndex: from, toIndex: to, source });
+                return;
+            }
+            this.reset();
+            return;
+        }
+        // Keyboard moves were applied as they happened; this only confirms.
+        const node = this.nodeAt(current.insertAt);
+        const moved = node && current.insertAt !== current.fromIndex;
+        this.announce(moved ? `Dropped at position ${current.insertAt + 1} of ${nodes.length}.` : 'Cancelled. Row returned to its original position.');
+        if (moved) {
+            this.finish({ node: node, fromIndex: current.fromIndex, toIndex: current.insertAt, source });
+            return;
+        }
+        this.reset();
+    }
+    /** Abort, restoring anything a keyboard drag already applied. */
+    cancel() {
+        const current = this.state$.value;
+        if (current?.source === 'keyboard' && this.context && current.insertAt !== current.fromIndex) {
+            this.context.move(current.insertAt, current.fromIndex);
+            this.announce('Cancelled. Row returned to its original position.');
+        }
+        else if (current) {
+            this.announce('Cancelled.');
+        }
+        this.reset();
+    }
+    finish(event) {
+        const done = this.onEnd;
+        this.reset();
+        this.zone.run(() => done?.(event));
+    }
+    reset() {
+        this.stopAutoScroll();
+        this.appliedFrom = null;
+        this.onEnd = undefined;
+        if (this.state$.value !== null) {
+            this.zone.run(() => this.state$.next(null));
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Helpers
+    // -------------------------------------------------------------------------
+    publish(state) {
+        this.zone.run(() => this.state$.next(state));
+    }
+    announce(message) {
+        this.zone.run(() => this.announcement$.next(message));
+    }
+    describe(node, index) {
+        return `Row ${index + 1} of ${this.context?.nodes().length ?? 0},`;
+    }
+    indexOf(node) {
+        return this.context?.nodes().findIndex(candidate => candidate.rowId === node.rowId) ?? -1;
+    }
+    nodeAt(index) {
+        return this.context?.nodes()[index] ?? null;
+    }
+    clamp(value, min, max) {
+        return Math.min(Math.max(value, min), max);
+    }
+    ngOnDestroy() {
+        this.teardownPointer();
+        this.state$.next(null);
+        this.state$.complete();
+        this.announcement$.complete();
+        this.context = null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OneGridRowDragService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OneGridRowDragService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OneGridRowDragService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"one-grid-row-drag.service.js","sourceRoot":"","sources":["../../../../../../projects/one-grid/src/lib/core/services/one-grid-row-drag.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, NgZone, OnDestroy, inject } from '@angular/core';\nimport { BehaviorSubject } from 'rxjs';\nimport { OneRowDragEvent, OneRowDragState } from '../models/one-row-drag.model';\nimport { OneRowNode } from '../instants/one-row-node.class';\n\n/** What the body has to lend the service to run a drag. */\nexport interface OneRowDragContext<T = any> {\n\n    /** The scrolling element the rows live in. */\n    viewport: HTMLElement;\n\n    /** Fixed row height. The whole index calculation rests on rows being uniform. */\n    itemSize: number;\n\n    /** Current display order. Read fresh on every move — a drag mutates it. */\n    nodes: () => OneRowNode<T>[];\n\n    /** Apply the move. Returns false if the grid refused it. */\n    move: (fromIndex: number, toIndex: number) => boolean;\n}\n\n/** Pointer distance before a press becomes a drag. */\nconst DRAG_THRESHOLD_PX = 4;\n\n/** How close to an edge auto-scroll kicks in, and how fast it goes. */\nconst EDGE_ZONE_PX = 36;\nconst EDGE_SPEED_PX = 12;\n\n/**\n * Owns one row-drag gesture at a time.\n *\n * Built on pointer events rather than HTML5 drag-and-drop or the CDK's\n * drag-drop:\n *\n * - HTML5 DnD does not fire for touch at all, and its drag image cannot be\n *   styled to match the grid.\n * - `cdkDropList` assumes every item it manages is in the DOM. Inside a virtual\n *   scroll viewport rows unmount as they leave the buffer, so the list it\n *   thinks it is sorting is only ever the visible window.\n * - Pointer events cover mouse, touch and pen in one path, and pointer capture\n *   keeps the gesture alive when the finger leaves the row it started on.\n *\n * Because rows are a fixed `itemSize`, the drop target is arithmetic on the\n * pointer's Y rather than a hit test against row elements — which is also why\n * it stays correct for rows that are scrolled out and not rendered.\n */\n@Injectable()\nexport class OneGridRowDragService<T = any> implements OnDestroy {\n\n    private readonly zone = inject(NgZone);\n\n    /** Live drag, for the body to render the handle state and the indicator. */\n    readonly state$ = new BehaviorSubject<OneRowDragState | null>(null);\n\n    /** Screen-reader narration for the keyboard path. */\n    readonly announcement$ = new BehaviorSubject<string>('');\n\n    private context: OneRowDragContext<T> | null = null;\n\n    private pointerId: number | null = null;\n    private handle: HTMLElement | null = null;\n    private startY = 0;\n    private armed = false;\n    private lastClientY = 0;\n    private scrollFrame: number | null = null;\n\n    /** A move already applied during this drag, so a cancel can undo it. */\n    private appliedFrom: number | null = null;\n\n    private onMove?: (event: OneRowDragEvent<T>) => void;\n    private onEnd?: (event: OneRowDragEvent<T> | null) => void;\n\n    attach(context: OneRowDragContext<T>): void {\n\n        this.context = context;\n    }\n\n    get state(): OneRowDragState | null {\n\n        return this.state$.value;\n    }\n\n    get dragging(): boolean {\n\n        return this.state$.value !== null;\n    }\n\n    // -------------------------------------------------------------------------\n    // Pointer\n    // -------------------------------------------------------------------------\n\n    /**\n     * Begin a pointer drag. Nothing visible happens until the pointer has moved\n     * {@link DRAG_THRESHOLD_PX}, so a click on the handle — which is also the\n     * keyboard affordance — is not swallowed by a zero-distance drag.\n     */\n    startPointerDrag(\n        event: PointerEvent,\n        node: OneRowNode<T>,\n        handlers: { onEnd?: (event: OneRowDragEvent<T> | null) => void } = {},\n    ): void {\n\n        if (!this.context || this.dragging || this.pointerId !== null) return;\n\n        // Secondary buttons open context menus; they are not a drag.\n        if (event.button !== 0) return;\n\n        const index = this.indexOf(node);\n\n        if (index === -1) return;\n\n        this.pointerId = event.pointerId;\n        this.handle = event.target as HTMLElement;\n        this.startY = event.clientY;\n        this.lastClientY = event.clientY;\n        this.armed = false;\n        this.appliedFrom = index;\n        this.onEnd = handlers.onEnd;\n\n        this.handle.setPointerCapture?.(event.pointerId);\n\n        // Outside Angular: pointermove fires at the display's refresh rate and\n        // every one of them would otherwise run change detection over the grid.\n        // The few that change the drop target re-enter through `publish`.\n        this.zone.runOutsideAngular(() => {\n            document.addEventListener('pointermove', this.handlePointerMove, { passive: false });\n            document.addEventListener('pointerup', this.handlePointerUp);\n            document.addEventListener('pointercancel', this.handlePointerCancel);\n            document.addEventListener('keydown', this.handlePointerKeydown);\n        });\n    }\n\n    private handlePointerMove = (event: PointerEvent): void => {\n\n        if (this.pointerId === null || event.pointerId !== this.pointerId) return;\n\n        if (!this.armed) {\n\n            if (Math.abs(event.clientY - this.startY) < DRAG_THRESHOLD_PX) return;\n\n            this.armed = true;\n\n            this.publish({ rowId: this.nodeAt(this.appliedFrom!)?.rowId ?? '', fromIndex: this.appliedFrom!, insertAt: this.appliedFrom!, source: 'pointer' });\n        }\n\n        // Held so the auto-scroll loop can recompute the target as the viewport\n        // moves under a stationary finger.\n        this.lastClientY = event.clientY;\n\n        // Touch scrolling would otherwise pan the viewport out from under us.\n        event.preventDefault();\n\n        this.updateFromPointer();\n        this.updateAutoScroll();\n    };\n\n    private handlePointerUp = (event: PointerEvent): void => {\n\n        if (this.pointerId === null || event.pointerId !== this.pointerId) return;\n\n        const dragged = this.armed;\n\n        this.teardownPointer();\n\n        if (!dragged) {\n\n            this.reset();\n\n            return;\n        }\n\n        this.commit('pointer');\n    };\n\n    private handlePointerCancel = (): void => {\n\n        this.teardownPointer();\n\n        this.cancel();\n    };\n\n    /** Escape aborts a pointer drag, the same as it does a keyboard one. */\n    private handlePointerKeydown = (event: KeyboardEvent): void => {\n\n        if (event.key !== 'Escape') return;\n\n        event.preventDefault();\n\n        this.teardownPointer();\n\n        this.cancel();\n    };\n\n    /**\n     * Turn the pointer's Y into an insertion boundary.\n     *\n     * Boundaries, not rows: the value is where the row would be *inserted*, so\n     * 0 is above the first row and `length` is below the last. Rounding rather\n     * than flooring puts the split at the middle of each row, which is what\n     * makes the indicator flip when you cross the halfway point.\n     */\n    private updateFromPointer(): void {\n\n        const current = this.state$.value;\n\n        if (!this.context || !current) return;\n\n        const rect = this.context.viewport.getBoundingClientRect();\n        const offset = this.lastClientY - rect.top + this.context.viewport.scrollTop;\n\n        const insertAt = this.clamp(Math.round(offset / this.context.itemSize), 0, this.context.nodes().length);\n\n        if (insertAt === current.insertAt) return;\n\n        this.publish({ ...current, insertAt });\n    }\n\n    /**\n     * Scroll when the pointer sits near an edge, so rows outside the viewport\n     * are reachable without letting go. Runs on rAF while the pointer is parked\n     * in the zone, and re-derives the target each frame because the content\n     * moves while the pointer does not.\n     */\n    private updateAutoScroll(): void {\n\n        if (!this.context) return;\n\n        const rect = this.context.viewport.getBoundingClientRect();\n\n        const distanceToTop = this.lastClientY - rect.top;\n        const distanceToBottom = rect.bottom - this.lastClientY;\n\n        let delta = 0;\n\n        if (distanceToTop < EDGE_ZONE_PX) delta = -EDGE_SPEED_PX;\n        else if (distanceToBottom < EDGE_ZONE_PX) delta = EDGE_SPEED_PX;\n\n        if (delta === 0) {\n\n            this.stopAutoScroll();\n\n            return;\n        }\n\n        if (this.scrollFrame !== null) return;\n\n        const step = (): void => {\n\n            if (!this.context || !this.dragging) {\n\n                this.stopAutoScroll();\n\n                return;\n            }\n\n            const viewport = this.context.viewport;\n            const before = viewport.scrollTop;\n\n            viewport.scrollTop = before + delta;\n\n            // Hit the end — nothing more to reveal, so stop burning frames.\n            if (viewport.scrollTop === before) {\n\n                this.stopAutoScroll();\n\n                return;\n            }\n\n            this.updateFromPointer();\n\n            this.scrollFrame = requestAnimationFrame(step);\n        };\n\n        this.scrollFrame = requestAnimationFrame(step);\n    }\n\n    private stopAutoScroll(): void {\n\n        if (this.scrollFrame === null) return;\n\n        cancelAnimationFrame(this.scrollFrame);\n\n        this.scrollFrame = null;\n    }\n\n    private teardownPointer(): void {\n\n        this.stopAutoScroll();\n\n        if (this.handle && this.pointerId !== null) {\n\n            this.handle.releasePointerCapture?.(this.pointerId);\n        }\n\n        document.removeEventListener('pointermove', this.handlePointerMove);\n        document.removeEventListener('pointerup', this.handlePointerUp);\n        document.removeEventListener('pointercancel', this.handlePointerCancel);\n        document.removeEventListener('keydown', this.handlePointerKeydown);\n\n        this.pointerId = null;\n        this.handle = null;\n        this.armed = false;\n    }\n\n    // -------------------------------------------------------------------------\n    // Keyboard\n    //\n    // WCAG 2.5.7 Dragging Movements: anything achievable by dragging needs a\n    // single-pointer, non-dragging alternative. Arrow-key moves are that, and\n    // they are also simply how a keyboard user reorders a list.\n    // -------------------------------------------------------------------------\n\n    /** Space/Enter on the handle: pick the row up, or put it down. */\n    toggleKeyboardDrag(node: OneRowNode<T>, handlers: { onEnd?: (event: OneRowDragEvent<T> | null) => void } = {}): void {\n\n        if (!this.context) return;\n\n        if (this.state$.value?.source === 'keyboard') {\n\n            this.commit('keyboard');\n\n            return;\n        }\n\n        if (this.dragging) return;\n\n        const index = this.indexOf(node);\n\n        if (index === -1) return;\n\n        this.appliedFrom = index;\n        this.onEnd = handlers.onEnd;\n\n        this.publish({ rowId: node.rowId, fromIndex: index, insertAt: index, source: 'keyboard' });\n\n        this.announce(`${this.describe(node, index)} grabbed. Use the arrow keys to move it, space to drop, escape to cancel.`);\n    }\n\n    /**\n     * Arrow keys move the row a position at a time, applying as they go.\n     *\n     * Applied rather than previewed because the row has to be seen to move: a\n     * keyboard user gets no drag image, and a preview line alone tells someone\n     * relying on a screen reader nothing about where the row now sits. Escape\n     * still restores the original position.\n     */\n    moveKeyboard(delta: number): boolean {\n\n        const current = this.state$.value;\n\n        if (!this.context || current?.source !== 'keyboard') return false;\n\n        const nodes = this.context.nodes();\n        const from = current.insertAt;\n        const to = this.clamp(from + delta, 0, nodes.length - 1);\n\n        if (to === from) {\n\n            this.announce(to === 0 ? 'Already at the top.' : 'Already at the bottom.');\n\n            return true;\n        }\n\n        if (!this.context.move(from, to)) return true;\n\n        this.publish({ ...current, insertAt: to });\n\n        const node = this.nodeAt(to);\n\n        this.announce(node ? `Moved to position ${to + 1} of ${nodes.length}.` : '');\n\n        return true;\n    }\n\n    // -------------------------------------------------------------------------\n    // Commit / cancel\n    // -------------------------------------------------------------------------\n\n    private commit(source: 'pointer' | 'keyboard'): void {\n\n        const current = this.state$.value;\n\n        if (!this.context || !current) {\n\n            this.reset();\n\n            return;\n        }\n\n        const nodes = this.context.nodes();\n\n        // Pointer drags apply once, at the end. A boundary index becomes a row\n        // index by dropping one when the row travelled downwards, since lifting\n        // it out first shifts everything below it up.\n        if (source === 'pointer') {\n\n            const from = current.fromIndex;\n            const to = this.clamp(current.insertAt > from ? current.insertAt - 1 : current.insertAt, 0, nodes.length - 1);\n\n            const node = this.nodeAt(from);\n\n            if (node && to !== from && this.context.move(from, to)) {\n\n                this.finish({ node, fromIndex: from, toIndex: to, source });\n\n                return;\n            }\n\n            this.reset();\n\n            return;\n        }\n\n        // Keyboard moves were applied as they happened; this only confirms.\n        const node = this.nodeAt(current.insertAt);\n\n        const moved = node && current.insertAt !== current.fromIndex;\n\n        this.announce(moved ? `Dropped at position ${current.insertAt + 1} of ${nodes.length}.` : 'Cancelled. Row returned to its original position.');\n\n        if (moved) {\n\n            this.finish({ node: node!, fromIndex: current.fromIndex, toIndex: current.insertAt, source });\n\n            return;\n        }\n\n        this.reset();\n    }\n\n    /** Abort, restoring anything a keyboard drag already applied. */\n    cancel(): void {\n\n        const current = this.state$.value;\n\n        if (current?.source === 'keyboard' && this.context && current.insertAt !== current.fromIndex) {\n\n            this.context.move(current.insertAt, current.fromIndex);\n\n            this.announce('Cancelled. Row returned to its original position.');\n\n        } else if (current) {\n\n            this.announce('Cancelled.');\n        }\n\n        this.reset();\n    }\n\n    private finish(event: OneRowDragEvent<T>): void {\n\n        const done = this.onEnd;\n\n        this.reset();\n\n        this.zone.run(() => done?.(event));\n    }\n\n    private reset(): void {\n\n        this.stopAutoScroll();\n\n        this.appliedFrom = null;\n        this.onEnd = undefined;\n\n        if (this.state$.value !== null) {\n\n            this.zone.run(() => this.state$.next(null));\n        }\n    }\n\n    // -------------------------------------------------------------------------\n    // Helpers\n    // -------------------------------------------------------------------------\n\n    private publish(state: OneRowDragState): void {\n\n        this.zone.run(() => this.state$.next(state));\n    }\n\n    private announce(message: string): void {\n\n        this.zone.run(() => this.announcement$.next(message));\n    }\n\n    private describe(node: OneRowNode<T>, index: number): string {\n\n        return `Row ${index + 1} of ${this.context?.nodes().length ?? 0},`;\n    }\n\n    private indexOf(node: OneRowNode<T>): number {\n\n        return this.context?.nodes().findIndex(candidate => candidate.rowId === node.rowId) ?? -1;\n    }\n\n    private nodeAt(index: number): OneRowNode<T> | null {\n\n        return this.context?.nodes()[index] ?? null;\n    }\n\n    private clamp(value: number, min: number, max: number): number {\n\n        return Math.min(Math.max(value, min), max);\n    }\n\n    ngOnDestroy(): void {\n\n        this.teardownPointer();\n\n        this.state$.next(null);\n        this.state$.complete();\n        this.announcement$.complete();\n\n        this.context = null;\n    }\n}\n"]}

package/esm2022/lib/core/services/one-grid-selection.service.mjs

@@ -31,13 +31,26 @@ export class OneGridSelectionService {
     toggleAllSelection(allIds, selected) {
         selected ? this._selectedIds = new Set(allIds) : this._selectedIds.clear();
     }
-    // Header Checkbox State
+    /**
+     * Tri-state for the header checkbox, over the rows currently present.
+     *
+     * This compared `_selectedIds.size` with `allIds.length` and never checked
+     * that the selected ids were among the present ones. Selecting two rows and
+     * then swapping in two different rows reported `checked` with nothing
+     * actually selected, because the two counts happened to match. Counting the
+     * intersection is the only thing that answers the question being asked.
+     */
     getSelectAllState(allIds) {
-        if (this._selectedIds.size === 0)
+        if (!allIds?.length)
             return 'unchecked';
-        if (this._selectedIds.size === allIds.length)
-            return 'checked';
-        return 'indeterminate';
+        let selected = 0;
+        for (const rowId of allIds) {
+            if (this._selectedIds.has(rowId))
+                selected++;
+        }
+        if (selected === 0)
+            return 'unchecked';
+        return selected === allIds.length ? 'checked' : 'indeterminate';
     }
     selectAll(rowIds) {
         this._selectedIds = new Set(rowIds);
@@ -51,4 +64,4 @@ export class OneGridSelectionService {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OneGridSelectionService, decorators: [{
             type: Injectable
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib25lLWdyaWQtc2VsZWN0aW9uLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9vbmUtZ3JpZC9zcmMvbGliL2NvcmUvc2VydmljZXMvb25lLWdyaWQtc2VsZWN0aW9uLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFJM0MsTUFBTSxPQUFPLHVCQUF1QjtJQURwQztRQUdVLGlCQUFZLEdBQUcsSUFBSSxHQUFHLEVBQVUsQ0FBQztRQUNqQyxtQkFBYyxHQUFxQixJQUFJLENBQUM7S0FnRWpEO0lBOURRLGNBQWM7UUFFbkIsT0FBTyxJQUFJLENBQUMsWUFBWSxDQUFDO0lBQzNCLENBQUM7SUFFTSxjQUFjLENBQUMsTUFBZ0I7UUFFcEMsSUFBSSxDQUFDLFlBQVksR0FBRyxJQUFJLEdBQUcsQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUN0QyxDQUFDO0lBRU0sZ0JBQWdCO1FBRXJCLE9BQU8sSUFBSSxDQUFDLGNBQWMsQ0FBQztJQUM3QixDQUFDO0lBRU0sZ0JBQWdCLENBQUMsSUFBc0I7UUFFNUMsSUFBSSxDQUFDLGNBQWMsR0FBRyxJQUFJLENBQUM7UUFFM0IsSUFBSSxJQUFJLEtBQUssUUFBUSxJQUFJLElBQUksQ0FBQyxZQUFZLENBQUMsSUFBSSxHQUFHLENBQUMsRUFBRSxDQUFDO1lBRXBELGtDQUFrQztZQUNsQyxNQUFNLEtBQUssR0FBRyxJQUFJLENBQUMsWUFBWSxDQUFDLE1BQU0sRUFBRSxDQUFDLElBQUksRUFBRSxDQUFDLEtBQUssQ0FBQztZQUV0RCxJQUFJLENBQUMsWUFBWSxHQUFHLElBQUksR0FBRyxDQUFDLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQztRQUN2QyxDQUFDO0lBQ0gsQ0FBQztJQUVNLGVBQWUsQ0FBQyxLQUFhLEVBQUUsUUFBaUI7UUFFckQsSUFBSSxJQUFJLENBQUMsY0FBYyxLQUFLLFFBQVEsRUFBRSxDQUFDO1lBRXJDLElBQUksQ0FBQyxZQUFZLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDNUIsQ0FBQztRQUVELFFBQVEsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxZQUFZLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQzVFLENBQUM7SUFFTSxrQkFBa0IsQ0FBQyxNQUFnQixFQUFFLFFBQWlCO1FBRTNELFFBQVEsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLFlBQVksR0FBRyxJQUFJLEdBQUcsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxLQUFLLEVBQUUsQ0FBQztJQUM3RSxDQUFDO0lBRUQsd0JBQXdCO0lBQ2pCLGlCQUFpQixDQUFDLE1BQWtCO1FBRXpDLElBQUksSUFBSSxDQUFDLFlBQVksQ0FBQyxJQUFJLEtBQUssQ0FBQztZQUFFLE9BQU8sV0FBVyxDQUFDO1FBRXJELElBQUksSUFBSSxDQUFDLFlBQVksQ0FBQyxJQUFJLEtBQUssTUFBTSxDQUFDLE1BQU07WUFBRSxPQUFPLFNBQVMsQ0FBQztRQUUvRCxPQUFPLGVBQWUsQ0FBQztJQUN6QixDQUFDO0lBRU0sU0FBUyxDQUFDLE1BQWdCO1FBRS9CLElBQUksQ0FBQyxZQUFZLEdBQUcsSUFBSSxHQUFHLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDdEMsQ0FBQztJQUVNLFdBQVc7UUFFaEIsSUFBSSxDQUFDLFlBQVksQ0FBQyxLQUFLLEVBQUUsQ0FBQztJQUM1QixDQUFDOytHQWxFVSx1QkFBdUI7bUhBQXZCLHVCQUF1Qjs7NEZBQXZCLHVCQUF1QjtrQkFEbkMsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IE9uZUNoZWNrYm94U3RhdGUsIFJvd1NlbGVjdGlvbk1vZGUgfSBmcm9tICcuLi9tb2RlbHMvb25lLWV2ZW50LXR5cGVzLm1vZGVsJztcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIE9uZUdyaWRTZWxlY3Rpb25TZXJ2aWNlIHtcblxuICBwcml2YXRlIF9zZWxlY3RlZElkcyA9IG5ldyBTZXQ8c3RyaW5nPigpO1xuICBwcml2YXRlIF9zZWxlY3Rpb25Nb2RlOiBSb3dTZWxlY3Rpb25Nb2RlID0gbnVsbDtcblxuICBwdWJsaWMgZ2V0U2VsZWN0ZWRJZHMoKTogU2V0PHN0cmluZz4ge1xuXG4gICAgcmV0dXJuIHRoaXMuX3NlbGVjdGVkSWRzO1xuICB9XG5cbiAgcHVibGljIHNldFNlbGVjdGVkSWRzKHJvd0lkczogc3RyaW5nW10pIHtcblxuICAgIHRoaXMuX3NlbGVjdGVkSWRzID0gbmV3IFNldChyb3dJZHMpO1xuICB9XG5cbiAgcHVibGljIGdldFNlbGVjdGlvbk1vZGUoKTogUm93U2VsZWN0aW9uTW9kZSB7XG5cbiAgICByZXR1cm4gdGhpcy5fc2VsZWN0aW9uTW9kZTtcbiAgfVxuXG4gIHB1YmxpYyBzZXRTZWxlY3Rpb25Nb2RlKG1vZGU6IFJvd1NlbGVjdGlvbk1vZGUpIHtcblxuICAgIHRoaXMuX3NlbGVjdGlvbk1vZGUgPSBtb2RlO1xuXG4gICAgaWYgKG1vZGUgPT09ICdzaW5nbGUnICYmIHRoaXMuX3NlbGVjdGVkSWRzLnNpemUgPiAxKSB7XG5cbiAgICAgIC8vIGtlZXAgb25seSBvbmUgaWYgbW9kZSBpcyBzaW5nbGVcbiAgICAgIGNvbnN0IGZpcnN0ID0gdGhpcy5fc2VsZWN0ZWRJZHMudmFsdWVzKCkubmV4dCgpLnZhbHVlO1xuXG4gICAgICB0aGlzLl9zZWxlY3RlZElkcyA9IG5ldyBTZXQoW2ZpcnN0XSk7XG4gICAgfVxuICB9XG5cbiAgcHVibGljIHRvZ2dsZVNlbGVjdGlvbihyb3dJZDogc3RyaW5nLCBzZWxlY3RlZDogYm9vbGVhbikge1xuXG4gICAgaWYgKHRoaXMuX3NlbGVjdGlvbk1vZGUgPT09ICdzaW5nbGUnKSB7XG5cbiAgICAgIHRoaXMuX3NlbGVjdGVkSWRzLmNsZWFyKCk7XG4gICAgfVxuXG4gICAgc2VsZWN0ZWQgPyB0aGlzLl9zZWxlY3RlZElkcy5hZGQocm93SWQpIDogdGhpcy5fc2VsZWN0ZWRJZHMuZGVsZXRlKHJvd0lkKTtcbiAgfVxuXG4gIHB1YmxpYyB0b2dnbGVBbGxTZWxlY3Rpb24oYWxsSWRzOiBzdHJpbmdbXSwgc2VsZWN0ZWQ6IGJvb2xlYW4pIHtcblxuICAgIHNlbGVjdGVkID8gdGhpcy5fc2VsZWN0ZWRJZHMgPSBuZXcgU2V0KGFsbElkcykgOiB0aGlzLl9zZWxlY3RlZElkcy5jbGVhcigpO1xuICB9XG5cbiAgLy8gSGVhZGVyIENoZWNrYm94IFN0YXRlXG4gIHB1YmxpYyBnZXRTZWxlY3RBbGxTdGF0ZShhbGxJZHM6IChzdHJpbmcpW10pOiBPbmVDaGVja2JveFN0YXRlIHtcblxuICAgIGlmICh0aGlzLl9zZWxlY3RlZElkcy5zaXplID09PSAwKSByZXR1cm4gJ3VuY2hlY2tlZCc7XG5cbiAgICBpZiAodGhpcy5fc2VsZWN0ZWRJZHMuc2l6ZSA9PT0gYWxsSWRzLmxlbmd0aCkgcmV0dXJuICdjaGVja2VkJztcblxuICAgIHJldHVybiAnaW5kZXRlcm1pbmF0ZSc7XG4gIH1cblxuICBwdWJsaWMgc2VsZWN0QWxsKHJvd0lkczogc3RyaW5nW10pOiB2b2lkIHtcblxuICAgIHRoaXMuX3NlbGVjdGVkSWRzID0gbmV3IFNldChyb3dJZHMpO1xuICB9XG5cbiAgcHVibGljIGRlc2VsZWN0QWxsKCk6IHZvaWQge1xuXG4gICAgdGhpcy5fc2VsZWN0ZWRJZHMuY2xlYXIoKTtcbiAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/helpers/one-column-def.helper.mjs

@@ -1,3 +1,20 @@
+/** Width used when a column defines neither `width` nor `minWidth`. */
+export const ONE_DEFAULT_COLUMN_WIDTH = 150;
+/**
+ * The rendered width of a column, clamped to its bounds.
+ *
+ * `width`, `minWidth` and `maxWidth` are all optional, and the previous inline
+ * expression — repeated in two places — fell back to `minWidth` when `width`
+ * was absent. With neither set that produced `undefined`, and summing it gave
+ * a `NaN` row width, so the row collapsed. This is total: every combination of
+ * present and absent bounds resolves to a usable number.
+ */
+export function resolveColumnWidth(column) {
+    const min = column?.minWidth ?? 0;
+    const max = column?.maxWidth ?? Number.POSITIVE_INFINITY;
+    const width = column?.width ?? column?.minWidth ?? ONE_DEFAULT_COLUMN_WIDTH;
+    return Math.min(Math.max(width, min), max);
+}
 /**
  * Apply Default Column Definitions
  */
@@ -10,7 +27,15 @@ export function applyDefaultColumnDef(columnDefs, defaultColumnDef) {
 /**
  * One Column Params Resolver (Cell Renderer)
  */
-export function resolveOneCellRendererParams(prop, params) {
+export function resolveOneCellRendererParams(prop, params, 
+/**
+ * What an unset property means: `false` for a capability you opt into,
+ * `true` for a restriction you opt out of. `!!prop` could not tell the two
+ * apart, which left `updatable` — a restriction — defaulting to "deny".
+ */
+whenUnset = false) {
+    if (prop === undefined || prop === null)
+        return whenUnset;
     return typeof prop === 'function' ? prop(params) : !!prop;
 }
 /**
@@ -25,4 +50,4 @@ export function resolveOneColumDefParams(prop, params) {
 export function resolveOneValueGetterParams(prop, params) {
     return typeof prop === 'function' ? prop(params) : prop;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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