@affino/datagrid-vue 0.3.2 → 0.3.4

package/dist/imperative/selectionDomAdapter.js

@@ -1,466 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,80 +0,0 @@
-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/piniaTableSettingsAdapter.d.ts

@@ -1,5 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,45 +0,0 @@
-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/src/index.d.ts

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

package/dist/src/index.d.ts.map

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

package/dist/src/index.js

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

package/dist/src/piniaTableSettingsAdapter.d.ts

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

package/dist/src/piniaTableSettingsAdapter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"piniaTableSettingsAdapter.d.ts","sourceRoot":"","sources":["../../src/piniaTableSettingsAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AAC9D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAA;AAEnE,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,kBAAkB,GAAG,sBAAsB,CA8CjG"}

package/dist/src/piniaTableSettingsAdapter.js

@@ -1,37 +0,0 @@
-export function createPiniaTableSettingsAdapter(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);
-        },
-    };
-}