@affino/datagrid-vue 0.3.2 → 0.3.4

package/dist/composables/internal/useAffinoDataGrid/useAffinoDataGridRangeClipboard.js

@@ -1,470 +0,0 @@
-import { ref, watch } from "vue";
-import { useDataGridClipboardBridge, useDataGridClipboardMutations, useDataGridRangeMutationEngine, } from "@affino/datagrid-orchestration";
-function isRecordRow(value) {
-    return Boolean(value) && typeof value === "object";
-}
-function coerceStringDraftToCellValue(current, draft) {
-    if (typeof current === "number") {
-        const parsed = Number(draft);
-        return Number.isFinite(parsed) ? parsed : current;
-    }
-    if (typeof current === "boolean") {
-        const normalized = draft.trim().toLowerCase();
-        if (normalized === "true" || normalized === "1") {
-            return true;
-        }
-        if (normalized === "false" || normalized === "0") {
-            return false;
-        }
-        return current;
-    }
-    return draft;
-}
-export function useAffinoDataGridRangeClipboard(options) {
-    const cellRangeLastAction = ref("Ready");
-    const copiedSelectionRange = ref(null);
-    const fillPreviewRange = ref(null);
-    const rangeMovePreviewRange = ref(null);
-    const setRangeLastAction = (message, actionOptions = {}) => {
-        cellRangeLastAction.value = message;
-        options.pushFeedback({
-            source: "range",
-            action: actionOptions.action ?? "range",
-            message,
-            affected: actionOptions.affected,
-            ok: true,
-        });
-    };
-    const resolveColumnKeyAtIndex = (columnIndex) => (options.runtime.columnSnapshot.value.visibleColumns[columnIndex]?.key ?? null);
-    const resolveDisplayNodeAtIndex = (rowIndex) => (options.runtime.api.getRow(rowIndex));
-    const resolveDisplayLeafRowAtIndex = (rowIndex) => {
-        const rowNode = resolveDisplayNodeAtIndex(rowIndex);
-        if (!rowNode || rowNode.kind !== "leaf") {
-            return undefined;
-        }
-        return rowNode.data;
-    };
-    const materializeDisplayRows = () => {
-        const rowCount = options.runtime.api.getRowCount();
-        const rowsBuffer = [];
-        for (let rowIndex = 0; rowIndex < rowCount; rowIndex += 1) {
-            const rowNode = resolveDisplayNodeAtIndex(rowIndex);
-            if (rowNode) {
-                rowsBuffer.push(rowNode);
-            }
-        }
-        return rowsBuffer;
-    };
-    const normalizeCellRange = (range) => {
-        if (!range) {
-            return null;
-        }
-        const rowTotal = options.runtime.api.getRowCount();
-        const colTotal = options.runtime.columnSnapshot.value.visibleColumns.length;
-        if (rowTotal <= 0 || colTotal <= 0) {
-            return null;
-        }
-        const clamp = (value, max) => (Math.max(0, Math.min(max, Math.trunc(value))));
-        const maxRow = Math.max(0, rowTotal - 1);
-        const maxCol = Math.max(0, colTotal - 1);
-        const startRow = clamp(Math.min(range.startRow, range.endRow), maxRow);
-        const endRow = clamp(Math.max(range.startRow, range.endRow), maxRow);
-        const startColumn = clamp(Math.min(range.startColumn, range.endColumn), maxCol);
-        const endColumn = clamp(Math.max(range.startColumn, range.endColumn), maxCol);
-        return {
-            startRow,
-            endRow,
-            startColumn,
-            endColumn,
-        };
-    };
-    const areCellRangesEqual = (left, right) => {
-        if (!left && !right) {
-            return true;
-        }
-        if (!left || !right) {
-            return false;
-        }
-        return (left.startRow === right.startRow
-            && left.endRow === right.endRow
-            && left.startColumn === right.startColumn
-            && left.endColumn === right.endColumn);
-    };
-    const resolveCurrentCellCoord = () => {
-        const active = options.activeCellSelection.value;
-        if (!active) {
-            return null;
-        }
-        return {
-            rowIndex: active.rowIndex,
-            columnIndex: active.columnIndex,
-        };
-    };
-    const resolveCopyRange = () => (normalizeCellRange(options.cellSelectionRange.value));
-    const resolveActiveRangeCellCount = () => {
-        const range = resolveCopyRange();
-        if (!range) {
-            return 0;
-        }
-        return Math.max(0, range.endRow - range.startRow + 1)
-            * Math.max(0, range.endColumn - range.startColumn + 1);
-    };
-    const resolveCellValue = (row, columnKey) => {
-        if (!isRecordRow(row)) {
-            return undefined;
-        }
-        return row[columnKey];
-    };
-    const applyDraftValue = (row, columnKey, draft) => {
-        if (!isRecordRow(row)) {
-            return false;
-        }
-        const record = row;
-        const current = record[columnKey];
-        record[columnKey] = coerceStringDraftToCellValue(current, draft);
-        return true;
-    };
-    const clearCellValue = (row, columnKey) => {
-        if (!isRecordRow(row)) {
-            return false;
-        }
-        const record = row;
-        record[columnKey] = null;
-        return true;
-    };
-    const cloneRowForMutation = (row) => {
-        try {
-            if (typeof structuredClone === "function") {
-                return structuredClone(row);
-            }
-        }
-        catch {
-            // Fall through to shallow clone.
-        }
-        if (Array.isArray(row)) {
-            return [...row];
-        }
-        if (isRecordRow(row)) {
-            return { ...row };
-        }
-        return row;
-    };
-    const sourceRowIdMap = ref(new Map());
-    watch(options.rows, nextRows => {
-        const nextMap = new Map();
-        nextRows.forEach((row, index) => {
-            nextMap.set(row, options.resolveRowKey(row, index));
-        });
-        sourceRowIdMap.value = nextMap;
-    }, { immediate: true, flush: "sync" });
-    const resolveSourceRowId = (row) => {
-        const direct = sourceRowIdMap.value.get(row);
-        if (direct) {
-            return direct;
-        }
-        const index = options.rows.value.indexOf(row);
-        if (index >= 0) {
-            return options.resolveRowKey(row, index);
-        }
-        return String(index);
-    };
-    const captureMutationSnapshot = () => ({
-        rows: options.rows.value,
-        selection: options.runtime.api.hasSelectionSupport() ? options.runtime.api.getSelectionSnapshot() : null,
-    });
-    const recordCellRangeIntent = async (descriptor, beforeSnapshot) => {
-        if (!options.runtime.api.hasTransactionSupport()) {
-            return;
-        }
-        const afterSelection = options.runtime.api.hasSelectionSupport()
-            ? options.runtime.api.getSelectionSnapshot()
-            : null;
-        const affectedRange = normalizeCellRange(descriptor.affectedRange);
-        await options.runtime.api.applyTransaction({
-            label: descriptor.label,
-            meta: {
-                intent: `cells-${descriptor.intent}`,
-                affectedRange: affectedRange
-                    ? {
-                        startRow: affectedRange.startRow,
-                        endRow: affectedRange.endRow,
-                        startColumn: affectedRange.startColumn,
-                        endColumn: affectedRange.endColumn,
-                    }
-                    : null,
-            },
-            commands: [
-                {
-                    type: `cells.${descriptor.intent}`,
-                    payload: {
-                        rows: options.rows.value,
-                        selection: afterSelection,
-                    },
-                    rollbackPayload: {
-                        rows: beforeSnapshot.rows,
-                        selection: beforeSnapshot.selection,
-                    },
-                    meta: {
-                        intent: `cells-${descriptor.intent}`,
-                    },
-                },
-            ],
-        });
-    };
-    const clipboardBridge = useDataGridClipboardBridge({
-        copiedSelectionRange,
-        lastCopiedPayload: options.featureSuite.lastCopiedText,
-        resolveCopyRange,
-        getRowAtIndex: resolveDisplayLeafRowAtIndex,
-        getColumnKeyAtIndex: resolveColumnKeyAtIndex,
-        getCellValue: resolveCellValue,
-        setLastAction(message) {
-            setRangeLastAction(message, { action: "copy-range" });
-        },
-        closeContextMenu: options.closeContextMenu,
-        writeClipboardText: async (text) => {
-            await options.featureSuite.copyText(text);
-        },
-        readClipboardText: options.featureSuite.readText,
-        isColumnCopyable: columnKey => columnKey !== "select",
-    });
-    const clipboardMutations = useDataGridClipboardMutations({
-        sourceRows: options.rows,
-        setSourceRows(nextRows) {
-            options.rows.value = nextRows;
-        },
-        cloneRow: cloneRowForMutation,
-        resolveRowId: resolveSourceRowId,
-        resolveCopyRange,
-        resolveCurrentCellCoord,
-        normalizeCellCoord(coord) {
-            const normalized = options.resolveCellCoordByIndex(coord.rowIndex, coord.columnIndex);
-            if (!normalized) {
-                return null;
-            }
-            return {
-                rowIndex: normalized.rowIndex,
-                columnIndex: normalized.columnIndex,
-            };
-        },
-        normalizeSelectionRange(range) {
-            return normalizeCellRange(range);
-        },
-        resolveRowAtViewIndex: resolveDisplayLeafRowAtIndex,
-        resolveColumnKeyAtIndex: resolveColumnKeyAtIndex,
-        isEditableColumn: columnKey => columnKey !== "select",
-        canApplyPastedValue: () => true,
-        applyEditedValue: applyDraftValue,
-        clearValueForCut: clearCellValue,
-        applySelectionRange(range) {
-            const current = options.cellSelectionRange.value;
-            if (current
-                && current.startRow === current.endRow
-                && current.startColumn === current.endColumn) {
-                options.applySelectionFromRange(current, "end");
-                return;
-            }
-            options.applySelectionFromRange(range, "end");
-        },
-        closeContextMenu: options.closeContextMenu,
-        setLastAction(message) {
-            setRangeLastAction(message, { action: "clipboard-range" });
-        },
-        readClipboardPayload: clipboardBridge.readClipboardPayload,
-        parseClipboardMatrix: clipboardBridge.parseClipboardMatrix,
-        copySelection: clipboardBridge.copySelection,
-        captureBeforeSnapshot: captureMutationSnapshot,
-        async recordIntentTransaction(descriptor, beforeSnapshot) {
-            try {
-                await recordCellRangeIntent(descriptor, beforeSnapshot);
-            }
-            catch {
-                // Keep mutation result deterministic even when history record fails.
-            }
-        },
-    });
-    const rangeMutationEngine = useDataGridRangeMutationEngine({
-        resolveRangeMoveBaseRange: resolveCopyRange,
-        resolveRangeMovePreviewRange: () => normalizeCellRange(rangeMovePreviewRange.value),
-        resolveFillBaseRange: resolveCopyRange,
-        resolveFillPreviewRange: () => normalizeCellRange(fillPreviewRange.value),
-        areRangesEqual: areCellRangesEqual,
-        captureBeforeSnapshot: captureMutationSnapshot,
-        resolveSourceRows: () => options.rows.value,
-        resolveSourceRowId: resolveSourceRowId,
-        applySourceRows(nextRows) {
-            options.rows.value = nextRows;
-        },
-        resolveDisplayedRows: materializeDisplayRows,
-        resolveDisplayedRowId(rowNode) {
-            return String(rowNode.rowId ?? rowNode.rowKey ?? rowNode.sourceIndex);
-        },
-        resolveColumnKeyAtIndex: resolveColumnKeyAtIndex,
-        resolveDisplayedCellValue(rowNode, columnKey) {
-            if (rowNode.kind !== "leaf") {
-                return null;
-            }
-            return resolveCellValue(rowNode.data, columnKey);
-        },
-        resolveSourceCellValue: resolveCellValue,
-        normalizeClipboardValue(value) {
-            if (value === null || typeof value === "undefined") {
-                return "";
-            }
-            return String(value);
-        },
-        isExcludedColumn: columnKey => columnKey === "select",
-        isEditableColumn: columnKey => columnKey !== "select",
-        applyValueForMove: applyDraftValue,
-        clearValueForMove: clearCellValue,
-        applyEditedValue: applyDraftValue,
-        recomputeDerived: () => { },
-        isCellWithinRange(rowIndex, columnIndex, range) {
-            return (rowIndex >= range.startRow
-                && rowIndex <= range.endRow
-                && columnIndex >= range.startColumn
-                && columnIndex <= range.endColumn);
-        },
-        setSelectionFromRange(range, activePosition) {
-            options.applySelectionFromRange(range, activePosition);
-        },
-        recordIntent(descriptor, beforeSnapshot) {
-            void recordCellRangeIntent(descriptor, beforeSnapshot).catch(() => {
-                // Keep range mutation deterministic when history logging fails.
-            });
-        },
-        setLastAction(message) {
-            setRangeLastAction(message, { action: "range-mutation" });
-        },
-    });
-    const setFillPreviewRange = (range) => {
-        fillPreviewRange.value = normalizeCellRange(range);
-    };
-    const setRangeMovePreviewRange = (range) => {
-        rangeMovePreviewRange.value = normalizeCellRange(range);
-    };
-    const interactionsEnabled = ref(options.interactions.enabled);
-    const rangeInteractionsEnabled = ref(options.interactions.rangeEnabled);
-    const rangeFillEnabled = ref(options.interactions.fillEnabled);
-    const rangeMoveEnabled = ref(options.interactions.moveEnabled);
-    const rangePointerMode = ref("idle");
-    const isRangePointerActive = ref(false);
-    const clearRangePreviews = () => {
-        setFillPreviewRange(null);
-        setRangeMovePreviewRange(null);
-    };
-    const computeFillPreview = (baseRange, rowIndex, columnIndex) => {
-        const rowDistance = Math.abs(rowIndex - baseRange.endRow);
-        const columnDistance = Math.abs(columnIndex - baseRange.endColumn);
-        const fillAxis = rowDistance >= columnDistance ? "vertical" : "horizontal";
-        if (fillAxis === "vertical") {
-            return normalizeCellRange({
-                startRow: Math.min(baseRange.startRow, rowIndex),
-                endRow: Math.max(baseRange.endRow, rowIndex),
-                startColumn: baseRange.startColumn,
-                endColumn: baseRange.endColumn,
-            }) ?? baseRange;
-        }
-        return normalizeCellRange({
-            startRow: baseRange.startRow,
-            endRow: baseRange.endRow,
-            startColumn: Math.min(baseRange.startColumn, columnIndex),
-            endColumn: Math.max(baseRange.endColumn, columnIndex),
-        }) ?? baseRange;
-    };
-    const computeRangeMovePreview = (baseRange, rowIndex, columnIndex) => {
-        const rowSpan = Math.max(1, baseRange.endRow - baseRange.startRow + 1);
-        const columnSpan = Math.max(1, baseRange.endColumn - baseRange.startColumn + 1);
-        return normalizeCellRange({
-            startRow: rowIndex,
-            endRow: rowIndex + rowSpan - 1,
-            startColumn: columnIndex,
-            endColumn: columnIndex + columnSpan - 1,
-        }) ?? baseRange;
-    };
-    const updateRangePointerPreview = (rowIndex, columnKey) => {
-        if (!rangeInteractionsEnabled.value || !isRangePointerActive.value) {
-            return;
-        }
-        const baseRange = normalizeCellRange(options.cellSelectionRange.value);
-        const columnIndex = options.resolveVisibleColumnIndex(columnKey);
-        if (!baseRange || columnIndex < 0) {
-            return;
-        }
-        if (rangePointerMode.value === "fill" && rangeFillEnabled.value) {
-            setFillPreviewRange(computeFillPreview(baseRange, rowIndex, columnIndex));
-            return;
-        }
-        if (rangePointerMode.value === "move" && rangeMoveEnabled.value) {
-            setRangeMovePreviewRange(computeRangeMovePreview(baseRange, rowIndex, columnIndex));
-        }
-    };
-    const stopRangePointerInteraction = (apply = true) => {
-        if (!isRangePointerActive.value) {
-            return;
-        }
-        const mode = rangePointerMode.value;
-        isRangePointerActive.value = false;
-        rangePointerMode.value = "idle";
-        if (!apply) {
-            clearRangePreviews();
-            return;
-        }
-        if (mode === "fill" && rangeFillEnabled.value) {
-            rangeMutationEngine.applyFillPreview();
-            return;
-        }
-        if (mode === "move" && rangeMoveEnabled.value) {
-            rangeMutationEngine.applyRangeMove();
-        }
-    };
-    const startRangePointerInteraction = (mode, params) => {
-        if (!interactionsEnabled.value || !rangeInteractionsEnabled.value) {
-            return false;
-        }
-        if (mode === "fill" && !rangeFillEnabled.value) {
-            return false;
-        }
-        if (mode === "move" && !rangeMoveEnabled.value) {
-            return false;
-        }
-        const columnIndex = options.resolveVisibleColumnIndex(params.columnKey);
-        if (columnIndex < 0 || !normalizeCellRange(options.cellSelectionRange.value)) {
-            return false;
-        }
-        rangePointerMode.value = mode;
-        isRangePointerActive.value = true;
-        updateRangePointerPreview(params.rowIndex, params.columnKey);
-        return true;
-    };
-    const copySelection = (trigger = "context-menu") => (clipboardBridge.copySelection(trigger));
-    const pasteSelection = (trigger = "context-menu") => (clipboardMutations.pasteSelection(trigger));
-    const cutSelection = (trigger = "context-menu") => (clipboardMutations.cutSelection(trigger));
-    const clearSelection = (trigger = "context-menu") => (clipboardMutations.clearCurrentSelection(trigger));
-    const hasCellRangeContext = () => Boolean(resolveCopyRange() || resolveCurrentCellCoord());
-    return {
-        copiedRange: copiedSelectionRange,
-        fillPreviewRange,
-        rangeMovePreviewRange,
-        lastAction: cellRangeLastAction,
-        interactionsEnabled,
-        rangeInteractionsEnabled,
-        rangeFillEnabled,
-        rangeMoveEnabled,
-        rangePointerMode,
-        stopRangePointerInteraction,
-        startRangePointerInteraction,
-        updateRangePointerPreview,
-        hasCellRangeContext,
-        resolveActiveRangeCellCount,
-        copySelection,
-        pasteSelection,
-        cutSelection,
-        clearSelection,
-        setFillPreviewRange,
-        setRangeMovePreviewRange,
-        applyFillPreview: rangeMutationEngine.applyFillPreview,
-        applyRangeMove: rangeMutationEngine.applyRangeMove,
-        dispose: clipboardBridge.dispose,
-    };
-}

package/dist/composables/internal/useAffinoDataGrid/useAffinoDataGridResultAssembly.d.ts

@@ -1,23 +0,0 @@
-import type { Ref } from "vue";
-import type { DataGridColumnDef } from "@affino/datagrid-core";
-import type { UseDataGridRuntimeResult } from "../../useDataGridRuntime";
-import type { UseAffinoDataGridFeatureSuiteResult } from "./useAffinoDataGridFeatureSuite";
-import type { UseAffinoDataGridBindingSuiteResult } from "./useAffinoDataGridBindingSuite";
-import type { UseAffinoDataGridResult } from "../../useAffinoDataGrid.types";
-export interface UseAffinoDataGridResultAssemblyOptions<TRow> {
-    runtime: UseDataGridRuntimeResult<TRow>;
-    rows: Ref<readonly TRow[]>;
-    columns: Ref<readonly DataGridColumnDef[]>;
-    componentProps: UseAffinoDataGridResult<TRow>["componentProps"];
-    sort: Pick<UseAffinoDataGridResult<TRow>, "sortState" | "setSortState" | "toggleColumnSort" | "clearSort">;
-    runAction: UseAffinoDataGridResult<TRow>["actions"]["runAction"];
-    filteringHelpers: UseAffinoDataGridResult<TRow>["features"]["filtering"]["helpers"];
-    featureSuite: UseAffinoDataGridFeatureSuiteResult<TRow>;
-    bindingSuite: UseAffinoDataGridBindingSuiteResult<TRow>;
-}
-type UseAffinoDataGridAssembledBaseResult<TRow> = Omit<UseAffinoDataGridResult<TRow>, "DataGrid" | "pagination" | "columnState" | "history" | "rowReorder" | "cellSelection" | "cellRange" | "bindings" | "events"> & {
-    bindings: Omit<UseAffinoDataGridResult<TRow>["bindings"], "cellSelection">;
-};
-export declare function assembleAffinoDataGridResult<TRow>(options: UseAffinoDataGridResultAssemblyOptions<TRow>): UseAffinoDataGridAssembledBaseResult<TRow>;
-export {};
-//# sourceMappingURL=useAffinoDataGridResultAssembly.d.ts.map

package/dist/composables/internal/useAffinoDataGrid/useAffinoDataGridResultAssembly.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useAffinoDataGridResultAssembly.d.ts","sourceRoot":"","sources":["../../../../src/composables/internal/useAffinoDataGrid/useAffinoDataGridResultAssembly.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAC9B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAC9D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAA;AACxE,OAAO,KAAK,EAAE,mCAAmC,EAAE,MAAM,iCAAiC,CAAA;AAC1F,OAAO,KAAK,EAAE,mCAAmC,EAAE,MAAM,iCAAiC,CAAA;AAC1F,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAA;AAE5E,MAAM,WAAW,sCAAsC,CAAC,IAAI;IAC1D,OAAO,EAAE,wBAAwB,CAAC,IAAI,CAAC,CAAA;IACvC,IAAI,EAAE,GAAG,CAAC,SAAS,IAAI,EAAE,CAAC,CAAA;IAC1B,OAAO,EAAE,GAAG,CAAC,SAAS,iBAAiB,EAAE,CAAC,CAAA;IAC1C,cAAc,EAAE,uBAAuB,CAAC,IAAI,CAAC,CAAC,gBAAgB,CAAC,CAAA;IAC/D,IAAI,EAAE,IAAI,CACR,uBAAuB,CAAC,IAAI,CAAC,EAC7B,WAAW,GAAG,cAAc,GAAG,kBAAkB,GAAG,WAAW,CAChE,CAAA;IACD,SAAS,EAAE,uBAAuB,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,CAAC,WAAW,CAAC,CAAA;IAChE,gBAAgB,EAAE,uBAAuB,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,CAAA;IACnF,YAAY,EAAE,mCAAmC,CAAC,IAAI,CAAC,CAAA;IACvD,YAAY,EAAE,mCAAmC,CAAC,IAAI,CAAC,CAAA;CACxD;AAED,KAAK,oCAAoC,CAAC,IAAI,IAAI,IAAI,CACpD,uBAAuB,CAAC,IAAI,CAAC,EAC7B,UAAU,GACR,YAAY,GACZ,aAAa,GACb,SAAS,GACT,YAAY,GACZ,eAAe,GACf,WAAW,GACX,UAAU,GACV,QAAQ,CACX,GAAG;IACF,QAAQ,EAAE,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC,EAAE,eAAe,CAAC,CAAA;CAC3E,CAAA;AAED,wBAAgB,4BAA4B,CAAC,IAAI,EAC/C,OAAO,EAAE,sCAAsC,CAAC,IAAI,CAAC,GACpD,oCAAoC,CAAC,IAAI,CAAC,CAmI5C"}

package/dist/composables/internal/useAffinoDataGrid/useAffinoDataGridResultAssembly.js

@@ -1,131 +0,0 @@
-export function assembleAffinoDataGridResult(options) {
-    const { runtime, rows, columns, componentProps, sort, runAction } = options;
-    const features = options.featureSuite;
-    const bindings = options.bindingSuite;
-    return {
-        ...runtime,
-        rows,
-        columns,
-        componentProps,
-        sortState: sort.sortState,
-        setSortState: sort.setSortState,
-        toggleColumnSort: sort.toggleColumnSort,
-        clearSort: sort.clearSort,
-        actions: {
-            copySelectedRows: features.copySelectedRows,
-            cutSelectedRows: features.cutSelectedRows,
-            pasteRowsAppend: features.pasteRowsAppend,
-            clearSelectedRows: features.clearSelectedRows,
-            selectAllRows: features.selectAllRows,
-            runAction,
-        },
-        contextMenu: {
-            state: bindings.contextMenuState,
-            style: bindings.contextMenuStyle,
-            actions: bindings.contextMenuActions,
-            contextMenuRef: bindings.contextMenuRef,
-            open: bindings.openContextMenu,
-            close: bindings.closeContextMenu,
-            onKeyDown: bindings.onContextMenuKeyDown,
-            runAction: bindings.runContextMenuAction,
-        },
-        features: {
-            selection: {
-                enabled: features.selectionEnabled,
-                selectedRowKeys: features.selectedRowKeys,
-                selectedCount: features.selectedCount,
-                isSelectedByKey: features.isSelectedByKey,
-                setSelectedByKey: features.setSelectedByKey,
-                toggleSelectedByKey: features.toggleSelectedByKey,
-                clearSelection: features.clearSelection,
-                resolveRowKey: features.resolveRowKey,
-            },
-            clipboard: {
-                enabled: features.clipboardEnabled,
-                lastCopiedText: features.lastCopiedText,
-                copyText: features.copyText,
-                readText: features.readText,
-                copyRows: features.copyRows,
-                parseRows: features.parseRows,
-            },
-            editing: {
-                enabled: features.editingEnabled,
-                mode: features.editingMode,
-                enum: features.editingEnum,
-                enumEditor: {
-                    enabled: features.enumEditorEnabled,
-                    primitive: features.enumEditorPrimitive,
-                    resolveOptions: features.resolveEnumEditorOptions,
-                },
-                activeSession: features.activeSession,
-                beginEdit: features.beginEdit,
-                updateDraft: features.updateDraft,
-                cancelEdit: features.cancelEdit,
-                commitEdit: features.commitEdit,
-            },
-            filtering: {
-                enabled: features.filteringEnabled,
-                model: features.filterModel,
-                setModel: features.setFilterModel,
-                clear: features.clearFilterModel,
-                setAdvancedExpression: features.setAdvancedFilterExpression,
-                helpers: options.filteringHelpers,
-            },
-            summary: {
-                enabled: features.summaryEnabled,
-                selected: features.selectedSummary,
-                recomputeSelected: features.recomputeSelectedSummary,
-            },
-            visibility: {
-                enabled: features.visibilityEnabled,
-                hiddenColumnKeys: features.hiddenColumnKeys,
-                isColumnVisible: features.isColumnVisible,
-                setColumnVisible: features.setColumnVisible,
-                toggleColumnVisible: features.toggleColumnVisible,
-                setHiddenColumnKeys: features.setHiddenColumnKeys,
-                reset: features.resetHiddenColumns,
-            },
-            tree: {
-                enabled: features.treeEnabled,
-                groupSelectsChildren: features.groupSelectsChildren,
-                groupBy: features.groupBy,
-                groupExpansion: features.groupExpansion,
-                setGroupBy: features.setGroupBy,
-                setGroupExpansion: features.setGroupExpansion,
-                clearGroupBy: features.clearGroupBy,
-                toggleGroup: features.toggleGroup,
-                isGroupExpanded: features.isGroupExpanded,
-                expandGroups: features.expandGroups,
-                collapseGroups: features.collapseGroups,
-                expandAll: features.expandAllGroups,
-                collapseAll: features.collapseAllGroups,
-            },
-            rowHeight: {
-                enabled: features.rowHeightEnabled,
-                supported: features.rowHeightSupported,
-                mode: features.rowHeightMode,
-                base: features.baseRowHeight,
-                setMode: features.setRowHeightMode,
-                setBase: features.setBaseRowHeight,
-                measureVisible: features.measureVisibleRowHeights,
-                apply: features.applyRowHeightSettings,
-            },
-        },
-        bindings: {
-            getRowKey: features.resolveRowKey,
-            headerSort: bindings.createHeaderSortBindings,
-            rowSelection: bindings.createRowSelectionBindings,
-            editableCell: bindings.createEditableCellBindings,
-            isCellEditing: features.isCellEditing,
-            inlineEditor: bindings.createInlineEditorBindings,
-            headerCell: bindings.createHeaderCellBindings,
-            headerReorder: bindings.createHeaderReorderBindings,
-            rowReorder: bindings.createRowReorderBindings,
-            dataCell: bindings.createDataCellBindings,
-            contextMenuRef: bindings.setContextMenuRef,
-            contextMenuRoot: bindings.createContextMenuRootBindings,
-            contextMenuAction: bindings.createContextMenuActionBinding,
-            actionButton: bindings.createActionButtonBinding,
-        },
-    };
-}

package/dist/composables/internal/useAffinoDataGrid/useAffinoDataGridRowHeightFeature.d.ts

@@ -1,30 +0,0 @@
-import { type ComputedRef, type Ref } from "vue";
-import type { UseDataGridRuntimeResult } from "../../useDataGridRuntime";
-export type AffinoRowHeightMode = "fixed" | "auto";
-export interface AffinoRowHeightFeatureInput {
-    enabled?: boolean;
-    mode?: AffinoRowHeightMode;
-    base?: number;
-}
-export interface NormalizedAffinoRowHeightFeature {
-    enabled: boolean;
-    mode: AffinoRowHeightMode;
-    base: number;
-}
-export interface UseAffinoDataGridRowHeightFeatureOptions<TRow> {
-    runtime: UseDataGridRuntimeResult<TRow>;
-    feature: NormalizedAffinoRowHeightFeature;
-}
-export interface UseAffinoDataGridRowHeightFeatureResult {
-    rowHeightEnabled: Ref<boolean>;
-    rowHeightMode: Ref<AffinoRowHeightMode>;
-    baseRowHeight: Ref<number>;
-    rowHeightSupported: ComputedRef<boolean>;
-    setRowHeightMode: (mode: AffinoRowHeightMode) => void;
-    setBaseRowHeight: (height: number) => void;
-    measureVisibleRowHeights: () => boolean;
-    applyRowHeightSettings: () => boolean;
-}
-export declare function normalizeRowHeightFeature(input: boolean | AffinoRowHeightFeatureInput | undefined): NormalizedAffinoRowHeightFeature;
-export declare function useAffinoDataGridRowHeightFeature<TRow>(options: UseAffinoDataGridRowHeightFeatureOptions<TRow>): UseAffinoDataGridRowHeightFeatureResult;
-//# sourceMappingURL=useAffinoDataGridRowHeightFeature.d.ts.map

package/dist/composables/internal/useAffinoDataGrid/useAffinoDataGridRowHeightFeature.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useAffinoDataGridRowHeightFeature.d.ts","sourceRoot":"","sources":["../../../../src/composables/internal/useAffinoDataGrid/useAffinoDataGridRowHeightFeature.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,KAAK,WAAW,EAAE,KAAK,GAAG,EAAE,MAAM,KAAK,CAAA;AACtE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAA;AAExE,MAAM,MAAM,mBAAmB,GAAG,OAAO,GAAG,MAAM,CAAA;AAElD,MAAM,WAAW,2BAA2B;IAC1C,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,IAAI,CAAC,EAAE,mBAAmB,CAAA;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,gCAAgC;IAC/C,OAAO,EAAE,OAAO,CAAA;IAChB,IAAI,EAAE,mBAAmB,CAAA;IACzB,IAAI,EAAE,MAAM,CAAA;CACb;AAED,MAAM,WAAW,wCAAwC,CAAC,IAAI;IAC5D,OAAO,EAAE,wBAAwB,CAAC,IAAI,CAAC,CAAA;IACvC,OAAO,EAAE,gCAAgC,CAAA;CAC1C;AAED,MAAM,WAAW,uCAAuC;IACtD,gBAAgB,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;IAC9B,aAAa,EAAE,GAAG,CAAC,mBAAmB,CAAC,CAAA;IACvC,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAC1B,kBAAkB,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;IACxC,gBAAgB,EAAE,CAAC,IAAI,EAAE,mBAAmB,KAAK,IAAI,CAAA;IACrD,gBAAgB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IAC1C,wBAAwB,EAAE,MAAM,OAAO,CAAA;IACvC,sBAAsB,EAAE,MAAM,OAAO,CAAA;CACtC;AAqBD,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,OAAO,GAAG,2BAA2B,GAAG,SAAS,GACvD,gCAAgC,CAoBlC;AAED,wBAAgB,iCAAiC,CAAC,IAAI,EACpD,OAAO,EAAE,wCAAwC,CAAC,IAAI,CAAC,GACtD,uCAAuC,CA6DzC"}