@tanstack/table-core 9.0.0-beta.2 → 9.0.0-beta.20

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

@@ -49,7 +49,9 @@ function table_reset(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.
+* 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
@@ -57,11 +59,37 @@ function table_reset(table) {
 * ```
 */
 function table_mergeOptions(table, newOptions) {
-	if (table.options.mergeOptions) return table.options.mergeOptions(table.options, newOptions);
-	return {
+	const { features, atoms, initialState } = table.options;
+	if (!table.options.mergeOptions) return {
 		...table.options,
-		...newOptions
+		...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.
@@ -75,14 +103,7 @@ function table_mergeOptions(table, newOptions) {
 * ```
 */
 function table_setOptions(table, updater) {
-	const newOptions = require_utils.functionalUpdate(updater, table.options);
-	const { rowModels, features, atoms, initialState } = table.options;
-	const mergedOptions = Object.assign(table_mergeOptions(table, newOptions), {
-		rowModels,
-		features,
-		atoms,
-		initialState
-	});
+	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);

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

@@ -1 +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] as any)\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 { rowModels, 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    rowModels,\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,IAAW;EACrD;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,WAAW,UAAU,OAAO,iBAAiB,MAAM;CAC3D,MAAM,gBAAgB,OAAO,OAAO,mBAAmB,OAAO,UAAU,GAAG;EAGzE;EACA;EACA;EACA;CACF,CAAC;CAED,IAAI,MAAM,cACR,MAAM,aAAa,UAAU,aAAa;MAE1C,MAAM,UAAU;CAElB,mCAAmC,KAAK;AAC1C"}
+{"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. 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,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;;;;;;;;;;;;;;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,7 +1,7 @@
 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";
-import { Table_Internal } from "../../types/Table.cjs";
 
 //#region src/core/table/coreTablesFeature.utils.d.ts
 /**
@@ -15,7 +15,7 @@ import { Table_Internal } from "../../types/Table.cjs";
  * table_syncExternalStateToBaseAtoms(table)
  * ```
  */
-declare function table_syncExternalStateToBaseAtoms<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): void;
+declare function table_syncExternalStateToBaseAtoms<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>): void;
 /**
  * Resets all internal table base atoms to `table.initialState`.
  *
@@ -27,19 +27,21 @@ declare function table_syncExternalStateToBaseAtoms<TFeatures extends TableFeatu
  * table_reset(table)
  * ```
  */
-declare function table_reset<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): void;
+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.
+ * 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_Internal<TFeatures, TData>, newOptions: TableOptions<TFeatures, TData>): TableOptions<TFeatures, TData>;
+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.
  *
@@ -51,7 +53,7 @@ declare function table_mergeOptions<TFeatures extends TableFeatures, TData exten
  * 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;
+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.d.ts

@@ -1,7 +1,7 @@
 import { RowData, Updater } from "../../types/type-utils.js";
 import { TableOptions } from "../../types/TableOptions.js";
+import { Table } from "../../types/Table.js";
 import { TableFeatures } from "../../types/TableFeatures.js";
-import { Table_Internal } from "../../types/Table.js";
 
 //#region src/core/table/coreTablesFeature.utils.d.ts
 /**
@@ -15,7 +15,7 @@ import { Table_Internal } from "../../types/Table.js";
  * table_syncExternalStateToBaseAtoms(table)
  * ```
  */
-declare function table_syncExternalStateToBaseAtoms<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): void;
+declare function table_syncExternalStateToBaseAtoms<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>): void;
 /**
  * Resets all internal table base atoms to `table.initialState`.
  *
@@ -27,19 +27,21 @@ declare function table_syncExternalStateToBaseAtoms<TFeatures extends TableFeatu
  * table_reset(table)
  * ```
  */
-declare function table_reset<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): void;
+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.
+ * 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_Internal<TFeatures, TData>, newOptions: TableOptions<TFeatures, TData>): TableOptions<TFeatures, TData>;
+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.
  *
@@ -51,7 +53,7 @@ declare function table_mergeOptions<TFeatures extends TableFeatures, TData exten
  * 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;
+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.ts.map

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

@@ -49,7 +49,9 @@ function table_reset(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.
+* 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
@@ -57,11 +59,37 @@ function table_reset(table) {
 * ```
 */
 function table_mergeOptions(table, newOptions) {
-	if (table.options.mergeOptions) return table.options.mergeOptions(table.options, newOptions);
-	return {
+	const { features, atoms, initialState } = table.options;
+	if (!table.options.mergeOptions) return {
 		...table.options,
-		...newOptions
+		...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.
@@ -75,14 +103,7 @@ function table_mergeOptions(table, newOptions) {
 * ```
 */
 function table_setOptions(table, updater) {
-	const newOptions = functionalUpdate(updater, table.options);
-	const { rowModels, features, atoms, initialState } = table.options;
-	const mergedOptions = Object.assign(table_mergeOptions(table, newOptions), {
-		rowModels,
-		features,
-		atoms,
-		initialState
-	});
+	const mergedOptions = table_mergeOptions(table, functionalUpdate(updater, table.options));
 	if (table.optionsStore) table.optionsStore.set(() => mergedOptions);
 	else table.options = mergedOptions;
 	table_syncExternalStateToBaseAtoms(table);

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

@@ -1 +1 @@
-{"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 !== 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] as any)\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 { rowModels, 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    rowModels,\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,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,IAAW;EACrD;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,aAAa,iBAAiB,SAAS,MAAM,OAAO;CAE1D,MAAM,EAAE,WAAW,UAAU,OAAO,iBAAiB,MAAM;CAC3D,MAAM,gBAAgB,OAAO,OAAO,mBAAmB,OAAO,UAAU,GAAG;EAGzE;EACA;EACA;EACA;CACF,CAAC;CAED,IAAI,MAAM,cACR,MAAM,aAAa,UAAU,aAAa;MAE1C,MAAM,UAAU;CAElB,mCAAmC,KAAK;AAC1C"}
+{"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 !== 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. 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,SAAS,IAAI,GACjC,SAAS,UAAU,aAAa;EAEpC;CACF,CAAC;AACH;;;;;;;;;;;;AAaA,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;AACH;;;;;;;;;;;;;;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/features/column-faceting/columnFacetingFeature.cjs

@@ -3,71 +3,59 @@ const require_columnFacetingFeature_utils = require('./columnFacetingFeature.uti
 
 //#region src/features/column-faceting/columnFacetingFeature.ts
 /**
-* Creates the stock column faceting feature.
-*
-* The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.
+* Feature that derives faceted row models, unique values, and min/max values for filters.
 */
-function constructColumnFacetingFeature() {
-	return {
-		assignColumnPrototype: (prototype, table) => {
-			require_utils.assignPrototypeAPIs("columnFacetingFeature", prototype, table, {
-				column_getFacetedRowModel: {
-					memoDeps: () => {
-						var _table$atoms$columnFi, _table$atoms$globalFi;
-						return [
-							table.getPreFilteredRowModel().rows,
-							(_table$atoms$columnFi = table.atoms.columnFilters) === null || _table$atoms$columnFi === void 0 ? void 0 : _table$atoms$columnFi.get(),
-							(_table$atoms$globalFi = table.atoms.globalFilter) === null || _table$atoms$globalFi === void 0 ? void 0 : _table$atoms$globalFi.get(),
-							table.getFilteredRowModel().rows
-						];
-					},
-					fn: (column) => require_columnFacetingFeature_utils.column_getFacetedRowModel(column, column.table)
+const columnFacetingFeature = {
+	assignColumnPrototype: (prototype, table) => {
+		require_utils.assignPrototypeAPIs("columnFacetingFeature", prototype, table, {
+			column_getFacetedRowModel: {
+				memoDeps: () => {
+					var _table$atoms$columnFi, _table$atoms$globalFi;
+					return [
+						table.getPreFilteredRowModel().rows,
+						(_table$atoms$columnFi = table.atoms.columnFilters) === null || _table$atoms$columnFi === void 0 ? void 0 : _table$atoms$columnFi.get(),
+						(_table$atoms$globalFi = table.atoms.globalFilter) === null || _table$atoms$globalFi === void 0 ? void 0 : _table$atoms$globalFi.get(),
+						table.getFilteredRowModel().rows
+					];
 				},
-				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)
+				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: () => {
+					var _table$atoms$columnFi2, _table$atoms$globalFi2;
+					return [
+						table.getPreFilteredRowModel().rows,
+						(_table$atoms$columnFi2 = table.atoms.columnFilters) === null || _table$atoms$columnFi2 === void 0 ? void 0 : _table$atoms$columnFi2.get(),
+						(_table$atoms$globalFi2 = table.atoms.globalFilter) === null || _table$atoms$globalFi2 === void 0 ? void 0 : _table$atoms$globalFi2.get(),
+						table.getFilteredRowModel().rows
+					];
 				},
-				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: () => {
-						var _table$atoms$columnFi2, _table$atoms$globalFi2;
-						return [
-							table.getPreFilteredRowModel().rows,
-							(_table$atoms$columnFi2 = table.atoms.columnFilters) === null || _table$atoms$columnFi2 === void 0 ? void 0 : _table$atoms$columnFi2.get(),
-							(_table$atoms$globalFi2 = table.atoms.globalFilter) === null || _table$atoms$globalFi2 === void 0 ? void 0 : _table$atoms$globalFi2.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)
-				}
-			});
-		}
-	};
-}
-/**
-* The stock column faceting feature.
-*
-* Register this feature to add faceted row model, unique value, and min/max
-* helpers for column and global filter UIs.
-*/
-const columnFacetingFeature = constructColumnFacetingFeature();
+				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;
-exports.constructColumnFacetingFeature = constructColumnFacetingFeature;
 //# sourceMappingURL=columnFacetingFeature.cjs.map

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

@@ -1 +1 @@
-{"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 { RowData } from '../../types/type-utils'\nimport type { TableFeature, TableFeatures } from '../../types/TableFeatures'\nimport type { Column_Internal } from '../../types/Column'\n// import type {\n//   CachedRowModel_Faceted,\n//   Column_ColumnFaceting,\n//   CreateRowModel_Faceted,\n// } from './columnFacetingFeature.types'\n\nexport interface ColumnFacetingFeatureConstructors<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n> {\n  // CachedRowModel: CachedRowModel_Faceted<TFeatures, TData>\n  // Column: Column_ColumnFaceting<TFeatures, TData>\n  // CreateRowModels: CreateRowModel_Faceted<TFeatures, TData>\n}\n\n/**\n * Creates the stock column faceting feature.\n *\n * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.\n */\nexport function constructColumnFacetingFeature<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(): TableFeature<ColumnFacetingFeatureConstructors<TFeatures, TData>> {\n  return {\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: Column_Internal<TFeatures, TData>) => [\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: Column_Internal<TFeatures, TData>) => [\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}\n\n/**\n * The stock column faceting feature.\n *\n * Register this feature to add faceted row model, unique value, and min/max\n * helpers for column and global filter UIs.\n */\nexport const columnFacetingFeature = constructColumnFacetingFeature()\n"],"mappings":";;;;;;;;;AAoCA,SAAgB,iCAGuD;CACrE,OAAO;EACL,wBAAwB,WAAW,UAAU;GAC3C,kCAAoB,yBAAyB,WAAW,OAAO;IAC7D,2BAA2B;KACzB,gBAAgB;;;OACd,MAAM,uBAAuB,CAAC,CAAC;gCAC/B,MAAM,MAAM,6FAAe,IAAI;gCAC/B,MAAM,MAAM,4FAAc,IAAI;OAC9B,MAAM,oBAAoB,CAAC,CAAC;MAC9B;;KACA,KAAK,WAAWA,8DAA0B,QAAQ,OAAO,KAAK;IAChE;IACA,+BAA+B;KAC7B,WAAW,WAA8C,CACvDC,iCACE,QACA,sBACAD,+DACA,OAAO,KACT,CAAC,CAAC,QACJ;KACA,KAAK,WAAWE,kEAA8B,QAAQ,OAAO,KAAK;IACpE;IACA,+BAA+B;KAC7B,WAAW,WAA8C,CACvDD,iCACE,QACA,sBACAD,+DACA,OAAO,KACT,CAAC,CAAC,QACJ;KACA,KAAK,WAAWG,kEAA8B,QAAQ,OAAO,KAAK;IACpE;GACF,CAAC;EACH;EAEA,qBAAqB,UAAU;GAC7B,8BAAgB,yBAAyB,OAAO;IAC9C,gCAAgC;KAC9B,gBAAgB;;;OACd,MAAM,uBAAuB,CAAC,CAAC;iCAC/B,MAAM,MAAM,+FAAe,IAAI;iCAC/B,MAAM,MAAM,8FAAc,IAAI;OAC9B,MAAM,oBAAoB,CAAC,CAAC;MAC9B;;KACA,UAAUC,mEAA+B,KAAK;IAChD;IACA,oCAAoC;KAClC,gBAAgB,CACdH,iCACE,OACA,4BACAG,kEACF,CAAC,CAAC,QACJ;KACA,UAAUC,uEAAmC,KAAK;IACpD;IACA,oCAAoC;KAClC,gBAAgB,CACdJ,iCACE,OACA,4BACAG,kEACF,CAAC,CAAC,QACJ;KACA,UAAUE,uEAAmC,KAAK;IACpD;GACF,CAAC;EACH;CACF;AACF;;;;;;;AAQA,MAAa,wBAAwB,+BAA+B"}
+{"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;;;MACd,MAAM,uBAAuB,CAAC,CAAC;+BAC/B,MAAM,MAAM,6FAAe,IAAI;+BAC/B,MAAM,MAAM,4FAAc,IAAI;MAC9B,MAAM,oBAAoB,CAAC,CAAC;KAC9B;;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;;;MACd,MAAM,uBAAuB,CAAC,CAAC;gCAC/B,MAAM,MAAM,+FAAe,IAAI;gCAC/B,MAAM,MAAM,8FAAc,IAAI;MAC9B,MAAM,oBAAoB,CAAC,CAAC;KAC9B;;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,21 +1,10 @@
-import { RowData } from "../../types/type-utils.cjs";
-import { TableFeature, TableFeatures } from "../../types/TableFeatures.cjs";
+import { TableFeature } from "../../types/TableFeatures.cjs";
 
 //#region src/features/column-faceting/columnFacetingFeature.d.ts
-interface ColumnFacetingFeatureConstructors<TFeatures extends TableFeatures, TData extends RowData> {}
 /**
- * Creates the stock column faceting feature.
- *
- * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.
+ * Feature that derives faceted row models, unique values, and min/max values for filters.
  */
-declare function constructColumnFacetingFeature<TFeatures extends TableFeatures, TData extends RowData>(): TableFeature<ColumnFacetingFeatureConstructors<TFeatures, TData>>;
-/**
- * The stock column faceting feature.
- *
- * Register this feature to add faceted row model, unique value, and min/max
- * helpers for column and global filter UIs.
- */
-declare const columnFacetingFeature: TableFeature<ColumnFacetingFeatureConstructors<TableFeatures, RowData>>;
+declare const columnFacetingFeature: TableFeature;
 //#endregion
-export { ColumnFacetingFeatureConstructors, columnFacetingFeature, constructColumnFacetingFeature };
+export { columnFacetingFeature };
 //# sourceMappingURL=columnFacetingFeature.d.cts.map

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

@@ -1,21 +1,10 @@
-import { RowData } from "../../types/type-utils.js";
-import { TableFeature, TableFeatures } from "../../types/TableFeatures.js";
+import { TableFeature } from "../../types/TableFeatures.js";
 
 //#region src/features/column-faceting/columnFacetingFeature.d.ts
-interface ColumnFacetingFeatureConstructors<TFeatures extends TableFeatures, TData extends RowData> {}
 /**
- * Creates the stock column faceting feature.
- *
- * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.
+ * Feature that derives faceted row models, unique values, and min/max values for filters.
  */
-declare function constructColumnFacetingFeature<TFeatures extends TableFeatures, TData extends RowData>(): TableFeature<ColumnFacetingFeatureConstructors<TFeatures, TData>>;
-/**
- * The stock column faceting feature.
- *
- * Register this feature to add faceted row model, unique value, and min/max
- * helpers for column and global filter UIs.
- */
-declare const columnFacetingFeature: TableFeature<ColumnFacetingFeatureConstructors<TableFeatures, RowData>>;
+declare const columnFacetingFeature: TableFeature;
 //#endregion
-export { ColumnFacetingFeatureConstructors, columnFacetingFeature, constructColumnFacetingFeature };
+export { columnFacetingFeature };
 //# sourceMappingURL=columnFacetingFeature.d.ts.map

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

@@ -3,70 +3,59 @@ import { column_getFacetedMinMaxValues, column_getFacetedRowModel, column_getFac
 
 //#region src/features/column-faceting/columnFacetingFeature.ts
 /**
-* Creates the stock column faceting feature.
-*
-* The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.
+* Feature that derives faceted row models, unique values, and min/max values for filters.
 */
-function constructColumnFacetingFeature() {
-	return {
-		assignColumnPrototype: (prototype, table) => {
-			assignPrototypeAPIs("columnFacetingFeature", prototype, table, {
-				column_getFacetedRowModel: {
-					memoDeps: () => {
-						var _table$atoms$columnFi, _table$atoms$globalFi;
-						return [
-							table.getPreFilteredRowModel().rows,
-							(_table$atoms$columnFi = table.atoms.columnFilters) === null || _table$atoms$columnFi === void 0 ? void 0 : _table$atoms$columnFi.get(),
-							(_table$atoms$globalFi = table.atoms.globalFilter) === null || _table$atoms$globalFi === void 0 ? void 0 : _table$atoms$globalFi.get(),
-							table.getFilteredRowModel().rows
-						];
-					},
-					fn: (column) => column_getFacetedRowModel(column, column.table)
+const columnFacetingFeature = {
+	assignColumnPrototype: (prototype, table) => {
+		assignPrototypeAPIs("columnFacetingFeature", prototype, table, {
+			column_getFacetedRowModel: {
+				memoDeps: () => {
+					var _table$atoms$columnFi, _table$atoms$globalFi;
+					return [
+						table.getPreFilteredRowModel().rows,
+						(_table$atoms$columnFi = table.atoms.columnFilters) === null || _table$atoms$columnFi === void 0 ? void 0 : _table$atoms$columnFi.get(),
+						(_table$atoms$globalFi = table.atoms.globalFilter) === null || _table$atoms$globalFi === void 0 ? void 0 : _table$atoms$globalFi.get(),
+						table.getFilteredRowModel().rows
+					];
 				},
-				column_getFacetedMinMaxValues: {
-					memoDeps: (column) => [callMemoOrStaticFn(column, "getFacetedRowModel", column_getFacetedRowModel, column.table).flatRows],
-					fn: (column) => column_getFacetedMinMaxValues(column, column.table)
+				fn: (column) => column_getFacetedRowModel(column, column.table)
+			},
+			column_getFacetedMinMaxValues: {
+				memoDeps: (column) => [callMemoOrStaticFn(column, "getFacetedRowModel", column_getFacetedRowModel, column.table).flatRows],
+				fn: (column) => column_getFacetedMinMaxValues(column, column.table)
+			},
+			column_getFacetedUniqueValues: {
+				memoDeps: (column) => [callMemoOrStaticFn(column, "getFacetedRowModel", column_getFacetedRowModel, column.table).flatRows],
+				fn: (column) => column_getFacetedUniqueValues(column, column.table)
+			}
+		});
+	},
+	constructTableAPIs: (table) => {
+		assignTableAPIs("columnFacetingFeature", table, {
+			table_getGlobalFacetedRowModel: {
+				memoDeps: () => {
+					var _table$atoms$columnFi2, _table$atoms$globalFi2;
+					return [
+						table.getPreFilteredRowModel().rows,
+						(_table$atoms$columnFi2 = table.atoms.columnFilters) === null || _table$atoms$columnFi2 === void 0 ? void 0 : _table$atoms$columnFi2.get(),
+						(_table$atoms$globalFi2 = table.atoms.globalFilter) === null || _table$atoms$globalFi2 === void 0 ? void 0 : _table$atoms$globalFi2.get(),
+						table.getFilteredRowModel().rows
+					];
 				},
-				column_getFacetedUniqueValues: {
-					memoDeps: (column) => [callMemoOrStaticFn(column, "getFacetedRowModel", column_getFacetedRowModel, column.table).flatRows],
-					fn: (column) => column_getFacetedUniqueValues(column, column.table)
-				}
-			});
-		},
-		constructTableAPIs: (table) => {
-			assignTableAPIs("columnFacetingFeature", table, {
-				table_getGlobalFacetedRowModel: {
-					memoDeps: () => {
-						var _table$atoms$columnFi2, _table$atoms$globalFi2;
-						return [
-							table.getPreFilteredRowModel().rows,
-							(_table$atoms$columnFi2 = table.atoms.columnFilters) === null || _table$atoms$columnFi2 === void 0 ? void 0 : _table$atoms$columnFi2.get(),
-							(_table$atoms$globalFi2 = table.atoms.globalFilter) === null || _table$atoms$globalFi2 === void 0 ? void 0 : _table$atoms$globalFi2.get(),
-							table.getFilteredRowModel().rows
-						];
-					},
-					fn: () => table_getGlobalFacetedRowModel(table)
-				},
-				table_getGlobalFacetedMinMaxValues: {
-					memoDeps: () => [callMemoOrStaticFn(table, "getGlobalFacetedRowModel", table_getGlobalFacetedRowModel).flatRows],
-					fn: () => table_getGlobalFacetedMinMaxValues(table)
-				},
-				table_getGlobalFacetedUniqueValues: {
-					memoDeps: () => [callMemoOrStaticFn(table, "getGlobalFacetedRowModel", table_getGlobalFacetedRowModel).flatRows],
-					fn: () => table_getGlobalFacetedUniqueValues(table)
-				}
-			});
-		}
-	};
-}
-/**
-* The stock column faceting feature.
-*
-* Register this feature to add faceted row model, unique value, and min/max
-* helpers for column and global filter UIs.
-*/
-const columnFacetingFeature = constructColumnFacetingFeature();
+				fn: () => table_getGlobalFacetedRowModel(table)
+			},
+			table_getGlobalFacetedMinMaxValues: {
+				memoDeps: () => [callMemoOrStaticFn(table, "getGlobalFacetedRowModel", table_getGlobalFacetedRowModel).flatRows],
+				fn: () => table_getGlobalFacetedMinMaxValues(table)
+			},
+			table_getGlobalFacetedUniqueValues: {
+				memoDeps: () => [callMemoOrStaticFn(table, "getGlobalFacetedRowModel", table_getGlobalFacetedRowModel).flatRows],
+				fn: () => table_getGlobalFacetedUniqueValues(table)
+			}
+		});
+	}
+};
 
 //#endregion
-export { columnFacetingFeature, constructColumnFacetingFeature };
+export { columnFacetingFeature };
 //# sourceMappingURL=columnFacetingFeature.js.map