@tanstack/table-core 9.0.0-alpha.41 → 9.0.0-alpha.42

package/src/core/table/constructTable.ts

@@ -1,6 +1,6 @@
-import { createAtom, createStore } from '@tanstack/store'
 import { coreFeatures } from '../coreFeatures'
 import { cloneState } from '../../utils'
+import { atomToStore } from '../reactivity/coreReactivityFeature.utils'
 import type { RowData } from '../../types/type-utils'
 import type { TableFeature, TableFeatures } from '../../types/TableFeatures'
 import type { Table, Table_Internal } from '../../types/Table'
@@ -21,15 +21,18 @@ export function constructTable<
   TFeatures extends TableFeatures,
   TData extends RowData,
 >(tableOptions: TableOptions<TFeatures, TData>): Table<TFeatures, TData> {
+  const _reactivity = tableOptions._features.coreReativityFeature!
+
   const table = {
+    _reactivity,
     _features: { ...coreFeatures, ...tableOptions._features },
     _rowModels: {},
     _rowModelFns: {},
     get options() {
-      return this.optionsStore.state
+      return this.optionsStore.get()
     },
     set options(value) {
-      this.optionsStore.setState(() => value)
+      this.optionsStore.set(() => value)
     },
     baseAtoms: {},
     atoms: {},
@@ -41,10 +44,10 @@ export function constructTable<
     return Object.assign(obj, feature.getDefaultTableOptions?.(table))
   }, {}) as TableOptions<TFeatures, TData>
 
-  table.optionsStore = createStore({
-    ...defaultOptions,
-    ...tableOptions,
-  })
+  // @ts-ignore - direct set
+  table.optionsStore = _reactivity.createWritableAtom<
+    TableOptions<TFeatures, TData>
+  >({ ...defaultOptions, ...tableOptions }, { debugName: 'table/optionsStore' })
 
   table.initialState = getInitialTableState(
     table._features,
@@ -57,31 +60,44 @@ export function constructTable<
 
   for (const key of stateKeys) {
     // create writable base atom
-    table.baseAtoms[key] = createAtom(table.initialState[key]) as any
+    table.baseAtoms[key] = _reactivity.createWritableAtom(
+      table.initialState[key],
+      {
+        debugName: `table/baseAtoms/${key}`,
+      },
+    ) as any
 
     // create readonly derived atom: on each get(), read current options (state, then external atom, then base)
-    ;(table.atoms as any)[key] = createAtom(() => {
-      // Reading optionsStore.state keeps this reactive to setOptions
-      const opts = table.optionsStore.state
-      const state = opts.state
-      if (key in (state ?? {})) {
-        return state![key]
-      }
-      const externalAtom = opts.atoms?.[key]
-      if (externalAtom) {
-        return externalAtom.get()
-      }
-      return table.baseAtoms[key].get()
-    })
+    ;(table.atoms as any)[key] = _reactivity.createReadonlyAtom(
+      () => {
+        // Reading optionsStore.get() keeps this reactive to setOptions
+        const opts = table.optionsStore.get()
+        const state = opts.state
+        if (key in (state ?? {})) {
+          return state![key]
+        }
+        const externalAtom = opts.atoms?.[key]
+        if (externalAtom) {
+          return externalAtom.get()
+        }
+        return table.baseAtoms[key].get()
+      },
+      { debugName: `table/atoms/${key}` },
+    )
   }
 
-  table.store = createStore(() => {
-    const snapshot = {} as TableState<TFeatures>
-    for (const key of stateKeys) {
-      snapshot[key] = table.atoms[key].get()
-    }
-    return snapshot
-  })
+  table.store = atomToStore(
+    _reactivity.createReadonlyAtom(
+      () => {
+        const snapshot = {} as TableState<TFeatures>
+        for (const key of stateKeys) {
+          snapshot[key] = table.atoms[key].get()
+        }
+        return snapshot
+      },
+      { debugName: 'table/store' },
+    ),
+  )
 
   if (
     process.env.NODE_ENV === 'development' &&

package/src/core/table/coreTablesFeature.types.ts

@@ -1,4 +1,5 @@
-import type { Atom, ReadonlyAtom, ReadonlyStore, Store } from '@tanstack/store'
+import type { TableReactivityBindings } from '../reactivity/coreReactivityFeature.types'
+import type { Atom, ReadonlyAtom, ReadonlyStore } from '@tanstack/store'
 import type { CoreFeatures } from '../coreFeatures'
 import type { RowModelFns } from '../../types/RowModelFns'
 import type { RowData, Updater } from '../../types/type-utils'
@@ -67,11 +68,11 @@ export interface TableOptions_Table<
   /**
    * The features that you want to enable for the table.
    */
-  _features: TFeatures
+  readonly _features: TFeatures
   /**
    * The row model options that you want to enable for the table.
    */
-  _rowModels?: CreateRowModels_All<TFeatures, TData>
+  readonly _rowModels?: CreateRowModels_All<TFeatures, TData>
   /**
    * 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]`
@@ -79,35 +80,35 @@ export interface TableOptions_Table<
    * still routed through the internal base atom; consumers are responsible for
    * mirroring changes back to their external atom via the corresponding `onXChange` callback.
    */
-  atoms?: ExternalAtoms<TFeatures>
+  readonly atoms?: ExternalAtoms<TFeatures>
   /**
    * Set this option to override any of the `autoReset...` feature options.
    */
-  autoResetAll?: boolean
+  readonly autoResetAll?: boolean
   /**
    * The data for the table to display. When the `data` option changes reference, the table will reprocess the data.
    */
-  data: ReadonlyArray<TData>
+  readonly data: ReadonlyArray<TData>
   /**
    * Use this option to optionally pass initial state to the table. This state will be used when resetting various table states either automatically by the table (eg. `options.autoResetPageIndex`) or via functions like `table.resetRowSelection()`. Most reset function allow you optionally pass a flag to reset to a blank/default state instead of the initial state.
    * Table state will not be reset when this object changes, which also means that the initial state object does not need to be stable.
    */
-  initialState?: Partial<TableState<TFeatures>>
+  readonly initialState?: Partial<TableState<TFeatures>>
   /**
    * This option is used to optionally implement the merging of table options.
    */
-  mergeOptions?: (
+  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`.
    */
-  meta?: TableMeta<TFeatures, TData>
+  readonly meta?: TableMeta<TFeatures, TData>
   /**
    * Pass in individual self-managed state to the table.
    */
-  state?: Partial<TableState<TFeatures>>
+  readonly state?: Partial<TableState<TFeatures>>
 }
 
 export interface Table_CoreProperties<
@@ -115,9 +116,9 @@ export interface Table_CoreProperties<
   TData extends RowData,
 > {
   /**
-   * The features that are enabled for the table.
+   * Table reactivity bindings for interacting with TanStack Store.
    */
-  _features: Partial<CoreFeatures> & TFeatures
+  readonly _reactivity: TableReactivityBindings
   /**
    * Prototype cache for Cell objects - shared by all cells in this table
    */
@@ -126,6 +127,10 @@ export interface Table_CoreProperties<
    * 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
    */
@@ -133,43 +138,43 @@ export interface Table_CoreProperties<
   /**
    * The row model processing functions that are used to process the data by features.
    */
-  _rowModelFns: RowModelFns<TFeatures, TData>
+  readonly _rowModelFns: RowModelFns<TFeatures, TData>
   /**
    * The row models that are enabled for the table.
    */
-  _rowModels: CachedRowModels<TFeatures, TData>
+  readonly _rowModels: CachedRowModels<TFeatures, TData>
   /**
    * Prototype cache for Row objects - shared by all rows in this table
    */
   _rowPrototype?: object
-  /**
-   * The internal writable atoms for each `TableState` slice. This is the library's
-   * single write surface — all state mutations from features land here.
-   */
-  baseAtoms: BaseAtoms<TFeatures>
   /**
    * 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).
    */
-  atoms: Atoms<TFeatures>
+  readonly atoms: Atoms<TFeatures>
   /**
-   * The base store for the table options.
+   * The internal writable atoms for each `TableState` slice. This is the library's
+   * single write surface — all state mutations from features land here.
    */
-  optionsStore: Store<TableOptions<TFeatures, TData>>
+  readonly baseAtoms: BaseAtoms<TFeatures>
   /**
    * This is the resolved initial state of the table.
    */
-  initialState: TableState<TFeatures>
+  readonly initialState: TableState<TFeatures>
   /**
    * A read-only reference to the table's current options.
    */
   readonly options: TableOptions<TFeatures, TData>
+  /**
+   * The base store for the table options.
+   */
+  readonly optionsStore: Atom<TableOptions<TFeatures, TData>>
   /**
    * The readonly flat store for the table state. Derives from `table.atoms`
    * only; never reads external state directly.
    */
-  store: ReadonlyStore<TableState<TFeatures>>
+  readonly store: ReadonlyStore<TableState<TFeatures>>
 }
 
 export interface Table_Table<

package/src/core/table/coreTablesFeature.utils.ts

@@ -1,4 +1,3 @@
-import { batch } from '@tanstack/store'
 import { cloneState, functionalUpdate } from '../../utils'
 import type { RowData, Updater } from '../../types/type-utils'
 import type { TableFeatures } from '../../types/TableFeatures'
@@ -10,7 +9,7 @@ export function table_reset<
   TData extends RowData,
 >(table: Table_Internal<TFeatures, TData>): void {
   const snap = cloneState(table.initialState)
-  batch(() => {
+  table._reactivity.batch(() => {
     for (const key of Object.keys(snap) as Array<keyof typeof snap>) {
       ;(table.baseAtoms as any)[key].set(snap[key] as any)
     }
@@ -43,5 +42,5 @@ export function table_setOptions<
 ): void {
   const newOptions = functionalUpdate(updater, table.options)
   const mergedOptions = table_mergeOptions(table, newOptions)
-  table.optionsStore.setState(() => mergedOptions)
+  table.optionsStore.set(() => mergedOptions)
 }

package/src/index.ts

@@ -71,9 +71,6 @@ export * from './fns/sortFns'
 
 export * from './features/stockFeatures'
 
-// tableReactivityFeature
-export * from './features/table-reactivity/tableReactivityFeature'
-
 // columnFacetingFeature
 export * from './features/column-faceting/columnFacetingFeature'
 export * from './features/column-faceting/columnFacetingFeature.types'

package/src/reactivity.ts

@@ -0,0 +1,3 @@
+export * from './core/reactivity/coreReactivityFeature.types'
+export * from './core/reactivity/constructReactivityBindings'
+export * from './core/reactivity/coreReactivityFeature.utils'

package/src/types/Table.ts

@@ -1,4 +1,4 @@
-import type { ReadonlyStore } from '@tanstack/store'
+import type { ReadonlyAtom, ReadonlyStore } from '@tanstack/store'
 import type { Table_ColumnFaceting } from '../features/column-faceting/columnFacetingFeature.types'
 import type { Table_ColumnResizing } from '../features/column-resizing/columnResizingFeature.types'
 import type { Table_ColumnFiltering } from '../features/column-filtering/columnFilteringFeature.types'

package/src/types/TableFeatures.ts

@@ -12,13 +12,13 @@ export type ExtractFeatureTypes<
   TFeatures extends TableFeatures,
 > = UnionToIntersection<
   {
-    [K in keyof TFeatures]: TFeatures[K] extends TableFeature<
-      infer FeatureConstructorOptions
-    >
-      ? TKey extends keyof FeatureConstructorOptions
-        ? FeatureConstructorOptions[TKey]
-        : never
-      : any
+    [K in keyof TFeatures]: K extends 'coreReativityFeature'
+      ? never
+      : TFeatures[K] extends TableFeature<infer FeatureConstructorOptions>
+        ? TKey extends keyof FeatureConstructorOptions
+          ? FeatureConstructorOptions[TKey]
+          : never
+        : any
   }[keyof TFeatures]
 >
 

package/dist/features/table-reactivity/tableReactivityFeature.cjs

@@ -1,46 +0,0 @@
-
-//#region src/features/table-reactivity/tableReactivityFeature.ts
-function constructReactivityFeature(bindings) {
-	return { constructTableAPIs: (table) => {
-		table.optionsStore = bindStore(table.optionsStore, bindings.optionsNotifier);
-		table.atoms = bindAtoms(table.atoms, bindings.stateNotifier);
-	} };
-}
-const bindStore = (store, notifier) => {
-	const stateDescriptor = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(store), "state");
-	Object.defineProperty(store, "state", {
-		configurable: true,
-		enumerable: true,
-		get() {
-			notifier === null || notifier === void 0 || notifier();
-			return stateDescriptor.get.call(store);
-		}
-	});
-	return store;
-};
-const bindAtoms = (atoms, notifier) => {
-	if (!notifier) return atoms;
-	const wrappedCache = /* @__PURE__ */ new Map();
-	return new Proxy(atoms, { get(target, prop, receiver) {
-		const atom = Reflect.get(target, prop, receiver);
-		if (!atom || typeof prop !== "string" || !isAtomLike(atom)) return atom;
-		if (wrappedCache.has(prop)) return wrappedCache.get(prop);
-		const originalGet = atom.get.bind(atom);
-		const wrapped = new Proxy(atom, { get(atomTarget, atomProp, atomReceiver) {
-			if (atomProp === "get") return () => {
-				notifier();
-				return originalGet();
-			};
-			return Reflect.get(atomTarget, atomProp, atomReceiver);
-		} });
-		wrappedCache.set(prop, wrapped);
-		return wrapped;
-	} });
-};
-function isAtomLike(value) {
-	return typeof value === "object" && value !== null && typeof value.get === "function";
-}
-
-//#endregion
-exports.constructReactivityFeature = constructReactivityFeature;
-//# sourceMappingURL=tableReactivityFeature.cjs.map

package/dist/features/table-reactivity/tableReactivityFeature.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"tableReactivityFeature.cjs","names":[],"sources":["../../../src/features/table-reactivity/tableReactivityFeature.ts"],"sourcesContent":["import type { ReadonlyStore, Store } from '@tanstack/store'\nimport type { TableFeature, TableFeatures } from '../../types/TableFeatures'\nimport type { RowData } from '../../types/type-utils'\n\nexport interface TableReactivityFeatureConstructors<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n> {}\n\nexport function constructReactivityFeature<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(bindings: {\n  stateNotifier?: () => unknown\n  optionsNotifier?: () => unknown\n}): TableFeature<TableReactivityFeatureConstructors<TFeatures, TData>> {\n  return {\n    constructTableAPIs: (table) => {\n      table.optionsStore = bindStore(\n        table.optionsStore,\n        bindings.optionsNotifier,\n      )\n      table.atoms = bindAtoms(table.atoms, bindings.stateNotifier)\n    },\n  }\n}\n\nconst bindStore = <T extends Store<any> | ReadonlyStore<any>>(\n  store: T,\n  notifier?: () => unknown,\n): T => {\n  const stateDescriptor = Object.getOwnPropertyDescriptor(\n    Object.getPrototypeOf(store),\n    'state',\n  )!\n\n  Object.defineProperty(store, 'state', {\n    configurable: true,\n    enumerable: true,\n    get() {\n      notifier?.()\n      return stateDescriptor.get!.call(store)\n    },\n  })\n\n  return store\n}\n\n// Wraps an atoms/baseAtoms map so that `.get()` on any individual atom\n// calls the framework notifier first — matching how `bindStore` wraps\n// `store.state`. The proxy also transparently forwards missing slices\n// (atoms for features not registered on this table) as `undefined`.\nconst bindAtoms = <T extends object>(atoms: T, notifier?: () => unknown): T => {\n  if (!notifier) return atoms\n  // Cache wrapped atoms so referential identity is stable per slice.\n  const wrappedCache = new Map<PropertyKey, any>()\n  return new Proxy(atoms, {\n    get(target, prop, receiver) {\n      const atom = Reflect.get(target, prop, receiver) as unknown\n      if (!atom || typeof prop !== 'string' || !isAtomLike(atom)) {\n        return atom\n      }\n      if (wrappedCache.has(prop)) return wrappedCache.get(prop)\n      const originalGet = atom.get.bind(atom)\n      const wrapped = new Proxy(atom, {\n        get(atomTarget, atomProp, atomReceiver) {\n          if (atomProp === 'get') {\n            return () => {\n              notifier()\n              return originalGet()\n            }\n          }\n          return Reflect.get(atomTarget, atomProp, atomReceiver)\n        },\n      })\n      wrappedCache.set(prop, wrapped)\n      return wrapped\n    },\n  })\n}\n\ninterface AtomLike {\n  get: () => unknown\n}\n\nfunction isAtomLike(value: unknown): value is AtomLike {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    typeof (value as { get?: unknown }).get === 'function'\n  )\n}\n"],"mappings":";;AASA,SAAgB,2BAGd,UAGqE;AACrE,QAAO,EACL,qBAAqB,UAAU;AAC7B,QAAM,eAAe,UACnB,MAAM,cACN,SAAS,gBACV;AACD,QAAM,QAAQ,UAAU,MAAM,OAAO,SAAS,cAAc;IAE/D;;AAGH,MAAM,aACJ,OACA,aACM;CACN,MAAM,kBAAkB,OAAO,yBAC7B,OAAO,eAAe,MAAM,EAC5B,QACD;AAED,QAAO,eAAe,OAAO,SAAS;EACpC,cAAc;EACd,YAAY;EACZ,MAAM;AACJ,yDAAY;AACZ,UAAO,gBAAgB,IAAK,KAAK,MAAM;;EAE1C,CAAC;AAEF,QAAO;;AAOT,MAAM,aAA+B,OAAU,aAAgC;AAC7E,KAAI,CAAC,SAAU,QAAO;CAEtB,MAAM,+BAAe,IAAI,KAAuB;AAChD,QAAO,IAAI,MAAM,OAAO,EACtB,IAAI,QAAQ,MAAM,UAAU;EAC1B,MAAM,OAAO,QAAQ,IAAI,QAAQ,MAAM,SAAS;AAChD,MAAI,CAAC,QAAQ,OAAO,SAAS,YAAY,CAAC,WAAW,KAAK,CACxD,QAAO;AAET,MAAI,aAAa,IAAI,KAAK,CAAE,QAAO,aAAa,IAAI,KAAK;EACzD,MAAM,cAAc,KAAK,IAAI,KAAK,KAAK;EACvC,MAAM,UAAU,IAAI,MAAM,MAAM,EAC9B,IAAI,YAAY,UAAU,cAAc;AACtC,OAAI,aAAa,MACf,cAAa;AACX,cAAU;AACV,WAAO,aAAa;;AAGxB,UAAO,QAAQ,IAAI,YAAY,UAAU,aAAa;KAEzD,CAAC;AACF,eAAa,IAAI,MAAM,QAAQ;AAC/B,SAAO;IAEV,CAAC;;AAOJ,SAAS,WAAW,OAAmC;AACrD,QACE,OAAO,UAAU,YACjB,UAAU,QACV,OAAQ,MAA4B,QAAQ"}

package/dist/features/table-reactivity/tableReactivityFeature.d.cts

@@ -1,12 +0,0 @@
-import { RowData } from "../../types/type-utils.cjs";
-import { TableFeature, TableFeatures } from "../../types/TableFeatures.cjs";
-
-//#region src/features/table-reactivity/tableReactivityFeature.d.ts
-interface TableReactivityFeatureConstructors<TFeatures extends TableFeatures, TData extends RowData> {}
-declare function constructReactivityFeature<TFeatures extends TableFeatures, TData extends RowData>(bindings: {
-  stateNotifier?: () => unknown;
-  optionsNotifier?: () => unknown;
-}): TableFeature<TableReactivityFeatureConstructors<TFeatures, TData>>;
-//#endregion
-export { TableReactivityFeatureConstructors, constructReactivityFeature };
-//# sourceMappingURL=tableReactivityFeature.d.cts.map

package/dist/features/table-reactivity/tableReactivityFeature.d.ts

@@ -1,12 +0,0 @@
-import { RowData } from "../../types/type-utils.js";
-import { TableFeature, TableFeatures } from "../../types/TableFeatures.js";
-
-//#region src/features/table-reactivity/tableReactivityFeature.d.ts
-interface TableReactivityFeatureConstructors<TFeatures extends TableFeatures, TData extends RowData> {}
-declare function constructReactivityFeature<TFeatures extends TableFeatures, TData extends RowData>(bindings: {
-  stateNotifier?: () => unknown;
-  optionsNotifier?: () => unknown;
-}): TableFeature<TableReactivityFeatureConstructors<TFeatures, TData>>;
-//#endregion
-export { TableReactivityFeatureConstructors, constructReactivityFeature };
-//# sourceMappingURL=tableReactivityFeature.d.ts.map

package/dist/features/table-reactivity/tableReactivityFeature.js

@@ -1,45 +0,0 @@
-//#region src/features/table-reactivity/tableReactivityFeature.ts
-function constructReactivityFeature(bindings) {
-	return { constructTableAPIs: (table) => {
-		table.optionsStore = bindStore(table.optionsStore, bindings.optionsNotifier);
-		table.atoms = bindAtoms(table.atoms, bindings.stateNotifier);
-	} };
-}
-const bindStore = (store, notifier) => {
-	const stateDescriptor = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(store), "state");
-	Object.defineProperty(store, "state", {
-		configurable: true,
-		enumerable: true,
-		get() {
-			notifier === null || notifier === void 0 || notifier();
-			return stateDescriptor.get.call(store);
-		}
-	});
-	return store;
-};
-const bindAtoms = (atoms, notifier) => {
-	if (!notifier) return atoms;
-	const wrappedCache = /* @__PURE__ */ new Map();
-	return new Proxy(atoms, { get(target, prop, receiver) {
-		const atom = Reflect.get(target, prop, receiver);
-		if (!atom || typeof prop !== "string" || !isAtomLike(atom)) return atom;
-		if (wrappedCache.has(prop)) return wrappedCache.get(prop);
-		const originalGet = atom.get.bind(atom);
-		const wrapped = new Proxy(atom, { get(atomTarget, atomProp, atomReceiver) {
-			if (atomProp === "get") return () => {
-				notifier();
-				return originalGet();
-			};
-			return Reflect.get(atomTarget, atomProp, atomReceiver);
-		} });
-		wrappedCache.set(prop, wrapped);
-		return wrapped;
-	} });
-};
-function isAtomLike(value) {
-	return typeof value === "object" && value !== null && typeof value.get === "function";
-}
-
-//#endregion
-export { constructReactivityFeature };
-//# sourceMappingURL=tableReactivityFeature.js.map

package/dist/features/table-reactivity/tableReactivityFeature.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tableReactivityFeature.js","names":[],"sources":["../../../src/features/table-reactivity/tableReactivityFeature.ts"],"sourcesContent":["import type { ReadonlyStore, Store } from '@tanstack/store'\nimport type { TableFeature, TableFeatures } from '../../types/TableFeatures'\nimport type { RowData } from '../../types/type-utils'\n\nexport interface TableReactivityFeatureConstructors<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n> {}\n\nexport function constructReactivityFeature<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(bindings: {\n  stateNotifier?: () => unknown\n  optionsNotifier?: () => unknown\n}): TableFeature<TableReactivityFeatureConstructors<TFeatures, TData>> {\n  return {\n    constructTableAPIs: (table) => {\n      table.optionsStore = bindStore(\n        table.optionsStore,\n        bindings.optionsNotifier,\n      )\n      table.atoms = bindAtoms(table.atoms, bindings.stateNotifier)\n    },\n  }\n}\n\nconst bindStore = <T extends Store<any> | ReadonlyStore<any>>(\n  store: T,\n  notifier?: () => unknown,\n): T => {\n  const stateDescriptor = Object.getOwnPropertyDescriptor(\n    Object.getPrototypeOf(store),\n    'state',\n  )!\n\n  Object.defineProperty(store, 'state', {\n    configurable: true,\n    enumerable: true,\n    get() {\n      notifier?.()\n      return stateDescriptor.get!.call(store)\n    },\n  })\n\n  return store\n}\n\n// Wraps an atoms/baseAtoms map so that `.get()` on any individual atom\n// calls the framework notifier first — matching how `bindStore` wraps\n// `store.state`. The proxy also transparently forwards missing slices\n// (atoms for features not registered on this table) as `undefined`.\nconst bindAtoms = <T extends object>(atoms: T, notifier?: () => unknown): T => {\n  if (!notifier) return atoms\n  // Cache wrapped atoms so referential identity is stable per slice.\n  const wrappedCache = new Map<PropertyKey, any>()\n  return new Proxy(atoms, {\n    get(target, prop, receiver) {\n      const atom = Reflect.get(target, prop, receiver) as unknown\n      if (!atom || typeof prop !== 'string' || !isAtomLike(atom)) {\n        return atom\n      }\n      if (wrappedCache.has(prop)) return wrappedCache.get(prop)\n      const originalGet = atom.get.bind(atom)\n      const wrapped = new Proxy(atom, {\n        get(atomTarget, atomProp, atomReceiver) {\n          if (atomProp === 'get') {\n            return () => {\n              notifier()\n              return originalGet()\n            }\n          }\n          return Reflect.get(atomTarget, atomProp, atomReceiver)\n        },\n      })\n      wrappedCache.set(prop, wrapped)\n      return wrapped\n    },\n  })\n}\n\ninterface AtomLike {\n  get: () => unknown\n}\n\nfunction isAtomLike(value: unknown): value is AtomLike {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    typeof (value as { get?: unknown }).get === 'function'\n  )\n}\n"],"mappings":";AASA,SAAgB,2BAGd,UAGqE;AACrE,QAAO,EACL,qBAAqB,UAAU;AAC7B,QAAM,eAAe,UACnB,MAAM,cACN,SAAS,gBACV;AACD,QAAM,QAAQ,UAAU,MAAM,OAAO,SAAS,cAAc;IAE/D;;AAGH,MAAM,aACJ,OACA,aACM;CACN,MAAM,kBAAkB,OAAO,yBAC7B,OAAO,eAAe,MAAM,EAC5B,QACD;AAED,QAAO,eAAe,OAAO,SAAS;EACpC,cAAc;EACd,YAAY;EACZ,MAAM;AACJ,yDAAY;AACZ,UAAO,gBAAgB,IAAK,KAAK,MAAM;;EAE1C,CAAC;AAEF,QAAO;;AAOT,MAAM,aAA+B,OAAU,aAAgC;AAC7E,KAAI,CAAC,SAAU,QAAO;CAEtB,MAAM,+BAAe,IAAI,KAAuB;AAChD,QAAO,IAAI,MAAM,OAAO,EACtB,IAAI,QAAQ,MAAM,UAAU;EAC1B,MAAM,OAAO,QAAQ,IAAI,QAAQ,MAAM,SAAS;AAChD,MAAI,CAAC,QAAQ,OAAO,SAAS,YAAY,CAAC,WAAW,KAAK,CACxD,QAAO;AAET,MAAI,aAAa,IAAI,KAAK,CAAE,QAAO,aAAa,IAAI,KAAK;EACzD,MAAM,cAAc,KAAK,IAAI,KAAK,KAAK;EACvC,MAAM,UAAU,IAAI,MAAM,MAAM,EAC9B,IAAI,YAAY,UAAU,cAAc;AACtC,OAAI,aAAa,MACf,cAAa;AACX,cAAU;AACV,WAAO,aAAa;;AAGxB,UAAO,QAAQ,IAAI,YAAY,UAAU,aAAa;KAEzD,CAAC;AACF,eAAa,IAAI,MAAM,QAAQ;AAC/B,SAAO;IAEV,CAAC;;AAOJ,SAAS,WAAW,OAAmC;AACrD,QACE,OAAO,UAAU,YACjB,UAAU,QACV,OAAQ,MAA4B,QAAQ"}

package/src/features/table-reactivity/tableReactivityFeature.ts

@@ -1,92 +0,0 @@
-import type { ReadonlyStore, Store } from '@tanstack/store'
-import type { TableFeature, TableFeatures } from '../../types/TableFeatures'
-import type { RowData } from '../../types/type-utils'
-
-export interface TableReactivityFeatureConstructors<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-> {}
-
-export function constructReactivityFeature<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(bindings: {
-  stateNotifier?: () => unknown
-  optionsNotifier?: () => unknown
-}): TableFeature<TableReactivityFeatureConstructors<TFeatures, TData>> {
-  return {
-    constructTableAPIs: (table) => {
-      table.optionsStore = bindStore(
-        table.optionsStore,
-        bindings.optionsNotifier,
-      )
-      table.atoms = bindAtoms(table.atoms, bindings.stateNotifier)
-    },
-  }
-}
-
-const bindStore = <T extends Store<any> | ReadonlyStore<any>>(
-  store: T,
-  notifier?: () => unknown,
-): T => {
-  const stateDescriptor = Object.getOwnPropertyDescriptor(
-    Object.getPrototypeOf(store),
-    'state',
-  )!
-
-  Object.defineProperty(store, 'state', {
-    configurable: true,
-    enumerable: true,
-    get() {
-      notifier?.()
-      return stateDescriptor.get!.call(store)
-    },
-  })
-
-  return store
-}
-
-// Wraps an atoms/baseAtoms map so that `.get()` on any individual atom
-// calls the framework notifier first — matching how `bindStore` wraps
-// `store.state`. The proxy also transparently forwards missing slices
-// (atoms for features not registered on this table) as `undefined`.
-const bindAtoms = <T extends object>(atoms: T, notifier?: () => unknown): T => {
-  if (!notifier) return atoms
-  // Cache wrapped atoms so referential identity is stable per slice.
-  const wrappedCache = new Map<PropertyKey, any>()
-  return new Proxy(atoms, {
-    get(target, prop, receiver) {
-      const atom = Reflect.get(target, prop, receiver) as unknown
-      if (!atom || typeof prop !== 'string' || !isAtomLike(atom)) {
-        return atom
-      }
-      if (wrappedCache.has(prop)) return wrappedCache.get(prop)
-      const originalGet = atom.get.bind(atom)
-      const wrapped = new Proxy(atom, {
-        get(atomTarget, atomProp, atomReceiver) {
-          if (atomProp === 'get') {
-            return () => {
-              notifier()
-              return originalGet()
-            }
-          }
-          return Reflect.get(atomTarget, atomProp, atomReceiver)
-        },
-      })
-      wrappedCache.set(prop, wrapped)
-      return wrapped
-    },
-  })
-}
-
-interface AtomLike {
-  get: () => unknown
-}
-
-function isAtomLike(value: unknown): value is AtomLike {
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    typeof (value as { get?: unknown }).get === 'function'
-  )
-}