@tanstack/table-core 9.0.0-alpha.46 → 9.0.0-alpha.47

package/dist/utils.js

@@ -18,16 +18,16 @@ function cloneState(value) {
 		const proto = Object.getPrototypeOf(value);
 		if (proto !== Object.prototype && proto !== null) return value;
 		const copy = {};
-		for (const key of Object.keys(value)) copy[key] = cloneState(value[key]);
+		const keys = Object.keys(value);
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			copy[key] = cloneState(value[key]);
+		}
 		return copy;
 	}
 	return value;
 }
 /**
-* A no-operation function used as a safe default callback.
-*/
-function noop() {}
-/**
 * Creates a table state updater for a single state slice.
 *
 * The updater writes through the table base atom for the slice and supports both value and functional updater forms.
@@ -45,12 +45,6 @@ function isFunction(d) {
 	return d instanceof Function;
 }
 /**
-* Returns whether a value is an array containing only numbers.
-*/
-function isNumberArray(d) {
-	return Array.isArray(d) && d.every((val) => typeof val === "number");
-}
-/**
 * Flattens a tree of nodes by recursively reading child nodes.
 *
 * The original nodes are preserved in depth-first order.
@@ -68,25 +62,6 @@ function flattenBy(arr, getChildren) {
 	return flat;
 }
 /**
-* Symbol used to attach internal memo metadata to wrapped functions.
-*
-* This is exported so diagnostics can recognize memoized functions without
-* depending on a string property name.
-*/
-const $internalMemoFnMeta = Symbol("memoFnMeta");
-/**
-* @internal
-*/
-function setMemoFnMeta(fn, meta) {
-	Object.defineProperty(fn, $internalMemoFnMeta, { value: meta });
-}
-/**
-* @internal
-*/
-function getMemoFnMeta(fn) {
-	return (typeof fn === "function" && fn[$internalMemoFnMeta]) ?? null;
-}
-/**
 * Creates a dependency-tracked memoized function for table internals.
 *
 * The memo recomputes only when its dependency tuple changes and can emit debug timing information.
@@ -97,7 +72,13 @@ const memo = ({ fn, memoDeps, onAfterCompare, onAfterUpdate, onBeforeCompare, on
 	const memoizedFn = (depArgs) => {
 		onBeforeCompare === null || onBeforeCompare === void 0 || onBeforeCompare();
 		const newDeps = memoDeps === null || memoDeps === void 0 ? void 0 : memoDeps(depArgs);
-		const depsChanged = !newDeps || newDeps.length !== (deps === null || deps === void 0 ? void 0 : deps.length) || newDeps.some((dep, index) => (deps === null || deps === void 0 ? void 0 : deps[index]) !== dep);
+		let depsChanged = !newDeps || newDeps.length !== (deps === null || deps === void 0 ? void 0 : deps.length);
+		if (!depsChanged && newDeps) {
+			for (let i = 0; i < newDeps.length; i++) if (newDeps[i] !== deps[i]) {
+				depsChanged = true;
+				break;
+			}
+		}
 		onAfterCompare === null || onAfterCompare === void 0 || onAfterCompare(depsChanged);
 		if (!depsChanged) return result;
 		deps = newDeps;
@@ -106,7 +87,6 @@ const memo = ({ fn, memoDeps, onAfterCompare, onAfterUpdate, onBeforeCompare, on
 		onAfterUpdate === null || onAfterUpdate === void 0 || onAfterUpdate(result);
 		return result;
 	};
-	setMemoFnMeta(memoizedFn, { originalArgsLength: fn.length });
 	return memoizedFn;
 };
 const pad = (str, num) => {
@@ -147,6 +127,10 @@ function tableMemo({ feature, fnName, objectId, onAfterUpdate, table, ...memoOpt
 		console.trace();
 		console.groupEnd();
 	}
+	const onAfterUpdateHandler = () => {
+		const { schedule, untrack } = table._reactivity;
+		schedule(() => untrack(() => onAfterUpdate === null || onAfterUpdate === void 0 ? void 0 : onAfterUpdate()));
+	};
 	const debugOptions = process.env.NODE_ENV === "development" ? {
 		onBeforeCompare: () => {
 			if (debugCache) beforeCompareTime = performance.now();
@@ -166,10 +150,10 @@ function tableMemo({ feature, fnName, objectId, onAfterUpdate, table, ...memoOpt
 				endCalcTime = performance.now();
 				logTime(Math.round((endCalcTime - startCalcTime) * 100) / 100, true);
 			}
-			queueMicrotask(() => onAfterUpdate === null || onAfterUpdate === void 0 ? void 0 : onAfterUpdate());
+			onAfterUpdateHandler();
 		}
 	} : { onAfterUpdate: () => {
-		queueMicrotask(() => onAfterUpdate === null || onAfterUpdate === void 0 ? void 0 : onAfterUpdate());
+		onAfterUpdateHandler();
 	} };
 	return memo({
 		...memoOptions,
@@ -232,7 +216,6 @@ function assignPrototypeAPIs(feature, prototype, table, apis) {
 		} else prototype[fnKey] = function(...args) {
 			return fn(this, ...args);
 		};
-		setMemoFnMeta(prototype[fnKey], { originalArgsLength: fn.length });
 	}
 }
 /**
@@ -244,5 +227,5 @@ function callMemoOrStaticFn(obj, fnKey, staticFn, ...args) {
 }
 
 //#endregion
-export { $internalMemoFnMeta, assignPrototypeAPIs, assignTableAPIs, callMemoOrStaticFn, cloneState, flattenBy, functionalUpdate, getFunctionNameInfo, getMemoFnMeta, isFunction, isNumberArray, makeStateUpdater, memo, noop, tableMemo };
+export { assignPrototypeAPIs, assignTableAPIs, callMemoOrStaticFn, cloneState, flattenBy, functionalUpdate, getFunctionNameInfo, isFunction, makeStateUpdater, memo, tableMemo };
 //# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","names":[],"sources":["../src/utils.ts"],"sourcesContent":["import type { Table, Table_Internal } from './types/Table'\nimport type { NoInfer, RowData, Updater } from './types/type-utils'\nimport type { TableFeatures } from './types/TableFeatures'\nimport type { TableState, TableState_All } from './types/TableState'\n\n/**\n * Applies a TanStack updater to a value.\n *\n * If the updater is a function it is called with the previous value; otherwise the updater value is returned directly.\n */\nexport function functionalUpdate<T>(updater: Updater<T>, input: T): T {\n  return typeof updater === 'function'\n    ? (updater as (i: T) => T)(input)\n    : updater\n}\n\n/**\n * Clones table state values while preserving non-plain objects.\n *\n * Plain objects and arrays are copied recursively so state updates can avoid mutating existing references.\n */\nexport function cloneState<T>(value: T): T {\n  if (Array.isArray(value)) {\n    return value.map(cloneState) as T\n  }\n\n  if (value && typeof value === 'object') {\n    const proto = Object.getPrototypeOf(value)\n\n    if (proto !== Object.prototype && proto !== null) {\n      return value\n    }\n\n    const copy: Record<string, unknown> = {}\n\n    for (const key of Object.keys(value)) {\n      copy[key] = cloneState((value as Record<string, unknown>)[key])\n    }\n\n    return copy as T\n  }\n\n  return value\n}\n\n/**\n * A no-operation function used as a safe default callback.\n */\nexport function noop() {}\n\n/**\n * Creates a table state updater for a single state slice.\n *\n * The updater writes through the table base atom for the slice and supports both value and functional updater forms.\n */\nexport function makeStateUpdater<\n  TFeatures extends TableFeatures,\n  K extends (string & {}) | keyof TableState_All | keyof TableState<TFeatures>,\n>(key: K, instance: Table<TFeatures, any>) {\n  return (updater: Updater<TableState<any>[K & keyof TableState<any>]>) => {\n    const externalAtom = (instance.options as any).atoms?.[key]\n    const targetAtom = externalAtom ?? (instance.baseAtoms as any)[key]\n    targetAtom.set((old: any) => functionalUpdate(updater, old))\n  }\n}\n\ntype AnyFunction = (...args: any) => any\n\n/**\n * Returns whether a value is a function.\n */\nexport function isFunction<T extends AnyFunction>(d: any): d is T {\n  return d instanceof Function\n}\n\n/**\n * Returns whether a value is an array containing only numbers.\n */\nexport function isNumberArray(d: any): d is Array<number> {\n  return Array.isArray(d) && d.every((val) => typeof val === 'number')\n}\n\n/**\n * Flattens a tree of nodes by recursively reading child nodes.\n *\n * The original nodes are preserved in depth-first order.\n */\nexport function flattenBy<TNode>(\n  arr: Array<TNode>,\n  getChildren: (item: TNode) => Array<TNode>,\n) {\n  const flat: Array<TNode> = []\n\n  const recurse = (subArr: Array<TNode>) => {\n    subArr.forEach((item) => {\n      flat.push(item)\n      const children = getChildren(item)\n      if (children.length) {\n        recurse(children)\n      }\n    })\n  }\n\n  recurse(arr)\n\n  return flat\n}\n\n/**\n * Symbol used to attach internal memo metadata to wrapped functions.\n *\n * This is exported so diagnostics can recognize memoized functions without\n * depending on a string property name.\n */\nexport const $internalMemoFnMeta = Symbol('memoFnMeta')\nexport type MemoFnMeta = { originalArgsLength?: number }\n\n/**\n * @internal\n */\nfunction setMemoFnMeta(fn: Function, meta: MemoFnMeta) {\n  Object.defineProperty(fn, $internalMemoFnMeta, { value: meta })\n}\n\n/**\n * @internal\n */\nexport function getMemoFnMeta(fn: any): MemoFnMeta | null {\n  return (typeof fn === 'function' && fn[$internalMemoFnMeta]) ?? null\n}\n\ninterface MemoOptions<TDeps extends ReadonlyArray<any>, TDepArgs, TResult> {\n  fn: (...args: NoInfer<TDeps>) => TResult\n  memoDeps?: (depArgs?: TDepArgs) => [...TDeps] | undefined\n  onAfterCompare?: (depsChanged: boolean) => void\n  onAfterUpdate?: (result: TResult) => void\n  onBeforeCompare?: () => void\n  onBeforeUpdate?: () => void\n}\n\n/**\n * Creates a dependency-tracked memoized function for table internals.\n *\n * The memo recomputes only when its dependency tuple changes and can emit debug timing information.\n */\nexport const memo = <TDeps extends ReadonlyArray<any>, TDepArgs, TResult>({\n  fn,\n  memoDeps,\n  onAfterCompare,\n  onAfterUpdate,\n  onBeforeCompare,\n  onBeforeUpdate,\n}: MemoOptions<TDeps, TDepArgs, TResult>): ((\n  depArgs?: TDepArgs,\n) => TResult) => {\n  let deps: Array<any> | undefined = []\n  let result: TResult | undefined\n\n  const memoizedFn = (depArgs?: TDepArgs): TResult => {\n    onBeforeCompare?.()\n    const newDeps = memoDeps?.(depArgs)\n    const depsChanged =\n      !newDeps ||\n      newDeps.length !== deps?.length ||\n      newDeps.some((dep: any, index: number) => deps?.[index] !== dep)\n    onAfterCompare?.(depsChanged)\n\n    if (!depsChanged) {\n      return result!\n    }\n\n    deps = newDeps\n\n    onBeforeUpdate?.()\n    result = fn(...(newDeps ?? ([] as any)))\n    onAfterUpdate?.(result)\n\n    return result\n  }\n\n  setMemoFnMeta(memoizedFn, { originalArgsLength: fn.length })\n\n  return memoizedFn\n}\n\ninterface TableMemoOptions<\n  TFeatures extends TableFeatures,\n  TDeps extends ReadonlyArray<any>,\n  TDepArgs,\n  TResult,\n> extends MemoOptions<TDeps, TDepArgs, TResult> {\n  feature?: keyof TFeatures & string\n  fnName: string\n  objectId?: string\n  onAfterUpdate?: () => void\n  table: Table_Internal<TFeatures, any>\n}\n\nconst pad = (str: number | string, num: number) => {\n  str = String(str)\n  while (str.length < num) {\n    str = ' ' + str\n  }\n  return str\n}\n\n/**\n * Creates a table-aware memoized function.\n *\n * This wraps `memo` with table debug options and feature metadata so row models and derived APIs can share consistent diagnostics.\n */\nexport function tableMemo<\n  TFeatures extends TableFeatures,\n  TDeps extends ReadonlyArray<any>,\n  TDepArgs,\n  TResult,\n>({\n  feature,\n  fnName,\n  objectId,\n  onAfterUpdate,\n  table,\n  ...memoOptions\n}: TableMemoOptions<TFeatures, TDeps, TDepArgs, TResult>) {\n  let beforeCompareTime: number\n  let afterCompareTime: number\n  let startCalcTime: number\n  let endCalcTime: number\n  let runCount = 0\n  let debug: boolean | undefined\n  let debugCache: boolean | undefined\n\n  if (process.env.NODE_ENV === 'development') {\n    const { debugCache: _debugCache, debugAll } = table.options\n    debugCache = _debugCache\n    const { parentName } = getFunctionNameInfo(fnName, '.')\n\n    const debugByParent =\n      // @ts-expect-error\n      table.options[\n        `debug${(parentName != 'table' ? parentName + 's' : parentName).replace(\n          parentName,\n          parentName.charAt(0).toUpperCase() + parentName.slice(1),\n        )}`\n      ]\n    const debugByFeature = feature\n      ? // @ts-expect-error\n        table.options[\n          `debug${feature.charAt(0).toUpperCase() + feature.slice(1)}`\n        ]\n      : false\n\n    debug = debugAll || debugByParent || debugByFeature\n  }\n\n  function logTime(time: number, depsChanged: boolean) {\n    const runType =\n      runCount === 0\n        ? '(1st run)'\n        : depsChanged\n          ? '(rerun #' + runCount + ')'\n          : '(cache)'\n    runCount++\n\n    console.groupCollapsed(\n      `%c⏱ ${pad(`${time.toFixed(1)} ms`, 12)} %c${runType}%c ${fnName}%c ${objectId ? `(${fnName.split('.')[0]}Id: ${objectId})` : ''}`,\n      `font-size: .6rem; font-weight: bold; ${\n        depsChanged\n          ? `color: hsl(\n        ${Math.max(0, Math.min(120 - Math.log10(time) * 60, 120))}deg 100% 31%);`\n          : ''\n      } `,\n      `color: ${runCount < 2 ? '#FF00FF' : '#FF1493'}`,\n      'color: #666',\n      'color: #87CEEB',\n    )\n    console.info({\n      feature,\n      state: table.store.state,\n      deps: memoOptions.memoDeps?.toString(),\n    })\n    console.trace()\n    console.groupEnd()\n  }\n\n  const debugOptions =\n    process.env.NODE_ENV === 'development'\n      ? {\n          onBeforeCompare: () => {\n            if (debugCache) {\n              beforeCompareTime = performance.now()\n            }\n          },\n          onAfterCompare: (depsChanged: boolean) => {\n            if (debugCache) {\n              afterCompareTime = performance.now()\n              const compareTime =\n                Math.round((afterCompareTime - beforeCompareTime) * 100) / 100\n              if (!depsChanged) {\n                logTime(compareTime, depsChanged)\n              }\n            }\n          },\n          onBeforeUpdate: () => {\n            if (debug) {\n              startCalcTime = performance.now()\n            }\n          },\n          onAfterUpdate: () => {\n            if (debug) {\n              endCalcTime = performance.now()\n              const executionTime =\n                Math.round((endCalcTime - startCalcTime) * 100) / 100\n              logTime(executionTime, true)\n            }\n            queueMicrotask(() => onAfterUpdate?.())\n          },\n        }\n      : {\n          onAfterUpdate: () => {\n            queueMicrotask(() => onAfterUpdate?.())\n          },\n        }\n\n  return memo({\n    ...memoOptions,\n    ...debugOptions,\n  })\n}\n\nexport interface API<TDeps extends ReadonlyArray<any>, TDepArgs> {\n  fn: (...args: any) => any\n  memoDeps?: (depArgs?: any) => [...any] | undefined\n}\n\nexport type APIObject<TDeps extends ReadonlyArray<any>, TDepArgs> = Record<\n  string,\n  API<TDeps, TDepArgs>\n>\n\n/**\n * Assumes that a function name is in the format of `parentName_fnKey` and returns the `fnKey` and `fnName` in the format of `parentName.fnKey`.\n */\nexport function getFunctionNameInfo(\n  staticFnName: string,\n  splitBy: '_' | '.' = '_',\n) {\n  const [parentName, fnKey] = staticFnName.split(splitBy)\n  const fnName = `${parentName}.${fnKey}`\n  return { fnKey, fnName, parentName } as {\n    fnKey: string\n    fnName: string\n    parentName: string\n  }\n}\n\n/**\n * Assigns Table API methods directly to the table instance.\n * Unlike row/cell/column/header, the table is a singleton so methods are assigned directly.\n */\nexport function assignTableAPIs<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TDeps extends ReadonlyArray<any>,\n  TDepArgs,\n>(\n  feature: keyof TFeatures & string,\n  table: Table_Internal<TFeatures, TData>,\n  apis: APIObject<TDeps, NoInfer<TDepArgs>>,\n): void {\n  for (const [staticFnName, { fn, memoDeps }] of Object.entries(apis)) {\n    const { fnKey, fnName } = getFunctionNameInfo(staticFnName)\n\n    ;(table as Record<string, any>)[fnKey] = memoDeps\n      ? tableMemo({\n          memoDeps,\n          fn,\n          fnName,\n          table,\n          feature,\n        })\n      : fn\n  }\n}\n\nexport interface PrototypeAPI<TDeps extends ReadonlyArray<any>, TDepArgs> {\n  fn: (self: any, ...args: any) => any\n  memoDeps?: (self: any, depArgs?: any) => [...any] | undefined\n}\n\nexport type PrototypeAPIObject<\n  TDeps extends ReadonlyArray<any>,\n  TDepArgs,\n> = Record<string, PrototypeAPI<TDeps, TDepArgs>>\n\n/**\n * Assigns API methods to a prototype object for memory-efficient method sharing.\n * All instances created with this prototype will share the same method references.\n *\n * For memoized methods, the memo state is lazily created and stored on each instance.\n * This provides the best of both worlds: shared method code + per-instance caching.\n */\nexport function assignPrototypeAPIs<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TDeps extends ReadonlyArray<any>,\n  TDepArgs,\n>(\n  feature: keyof TFeatures & string,\n  prototype: Record<string, any>,\n  table: Table_Internal<TFeatures, TData>,\n  apis: PrototypeAPIObject<TDeps, NoInfer<TDepArgs>>,\n): void {\n  for (const [staticFnName, { fn, memoDeps }] of Object.entries(apis)) {\n    const { fnKey, fnName } = getFunctionNameInfo(staticFnName)\n\n    if (memoDeps) {\n      // For memoized methods, create a function that lazily initializes\n      // the memo on first access and stores it on the instance\n      const memoKey = `_memo_${fnKey}`\n\n      prototype[fnKey] = function (this: any, ...args: Array<any>) {\n        // Lazily create memo on first access for this instance\n        if (!this[memoKey]) {\n          const self = this\n          this[memoKey] = tableMemo({\n            memoDeps: (depArgs) => memoDeps(self, depArgs),\n            fn: (...deps) => fn(self, ...deps),\n            fnName,\n            objectId: self.id,\n            table,\n            feature,\n          })\n        }\n        return this[memoKey](...args)\n      }\n    } else {\n      // Non-memoized methods just call the static function with `this`\n      prototype[fnKey] = function (this: any, ...args: Array<any>) {\n        return fn(this, ...args)\n      }\n    }\n\n    setMemoFnMeta(prototype[fnKey], { originalArgsLength: fn.length })\n  }\n}\n\n/**\n * Looks to run the memoized function with the builder pattern on the object if it exists, otherwise fallback to the static method passed in.\n */\nexport function callMemoOrStaticFn<\n  TObject extends Record<string, any>,\n  TStaticFn extends AnyFunction,\n>(\n  obj: TObject,\n  fnKey: string,\n  staticFn: TStaticFn,\n  ...args: Parameters<TStaticFn> extends [any, ...infer Rest] ? Rest : never\n): ReturnType<TStaticFn> {\n  return (\n    (obj[fnKey] as Function | undefined)?.(...args) ?? staticFn(obj, ...args)\n  )\n}\n"],"mappings":"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"}
+{"version":3,"file":"utils.js","names":[],"sources":["../src/utils.ts"],"sourcesContent":["import type { Table, Table_Internal } from './types/Table'\nimport type { NoInfer, RowData, Updater } from './types/type-utils'\nimport type { TableFeatures } from './types/TableFeatures'\nimport type { TableState, TableState_All } from './types/TableState'\n\n/**\n * Applies a TanStack updater to a value.\n *\n * If the updater is a function it is called with the previous value; otherwise the updater value is returned directly.\n */\nexport function functionalUpdate<T>(updater: Updater<T>, input: T): T {\n  return typeof updater === 'function'\n    ? (updater as (i: T) => T)(input)\n    : updater\n}\n\n/**\n * Clones table state values while preserving non-plain objects.\n *\n * Plain objects and arrays are copied recursively so state updates can avoid mutating existing references.\n */\nexport function cloneState<T>(value: T): T {\n  if (Array.isArray(value)) {\n    return value.map(cloneState) as T\n  }\n\n  if (value && typeof value === 'object') {\n    const proto = Object.getPrototypeOf(value)\n\n    if (proto !== Object.prototype && proto !== null) {\n      return value\n    }\n\n    const copy: Record<string, unknown> = {}\n    const keys = Object.keys(value)\n\n    for (let i = 0; i < keys.length; i++) {\n      const key = keys[i]!\n      copy[key] = cloneState((value as Record<string, unknown>)[key])\n    }\n\n    return copy as T\n  }\n\n  return value\n}\n\n/**\n * Creates a table state updater for a single state slice.\n *\n * The updater writes through the table base atom for the slice and supports both value and functional updater forms.\n */\nexport function makeStateUpdater<\n  TFeatures extends TableFeatures,\n  K extends (string & {}) | keyof TableState_All | keyof TableState<TFeatures>,\n>(key: K, instance: Table<TFeatures, any>) {\n  return (updater: Updater<TableState<any>[K & keyof TableState<any>]>) => {\n    const externalAtom = (instance.options as any).atoms?.[key]\n    const targetAtom = externalAtom ?? (instance.baseAtoms as any)[key]\n    targetAtom.set((old: any) => functionalUpdate(updater, old))\n  }\n}\n\ntype AnyFunction = (...args: any) => any\n\n/**\n * Returns whether a value is a function.\n */\nexport function isFunction<T extends AnyFunction>(d: any): d is T {\n  return d instanceof Function\n}\n\n/**\n * Flattens a tree of nodes by recursively reading child nodes.\n *\n * The original nodes are preserved in depth-first order.\n */\nexport function flattenBy<TNode>(\n  arr: Array<TNode>,\n  getChildren: (item: TNode) => Array<TNode>,\n) {\n  const flat: Array<TNode> = []\n\n  const recurse = (subArr: Array<TNode>) => {\n    subArr.forEach((item) => {\n      flat.push(item)\n      const children = getChildren(item)\n      if (children.length) {\n        recurse(children)\n      }\n    })\n  }\n\n  recurse(arr)\n\n  return flat\n}\n\ninterface MemoOptions<TDeps extends ReadonlyArray<any>, TDepArgs, TResult> {\n  fn: (...args: NoInfer<TDeps>) => TResult\n  memoDeps?: (depArgs?: TDepArgs) => [...TDeps] | undefined\n  onAfterCompare?: (depsChanged: boolean) => void\n  onAfterUpdate?: (result: TResult) => void\n  onBeforeCompare?: () => void\n  onBeforeUpdate?: () => void\n}\n\n/**\n * Creates a dependency-tracked memoized function for table internals.\n *\n * The memo recomputes only when its dependency tuple changes and can emit debug timing information.\n */\nexport const memo = <TDeps extends ReadonlyArray<any>, TDepArgs, TResult>({\n  fn,\n  memoDeps,\n  onAfterCompare,\n  onAfterUpdate,\n  onBeforeCompare,\n  onBeforeUpdate,\n}: MemoOptions<TDeps, TDepArgs, TResult>): ((\n  depArgs?: TDepArgs,\n) => TResult) => {\n  let deps: Array<any> | undefined = []\n  let result: TResult | undefined\n\n  const memoizedFn = (depArgs?: TDepArgs): TResult => {\n    onBeforeCompare?.()\n    const newDeps = memoDeps?.(depArgs)\n    let depsChanged = !newDeps || newDeps.length !== deps?.length\n    if (!depsChanged && newDeps) {\n      for (let i = 0; i < newDeps.length; i++) {\n        if (newDeps[i] !== deps![i]) {\n          depsChanged = true\n          break\n        }\n      }\n    }\n    onAfterCompare?.(depsChanged)\n\n    if (!depsChanged) {\n      return result!\n    }\n\n    deps = newDeps\n\n    onBeforeUpdate?.()\n    result = fn(...(newDeps ?? ([] as any)))\n    onAfterUpdate?.(result)\n\n    return result\n  }\n\n  return memoizedFn\n}\n\ninterface TableMemoOptions<\n  TFeatures extends TableFeatures,\n  TDeps extends ReadonlyArray<any>,\n  TDepArgs,\n  TResult,\n> extends MemoOptions<TDeps, TDepArgs, TResult> {\n  feature?: keyof TFeatures & string\n  fnName: string\n  objectId?: string\n  onAfterUpdate?: () => void\n  table: Table_Internal<TFeatures, any>\n}\n\nconst pad = (str: number | string, num: number) => {\n  str = String(str)\n  while (str.length < num) {\n    str = ' ' + str\n  }\n  return str\n}\n\n/**\n * Creates a table-aware memoized function.\n *\n * This wraps `memo` with table debug options and feature metadata so row models and derived APIs can share consistent diagnostics.\n */\nexport function tableMemo<\n  TFeatures extends TableFeatures,\n  TDeps extends ReadonlyArray<any>,\n  TDepArgs,\n  TResult,\n>({\n  feature,\n  fnName,\n  objectId,\n  onAfterUpdate,\n  table,\n  ...memoOptions\n}: TableMemoOptions<TFeatures, TDeps, TDepArgs, TResult>) {\n  let beforeCompareTime: number\n  let afterCompareTime: number\n  let startCalcTime: number\n  let endCalcTime: number\n  let runCount = 0\n  let debug: boolean | undefined\n  let debugCache: boolean | undefined\n\n  if (process.env.NODE_ENV === 'development') {\n    const { debugCache: _debugCache, debugAll } = table.options\n    debugCache = _debugCache\n    const { parentName } = getFunctionNameInfo(fnName, '.')\n\n    const debugByParent =\n      // @ts-expect-error\n      table.options[\n        `debug${(parentName != 'table' ? parentName + 's' : parentName).replace(\n          parentName,\n          parentName.charAt(0).toUpperCase() + parentName.slice(1),\n        )}`\n      ]\n    const debugByFeature = feature\n      ? // @ts-expect-error\n        table.options[\n          `debug${feature.charAt(0).toUpperCase() + feature.slice(1)}`\n        ]\n      : false\n\n    debug = debugAll || debugByParent || debugByFeature\n  }\n\n  function logTime(time: number, depsChanged: boolean) {\n    const runType =\n      runCount === 0\n        ? '(1st run)'\n        : depsChanged\n          ? '(rerun #' + runCount + ')'\n          : '(cache)'\n    runCount++\n\n    console.groupCollapsed(\n      `%c⏱ ${pad(`${time.toFixed(1)} ms`, 12)} %c${runType}%c ${fnName}%c ${objectId ? `(${fnName.split('.')[0]}Id: ${objectId})` : ''}`,\n      `font-size: .6rem; font-weight: bold; ${\n        depsChanged\n          ? `color: hsl(\n        ${Math.max(0, Math.min(120 - Math.log10(time) * 60, 120))}deg 100% 31%);`\n          : ''\n      } `,\n      `color: ${runCount < 2 ? '#FF00FF' : '#FF1493'}`,\n      'color: #666',\n      'color: #87CEEB',\n    )\n    console.info({\n      feature,\n      state: table.store.state,\n      deps: memoOptions.memoDeps?.toString(),\n    })\n    console.trace()\n    console.groupEnd()\n  }\n\n  const onAfterUpdateHandler = () => {\n    const { schedule, untrack } = table._reactivity\n    schedule(() => untrack(() => onAfterUpdate?.()))\n  }\n\n  const debugOptions =\n    process.env.NODE_ENV === 'development'\n      ? {\n          onBeforeCompare: () => {\n            if (debugCache) {\n              beforeCompareTime = performance.now()\n            }\n          },\n          onAfterCompare: (depsChanged: boolean) => {\n            if (debugCache) {\n              afterCompareTime = performance.now()\n              const compareTime =\n                Math.round((afterCompareTime - beforeCompareTime) * 100) / 100\n              if (!depsChanged) {\n                logTime(compareTime, depsChanged)\n              }\n            }\n          },\n          onBeforeUpdate: () => {\n            if (debug) {\n              startCalcTime = performance.now()\n            }\n          },\n          onAfterUpdate: () => {\n            if (debug) {\n              endCalcTime = performance.now()\n              const executionTime =\n                Math.round((endCalcTime - startCalcTime) * 100) / 100\n              logTime(executionTime, true)\n            }\n            onAfterUpdateHandler()\n          },\n        }\n      : {\n          onAfterUpdate: () => {\n            onAfterUpdateHandler()\n          },\n        }\n\n  return memo({\n    ...memoOptions,\n    ...debugOptions,\n  })\n}\n\nexport interface API<TDeps extends ReadonlyArray<any>, TDepArgs> {\n  fn: (...args: any) => any\n  memoDeps?: (depArgs?: any) => [...any] | undefined\n}\n\nexport type APIObject<TDeps extends ReadonlyArray<any>, TDepArgs> = Record<\n  string,\n  API<TDeps, TDepArgs>\n>\n\n/**\n * Assumes that a function name is in the format of `parentName_fnKey` and returns the `fnKey` and `fnName` in the format of `parentName.fnKey`.\n */\nexport function getFunctionNameInfo(\n  staticFnName: string,\n  splitBy: '_' | '.' = '_',\n) {\n  const [parentName, fnKey] = staticFnName.split(splitBy)\n  const fnName = `${parentName}.${fnKey}`\n  return { fnKey, fnName, parentName } as {\n    fnKey: string\n    fnName: string\n    parentName: string\n  }\n}\n\n/**\n * Assigns Table API methods directly to the table instance.\n * Unlike row/cell/column/header, the table is a singleton so methods are assigned directly.\n */\nexport function assignTableAPIs<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TDeps extends ReadonlyArray<any>,\n  TDepArgs,\n>(\n  feature: keyof TFeatures & string,\n  table: Table_Internal<TFeatures, TData>,\n  apis: APIObject<TDeps, NoInfer<TDepArgs>>,\n): void {\n  for (const [staticFnName, { fn, memoDeps }] of Object.entries(apis)) {\n    const { fnKey, fnName } = getFunctionNameInfo(staticFnName)\n\n    ;(table as Record<string, any>)[fnKey] = memoDeps\n      ? tableMemo({\n          memoDeps,\n          fn,\n          fnName,\n          table,\n          feature,\n        })\n      : fn\n  }\n}\n\nexport interface PrototypeAPI<TDeps extends ReadonlyArray<any>, TDepArgs> {\n  fn: (self: any, ...args: any) => any\n  memoDeps?: (self: any, depArgs?: any) => [...any] | undefined\n}\n\nexport type PrototypeAPIObject<\n  TDeps extends ReadonlyArray<any>,\n  TDepArgs,\n> = Record<string, PrototypeAPI<TDeps, TDepArgs>>\n\n/**\n * Assigns API methods to a prototype object for memory-efficient method sharing.\n * All instances created with this prototype will share the same method references.\n *\n * For memoized methods, the memo state is lazily created and stored on each instance.\n * This provides the best of both worlds: shared method code + per-instance caching.\n */\nexport function assignPrototypeAPIs<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TDeps extends ReadonlyArray<any>,\n  TDepArgs,\n>(\n  feature: keyof TFeatures & string,\n  prototype: Record<string, any>,\n  table: Table_Internal<TFeatures, TData>,\n  apis: PrototypeAPIObject<TDeps, NoInfer<TDepArgs>>,\n): void {\n  for (const [staticFnName, { fn, memoDeps }] of Object.entries(apis)) {\n    const { fnKey, fnName } = getFunctionNameInfo(staticFnName)\n\n    if (memoDeps) {\n      // For memoized methods, create a function that lazily initializes\n      // the memo on first access and stores it on the instance\n      const memoKey = `_memo_${fnKey}`\n\n      prototype[fnKey] = function (this: any, ...args: Array<any>) {\n        // Lazily create memo on first access for this instance\n        if (!this[memoKey]) {\n          const self = this\n          this[memoKey] = tableMemo({\n            memoDeps: (depArgs) => memoDeps(self, depArgs),\n            fn: (...deps) => fn(self, ...deps),\n            fnName,\n            objectId: self.id,\n            table,\n            feature,\n          })\n        }\n        return this[memoKey](...args)\n      }\n    } else {\n      // Non-memoized methods just call the static function with `this`\n      prototype[fnKey] = function (this: any, ...args: Array<any>) {\n        return fn(this, ...args)\n      }\n    }\n  }\n}\n\n/**\n * Looks to run the memoized function with the builder pattern on the object if it exists, otherwise fallback to the static method passed in.\n */\nexport function callMemoOrStaticFn<\n  TObject extends Record<string, any>,\n  TStaticFn extends AnyFunction,\n>(\n  obj: TObject,\n  fnKey: string,\n  staticFn: TStaticFn,\n  ...args: Parameters<TStaticFn> extends [any, ...infer Rest] ? Rest : never\n): ReturnType<TStaticFn> {\n  return (\n    (obj[fnKey] as Function | undefined)?.(...args) ?? staticFn(obj, ...args)\n  )\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/table-core",
-  "version": "9.0.0-alpha.46",
+  "version": "9.0.0-alpha.47",
   "description": "Headless UI for building powerful tables & datagrids for TS/JS.",
   "author": "Tanner Linsley",
   "license": "MIT",

package/src/core/cells/constructCell.ts

@@ -16,8 +16,9 @@ function getCellPrototype<
 >(table: Table_Internal<TFeatures, TData>): object {
   if (!table._cellPrototype) {
     table._cellPrototype = { table }
-    for (const feature of Object.values(table._features)) {
-      feature.assignCellPrototype?.(table._cellPrototype, table)
+    const features = Object.values(table._features)
+    for (let i = 0; i < features.length; i++) {
+      features[i]!.assignCellPrototype?.(table._cellPrototype, table)
     }
   }
   return table._cellPrototype

package/src/core/columns/constructColumn.ts

@@ -20,8 +20,9 @@ function getColumnPrototype<
 >(table: Table_Internal<TFeatures, TData>): object {
   if (!table._columnPrototype) {
     table._columnPrototype = { table }
-    for (const feature of Object.values(table._features)) {
-      feature.assignColumnPrototype?.(table._columnPrototype, table)
+    const features = Object.values(table._features)
+    for (let i = 0; i < features.length; i++) {
+      features[i]!.assignColumnPrototype?.(table._columnPrototype, table)
     }
   }
   return table._columnPrototype
@@ -69,7 +70,8 @@ export function constructColumn<
       accessorFn = (originalRow: TData) => {
         let result = originalRow as Record<string, any> | undefined
 
-        for (const key of keys) {
+        for (let i = 0; i < keys.length; i++) {
+          const key = keys[i]!
           result = result?.[key]
           if (process.env.NODE_ENV === 'development' && result === undefined) {
             console.warn(

package/src/core/columns/coreColumnsFeature.utils.ts

@@ -179,7 +179,9 @@ export function table_getAllFlatColumnsById<
   table: Table_Internal<TFeatures, TData>,
 ): Record<string, Column<TFeatures, TData, unknown>> {
   const result: Record<string, Column<TFeatures, TData, unknown>> = {}
-  for (const column of table.getAllFlatColumns()) {
+  const flatColumns = table.getAllFlatColumns()
+  for (let i = 0; i < flatColumns.length; i++) {
+    const column = flatColumns[i]!
     result[column.id] = column
   }
   return result
@@ -228,7 +230,9 @@ export function table_getAllLeafColumnsById<
   table: Table_Internal<TFeatures, TData>,
 ): Record<string, Column<TFeatures, TData, unknown>> {
   const result: Record<string, Column<TFeatures, TData, unknown>> = {}
-  for (const column of table.getAllLeafColumns()) {
+  const leafColumns = table.getAllLeafColumns()
+  for (let i = 0; i < leafColumns.length; i++) {
+    const column = leafColumns[i]!
     result[column.id] = column
   }
   return result

package/src/core/headers/buildHeaderGroups.ts

@@ -37,15 +37,14 @@ export function buildHeaderGroups<
   ) => {
     maxDepth = Math.max(maxDepth, depth)
 
-    columns
-      .filter((column) =>
-        callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible),
-      )
-      .forEach((column) => {
+    for (let i = 0; i < columns.length; i++) {
+      const column = columns[i]!
+      if (callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible)) {
         if (column.columns.length) {
           findMaxDepth(column.columns, depth + 1)
         }
-      }, 0)
+      }
+    }
   }
 
   findMaxDepth(allColumns)
@@ -136,43 +135,43 @@ export function buildHeaderGroups<
 
   headerGroups.reverse()
 
-  // headerGroups = headerGroups.filter(headerGroup => {
-  //   return !headerGroup.headers.every(header => header.isPlaceholder)
-  // })
-
   const recurseHeadersForSpans = (
     headers: Array<Header<TFeatures, TData, TValue>>,
   ): Array<{ colSpan: number; rowSpan: number }> => {
-    const filteredHeaders = headers.filter((header) =>
-      callMemoOrStaticFn(header.column, 'getIsVisible', column_getIsVisible),
-    )
+    const results: Array<{ colSpan: number; rowSpan: number }> = []
+
+    for (let i = 0; i < headers.length; i++) {
+      const header = headers[i]!
+      if (
+        !callMemoOrStaticFn(header.column, 'getIsVisible', column_getIsVisible)
+      ) {
+        continue
+      }
 
-    return filteredHeaders.map((header) => {
       let colSpan = 0
-      let rowSpan = 0
-      let childRowSpans = [0]
+      let minChildRowSpan = Infinity
 
       if (header.subHeaders.length) {
-        childRowSpans = []
-
-        recurseHeadersForSpans(header.subHeaders).forEach(
-          ({ colSpan: childColSpan, rowSpan: childRowSpan }) => {
-            colSpan += childColSpan
-            childRowSpans.push(childRowSpan)
-          },
-        )
+        const childSpans = recurseHeadersForSpans(header.subHeaders)
+        for (let j = 0; j < childSpans.length; j++) {
+          const child = childSpans[j]!
+          colSpan += child.colSpan
+          if (child.rowSpan < minChildRowSpan) {
+            minChildRowSpan = child.rowSpan
+          }
+        }
       } else {
         colSpan = 1
+        minChildRowSpan = 0
       }
 
-      const minChildRowSpan = Math.min(...childRowSpans)
-      rowSpan = rowSpan + minChildRowSpan
-
       header.colSpan = colSpan
-      header.rowSpan = rowSpan
+      header.rowSpan = minChildRowSpan
 
-      return { colSpan, rowSpan }
-    })
+      results.push({ colSpan, rowSpan: header.rowSpan })
+    }
+
+    return results
   }
 
   recurseHeadersForSpans(

package/src/core/headers/constructHeader.ts

@@ -15,8 +15,9 @@ function getHeaderPrototype<
 >(table: Table_Internal<TFeatures, TData>): object {
   if (!table._headerPrototype) {
     table._headerPrototype = { table }
-    for (const feature of Object.values(table._features)) {
-      feature.assignHeaderPrototype?.(table._headerPrototype, table)
+    const features = Object.values(table._features)
+    for (let i = 0; i < features.length; i++) {
+      features[i]!.assignHeaderPrototype?.(table._headerPrototype, table)
     }
   }
   return table._headerPrototype

package/src/core/headers/coreHeadersFeature.ts

@@ -1,13 +1,4 @@
-import {
-  assignPrototypeAPIs,
-  assignTableAPIs,
-  callMemoOrStaticFn,
-} from '../../utils'
-import {
-  table_getCenterHeaderGroups,
-  table_getLeftHeaderGroups,
-  table_getRightHeaderGroups,
-} from '../../features/column-pinning/columnPinningFeature.utils'
+import { assignPrototypeAPIs, assignTableAPIs } from '../../utils'
 import {
   header_getContext,
   header_getLeafHeaders,
@@ -74,23 +65,7 @@ export function constructCoreHeadersFeature<
         },
         table_getLeafHeaders: {
           fn: () => table_getLeafHeaders(table),
-          memoDeps: () => [
-            callMemoOrStaticFn(
-              table,
-              'getLeftHeaderGroups',
-              table_getLeftHeaderGroups,
-            ),
-            callMemoOrStaticFn(
-              table,
-              'getCenterHeaderGroups',
-              table_getCenterHeaderGroups,
-            ),
-            callMemoOrStaticFn(
-              table,
-              'getRightHeaderGroups',
-              table_getRightHeaderGroups,
-            ),
-          ],
+          memoDeps: () => [table.getHeaderGroups()],
         },
       })
     },

package/src/core/headers/coreHeadersFeature.utils.ts

@@ -1,9 +1,4 @@
-import {
-  getDefaultColumnPinningState,
-  table_getCenterHeaderGroups,
-  table_getLeftHeaderGroups,
-  table_getRightHeaderGroups,
-} from '../../features/column-pinning/columnPinningFeature.utils'
+import { getDefaultColumnPinningState } from '../../features/column-pinning/columnPinningFeature.utils'
 import {
   column_getIsVisible,
   table_getVisibleLeafColumns,
@@ -90,11 +85,17 @@ export function table_getHeaderGroups<
     'getVisibleLeafColumns',
     table_getVisibleLeafColumns,
   ) as Array<Column<TFeatures, TData, unknown>>
+
+  // Fast path: no columns are pinned — skip per-side lookups, partition, and spread.
+  if (!left.length && !right.length) {
+    return buildHeaderGroups(allColumns, leafColumns, table)
+  }
+
   const leafColumnsById = table.getAllLeafColumnsById()
 
   const leftColumns: typeof leafColumns = []
-  for (const columnId of left) {
-    const column = leafColumnsById[columnId]
+  for (let i = 0; i < left.length; i++) {
+    const column = leafColumnsById[left[i]!]
     if (
       column &&
       callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible)
@@ -104,8 +105,8 @@ export function table_getHeaderGroups<
   }
 
   const rightColumns: typeof leafColumns = []
-  for (const columnId of right) {
-    const column = leafColumnsById[columnId]
+  for (let i = 0; i < right.length; i++) {
+    const column = leafColumnsById[right[i]!]
     if (
       column &&
       callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible)
@@ -118,13 +119,11 @@ export function table_getHeaderGroups<
     (column) => !left.includes(column.id) && !right.includes(column.id),
   )
 
-  const headerGroups = buildHeaderGroups(
+  return buildHeaderGroups(
     allColumns,
     [...leftColumns, ...centerColumns, ...rightColumns],
     table,
   )
-
-  return headerGroups
 }
 
 /**
@@ -160,11 +159,14 @@ export function table_getFlatHeaders<
   TData extends RowData,
 >(table: Table_Internal<TFeatures, TData>) {
   const headerGroups = table.getHeaderGroups()
-  return headerGroups
-    .map((headerGroup) => {
-      return headerGroup.headers
-    })
-    .flat()
+  const result: Array<Header<TFeatures, TData, unknown>> = []
+  for (let i = 0; i < headerGroups.length; i++) {
+    const headers = headerGroups[i]!.headers
+    for (let j = 0; j < headers.length; j++) {
+      result.push(headers[j]!)
+    }
+  }
+  return result
 }
 
 /**
@@ -181,29 +183,13 @@ export function table_getLeafHeaders<
   TFeatures extends TableFeatures,
   TData extends RowData,
 >(table: Table_Internal<TFeatures, TData>) {
-  const left = callMemoOrStaticFn(
-    table,
-    'getLeftHeaderGroups',
-    table_getLeftHeaderGroups,
-  )
-  const center = callMemoOrStaticFn(
-    table,
-    'getCenterHeaderGroups',
-    table_getCenterHeaderGroups,
-  )
-  const right = callMemoOrStaticFn(
-    table,
-    'getRightHeaderGroups',
-    table_getRightHeaderGroups,
-  )
-
-  return [
-    ...(left[0]?.headers ?? []),
-    ...(center[0]?.headers ?? []),
-    ...(right[0]?.headers ?? []),
-  ]
-    .map((header) => {
-      return header.getLeafHeaders()
-    })
-    .flat()
+  const topHeaders = table.getHeaderGroups()[0]?.headers ?? []
+  const result: Array<Header<TFeatures, TData, unknown>> = []
+  for (let i = 0; i < topHeaders.length; i++) {
+    const leafHeaders = topHeaders[i]!.getLeafHeaders()
+    for (let j = 0; j < leafHeaders.length; j++) {
+      result.push(leafHeaders[j]!)
+    }
+  }
+  return result
 }

package/src/core/reactivity/coreReactivityFeature.types.ts

@@ -38,4 +38,8 @@ export interface TableReactivityBindings {
    * Batches reactive updates to avoid intermediate recomputation.
    */
   batch: (fn: () => void) => void
+  /**
+   * Schedules a function to run. This is used to defer updates after the current call stack (render, etc.) has finished
+   */
+  schedule: (fn: () => void) => void
 }

package/src/core/rows/constructRow.ts

@@ -14,8 +14,9 @@ function getRowPrototype<
 >(table: Table_Internal<TFeatures, TData>): object {
   if (!table._rowPrototype) {
     table._rowPrototype = { table }
-    for (const feature of Object.values(table._features)) {
-      feature.assignRowPrototype?.(table._rowPrototype, table)
+    const features = Object.values(table._features)
+    for (let i = 0; i < features.length; i++) {
+      features[i]!.assignRowPrototype?.(table._rowPrototype, table)
     }
   }
   return table._rowPrototype
@@ -56,8 +57,9 @@ export const constructRow = <
   row.subRows = subRows ?? []
 
   // Initialize instance-specific data (e.g., caches) for features that need it
-  for (const feature of Object.values(table._features)) {
-    feature.initRowInstanceData?.(row)
+  const features = Object.values(table._features)
+  for (let i = 0; i < features.length; i++) {
+    features[i]!.initRowInstanceData?.(row)
   }
 
   return row as Row<TFeatures, TData>

package/src/core/rows/coreRowsFeature.utils.ts

@@ -164,9 +164,14 @@ export function row_getAllCells<
   TFeatures extends TableFeatures,
   TData extends RowData,
 >(row: Row<TFeatures, TData>): Array<Cell<TFeatures, TData, unknown>> {
-  return row.table.getAllLeafColumns().map((column) => {
-    return constructCell(column, row, row.table)
-  })
+  const columns = row.table.getAllLeafColumns()
+  const cells: Array<Cell<TFeatures, TData, unknown>> = new Array(
+    columns.length,
+  )
+  for (let i = 0; i < columns.length; i++) {
+    cells[i] = constructCell(columns[i]!, row, row.table)
+  }
+  return cells
 }
 
 /**
@@ -184,7 +189,9 @@ export function row_getAllCellsByColumnId<
   TData extends RowData,
 >(row: Row<TFeatures, TData>) {
   const result: Record<string, Cell<TFeatures, TData, unknown>> = {}
-  for (const cell of row.getAllCells()) {
+  const cells = row.getAllCells()
+  for (let i = 0; i < cells.length; i++) {
+    const cell = cells[i]!
     result[cell.column.id] = cell
   }
   return result

package/src/core/table/constructTable.ts

@@ -79,7 +79,8 @@ export function constructTable<
     string & keyof TableState<TFeatures>
   >
 
-  for (const key of stateKeys) {
+  for (let i = 0; i < stateKeys.length; i++) {
+    const key = stateKeys[i]!
     // create writable base atom
     table.baseAtoms[key] = _reactivity.createWritableAtom(
       table.initialState[key],
@@ -107,7 +108,8 @@ export function constructTable<
     _reactivity.createReadonlyAtom(
       () => {
         const snapshot = {} as TableState<TFeatures>
-        for (const key of stateKeys) {
+        for (let i = 0; i < stateKeys.length; i++) {
+          const key = stateKeys[i]!
           snapshot[key] = table.atoms[key].get()
         }
         return snapshot
@@ -136,8 +138,8 @@ export function constructTable<
     )
   }
 
-  for (const feature of featuresList) {
-    feature.constructTableAPIs?.(table)
+  for (let i = 0; i < featuresList.length; i++) {
+    featuresList[i]!.constructTableAPIs?.(table)
   }
 
   return table

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

@@ -56,7 +56,9 @@ export function table_reset<
 >(table: Table_Internal<TFeatures, TData>): void {
   const snap = cloneState(table.initialState)
   table._reactivity.batch(() => {
-    for (const key of Object.keys(snap) as Array<keyof typeof snap>) {
+    const keys = Object.keys(snap) as Array<keyof typeof snap>
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i]!
       ;(table.baseAtoms as any)[key].set(snap[key] as any)
     }
   })