@tanstack/table-core 9.0.0-alpha.8 → 9.0.0-beta.10

package/dist/core/table/coreTablesFeature.types.d.cts

@@ -0,0 +1,198 @@
+import { RowData, Updater } from "../../types/type-utils.cjs";
+import { TableReactivityBindings } from "../reactivity/coreReactivityFeature.types.cjs";
+import { CoreFeatures } from "../coreFeatures.cjs";
+import { CachedRowModels } from "../../types/RowModel.cjs";
+import { RowModelFns } from "../../types/RowModelFns.cjs";
+import { TableState, TableState_All } from "../../types/TableState.cjs";
+import { TableOptions } from "../../types/TableOptions.cjs";
+import { IsAny, TableFeatures, ValidateFeatureSlots } from "../../types/TableFeatures.cjs";
+import { Atom, ReadonlyAtom, ReadonlyStore } from "@tanstack/store";
+
+//#region src/core/table/coreTablesFeature.types.d.ts
+interface TableMeta<TFeatures extends TableFeatures, TData extends RowData> {}
+/**
+ * Resolves the type of `options.meta` for a feature set.
+ *
+ * When the features object declares a `tableMeta` type-only slot
+ * (`tableFeatures({ ..., tableMeta: {} as MyTableMeta })`), that type wins.
+ * Otherwise this falls back to the global declaration-merged `TableMeta`
+ * interface.
+ */
+type ExtractTableMeta<TFeatures extends TableFeatures, TData extends RowData> = IsAny<TFeatures> extends true ? TableMeta<TFeatures, TData> : TFeatures extends {
+  tableMeta: infer TMeta extends object;
+} ? TMeta : TableMeta<TFeatures, TData>;
+/**
+ * A map of writable atoms, one per `TableState` slice. These are the internal
+ * writable atoms that the library always writes to via `makeStateUpdater`.
+ */
+type BaseAtoms<TFeatures extends TableFeatures> = { [K in keyof TableState<TFeatures>]-?: Atom<TableState<TFeatures>[K]> };
+/**
+ * A map of readonly derived atoms, one per `TableState` slice. Each derives
+ * from its corresponding `baseAtom` plus, optionally, a per-slice external
+ * atom or external state value.
+ *
+ * Precedence: `options.atoms[key]` > `options.state[key]` > `baseAtoms[key]`.
+ */
+type Atoms<TFeatures extends TableFeatures> = { [K in keyof TableState<TFeatures>]-?: ReadonlyAtom<TableState<TFeatures>[K]> };
+/**
+ * A map of optional external atoms, one per `TableState` slice. Consumers can
+ * provide their own writable atom for any state slice to take over ownership
+ * of that slice.
+ */
+type ExternalAtoms<TFeatures extends TableFeatures> = Partial<{ [K in keyof TableState<TFeatures>]: Atom<TableState<TFeatures>[K]> }>;
+/**
+ * Internal "all features" flat variants of the atom types. `Table_Internal`
+ * uses these so feature code (written generically over `TFeatures`) can access
+ * any slice atom (e.g. `table.atoms.columnPinning`) without TypeScript
+ * narrowing away slices that aren't in the current `TFeatures` union.
+ *
+ * Keys are optional: feature code can read atoms from slices it doesn't own,
+ * but those slices may not be registered on the current table. Consumers must
+ * use optional chaining (`table.atoms.columnPinning?.get() ?? default`).
+ */
+type BaseAtoms_All = { [K in keyof TableState_All]?: Atom<TableState_All[K]> };
+type Atoms_All = { [K in keyof TableState_All]?: ReadonlyAtom<TableState_All[K]> };
+type ExternalAtoms_All = Partial<{ [K in keyof TableState_All]: Atom<TableState_All[K]> }>;
+interface TableOptions_Table<TFeatures extends TableFeatures, TData extends RowData> {
+  /**
+   * The feature modules registered on this table instance.
+   *
+   * Feature registration controls which state slices, options, and prototype
+   * APIs are available. This object also carries the table's row model
+   * factories (`sortedRowModel`, `filteredRowModel`, etc.), row model function
+   * registries (`sortFns`, `filterFns`, `aggregationFns`), and type-only meta
+   * slots (`tableMeta`, `columnMeta`).
+   */
+  readonly features: TFeatures & ValidateFeatureSlots<TFeatures>;
+  /**
+   * Optionally, provide your own external writable atoms for individual state slices.
+   * When an atom is provided for a given slice, it takes precedence over `options.state[key]`
+   * and the internal base atom for that slice. Feature state update APIs write through
+   * the corresponding atom updater, so external atoms are the preferred v9 ownership
+   * model for app-managed table state slices.
+   */
+  readonly atoms?: ExternalAtoms<TFeatures>;
+  /**
+   * Set this option to override any of the `autoReset...` feature options.
+   */
+  readonly autoResetAll?: boolean;
+  /**
+   * The data for the table to display. When the `data` option changes reference, the table will reprocess the data.
+   */
+  readonly data: ReadonlyArray<TData>;
+  /**
+   * Optional key used to identify this table instance.
+   *
+   * This is used by TanStack Table Devtools to register and select tables. It is
+   * not required unless the table is passed to devtools.
+   */
+  readonly key?: string;
+  /**
+   * Optionally provide starting values for registered table state slices.
+   * Feature reset APIs use this value by default, and many reset APIs accept
+   * `true` to reset to that feature's blank/default state instead. Changing this
+   * object later does not reset table state, so it does not need to be stable.
+   */
+  readonly initialState?: Partial<TableState<TFeatures>>;
+  /**
+   * This option is used to optionally implement the merging of table options.
+   */
+  readonly mergeOptions?: (defaultOptions: TableOptions<TFeatures, TData>, options: Partial<TableOptions<TFeatures, TData>>) => TableOptions<TFeatures, TData>;
+  /**
+   * You can pass any object to `options.meta` and access it anywhere the `table` is available via `table.options.meta`.
+   *
+   * Declare its type per-table via the `tableMeta` type-only slot on the
+   * `features` option, or globally via declaration merging on `TableMeta`.
+   */
+  readonly meta?: ExtractTableMeta<TFeatures, TData>;
+  /**
+   * Optionally provide externally managed values for individual state slices.
+   *
+   * Pair each slice with its matching `on[State]Change` callback so table state
+   * updates can be persisted outside the table. External atoms take precedence
+   * over this option when both are provided for the same slice.
+   */
+  readonly state?: Partial<TableState<TFeatures>>;
+}
+interface Table_CoreProperties<TFeatures extends TableFeatures, TData extends RowData> {
+  /**
+   * Table reactivity bindings for interacting with TanStack Store.
+   */
+  readonly _reactivity: TableReactivityBindings;
+  /**
+   * Prototype cache for Cell objects - shared by all cells in this table
+   */
+  _cellPrototype?: object;
+  /**
+   * Prototype cache for Column objects - shared by all columns in this table
+   */
+  _columnPrototype?: object;
+  /**
+   * The features that are enabled for the table.
+   */
+  readonly _features: Partial<CoreFeatures> & TFeatures;
+  /**
+   * Prototype cache for Header objects - shared by all headers in this table
+   */
+  _headerPrototype?: object;
+  /**
+   * The row model processing functions that are used to process the data by features.
+   */
+  readonly _rowModelFns: RowModelFns<TFeatures, TData>;
+  /**
+   * The row models that are enabled for the table.
+   */
+  readonly _rowModels: CachedRowModels<TFeatures, TData>;
+  /**
+   * Prototype cache for Row objects - shared by all rows in this table
+   */
+  _rowPrototype?: object;
+  /**
+   * The readonly derived atoms for each `TableState` slice. Each derives from
+   * its corresponding `baseAtom` plus, optionally, a per-slice external atom or
+   * external state value (precedence: external atom > external state > base atom).
+   */
+  readonly atoms: Atoms<TFeatures>;
+  /**
+   * The internal writable atoms for each `TableState` slice. This is the library's
+   * single write surface — all state mutations from features land here.
+   */
+  readonly baseAtoms: BaseAtoms<TFeatures>;
+  /**
+   * This is the resolved initial state of the table.
+   */
+  readonly initialState: TableState<TFeatures>;
+  /**
+   * A read-only reference to the table's current options.
+   */
+  readonly options: TableOptions<TFeatures, TData>;
+  /**
+   * Writable atom for table options. Only created when `createOptionsStore` is
+   * true on the active core reactivity bindings. Adapters that opt out keep
+   * options as plain resolved data instead of backing them with an atom.
+   */
+  readonly optionsStore?: Atom<TableOptions<TFeatures, TData>> | undefined;
+  /**
+   * The readonly flat store for the table state. Derives from `table.atoms`
+   * only; never reads external state directly.
+   */
+  readonly store: ReadonlyStore<TableState<TFeatures>>;
+}
+interface Table_Table<TFeatures extends TableFeatures, TData extends RowData> extends Table_CoreProperties<TFeatures, TData> {
+  /**
+   * Resets the table's internal base atoms to `table.initialState`.
+   *
+   * Prefer feature-specific reset APIs, such as `resetPagination`, when a state
+   * slice may be owned by an external atom or needs that feature's blank/default
+   * reset behavior.
+   */
+  reset: () => void;
+  /**
+   * Updates the table options by applying a value or updater to the current
+   * resolved options and then merging them through `options.mergeOptions`.
+   */
+  setOptions: (newOptions: Updater<TableOptions<TFeatures, TData>>) => void;
+}
+//#endregion
+export { Atoms, Atoms_All, BaseAtoms, BaseAtoms_All, ExternalAtoms, ExternalAtoms_All, ExtractTableMeta, TableMeta, TableOptions_Table, Table_CoreProperties, Table_Table };
+//# sourceMappingURL=coreTablesFeature.types.d.cts.map

package/dist/core/table/coreTablesFeature.types.d.ts

@@ -0,0 +1,198 @@
+import { RowData, Updater } from "../../types/type-utils.js";
+import { TableReactivityBindings } from "../reactivity/coreReactivityFeature.types.js";
+import { CoreFeatures } from "../coreFeatures.js";
+import { CachedRowModels } from "../../types/RowModel.js";
+import { RowModelFns } from "../../types/RowModelFns.js";
+import { TableState, TableState_All } from "../../types/TableState.js";
+import { TableOptions } from "../../types/TableOptions.js";
+import { IsAny, TableFeatures, ValidateFeatureSlots } from "../../types/TableFeatures.js";
+import { Atom, ReadonlyAtom, ReadonlyStore } from "@tanstack/store";
+
+//#region src/core/table/coreTablesFeature.types.d.ts
+interface TableMeta<TFeatures extends TableFeatures, TData extends RowData> {}
+/**
+ * Resolves the type of `options.meta` for a feature set.
+ *
+ * When the features object declares a `tableMeta` type-only slot
+ * (`tableFeatures({ ..., tableMeta: {} as MyTableMeta })`), that type wins.
+ * Otherwise this falls back to the global declaration-merged `TableMeta`
+ * interface.
+ */
+type ExtractTableMeta<TFeatures extends TableFeatures, TData extends RowData> = IsAny<TFeatures> extends true ? TableMeta<TFeatures, TData> : TFeatures extends {
+  tableMeta: infer TMeta extends object;
+} ? TMeta : TableMeta<TFeatures, TData>;
+/**
+ * A map of writable atoms, one per `TableState` slice. These are the internal
+ * writable atoms that the library always writes to via `makeStateUpdater`.
+ */
+type BaseAtoms<TFeatures extends TableFeatures> = { [K in keyof TableState<TFeatures>]-?: Atom<TableState<TFeatures>[K]> };
+/**
+ * A map of readonly derived atoms, one per `TableState` slice. Each derives
+ * from its corresponding `baseAtom` plus, optionally, a per-slice external
+ * atom or external state value.
+ *
+ * Precedence: `options.atoms[key]` > `options.state[key]` > `baseAtoms[key]`.
+ */
+type Atoms<TFeatures extends TableFeatures> = { [K in keyof TableState<TFeatures>]-?: ReadonlyAtom<TableState<TFeatures>[K]> };
+/**
+ * A map of optional external atoms, one per `TableState` slice. Consumers can
+ * provide their own writable atom for any state slice to take over ownership
+ * of that slice.
+ */
+type ExternalAtoms<TFeatures extends TableFeatures> = Partial<{ [K in keyof TableState<TFeatures>]: Atom<TableState<TFeatures>[K]> }>;
+/**
+ * Internal "all features" flat variants of the atom types. `Table_Internal`
+ * uses these so feature code (written generically over `TFeatures`) can access
+ * any slice atom (e.g. `table.atoms.columnPinning`) without TypeScript
+ * narrowing away slices that aren't in the current `TFeatures` union.
+ *
+ * Keys are optional: feature code can read atoms from slices it doesn't own,
+ * but those slices may not be registered on the current table. Consumers must
+ * use optional chaining (`table.atoms.columnPinning?.get() ?? default`).
+ */
+type BaseAtoms_All = { [K in keyof TableState_All]?: Atom<TableState_All[K]> };
+type Atoms_All = { [K in keyof TableState_All]?: ReadonlyAtom<TableState_All[K]> };
+type ExternalAtoms_All = Partial<{ [K in keyof TableState_All]: Atom<TableState_All[K]> }>;
+interface TableOptions_Table<TFeatures extends TableFeatures, TData extends RowData> {
+  /**
+   * The feature modules registered on this table instance.
+   *
+   * Feature registration controls which state slices, options, and prototype
+   * APIs are available. This object also carries the table's row model
+   * factories (`sortedRowModel`, `filteredRowModel`, etc.), row model function
+   * registries (`sortFns`, `filterFns`, `aggregationFns`), and type-only meta
+   * slots (`tableMeta`, `columnMeta`).
+   */
+  readonly features: TFeatures & ValidateFeatureSlots<TFeatures>;
+  /**
+   * Optionally, provide your own external writable atoms for individual state slices.
+   * When an atom is provided for a given slice, it takes precedence over `options.state[key]`
+   * and the internal base atom for that slice. Feature state update APIs write through
+   * the corresponding atom updater, so external atoms are the preferred v9 ownership
+   * model for app-managed table state slices.
+   */
+  readonly atoms?: ExternalAtoms<TFeatures>;
+  /**
+   * Set this option to override any of the `autoReset...` feature options.
+   */
+  readonly autoResetAll?: boolean;
+  /**
+   * The data for the table to display. When the `data` option changes reference, the table will reprocess the data.
+   */
+  readonly data: ReadonlyArray<TData>;
+  /**
+   * Optional key used to identify this table instance.
+   *
+   * This is used by TanStack Table Devtools to register and select tables. It is
+   * not required unless the table is passed to devtools.
+   */
+  readonly key?: string;
+  /**
+   * Optionally provide starting values for registered table state slices.
+   * Feature reset APIs use this value by default, and many reset APIs accept
+   * `true` to reset to that feature's blank/default state instead. Changing this
+   * object later does not reset table state, so it does not need to be stable.
+   */
+  readonly initialState?: Partial<TableState<TFeatures>>;
+  /**
+   * This option is used to optionally implement the merging of table options.
+   */
+  readonly mergeOptions?: (defaultOptions: TableOptions<TFeatures, TData>, options: Partial<TableOptions<TFeatures, TData>>) => TableOptions<TFeatures, TData>;
+  /**
+   * You can pass any object to `options.meta` and access it anywhere the `table` is available via `table.options.meta`.
+   *
+   * Declare its type per-table via the `tableMeta` type-only slot on the
+   * `features` option, or globally via declaration merging on `TableMeta`.
+   */
+  readonly meta?: ExtractTableMeta<TFeatures, TData>;
+  /**
+   * Optionally provide externally managed values for individual state slices.
+   *
+   * Pair each slice with its matching `on[State]Change` callback so table state
+   * updates can be persisted outside the table. External atoms take precedence
+   * over this option when both are provided for the same slice.
+   */
+  readonly state?: Partial<TableState<TFeatures>>;
+}
+interface Table_CoreProperties<TFeatures extends TableFeatures, TData extends RowData> {
+  /**
+   * Table reactivity bindings for interacting with TanStack Store.
+   */
+  readonly _reactivity: TableReactivityBindings;
+  /**
+   * Prototype cache for Cell objects - shared by all cells in this table
+   */
+  _cellPrototype?: object;
+  /**
+   * Prototype cache for Column objects - shared by all columns in this table
+   */
+  _columnPrototype?: object;
+  /**
+   * The features that are enabled for the table.
+   */
+  readonly _features: Partial<CoreFeatures> & TFeatures;
+  /**
+   * Prototype cache for Header objects - shared by all headers in this table
+   */
+  _headerPrototype?: object;
+  /**
+   * The row model processing functions that are used to process the data by features.
+   */
+  readonly _rowModelFns: RowModelFns<TFeatures, TData>;
+  /**
+   * The row models that are enabled for the table.
+   */
+  readonly _rowModels: CachedRowModels<TFeatures, TData>;
+  /**
+   * Prototype cache for Row objects - shared by all rows in this table
+   */
+  _rowPrototype?: object;
+  /**
+   * The readonly derived atoms for each `TableState` slice. Each derives from
+   * its corresponding `baseAtom` plus, optionally, a per-slice external atom or
+   * external state value (precedence: external atom > external state > base atom).
+   */
+  readonly atoms: Atoms<TFeatures>;
+  /**
+   * The internal writable atoms for each `TableState` slice. This is the library's
+   * single write surface — all state mutations from features land here.
+   */
+  readonly baseAtoms: BaseAtoms<TFeatures>;
+  /**
+   * This is the resolved initial state of the table.
+   */
+  readonly initialState: TableState<TFeatures>;
+  /**
+   * A read-only reference to the table's current options.
+   */
+  readonly options: TableOptions<TFeatures, TData>;
+  /**
+   * Writable atom for table options. Only created when `createOptionsStore` is
+   * true on the active core reactivity bindings. Adapters that opt out keep
+   * options as plain resolved data instead of backing them with an atom.
+   */
+  readonly optionsStore?: Atom<TableOptions<TFeatures, TData>> | undefined;
+  /**
+   * The readonly flat store for the table state. Derives from `table.atoms`
+   * only; never reads external state directly.
+   */
+  readonly store: ReadonlyStore<TableState<TFeatures>>;
+}
+interface Table_Table<TFeatures extends TableFeatures, TData extends RowData> extends Table_CoreProperties<TFeatures, TData> {
+  /**
+   * Resets the table's internal base atoms to `table.initialState`.
+   *
+   * Prefer feature-specific reset APIs, such as `resetPagination`, when a state
+   * slice may be owned by an external atom or needs that feature's blank/default
+   * reset behavior.
+   */
+  reset: () => void;
+  /**
+   * Updates the table options by applying a value or updater to the current
+   * resolved options and then merging them through `options.mergeOptions`.
+   */
+  setOptions: (newOptions: Updater<TableOptions<TFeatures, TData>>) => void;
+}
+//#endregion
+export { Atoms, Atoms_All, BaseAtoms, BaseAtoms_All, ExternalAtoms, ExternalAtoms_All, ExtractTableMeta, TableMeta, TableOptions_Table, Table_CoreProperties, Table_Table };
+//# sourceMappingURL=coreTablesFeature.types.d.ts.map

package/dist/core/table/coreTablesFeature.utils.cjs

@@ -0,0 +1,95 @@
+const require_utils = require('../../utils.cjs');
+
+//#region src/core/table/coreTablesFeature.utils.ts
+/**
+* Synchronizes externally controlled state slices into the table's base atoms.
+*
+* This keeps legacy `options.state` values reflected in the atom graph so
+* derived atoms, stores, and table APIs read a consistent snapshot.
+*
+* @example
+* ```ts
+* table_syncExternalStateToBaseAtoms(table)
+* ```
+*/
+function table_syncExternalStateToBaseAtoms(table) {
+	const state = table.options.state;
+	if (!state) return;
+	table._reactivity.batch(() => {
+		for (const key in state) {
+			const baseAtom = table.baseAtoms[key];
+			if (!baseAtom) continue;
+			const externalState = state[key];
+			if (externalState !== baseAtom.get()) baseAtom.set(() => externalState);
+		}
+	});
+}
+/**
+* Resets all internal table base atoms to `table.initialState`.
+*
+* This resets internally owned state slices in a single reactivity batch. Use
+* feature-specific reset APIs when a slice may be externally owned.
+*
+* @example
+* ```ts
+* table_reset(table)
+* ```
+*/
+function table_reset(table) {
+	const snap = require_utils.cloneState(table.initialState);
+	table._reactivity.batch(() => {
+		const keys = Object.keys(snap);
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			table.baseAtoms[key].set(snap[key]);
+		}
+	});
+}
+/**
+* Merges new table options with the current resolved options.
+*
+* If `options.mergeOptions` is provided, it owns the merge behavior; otherwise
+* options are shallow-merged.
+*
+* @example
+* ```ts
+* const options = table_mergeOptions(table, nextOptions)
+* ```
+*/
+function table_mergeOptions(table, newOptions) {
+	if (table.options.mergeOptions) return table.options.mergeOptions(table.options, newOptions);
+	return {
+		...table.options,
+		...newOptions
+	};
+}
+/**
+* Updates the table options object.
+*
+* The updater receives the current resolved options and the merged result is
+* immediately assigned to the table instance.
+*
+* @example
+* ```ts
+* table_setOptions(table, (old) => old)
+* ```
+*/
+function table_setOptions(table, updater) {
+	const newOptions = require_utils.functionalUpdate(updater, table.options);
+	const { features, atoms, initialState } = table.options;
+	const mergedOptions = Object.assign(table_mergeOptions(table, newOptions), {
+		features,
+		atoms,
+		initialState
+	});
+	if (table.optionsStore) table.optionsStore.set(() => mergedOptions);
+	else table.options = mergedOptions;
+	table_syncExternalStateToBaseAtoms(table);
+}
+
+//#endregion
+exports.table_mergeOptions = table_mergeOptions;
+exports.table_reset = table_reset;
+exports.table_setOptions = table_setOptions;
+exports.table_syncExternalStateToBaseAtoms = table_syncExternalStateToBaseAtoms;
+//# sourceMappingURL=coreTablesFeature.utils.cjs.map

package/dist/core/table/coreTablesFeature.utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"coreTablesFeature.utils.cjs","names":["cloneState","functionalUpdate"],"sources":["../../../src/core/table/coreTablesFeature.utils.ts"],"sourcesContent":["import { cloneState, functionalUpdate } from '../../utils'\nimport type { RowData, Updater } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Table_Internal } from '../../types/Table'\nimport type { TableOptions } from '../../types/TableOptions'\n\n/**\n * Synchronizes externally controlled state slices into the table's base atoms.\n *\n * This keeps legacy `options.state` values reflected in the atom graph so\n * derived atoms, stores, and table APIs read a consistent snapshot.\n *\n * @example\n * ```ts\n * table_syncExternalStateToBaseAtoms(table)\n * ```\n */\nexport function table_syncExternalStateToBaseAtoms<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): void {\n  const state = table.options.state\n  if (!state) {\n    return\n  }\n\n  table._reactivity.batch(() => {\n    for (const key in state) {\n      const baseAtom = (table.baseAtoms as Record<string, any>)[key]\n      if (!baseAtom) {\n        continue\n      }\n\n      const externalState = state[key as keyof typeof state]\n      if (externalState !== baseAtom.get()) {\n        baseAtom.set(() => externalState)\n      }\n    }\n  })\n}\n\n/**\n * Resets all internal table base atoms to `table.initialState`.\n *\n * This resets internally owned state slices in a single reactivity batch. Use\n * feature-specific reset APIs when a slice may be externally owned.\n *\n * @example\n * ```ts\n * table_reset(table)\n * ```\n */\nexport function table_reset<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): void {\n  const snap = cloneState(table.initialState)\n  table._reactivity.batch(() => {\n    const keys = Object.keys(snap) as Array<keyof typeof snap>\n    for (let i = 0; i < keys.length; i++) {\n      const key = keys[i]!\n      ;(table.baseAtoms as any)[key].set(snap[key])\n    }\n  })\n}\n\n/**\n * Merges new table options with the current resolved options.\n *\n * If `options.mergeOptions` is provided, it owns the merge behavior; otherwise\n * options are shallow-merged.\n *\n * @example\n * ```ts\n * const options = table_mergeOptions(table, nextOptions)\n * ```\n */\nexport function table_mergeOptions<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  newOptions: TableOptions<TFeatures, TData>,\n) {\n  if (table.options.mergeOptions) {\n    return table.options.mergeOptions(table.options, newOptions)\n  }\n\n  return {\n    ...table.options,\n    ...newOptions,\n  }\n}\n\n/**\n * Updates the table options object.\n *\n * The updater receives the current resolved options and the merged result is\n * immediately assigned to the table instance.\n *\n * @example\n * ```ts\n * table_setOptions(table, (old) => old)\n * ```\n */\nexport function table_setOptions<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  updater: Updater<TableOptions<TFeatures, TData>>,\n): void {\n  const newOptions = functionalUpdate(updater, table.options)\n  // table static options that should never change after initialization\n  const { features, atoms, initialState } = table.options\n  const mergedOptions = Object.assign(table_mergeOptions(table, newOptions), {\n    // Once the table instance is created those properties should never change after initialization,\n    // so we assign them back preserving the `table_mergeOptions` object reference\n    features,\n    atoms,\n    initialState,\n  })\n\n  if (table.optionsStore) {\n    table.optionsStore.set(() => mergedOptions)\n  } else {\n    table.options = mergedOptions\n  }\n  table_syncExternalStateToBaseAtoms(table)\n}\n"],"mappings":";;;;;;;;;;;;;;AAiBA,SAAgB,mCAGd,OAA+C;CAC/C,MAAM,QAAQ,MAAM,QAAQ;CAC5B,IAAI,CAAC,OACH;CAGF,MAAM,YAAY,YAAY;EAC5B,KAAK,MAAM,OAAO,OAAO;GACvB,MAAM,WAAY,MAAM,UAAkC;GAC1D,IAAI,CAAC,UACH;GAGF,MAAM,gBAAgB,MAAM;GAC5B,IAAI,kBAAkB,SAAS,IAAI,GACjC,SAAS,UAAU,aAAa;EAEpC;CACF,CAAC;AACH;;;;;;;;;;;;AAaA,SAAgB,YAGd,OAA+C;CAC/C,MAAM,OAAOA,yBAAW,MAAM,YAAY;CAC1C,MAAM,YAAY,YAAY;EAC5B,MAAM,OAAO,OAAO,KAAK,IAAI;EAC7B,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;GACpC,MAAM,MAAM,KAAK;GAChB,AAAC,MAAM,UAAkB,IAAI,CAAC,IAAI,KAAK,IAAI;EAC9C;CACF,CAAC;AACH;;;;;;;;;;;;AAaA,SAAgB,mBAId,OACA,YACA;CACA,IAAI,MAAM,QAAQ,cAChB,OAAO,MAAM,QAAQ,aAAa,MAAM,SAAS,UAAU;CAG7D,OAAO;EACL,GAAG,MAAM;EACT,GAAG;CACL;AACF;;;;;;;;;;;;AAaA,SAAgB,iBAId,OACA,SACM;CACN,MAAM,aAAaC,+BAAiB,SAAS,MAAM,OAAO;CAE1D,MAAM,EAAE,UAAU,OAAO,iBAAiB,MAAM;CAChD,MAAM,gBAAgB,OAAO,OAAO,mBAAmB,OAAO,UAAU,GAAG;EAGzE;EACA;EACA;CACF,CAAC;CAED,IAAI,MAAM,cACR,MAAM,aAAa,UAAU,aAAa;MAE1C,MAAM,UAAU;CAElB,mCAAmC,KAAK;AAC1C"}

package/dist/core/table/coreTablesFeature.utils.d.cts

@@ -0,0 +1,57 @@
+import { RowData, Updater } from "../../types/type-utils.cjs";
+import { TableOptions } from "../../types/TableOptions.cjs";
+import { Table_Internal } from "../../types/Table.cjs";
+import { TableFeatures } from "../../types/TableFeatures.cjs";
+
+//#region src/core/table/coreTablesFeature.utils.d.ts
+/**
+ * Synchronizes externally controlled state slices into the table's base atoms.
+ *
+ * This keeps legacy `options.state` values reflected in the atom graph so
+ * derived atoms, stores, and table APIs read a consistent snapshot.
+ *
+ * @example
+ * ```ts
+ * table_syncExternalStateToBaseAtoms(table)
+ * ```
+ */
+declare function table_syncExternalStateToBaseAtoms<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): void;
+/**
+ * Resets all internal table base atoms to `table.initialState`.
+ *
+ * This resets internally owned state slices in a single reactivity batch. Use
+ * feature-specific reset APIs when a slice may be externally owned.
+ *
+ * @example
+ * ```ts
+ * table_reset(table)
+ * ```
+ */
+declare function table_reset<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): void;
+/**
+ * Merges new table options with the current resolved options.
+ *
+ * If `options.mergeOptions` is provided, it owns the merge behavior; otherwise
+ * options are shallow-merged.
+ *
+ * @example
+ * ```ts
+ * const options = table_mergeOptions(table, nextOptions)
+ * ```
+ */
+declare function table_mergeOptions<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, newOptions: TableOptions<TFeatures, TData>): TableOptions<TFeatures, TData>;
+/**
+ * Updates the table options object.
+ *
+ * The updater receives the current resolved options and the merged result is
+ * immediately assigned to the table instance.
+ *
+ * @example
+ * ```ts
+ * table_setOptions(table, (old) => old)
+ * ```
+ */
+declare function table_setOptions<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, updater: Updater<TableOptions<TFeatures, TData>>): void;
+//#endregion
+export { table_mergeOptions, table_reset, table_setOptions, table_syncExternalStateToBaseAtoms };
+//# sourceMappingURL=coreTablesFeature.utils.d.cts.map

package/dist/core/table/coreTablesFeature.utils.d.ts

@@ -0,0 +1,57 @@
+import { RowData, Updater } from "../../types/type-utils.js";
+import { TableOptions } from "../../types/TableOptions.js";
+import { Table_Internal } from "../../types/Table.js";
+import { TableFeatures } from "../../types/TableFeatures.js";
+
+//#region src/core/table/coreTablesFeature.utils.d.ts
+/**
+ * Synchronizes externally controlled state slices into the table's base atoms.
+ *
+ * This keeps legacy `options.state` values reflected in the atom graph so
+ * derived atoms, stores, and table APIs read a consistent snapshot.
+ *
+ * @example
+ * ```ts
+ * table_syncExternalStateToBaseAtoms(table)
+ * ```
+ */
+declare function table_syncExternalStateToBaseAtoms<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): void;
+/**
+ * Resets all internal table base atoms to `table.initialState`.
+ *
+ * This resets internally owned state slices in a single reactivity batch. Use
+ * feature-specific reset APIs when a slice may be externally owned.
+ *
+ * @example
+ * ```ts
+ * table_reset(table)
+ * ```
+ */
+declare function table_reset<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): void;
+/**
+ * Merges new table options with the current resolved options.
+ *
+ * If `options.mergeOptions` is provided, it owns the merge behavior; otherwise
+ * options are shallow-merged.
+ *
+ * @example
+ * ```ts
+ * const options = table_mergeOptions(table, nextOptions)
+ * ```
+ */
+declare function table_mergeOptions<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, newOptions: TableOptions<TFeatures, TData>): TableOptions<TFeatures, TData>;
+/**
+ * Updates the table options object.
+ *
+ * The updater receives the current resolved options and the merged result is
+ * immediately assigned to the table instance.
+ *
+ * @example
+ * ```ts
+ * table_setOptions(table, (old) => old)
+ * ```
+ */
+declare function table_setOptions<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, updater: Updater<TableOptions<TFeatures, TData>>): void;
+//#endregion
+export { table_mergeOptions, table_reset, table_setOptions, table_syncExternalStateToBaseAtoms };
+//# sourceMappingURL=coreTablesFeature.utils.d.ts.map