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

package/src/utils.ts

@@ -3,12 +3,22 @@ import type { NoInfer, RowData, Updater } from './types/type-utils'
 import type { TableFeatures } from './types/TableFeatures'
 import type { TableState, TableState_All } from './types/TableState'
 
+/**
+ * Applies a TanStack updater to a value.
+ *
+ * If the updater is a function it is called with the previous value; otherwise the updater value is returned directly.
+ */
 export function functionalUpdate<T>(updater: Updater<T>, input: T): T {
   return typeof updater === 'function'
     ? (updater as (i: T) => T)(input)
     : updater
 }
 
+/**
+ * Clones table state values while preserving non-plain objects.
+ *
+ * Plain objects and arrays are copied recursively so state updates can avoid mutating existing references.
+ */
 export function cloneState<T>(value: T): T {
   if (Array.isArray(value)) {
     return value.map(cloneState) as T
@@ -22,8 +32,10 @@ export function cloneState<T>(value: T): T {
     }
 
     const copy: Record<string, unknown> = {}
+    const keys = Object.keys(value)
 
-    for (const key of Object.keys(value)) {
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i]!
       copy[key] = cloneState((value as Record<string, unknown>)[key])
     }
 
@@ -33,8 +45,11 @@ export function cloneState<T>(value: T): T {
   return value
 }
 
-export 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.
+ */
 export function makeStateUpdater<
   TFeatures extends TableFeatures,
   K extends (string & {}) | keyof TableState_All | keyof TableState<TFeatures>,
@@ -48,14 +63,18 @@ export function makeStateUpdater<
 
 type AnyFunction = (...args: any) => any
 
+/**
+ * Returns whether a value is a function.
+ */
 export function isFunction<T extends AnyFunction>(d: any): d is T {
   return d instanceof Function
 }
 
-export function isNumberArray(d: any): d is Array<number> {
-  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.
+ */
 export function flattenBy<TNode>(
   arr: Array<TNode>,
   getChildren: (item: TNode) => Array<TNode>,
@@ -77,23 +96,6 @@ export function flattenBy<TNode>(
   return flat
 }
 
-export const $internalMemoFnMeta = Symbol('memoFnMeta')
-export type MemoFnMeta = { originalArgsLength?: number }
-
-/**
- * @internal
- */
-function setMemoFnMeta(fn: Function, meta: MemoFnMeta) {
-  Object.defineProperty(fn, $internalMemoFnMeta, { value: meta })
-}
-
-/**
- * @internal
- */
-export function getMemoFnMeta(fn: any): MemoFnMeta | null {
-  return (typeof fn === 'function' && fn[$internalMemoFnMeta]) ?? null
-}
-
 interface MemoOptions<TDeps extends ReadonlyArray<any>, TDepArgs, TResult> {
   fn: (...args: NoInfer<TDeps>) => TResult
   memoDeps?: (depArgs?: TDepArgs) => [...TDeps] | undefined
@@ -103,6 +105,11 @@ interface MemoOptions<TDeps extends ReadonlyArray<any>, TDepArgs, TResult> {
   onBeforeUpdate?: () => void
 }
 
+/**
+ * Creates a dependency-tracked memoized function for table internals.
+ *
+ * The memo recomputes only when its dependency tuple changes and can emit debug timing information.
+ */
 export const memo = <TDeps extends ReadonlyArray<any>, TDepArgs, TResult>({
   fn,
   memoDeps,
@@ -119,10 +126,15 @@ export const memo = <TDeps extends ReadonlyArray<any>, TDepArgs, TResult>({
   const memoizedFn = (depArgs?: TDepArgs): TResult => {
     onBeforeCompare?.()
     const newDeps = memoDeps?.(depArgs)
-    const depsChanged =
-      !newDeps ||
-      newDeps.length !== deps?.length ||
-      newDeps.some((dep: any, index: number) => deps?.[index] !== dep)
+    let depsChanged = !newDeps || newDeps.length !== deps?.length
+    if (!depsChanged && newDeps) {
+      for (let i = 0; i < newDeps.length; i++) {
+        if (newDeps[i] !== deps![i]) {
+          depsChanged = true
+          break
+        }
+      }
+    }
     onAfterCompare?.(depsChanged)
 
     if (!depsChanged) {
@@ -138,8 +150,6 @@ export const memo = <TDeps extends ReadonlyArray<any>, TDepArgs, TResult>({
     return result
   }
 
-  setMemoFnMeta(memoizedFn, { originalArgsLength: fn.length })
-
   return memoizedFn
 }
 
@@ -164,6 +174,11 @@ const pad = (str: number | string, num: number) => {
   return str
 }
 
+/**
+ * Creates a table-aware memoized function.
+ *
+ * This wraps `memo` with table debug options and feature metadata so row models and derived APIs can share consistent diagnostics.
+ */
 export function tableMemo<
   TFeatures extends TableFeatures,
   TDeps extends ReadonlyArray<any>,
@@ -238,6 +253,11 @@ export function tableMemo<
     console.groupEnd()
   }
 
+  const onAfterUpdateHandler = () => {
+    const { schedule, untrack } = table._reactivity
+    schedule(() => untrack(() => onAfterUpdate?.()))
+  }
+
   const debugOptions =
     process.env.NODE_ENV === 'development'
       ? {
@@ -268,12 +288,12 @@ export function tableMemo<
                 Math.round((endCalcTime - startCalcTime) * 100) / 100
               logTime(executionTime, true)
             }
-            queueMicrotask(() => onAfterUpdate?.())
+            onAfterUpdateHandler()
           },
         }
       : {
           onAfterUpdate: () => {
-            queueMicrotask(() => onAfterUpdate?.())
+            onAfterUpdateHandler()
           },
         }
 
@@ -395,8 +415,6 @@ export function assignPrototypeAPIs<
         return fn(this, ...args)
       }
     }
-
-    setMemoFnMeta(prototype[fnKey], { originalArgsLength: fn.length })
   }
 }