@affino/datagrid-vue 0.1.0

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

@@ -0,0 +1,316 @@
+function toAriaSortDirection(direction) {
+    if (direction === "asc") {
+        return "ascending";
+    }
+    if (direction === "desc") {
+        return "descending";
+    }
+    return "none";
+}
+export function useAffinoDataGridBaseBindings(options) {
+    const DRAG_COLUMN_KEY_MIME = "application/x-affino-datagrid-column-key";
+    const DRAG_ROW_KEY_MIME = "application/x-affino-datagrid-row-key";
+    let draggedColumnKey = null;
+    let draggedRowKey = null;
+    const resolveDraggedColumnKey = (event) => {
+        const dataTransfer = event?.dataTransfer ?? null;
+        if (dataTransfer) {
+            const explicit = dataTransfer.getData(DRAG_COLUMN_KEY_MIME);
+            if (explicit) {
+                return explicit;
+            }
+            const fallback = dataTransfer.getData("text/plain");
+            if (fallback) {
+                return fallback;
+            }
+        }
+        return draggedColumnKey;
+    };
+    const moveColumnBefore = (sourceKey, targetKey) => {
+        if (!sourceKey || !targetKey || sourceKey === targetKey) {
+            return false;
+        }
+        const currentOrder = [...options.resolveColumnOrder()];
+        const sourceIndex = currentOrder.indexOf(sourceKey);
+        const targetIndex = currentOrder.indexOf(targetKey);
+        if (sourceIndex < 0 || targetIndex < 0) {
+            return false;
+        }
+        const withoutSource = currentOrder.filter(key => key !== sourceKey);
+        const nextTargetIndex = withoutSource.indexOf(targetKey);
+        if (nextTargetIndex < 0) {
+            return false;
+        }
+        withoutSource.splice(nextTargetIndex, 0, sourceKey);
+        options.setColumnOrder(withoutSource);
+        return true;
+    };
+    const moveColumnByOffset = (columnKey, offset) => {
+        const currentOrder = [...options.resolveColumnOrder()];
+        const fromIndex = currentOrder.indexOf(columnKey);
+        if (fromIndex < 0) {
+            return false;
+        }
+        const toIndex = Math.max(0, Math.min(currentOrder.length - 1, fromIndex + offset));
+        if (toIndex === fromIndex) {
+            return false;
+        }
+        const [moved] = currentOrder.splice(fromIndex, 1);
+        if (!moved) {
+            return false;
+        }
+        currentOrder.splice(toIndex, 0, moved);
+        options.setColumnOrder(currentOrder);
+        return true;
+    };
+    const resolveDraggedRowKey = (event) => {
+        const dataTransfer = event?.dataTransfer ?? null;
+        if (dataTransfer) {
+            const explicit = dataTransfer.getData(DRAG_ROW_KEY_MIME);
+            if (explicit) {
+                return explicit;
+            }
+            const fallback = dataTransfer.getData("text/plain");
+            if (fallback) {
+                return fallback;
+            }
+        }
+        return draggedRowKey;
+    };
+    const moveRowByOffset = async (rowKey, offset) => {
+        if (!options.canReorderRows()) {
+            return false;
+        }
+        const order = options.resolveRowOrder();
+        const fromIndex = order.indexOf(rowKey);
+        if (fromIndex < 0) {
+            return false;
+        }
+        const targetIndex = fromIndex + offset;
+        if (targetIndex < 0 || targetIndex >= order.length) {
+            return false;
+        }
+        const targetKey = order[targetIndex];
+        if (!targetKey) {
+            return false;
+        }
+        return options.moveRowByKey(rowKey, targetKey, offset > 0 ? "after" : "before");
+    };
+    const createHeaderSortBindings = (columnKey) => ({
+        role: "columnheader",
+        tabindex: 0,
+        "aria-sort": toAriaSortDirection(options.resolveColumnSortDirection(columnKey)),
+        onClick: (_event) => {
+            options.toggleColumnSort(columnKey);
+        },
+        onKeydown: (event) => {
+            if (event.key !== "Enter" && event.key !== " ") {
+                return;
+            }
+            event.preventDefault();
+            options.toggleColumnSort(columnKey);
+        },
+    });
+    const createHeaderReorderBindings = (columnKey) => ({
+        draggable: true,
+        "data-column-key": columnKey,
+        onDragstart: (event) => {
+            draggedColumnKey = columnKey;
+            if (event.dataTransfer) {
+                event.dataTransfer.effectAllowed = "move";
+                event.dataTransfer.setData(DRAG_COLUMN_KEY_MIME, columnKey);
+                event.dataTransfer.setData("text/plain", columnKey);
+            }
+        },
+        onDragover: (event) => {
+            event.preventDefault();
+            if (event.dataTransfer) {
+                event.dataTransfer.dropEffect = "move";
+            }
+        },
+        onDrop: (event) => {
+            event.preventDefault();
+            const sourceKey = resolveDraggedColumnKey(event);
+            if (!sourceKey) {
+                draggedColumnKey = null;
+                return;
+            }
+            moveColumnBefore(sourceKey, columnKey);
+            draggedColumnKey = null;
+        },
+        onDragend: (_event) => {
+            draggedColumnKey = null;
+        },
+        onKeydown: (event) => {
+            if (!(event.altKey && event.shiftKey)) {
+                return;
+            }
+            if (event.key === "ArrowLeft") {
+                event.preventDefault();
+                moveColumnByOffset(columnKey, -1);
+                return;
+            }
+            if (event.key === "ArrowRight") {
+                event.preventDefault();
+                moveColumnByOffset(columnKey, 1);
+            }
+        },
+    });
+    const createRowSelectionBindings = (row, index) => {
+        const rowKey = options.resolveRowKey(row, index);
+        return {
+            role: "row",
+            tabindex: 0,
+            "data-row-key": rowKey,
+            "aria-selected": (options.isSelectedByKey(rowKey) ? "true" : "false"),
+            onClick: (event) => {
+                const shouldToggle = Boolean(event?.metaKey || event?.ctrlKey);
+                if (shouldToggle) {
+                    options.toggleSelectedByKey(rowKey);
+                    return;
+                }
+                options.selectOnlyRow(rowKey);
+            },
+            onKeydown: (event) => {
+                if (event.key !== " " && event.key !== "Enter") {
+                    return;
+                }
+                event.preventDefault();
+                const shouldToggle = event.metaKey || event.ctrlKey;
+                if (shouldToggle) {
+                    options.toggleSelectedByKey(rowKey);
+                    return;
+                }
+                options.selectOnlyRow(rowKey);
+            },
+        };
+    };
+    const createRowReorderBindings = (row, index) => {
+        const rowKey = options.resolveRowKey(row, index);
+        return {
+            draggable: true,
+            "data-row-key": rowKey,
+            onDragstart: (event) => {
+                if (!options.canReorderRows()) {
+                    event.preventDefault();
+                    draggedRowKey = null;
+                    return;
+                }
+                draggedRowKey = rowKey;
+                if (event.dataTransfer) {
+                    event.dataTransfer.effectAllowed = "move";
+                    event.dataTransfer.setData(DRAG_ROW_KEY_MIME, rowKey);
+                    event.dataTransfer.setData("text/plain", rowKey);
+                }
+            },
+            onDragover: (event) => {
+                if (!options.canReorderRows()) {
+                    return;
+                }
+                event.preventDefault();
+                if (event.dataTransfer) {
+                    event.dataTransfer.dropEffect = "move";
+                }
+            },
+            onDrop: (event) => {
+                event.preventDefault();
+                if (!options.canReorderRows()) {
+                    draggedRowKey = null;
+                    return;
+                }
+                const sourceKey = resolveDraggedRowKey(event);
+                if (!sourceKey) {
+                    draggedRowKey = null;
+                    return;
+                }
+                void options.moveRowByKey(sourceKey, rowKey, "before");
+                draggedRowKey = null;
+            },
+            onDragend: (_event) => {
+                draggedRowKey = null;
+            },
+            onKeydown: (event) => {
+                if (!(event.altKey && event.shiftKey)) {
+                    return;
+                }
+                if (event.key === "ArrowUp") {
+                    event.preventDefault();
+                    void moveRowByOffset(rowKey, -1);
+                    return;
+                }
+                if (event.key === "ArrowDown") {
+                    event.preventDefault();
+                    void moveRowByOffset(rowKey, 1);
+                }
+            },
+        };
+    };
+    const createEditableCellBindings = (params) => {
+        const rowKey = options.resolveRowKey(params.row, params.rowIndex);
+        const editable = params.editable ?? true;
+        const startEdit = () => {
+            if (!editable || !options.editingEnabled.value) {
+                return;
+            }
+            options.beginEdit({
+                rowKey,
+                columnKey: params.columnKey,
+                draft: options.resolveCellDraft({
+                    row: params.row,
+                    columnKey: params.columnKey,
+                    value: params.value,
+                }),
+            });
+        };
+        return {
+            "data-row-key": rowKey,
+            "data-column-key": params.columnKey,
+            "data-inline-editable": editable ? "true" : "false",
+            onDblclick: (_event) => {
+                startEdit();
+            },
+            onKeydown: (event) => {
+                if (event.key !== "Enter" && event.key !== "F2") {
+                    return;
+                }
+                event.preventDefault();
+                startEdit();
+            },
+        };
+    };
+    const createInlineEditorBindings = (params) => ({
+        value: options.isCellEditing(params.rowKey, params.columnKey)
+            ? (options.activeSession.value?.draft ?? "")
+            : "",
+        onInput: (event) => {
+            const target = event.target;
+            options.updateDraft(target?.value ?? "");
+        },
+        onBlur: () => {
+            if (params.commitOnBlur === false) {
+                return;
+            }
+            void options.commitEdit();
+        },
+        onKeydown: (event) => {
+            if (event.key === "Escape") {
+                event.preventDefault();
+                options.cancelEdit();
+                return;
+            }
+            if (event.key !== "Enter") {
+                return;
+            }
+            event.preventDefault();
+            void options.commitEdit();
+        },
+    });
+    return {
+        createHeaderSortBindings,
+        createHeaderReorderBindings,
+        createRowSelectionBindings,
+        createRowReorderBindings,
+        createEditableCellBindings,
+        createInlineEditorBindings,
+    };
+}

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

@@ -0,0 +1,40 @@
+import type { Ref } from "vue";
+import type { DataGridColumnDef, DataGridSortDirection } from "@affino/datagrid-core";
+import { type UseAffinoDataGridBaseBindingsResult } from "./useAffinoDataGridBaseBindings";
+import { type UseAffinoDataGridContextMenuFeatureResult } from "./useAffinoDataGridContextMenuFeature";
+import type { AffinoDataGridActionId, AffinoDataGridActionResult, AffinoDataGridEditMode, AffinoDataGridEditSession, AffinoDataGridRunActionOptions } from "../../useAffinoDataGrid.types";
+export interface UseAffinoDataGridBindingSuiteOptions<TRow> {
+    columns: Ref<readonly DataGridColumnDef[]>;
+    resolveColumnOrder: () => readonly string[];
+    setColumnOrder: (keys: readonly string[]) => void;
+    resolveRowOrder: () => readonly string[];
+    moveRowByKey: (sourceRowKey: string, targetRowKey: string, position?: "before" | "after") => Promise<boolean> | boolean;
+    canReorderRows: () => boolean;
+    resolveRowKey: (row: TRow, index: number) => string;
+    resolveColumnSortDirection: (columnKey: string) => DataGridSortDirection | null;
+    toggleColumnSort: (columnKey: string, directionCycle?: readonly DataGridSortDirection[]) => void;
+    isSelectedByKey: (rowKey: string) => boolean;
+    toggleSelectedByKey: (rowKey: string) => void;
+    selectOnlyRow: (rowKey: string) => void;
+    editingEnabled: Ref<boolean>;
+    beginEdit: (session: Omit<AffinoDataGridEditSession, "mode"> & {
+        mode?: AffinoDataGridEditMode;
+    }) => boolean;
+    resolveCellDraft: (params: {
+        row: TRow;
+        columnKey: string;
+        value?: unknown;
+    }) => string;
+    isCellEditing: (rowKey: string, columnKey: string) => boolean;
+    activeSession: Ref<AffinoDataGridEditSession | null>;
+    updateDraft: (draft: string) => boolean;
+    cancelEdit: () => boolean;
+    commitEdit: () => Promise<boolean>;
+    runAction: (actionId: AffinoDataGridActionId, actionOptions?: AffinoDataGridRunActionOptions) => Promise<AffinoDataGridActionResult>;
+}
+export type UseAffinoDataGridBindingSuiteResult<TRow> = UseAffinoDataGridBaseBindingsResult<TRow> & UseAffinoDataGridContextMenuFeatureResult<TRow, AffinoDataGridActionId, AffinoDataGridActionResult> & {
+    findCellElement: (rowKey: string, columnKey: string) => HTMLElement | null;
+    findHeaderElement: (columnKey: string) => HTMLElement | null;
+};
+export declare function useAffinoDataGridBindingSuite<TRow>(options: UseAffinoDataGridBindingSuiteOptions<TRow>): UseAffinoDataGridBindingSuiteResult<TRow>;
+//# sourceMappingURL=useAffinoDataGridBindingSuite.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useAffinoDataGridBindingSuite.d.ts","sourceRoot":"","sources":["../../../../src/composables/internal/useAffinoDataGrid/useAffinoDataGridBindingSuite.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,68 @@
+import { useAffinoDataGridBaseBindings, } from "./useAffinoDataGridBaseBindings";
+import { useAffinoDataGridContextMenuFeature, } from "./useAffinoDataGridContextMenuFeature";
+export function useAffinoDataGridBindingSuite(options) {
+    const { createHeaderSortBindings, createHeaderReorderBindings, createRowSelectionBindings, createRowReorderBindings, createEditableCellBindings, createInlineEditorBindings, } = useAffinoDataGridBaseBindings({
+        resolveColumnOrder: options.resolveColumnOrder,
+        setColumnOrder: options.setColumnOrder,
+        resolveRowOrder: options.resolveRowOrder,
+        moveRowByKey: options.moveRowByKey,
+        canReorderRows: options.canReorderRows,
+        resolveColumnSortDirection: options.resolveColumnSortDirection,
+        toggleColumnSort: options.toggleColumnSort,
+        resolveRowKey: options.resolveRowKey,
+        isSelectedByKey: options.isSelectedByKey,
+        toggleSelectedByKey: options.toggleSelectedByKey,
+        selectOnlyRow: options.selectOnlyRow,
+        editingEnabled: options.editingEnabled,
+        beginEdit: options.beginEdit,
+        resolveCellDraft: options.resolveCellDraft,
+        isCellEditing: options.isCellEditing,
+        activeSession: options.activeSession,
+        updateDraft: options.updateDraft,
+        cancelEdit: options.cancelEdit,
+        commitEdit: options.commitEdit,
+    });
+    const contextMenuFeature = useAffinoDataGridContextMenuFeature({
+        columns: options.columns,
+        resolveRowKey: options.resolveRowKey,
+        createHeaderSortBindings,
+        createHeaderReorderBindings,
+        createEditableCellBindings,
+        runAction: options.runAction,
+    });
+    const findCellElement = (rowKey, columnKey) => {
+        if (typeof document === "undefined") {
+            return null;
+        }
+        const cells = document.querySelectorAll("[data-row-key][data-column-key]");
+        for (const cell of cells) {
+            if (cell.dataset.rowKey === rowKey && cell.dataset.columnKey === columnKey) {
+                return cell;
+            }
+        }
+        return null;
+    };
+    const findHeaderElement = (columnKey) => {
+        if (typeof document === "undefined") {
+            return null;
+        }
+        const headers = document.querySelectorAll("[role='columnheader'][data-column-key]");
+        for (const header of headers) {
+            if (header.dataset.columnKey === columnKey) {
+                return header;
+            }
+        }
+        return null;
+    };
+    return {
+        createHeaderSortBindings,
+        createHeaderReorderBindings,
+        createRowSelectionBindings,
+        createRowReorderBindings,
+        createEditableCellBindings,
+        createInlineEditorBindings,
+        findCellElement,
+        findHeaderElement,
+        ...contextMenuFeature,
+    };
+}

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

@@ -0,0 +1,37 @@
+import { type ComputedRef, type Ref } from "vue";
+import type { AffinoDataGridRowMutationOptions } from "./useAffinoDataGridFeatureSuite";
+export interface AffinoClipboardFeatureInput<TRow> {
+    enabled?: boolean;
+    useSystemClipboard?: boolean;
+    serializeRows?: (rows: readonly TRow[]) => string;
+    parseRows?: (text: string) => readonly TRow[];
+}
+export interface NormalizedAffinoClipboardFeature<TRow> {
+    enabled: boolean;
+    useSystemClipboard: boolean;
+    serializeRows: (rows: readonly TRow[]) => string;
+    parseRows: (text: string) => readonly TRow[];
+}
+export interface UseAffinoDataGridClipboardFeatureOptions<TRow> {
+    rows: Ref<readonly TRow[]>;
+    selectedRowKeySet: Ref<Set<string>>;
+    feature: NormalizedAffinoClipboardFeature<TRow>;
+    resolveRowKey: (row: TRow, index: number) => string;
+    replaceRows: (rows: readonly TRow[], options?: AffinoDataGridRowMutationOptions) => Promise<boolean>;
+}
+export interface UseAffinoDataGridClipboardFeatureResult<TRow> {
+    clipboardEnabled: Ref<boolean>;
+    lastCopiedText: ComputedRef<string>;
+    copyText: (text: string) => Promise<boolean>;
+    readText: () => Promise<string>;
+    copyRows: (rows?: readonly TRow[]) => Promise<boolean>;
+    parseRows: (text: string) => readonly TRow[];
+    resolveSelectedRows: () => readonly TRow[];
+    copySelectedRows: () => Promise<boolean>;
+    clearSelectedRows: () => Promise<number>;
+    cutSelectedRows: () => Promise<number>;
+    pasteRowsAppend: () => Promise<number>;
+}
+export declare function normalizeClipboardFeature<TRow>(input: boolean | AffinoClipboardFeatureInput<TRow> | undefined): NormalizedAffinoClipboardFeature<TRow>;
+export declare function useAffinoDataGridClipboardFeature<TRow>(options: UseAffinoDataGridClipboardFeatureOptions<TRow>): UseAffinoDataGridClipboardFeatureResult<TRow>;
+//# sourceMappingURL=useAffinoDataGridClipboardFeature.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useAffinoDataGridClipboardFeature.d.ts","sourceRoot":"","sources":["../../../../src/composables/internal/useAffinoDataGrid/useAffinoDataGridClipboardFeature.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,WAAW,EAAE,KAAK,GAAG,EAAE,MAAM,KAAK,CAAA;AAC/D,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,iCAAiC,CAAA;AAEvF,MAAM,WAAW,2BAA2B,CAAC,IAAI;IAC/C,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,kBAAkB,CAAC,EAAE,OAAO,CAAA;IAC5B,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,SAAS,IAAI,EAAE,KAAK,MAAM,CAAA;IACjD,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,SAAS,IAAI,EAAE,CAAA;CAC9C;AAED,MAAM,WAAW,gCAAgC,CAAC,IAAI;IACpD,OAAO,EAAE,OAAO,CAAA;IAChB,kBAAkB,EAAE,OAAO,CAAA;IAC3B,aAAa,EAAE,CAAC,IAAI,EAAE,SAAS,IAAI,EAAE,KAAK,MAAM,CAAA;IAChD,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,SAAS,IAAI,EAAE,CAAA;CAC7C;AAED,MAAM,WAAW,wCAAwC,CAAC,IAAI;IAC5D,IAAI,EAAE,GAAG,CAAC,SAAS,IAAI,EAAE,CAAC,CAAA;IAC1B,iBAAiB,EAAE,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAA;IACnC,OAAO,EAAE,gCAAgC,CAAC,IAAI,CAAC,CAAA;IAC/C,aAAa,EAAE,CAAC,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,CAAA;IACnD,WAAW,EAAE,CAAC,IAAI,EAAE,SAAS,IAAI,EAAE,EAAE,OAAO,CAAC,EAAE,gCAAgC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;CACrG;AAED,MAAM,WAAW,uCAAuC,CAAC,IAAI;IAC3D,gBAAgB,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;IAC9B,cAAc,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IACnC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAC5C,QAAQ,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAA;IAC/B,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,SAAS,IAAI,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IACtD,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,SAAS,IAAI,EAAE,CAAA;IAC5C,mBAAmB,EAAE,MAAM,SAAS,IAAI,EAAE,CAAA;IAC1C,gBAAgB,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAA;IACxC,iBAAiB,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAA;IACxC,eAAe,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAA;IACtC,eAAe,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAA;CACvC;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAC5C,KAAK,EAAE,OAAO,GAAG,2BAA2B,CAAC,IAAI,CAAC,GAAG,SAAS,GAC7D,gCAAgC,CAAC,IAAI,CAAC,CA8BxC;AAED,wBAAgB,iCAAiC,CAAC,IAAI,EACpD,OAAO,EAAE,wCAAwC,CAAC,IAAI,CAAC,GACtD,uCAAuC,CAAC,IAAI,CAAC,CAmI/C"}

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

@@ -0,0 +1,148 @@
+import { computed, ref } from "vue";
+export function normalizeClipboardFeature(input) {
+    if (typeof input === "boolean") {
+        return {
+            enabled: input,
+            useSystemClipboard: true,
+            serializeRows: rows => JSON.stringify(rows),
+            parseRows: text => {
+                try {
+                    const parsed = JSON.parse(text);
+                    return Array.isArray(parsed) ? parsed : [];
+                }
+                catch {
+                    return [];
+                }
+            },
+        };
+    }
+    if (!input) {
+        return {
+            enabled: false,
+            useSystemClipboard: true,
+            serializeRows: rows => JSON.stringify(rows),
+            parseRows: () => [],
+        };
+    }
+    return {
+        enabled: input.enabled ?? true,
+        useSystemClipboard: input.useSystemClipboard ?? true,
+        serializeRows: input.serializeRows ?? (rows => JSON.stringify(rows)),
+        parseRows: input.parseRows ?? (() => []),
+    };
+}
+export function useAffinoDataGridClipboardFeature(options) {
+    const clipboardEnabled = ref(options.feature.enabled);
+    const clipboardBuffer = ref("");
+    const lastCopiedText = computed(() => clipboardBuffer.value);
+    const copyText = async (text) => {
+        if (!clipboardEnabled.value) {
+            return false;
+        }
+        clipboardBuffer.value = text;
+        if (!options.feature.useSystemClipboard) {
+            return true;
+        }
+        try {
+            if (typeof navigator !== "undefined" && navigator.clipboard?.writeText) {
+                await navigator.clipboard.writeText(text);
+            }
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    const readText = async () => {
+        if (!clipboardEnabled.value) {
+            return "";
+        }
+        if (!options.feature.useSystemClipboard) {
+            return clipboardBuffer.value;
+        }
+        try {
+            if (typeof navigator !== "undefined" && navigator.clipboard?.readText) {
+                const text = await navigator.clipboard.readText();
+                clipboardBuffer.value = text;
+                return text;
+            }
+        }
+        catch {
+            // Ignore clipboard read failures and fall back to in-memory value.
+        }
+        return clipboardBuffer.value;
+    };
+    const copyRows = async (rowsOverride) => {
+        const payload = options.feature.serializeRows(rowsOverride ?? options.rows.value);
+        return copyText(payload);
+    };
+    const parseRows = (text) => options.feature.parseRows(text);
+    const resolveSelectedRows = () => options.rows.value.filter((row, index) => (options.selectedRowKeySet.value.has(options.resolveRowKey(row, index))));
+    const copySelectedRows = async () => copyRows(resolveSelectedRows());
+    const removeSelectedRows = async (mutation) => {
+        const selectedKeys = options.selectedRowKeySet.value;
+        if (!selectedKeys.size) {
+            return 0;
+        }
+        const nextRows = options.rows.value.filter((row, index) => !selectedKeys.has(options.resolveRowKey(row, index)));
+        const affected = options.rows.value.length - nextRows.length;
+        if (affected <= 0) {
+            return 0;
+        }
+        const didReplace = await options.replaceRows(nextRows, {
+            intent: mutation.intent,
+            label: mutation.label,
+            clearSelection: true,
+        });
+        if (!didReplace) {
+            return 0;
+        }
+        return affected;
+    };
+    const clearSelectedRows = async () => removeSelectedRows({
+        intent: "clear",
+        label: "Clear selected rows",
+    });
+    const cutSelectedRows = async () => {
+        const copied = await copySelectedRows();
+        if (!copied) {
+            return 0;
+        }
+        return removeSelectedRows({
+            intent: "cut",
+            label: "Cut selected rows",
+        });
+    };
+    const pasteRowsAppend = async () => {
+        const text = await readText();
+        if (!text) {
+            return 0;
+        }
+        const parsedRows = parseRows(text);
+        if (parsedRows.length === 0) {
+            return 0;
+        }
+        const nextRows = [...options.rows.value, ...parsedRows];
+        const didReplace = await options.replaceRows(nextRows, {
+            intent: "paste",
+            label: "Paste rows append",
+        });
+        if (!didReplace) {
+            return 0;
+        }
+        return parsedRows.length;
+    };
+    return {
+        clipboardEnabled,
+        lastCopiedText,
+        copyText,
+        readText,
+        copyRows,
+        parseRows,
+        resolveSelectedRows,
+        copySelectedRows,
+        clearSelectedRows,
+        cutSelectedRows,
+        pasteRowsAppend,
+    };
+}