@affino/datagrid-vue 0.1.0

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

@@ -0,0 +1,220 @@
+import { onBeforeUnmount, ref } from "vue";
+function cloneGroupBy(groupBy) {
+    if (!groupBy) {
+        return null;
+    }
+    return {
+        fields: Array.isArray(groupBy.fields) ? [...groupBy.fields] : [],
+        expandedByDefault: Boolean(groupBy.expandedByDefault),
+    };
+}
+function cloneGroupExpansion(expansion) {
+    if (!expansion) {
+        return {
+            expandedByDefault: false,
+            toggledGroupKeys: [],
+        };
+    }
+    return {
+        expandedByDefault: Boolean(expansion.expandedByDefault),
+        toggledGroupKeys: Array.isArray(expansion.toggledGroupKeys) ? [...expansion.toggledGroupKeys] : [],
+    };
+}
+function normalizeGroupKey(groupKey) {
+    if (typeof groupKey !== "string") {
+        return null;
+    }
+    const trimmed = groupKey.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function toUniqueGroupKeys(groupKeys) {
+    const unique = new Set();
+    for (const rawKey of groupKeys) {
+        const key = normalizeGroupKey(rawKey);
+        if (key) {
+            unique.add(key);
+        }
+    }
+    return Array.from(unique);
+}
+function resolveRowGroupKey(row) {
+    if (row.kind !== "group") {
+        return null;
+    }
+    const fromMeta = row.groupMeta?.groupKey;
+    if (typeof fromMeta === "string" && fromMeta.trim().length > 0) {
+        return fromMeta.trim();
+    }
+    if (typeof row.rowId === "string" && row.rowId.trim().length > 0) {
+        return row.rowId.trim();
+    }
+    return null;
+}
+export function normalizeTreeFeature(input) {
+    if (typeof input === "boolean") {
+        return {
+            enabled: input,
+            initialGroupBy: null,
+            groupSelectsChildren: false,
+        };
+    }
+    if (!input) {
+        return {
+            enabled: false,
+            initialGroupBy: null,
+            groupSelectsChildren: false,
+        };
+    }
+    return {
+        enabled: input.enabled ?? true,
+        initialGroupBy: cloneGroupBy(input.initialGroupBy ?? null),
+        groupSelectsChildren: Boolean(input.groupSelectsChildren),
+    };
+}
+export function useAffinoDataGridTreeFeature(options) {
+    const treeEnabled = ref(options.feature.enabled);
+    const groupSelectsChildren = ref(Boolean(options.feature.groupSelectsChildren));
+    const snapshot = options.runtime.rowModel.getSnapshot();
+    const groupBy = ref(cloneGroupBy(snapshot.groupBy));
+    const groupExpansion = ref(cloneGroupExpansion(snapshot.groupExpansion));
+    const unsubscribe = options.runtime.rowModel.subscribe(next => {
+        groupBy.value = cloneGroupBy(next.groupBy);
+        groupExpansion.value = cloneGroupExpansion(next.groupExpansion);
+    });
+    onBeforeUnmount(() => {
+        unsubscribe();
+    });
+    if (treeEnabled.value && options.feature.initialGroupBy) {
+        options.runtime.api.setGroupBy(cloneGroupBy(options.feature.initialGroupBy));
+    }
+    const setGroupBy = (nextGroupBy) => {
+        if (!treeEnabled.value) {
+            return;
+        }
+        options.runtime.api.setGroupBy(cloneGroupBy(nextGroupBy));
+    };
+    const clearGroupBy = () => {
+        if (!treeEnabled.value) {
+            return;
+        }
+        options.runtime.api.setGroupBy(null);
+    };
+    const setGroupExpansion = (expansion) => {
+        if (!treeEnabled.value) {
+            return;
+        }
+        options.runtime.api.setGroupExpansion(expansion);
+    };
+    const toggleGroup = (groupKey) => {
+        if (!treeEnabled.value) {
+            return;
+        }
+        const key = normalizeGroupKey(groupKey);
+        if (!key) {
+            return;
+        }
+        options.runtime.api.toggleGroup(key);
+    };
+    const isGroupExpanded = (groupKey) => {
+        const key = normalizeGroupKey(groupKey);
+        if (!key) {
+            return false;
+        }
+        const expansion = groupExpansion.value;
+        const toggled = new Set(expansion.toggledGroupKeys ?? []);
+        return expansion.expandedByDefault ? !toggled.has(key) : toggled.has(key);
+    };
+    const collectVisibleGroupKeys = () => {
+        const total = options.runtime.api.getRowCount();
+        if (total <= 0) {
+            return [];
+        }
+        const rows = options.runtime.api.getRowsInRange({ start: 0, end: total - 1 });
+        const keys = new Set();
+        for (const row of rows) {
+            if (!row) {
+                continue;
+            }
+            const key = resolveRowGroupKey(row);
+            if (key) {
+                keys.add(key);
+            }
+        }
+        return Array.from(keys);
+    };
+    const resolveTargetGroupKeys = (groupKeys) => {
+        if (!groupKeys || groupKeys.length === 0) {
+            return collectVisibleGroupKeys();
+        }
+        return toUniqueGroupKeys(groupKeys);
+    };
+    const expandGroups = (groupKeys) => {
+        if (!treeEnabled.value) {
+            return 0;
+        }
+        const targets = resolveTargetGroupKeys(groupKeys);
+        let affected = 0;
+        for (const groupKey of targets) {
+            if (isGroupExpanded(groupKey)) {
+                continue;
+            }
+            options.runtime.api.expandGroup(groupKey);
+            affected += 1;
+        }
+        return affected;
+    };
+    const collapseGroups = (groupKeys) => {
+        if (!treeEnabled.value) {
+            return 0;
+        }
+        const targets = resolveTargetGroupKeys(groupKeys);
+        let affected = 0;
+        for (const groupKey of targets) {
+            if (!isGroupExpanded(groupKey)) {
+                continue;
+            }
+            options.runtime.api.collapseGroup(groupKey);
+            affected += 1;
+        }
+        return affected;
+    };
+    const expandAllGroups = () => {
+        if (!treeEnabled.value) {
+            return 0;
+        }
+        const previous = cloneGroupExpansion(groupExpansion.value);
+        if (previous.expandedByDefault && previous.toggledGroupKeys.length === 0) {
+            return 0;
+        }
+        const visibleGroupsBefore = collectVisibleGroupKeys().length;
+        options.runtime.api.expandAllGroups();
+        return visibleGroupsBefore > 0 ? visibleGroupsBefore : 1;
+    };
+    const collapseAllGroups = () => {
+        if (!treeEnabled.value) {
+            return 0;
+        }
+        const previous = cloneGroupExpansion(groupExpansion.value);
+        if (!previous.expandedByDefault && previous.toggledGroupKeys.length === 0) {
+            return 0;
+        }
+        const visibleGroupsBefore = collectVisibleGroupKeys().length;
+        options.runtime.api.collapseAllGroups();
+        return visibleGroupsBefore > 0 ? visibleGroupsBefore : 1;
+    };
+    return {
+        treeEnabled,
+        groupSelectsChildren,
+        groupBy,
+        groupExpansion,
+        setGroupBy,
+        setGroupExpansion,
+        clearGroupBy,
+        toggleGroup,
+        isGroupExpanded,
+        expandGroups,
+        collapseGroups,
+        expandAllGroups,
+        collapseAllGroups,
+    };
+}

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

@@ -0,0 +1,28 @@
+import { type ComputedRef, type Ref } from "vue";
+import type { DataGridColumnDef } from "@affino/datagrid-core";
+import type { UseDataGridRuntimeResult } from "../../useDataGridRuntime";
+export interface AffinoVisibilityFeatureInput {
+    enabled?: boolean;
+    hiddenColumnKeys?: readonly string[];
+}
+export interface NormalizedAffinoVisibilityFeature {
+    enabled: boolean;
+    hiddenColumnKeys: readonly string[];
+}
+export interface UseAffinoDataGridVisibilityFeatureOptions<TRow> {
+    runtime: UseDataGridRuntimeResult<TRow>;
+    columns: Ref<readonly DataGridColumnDef[]>;
+    feature: NormalizedAffinoVisibilityFeature;
+}
+export interface UseAffinoDataGridVisibilityFeatureResult {
+    visibilityEnabled: Ref<boolean>;
+    hiddenColumnKeys: ComputedRef<readonly string[]>;
+    isColumnVisible: (columnKey: string) => boolean;
+    setColumnVisible: (columnKey: string, visible: boolean) => void;
+    toggleColumnVisible: (columnKey: string) => void;
+    setHiddenColumnKeys: (keys: readonly string[]) => void;
+    resetHiddenColumns: () => void;
+}
+export declare function normalizeVisibilityFeature(input: boolean | AffinoVisibilityFeatureInput | undefined): NormalizedAffinoVisibilityFeature;
+export declare function useAffinoDataGridVisibilityFeature<TRow>(options: UseAffinoDataGridVisibilityFeatureOptions<TRow>): UseAffinoDataGridVisibilityFeatureResult;
+//# sourceMappingURL=useAffinoDataGridVisibilityFeature.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useAffinoDataGridVisibilityFeature.d.ts","sourceRoot":"","sources":["../../../../src/composables/internal/useAffinoDataGrid/useAffinoDataGridVisibilityFeature.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,KAAK,WAAW,EAAE,KAAK,GAAG,EAAE,MAAM,KAAK,CAAA;AACtE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAC9D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAA;AAExE,MAAM,WAAW,4BAA4B;IAC3C,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CACrC;AAED,MAAM,WAAW,iCAAiC;IAChD,OAAO,EAAE,OAAO,CAAA;IAChB,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAA;CACpC;AAED,MAAM,WAAW,yCAAyC,CAAC,IAAI;IAC7D,OAAO,EAAE,wBAAwB,CAAC,IAAI,CAAC,CAAA;IACvC,OAAO,EAAE,GAAG,CAAC,SAAS,iBAAiB,EAAE,CAAC,CAAA;IAC1C,OAAO,EAAE,iCAAiC,CAAA;CAC3C;AAED,MAAM,WAAW,wCAAwC;IACvD,iBAAiB,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;IAC/B,gBAAgB,EAAE,WAAW,CAAC,SAAS,MAAM,EAAE,CAAC,CAAA;IAChD,eAAe,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAA;IAC/C,gBAAgB,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA;IAC/D,mBAAmB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAA;IAChD,mBAAmB,EAAE,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,KAAK,IAAI,CAAA;IACtD,kBAAkB,EAAE,MAAM,IAAI,CAAA;CAC/B;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,OAAO,GAAG,4BAA4B,GAAG,SAAS,GACxD,iCAAiC,CAiBnC;AAED,wBAAgB,kCAAkC,CAAC,IAAI,EACrD,OAAO,EAAE,yCAAyC,CAAC,IAAI,CAAC,GACvD,wCAAwC,CA+C1C"}

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

@@ -0,0 +1,59 @@
+import { computed, ref, watch } from "vue";
+export function normalizeVisibilityFeature(input) {
+    if (typeof input === "boolean") {
+        return {
+            enabled: input,
+            hiddenColumnKeys: [],
+        };
+    }
+    if (!input) {
+        return {
+            enabled: false,
+            hiddenColumnKeys: [],
+        };
+    }
+    return {
+        enabled: input.enabled ?? true,
+        hiddenColumnKeys: Array.isArray(input.hiddenColumnKeys) ? [...input.hiddenColumnKeys] : [],
+    };
+}
+export function useAffinoDataGridVisibilityFeature(options) {
+    const visibilityEnabled = ref(options.feature.enabled);
+    const hiddenColumnKeySet = ref(new Set(options.feature.hiddenColumnKeys));
+    const hiddenColumnKeys = computed(() => Array.from(hiddenColumnKeySet.value));
+    const isColumnVisible = (columnKey) => (!hiddenColumnKeySet.value.has(columnKey));
+    const setColumnVisible = (columnKey, visible) => {
+        const next = new Set(hiddenColumnKeySet.value);
+        if (visible) {
+            next.delete(columnKey);
+        }
+        else {
+            next.add(columnKey);
+        }
+        hiddenColumnKeySet.value = next;
+    };
+    const toggleColumnVisible = (columnKey) => {
+        setColumnVisible(columnKey, !isColumnVisible(columnKey));
+    };
+    const setHiddenColumnKeys = (keys) => {
+        hiddenColumnKeySet.value = new Set(keys);
+    };
+    const resetHiddenColumns = () => {
+        hiddenColumnKeySet.value = new Set();
+    };
+    watch([options.columns, hiddenColumnKeys, visibilityEnabled], ([nextColumns, nextHiddenColumnKeys, enabled]) => {
+        const hidden = new Set(nextHiddenColumnKeys);
+        nextColumns.forEach(column => {
+            options.runtime.api.setColumnVisibility(column.key, !enabled || !hidden.has(column.key));
+        });
+    }, { immediate: true });
+    return {
+        visibilityEnabled,
+        hiddenColumnKeys,
+        isColumnVisible,
+        setColumnVisible,
+        toggleColumnVisible,
+        setHiddenColumnKeys,
+        resetHiddenColumns,
+    };
+}

package/dist/composables/selection/selectionControllerStateScheduler.d.ts

@@ -0,0 +1,13 @@
+export interface SelectionControllerStateSchedulerEnvironment<State> {
+    applyState: (state: State) => void;
+    requestFrame: (callback: () => void) => number | ReturnType<typeof setTimeout>;
+    cancelFrame: (handle: number | ReturnType<typeof setTimeout>) => void;
+    scheduleNextTick: (callback: () => void) => void;
+}
+export interface SelectionControllerStateScheduler<State> {
+    schedule(state: State): void;
+    flush(): void;
+    cancel(): void;
+}
+export declare function createSelectionControllerStateScheduler<State>(environment: SelectionControllerStateSchedulerEnvironment<State>): SelectionControllerStateScheduler<State>;
+//# sourceMappingURL=selectionControllerStateScheduler.d.ts.map

package/dist/composables/selection/selectionControllerStateScheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectionControllerStateScheduler.d.ts","sourceRoot":"","sources":["../../../src/composables/selection/selectionControllerStateScheduler.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,4CAA4C,CAAC,KAAK;IACjE,UAAU,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;IAClC,YAAY,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,CAAA;IAC9E,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,KAAK,IAAI,CAAA;IACrE,gBAAgB,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,CAAA;CACjD;AAED,MAAM,WAAW,iCAAiC,CAAC,KAAK;IACtD,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;IAC5B,KAAK,IAAI,IAAI,CAAA;IACb,MAAM,IAAI,IAAI,CAAA;CACf;AAED,wBAAgB,uCAAuC,CAAC,KAAK,EAC3D,WAAW,EAAE,4CAA4C,CAAC,KAAK,CAAC,GAC/D,iCAAiC,CAAC,KAAK,CAAC,CAsD1C"}

package/dist/composables/selection/selectionControllerStateScheduler.js

@@ -0,0 +1,48 @@
+export function createSelectionControllerStateScheduler(environment) {
+    let pendingState = null;
+    let frameHandle = null;
+    let nextTickPending = false;
+    const flush = () => {
+        if (pendingState === null) {
+            return;
+        }
+        const stateToApply = pendingState;
+        pendingState = null;
+        environment.applyState(stateToApply);
+    };
+    const queueNextTick = () => {
+        if (nextTickPending) {
+            return;
+        }
+        nextTickPending = true;
+        environment.scheduleNextTick(() => {
+            nextTickPending = false;
+            flush();
+        });
+    };
+    const schedule = (state) => {
+        pendingState = state;
+        if (frameHandle !== null) {
+            queueNextTick();
+            return;
+        }
+        frameHandle = environment.requestFrame(() => {
+            frameHandle = null;
+            flush();
+        });
+        queueNextTick();
+    };
+    const cancel = () => {
+        if (frameHandle !== null) {
+            environment.cancelFrame(frameHandle);
+            frameHandle = null;
+        }
+        pendingState = null;
+        nextTickPending = false;
+    };
+    return {
+        schedule,
+        flush,
+        cancel,
+    };
+}

package/dist/composables/selection/selectionGeometry.d.ts

@@ -0,0 +1,47 @@
+export interface SelectionGeometryPoint<RowKey = unknown> {
+    rowIndex: number;
+    colIndex: number;
+    rowId?: RowKey | null;
+}
+export interface SelectionGeometryRange<RowKey = unknown> {
+    startRow: number;
+    endRow: number;
+    startCol: number;
+    endCol: number;
+    anchor: SelectionGeometryPoint<RowKey>;
+    focus: SelectionGeometryPoint<RowKey>;
+}
+export interface SelectionGeometryArea {
+    startRow: number;
+    endRow: number;
+    startCol: number;
+    endCol: number;
+}
+export interface SelectionOverlaySignature {
+    ranges: string;
+    active: string;
+    fill: string;
+    cut: string;
+}
+export declare function clampNumber(value: number, min: number, max: number): number;
+export declare function serializeSelectionRange<RowKey = unknown>(range: SelectionGeometryRange<RowKey>): string;
+export declare function serializeSelectionRanges<RowKey = unknown>(ranges: readonly SelectionGeometryRange<RowKey>[]): string;
+export declare function serializeSelectionArea(area: SelectionGeometryArea | null): string;
+export declare function serializeSelectionAreas(areas: readonly SelectionGeometryArea[]): string;
+export declare function buildSelectionOverlaySignature<RowKey = unknown>(input: {
+    ranges: readonly SelectionGeometryRange<RowKey>[];
+    activeRangeIndex: number;
+    fillPreview: SelectionGeometryArea | null;
+    cutPreviewAreas: readonly SelectionGeometryArea[];
+}): SelectionOverlaySignature;
+export declare function detectFullColumnSelectionIndex<RowKey = unknown>(ranges: readonly SelectionGeometryRange<RowKey>[], grid: {
+    rowCount: number;
+    colCount: number;
+}): number | null;
+export declare function createSelectionCellKey(rowIndex: number, columnIndex: number): string;
+export declare const ROW_HEADER_CLASS_NONE = "";
+export declare const ROW_HEADER_CLASS_FULL = "ui-table__row-index--full";
+export declare const ROW_HEADER_CLASS_HIGHLIGHT = "ui-table__row-index--highlight";
+export declare const ROW_HEADER_CLASS_RANGE = "ui-table__row-index--range";
+export declare function resolveRowHeaderClassValue(isFull: boolean, isHighlighted: boolean, inSelection: boolean): string;
+//# sourceMappingURL=selectionGeometry.d.ts.map

package/dist/composables/selection/selectionGeometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectionGeometry.d.ts","sourceRoot":"","sources":["../../../src/composables/selection/selectionGeometry.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,sBAAsB,CAAC,MAAM,GAAG,OAAO;IACtD,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CACtB;AAED,MAAM,WAAW,sBAAsB,CAAC,MAAM,GAAG,OAAO;IACtD,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,sBAAsB,CAAC,MAAM,CAAC,CAAA;IACtC,KAAK,EAAE,sBAAsB,CAAC,MAAM,CAAC,CAAA;CACtC;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,yBAAyB;IACxC,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;CACZ;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAO3E;AAED,wBAAgB,uBAAuB,CAAC,MAAM,GAAG,OAAO,EAAE,KAAK,EAAE,sBAAsB,CAAC,MAAM,CAAC,GAAG,MAAM,CAWvG;AAED,wBAAgB,wBAAwB,CAAC,MAAM,GAAG,OAAO,EAAE,MAAM,EAAE,SAAS,sBAAsB,CAAC,MAAM,CAAC,EAAE,GAAG,MAAM,CAGpH;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,qBAAqB,GAAG,IAAI,GAAG,MAAM,CAGjF;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,SAAS,qBAAqB,EAAE,GAAG,MAAM,CAGvF;AAED,wBAAgB,8BAA8B,CAAC,MAAM,GAAG,OAAO,EAAE,KAAK,EAAE;IACtE,MAAM,EAAE,SAAS,sBAAsB,CAAC,MAAM,CAAC,EAAE,CAAA;IACjD,gBAAgB,EAAE,MAAM,CAAA;IACxB,WAAW,EAAE,qBAAqB,GAAG,IAAI,CAAA;IACzC,eAAe,EAAE,SAAS,qBAAqB,EAAE,CAAA;CAClD,GAAG,yBAAyB,CAc5B;AAED,wBAAgB,8BAA8B,CAAC,MAAM,GAAG,OAAO,EAC7D,MAAM,EAAE,SAAS,sBAAsB,CAAC,MAAM,CAAC,EAAE,EACjD,IAAI,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAC3C,MAAM,GAAG,IAAI,CAWf;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAEpF;AAED,eAAO,MAAM,qBAAqB,KAAK,CAAA;AACvC,eAAO,MAAM,qBAAqB,8BAA8B,CAAA;AAChE,eAAO,MAAM,0BAA0B,mCAAmC,CAAA;AAC1E,eAAO,MAAM,sBAAsB,+BAA+B,CAAA;AAElE,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,GAAG,MAAM,CAKhH"}

package/dist/composables/selection/selectionGeometry.js

@@ -0,0 +1,84 @@
+export function clampNumber(value, min, max) {
+    if (!Number.isFinite(value)) {
+        return min;
+    }
+    if (value < min)
+        return min;
+    if (value > max)
+        return max;
+    return value;
+}
+export function serializeSelectionRange(range) {
+    return [
+        range.startRow,
+        range.endRow,
+        range.startCol,
+        range.endCol,
+        range.anchor.rowIndex,
+        range.anchor.colIndex,
+        range.focus.rowIndex,
+        range.focus.colIndex,
+    ].join(":");
+}
+export function serializeSelectionRanges(ranges) {
+    if (!ranges.length)
+        return "";
+    return ranges.map(serializeSelectionRange).join("|");
+}
+export function serializeSelectionArea(area) {
+    if (!area)
+        return "";
+    return [area.startRow, area.endRow, area.startCol, area.endCol].join(":");
+}
+export function serializeSelectionAreas(areas) {
+    if (!areas.length)
+        return "";
+    return areas.map(serializeSelectionArea).join("|");
+}
+export function buildSelectionOverlaySignature(input) {
+    const { ranges, fillPreview, cutPreviewAreas } = input;
+    const activeRangeIndexRaw = input.activeRangeIndex;
+    const hasActive = ranges.length > 0 && activeRangeIndexRaw >= 0 && activeRangeIndexRaw < ranges.length;
+    const activeRangeIndex = hasActive ? clampNumber(activeRangeIndexRaw, 0, ranges.length - 1) : -1;
+    const activeRange = hasActive ? ranges[activeRangeIndex] ?? null : null;
+    const staticRanges = hasActive ? ranges.filter((_, index) => index !== activeRangeIndex) : ranges;
+    return {
+        ranges: serializeSelectionRanges(staticRanges),
+        active: activeRange ? serializeSelectionRange(activeRange) : "",
+        fill: serializeSelectionArea(fillPreview),
+        cut: serializeSelectionAreas(cutPreviewAreas),
+    };
+}
+export function detectFullColumnSelectionIndex(ranges, grid) {
+    const rowCount = Math.max(grid.rowCount, 0);
+    const colCount = Math.max(grid.colCount, 0);
+    if (rowCount === 0 || colCount === 0)
+        return null;
+    if (ranges.length !== 1)
+        return null;
+    const [range] = ranges;
+    if (range.startCol !== range.endCol)
+        return null;
+    if (range.startRow !== 0)
+        return null;
+    const expectedEndRow = Math.max(rowCount - 1, 0);
+    if (range.endRow !== expectedEndRow)
+        return null;
+    return clampNumber(range.startCol, 0, colCount - 1);
+}
+export function createSelectionCellKey(rowIndex, columnIndex) {
+    return `${rowIndex}:${columnIndex}`;
+}
+export const ROW_HEADER_CLASS_NONE = "";
+export const ROW_HEADER_CLASS_FULL = "ui-table__row-index--full";
+export const ROW_HEADER_CLASS_HIGHLIGHT = "ui-table__row-index--highlight";
+export const ROW_HEADER_CLASS_RANGE = "ui-table__row-index--range";
+export function resolveRowHeaderClassValue(isFull, isHighlighted, inSelection) {
+    if (isFull)
+        return ROW_HEADER_CLASS_FULL;
+    if (isHighlighted)
+        return ROW_HEADER_CLASS_HIGHLIGHT;
+    if (inSelection)
+        return ROW_HEADER_CLASS_RANGE;
+    return ROW_HEADER_CLASS_NONE;
+}

package/dist/composables/selection/selectionInput.d.ts

@@ -0,0 +1,6 @@
+export interface SelectionPointerCoordinates {
+    clientX: number;
+    clientY: number;
+}
+export declare function toSelectionPointerCoordinates(event: Pick<MouseEvent, "clientX" | "clientY">): SelectionPointerCoordinates;
+//# sourceMappingURL=selectionInput.d.ts.map

package/dist/composables/selection/selectionInput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectionInput.d.ts","sourceRoot":"","sources":["../../../src/composables/selection/selectionInput.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,2BAA2B;IAC1C,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,EAAE,SAAS,GAAG,SAAS,CAAC,GAAG,2BAA2B,CAKzH"}

package/dist/composables/selection/selectionInput.js

@@ -0,0 +1,6 @@
+export function toSelectionPointerCoordinates(event) {
+    return {
+        clientX: event.clientX,
+        clientY: event.clientY,
+    };
+}

package/dist/composables/selection/selectionOverlayUpdateScheduler.d.ts

@@ -0,0 +1,21 @@
+export type OverlayUpdatePriority = "user-blocking" | "background";
+export type OverlayScheduleMode = "frame" | "idle";
+export interface SelectionOverlayUpdateSchedulerEnvironment {
+    request: (callback: () => void, options?: {
+        mode?: "frame" | "idle";
+        timeout?: number;
+    }) => number;
+    cancel: (handle: number) => void;
+    flush: () => void;
+    queueMicrotask?: (callback: () => void) => void;
+    backgroundTimeout?: number;
+}
+export interface SelectionOverlayUpdateScheduler {
+    schedule(options?: {
+        priority?: OverlayUpdatePriority;
+        timeout?: number;
+    }): void;
+    cancel(): void;
+}
+export declare function createSelectionOverlayUpdateScheduler(environment: SelectionOverlayUpdateSchedulerEnvironment): SelectionOverlayUpdateScheduler;
+//# sourceMappingURL=selectionOverlayUpdateScheduler.d.ts.map

package/dist/composables/selection/selectionOverlayUpdateScheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectionOverlayUpdateScheduler.d.ts","sourceRoot":"","sources":["../../../src/composables/selection/selectionOverlayUpdateScheduler.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,qBAAqB,GAAG,eAAe,GAAG,YAAY,CAAA;AAClE,MAAM,MAAM,mBAAmB,GAAG,OAAO,GAAG,MAAM,CAAA;AAElD,MAAM,WAAW,0CAA0C;IACzD,OAAO,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,OAAO,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,MAAM,CAAA;IAClG,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IAChC,KAAK,EAAE,MAAM,IAAI,CAAA;IACjB,cAAc,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,CAAA;IAC/C,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAC3B;AAED,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,CAAC,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,qBAAqB,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;IAChF,MAAM,IAAI,IAAI,CAAA;CACf;AAYD,wBAAgB,qCAAqC,CACnD,WAAW,EAAE,0CAA0C,GACtD,+BAA+B,CA+DjC"}

package/dist/composables/selection/selectionOverlayUpdateScheduler.js

@@ -0,0 +1,65 @@
+const OVERLAY_MICROTASK_HANDLE = -1;
+const defaultQueueMicrotask = (callback) => {
+    if (typeof globalThis.queueMicrotask === "function") {
+        globalThis.queueMicrotask(callback);
+        return;
+    }
+    void Promise.resolve().then(callback);
+};
+export function createSelectionOverlayUpdateScheduler(environment) {
+    const queueMicrotask = environment.queueMicrotask ?? defaultQueueMicrotask;
+    const backgroundTimeout = environment.backgroundTimeout ?? 160;
+    let handle = null;
+    let mode = null;
+    let microtaskScheduled = false;
+    const runFlush = () => {
+        if (!microtaskScheduled) {
+            return;
+        }
+        microtaskScheduled = false;
+        handle = null;
+        mode = null;
+        environment.flush();
+    };
+    const cancel = () => {
+        if (handle === null) {
+            return;
+        }
+        if (handle === OVERLAY_MICROTASK_HANDLE) {
+            microtaskScheduled = false;
+        }
+        else {
+            environment.cancel(handle);
+        }
+        handle = null;
+        mode = null;
+    };
+    const schedule = (options) => {
+        const priority = options?.priority ?? "user-blocking";
+        const nextMode = priority === "background" ? "idle" : "frame";
+        const timeout = options?.timeout ?? backgroundTimeout;
+        if (handle !== null) {
+            if (mode === nextMode) {
+                return;
+            }
+            cancel();
+        }
+        if (nextMode === "frame") {
+            mode = nextMode;
+            handle = OVERLAY_MICROTASK_HANDLE;
+            microtaskScheduled = true;
+            queueMicrotask(runFlush);
+            return;
+        }
+        mode = nextMode;
+        handle = environment.request(() => {
+            handle = null;
+            mode = null;
+            environment.flush();
+        }, { mode: "idle", timeout });
+    };
+    return {
+        schedule,
+        cancel,
+    };
+}