@iris-ui-kit/react 0.3.0 → 0.3.2

package/dist/grid.cjs

@@ -0,0 +1,1007 @@
+'use client'
+'use strict';
+
+var React4 = require('react');
+var grid = require('@iris-ui-kit/core/grid');
+var core = require('@iris-ui-kit/core');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React4__namespace = /*#__PURE__*/_interopNamespace(React4);
+
+// src/grid/useGridCore.ts
+function useGridCore(options = {}) {
+  const coreRef = React4__namespace.useRef(null);
+  const ownershipRef = React4__namespace.useRef(null);
+  if (coreRef.current === null) {
+    const core2 = grid.createGridCore(options);
+    const ownership2 = { committed: false };
+    coreRef.current = core2;
+    ownershipRef.current = ownership2;
+    queueMicrotask(() => {
+      if (!ownership2.committed) core2.destroy();
+    });
+  }
+  const core = coreRef.current;
+  const ownership = ownershipRef.current;
+  const lifecycleGeneration = React4__namespace.useRef(0);
+  React4__namespace.useInsertionEffect(() => {
+    ownership.committed = true;
+  }, [core, ownership]);
+  React4__namespace.useEffect(() => {
+    const generation = ++lifecycleGeneration.current;
+    core.ready();
+    return () => {
+      queueMicrotask(() => {
+        if (lifecycleGeneration.current === generation) core.destroy();
+      });
+    };
+  }, [core]);
+  return core;
+}
+
+// src/grid/legacyGridOptions.ts
+function toGridColumnsOptions(props) {
+  return {
+    visibility: props.columnVisibility,
+    visibilityControlled: true,
+    onVisibilityChange: props.onColumnVisibilityChange,
+    order: props.columnOrder,
+    orderControlled: true,
+    onOrderChange: props.onColumnOrderChange,
+    widths: props.columnWidths,
+    defaultWidths: props.defaultColumnWidths,
+    onWidthsChange: props.onColumnWidthsChange,
+    pinned: props.pinnedColumns,
+    onPinnedChange: props.onColumnPinnedChange
+  };
+}
+function toGridRowsOptions(props) {
+  const rows = props.data ?? [];
+  return {
+    initialRows: props.keepSource ? [...rows] : rows,
+    options: {
+      ...props.rowKeyField === void 0 ? {} : { rowKeyField: props.rowKeyField },
+      ...props.getRowKey === void 0 ? {} : { getRowKey: props.getRowKey },
+      ...props.getChildren === void 0 ? {} : { getChildren: props.getChildren },
+      ...props.setChildren === void 0 ? {} : { setChildren: props.setChildren },
+      onBeforeRowsChange: props.beforeChange,
+      onRowsChange: props.onChange
+    }
+  };
+}
+function toGridSelectionOptions(props) {
+  return {
+    mode: props.selectable === "single" ? "single" : "multiple",
+    value: props.selection,
+    defaultValue: props.defaultSelection,
+    onChange: props.onSelectionChange
+  };
+}
+function toGridExpansionOptions(props) {
+  return {
+    mode: "multiple",
+    defaultValue: (props.defaultExpandedRowKeys ?? []).map(String),
+    onChange: props.onChange
+  };
+}
+function toGridPaginationOptions(props) {
+  const state = props.state;
+  const onChange = state ? (change) => {
+    props.request?.({ page: change.page, pageSize: change.pageSize });
+    props.proxyConfig?.onPageChange?.(change.page, change.pageSize);
+  } : void 0;
+  return {
+    page: state?.page,
+    pageSize: state?.pageSize,
+    total: state?.total,
+    defaultPage: props.proxyConfig?.defaultPage,
+    defaultPageSize: props.proxyConfig?.pageSize,
+    onChange
+  };
+}
+function toGridSortingOptions(props) {
+  return {
+    leafColumns: props.columns,
+    sort: props.sort,
+    defaultSort: props.defaultSort,
+    onSortChange: props.onSortChange,
+    multiSort: props.multiSort,
+    multiSortState: props.multiSortState,
+    defaultMultiSort: props.defaultMultiSort,
+    onMultiSortChange: props.onMultiSortChange,
+    formulaTables: props.formulaTables
+  };
+}
+function toGridFilteringOptions(props) {
+  return {
+    columns: props.columns,
+    getValue: props.getValue,
+    filters: props.filters,
+    defaultFilters: props.defaultFilters,
+    onFiltersChange: props.onFiltersChange,
+    filterValues: props.filterValues,
+    defaultFilterValues: props.defaultFilterValues,
+    onFilterValuesChange: props.onFilterValuesChange,
+    controlled: true,
+    formFilters: props.formFilters,
+    query: props.query,
+    proxy: Boolean(props.proxy),
+    remote: props.remoteFilter
+  };
+}
+function useStore(store) {
+  return React4.useSyncExternalStore(
+    store.subscribe,
+    store.getState,
+    store.getState
+    // SSR fallback — same as client snapshot in our case.
+  );
+}
+function useStoreSelector(store, selector, isEqual) {
+  const [slice, setSlice] = React4__namespace.useState(() => selector(store.getState()));
+  const selRef = React4__namespace.useRef(selector);
+  selRef.current = selector;
+  const eqRef = React4__namespace.useRef(isEqual);
+  eqRef.current = isEqual;
+  React4__namespace.useEffect(() => {
+    const read = (s) => selRef.current(s);
+    const eq = (a, b) => (eqRef.current ?? Object.is)(a, b);
+    setSlice((prev) => {
+      const next = read(store.getState());
+      return eq(prev, next) ? prev : next;
+    });
+    return store.subscribeWith(read, setSlice, eq);
+  }, [store]);
+  return slice;
+}
+function useGridFeature(core, name, modelMethod, create) {
+  const feature = React4__namespace.useRef(null);
+  if (feature.current === null) feature.current = create();
+  if (!core.hasFeature(name)) core.use(feature.current);
+  return core.invoke(modelMethod);
+}
+
+// src/grid/useGridColumns.ts
+var EMPTY_VISIBILITY = {};
+var EMPTY_ORDER = [];
+var EMPTY_WIDTHS = {};
+var EMPTY_PINNED = {};
+function visibilitySignature(visibility) {
+  return visibility ? JSON.stringify(Object.keys(visibility).map((key) => [key, visibility[key]])) : "";
+}
+function cloneColumnsState(state) {
+  return {
+    visibility: { ...state.visibility },
+    order: [...state.order],
+    widths: { ...state.widths },
+    pinned: { ...state.pinned }
+  };
+}
+function useGridColumns(core, options = {}) {
+  const latest = React4__namespace.useRef(options);
+  latest.current = options;
+  const model = useGridFeature(
+    core,
+    "columns",
+    "getColumnsModel",
+    () => grid.createGridColumnsFeature({
+      defaultVisibility: options.visibility ?? options.defaultVisibility,
+      defaultOrder: options.order ?? options.defaultOrder,
+      defaultWidths: options.widths ?? options.defaultWidths,
+      defaultPinned: options.pinned ?? options.defaultPinned,
+      onVisibilityChange: (visibility) => latest.current.onVisibilityChange?.(visibility),
+      onOrderChange: (order) => latest.current.onOrderChange?.(order),
+      onWidthsChange: (widths) => latest.current.onWidthsChange?.(widths),
+      onPinnedChange: (key, side) => latest.current.onPinnedChange?.(key, side)
+    })
+  );
+  const internal = useStore(model.store);
+  const visibilityControlled = options.visibilityControlled ?? options.visibility !== void 0;
+  const orderControlled = options.orderControlled ?? options.order !== void 0;
+  const widthsControlled = options.widths !== void 0;
+  const pinnedControlled = options.pinned !== void 0;
+  const visibilityVersion = visibilitySignature(
+    visibilityControlled ? options.visibility : void 0
+  );
+  const lastUncontrolledVisibility = React4__namespace.useRef({
+    ...options.defaultVisibility ?? EMPTY_VISIBILITY
+  });
+  const lastUncontrolledOrder = React4__namespace.useRef([...options.defaultOrder ?? EMPTY_ORDER]);
+  const lastUncontrolledWidths = React4__namespace.useRef({
+    ...options.defaultWidths ?? EMPTY_WIDTHS
+  });
+  const lastUncontrolledPinned = React4__namespace.useRef({
+    ...options.defaultPinned ?? EMPTY_PINNED
+  });
+  const wasVisibilityControlled = React4__namespace.useRef(visibilityControlled);
+  const wasOrderControlled = React4__namespace.useRef(orderControlled);
+  const wasWidthsControlled = React4__namespace.useRef(widthsControlled);
+  const wasPinnedControlled = React4__namespace.useRef(pinnedControlled);
+  const enteringVisibilityControlled = visibilityControlled && !wasVisibilityControlled.current;
+  const enteringOrderControlled = orderControlled && !wasOrderControlled.current;
+  const enteringWidthsControlled = widthsControlled && !wasWidthsControlled.current;
+  const enteringPinnedControlled = pinnedControlled && !wasPinnedControlled.current;
+  if (enteringVisibilityControlled || enteringOrderControlled || enteringWidthsControlled || enteringPinnedControlled) {
+    const liveState = model.store.getState();
+    if (enteringVisibilityControlled) {
+      lastUncontrolledVisibility.current = { ...liveState.visibility };
+    }
+    if (enteringOrderControlled) lastUncontrolledOrder.current = [...liveState.order];
+    if (enteringWidthsControlled) lastUncontrolledWidths.current = { ...liveState.widths };
+    if (enteringPinnedControlled) lastUncontrolledPinned.current = { ...liveState.pinned };
+  }
+  if (!visibilityControlled && !wasVisibilityControlled.current) {
+    lastUncontrolledVisibility.current = { ...internal.visibility };
+  }
+  if (!orderControlled && !wasOrderControlled.current) {
+    lastUncontrolledOrder.current = [...internal.order];
+  }
+  if (!widthsControlled && !wasWidthsControlled.current) {
+    lastUncontrolledWidths.current = { ...internal.widths };
+  }
+  if (!pinnedControlled && !wasPinnedControlled.current) {
+    lastUncontrolledPinned.current = { ...internal.pinned };
+  }
+  const state = cloneColumnsState({
+    visibility: visibilityControlled ? { ...options.visibility ?? EMPTY_VISIBILITY } : wasVisibilityControlled.current ? lastUncontrolledVisibility.current : internal.visibility,
+    order: orderControlled ? [...options.order ?? EMPTY_ORDER] : wasOrderControlled.current ? lastUncontrolledOrder.current : internal.order,
+    // Removing a controlled order must restore the last uncontrolled/default
+    // snapshot rather than exposing a rejected controlled proposal. Widths
+    // use the same handoff policy below.
+    // Removing a controlled width map must restore the last uncontrolled or
+    // default snapshot immediately; otherwise one render leaks the rejected
+    // controlled widths before the silent model rebase runs.
+    widths: widthsControlled ? { ...options.widths } : wasWidthsControlled.current ? lastUncontrolledWidths.current : internal.widths,
+    pinned: pinnedControlled ? { ...options.pinned } : wasPinnedControlled.current ? lastUncontrolledPinned.current : internal.pinned
+  });
+  React4__namespace.useEffect(() => {
+    if (visibilityControlled) model.syncVisibility(options.visibility ?? {});
+    else if (wasVisibilityControlled.current)
+      model.syncVisibility(lastUncontrolledVisibility.current);
+    wasVisibilityControlled.current = visibilityControlled;
+  }, [model, options.visibility, visibilityControlled, visibilityVersion]);
+  React4__namespace.useEffect(() => {
+    if (orderControlled) model.syncOrder(options.order ?? []);
+    else if (wasOrderControlled.current) model.syncOrder(lastUncontrolledOrder.current);
+    wasOrderControlled.current = orderControlled;
+  }, [model, options.order, orderControlled]);
+  React4__namespace.useEffect(() => {
+    if (widthsControlled) model.syncWidths(options.widths ?? {});
+    else if (wasWidthsControlled.current) model.syncWidths(lastUncontrolledWidths.current);
+    wasWidthsControlled.current = widthsControlled;
+  }, [model, options.widths, widthsControlled]);
+  React4__namespace.useEffect(() => {
+    if (pinnedControlled) model.syncPinned(options.pinned ?? {});
+    else if (wasPinnedControlled.current) model.syncPinned(lastUncontrolledPinned.current);
+    wasPinnedControlled.current = pinnedControlled;
+  }, [model, options.pinned, pinnedControlled]);
+  const rebaseVisibility = React4__namespace.useCallback(() => {
+    if (latest.current.visibilityControlled ?? latest.current.visibility !== void 0) {
+      model.syncVisibility(latest.current.visibility ?? {});
+    } else if (wasVisibilityControlled.current) {
+      model.syncVisibility(lastUncontrolledVisibility.current);
+    }
+  }, [model]);
+  const rebaseOrder = React4__namespace.useCallback(() => {
+    if (latest.current.orderControlled ?? latest.current.order !== void 0) {
+      model.syncOrder(latest.current.order ?? []);
+    }
+  }, [model]);
+  const rebaseWidths = React4__namespace.useCallback(() => {
+    if (latest.current.widths !== void 0) model.syncWidths(latest.current.widths);
+    else if (wasWidthsControlled.current) model.syncWidths(lastUncontrolledWidths.current);
+  }, [model]);
+  const rebasePinned = React4__namespace.useCallback(() => {
+    if (latest.current.pinned !== void 0) model.syncPinned(latest.current.pinned);
+    else if (wasPinnedControlled.current) model.syncPinned(lastUncontrolledPinned.current);
+  }, [model]);
+  const setVisibility = React4__namespace.useCallback(
+    (visibility) => {
+      rebaseVisibility();
+      model.setVisibility(visibility);
+    },
+    [model, rebaseVisibility]
+  );
+  const toggleVisibility = React4__namespace.useCallback(
+    (key) => {
+      rebaseVisibility();
+      model.toggleVisibility(key);
+    },
+    [model, rebaseVisibility]
+  );
+  const setOrder = React4__namespace.useCallback(
+    (order) => {
+      rebaseOrder();
+      model.setOrder(order);
+    },
+    [model, rebaseOrder]
+  );
+  const clearOrder = React4__namespace.useCallback(() => {
+    rebaseOrder();
+    model.setOrder(void 0);
+  }, [model, rebaseOrder]);
+  const setWidths = React4__namespace.useCallback(
+    (widths) => {
+      rebaseWidths();
+      model.setWidths(widths);
+    },
+    [model, rebaseWidths]
+  );
+  const setWidth = React4__namespace.useCallback(
+    (key, width) => {
+      rebaseWidths();
+      model.setWidth(key, width);
+    },
+    [model, rebaseWidths]
+  );
+  const resetWidths = React4__namespace.useCallback(() => {
+    rebaseWidths();
+    model.setWidths({});
+  }, [model, rebaseWidths]);
+  const setPinned = React4__namespace.useCallback(
+    (key, side) => {
+      rebasePinned();
+      model.setPinned(key, side);
+    },
+    [model, rebasePinned]
+  );
+  return {
+    model,
+    state,
+    controlled: {
+      visibility: visibilityControlled,
+      order: orderControlled,
+      widths: widthsControlled,
+      pinned: pinnedControlled
+    },
+    setVisibility,
+    toggleVisibility,
+    setOrder,
+    clearOrder,
+    setWidths,
+    setWidth,
+    resetWidths,
+    setPinned
+  };
+}
+function defaultValue(row, column) {
+  return row[column.dataIndex ?? column.key];
+}
+function defaultSetValue(row, column, value) {
+  return { ...row, [column.dataIndex ?? column.key]: value };
+}
+function resolveCommitOptions(options) {
+  if (typeof options === "function") return options();
+  return options ?? {};
+}
+function useGridClipboard(core, options) {
+  const latest = React4__namespace.useRef(options);
+  latest.current = options;
+  const model = useGridFeature(
+    core,
+    "clipboard",
+    "getClipboardModel",
+    () => grid.createGridClipboardFeature({
+      getRows: () => latest.current.getRows?.() ?? core.invoke("getRows"),
+      getColumns: () => latest.current.getColumns(),
+      rowKeyField: latest.current.rowKeyField,
+      overflowRows: (context) => latest.current.overflowRows?.(context),
+      resolveValue: (row, column) => {
+        const resolve = latest.current.resolveValue;
+        return resolve ? resolve(row, column) : defaultValue(row, column);
+      },
+      parseValue: (text, row, column) => {
+        const parse = latest.current.parseValue;
+        return parse ? parse(text, row, column) : text;
+      },
+      setValue: (row, column, value) => latest.current.setValue?.(row, column, value) ?? defaultSetValue(row, column, value),
+      isCellEditable: (row, column, rowIndex, columnIndex) => latest.current.isCellEditable?.(row, column, rowIndex, columnIndex) ?? true,
+      reconcileRows: (sourceRows, previousRows, rows) => latest.current.reconcileRows?.(sourceRows, previousRows, rows) ?? rows,
+      commitOptions: () => resolveCommitOptions(latest.current.commitOptions),
+      onCopy: (change) => latest.current.onCopy?.(change),
+      onPaste: (change) => latest.current.onPaste?.(change)
+    })
+  );
+  const serialize = React4__namespace.useCallback(
+    (format, copyWithFormat) => model.serialize(
+      format ?? latest.current.copyFormat ?? "tsv",
+      copyWithFormat ?? latest.current.copyWithFormat ?? false
+    ),
+    [model]
+  );
+  const paste = React4__namespace.useCallback(
+    (text, range) => model.paste(text, range),
+    [model]
+  );
+  return { core, model, serialize, paste };
+}
+function cloneFilters(filters) {
+  return { ...filters ?? {} };
+}
+function cloneFilterValues(filterValues) {
+  return Object.fromEntries(
+    Object.entries(filterValues ?? {}).map(([key, values]) => [key, [...values]])
+  );
+}
+function useGridFiltering(core$1, data, options) {
+  const latest = React4__namespace.useRef(options);
+  latest.current = options;
+  const filtersControlled = options.controlled === true || options.filters !== void 0;
+  const valuesControlled = options.controlled === true || options.filterValues !== void 0;
+  const model = useGridFeature(
+    core$1,
+    "filtering",
+    "getFilteringModel",
+    () => grid.createGridFilteringFeature({
+      defaultFilters: filtersControlled ? options.filters ?? {} : options.defaultFilters,
+      defaultFilterValues: valuesControlled ? options.filterValues ?? {} : options.defaultFilterValues,
+      onFiltersChange: (next) => latest.current.onFiltersChange?.(next),
+      onFilterValuesChange: (next) => latest.current.onFilterValuesChange?.(next)
+    })
+  );
+  const internalState = useStore(model.store);
+  const filtersSignature = JSON.stringify(options.filters);
+  const filterValuesSignature = JSON.stringify(options.filterValues);
+  const wasFiltersControlled = React4__namespace.useRef(filtersControlled);
+  const uncontrolledFilters = React4__namespace.useRef({});
+  const hasUncontrolledFilters = React4__namespace.useRef(!filtersControlled);
+  const lastControlledFilters = React4__namespace.useRef(cloneFilters(options.filters));
+  const wasFilterValuesControlled = React4__namespace.useRef(valuesControlled);
+  const uncontrolledFilterValues = React4__namespace.useRef({});
+  const hasUncontrolledFilterValues = React4__namespace.useRef(!valuesControlled);
+  const lastControlledFilterValues = React4__namespace.useRef(
+    cloneFilterValues(options.filterValues)
+  );
+  const leavingFiltersControlled = wasFiltersControlled.current && !filtersControlled;
+  const leavingFilterValuesControlled = wasFilterValuesControlled.current && !valuesControlled;
+  if (!filtersControlled && !leavingFiltersControlled) {
+    uncontrolledFilters.current = cloneFilters(internalState.filters);
+    hasUncontrolledFilters.current = true;
+  }
+  if (!valuesControlled && !leavingFilterValuesControlled) {
+    uncontrolledFilterValues.current = cloneFilterValues(internalState.filterValues);
+    hasUncontrolledFilterValues.current = true;
+  }
+  if (filtersControlled && !wasFiltersControlled.current) {
+    uncontrolledFilters.current = cloneFilters(internalState.filters);
+    hasUncontrolledFilters.current = true;
+  }
+  if (valuesControlled && !wasFilterValuesControlled.current) {
+    uncontrolledFilterValues.current = cloneFilterValues(internalState.filterValues);
+    hasUncontrolledFilterValues.current = true;
+  }
+  if (filtersControlled) lastControlledFilters.current = cloneFilters(options.filters);
+  if (valuesControlled) {
+    lastControlledFilterValues.current = cloneFilterValues(options.filterValues);
+  }
+  const filters = cloneFilters(
+    filtersControlled ? options.filters : leavingFiltersControlled ? hasUncontrolledFilters.current ? uncontrolledFilters.current : lastControlledFilters.current : internalState.filters
+  );
+  const filterValues = cloneFilterValues(
+    valuesControlled ? options.filterValues : leavingFilterValuesControlled ? hasUncontrolledFilterValues.current ? uncontrolledFilterValues.current : lastControlledFilterValues.current : internalState.filterValues
+  );
+  React4__namespace.useEffect(() => {
+    if (filtersControlled) {
+      const next = cloneFilters(options.filters);
+      lastControlledFilters.current = cloneFilters(next);
+      model.syncFilters(next);
+    } else if (wasFiltersControlled.current) {
+      const restore = hasUncontrolledFilters.current ? uncontrolledFilters.current : lastControlledFilters.current;
+      uncontrolledFilters.current = cloneFilters(restore);
+      hasUncontrolledFilters.current = true;
+      model.syncFilters(restore);
+    }
+    wasFiltersControlled.current = filtersControlled;
+  }, [filtersControlled, model, options.filters, filtersSignature]);
+  React4__namespace.useEffect(() => {
+    if (valuesControlled) {
+      const next = cloneFilterValues(options.filterValues);
+      lastControlledFilterValues.current = cloneFilterValues(next);
+      model.syncFilterValues(next);
+    } else if (wasFilterValuesControlled.current) {
+      const restore = hasUncontrolledFilterValues.current ? uncontrolledFilterValues.current : lastControlledFilterValues.current;
+      uncontrolledFilterValues.current = cloneFilterValues(restore);
+      hasUncontrolledFilterValues.current = true;
+      model.syncFilterValues(restore);
+    }
+    wasFilterValuesControlled.current = valuesControlled;
+  }, [model, options.filterValues, valuesControlled, filterValuesSignature]);
+  const filteredData = React4__namespace.useMemo(() => {
+    if (options.remote) return data;
+    const merged = options.proxy ? { ...filters } : core.mergeFormFilters(filters, options.formFilters ?? {});
+    for (const [key, value] of Object.entries(options.query?.filters ?? {})) {
+      if (value !== "") merged[key] = value;
+    }
+    return core.filterTableRows(data, options.columns, {
+      getValue: options.getValue,
+      filters: merged,
+      filterValues,
+      additionalFilterValues: options.query?.inValues ? [options.query.inValues] : void 0,
+      filterRules: options.query?.rules
+    });
+  }, [
+    data,
+    filterValues,
+    filters,
+    options.columns,
+    options.formFilters,
+    options.getValue,
+    options.proxy,
+    options.query,
+    options.remote
+  ]);
+  return { core: core$1, model, filters, filterValues, filteredData };
+}
+function useGridEditing(core, options) {
+  const latest = React4__namespace.useRef(options);
+  latest.current = options;
+  const model = useGridFeature(
+    core,
+    "editing",
+    "getEditingModel",
+    () => grid.createGridEditingFeature({
+      getRowKey: (row, index) => latest.current.getRowKey(row, index),
+      getRowIndex: (rowKey, row, rootRows) => latest.current.getRowIndex?.(rowKey, row, rootRows),
+      getRules: (columnKey) => latest.current.getRules?.(columnKey),
+      getValue: (row, columnKey) => {
+        const getValue = latest.current.getValue;
+        return getValue ? getValue(row, columnKey) : row[columnKey];
+      },
+      setValue: (row, columnKey, value) => latest.current.setValue?.(row, columnKey, value) ?? { ...row, [columnKey]: value },
+      coerce: (draft, row, columnKey) => {
+        const coerce = latest.current.coerce;
+        return coerce ? coerce(draft, row, columnKey) : draft;
+      },
+      validate: (value, row, columnKey) => latest.current.validate?.(value, row, columnKey) ?? null,
+      isEditable: (row, columnKey) => latest.current.isEditable?.(row, columnKey) ?? true,
+      missingRowMessage: options.missingRowMessage,
+      commitOptions: () => {
+        const configured = latest.current.commitOptions;
+        return typeof configured === "function" ? configured() : configured ?? {};
+      },
+      onStateChange: (state2) => latest.current.onStateChange?.(state2),
+      onValidation: (validation) => latest.current.onValidation?.(validation),
+      onCommit: (commit) => latest.current.onCommit?.(commit)
+    })
+  );
+  const state = useStoreSelector(model.store, () => model.getState());
+  return {
+    core,
+    model,
+    state,
+    startCellEdit: (rowKey, columnKey, initialDraft) => model.start(rowKey, columnKey, initialDraft),
+    setCellDraft: (value) => model.setDraft(value),
+    cancelCellEdit: () => model.cancelEdit(),
+    commitCellEdit: (value) => model.commitEdit(value),
+    isCellEditing: (rowKey, columnKey) => model.isEditing(rowKey, columnKey)
+  };
+}
+function useGridExpansion(core, options = {}) {
+  const latest = React4__namespace.useRef(options);
+  latest.current = options;
+  const model = useGridFeature(
+    core,
+    "expansion",
+    "getExpansionModel",
+    () => grid.createGridExpansionFeature({
+      mode: options.mode,
+      defaultExpanded: options.defaultValue,
+      getKeys: () => latest.current.getKeys?.() ?? [],
+      onChange: (keys) => latest.current.onChange?.(keys)
+    })
+  );
+  const expandedKeys = useStore(model.store);
+  return { core, model, expandedKeys: [...expandedKeys] };
+}
+function controlledState(options) {
+  return {
+    ...options.page !== void 0 ? { page: options.page } : {},
+    ...options.pageSize !== void 0 ? { pageSize: options.pageSize } : {},
+    ...options.total !== void 0 ? { total: options.total } : {}
+  };
+}
+function useGridPagination(core, options = {}) {
+  const latest = React4__namespace.useRef(options);
+  latest.current = options;
+  const model = useGridFeature(
+    core,
+    "pagination",
+    "getPaginationModel",
+    () => grid.createGridPaginationFeature({
+      defaultPage: options.page ?? options.defaultPage,
+      defaultPageSize: options.pageSize ?? options.defaultPageSize,
+      defaultTotal: options.total ?? options.defaultTotal,
+      onChange: (change) => latest.current.onChange?.(change)
+    })
+  );
+  const internal = useStore(model.store);
+  const projectionRef = React4__namespace.useRef(null);
+  if (projectionRef.current === null) {
+    projectionRef.current = grid.createGridPaginationProjection(model, controlledState(options));
+  }
+  const projection = projectionRef.current;
+  const controlled = options.page !== void 0 || options.pageSize !== void 0 || options.total !== void 0;
+  const controlledProps = controlledState(options);
+  const pagination = projection.project(internal, controlledProps);
+  React4__namespace.useEffect(() => {
+    projection.sync(controlledState(options));
+    return () => projection.dispose();
+  }, [options.page, options.pageSize, options.total, projection]);
+  const rebase = React4__namespace.useCallback(() => {
+    projection.sync(controlledState(latest.current));
+  }, [projection]);
+  const setPage = React4__namespace.useCallback(
+    (page) => {
+      rebase();
+      model.setPage(page);
+    },
+    [model, rebase]
+  );
+  const setPageSize = React4__namespace.useCallback(
+    (pageSize) => {
+      rebase();
+      model.setPageSize(pageSize);
+    },
+    [model, rebase]
+  );
+  const setPagination = React4__namespace.useCallback(
+    (page, pageSize) => {
+      rebase();
+      model.set(page, pageSize);
+    },
+    [model, rebase]
+  );
+  return { model, pagination, controlled, setPage, setPageSize, setPagination };
+}
+function useGridRange(core, options = {}) {
+  const latest = React4__namespace.useRef(options);
+  latest.current = options;
+  const model = useGridFeature(
+    core,
+    "range",
+    "getRangeModel",
+    () => grid.createGridRangeFeature({
+      onChange: (change) => latest.current.onChange?.(change)
+    })
+  );
+  const state = React4__namespace.useSyncExternalStore(model.subscribe, model.getState, model.getState);
+  const range = React4__namespace.useMemo(() => model.getRange(), [model, state]);
+  return { core, model, state, range };
+}
+function sameKeys(left, right) {
+  return left.length === right.length && left.every(
+    (key, index) => key === right[index] || key !== key && right[index] !== right[index]
+  );
+}
+function useGridSelection(core, options = {}) {
+  const latest = React4__namespace.useRef(options);
+  latest.current = options;
+  const model = useGridFeature(
+    core,
+    "selection",
+    "getSelectionModel",
+    () => grid.createGridSelectionFeature({
+      mode: options.mode,
+      defaultSelected: options.value ?? options.defaultValue,
+      getKeys: () => latest.current.getKeys?.() ?? [],
+      onChange: (keys) => latest.current.onChange?.(keys)
+    })
+  );
+  const internalSelection = useStore(model.store);
+  const controlled = options.value !== void 0;
+  const wasControlled = React4__namespace.useRef(controlled);
+  const uncontrolledSnapshot = React4__namespace.useRef([]);
+  const hasUncontrolledSnapshot = React4__namespace.useRef(!controlled);
+  const lastControlledSnapshot = React4__namespace.useRef([...options.value ?? []]);
+  const leavingControlled = wasControlled.current && !controlled;
+  if (controlled && !wasControlled.current) {
+    uncontrolledSnapshot.current = [...model.store.getState()];
+    hasUncontrolledSnapshot.current = true;
+  }
+  if (!controlled && !leavingControlled) {
+    uncontrolledSnapshot.current = [...internalSelection];
+    hasUncontrolledSnapshot.current = true;
+  }
+  if (controlled) lastControlledSnapshot.current = [...options.value ?? []];
+  const uncontrolledValue = leavingControlled ? hasUncontrolledSnapshot.current ? uncontrolledSnapshot.current : lastControlledSnapshot.current : internalSelection;
+  React4__namespace.useEffect(() => {
+    if (controlled) {
+      const next = options.value ?? [];
+      lastControlledSnapshot.current = [...next];
+      if (!sameKeys(model.get(), next)) model.sync(next);
+    } else if (wasControlled.current) {
+      const next = hasUncontrolledSnapshot.current ? uncontrolledSnapshot.current : lastControlledSnapshot.current;
+      if (!hasUncontrolledSnapshot.current) {
+        uncontrolledSnapshot.current = [...next];
+        hasUncontrolledSnapshot.current = true;
+      }
+      if (!sameKeys(model.get(), next)) model.sync(next);
+    }
+    wasControlled.current = controlled;
+  }, [controlled, model, options.value ? [...options.value] : void 0]);
+  const rebase = React4__namespace.useCallback(() => {
+    if (latest.current.value !== void 0) model.sync(latest.current.value);
+  }, [model]);
+  return {
+    core,
+    model,
+    selection: [...controlled ? options.value ?? [] : uncontrolledValue],
+    controlled,
+    rebase
+  };
+}
+function useGridRows(core, initialRows, options = {}) {
+  const latest = React4__namespace.useRef(options);
+  latest.current = options;
+  const model = useGridFeature(
+    core,
+    "rows",
+    "getRowsModel",
+    () => grid.createGridRowsFeature({
+      defaultRows: initialRows,
+      cloneDefaultRows: options.cloneDefaultRows,
+      rowKeyField: options.rowKeyField,
+      getRowKey: (row, index) => latest.current.getRowKey?.(row, index),
+      getChildren: options.getChildren ? (row) => latest.current.getChildren?.(row) : void 0,
+      setChildren: options.setChildren ? (row, children) => latest.current.setChildren?.(row, children) : void 0,
+      onBeforeRowsChange: (transaction) => latest.current.onBeforeRowsChange?.(transaction),
+      onRowsChange: (transaction) => latest.current.onRowsChange?.(transaction)
+    })
+  );
+  const rows = useStoreSelector(model.store, (current) => [...current]);
+  return { model, rows };
+}
+function cloneSort(sort) {
+  return sort ? { ...sort } : null;
+}
+function cloneSorts(sorts) {
+  return sorts.map((sort) => ({ ...sort }));
+}
+function useGridSorting(core$1, data, options) {
+  const latest = React4__namespace.useRef(options);
+  latest.current = options;
+  const model = useGridFeature(
+    core$1,
+    "sorting",
+    "getSortingModel",
+    () => grid.createGridSortingFeature({
+      mode: options.multiSort ? "multiple" : "single",
+      defaultSort: options.sort !== void 0 ? options.sort : options.defaultSort,
+      defaultMultiSort: options.multiSortState !== void 0 ? options.multiSortState : options.defaultMultiSort,
+      onSortChange: (next) => latest.current.onSortChange?.(next),
+      onMultiSortChange: (next) => latest.current.onMultiSortChange?.(next)
+    })
+  );
+  const internalState = useStore(model.store);
+  const sortControlled = options.sort !== void 0;
+  const multiControlled = options.multiSortState !== void 0;
+  const sortSignature = JSON.stringify(options.sort);
+  const multiSortSignature = JSON.stringify(options.multiSortState);
+  const wasSortControlled = React4__namespace.useRef(sortControlled);
+  const uncontrolledSort = React4__namespace.useRef(null);
+  const hasUncontrolledSort = React4__namespace.useRef(!sortControlled);
+  const lastControlledSort = React4__namespace.useRef(cloneSort(options.sort ?? null));
+  const wasMultiSortControlled = React4__namespace.useRef(multiControlled);
+  const uncontrolledMultiSort = React4__namespace.useRef([]);
+  const hasUncontrolledMultiSort = React4__namespace.useRef(!multiControlled);
+  const lastControlledMultiSort = React4__namespace.useRef(
+    cloneSorts(options.multiSortState ?? [])
+  );
+  const leavingSortControlled = wasSortControlled.current && !sortControlled;
+  const leavingMultiSortControlled = wasMultiSortControlled.current && !multiControlled;
+  const enteringSortControlled = sortControlled && !wasSortControlled.current;
+  const enteringMultiSortControlled = multiControlled && !wasMultiSortControlled.current;
+  if (enteringSortControlled || enteringMultiSortControlled) {
+    const liveState = model.store.getState();
+    if (enteringSortControlled) {
+      uncontrolledSort.current = cloneSort(liveState.sort);
+      hasUncontrolledSort.current = true;
+    }
+    if (enteringMultiSortControlled) {
+      uncontrolledMultiSort.current = cloneSorts(liveState.multiSort);
+      hasUncontrolledMultiSort.current = true;
+    }
+  }
+  if (!sortControlled && !leavingSortControlled) {
+    uncontrolledSort.current = cloneSort(internalState.sort);
+    hasUncontrolledSort.current = true;
+  }
+  if (!multiControlled && !leavingMultiSortControlled) {
+    uncontrolledMultiSort.current = cloneSorts(internalState.multiSort);
+    hasUncontrolledMultiSort.current = true;
+  }
+  if (sortControlled) lastControlledSort.current = cloneSort(options.sort ?? null);
+  if (multiControlled) {
+    lastControlledMultiSort.current = cloneSorts(options.multiSortState ?? []);
+  }
+  const sortState = sortControlled ? cloneSort(options.sort ?? null) : cloneSort(
+    leavingSortControlled ? hasUncontrolledSort.current ? uncontrolledSort.current : lastControlledSort.current : internalState.sort
+  );
+  const multiSortState = multiControlled ? cloneSorts(options.multiSortState ?? []) : cloneSorts(
+    leavingMultiSortControlled ? hasUncontrolledMultiSort.current ? uncontrolledMultiSort.current : lastControlledMultiSort.current : internalState.multiSort
+  );
+  React4__namespace.useEffect(() => {
+    if (sortControlled) {
+      const next = options.sort ?? null;
+      lastControlledSort.current = cloneSort(next);
+      model.syncSort(next);
+    } else if (wasSortControlled.current) {
+      const restore = hasUncontrolledSort.current ? uncontrolledSort.current : lastControlledSort.current;
+      if (!hasUncontrolledSort.current) {
+        uncontrolledSort.current = cloneSort(restore);
+        hasUncontrolledSort.current = true;
+      }
+      model.syncSort(restore);
+    }
+    wasSortControlled.current = sortControlled;
+  }, [model, options.sort, sortControlled, sortSignature]);
+  React4__namespace.useEffect(() => {
+    if (multiControlled) {
+      const next = cloneSorts(options.multiSortState ?? []);
+      lastControlledMultiSort.current = cloneSorts(next);
+      model.syncMultiSort(next);
+    } else if (wasMultiSortControlled.current) {
+      const restore = hasUncontrolledMultiSort.current ? uncontrolledMultiSort.current : lastControlledMultiSort.current;
+      uncontrolledMultiSort.current = cloneSorts(restore);
+      hasUncontrolledMultiSort.current = true;
+      model.syncMultiSort(restore);
+    }
+    wasMultiSortControlled.current = multiControlled;
+  }, [model, multiControlled, options.multiSortState, multiSortSignature]);
+  const setSort = React4__namespace.useCallback(
+    (next) => {
+      if (latest.current.sort !== void 0) model.syncSort(latest.current.sort ?? null);
+      model.setSort(next);
+    },
+    [model]
+  );
+  const cycleSort = React4__namespace.useCallback(
+    (column) => {
+      if (!column.sortable) return;
+      if (latest.current.sort !== void 0) model.syncSort(latest.current.sort ?? null);
+      model.cycleSort(column.key);
+    },
+    [model]
+  );
+  const setMultiSort = React4__namespace.useCallback(
+    (next) => {
+      if (latest.current.multiSortState !== void 0) {
+        model.syncMultiSort(latest.current.multiSortState);
+      }
+      model.setMultiSort(next);
+    },
+    [model]
+  );
+  const cycleMultiSort = React4__namespace.useCallback(
+    (column) => {
+      if (!column.sortable) return;
+      if (latest.current.multiSortState !== void 0) {
+        model.syncMultiSort(latest.current.multiSortState);
+      }
+      model.cycleMultiSort(column.key);
+    },
+    [model]
+  );
+  const getValue = React4__namespace.useCallback(
+    (row, column) => {
+      if (column.sortBy !== void 0) return row[column.sortBy];
+      return core.resolveTableColumnValue(row, column, options.formulaTables);
+    },
+    [options.formulaTables]
+  );
+  const sortComparator = React4__namespace.useMemo(
+    () => core.createTableSortComparator(sortState, options.leafColumns, getValue),
+    [getValue, options.leafColumns, sortState]
+  );
+  const multiSortComparator = React4__namespace.useMemo(
+    () => core.createTableMultiSortComparator(multiSortState, options.leafColumns, getValue),
+    [getValue, options.leafColumns, multiSortState]
+  );
+  const sortedData = React4__namespace.useMemo(
+    () => core.sortTableRows(data, options.leafColumns, {
+      mode: options.multiSort ? "multiple" : "single",
+      sort: sortState,
+      multiSort: multiSortState,
+      getValue
+    }),
+    [data, getValue, multiSortState, options.leafColumns, options.multiSort, sortState]
+  );
+  return {
+    core: core$1,
+    model,
+    sortState,
+    cycleSort,
+    setSort,
+    sortComparator,
+    sortedData,
+    multiSortState,
+    cycleMultiSort,
+    setMultiSort,
+    multiSortComparator
+  };
+}
+var useIsomorphicLayoutEffect = typeof window === "undefined" || typeof document === "undefined" ? React4__namespace.useEffect : React4__namespace.useLayoutEffect;
+function useGridVirtual(core, options) {
+  const latest = React4__namespace.useRef(options);
+  latest.current = options;
+  const model = useGridFeature(
+    core,
+    "virtual",
+    "getVirtualModel",
+    () => grid.createGridVirtualFeature({
+      count: options.items.length,
+      estimateSize: (index) => {
+        const estimate = latest.current.estimateSize;
+        return typeof estimate === "function" ? estimate(index) : estimate;
+      },
+      viewportSize: options.viewportSize,
+      scrollOffset: options.scrollOffset,
+      buffer: options.buffer,
+      fixedSize: typeof options.estimateSize === "number" ? options.estimateSize : null,
+      getItemKey: (index) => {
+        const item = latest.current.items[index];
+        const keyOf = latest.current.getItemKey;
+        return item !== void 0 && keyOf ? keyOf(item, index) : index;
+      },
+      onRangeChange: (change) => latest.current.onRangeChange?.(change)
+    })
+  );
+  useIsomorphicLayoutEffect(() => {
+    model.setCount(options.items.length);
+  }, [model, options.items, options.getItemKey]);
+  useIsomorphicLayoutEffect(() => {
+    model.setBuffer(options.buffer ?? 0);
+  }, [model, options.buffer]);
+  useIsomorphicLayoutEffect(() => {
+    model.setEstimateSize(
+      options.estimateSize,
+      typeof options.estimateSize === "number" ? options.estimateSize : null
+    );
+  }, [model, options.estimateSize]);
+  useIsomorphicLayoutEffect(() => {
+    if (options.viewportSize !== void 0) model.setViewportSize(options.viewportSize);
+  }, [model, options.viewportSize]);
+  useIsomorphicLayoutEffect(() => {
+    if (options.scrollOffset !== void 0) model.setScroll(options.scrollOffset);
+  }, [model, options.scrollOffset]);
+  return { model };
+}
+
+exports.toGridColumnsOptions = toGridColumnsOptions;
+exports.toGridExpansionOptions = toGridExpansionOptions;
+exports.toGridFilteringOptions = toGridFilteringOptions;
+exports.toGridPaginationOptions = toGridPaginationOptions;
+exports.toGridRowsOptions = toGridRowsOptions;
+exports.toGridSelectionOptions = toGridSelectionOptions;
+exports.toGridSortingOptions = toGridSortingOptions;
+exports.useGridClipboard = useGridClipboard;
+exports.useGridColumns = useGridColumns;
+exports.useGridCore = useGridCore;
+exports.useGridEditing = useGridEditing;
+exports.useGridExpansion = useGridExpansion;
+exports.useGridFiltering = useGridFiltering;
+exports.useGridPagination = useGridPagination;
+exports.useGridRange = useGridRange;
+exports.useGridRows = useGridRows;
+exports.useGridSelection = useGridSelection;
+exports.useGridSorting = useGridSorting;
+exports.useGridVirtual = useGridVirtual;
+//# sourceMappingURL=grid.cjs.map
+//# sourceMappingURL=grid.cjs.map