@affino/datagrid-vue 0.1.0

package/dist/imperative/selectionDomAdapter.js

@@ -0,0 +1,466 @@
+import { elementFromPoint, getCellElement, scrollCellIntoView, buildTableSpaceColumnLayout, } from "../../core/dom/gridUtils";
+import { computeFillHandleStyle } from "../../core/selection/fillHandle";
+import { acquireFillHandleStyle, } from "../../core/selection/fillHandleStylePool";
+import { clientToTableSpace, viewportToTableSpace, } from "../../core/selection/coordinateSpace";
+import { scheduleMeasurement } from "../../core/runtime/measurementQueue";
+import { clamp } from "../../core/utils/constants";
+export function createSelectionDomAdapter(options) {
+    const { containerRef, overlayContainerRef, localColumns, totalRowCount, viewport, rowIndexColumnKey, getRowIdByIndex, resolveCellElement, resolveHeaderCellElement, } = options;
+    const effectiveOverlayRef = overlayContainerRef ?? containerRef;
+    let cachedOverlayRect = null;
+    let pendingScrollMeasurement = null;
+    function resolveColumnLayoutWidth(column) {
+        const widthMap = viewport.columnWidthMap.value;
+        const mapped = widthMap.get(column.key);
+        if (typeof mapped === "number" && Number.isFinite(mapped) && mapped > 0) {
+            return mapped;
+        }
+        const candidates = [column.width, column.minWidth, column.maxWidth];
+        for (const candidate of candidates) {
+            if (typeof candidate === "number" && Number.isFinite(candidate) && candidate > 0) {
+                return candidate;
+            }
+        }
+        return 0;
+    }
+    function buildCurrentTableSpaceLayout() {
+        const columns = localColumns.value;
+        if (!columns.length) {
+            return null;
+        }
+        return buildTableSpaceColumnLayout({
+            columns,
+            getColumnKey: column => column.key,
+            columnWidthMap: viewport.columnWidthMap.value,
+            pinnedLeft: viewport.pinnedLeftEntries.value,
+            pinnedRight: viewport.pinnedRightEntries.value,
+            resolveColumnWidth: resolveColumnLayoutWidth,
+        });
+    }
+    function createImmediateHandle(value) {
+        return {
+            promise: Promise.resolve(value),
+            cancel() {
+                // no-op for already resolved handles
+            },
+        };
+    }
+    function invalidateMetrics() {
+        cachedOverlayRect = null;
+        if (pendingScrollMeasurement) {
+            pendingScrollMeasurement.cancel();
+            pendingScrollMeasurement = null;
+        }
+    }
+    function getScrollContainer() {
+        return containerRef.value;
+    }
+    function getOverlayContainer() {
+        return effectiveOverlayRef.value ?? null;
+    }
+    function ensureOverlayRect(container) {
+        if (!cachedOverlayRect) {
+            cachedOverlayRect = container.getBoundingClientRect();
+        }
+        return cachedOverlayRect;
+    }
+    function clampRowIndex(rowIndex) {
+        return clamp(rowIndex, 0, Math.max(totalRowCount.value - 1, 0));
+    }
+    function resolveCellFromPoint(clientX, clientY) {
+        const container = getScrollContainer();
+        if (!container)
+            return null;
+        const element = elementFromPoint(clientX, clientY);
+        if (!element)
+            return null;
+        let current = element;
+        while (current && current !== document.body) {
+            if (current instanceof HTMLElement &&
+                current.hasAttribute("data-row-index") &&
+                current.hasAttribute("data-col-key")) {
+                const rowIndex = Number.parseInt(current.getAttribute("data-row-index") || "", 10);
+                const colKey = current.getAttribute("data-col-key") || "";
+                const colIndex = localColumns.value.findIndex(column => column.key === colKey);
+                if (!Number.isNaN(rowIndex) && colIndex !== -1) {
+                    const normalizedRow = clampRowIndex(rowIndex);
+                    return {
+                        rowIndex: normalizedRow,
+                        colIndex,
+                        rowId: getRowIdByIndex(normalizedRow),
+                    };
+                }
+                break;
+            }
+            current = current.parentElement;
+        }
+        const rect = container.getBoundingClientRect();
+        if (clientX < rect.left || clientX > rect.right || clientY < rect.top || clientY > rect.bottom) {
+            return null;
+        }
+        return null;
+    }
+    function resolveRowIndexFromPoint(clientX, clientY) {
+        const container = getScrollContainer();
+        if (!container)
+            return null;
+        const element = elementFromPoint(clientX, clientY);
+        if (!element)
+            return null;
+        let current = element;
+        while (current && current !== document.body) {
+            if (current instanceof HTMLElement && current.hasAttribute("data-row-index")) {
+                const value = Number.parseInt(current.getAttribute("data-row-index") || "", 10);
+                if (!Number.isNaN(value)) {
+                    return clampRowIndex(value);
+                }
+                break;
+            }
+            current = current.parentElement;
+        }
+        const rect = container.getBoundingClientRect();
+        if (clientY < rect.top)
+            return 0;
+        if (clientY > rect.bottom)
+            return Math.max(totalRowCount.value - 1, 0);
+        return null;
+    }
+    function resolveFillHandleStyle(input) {
+        if (!getScrollContainer() || !getOverlayContainer()) {
+            return createImmediateHandle(null);
+        }
+        return scheduleMeasurement(() => {
+            const scrollContainer = getScrollContainer();
+            const overlayContainer = getOverlayContainer();
+            if (!scrollContainer || !overlayContainer) {
+                return null;
+            }
+            const activeColumn = localColumns.value[input.range.endCol];
+            if (!activeColumn || activeColumn.isSystem) {
+                return null;
+            }
+            const viewportWidth = viewport.viewportWidth.value || scrollContainer.clientWidth || 0;
+            const viewportHeight = viewport.viewportHeight.value || scrollContainer.clientHeight || 0;
+            const scrollLeftValue = viewport.scrollLeft.value;
+            const scrollTopValue = viewport.scrollTop.value;
+            const layout = buildCurrentTableSpaceLayout();
+            const layoutInfo = layout?.byKey.get(activeColumn.key) ?? null;
+            const result = computeFillHandleStyle({
+                activeRange: input.range,
+                columns: localColumns.value,
+                columnWidthMap: viewport.columnWidthMap.value,
+                pinnedLeft: viewport.pinnedLeftEntries.value,
+                pinnedRight: viewport.pinnedRightEntries.value,
+                rowHeight: viewport.effectiveRowHeight.value || 0,
+                fillHandleSize: input.fillHandleSize,
+                viewport: {
+                    width: viewportWidth,
+                    height: viewportHeight,
+                    scrollLeft: scrollLeftValue,
+                    scrollTop: scrollTopValue,
+                    startRow: viewport.startIndex.value,
+                    endRow: viewport.endIndex.value,
+                    visibleStartCol: viewport.visibleStartCol.value,
+                    visibleEndCol: viewport.visibleEndCol.value,
+                    virtualizationEnabled: viewport.virtualizationEnabled.value !== false,
+                },
+                getColumnKey: column => column.key,
+                isSystemColumn: column => column.isSystem === true,
+                rowIndexColumnKey,
+            });
+            if (!result) {
+                return null;
+            }
+            const fallback = applyDomFallback({
+                scrollContainer,
+                overlayContainer,
+                rowIndex: input.range.endRow,
+                columnKey: activeColumn.key,
+                fillHandleSize: input.fillHandleSize,
+                scrollLeft: scrollLeftValue,
+                scrollTop: scrollTopValue,
+            });
+            if (result.kind === "fallback") {
+                return fallback.handled ? fallback.style : null;
+            }
+            if (fallback.handled) {
+                return fallback.style;
+            }
+            if (!layout || !layoutInfo) {
+                return null;
+            }
+            const columnWidth = Math.max(0, layoutInfo.width);
+            if (!(columnWidth > 0)) {
+                return null;
+            }
+            const normalizedSize = Math.max(0, Math.min(columnWidth, result.size));
+            let actualColumnLeft;
+            if (layoutInfo.pin === "left") {
+                actualColumnLeft = layoutInfo.left;
+            }
+            else if (layoutInfo.pin === "right") {
+                if (!(viewportWidth > 0)) {
+                    return null;
+                }
+                const pinnedRightBase = layout.pinnedLeftWidth + layout.scrollableWidth;
+                const offsetWithinPinned = layoutInfo.left - pinnedRightBase;
+                actualColumnLeft = viewportWidth - layout.pinnedRightWidth + offsetWithinPinned;
+            }
+            else {
+                actualColumnLeft = layoutInfo.left - scrollLeftValue;
+            }
+            const actualColumnRight = actualColumnLeft + columnWidth;
+            const actualLeft = actualColumnRight - normalizedSize;
+            const actualTop = result.top;
+            if (!Number.isFinite(actualLeft) || !Number.isFinite(actualTop)) {
+                return null;
+            }
+            const styleLeft = Math.round(viewportToTableSpace(actualLeft, scrollLeftValue));
+            const styleTop = Math.round(viewportToTableSpace(actualTop, scrollTopValue));
+            const stylePayload = acquireFillHandleStyle();
+            stylePayload.width = `${normalizedSize}px`;
+            stylePayload.height = `${normalizedSize}px`;
+            stylePayload.left = `${styleLeft}px`;
+            stylePayload.top = `${styleTop}px`;
+            stylePayload.x = styleLeft;
+            stylePayload.y = styleTop;
+            stylePayload.widthValue = normalizedSize;
+            stylePayload.heightValue = normalizedSize;
+            return stylePayload;
+        });
+    }
+    function applyDomFallback(args) {
+        const { scrollContainer, overlayContainer, rowIndex, columnKey, fillHandleSize, scrollLeft, scrollTop, } = args;
+        const cell = resolveCellElement?.(rowIndex, columnKey) ??
+            getCellElement(scrollContainer, rowIndex, columnKey) ??
+            getCellElement(overlayContainer, rowIndex, columnKey);
+        if (!cell) {
+            return { handled: false, style: null };
+        }
+        const overlayRect = ensureOverlayRect(overlayContainer);
+        const cellRect = cell.getBoundingClientRect();
+        const size = fillHandleSize;
+        if (rowIndexColumnKey) {
+            const pinnedRowIndexCell = resolveCellElement?.(rowIndex, rowIndexColumnKey) ??
+                getCellElement(scrollContainer, rowIndex, rowIndexColumnKey) ??
+                getCellElement(overlayContainer, rowIndex, rowIndexColumnKey);
+            if (pinnedRowIndexCell) {
+                const pinnedRect = pinnedRowIndexCell.getBoundingClientRect();
+                // Convert DOM client coordinates into canonical table-space (world) coordinates.
+                const fillLeftTable = clientToTableSpace(cellRect.right, overlayRect.left, scrollLeft) - size;
+                const pinnedRightTable = clientToTableSpace(pinnedRect.right, overlayRect.left, scrollLeft);
+                if (!Number.isFinite(fillLeftTable) || !Number.isFinite(pinnedRightTable)) {
+                    return { handled: true, style: null };
+                }
+                if (fillLeftTable <= pinnedRightTable + 0.5) {
+                    return { handled: true, style: null };
+                }
+            }
+        }
+        const tableRight = clientToTableSpace(cellRect.right, overlayRect.left, scrollLeft);
+        const tableBottom = clientToTableSpace(cellRect.bottom, overlayRect.top, scrollTop);
+        if (!Number.isFinite(tableRight) || !Number.isFinite(tableBottom)) {
+            return { handled: true, style: null };
+        }
+        const styleLeft = Math.round(tableRight - size);
+        const styleTop = Math.round(tableBottom - size);
+        const style = acquireFillHandleStyle();
+        style.width = `${size}px`;
+        style.height = `${size}px`;
+        style.left = `${styleLeft}px`;
+        style.top = `${styleTop}px`;
+        style.x = styleLeft;
+        style.y = styleTop;
+        style.widthValue = size;
+        style.heightValue = size;
+        return {
+            handled: true,
+            style,
+        };
+    }
+    function scrollSelectionIntoView(input) {
+        const container = getScrollContainer();
+        if (!container)
+            return;
+        const { range, cursor } = input;
+        const attempt = input.attempt ?? 0;
+        const maxAttempts = input.maxAttempts ?? 4;
+        const rowTargets = new Set();
+        if (range) {
+            rowTargets.add(range.startRow);
+            rowTargets.add(range.endRow);
+        }
+        else if (cursor) {
+            rowTargets.add(cursor.rowIndex);
+        }
+        const colTargets = new Set();
+        if (range) {
+            colTargets.add(range.startCol);
+            colTargets.add(range.endCol);
+        }
+        else if (cursor) {
+            colTargets.add(cursor.colIndex);
+        }
+        if (rowTargets.size) {
+            const rowHeight = viewport.effectiveRowHeight.value || 1;
+            const viewportHeight = viewport.viewportHeight.value || rowHeight;
+            const scrollArgsBase = {
+                container,
+                rowHeight,
+                viewportHeight,
+                clampScrollTop: viewport.clampScrollTopValue,
+            };
+            const sortedRows = Array.from(rowTargets).sort((a, b) => a - b);
+            let nextScrollTop = viewport.scrollTop.value;
+            for (const rowIndex of sortedRows) {
+                nextScrollTop = scrollCellIntoView({
+                    ...scrollArgsBase,
+                    targetRowIndex: rowIndex,
+                    currentScrollTop: nextScrollTop,
+                });
+            }
+            viewport.scrollTop.value = nextScrollTop;
+        }
+        if (!colTargets.size)
+            return;
+        const padding = 2;
+        const referenceRows = rowTargets.size
+            ? Array.from(rowTargets)
+            : cursor
+                ? [cursor.rowIndex]
+                : [];
+        const columnMap = new Map(localColumns.value.map(column => [column.key, column]));
+        const columnKeys = Array.from(colTargets)
+            .map(index => localColumns.value[index]?.key)
+            .filter((key) => Boolean(key));
+        const visibilityKeys = columnKeys.filter(key => !isColumnPinned(columnMap.get(key)));
+        if (!visibilityKeys.length) {
+            return;
+        }
+        const scheduleRetry = () => {
+            if (attempt >= maxAttempts) {
+                return;
+            }
+            const nextInput = {
+                range,
+                cursor,
+                attempt: attempt + 1,
+                maxAttempts,
+            };
+            if (typeof requestAnimationFrame === "function") {
+                requestAnimationFrame(() => scrollSelectionIntoView(nextInput));
+            }
+            else {
+                setTimeout(() => scrollSelectionIntoView(nextInput), 16);
+            }
+        };
+        if (pendingScrollMeasurement) {
+            pendingScrollMeasurement.cancel();
+            pendingScrollMeasurement = null;
+        }
+        const measurementHandle = scheduleMeasurement(() => {
+            if (!container || !container.isConnected) {
+                return null;
+            }
+            const containerRect = container.getBoundingClientRect();
+            const viewLeftTable = container.scrollLeft;
+            const viewRightTable = container.scrollLeft + container.clientWidth;
+            let minLeftTable = null;
+            let maxRightTable = null;
+            let resolvedColumn = false;
+            // Translate any DOM-based measurements into the canonical table space so scroll math stays consistent.
+            for (const key of visibilityKeys) {
+                let rect = null;
+                for (const rowIndex of referenceRows) {
+                    const cell = resolveCellElement?.(rowIndex, key) ?? getCellElement(container, rowIndex, key);
+                    if (cell) {
+                        rect = cell.getBoundingClientRect();
+                        break;
+                    }
+                }
+                if (!rect) {
+                    const headerCell = resolveHeaderCellElement?.(key) ?? container.querySelector(`.ui-table-header-cell[data-column-key="${key}"]`);
+                    if (headerCell) {
+                        rect = headerCell.getBoundingClientRect();
+                    }
+                }
+                if (!rect) {
+                    continue;
+                }
+                resolvedColumn = true;
+                const rectLeftTable = clientToTableSpace(rect.left, containerRect.left, container.scrollLeft);
+                const rectRightTable = clientToTableSpace(rect.right, containerRect.left, container.scrollLeft);
+                minLeftTable = minLeftTable === null ? rectLeftTable : Math.min(minLeftTable, rectLeftTable);
+                maxRightTable = maxRightTable === null ? rectRightTable : Math.max(maxRightTable, rectRightTable);
+            }
+            return {
+                container,
+                resolvedColumn,
+                minLeftTable,
+                maxRightTable,
+                viewLeftTable,
+                viewRightTable,
+                visibilityKeys,
+            };
+        });
+        pendingScrollMeasurement = measurementHandle;
+        void measurementHandle.promise
+            .then(result => {
+            if (pendingScrollMeasurement !== measurementHandle) {
+                return;
+            }
+            pendingScrollMeasurement = null;
+            if (!result) {
+                return;
+            }
+            const activeContainer = getScrollContainer();
+            if (!activeContainer || activeContainer !== result.container) {
+                return;
+            }
+            if (!result.resolvedColumn) {
+                if (viewport.scrollToColumn && result.visibilityKeys.length && attempt < maxAttempts) {
+                    viewport.scrollToColumn(result.visibilityKeys[0]);
+                    scheduleRetry();
+                }
+                return;
+            }
+            const viewWidth = result.viewRightTable - result.viewLeftTable;
+            let adjusted = false;
+            if (result.minLeftTable !== null) {
+                if (result.minLeftTable < result.viewLeftTable + padding) {
+                    activeContainer.scrollLeft = Math.max(0, result.minLeftTable - padding);
+                    adjusted = true;
+                }
+            }
+            if (result.maxRightTable !== null) {
+                if (result.maxRightTable > result.viewRightTable - padding) {
+                    activeContainer.scrollLeft = Math.max(0, result.maxRightTable - viewWidth + padding);
+                    adjusted = true;
+                }
+            }
+            if (adjusted) {
+                cachedOverlayRect = null;
+                scheduleRetry();
+            }
+        })
+            .catch(() => {
+            if (pendingScrollMeasurement === measurementHandle) {
+                pendingScrollMeasurement = null;
+            }
+        });
+    }
+    function isColumnPinned(column) {
+        if (!column)
+            return false;
+        if (column.isSystem === true)
+            return true;
+        return column.pin === "left" || column.pin === "right";
+    }
+    return {
+        invalidateMetrics,
+        resolveCellFromPoint,
+        resolveRowIndexFromPoint,
+        resolveFillHandleStyle,
+        scrollSelectionIntoView,
+    };
+}

package/dist/imperative/useImperativeTableAdapter.d.ts

@@ -0,0 +1,12 @@
+import type { ComputedRef } from "vue";
+import type { UiTableBodyBindings } from "../context.js";
+import type { ImperativeBodyController, ImperativeBodyViewConfig, HeaderSnapshot } from "../../core/imperative/engine.js";
+export interface UseImperativeTableBodyOptions {
+    body: UiTableBodyBindings;
+    mode: ComputedRef<boolean>;
+    headerSnapshot: () => HeaderSnapshot;
+    viewConfig?: ImperativeBodyViewConfig;
+}
+export declare function useImperativeTableAdapter(options: UseImperativeTableBodyOptions): ImperativeBodyController;
+export type { ImperativeBodyController, ImperativeBodyViewConfig } from "../../core/imperative/engine.js";
+//# sourceMappingURL=useImperativeTableAdapter.d.ts.map

package/dist/imperative/useImperativeTableAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useImperativeTableAdapter.d.ts","sourceRoot":"","sources":["../../src/imperative/useImperativeTableAdapter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAA6B,MAAM,KAAK,CAAA;AACjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAA;AAIxD,OAAO,KAAK,EACV,wBAAwB,EACxB,wBAAwB,EAExB,cAAc,EACf,MAAM,iCAAiC,CAAA;AA2BxC,MAAM,WAAW,6BAA6B;IAC5C,IAAI,EAAE,mBAAmB,CAAA;IACzB,IAAI,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;IAC1B,cAAc,EAAE,MAAM,cAAc,CAAA;IACpC,UAAU,CAAC,EAAE,wBAAwB,CAAA;CACtC;AAED,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,6BAA6B,GAAG,wBAAwB,CA4D1G;AAED,YAAY,EAAE,wBAAwB,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAA"}

package/dist/imperative/useImperativeTableAdapter.js

@@ -0,0 +1,80 @@
+import { Fragment, h, onBeforeUnmount, render, watch } from "vue";
+import { ImperativeTableEngine } from "../../core/imperative/engine.js";
+import { createDomControllerSuite } from "./createDomControllerSuite";
+function createVueRenderer(body) {
+    return {
+        mountCustomCell({ slotName, props, host }) {
+            const slot = body.tableSlots?.[slotName];
+            if (!slot) {
+                render(null, host);
+                return;
+            }
+            const rendered = slot(props);
+            if (!rendered || (Array.isArray(rendered) && rendered.length === 0)) {
+                render(null, host);
+                return;
+            }
+            const vnode = Array.isArray(rendered)
+                ? h(Fragment, null, rendered)
+                : rendered;
+            render(vnode, host);
+        },
+        unmountCustomCell(host) {
+            render(null, host);
+        },
+    };
+}
+export function useImperativeTableAdapter(options) {
+    const renderer = createVueRenderer(options.body);
+    const engine = new ImperativeTableEngine({
+        body: options.body,
+        mode: options.mode,
+        headerSnapshot: options.headerSnapshot,
+        renderer,
+        view: options.viewConfig,
+        createControllers: createDomControllerSuite,
+    });
+    let containers = null;
+    watch(() => options.mode.value, value => {
+        if (!value) {
+            engine.detach();
+            return;
+        }
+        if (containers) {
+            engine.attach(containers);
+        }
+    }, { immediate: true });
+    watch(() => options.body.editCommand.value?.token, token => {
+        if (!token)
+            return;
+        if (!options.mode.value)
+            return;
+        const command = options.body.editCommand.value;
+        if (!command)
+            return;
+        engine.handleEditCommand(command);
+    });
+    onBeforeUnmount(() => engine.dispose());
+    return {
+        registerContainer(map) {
+            containers = map;
+            if (!options.mode.value)
+                return;
+            if (containers) {
+                engine.attach(containers);
+            }
+            else {
+                engine.detach();
+            }
+        },
+        handleRows(payload) {
+            engine.handleRows(payload);
+        },
+        handleColumns(payload) {
+            engine.handleColumns(payload);
+        },
+        handleEditCommand(command) {
+            engine.handleEditCommand(command);
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./stable";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA"}

package/dist/index.js

@@ -0,0 +1 @@
+export * from "./stable";

package/dist/piniaTableSettingsAdapter.d.ts

@@ -0,0 +1,5 @@
+import type { DataGridSettingsAdapter } from "@affino/datagrid-core";
+import type { DataGridSettingsStore } from "./tableSettingsStore";
+export declare function createDataGridSettingsAdapter(store: DataGridSettingsStore): DataGridSettingsAdapter;
+export declare function createPiniaTableSettingsAdapter(store: DataGridSettingsStore): DataGridSettingsAdapter;
+//# sourceMappingURL=piniaTableSettingsAdapter.d.ts.map

package/dist/piniaTableSettingsAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"piniaTableSettingsAdapter.d.ts","sourceRoot":"","sources":["../src/piniaTableSettingsAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAA;AACpE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAA;AAEjE,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,qBAAqB,GAC3B,uBAAuB,CAoCzB;AAID,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,qBAAqB,GAC3B,uBAAuB,CAQzB"}

package/dist/piniaTableSettingsAdapter.js

@@ -0,0 +1,45 @@
+export function createDataGridSettingsAdapter(store) {
+    return {
+        setColumnWidth(tableId, columnKey, width) {
+            store.setColumnWidth(tableId, columnKey, width);
+        },
+        getColumnWidth(tableId, columnKey) {
+            return store.getColumnWidth(tableId, columnKey);
+        },
+        setSortState(tableId, state) {
+            store.setSortState(tableId, state);
+        },
+        getSortState(tableId) {
+            return store.getSortState(tableId);
+        },
+        setFilterSnapshot(tableId, snapshot) {
+            store.setFilterSnapshot(tableId, snapshot);
+        },
+        getFilterSnapshot(tableId) {
+            return store.getFilterSnapshot(tableId);
+        },
+        setPinState(tableId, columnKey, position) {
+            store.setPinState(tableId, columnKey, position);
+        },
+        getPinState(tableId) {
+            return store.getPinState(tableId);
+        },
+        setGroupState(tableId, columns, expansion) {
+            store.setGroupState(tableId, columns, expansion);
+        },
+        getGroupState(tableId) {
+            return store.getGroupState(tableId);
+        },
+        clearTable(tableId) {
+            store.clearTable(tableId);
+        },
+    };
+}
+let legacyAdapterAliasWarned = false;
+export function createPiniaTableSettingsAdapter(store) {
+    if (!legacyAdapterAliasWarned) {
+        legacyAdapterAliasWarned = true;
+        console.warn("[DataGrid][deprecated] createPiniaTableSettingsAdapter is deprecated. Use createDataGridSettingsAdapter.");
+    }
+    return createDataGridSettingsAdapter(store);
+}

package/dist/public.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Stable public API for @affino/datagrid-vue.
+ */
+export { createDataGridSettingsAdapter, } from "./dataGridSettingsAdapter";
+export { useDataGridSettingsStore, type DataGridSettingsStore, } from "./dataGridSettingsStore";
+export { buildDataGridOverlayTransform, buildDataGridOverlayTransformFromSnapshot, } from "./composables/selectionOverlayTransform";
+export { mapDataGridA11yGridAttributes, mapDataGridA11yCellAttributes, type DataGridA11yGridAttributeMap, type DataGridA11yCellAttributeMap, } from "./adapters/a11yAttributesAdapter";
+export { useDataGridOverlayScrollState, type UseDataGridOverlayScrollStateOptions, } from "./composables/useDataGridOverlayScrollState";
+export { useDataGridContextMenu, type DataGridContextMenuAction, type DataGridContextMenuActionId, type DataGridContextMenuState, type DataGridContextMenuZone, type OpenDataGridContextMenuInput, type UseDataGridContextMenuOptions, type UseDataGridContextMenuResult, } from "./composables/useDataGridContextMenu";
+export { useDataGridRuntime, type DataGridRuntimeVirtualWindowSnapshot, type UseDataGridRuntimeOptions, type UseDataGridRuntimeResult, } from "./composables/useDataGridRuntime";
+export { DATA_GRID_CLASS_NAMES, DATA_GRID_DATA_ATTRS, DATA_GRID_SELECTORS, dataGridCellSelector, dataGridHeaderCellSelector, dataGridResizeHandleSelector, } from "./contracts/dataGridSelectors";
+export { useAffinoDataGrid, type AffinoDataGridEditMode, type AffinoDataGridEditSession, type AffinoDataGridActionId, type AffinoDataGridRunActionOptions, type AffinoDataGridActionResult, type AffinoDataGridActionBindingOptions, type AffinoDataGridSelectionFeature, type AffinoDataGridClipboardFeature, type AffinoDataGridEditingFeature, type AffinoDataGridFilteringFeature, type AffinoDataGridSummaryFeature, type AffinoDataGridVisibilityFeature, type AffinoDataGridTreeFeature, type AffinoDataGridFilterMergeMode, type AffinoDataGridSetFilterValueMode, type AffinoDataGridFilteringHelpers, type AffinoDataGridFeatures, type UseAffinoDataGridOptions, type UseAffinoDataGridResult, type UseAffinoDataGridMinimalOptions, type UseAffinoDataGridMinimalResult, } from "./composables/useAffinoDataGrid";
+export { useAffinoDataGridMinimal, } from "./composables/useAffinoDataGridMinimal";
+export { useAffinoDataGridUi, type AffinoDataGridUiToolbarAction, type UseAffinoDataGridUiOptions, type UseAffinoDataGridUiResult, } from "./composables/useAffinoDataGridUi";
+export { createDataGridVueRuntime, type CreateDataGridVueRuntimeOptions, type DataGridVueRuntime, } from "./runtime/createDataGridVueRuntime";
+export { DataGrid, AffinoDataGridSimple, } from "./components";
+export type { DataGridOverlayTransform, DataGridOverlayTransformInput, DataGridAppearanceConfig, DataGridStyleConfig, } from "./types";
+//# sourceMappingURL=public.d.ts.map

package/dist/public.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../src/public.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EACL,6BAA6B,GAC9B,MAAM,2BAA2B,CAAA;AAElC,OAAO,EACL,wBAAwB,EACxB,KAAK,qBAAqB,GAC3B,MAAM,yBAAyB,CAAA;AAEhC,OAAO,EACL,6BAA6B,EAC7B,yCAAyC,GAC1C,MAAM,yCAAyC,CAAA;AAEhD,OAAO,EACL,6BAA6B,EAC7B,6BAA6B,EAC7B,KAAK,4BAA4B,EACjC,KAAK,4BAA4B,GAClC,MAAM,kCAAkC,CAAA;AAEzC,OAAO,EACL,6BAA6B,EAC7B,KAAK,oCAAoC,GAC1C,MAAM,6CAA6C,CAAA;AAEpD,OAAO,EACL,sBAAsB,EACtB,KAAK,yBAAyB,EAC9B,KAAK,2BAA2B,EAChC,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,EAC5B,KAAK,4BAA4B,EACjC,KAAK,6BAA6B,EAClC,KAAK,4BAA4B,GAClC,MAAM,sCAAsC,CAAA;AAE7C,OAAO,EACL,kBAAkB,EAClB,KAAK,oCAAoC,EACzC,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,GAC9B,MAAM,kCAAkC,CAAA;AAEzC,OAAO,EACL,qBAAqB,EACrB,oBAAoB,EACpB,mBAAmB,EACnB,oBAAoB,EACpB,0BAA0B,EAC1B,4BAA4B,GAC7B,MAAM,+BAA+B,CAAA;AAEtC,OAAO,EACL,iBAAiB,EACjB,KAAK,sBAAsB,EAC3B,KAAK,yBAAyB,EAC9B,KAAK,sBAAsB,EAC3B,KAAK,8BAA8B,EACnC,KAAK,0BAA0B,EAC/B,KAAK,kCAAkC,EACvC,KAAK,8BAA8B,EACnC,KAAK,8BAA8B,EACnC,KAAK,4BAA4B,EACjC,KAAK,8BAA8B,EACnC,KAAK,4BAA4B,EACjC,KAAK,+BAA+B,EACpC,KAAK,yBAAyB,EAC9B,KAAK,6BAA6B,EAClC,KAAK,gCAAgC,EACrC,KAAK,8BAA8B,EACnC,KAAK,sBAAsB,EAC3B,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,EAC5B,KAAK,+BAA+B,EACpC,KAAK,8BAA8B,GACpC,MAAM,iCAAiC,CAAA;AAExC,OAAO,EACL,wBAAwB,GACzB,MAAM,wCAAwC,CAAA;AAE/C,OAAO,EACL,mBAAmB,EACnB,KAAK,6BAA6B,EAClC,KAAK,0BAA0B,EAC/B,KAAK,yBAAyB,GAC/B,MAAM,mCAAmC,CAAA;AAE1C,OAAO,EACL,wBAAwB,EACxB,KAAK,+BAA+B,EACpC,KAAK,kBAAkB,GACxB,MAAM,oCAAoC,CAAA;AAE3C,OAAO,EACL,QAAQ,EACR,oBAAoB,GACrB,MAAM,cAAc,CAAA;AAErB,YAAY,EACV,wBAAwB,EACxB,6BAA6B,EAC7B,wBAAwB,EACxB,mBAAmB,GACpB,MAAM,SAAS,CAAA"}

package/dist/public.js

@@ -0,0 +1,16 @@
+/**
+ * Stable public API for @affino/datagrid-vue.
+ */
+export { createDataGridSettingsAdapter, } from "./dataGridSettingsAdapter";
+export { useDataGridSettingsStore, } from "./dataGridSettingsStore";
+export { buildDataGridOverlayTransform, buildDataGridOverlayTransformFromSnapshot, } from "./composables/selectionOverlayTransform";
+export { mapDataGridA11yGridAttributes, mapDataGridA11yCellAttributes, } from "./adapters/a11yAttributesAdapter";
+export { useDataGridOverlayScrollState, } from "./composables/useDataGridOverlayScrollState";
+export { useDataGridContextMenu, } from "./composables/useDataGridContextMenu";
+export { useDataGridRuntime, } from "./composables/useDataGridRuntime";
+export { DATA_GRID_CLASS_NAMES, DATA_GRID_DATA_ATTRS, DATA_GRID_SELECTORS, dataGridCellSelector, dataGridHeaderCellSelector, dataGridResizeHandleSelector, } from "./contracts/dataGridSelectors";
+export { useAffinoDataGrid, } from "./composables/useAffinoDataGrid";
+export { useAffinoDataGridMinimal, } from "./composables/useAffinoDataGridMinimal";
+export { useAffinoDataGridUi, } from "./composables/useAffinoDataGridUi";
+export { createDataGridVueRuntime, } from "./runtime/createDataGridVueRuntime";
+export { DataGrid, AffinoDataGridSimple, } from "./components";