@tanstack/table-core 9.0.0-beta.52 → 9.0.0-beta.53

package/dist/core/table/coreTablesFeature.cjs

@@ -1,17 +0,0 @@
-const require_utils = require('../../utils.cjs');
-const require_coreTablesFeature_utils = require('./coreTablesFeature.utils.cjs');
-
-//#region src/core/table/coreTablesFeature.ts
-/**
-* Core feature that adds base table instance APIs such as reset and setOptions.
-*/
-const coreTablesFeature = { constructTableAPIs: (table) => {
-	require_utils.assignTableAPIs("coreTablesFeature", table, {
-		table_reset: { fn: () => require_coreTablesFeature_utils.table_reset(table) },
-		table_setOptions: { fn: (updater) => require_coreTablesFeature_utils.table_setOptions(table, updater) }
-	});
-} };
-
-//#endregion
-exports.coreTablesFeature = coreTablesFeature;
-//# sourceMappingURL=coreTablesFeature.cjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"coreTablesFeature.cjs","names":["table_reset","table_setOptions"],"sources":["../../../src/core/table/coreTablesFeature.ts"],"sourcesContent":["import { assignTableAPIs } from '../../utils'\nimport { table_reset, table_setOptions } from './coreTablesFeature.utils'\nimport type { TableFeature } from '../../types/TableFeatures'\n\n/**\n * Core feature that adds base table instance APIs such as reset and setOptions.\n */\nexport const coreTablesFeature: TableFeature = {\n  constructTableAPIs: (table) => {\n    assignTableAPIs('coreTablesFeature', table, {\n      table_reset: {\n        fn: () => table_reset(table),\n      },\n      table_setOptions: {\n        fn: (updater) => table_setOptions(table, updater),\n      },\n    })\n  },\n}\n"],"mappings":";;;;;;;AAOA,MAAa,oBAAkC,EAC7C,qBAAqB,UAAU;CAC7B,8BAAgB,qBAAqB,OAAO;EAC1C,aAAa,EACX,UAAUA,4CAAY,KAAK,EAC7B;EACA,kBAAkB,EAChB,KAAK,YAAYC,iDAAiB,OAAO,OAAO,EAClD;CACF,CAAC;AACH,EACF"}

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

@@ -1,10 +0,0 @@
-import { TableFeature } from "../../types/TableFeatures.cjs";
-
-//#region src/core/table/coreTablesFeature.d.ts
-/**
- * Core feature that adds base table instance APIs such as reset and setOptions.
- */
-declare const coreTablesFeature: TableFeature;
-//#endregion
-export { coreTablesFeature };
-//# sourceMappingURL=coreTablesFeature.d.cts.map

package/dist/core/table/coreTablesFeature.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"coreTablesFeature.js","names":[],"sources":["../../../src/core/table/coreTablesFeature.ts"],"sourcesContent":["import { assignTableAPIs } from '../../utils'\nimport { table_reset, table_setOptions } from './coreTablesFeature.utils'\nimport type { TableFeature } from '../../types/TableFeatures'\n\n/**\n * Core feature that adds base table instance APIs such as reset and setOptions.\n */\nexport const coreTablesFeature: TableFeature = {\n  constructTableAPIs: (table) => {\n    assignTableAPIs('coreTablesFeature', table, {\n      table_reset: {\n        fn: () => table_reset(table),\n      },\n      table_setOptions: {\n        fn: (updater) => table_setOptions(table, updater),\n      },\n    })\n  },\n}\n"],"mappings":";;;;;;;AAOA,MAAa,oBAAkC,EAC7C,qBAAqB,UAAU;CAC7B,gBAAgB,qBAAqB,OAAO;EAC1C,aAAa,EACX,UAAU,YAAY,KAAK,EAC7B;EACA,kBAAkB,EAChB,KAAK,YAAY,iBAAiB,OAAO,OAAO,EAClD;CACF,CAAC;AACH,EACF"}

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

@@ -1,199 +0,0 @@
-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<in out TFeatures extends TableFeatures, in out 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`
- * 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<Exclude<TableState_All[K], undefined>> };
-type Atoms_All = { [K in keyof TableState_All]?: ReadonlyAtom<TableState_All[K]> };
-type ExternalAtoms_All = Partial<{ [K in keyof TableState_All]: Atom<Exclude<TableState_All[K], undefined>> }>;
-interface TableOptions_Table<in out TFeatures extends TableFeatures, in out 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<in out TFeatures extends TableFeatures, in out 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<in out TFeatures extends TableFeatures, in out 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. After resetting internal atoms, this also invokes feature
-   * reset hooks for mutable, transient table-instance data.
-   */
-  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.utils.cjs

@@ -1,120 +0,0 @@
-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 !== table._reactivity.untrack(() => baseAtom.get())) baseAtom.set(() => externalState);
-		}
-	});
-}
-/**
-* Resets all internal table base atoms to `table.initialState`, then clears
-* transient instance data through registered feature reset hooks.
-*
-* 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]);
-		}
-	});
-	const features = Object.values(table._features);
-	for (let i = 0; i < features.length; i++) features[i].resetTableInstanceData?.(table);
-}
-/**
-* Merges new table options with the current resolved options.
-*
-* If `options.mergeOptions` is provided, it owns the merge behavior; otherwise
-* options are shallow-merged. Static options that should never change after
-* initialization are restored on a fresh object so framework merge helpers may
-* return readonly getter/proxy objects.
-*
-* @example
-* ```ts
-* const options = table_mergeOptions(table, nextOptions)
-* ```
-*/
-function table_mergeOptions(table, newOptions) {
-	const { features, atoms, initialState } = table.options;
-	if (!table.options.mergeOptions) return {
-		...table.options,
-		...newOptions,
-		features,
-		atoms,
-		initialState
-	};
-	const mergedOptions = table.options.mergeOptions(table.options, newOptions);
-	const descriptors = { ...Object.getOwnPropertyDescriptors(mergedOptions) };
-	return Object.defineProperties(Object.create(Object.getPrototypeOf(mergedOptions)), {
-		...descriptors,
-		features: {
-			value: features,
-			enumerable: true,
-			configurable: true,
-			writable: true
-		},
-		atoms: {
-			value: atoms,
-			enumerable: true,
-			configurable: true,
-			writable: true
-		},
-		initialState: {
-			value: initialState,
-			enumerable: true,
-			configurable: true,
-			writable: true
-		}
-	});
-}
-/**
-* 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 mergedOptions = table_mergeOptions(table, require_utils.functionalUpdate(updater, table.options));
-	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

@@ -1 +0,0 @@
-{"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 !== table._reactivity.untrack(() => baseAtom.get())) {\n        baseAtom.set(() => externalState)\n      }\n    }\n  })\n}\n\n/**\n * Resets all internal table base atoms to `table.initialState`, then clears\n * transient instance data through registered feature reset hooks.\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  const features = Object.values(table._features)\n  for (let i = 0; i < features.length; i++) {\n    features[i]!.resetTableInstanceData?.(table)\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. Static options that should never change after\n * initialization are restored on a fresh object so framework merge helpers may\n * return readonly getter/proxy objects.\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  const { features, atoms, initialState } = table.options\n\n  // simple merge if no mergeOptions is provided - performant\n  if (!table.options.mergeOptions) {\n    return {\n      ...table.options,\n      ...newOptions,\n      features,\n      atoms,\n      initialState,\n    }\n  }\n\n  // else use the mergeOptions function and preserve getters/setters\n  const mergedOptions = table.options.mergeOptions(\n    table.options as TableOptions<TFeatures, TData>,\n    newOptions,\n  )\n  const descriptors: PropertyDescriptorMap = {\n    ...Object.getOwnPropertyDescriptors(mergedOptions),\n  }\n\n  return Object.defineProperties(\n    Object.create(Object.getPrototypeOf(mergedOptions)),\n    {\n      ...descriptors,\n      features: {\n        value: features,\n        enumerable: true,\n        configurable: true,\n        writable: true,\n      },\n      atoms: {\n        value: atoms,\n        enumerable: true,\n        configurable: true,\n        writable: true,\n      },\n      initialState: {\n        value: initialState,\n        enumerable: true,\n        configurable: true,\n        writable: true,\n      },\n    },\n  ) as TableOptions<TFeatures, TData>\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(\n    updater,\n    table.options as TableOptions<TFeatures, TData>,\n  )\n  const mergedOptions = table_mergeOptions(table, newOptions)\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,MAAM,YAAY,cAAc,SAAS,IAAI,CAAC,GAClE,SAAS,UAAU,aAAa;EAEpC;CACF,CAAC;AACH;;;;;;;;;;;;;AAcA,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;CAED,MAAM,WAAW,OAAO,OAAO,MAAM,SAAS;CAC9C,KAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KACnC,SAAS,EAAE,CAAE,yBAAyB,KAAK;AAE/C;;;;;;;;;;;;;;AAeA,SAAgB,mBAId,OACA,YACA;CACA,MAAM,EAAE,UAAU,OAAO,iBAAiB,MAAM;CAGhD,IAAI,CAAC,MAAM,QAAQ,cACjB,OAAO;EACL,GAAG,MAAM;EACT,GAAG;EACH;EACA;EACA;CACF;CAIF,MAAM,gBAAgB,MAAM,QAAQ,aAClC,MAAM,SACN,UACF;CACA,MAAM,cAAqC,EACzC,GAAG,OAAO,0BAA0B,aAAa,EACnD;CAEA,OAAO,OAAO,iBACZ,OAAO,OAAO,OAAO,eAAe,aAAa,CAAC,GAClD;EACE,GAAG;EACH,UAAU;GACR,OAAO;GACP,YAAY;GACZ,cAAc;GACd,UAAU;EACZ;EACA,OAAO;GACL,OAAO;GACP,YAAY;GACZ,cAAc;GACd,UAAU;EACZ;EACA,cAAc;GACZ,OAAO;GACP,YAAY;GACZ,cAAc;GACd,UAAU;EACZ;CACF,CACF;AACF;;;;;;;;;;;;AAaA,SAAgB,iBAId,OACA,SACM;CAKN,MAAM,gBAAgB,mBAAmB,OAJtBC,+BACjB,SACA,MAAM,OAEiD,CAAC;CAE1D,IAAI,MAAM,cACR,MAAM,aAAa,UAAU,aAAa;MAE1C,MAAM,UAAU;CAElB,mCAAmC,KAAK;AAC1C"}

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

@@ -1,60 +0,0 @@
-import { RowData, Updater } from "../../types/type-utils.cjs";
-import { TableOptions } from "../../types/TableOptions.cjs";
-import { Table } 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<TFeatures, TData>): void;
-/**
- * Resets all internal table base atoms to `table.initialState`, then clears
- * transient instance data through registered feature reset hooks.
- *
- * 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<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. Static options that should never change after
- * initialization are restored on a fresh object so framework merge helpers may
- * return readonly getter/proxy objects.
- *
- * @example
- * ```ts
- * const options = table_mergeOptions(table, nextOptions)
- * ```
- */
-declare function table_mergeOptions<TFeatures extends TableFeatures, TData extends RowData>(table: Table<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<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.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"coreTablesFeature.utils.js","names":[],"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 !== table._reactivity.untrack(() => baseAtom.get())) {\n        baseAtom.set(() => externalState)\n      }\n    }\n  })\n}\n\n/**\n * Resets all internal table base atoms to `table.initialState`, then clears\n * transient instance data through registered feature reset hooks.\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  const features = Object.values(table._features)\n  for (let i = 0; i < features.length; i++) {\n    features[i]!.resetTableInstanceData?.(table)\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. Static options that should never change after\n * initialization are restored on a fresh object so framework merge helpers may\n * return readonly getter/proxy objects.\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  const { features, atoms, initialState } = table.options\n\n  // simple merge if no mergeOptions is provided - performant\n  if (!table.options.mergeOptions) {\n    return {\n      ...table.options,\n      ...newOptions,\n      features,\n      atoms,\n      initialState,\n    }\n  }\n\n  // else use the mergeOptions function and preserve getters/setters\n  const mergedOptions = table.options.mergeOptions(\n    table.options as TableOptions<TFeatures, TData>,\n    newOptions,\n  )\n  const descriptors: PropertyDescriptorMap = {\n    ...Object.getOwnPropertyDescriptors(mergedOptions),\n  }\n\n  return Object.defineProperties(\n    Object.create(Object.getPrototypeOf(mergedOptions)),\n    {\n      ...descriptors,\n      features: {\n        value: features,\n        enumerable: true,\n        configurable: true,\n        writable: true,\n      },\n      atoms: {\n        value: atoms,\n        enumerable: true,\n        configurable: true,\n        writable: true,\n      },\n      initialState: {\n        value: initialState,\n        enumerable: true,\n        configurable: true,\n        writable: true,\n      },\n    },\n  ) as TableOptions<TFeatures, TData>\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(\n    updater,\n    table.options as TableOptions<TFeatures, TData>,\n  )\n  const mergedOptions = table_mergeOptions(table, newOptions)\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,MAAM,YAAY,cAAc,SAAS,IAAI,CAAC,GAClE,SAAS,UAAU,aAAa;EAEpC;CACF,CAAC;AACH;;;;;;;;;;;;;AAcA,SAAgB,YAGd,OAA+C;CAC/C,MAAM,OAAO,WAAW,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;CAED,MAAM,WAAW,OAAO,OAAO,MAAM,SAAS;CAC9C,KAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KACnC,SAAS,EAAE,CAAE,yBAAyB,KAAK;AAE/C;;;;;;;;;;;;;;AAeA,SAAgB,mBAId,OACA,YACA;CACA,MAAM,EAAE,UAAU,OAAO,iBAAiB,MAAM;CAGhD,IAAI,CAAC,MAAM,QAAQ,cACjB,OAAO;EACL,GAAG,MAAM;EACT,GAAG;EACH;EACA;EACA;CACF;CAIF,MAAM,gBAAgB,MAAM,QAAQ,aAClC,MAAM,SACN,UACF;CACA,MAAM,cAAqC,EACzC,GAAG,OAAO,0BAA0B,aAAa,EACnD;CAEA,OAAO,OAAO,iBACZ,OAAO,OAAO,OAAO,eAAe,aAAa,CAAC,GAClD;EACE,GAAG;EACH,UAAU;GACR,OAAO;GACP,YAAY;GACZ,cAAc;GACd,UAAU;EACZ;EACA,OAAO;GACL,OAAO;GACP,YAAY;GACZ,cAAc;GACd,UAAU;EACZ;EACA,cAAc;GACZ,OAAO;GACP,YAAY;GACZ,cAAc;GACd,UAAU;EACZ;CACF,CACF;AACF;;;;;;;;;;;;AAaA,SAAgB,iBAId,OACA,SACM;CAKN,MAAM,gBAAgB,mBAAmB,OAJtB,iBACjB,SACA,MAAM,OAEiD,CAAC;CAE1D,IAAI,MAAM,cACR,MAAM,aAAa,UAAU,aAAa;MAE1C,MAAM,UAAU;CAElB,mCAAmC,KAAK;AAC1C"}

package/dist/experimental-worker-plugin.cjs

@@ -1,14 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_tableWorkerProtocol = require('./worker/tableWorkerProtocol.cjs');
-const require_initTableWorker = require('./worker/initTableWorker.cjs');
-const require_createTableWorker = require('./worker/createTableWorker.cjs');
-const require_createWorkerRowModel = require('./worker/createWorkerRowModel.cjs');
-
-exports.createTableWorker = require_createTableWorker.createTableWorker;
-exports.createWorkerRowModel = require_createWorkerRowModel.createWorkerRowModel;
-exports.getTableWorkerBridge = require_createTableWorker.getTableWorkerBridge;
-exports.initTableWorker = require_initTableWorker.initTableWorker;
-exports.syncTableWorker = require_createTableWorker.syncTableWorker;
-exports.tableWorkerPipeline = require_tableWorkerProtocol.tableWorkerPipeline;
-exports.tableWorkerStageStateDeps = require_tableWorkerProtocol.tableWorkerStageStateDeps;
-exports.workerRowModelsFeature = require_createTableWorker.workerRowModelsFeature;

package/dist/experimental-worker-plugin.d.cts

@@ -1,5 +0,0 @@
-import { TableState_WorkerRowModels, TableWorkerGroupNode, TableWorkerRequest, TableWorkerResponse, TableWorkerResult, TableWorkerRowNode, TableWorkerStage, TableWorkerStagePayload, tableWorkerPipeline, tableWorkerStageStateDeps } from "./worker/tableWorkerProtocol.cjs";
-import { TableWorkerConfig, initTableWorker } from "./worker/initTableWorker.cjs";
-import { TableWorker, TableWorkerBridge, TableWorkerOptions, createTableWorker, getTableWorkerBridge, syncTableWorker, workerRowModelsFeature } from "./worker/createTableWorker.cjs";
-import { createWorkerRowModel } from "./worker/createWorkerRowModel.cjs";
-export { TableState_WorkerRowModels, TableWorker, TableWorkerBridge, TableWorkerConfig, TableWorkerGroupNode, TableWorkerOptions, TableWorkerRequest, TableWorkerResponse, TableWorkerResult, TableWorkerRowNode, TableWorkerStage, TableWorkerStagePayload, createTableWorker, createWorkerRowModel, getTableWorkerBridge, initTableWorker, syncTableWorker, tableWorkerPipeline, tableWorkerStageStateDeps, workerRowModelsFeature };

package/dist/features/column-faceting/columnFacetingFeature.cjs

@@ -1,55 +0,0 @@
-const require_utils = require('../../utils.cjs');
-const require_columnFacetingFeature_utils = require('./columnFacetingFeature.utils.cjs');
-
-//#region src/features/column-faceting/columnFacetingFeature.ts
-/**
-* Feature that derives faceted row models, unique values, and min/max values for filters.
-*/
-const columnFacetingFeature = {
-	assignColumnPrototype: (prototype, table) => {
-		require_utils.assignPrototypeAPIs("columnFacetingFeature", prototype, table, {
-			column_getFacetedRowModel: {
-				memoDeps: () => [
-					table.getPreFilteredRowModel().rows,
-					table.atoms.columnFilters?.get(),
-					table.atoms.globalFilter?.get(),
-					table.getFilteredRowModel().rows
-				],
-				fn: (column) => require_columnFacetingFeature_utils.column_getFacetedRowModel(column, column.table)
-			},
-			column_getFacetedMinMaxValues: {
-				memoDeps: (column) => [require_utils.callMemoOrStaticFn(column, "getFacetedRowModel", require_columnFacetingFeature_utils.column_getFacetedRowModel, column.table).flatRows],
-				fn: (column) => require_columnFacetingFeature_utils.column_getFacetedMinMaxValues(column, column.table)
-			},
-			column_getFacetedUniqueValues: {
-				memoDeps: (column) => [require_utils.callMemoOrStaticFn(column, "getFacetedRowModel", require_columnFacetingFeature_utils.column_getFacetedRowModel, column.table).flatRows],
-				fn: (column) => require_columnFacetingFeature_utils.column_getFacetedUniqueValues(column, column.table)
-			}
-		});
-	},
-	constructTableAPIs: (table) => {
-		require_utils.assignTableAPIs("columnFacetingFeature", table, {
-			table_getGlobalFacetedRowModel: {
-				memoDeps: () => [
-					table.getPreFilteredRowModel().rows,
-					table.atoms.columnFilters?.get(),
-					table.atoms.globalFilter?.get(),
-					table.getFilteredRowModel().rows
-				],
-				fn: () => require_columnFacetingFeature_utils.table_getGlobalFacetedRowModel(table)
-			},
-			table_getGlobalFacetedMinMaxValues: {
-				memoDeps: () => [require_utils.callMemoOrStaticFn(table, "getGlobalFacetedRowModel", require_columnFacetingFeature_utils.table_getGlobalFacetedRowModel).flatRows],
-				fn: () => require_columnFacetingFeature_utils.table_getGlobalFacetedMinMaxValues(table)
-			},
-			table_getGlobalFacetedUniqueValues: {
-				memoDeps: () => [require_utils.callMemoOrStaticFn(table, "getGlobalFacetedRowModel", require_columnFacetingFeature_utils.table_getGlobalFacetedRowModel).flatRows],
-				fn: () => require_columnFacetingFeature_utils.table_getGlobalFacetedUniqueValues(table)
-			}
-		});
-	}
-};
-
-//#endregion
-exports.columnFacetingFeature = columnFacetingFeature;
-//# sourceMappingURL=columnFacetingFeature.cjs.map

package/dist/features/column-faceting/columnFacetingFeature.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"columnFacetingFeature.cjs","names":["column_getFacetedRowModel","callMemoOrStaticFn","column_getFacetedMinMaxValues","column_getFacetedUniqueValues","table_getGlobalFacetedRowModel","table_getGlobalFacetedMinMaxValues","table_getGlobalFacetedUniqueValues"],"sources":["../../../src/features/column-faceting/columnFacetingFeature.ts"],"sourcesContent":["import {\n  assignPrototypeAPIs,\n  assignTableAPIs,\n  callMemoOrStaticFn,\n} from '../../utils'\nimport {\n  column_getFacetedMinMaxValues,\n  column_getFacetedRowModel,\n  column_getFacetedUniqueValues,\n  table_getGlobalFacetedMinMaxValues,\n  table_getGlobalFacetedRowModel,\n  table_getGlobalFacetedUniqueValues,\n} from './columnFacetingFeature.utils'\nimport type { TableFeature } from '../../types/TableFeatures'\n\n/**\n * Feature that derives faceted row models, unique values, and min/max values for filters.\n */\nexport const columnFacetingFeature: TableFeature = {\n  assignColumnPrototype: (prototype, table) => {\n    assignPrototypeAPIs('columnFacetingFeature', prototype, table, {\n      column_getFacetedRowModel: {\n        memoDeps: () => [\n          table.getPreFilteredRowModel().rows,\n          table.atoms.columnFilters?.get(),\n          table.atoms.globalFilter?.get(),\n          table.getFilteredRowModel().rows,\n        ],\n        fn: (column) => column_getFacetedRowModel(column, column.table),\n      },\n      column_getFacetedMinMaxValues: {\n        memoDeps: (column) => [\n          callMemoOrStaticFn(\n            column,\n            'getFacetedRowModel',\n            column_getFacetedRowModel,\n            column.table,\n          ).flatRows,\n        ],\n        fn: (column) => column_getFacetedMinMaxValues(column, column.table),\n      },\n      column_getFacetedUniqueValues: {\n        memoDeps: (column) => [\n          callMemoOrStaticFn(\n            column,\n            'getFacetedRowModel',\n            column_getFacetedRowModel,\n            column.table,\n          ).flatRows,\n        ],\n        fn: (column) => column_getFacetedUniqueValues(column, column.table),\n      },\n    })\n  },\n\n  constructTableAPIs: (table) => {\n    assignTableAPIs('columnFacetingFeature', table, {\n      table_getGlobalFacetedRowModel: {\n        memoDeps: () => [\n          table.getPreFilteredRowModel().rows,\n          table.atoms.columnFilters?.get(),\n          table.atoms.globalFilter?.get(),\n          table.getFilteredRowModel().rows,\n        ],\n        fn: () => table_getGlobalFacetedRowModel(table),\n      },\n      table_getGlobalFacetedMinMaxValues: {\n        memoDeps: () => [\n          callMemoOrStaticFn(\n            table,\n            'getGlobalFacetedRowModel',\n            table_getGlobalFacetedRowModel,\n          ).flatRows,\n        ],\n        fn: () => table_getGlobalFacetedMinMaxValues(table),\n      },\n      table_getGlobalFacetedUniqueValues: {\n        memoDeps: () => [\n          callMemoOrStaticFn(\n            table,\n            'getGlobalFacetedRowModel',\n            table_getGlobalFacetedRowModel,\n          ).flatRows,\n        ],\n        fn: () => table_getGlobalFacetedUniqueValues(table),\n      },\n    })\n  },\n}\n"],"mappings":";;;;;;;AAkBA,MAAa,wBAAsC;CACjD,wBAAwB,WAAW,UAAU;EAC3C,kCAAoB,yBAAyB,WAAW,OAAO;GAC7D,2BAA2B;IACzB,gBAAgB;KACd,MAAM,uBAAuB,CAAC,CAAC;KAC/B,MAAM,MAAM,eAAe,IAAI;KAC/B,MAAM,MAAM,cAAc,IAAI;KAC9B,MAAM,oBAAoB,CAAC,CAAC;IAC9B;IACA,KAAK,WAAWA,8DAA0B,QAAQ,OAAO,KAAK;GAChE;GACA,+BAA+B;IAC7B,WAAW,WAAW,CACpBC,iCACE,QACA,sBACAD,+DACA,OAAO,KACT,CAAC,CAAC,QACJ;IACA,KAAK,WAAWE,kEAA8B,QAAQ,OAAO,KAAK;GACpE;GACA,+BAA+B;IAC7B,WAAW,WAAW,CACpBD,iCACE,QACA,sBACAD,+DACA,OAAO,KACT,CAAC,CAAC,QACJ;IACA,KAAK,WAAWG,kEAA8B,QAAQ,OAAO,KAAK;GACpE;EACF,CAAC;CACH;CAEA,qBAAqB,UAAU;EAC7B,8BAAgB,yBAAyB,OAAO;GAC9C,gCAAgC;IAC9B,gBAAgB;KACd,MAAM,uBAAuB,CAAC,CAAC;KAC/B,MAAM,MAAM,eAAe,IAAI;KAC/B,MAAM,MAAM,cAAc,IAAI;KAC9B,MAAM,oBAAoB,CAAC,CAAC;IAC9B;IACA,UAAUC,mEAA+B,KAAK;GAChD;GACA,oCAAoC;IAClC,gBAAgB,CACdH,iCACE,OACA,4BACAG,kEACF,CAAC,CAAC,QACJ;IACA,UAAUC,uEAAmC,KAAK;GACpD;GACA,oCAAoC;IAClC,gBAAgB,CACdJ,iCACE,OACA,4BACAG,kEACF,CAAC,CAAC,QACJ;IACA,UAAUE,uEAAmC,KAAK;GACpD;EACF,CAAC;CACH;AACF"}

package/dist/features/column-faceting/columnFacetingFeature.d.cts

@@ -1,10 +0,0 @@
-import { TableFeature } from "../../types/TableFeatures.cjs";
-
-//#region src/features/column-faceting/columnFacetingFeature.d.ts
-/**
- * Feature that derives faceted row models, unique values, and min/max values for filters.
- */
-declare const columnFacetingFeature: TableFeature;
-//#endregion
-export { columnFacetingFeature };
-//# sourceMappingURL=columnFacetingFeature.d.cts.map

package/dist/features/column-faceting/columnFacetingFeature.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"columnFacetingFeature.js","names":[],"sources":["../../../src/features/column-faceting/columnFacetingFeature.ts"],"sourcesContent":["import {\n  assignPrototypeAPIs,\n  assignTableAPIs,\n  callMemoOrStaticFn,\n} from '../../utils'\nimport {\n  column_getFacetedMinMaxValues,\n  column_getFacetedRowModel,\n  column_getFacetedUniqueValues,\n  table_getGlobalFacetedMinMaxValues,\n  table_getGlobalFacetedRowModel,\n  table_getGlobalFacetedUniqueValues,\n} from './columnFacetingFeature.utils'\nimport type { TableFeature } from '../../types/TableFeatures'\n\n/**\n * Feature that derives faceted row models, unique values, and min/max values for filters.\n */\nexport const columnFacetingFeature: TableFeature = {\n  assignColumnPrototype: (prototype, table) => {\n    assignPrototypeAPIs('columnFacetingFeature', prototype, table, {\n      column_getFacetedRowModel: {\n        memoDeps: () => [\n          table.getPreFilteredRowModel().rows,\n          table.atoms.columnFilters?.get(),\n          table.atoms.globalFilter?.get(),\n          table.getFilteredRowModel().rows,\n        ],\n        fn: (column) => column_getFacetedRowModel(column, column.table),\n      },\n      column_getFacetedMinMaxValues: {\n        memoDeps: (column) => [\n          callMemoOrStaticFn(\n            column,\n            'getFacetedRowModel',\n            column_getFacetedRowModel,\n            column.table,\n          ).flatRows,\n        ],\n        fn: (column) => column_getFacetedMinMaxValues(column, column.table),\n      },\n      column_getFacetedUniqueValues: {\n        memoDeps: (column) => [\n          callMemoOrStaticFn(\n            column,\n            'getFacetedRowModel',\n            column_getFacetedRowModel,\n            column.table,\n          ).flatRows,\n        ],\n        fn: (column) => column_getFacetedUniqueValues(column, column.table),\n      },\n    })\n  },\n\n  constructTableAPIs: (table) => {\n    assignTableAPIs('columnFacetingFeature', table, {\n      table_getGlobalFacetedRowModel: {\n        memoDeps: () => [\n          table.getPreFilteredRowModel().rows,\n          table.atoms.columnFilters?.get(),\n          table.atoms.globalFilter?.get(),\n          table.getFilteredRowModel().rows,\n        ],\n        fn: () => table_getGlobalFacetedRowModel(table),\n      },\n      table_getGlobalFacetedMinMaxValues: {\n        memoDeps: () => [\n          callMemoOrStaticFn(\n            table,\n            'getGlobalFacetedRowModel',\n            table_getGlobalFacetedRowModel,\n          ).flatRows,\n        ],\n        fn: () => table_getGlobalFacetedMinMaxValues(table),\n      },\n      table_getGlobalFacetedUniqueValues: {\n        memoDeps: () => [\n          callMemoOrStaticFn(\n            table,\n            'getGlobalFacetedRowModel',\n            table_getGlobalFacetedRowModel,\n          ).flatRows,\n        ],\n        fn: () => table_getGlobalFacetedUniqueValues(table),\n      },\n    })\n  },\n}\n"],"mappings":";;;;;;;AAkBA,MAAa,wBAAsC;CACjD,wBAAwB,WAAW,UAAU;EAC3C,oBAAoB,yBAAyB,WAAW,OAAO;GAC7D,2BAA2B;IACzB,gBAAgB;KACd,MAAM,uBAAuB,CAAC,CAAC;KAC/B,MAAM,MAAM,eAAe,IAAI;KAC/B,MAAM,MAAM,cAAc,IAAI;KAC9B,MAAM,oBAAoB,CAAC,CAAC;IAC9B;IACA,KAAK,WAAW,0BAA0B,QAAQ,OAAO,KAAK;GAChE;GACA,+BAA+B;IAC7B,WAAW,WAAW,CACpB,mBACE,QACA,sBACA,2BACA,OAAO,KACT,CAAC,CAAC,QACJ;IACA,KAAK,WAAW,8BAA8B,QAAQ,OAAO,KAAK;GACpE;GACA,+BAA+B;IAC7B,WAAW,WAAW,CACpB,mBACE,QACA,sBACA,2BACA,OAAO,KACT,CAAC,CAAC,QACJ;IACA,KAAK,WAAW,8BAA8B,QAAQ,OAAO,KAAK;GACpE;EACF,CAAC;CACH;CAEA,qBAAqB,UAAU;EAC7B,gBAAgB,yBAAyB,OAAO;GAC9C,gCAAgC;IAC9B,gBAAgB;KACd,MAAM,uBAAuB,CAAC,CAAC;KAC/B,MAAM,MAAM,eAAe,IAAI;KAC/B,MAAM,MAAM,cAAc,IAAI;KAC9B,MAAM,oBAAoB,CAAC,CAAC;IAC9B;IACA,UAAU,+BAA+B,KAAK;GAChD;GACA,oCAAoC;IAClC,gBAAgB,CACd,mBACE,OACA,4BACA,8BACF,CAAC,CAAC,QACJ;IACA,UAAU,mCAAmC,KAAK;GACpD;GACA,oCAAoC;IAClC,gBAAgB,CACd,mBACE,OACA,4BACA,8BACF,CAAC,CAAC,QACJ;IACA,UAAU,mCAAmC,KAAK;GACpD;EACF,CAAC;CACH;AACF"}

package/dist/features/column-faceting/columnFacetingFeature.types.d.cts

@@ -1,67 +0,0 @@
-import { RowData } from "../../types/type-utils.cjs";
-import { RowModel } from "../../core/row-models/coreRowModelsFeature.types.cjs";
-import { TableFeatures } from "../../types/TableFeatures.cjs";
-
-//#region src/features/column-faceting/columnFacetingFeature.types.d.ts
-interface Column_ColumnFaceting<in out TFeatures extends TableFeatures, in out TData extends RowData> {
-  /**
-   * Computes min/max numeric facet values for this column.
-   */
-  getFacetedMinMaxValues: () => undefined | [number, number];
-  /**
-   * Computes the row model used to derive this column's facet values.
-   *
-   * Other column filters are applied, while this column's own filter is
-   * excluded.
-   */
-  getFacetedRowModel: () => RowModel<TFeatures, TData>;
-  /**
-   * Computes unique facet values and occurrence counts for this column.
-   */
-  getFacetedUniqueValues: () => Map<any, number>;
-}
-interface Table_RowModels_Faceted<in out TFeatures extends TableFeatures, in out TData extends RowData> {
-  /**
-   * Computes min/max numeric facet values for the active faceting context.
-   *
-   * Requires a `facetedMinMaxValues` row-model factory on the `features` option.
-   */
-  getFacetedMinMaxValues: () => undefined | [number, number];
-  /**
-   * Computes the row model used to derive facet values.
-   *
-   * Requires a `facetedRowModel` row-model factory on the `features` option.
-   */
-  getFacetedRowModel: () => RowModel<TFeatures, TData>;
-  /**
-   * Computes unique facet values and occurrence counts.
-   *
-   * Requires a `facetedUniqueValues` row-model factory on the `features` option.
-   */
-  getFacetedUniqueValues: () => Map<any, number>;
-}
-interface CachedRowModel_Faceted<in out TFeatures extends TableFeatures, in out TData extends RowData> {
-  facetedRowModels?: Record<string, () => RowModel<TFeatures, TData>>;
-  facetedMinMaxValues?: Record<string, () => undefined | [number, number]>;
-  facetedUniqueValues?: Record<string, () => Map<any, number>>;
-  globalFacetedRowModel?: () => RowModel<TFeatures, TData>;
-  globalFacetedMinMaxValues?: () => undefined | [number, number];
-  globalFacetedUniqueValues?: () => Map<any, number>;
-}
-interface Table_ColumnFaceting<in out TFeatures extends TableFeatures, in out TData extends RowData> {
-  /**
-   * Returns the min and max values for the global filter.
-   */
-  getGlobalFacetedMinMaxValues: () => undefined | [number, number];
-  /**
-   * Computes the row model used to derive global facet values.
-   */
-  getGlobalFacetedRowModel: () => RowModel<TFeatures, TData>;
-  /**
-   * Returns the faceted unique values for the global filter.
-   */
-  getGlobalFacetedUniqueValues: () => Map<any, number>;
-}
-//#endregion
-export { CachedRowModel_Faceted, Column_ColumnFaceting, Table_ColumnFaceting, Table_RowModels_Faceted };
-//# sourceMappingURL=columnFacetingFeature.types.d.cts.map