@affino/datagrid-vue-app 0.1.1 → 0.1.2

package/dist/host/DataGridModuleHost.js

@@ -1,23 +0,0 @@
-import { defineComponent, h } from "vue";
-export default defineComponent({
-    name: "DataGridModuleHost",
-    props: {
-        modules: {
-            type: Array,
-            default: () => [],
-        },
-    },
-    setup(props) {
-        return () => {
-            if (props.modules.length === 0) {
-                return null;
-            }
-            return h("div", { class: "datagrid-app-toolbar" }, [
-                h("div", { class: "datagrid-app-toolbar__group" }, props.modules.map(module => (h(module.component, {
-                    key: module.key,
-                    ...(module.props ?? {}),
-                })))),
-            ]);
-        };
-    },
-});

package/dist/host/DataGridRuntimeHost.js

@@ -1,174 +0,0 @@
-import { computed, defineComponent, h, mergeProps, onBeforeUnmount, provide, ref, watch, } from "vue";
-import { useDataGridRuntime } from "@affino/datagrid-vue";
-import { applyDataGridTheme, } from "../theme/dataGridTheme";
-import { dataGridAppRootElementKey } from "../dataGridAppContext";
-export default defineComponent({
-    name: "DataGridRuntimeHost",
-    inheritAttrs: false,
-    props: {
-        rows: {
-            type: Array,
-            default: () => [],
-        },
-        rowModel: {
-            type: Object,
-            default: undefined,
-        },
-        columns: {
-            type: Array,
-            default: () => [],
-        },
-        theme: {
-            type: [String, Object],
-            default: undefined,
-        },
-        plugins: {
-            type: Array,
-            default: () => [],
-        },
-        services: {
-            type: Object,
-            default: undefined,
-        },
-        startupOrder: {
-            type: Array,
-            default: undefined,
-        },
-        autoStart: {
-            type: Boolean,
-            default: true,
-        },
-        renderMode: {
-            type: String,
-            default: "virtualization",
-        },
-        pagination: {
-            type: Object,
-            default: null,
-        },
-    },
-    emits: ["cell-change", "selection-change"],
-    setup(props, { attrs, slots, emit, expose }) {
-        const rootElementRef = ref(null);
-        provide(dataGridAppRootElementKey, rootElementRef);
-        let themeObserver = null;
-        const runtime = useDataGridRuntime({
-            rows: computed(() => props.rows),
-            rowModel: props.rowModel,
-            columns: computed(() => props.columns),
-            plugins: props.plugins,
-            services: props.services,
-            startupOrder: props.startupOrder,
-            autoStart: props.autoStart,
-        });
-        const bodyRuntime = runtime;
-        const publicRuntime = {
-            api: runtime.api,
-            syncBodyRowsInRange: runtime.syncBodyRowsInRange,
-            rowPartition: runtime.rowPartition,
-            virtualWindow: runtime.virtualWindow,
-            columnSnapshot: runtime.columnSnapshot,
-            getBodyRowAtIndex: bodyRuntime.getBodyRowAtIndex,
-            resolveBodyRowIndexById: bodyRuntime.resolveBodyRowIndexById,
-        };
-        const syncPaginationState = () => {
-            if (props.renderMode === "pagination") {
-                const pagination = props.pagination ?? { pageSize: 100, currentPage: 0 };
-                runtime.api.rows.setPagination({
-                    pageSize: Math.max(1, Math.trunc(pagination.pageSize)),
-                    currentPage: Math.max(0, Math.trunc(pagination.currentPage)),
-                });
-                return;
-            }
-            runtime.api.rows.setPagination(null);
-        };
-        watch(() => props.renderMode, () => {
-            syncPaginationState();
-        }, { immediate: true });
-        watch(() => props.pagination, () => {
-            syncPaginationState();
-        }, { immediate: true, deep: true });
-        if (typeof document !== "undefined") {
-            themeObserver = new MutationObserver(() => {
-                const rootElement = rootElementRef.value;
-                if (!rootElement) {
-                    return;
-                }
-                applyDataGridTheme(rootElement, props.theme);
-            });
-            themeObserver.observe(document.documentElement, {
-                attributes: true,
-                attributeFilter: ["class", "data-theme"],
-            });
-        }
-        watch([() => props.theme, rootElementRef], () => {
-            const rootElement = rootElementRef.value;
-            if (!rootElement) {
-                return;
-            }
-            applyDataGridTheme(rootElement, props.theme);
-        }, { immediate: true, deep: true });
-        const unsubscribeRowsChanged = runtime.api.events.on("rows:changed", payload => {
-            emit("cell-change", payload);
-        });
-        const unsubscribeSelectionChanged = runtime.api.events.on("selection:changed", payload => {
-            emit("selection-change", payload);
-        });
-        onBeforeUnmount(() => {
-            unsubscribeRowsChanged();
-            unsubscribeSelectionChanged();
-            themeObserver?.disconnect();
-            themeObserver = null;
-        });
-        const slotVirtualWindow = computed(() => {
-            const window = runtime.virtualWindow.value;
-            return {
-                ...(window ?? {}),
-                rowTotal: window?.rowTotal ?? runtime.rowPartition.value.bodyRowCount,
-                colTotal: runtime.columnSnapshot.value.visibleColumns.length,
-            };
-        });
-        expose({
-            api: runtime.api,
-            core: runtime.core,
-            runtime: publicRuntime,
-            rowModel: runtime.rowModel,
-            columnModel: runtime.columnModel,
-            columnSnapshot: runtime.columnSnapshot,
-            rowPartition: runtime.rowPartition,
-            setRows: runtime.setRows,
-            syncBodyRowsInRange: runtime.syncBodyRowsInRange,
-            getBodyRowAtIndex: bodyRuntime.getBodyRowAtIndex,
-            resolveBodyRowIndexById: bodyRuntime.resolveBodyRowIndexById,
-            virtualWindow: runtime.virtualWindow,
-            start: runtime.start,
-            stop: runtime.stop,
-        });
-        return () => h("div", mergeProps(attrs, {
-            ref: rootElementRef,
-            class: "affino-datagrid-app-root",
-            style: {
-                display: "flex",
-                flex: "1 1 auto",
-                width: "100%",
-                height: "100%",
-                minHeight: "0",
-                minWidth: "0",
-            },
-        }), slots.default?.({
-            api: runtime.api,
-            core: runtime.core,
-            runtime: publicRuntime,
-            grid: publicRuntime,
-            rowModel: runtime.rowModel,
-            columnModel: runtime.columnModel,
-            columnSnapshot: runtime.columnSnapshot.value,
-            rowPartition: runtime.rowPartition.value,
-            setRows: runtime.setRows,
-            syncBodyRowsInRange: runtime.syncBodyRowsInRange,
-            getBodyRowAtIndex: bodyRuntime.getBodyRowAtIndex,
-            resolveBodyRowIndexById: bodyRuntime.resolveBodyRowIndexById,
-            virtualWindow: slotVirtualWindow.value,
-        }) ?? []);
-    },
-});

package/dist/overlays/dataGridCellComboboxState.js

@@ -1,67 +0,0 @@
-export function createDataGridCellComboboxState(initial = {}) {
-    return {
-        open: initial.open ?? false,
-        filter: initial.filter ?? "",
-        activeIndex: initial.activeIndex ?? -1,
-    };
-}
-export function setDataGridCellComboboxOpen(state, open) {
-    if (state.open === open) {
-        return state;
-    }
-    return {
-        ...state,
-        open,
-    };
-}
-export function setDataGridCellComboboxFilter(state, filter) {
-    if (state.filter === filter) {
-        return state;
-    }
-    return {
-        ...state,
-        filter,
-    };
-}
-export function activateDataGridCellComboboxIndex(state, index, optionCount) {
-    const nextIndex = clampIndex(index, optionCount);
-    if (nextIndex === state.activeIndex) {
-        return state;
-    }
-    return {
-        ...state,
-        activeIndex: nextIndex,
-    };
-}
-export function moveDataGridCellComboboxFocus(state, delta, optionCount, loop = true) {
-    if (optionCount <= 0 || delta === 0) {
-        return state;
-    }
-    if (state.activeIndex < 0) {
-        return activateDataGridCellComboboxIndex(state, delta > 0 ? 0 : optionCount - 1, optionCount);
-    }
-    const rawTarget = state.activeIndex + Math.trunc(delta);
-    if (loop) {
-        return activateDataGridCellComboboxIndex(state, modulo(rawTarget, optionCount), optionCount);
-    }
-    return activateDataGridCellComboboxIndex(state, rawTarget, optionCount);
-}
-function clampIndex(index, optionCount) {
-    if (optionCount <= 0) {
-        return -1;
-    }
-    if (!Number.isFinite(index)) {
-        return 0;
-    }
-    const normalized = Math.trunc(index);
-    if (normalized < 0) {
-        return 0;
-    }
-    if (normalized >= optionCount) {
-        return optionCount - 1;
-    }
-    return normalized;
-}
-function modulo(value, divisor) {
-    return ((value % divisor) + divisor) % divisor;
-}

package/dist/overlays/dataGridColumnMenu.js

@@ -1,190 +0,0 @@
-export const DATAGRID_COLUMN_MENU_ITEM_KEYS = ["sort", "group", "pin", "filter"];
-export const DATAGRID_COLUMN_MENU_ACTION_KEYS = [
-    "sortAsc",
-    "sortDesc",
-    "clearSort",
-    "toggleGroup",
-    "pinMenu",
-    "pinLeft",
-    "pinRight",
-    "unpin",
-    "clearFilter",
-    "addCurrentSelectionToFilter",
-    "selectAllValues",
-    "clearAllValues",
-    "applyFilter",
-    "cancelFilter",
-];
-const DEFAULT_MAX_FILTER_VALUES = 120;
-function normalizeItems(input) {
-    const allowed = new Set(DATAGRID_COLUMN_MENU_ITEM_KEYS);
-    const source = Array.isArray(input) ? input : DATAGRID_COLUMN_MENU_ITEM_KEYS;
-    const normalized = [];
-    for (const item of source) {
-        if (!allowed.has(item) || normalized.includes(item)) {
-            continue;
-        }
-        normalized.push(item);
-    }
-    return normalized.length > 0 ? normalized : [...DATAGRID_COLUMN_MENU_ITEM_KEYS];
-}
-function normalizeItemSubset(input) {
-    if (!Array.isArray(input)) {
-        return [];
-    }
-    const allowed = new Set(DATAGRID_COLUMN_MENU_ITEM_KEYS);
-    const normalized = [];
-    for (const item of input) {
-        if (!allowed.has(item) || normalized.includes(item)) {
-            continue;
-        }
-        normalized.push(item);
-    }
-    return normalized;
-}
-function normalizeLabels(input) {
-    if (!input) {
-        return Object.freeze({});
-    }
-    const entries = Object.entries(input)
-        .filter(([key, value]) => DATAGRID_COLUMN_MENU_ITEM_KEYS.includes(key) && typeof value === "string")
-        .map(([key, value]) => [key, value.trim()])
-        .filter(([, value]) => value.length > 0);
-    return Object.freeze(Object.fromEntries(entries));
-}
-function normalizeDisabledReasons(input) {
-    if (!input) {
-        return Object.freeze({});
-    }
-    const entries = Object.entries(input)
-        .filter(([key, value]) => DATAGRID_COLUMN_MENU_ITEM_KEYS.includes(key) && typeof value === "string")
-        .map(([key, value]) => [key, value.trim()])
-        .filter(([, value]) => value.length > 0);
-    return Object.freeze(Object.fromEntries(entries));
-}
-function normalizeActionOptions(input) {
-    if (!input) {
-        return Object.freeze({});
-    }
-    const entries = Object.entries(input)
-        .filter(([key, value]) => DATAGRID_COLUMN_MENU_ACTION_KEYS.includes(key) && Boolean(value))
-        .map(([key, value]) => {
-        const option = value;
-        const normalized = {
-            ...(option.hidden === true ? { hidden: true } : {}),
-            ...(option.disabled === true ? { disabled: true } : {}),
-            ...(typeof option.disabledReason === "string" && option.disabledReason.trim().length > 0
-                ? { disabledReason: option.disabledReason.trim() }
-                : {}),
-            ...(typeof option.label === "string" && option.label.trim().length > 0
-                ? { label: option.label.trim() }
-                : {}),
-        };
-        return [key, Object.freeze(normalized)];
-    })
-        .filter(([, value]) => Object.keys(value).length > 0);
-    return Object.freeze(Object.fromEntries(entries));
-}
-function normalizeColumns(input) {
-    if (!input) {
-        return {};
-    }
-    const normalizedEntries = Object.entries(input)
-        .filter(([key]) => key.trim().length > 0)
-        .map(([key, value]) => {
-        const items = value?.items ? normalizeItems(value.items) : undefined;
-        const hide = normalizeItemSubset(value?.hide);
-        const disabled = normalizeItemSubset(value?.disabled);
-        const disabledReasons = normalizeDisabledReasons(value?.disabledReasons);
-        const labels = normalizeLabels(value?.labels);
-        const actions = normalizeActionOptions(value?.actions);
-        return [
-            key,
-            {
-                ...(items ? { items } : {}),
-                ...(hide.length > 0 ? { hide } : {}),
-                ...(disabled.length > 0 ? { disabled } : {}),
-                ...(Object.keys(disabledReasons).length > 0 ? { disabledReasons } : {}),
-                ...(Object.keys(labels).length > 0 ? { labels } : {}),
-                ...(Object.keys(actions).length > 0 ? { actions } : {}),
-            },
-        ];
-    });
-    return Object.fromEntries(normalizedEntries);
-}
-export function resolveDataGridColumnMenu(input) {
-    if (typeof input === "boolean") {
-        return {
-            enabled: input,
-            maxFilterValues: DEFAULT_MAX_FILTER_VALUES,
-            items: [...DATAGRID_COLUMN_MENU_ITEM_KEYS],
-            disabled: [],
-            disabledReasons: Object.freeze({}),
-            labels: Object.freeze({}),
-            actions: Object.freeze({}),
-            columns: {},
-        };
-    }
-    if (!input) {
-        return {
-            enabled: false,
-            maxFilterValues: DEFAULT_MAX_FILTER_VALUES,
-            items: [...DATAGRID_COLUMN_MENU_ITEM_KEYS],
-            disabled: [],
-            disabledReasons: Object.freeze({}),
-            labels: Object.freeze({}),
-            actions: Object.freeze({}),
-            columns: {},
-        };
-    }
-    return {
-        enabled: input.enabled ?? true,
-        maxFilterValues: Number.isFinite(input.maxFilterValues)
-            ? Math.max(20, Math.trunc(input.maxFilterValues))
-            : DEFAULT_MAX_FILTER_VALUES,
-        items: normalizeItems(input.items),
-        disabled: normalizeItemSubset(input.disabled),
-        disabledReasons: normalizeDisabledReasons(input.disabledReasons),
-        labels: normalizeLabels(input.labels),
-        actions: normalizeActionOptions(input.actions),
-        columns: normalizeColumns(input.columns),
-    };
-}
-export function resolveDataGridColumnMenuItems(options, columnKey) {
-    const columnOptions = options.columns[columnKey];
-    const baseItems = columnOptions?.items ? normalizeItems(columnOptions.items) : options.items;
-    const hidden = new Set(columnOptions?.hide ?? []);
-    const filtered = baseItems.filter(item => !hidden.has(item));
-    return filtered.length > 0 ? filtered : [];
-}
-export function resolveDataGridColumnMenuDisabledItems(options, columnKey) {
-    const visibleItems = resolveDataGridColumnMenuItems(options, columnKey);
-    const columnDisabled = new Set(options.columns[columnKey]?.disabled ?? []);
-    const globallyDisabled = new Set(options.disabled);
-    return visibleItems.filter(item => globallyDisabled.has(item) || columnDisabled.has(item));
-}
-export function resolveDataGridColumnMenuLabels(options, columnKey) {
-    return Object.freeze({
-        ...options.labels,
-        ...(options.columns[columnKey]?.labels ?? {}),
-    });
-}
-export function resolveDataGridColumnMenuDisabledReasons(options, columnKey) {
-    return Object.freeze({
-        ...options.disabledReasons,
-        ...(options.columns[columnKey]?.disabledReasons ?? {}),
-    });
-}
-export function resolveDataGridColumnMenuActionOptions(options, columnKey) {
-    const columnActions = options.columns[columnKey]?.actions ?? {};
-    const entries = DATAGRID_COLUMN_MENU_ACTION_KEYS
-        .map(actionKey => {
-        const merged = {
-            ...(options.actions[actionKey] ?? {}),
-            ...(columnActions[actionKey] ?? {}),
-        };
-        return [actionKey, Object.freeze(merged)];
-    })
-        .filter(([, value]) => Object.keys(value).length > 0);
-    return Object.freeze(Object.fromEntries(entries));
-}

package/dist/overlays/dataGridContextMenu.js

@@ -1,218 +0,0 @@
-export const DATAGRID_CELL_MENU_ITEM_KEYS = ["clipboard", "edit"];
-export const DATAGRID_CELL_MENU_ACTION_KEYS = ["cut", "copy", "paste", "clear"];
-export const DATAGRID_ROW_INDEX_MENU_ITEM_KEYS = ["insert", "clipboard", "selection"];
-export const DATAGRID_ROW_INDEX_MENU_ACTION_KEYS = [
-    "insertAbove",
-    "insertBelow",
-    "cut",
-    "copy",
-    "paste",
-    "deleteSelected",
-];
-function normalizeItems(input, allowedKeys) {
-    const allowed = new Set(allowedKeys);
-    const source = Array.isArray(input) ? input : allowedKeys;
-    const normalized = [];
-    for (const item of source) {
-        if (!allowed.has(item) || normalized.includes(item)) {
-            continue;
-        }
-        normalized.push(item);
-    }
-    return normalized.length > 0 ? normalized : [...allowedKeys];
-}
-function normalizeItemSubset(input, allowedKeys) {
-    if (!Array.isArray(input)) {
-        return [];
-    }
-    const allowed = new Set(allowedKeys);
-    const normalized = [];
-    for (const item of input) {
-        if (!allowed.has(item) || normalized.includes(item)) {
-            continue;
-        }
-        normalized.push(item);
-    }
-    return normalized;
-}
-function normalizeLabels(input, allowedKeys) {
-    if (!input) {
-        return Object.freeze({});
-    }
-    const entries = Object.entries(input)
-        .filter((entry) => allowedKeys.includes(entry[0]) && typeof entry[1] === "string")
-        .map(([key, value]) => [key, value.trim()])
-        .filter(([, value]) => value.length > 0);
-    return Object.freeze(Object.fromEntries(entries));
-}
-function normalizeActionOptions(input, allowedKeys) {
-    if (!input) {
-        return Object.freeze({});
-    }
-    const entries = Object.entries(input)
-        .filter(([key, value]) => allowedKeys.includes(key) && Boolean(value))
-        .map(([key, value]) => {
-        const option = value;
-        const normalized = {
-            ...(option.hidden === true ? { hidden: true } : {}),
-            ...(option.disabled === true ? { disabled: true } : {}),
-            ...(typeof option.disabledReason === "string" && option.disabledReason.trim().length > 0
-                ? { disabledReason: option.disabledReason.trim() }
-                : {}),
-            ...(typeof option.label === "string" && option.label.trim().length > 0
-                ? { label: option.label.trim() }
-                : {}),
-        };
-        return [key, Object.freeze(normalized)];
-    })
-        .filter(([, value]) => Object.keys(value).length > 0);
-    return Object.freeze(Object.fromEntries(entries));
-}
-function normalizeCellColumns(input) {
-    if (!input) {
-        return {};
-    }
-    const normalizedEntries = Object.entries(input)
-        .filter(([key]) => key.trim().length > 0)
-        .map(([key, value]) => {
-        const items = value?.items ? normalizeItems(value.items, DATAGRID_CELL_MENU_ITEM_KEYS) : undefined;
-        const hide = normalizeItemSubset(value?.hide, DATAGRID_CELL_MENU_ITEM_KEYS);
-        const disabled = normalizeItemSubset(value?.disabled, DATAGRID_CELL_MENU_ITEM_KEYS);
-        const disabledReasons = normalizeLabels(value?.disabledReasons, DATAGRID_CELL_MENU_ITEM_KEYS);
-        const labels = normalizeLabels(value?.labels, DATAGRID_CELL_MENU_ITEM_KEYS);
-        const actions = normalizeActionOptions(value?.actions, DATAGRID_CELL_MENU_ACTION_KEYS);
-        return [
-            key,
-            {
-                ...(items ? { items } : {}),
-                ...(hide.length > 0 ? { hide } : {}),
-                ...(disabled.length > 0 ? { disabled } : {}),
-                ...(Object.keys(disabledReasons).length > 0 ? { disabledReasons } : {}),
-                ...(Object.keys(labels).length > 0 ? { labels } : {}),
-                ...(Object.keys(actions).length > 0 ? { actions } : {}),
-            },
-        ];
-    });
-    return Object.freeze(Object.fromEntries(normalizedEntries));
-}
-export function resolveDataGridCellMenu(input) {
-    if (typeof input === "boolean") {
-        return {
-            enabled: input,
-            items: [...DATAGRID_CELL_MENU_ITEM_KEYS],
-            disabled: [],
-            disabledReasons: Object.freeze({}),
-            labels: Object.freeze({}),
-            actions: Object.freeze({}),
-            columns: {},
-        };
-    }
-    if (!input) {
-        return {
-            enabled: false,
-            items: [...DATAGRID_CELL_MENU_ITEM_KEYS],
-            disabled: [],
-            disabledReasons: Object.freeze({}),
-            labels: Object.freeze({}),
-            actions: Object.freeze({}),
-            columns: {},
-        };
-    }
-    return {
-        enabled: input.enabled ?? true,
-        items: normalizeItems(input.items, DATAGRID_CELL_MENU_ITEM_KEYS),
-        disabled: normalizeItemSubset(input.disabled, DATAGRID_CELL_MENU_ITEM_KEYS),
-        disabledReasons: normalizeLabels(input.disabledReasons, DATAGRID_CELL_MENU_ITEM_KEYS),
-        labels: normalizeLabels(input.labels, DATAGRID_CELL_MENU_ITEM_KEYS),
-        actions: normalizeActionOptions(input.actions, DATAGRID_CELL_MENU_ACTION_KEYS),
-        columns: normalizeCellColumns(input.columns),
-    };
-}
-export function resolveDataGridCellMenuItems(options, columnKey) {
-    const columnOptions = options.columns[columnKey];
-    const baseItems = columnOptions?.items
-        ? normalizeItems(columnOptions.items, DATAGRID_CELL_MENU_ITEM_KEYS)
-        : options.items;
-    const hidden = new Set(columnOptions?.hide ?? []);
-    const filtered = baseItems.filter(item => !hidden.has(item));
-    return filtered.length > 0 ? filtered : [];
-}
-export function resolveDataGridCellMenuDisabledItems(options, columnKey) {
-    const visibleItems = resolveDataGridCellMenuItems(options, columnKey);
-    const columnDisabled = new Set(options.columns[columnKey]?.disabled ?? []);
-    const globallyDisabled = new Set(options.disabled);
-    return visibleItems.filter(item => globallyDisabled.has(item) || columnDisabled.has(item));
-}
-export function resolveDataGridCellMenuLabels(options, columnKey) {
-    return Object.freeze({
-        ...options.labels,
-        ...(options.columns[columnKey]?.labels ?? {}),
-    });
-}
-export function resolveDataGridCellMenuDisabledReasons(options, columnKey) {
-    return Object.freeze({
-        ...options.disabledReasons,
-        ...(options.columns[columnKey]?.disabledReasons ?? {}),
-    });
-}
-export function resolveDataGridCellMenuActionOptions(options, columnKey) {
-    const columnActions = options.columns[columnKey]?.actions ?? {};
-    const entries = DATAGRID_CELL_MENU_ACTION_KEYS
-        .map(actionKey => {
-        const merged = {
-            ...(options.actions[actionKey] ?? {}),
-            ...(columnActions[actionKey] ?? {}),
-        };
-        return [actionKey, Object.freeze(merged)];
-    })
-        .filter(([, value]) => Object.keys(value).length > 0);
-    return Object.freeze(Object.fromEntries(entries));
-}
-export function resolveDataGridRowIndexMenu(input) {
-    if (typeof input === "boolean") {
-        return {
-            enabled: input,
-            items: [...DATAGRID_ROW_INDEX_MENU_ITEM_KEYS],
-            disabled: [],
-            disabledReasons: Object.freeze({}),
-            labels: Object.freeze({}),
-            actions: Object.freeze({}),
-        };
-    }
-    if (!input) {
-        return {
-            enabled: false,
-            items: [...DATAGRID_ROW_INDEX_MENU_ITEM_KEYS],
-            disabled: [],
-            disabledReasons: Object.freeze({}),
-            labels: Object.freeze({}),
-            actions: Object.freeze({}),
-        };
-    }
-    return {
-        enabled: input.enabled ?? true,
-        items: normalizeItems(input.items, DATAGRID_ROW_INDEX_MENU_ITEM_KEYS),
-        disabled: normalizeItemSubset(input.disabled, DATAGRID_ROW_INDEX_MENU_ITEM_KEYS),
-        disabledReasons: normalizeLabels(input.disabledReasons, DATAGRID_ROW_INDEX_MENU_ITEM_KEYS),
-        labels: normalizeLabels(input.labels, DATAGRID_ROW_INDEX_MENU_ITEM_KEYS),
-        actions: normalizeActionOptions(input.actions, DATAGRID_ROW_INDEX_MENU_ACTION_KEYS),
-    };
-}
-export function resolveDataGridRowIndexMenuItems(options) {
-    return options.items;
-}
-export function resolveDataGridRowIndexMenuDisabledItems(options) {
-    return options.disabled;
-}
-export function resolveDataGridRowIndexMenuLabels(options) {
-    return options.labels;
-}
-export function resolveDataGridRowIndexMenuDisabledReasons(options) {
-    return options.disabledReasons;
-}
-export function resolveDataGridRowIndexMenuActionOptions(options) {
-    const entries = DATAGRID_ROW_INDEX_MENU_ACTION_KEYS
-        .map(actionKey => [actionKey, Object.freeze({ ...(options.actions[actionKey] ?? {}) })])
-        .filter(([, value]) => Object.keys(value).length > 0);
-    return Object.freeze(Object.fromEntries(entries));
-}