@tanstack/table-core 9.0.0-beta.5 → 9.0.0-beta.51

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    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    if (!onAfterUpdate) {\n      return\n    }\n\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  TArgs extends Array<any>,\n  TReturn,\n>(\n  obj: TObject,\n  fnKey: string,\n  staticFn: (obj: TObject, ...args: TArgs) => TReturn,\n  ...args: TArgs\n): TReturn {\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_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> = proto === null ? makeObjectMap() : {}\n    const keys = Object.keys(value)\n\n    for (let i = 0; i < keys.length; i++) {\n      const key = keys[i]!\n      Object.defineProperty(copy, key, {\n        configurable: true,\n        enumerable: true,\n        value: cloneState((value as Record<string, unknown>)[key]),\n        writable: true,\n      })\n    }\n\n    return copy as T\n  }\n\n  return value\n}\n\n/**\n * Copies prototype-instance own properties without carrying over lazy memo\n * closures or the per-row cell cache, both of which are bound to the source\n * instance (cached cells reference the source row).\n */\nexport function copyInstancePropertiesWithoutMemos<\n  TTarget extends Record<string, any>,\n  TSource extends Record<string, any>,\n>(target: TTarget, source: TSource): TTarget & TSource {\n  const keys = Object.keys(source)\n  const targetRecord = target as Record<string, any>\n\n  for (let i = 0; i < keys.length; i++) {\n    const key = keys[i]!\n    if (!key.startsWith('_memo_') && key !== '_cellsCache') {\n      targetRecord[key] = source[key]\n    }\n  }\n\n  return target as TTarget & TSource\n}\n\n/**\n * Creates an object intended only for string-keyed dictionary lookups.\n *\n * The null prototype keeps user-controlled ids such as `__proto__` and\n * `hasOwnProperty` as plain data keys.\n */\nexport function makeObjectMap<TValue = unknown>(): Record<string, TValue> {\n  return Object.create(null) as Record<string, TValue>\n}\n\n/**\n * Checks whether an object owns a key, including null-prototype dictionaries.\n */\nexport function hasOwn(obj: object, key: PropertyKey): boolean {\n  return Object.prototype.hasOwnProperty.call(obj, key)\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>(\n  key: K,\n  // Minimal structural shape so any table view (public `Table`,\n  // `Table_Internal`, or a custom plugin table) can be passed without forcing\n  // the compiler to relate the full table types.\n  instance: {\n    readonly options: { readonly atoms?: object | undefined }\n    readonly baseAtoms: object\n  },\n) {\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 { debugAll } = table.options\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    if (!onAfterUpdate) {\n      return\n    }\n\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  TArgs extends Array<any>,\n  TReturn,\n>(\n  obj: TObject,\n  fnKey: string,\n  staticFn: (obj: TObject, ...args: TArgs) => TReturn,\n  ...args: TArgs\n): TReturn {\n  return (\n    (obj[fnKey] as Function | undefined)?.(...args) ?? staticFn(obj, ...args)\n  )\n}\n"],"mappings":"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"}

package/dist/worker/createTableWorker.cjs

@@ -0,0 +1,189 @@
+const require_rowPaginationFeature_utils = require('../features/row-pagination/rowPaginationFeature.utils.cjs');
+const require_rowExpandingFeature_utils = require('../features/row-expanding/rowExpandingFeature.utils.cjs');
+const require_tableWorkerProtocol = require('./tableWorkerProtocol.cjs');
+
+//#region src/worker/createTableWorker.ts
+/**
+* Registers the `workerRowModels` state slice
+* (`{ version, isPending, lastComputeMs, lastRoundTripMs }`). Worker results
+* land by bumping `version`, so re-renders flow through the exact same state
+* mechanism as every other table state change.
+*/
+const workerRowModelsFeature = { getInitialState: (initialState) => ({
+	workerRowModels: {
+		version: 0,
+		isPending: false
+	},
+	...initialState
+}) };
+/**
+* Creates the shared worker handle for a table's worker-backed row models.
+* Pass it to `createWorkerRowModel()` once per stage you want offloaded.
+*/
+function createTableWorker(options) {
+	const liveBridges = /* @__PURE__ */ new Set();
+	return {
+		_options: options,
+		_bridges: /* @__PURE__ */ new WeakMap(),
+		_liveBridges: liveBridges,
+		terminate: () => {
+			for (const bridge of liveBridges) {
+				bridge.worker?.terminate();
+				bridge.worker = null;
+				bridge.failed = false;
+				bridge.lastData = void 0;
+				bridge.inFlight = false;
+				bridge.needsProcess = true;
+				bridge.sentState = null;
+				bridge.sentStageCount = 0;
+			}
+			liveBridges.clear();
+		}
+	};
+}
+function getTableWorkerBridge(tableWorker, table) {
+	let bridge = tableWorker._bridges.get(table);
+	if (!bridge) {
+		bridge = {
+			worker: null,
+			failed: false,
+			lastData: void 0,
+			dataVersion: 0,
+			requestId: 0,
+			resultRequestId: 0,
+			inFlight: false,
+			needsProcess: true,
+			sentAt: 0,
+			stages: /* @__PURE__ */ new Set(),
+			sentState: null,
+			sentStageCount: 0,
+			lastState: {},
+			results: {},
+			stageVersions: {}
+		};
+		tableWorker._bridges.set(table, bridge);
+	}
+	return bridge;
+}
+/** Shallow reference comparison; atoms return stable refs when unchanged. */
+function statesEqual(a, b) {
+	if (a === null) return false;
+	const aKeys = Object.keys(a);
+	const bKeys = Object.keys(b);
+	if (aKeys.length !== bKeys.length) return false;
+	for (const key of bKeys) if (a[key] !== b[key]) return false;
+	return true;
+}
+function setWorkerRowModelsState(table, update) {
+	table.baseAtoms.workerRowModels?.set((prev) => update(prev ?? { version: 0 }));
+}
+function postProcess(table, bridge) {
+	const stages = require_tableWorkerProtocol.tableWorkerPipeline.filter((stage) => bridge.stages.has(stage));
+	bridge.needsProcess = false;
+	bridge.sentState = bridge.lastState;
+	bridge.sentStageCount = bridge.stages.size;
+	bridge.inFlight = true;
+	bridge.sentAt = performance.now();
+	const requestId = ++bridge.requestId;
+	bridge.worker.postMessage({
+		type: "process",
+		requestId,
+		dataVersion: bridge.dataVersion,
+		stages,
+		state: bridge.lastState
+	});
+	table._reactivity.schedule(() => {
+		if (bridge.requestId === requestId && bridge.resultRequestId < requestId) setWorkerRowModelsState(table, (prev) => ({
+			...prev,
+			isPending: true
+		}));
+	});
+}
+function handleResult(table, bridge, message) {
+	if (message.requestId !== bridge.requestId) return;
+	bridge.inFlight = false;
+	bridge.resultRequestId = message.requestId;
+	if (message.dataVersion !== bridge.dataVersion) {
+		postProcess(table, bridge);
+		return;
+	}
+	let anyChanged = false;
+	let groupedChanged = false;
+	for (const [stage, payload] of Object.entries(message.stages)) {
+		if (payload.kind === "unchanged") continue;
+		bridge.results[stage] = payload;
+		bridge.stageVersions[stage] = (bridge.stageVersions[stage] ?? 0) + 1;
+		anyChanged = true;
+		if (stage === "grouped") groupedChanged = true;
+	}
+	const roundTripMs = performance.now() - bridge.sentAt;
+	setWorkerRowModelsState(table, (prev) => ({
+		version: (prev.version ?? 0) + 1,
+		isPending: false,
+		lastComputeMs: message.computeMs,
+		lastRoundTripMs: roundTripMs
+	}));
+	if (anyChanged) table._reactivity.schedule(() => table._reactivity.untrack(() => {
+		if (groupedChanged) require_rowExpandingFeature_utils.table_autoResetExpanded(table);
+		require_rowPaginationFeature_utils.table_autoResetPageIndex(table);
+	}));
+	if (bridge.needsProcess) postProcess(table, bridge);
+}
+function handleError(table, bridge, event) {
+	if (bridge.failed) return;
+	bridge.failed = true;
+	bridge.inFlight = false;
+	console.error("[table-worker] The table worker failed; worker row models will keep their last results and stop updating. Check that the worker entry loads and that its initTableWorker() config is thread-portable.", event);
+	bridge.worker?.terminate();
+	bridge.worker = null;
+	setWorkerRowModelsState(table, (prev) => ({
+		...prev,
+		isPending: false
+	}));
+}
+function ensureWorker(tableWorker, table, bridge) {
+	if (bridge.worker) return;
+	bridge.worker = tableWorker._options.createWorker();
+	tableWorker._liveBridges.add(bridge);
+	bridge.worker.onmessage = (event) => {
+		handleResult(table, bridge, event.data);
+	};
+	bridge.worker.onerror = (event) => handleError(table, bridge, event);
+	bridge.worker.onmessageerror = (event) => handleError(table, bridge, event);
+}
+/**
+* Pull-based sync, called at the top of every worker-backed row model read
+* (i.e. every render). Posts data on identity change and a single-flight
+* process request on state change; both are cheap no-ops otherwise, and
+* multiple stages sharing the handle dedupe onto one request.
+*/
+function syncTableWorker(tableWorker, table) {
+	if (typeof Worker === "undefined") return;
+	const bridge = getTableWorkerBridge(tableWorker, table);
+	if (bridge.failed) return;
+	ensureWorker(tableWorker, table, bridge);
+	const data = table.options.data;
+	if (data !== bridge.lastData) {
+		bridge.lastData = data;
+		bridge.dataVersion++;
+		bridge.worker.postMessage({
+			type: "data",
+			dataVersion: bridge.dataVersion,
+			data
+		});
+		bridge.needsProcess = true;
+	}
+	const atoms = table.atoms;
+	const state = {};
+	for (const stage of bridge.stages) for (const key of require_tableWorkerProtocol.tableWorkerStageStateDeps[stage]) state[key] = atoms[key]?.get();
+	bridge.lastState = state;
+	if (!bridge.needsProcess && (!statesEqual(bridge.sentState, state) || bridge.stages.size !== bridge.sentStageCount)) bridge.needsProcess = true;
+	if (bridge.needsProcess && !bridge.inFlight) postProcess(table, bridge);
+}
+
+//#endregion
+exports.createTableWorker = createTableWorker;
+exports.getTableWorkerBridge = getTableWorkerBridge;
+exports.syncTableWorker = syncTableWorker;
+exports.workerRowModelsFeature = workerRowModelsFeature;
+//# sourceMappingURL=createTableWorker.cjs.map

package/dist/worker/createTableWorker.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTableWorker.cjs","names":["tableWorkerPipeline","tableWorkerStageStateDeps"],"sources":["../../src/worker/createTableWorker.ts"],"sourcesContent":["import { table_autoResetPageIndex } from '../features/row-pagination/rowPaginationFeature.utils'\nimport { table_autoResetExpanded } from '../features/row-expanding/rowExpandingFeature.utils'\nimport {\n  tableWorkerPipeline,\n  tableWorkerStageStateDeps,\n} from './tableWorkerProtocol'\nimport type { Table_Internal } from '../types/Table'\nimport type { TableFeature } from '../types/TableFeatures'\nimport type { TableWorkerDataPayload } from './rebuildRowModel'\nimport type {\n  TableState_WorkerRowModels,\n  TableWorkerResponse,\n  TableWorkerStage,\n  TableWorkerStagePayload,\n} from './tableWorkerProtocol'\n\n// Importing anything from this module (e.g. `workerRowModelsFeature`)\n// registers the plugin key and its state slice with the core type maps, so\n// userland needs no `declare module` of its own. Apps that never use worker\n// row models never load this module and never see the types.\ndeclare module '../types/TableFeatures' {\n  interface Plugins {\n    workerRowModelsFeature: TableFeature\n  }\n}\ndeclare module '../types/TableState' {\n  interface TableState_FeatureMap {\n    workerRowModelsFeature: TableState_WorkerRowModels\n  }\n}\n\nexport interface TableWorkerOptions {\n  /**\n   * Creates the dedicated worker that runs the shadow table. The worker entry\n   * must call `initTableWorker` with the same columns and processing config.\n   *\n   * The `new Worker(new URL(...))` expression must live in your code (not the\n   * library) so your bundler can statically discover and bundle the worker\n   * entry file.\n   *\n   * @example\n   * ```ts\n   * createWorker: () =>\n   *   new Worker(new URL('./table.worker.ts', import.meta.url), {\n   *     type: 'module',\n   *   })\n   * ```\n   */\n  createWorker: () => Worker\n}\n\nexport interface TableWorkerBridge {\n  worker: Worker | null\n  /** The worker errored (load failure or uncaught throw); stop posting. */\n  failed: boolean\n  lastData: unknown\n  dataVersion: number\n  requestId: number\n  resultRequestId: number\n  /** A process request has been posted and its result has not arrived yet. */\n  inFlight: boolean\n  /** State changed since the last posted request; post when possible. */\n  needsProcess: boolean\n  sentAt: number\n  /** The stages registered on this table (grows as factories initialize). */\n  stages: Set<TableWorkerStage>\n  /** Snapshot of state refs + stage count captured at the last post. */\n  sentState: Record<string, unknown> | null\n  sentStageCount: number\n  /** Latest observed state refs, posted on the trailing edge if in flight. */\n  lastState: Record<string, unknown>\n  results: { [K in TableWorkerStage]?: TableWorkerDataPayload }\n  /** Bumped per stage only when that stage's payload actually changed. */\n  stageVersions: { [K in TableWorkerStage]?: number }\n}\n\ntype AnyTable = Table_Internal<any, any>\n\n/**\n * A handle shared by every worker-backed row model on a table. It owns the\n * worker instance and the per-table request/result bookkeeping, so registering\n * one stage or four costs exactly one worker and one round trip per change.\n */\nexport interface TableWorker {\n  _options: TableWorkerOptions\n  _bridges: WeakMap<object, TableWorkerBridge>\n  _liveBridges: Set<TableWorkerBridge>\n  /**\n   * Terminates every worker created through this handle and resets the\n   * bookkeeping. Safe to call at any time: the next row model read lazily\n   * recreates the worker and re-sends the data (self-healing). Note that\n   * nothing calls this automatically yet; React StrictMode double-mounts and\n   * HMR updates still leak a worker in development until the reactivity\n   * bindings grow a real `unmount` hook.\n   */\n  terminate: () => void\n}\n\n/**\n * Registers the `workerRowModels` state slice\n * (`{ version, isPending, lastComputeMs, lastRoundTripMs }`). Worker results\n * land by bumping `version`, so re-renders flow through the exact same state\n * mechanism as every other table state change.\n */\nexport const workerRowModelsFeature: TableFeature = {\n  getInitialState: (initialState: any) => ({\n    workerRowModels: { version: 0, isPending: false },\n    ...initialState,\n  }),\n}\n\n/**\n * Creates the shared worker handle for a table's worker-backed row models.\n * Pass it to `createWorkerRowModel()` once per stage you want offloaded.\n */\nexport function createTableWorker(options: TableWorkerOptions): TableWorker {\n  const liveBridges = new Set<TableWorkerBridge>()\n  return {\n    _options: options,\n    _bridges: new WeakMap(),\n    _liveBridges: liveBridges,\n    terminate: () => {\n      for (const bridge of liveBridges) {\n        bridge.worker?.terminate()\n        bridge.worker = null\n        bridge.failed = false\n        bridge.lastData = undefined\n        bridge.inFlight = false\n        bridge.needsProcess = true\n        bridge.sentState = null\n        bridge.sentStageCount = 0\n      }\n      liveBridges.clear()\n    },\n  }\n}\n\nexport function getTableWorkerBridge(\n  tableWorker: TableWorker,\n  table: AnyTable,\n): TableWorkerBridge {\n  let bridge = tableWorker._bridges.get(table)\n  if (!bridge) {\n    bridge = {\n      worker: null,\n      failed: false,\n      lastData: undefined,\n      dataVersion: 0,\n      requestId: 0,\n      resultRequestId: 0,\n      inFlight: false,\n      needsProcess: true,\n      sentAt: 0,\n      stages: new Set(),\n      sentState: null,\n      sentStageCount: 0,\n      lastState: {},\n      results: {},\n      stageVersions: {},\n    }\n    tableWorker._bridges.set(table, bridge)\n  }\n  return bridge\n}\n\n/** Shallow reference comparison; atoms return stable refs when unchanged. */\nfunction statesEqual(\n  a: Record<string, unknown> | null,\n  b: Record<string, unknown>,\n): boolean {\n  if (a === null) return false\n  const aKeys = Object.keys(a)\n  const bKeys = Object.keys(b)\n  if (aKeys.length !== bKeys.length) return false\n  for (const key of bKeys) {\n    if (a[key] !== b[key]) return false\n  }\n  return true\n}\n\nfunction setWorkerRowModelsState(\n  table: AnyTable,\n  update: (prev: any) => Record<string, unknown>,\n) {\n  const stateAtom = (table.baseAtoms as Record<string, any>).workerRowModels\n  stateAtom?.set((prev: any) => update(prev ?? { version: 0 }))\n}\n\nfunction postProcess(table: AnyTable, bridge: TableWorkerBridge): void {\n  const stages = tableWorkerPipeline.filter((stage) => bridge.stages.has(stage))\n  bridge.needsProcess = false\n  bridge.sentState = bridge.lastState\n  bridge.sentStageCount = bridge.stages.size\n  bridge.inFlight = true\n  bridge.sentAt = performance.now()\n  const requestId = ++bridge.requestId\n  bridge.worker!.postMessage({\n    type: 'process',\n    requestId,\n    dataVersion: bridge.dataVersion,\n    stages,\n    state: bridge.lastState,\n  })\n  // postProcess can run during render (via sync); defer the pending write.\n  table._reactivity.schedule(() => {\n    if (bridge.requestId === requestId && bridge.resultRequestId < requestId) {\n      setWorkerRowModelsState(table, (prev) => ({ ...prev, isPending: true }))\n    }\n  })\n}\n\nfunction handleResult(\n  table: AnyTable,\n  bridge: TableWorkerBridge,\n  message: TableWorkerResponse,\n) {\n  if (message.requestId !== bridge.requestId) return\n  bridge.inFlight = false\n  bridge.resultRequestId = message.requestId\n\n  // A data change raced this request: the result is for the old dataset.\n  // Drop it and immediately re-process against the new data.\n  if (message.dataVersion !== bridge.dataVersion) {\n    postProcess(table, bridge)\n    return\n  }\n\n  // Merge stage payloads: `unchanged` keeps the previous result (and its\n  // rebuilt model, via the per-stage version), changed payloads replace it.\n  let anyChanged = false\n  let groupedChanged = false\n  for (const [stage, payload] of Object.entries(message.stages) as Array<\n    [TableWorkerStage, TableWorkerStagePayload]\n  >) {\n    if (payload.kind === 'unchanged') continue\n    bridge.results[stage] = payload\n    bridge.stageVersions[stage] = (bridge.stageVersions[stage] ?? 0) + 1\n    anyChanged = true\n    if (stage === 'grouped') groupedChanged = true\n  }\n\n  const roundTripMs = performance.now() - bridge.sentAt\n  setWorkerRowModelsState(table, (prev) => ({\n    version: (prev.version ?? 0) + 1,\n    isPending: false,\n    lastComputeMs: message.computeMs,\n    lastRoundTripMs: roundTripMs,\n  }))\n\n  // The async equivalent of the sync models' `onAfterUpdate` hooks. The\n  // worker's unchanged-detection is its memo identity, so `groupedChanged`\n  // mirrors exactly when the sync grouped model would have recomputed (and\n  // reset expansion).\n  if (anyChanged) {\n    table._reactivity.schedule(() =>\n      table._reactivity.untrack(() => {\n        if (groupedChanged) {\n          table_autoResetExpanded(table)\n        }\n        table_autoResetPageIndex(table)\n      }),\n    )\n  }\n\n  // Trailing edge: state changed while this request was in flight.\n  if (bridge.needsProcess) {\n    postProcess(table, bridge)\n  }\n}\n\nfunction handleError(\n  table: AnyTable,\n  bridge: TableWorkerBridge,\n  event: unknown,\n) {\n  if (bridge.failed) return\n  bridge.failed = true\n  bridge.inFlight = false\n  console.error(\n    '[table-worker] The table worker failed; worker row models will keep ' +\n      'their last results and stop updating. Check that the worker entry ' +\n      'loads and that its initTableWorker() config is thread-portable.',\n    event,\n  )\n  bridge.worker?.terminate()\n  bridge.worker = null\n  setWorkerRowModelsState(table, (prev) => ({ ...prev, isPending: false }))\n}\n\nfunction ensureWorker(\n  tableWorker: TableWorker,\n  table: AnyTable,\n  bridge: TableWorkerBridge,\n) {\n  if (bridge.worker) return\n  bridge.worker = tableWorker._options.createWorker()\n  tableWorker._liveBridges.add(bridge)\n  bridge.worker.onmessage = (event: MessageEvent<TableWorkerResponse>) => {\n    handleResult(table, bridge, event.data)\n  }\n  bridge.worker.onerror = (event) => handleError(table, bridge, event)\n  bridge.worker.onmessageerror = (event) => handleError(table, bridge, event)\n}\n\n/**\n * Pull-based sync, called at the top of every worker-backed row model read\n * (i.e. every render). Posts data on identity change and a single-flight\n * process request on state change; both are cheap no-ops otherwise, and\n * multiple stages sharing the handle dedupe onto one request.\n */\nexport function syncTableWorker(tableWorker: TableWorker, table: AnyTable) {\n  // SSR: no Worker global. Getters fall back to pre-stage models, so the\n  // server renders unprocessed rows and the client takes over after hydration.\n  if (typeof Worker === 'undefined') return\n\n  const bridge = getTableWorkerBridge(tableWorker, table)\n  if (bridge.failed) return\n  ensureWorker(tableWorker, table, bridge)\n\n  const data = table.options.data\n  if (data !== bridge.lastData) {\n    bridge.lastData = data\n    bridge.dataVersion++\n    bridge.worker!.postMessage({\n      type: 'data',\n      dataVersion: bridge.dataVersion,\n      data,\n    })\n    bridge.needsProcess = true\n  }\n\n  // Union of the registered stages' state deps, compared by reference (atoms\n  // return stable refs when a slice did not change).\n  const atoms = table.atoms as Record<string, any>\n  const state: Record<string, unknown> = {}\n  for (const stage of bridge.stages) {\n    for (const key of tableWorkerStageStateDeps[stage]) {\n      state[key] = atoms[key]?.get()\n    }\n  }\n  bridge.lastState = state\n\n  if (\n    !bridge.needsProcess &&\n    (!statesEqual(bridge.sentState, state) ||\n      bridge.stages.size !== bridge.sentStageCount)\n  ) {\n    bridge.needsProcess = true\n  }\n\n  // Single-flight: at most one request in the worker at a time. If one is in\n  // flight, the latest state is posted from the result handler (trailing\n  // edge), so rapid input coalesces instead of queueing doomed computes.\n  if (bridge.needsProcess && !bridge.inFlight) {\n    postProcess(table, bridge)\n  }\n}\n"],"mappings":"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"}

package/dist/worker/createTableWorker.d.cts

@@ -0,0 +1,102 @@
+import { TableState_WorkerRowModels, TableWorkerStage } from "./tableWorkerProtocol.cjs";
+import { Table } from "../types/Table.cjs";
+import { TableFeature } from "../types/TableFeatures.cjs";
+import { TableWorkerDataPayload } from "./rebuildRowModel.cjs";
+
+//#region src/worker/createTableWorker.d.ts
+declare module '../types/TableFeatures' {
+  interface Plugins {
+    workerRowModelsFeature: TableFeature;
+  }
+}
+declare module '../types/TableState' {
+  interface TableState_FeatureMap {
+    workerRowModelsFeature: TableState_WorkerRowModels;
+  }
+}
+interface TableWorkerOptions {
+  /**
+   * Creates the dedicated worker that runs the shadow table. The worker entry
+   * must call `initTableWorker` with the same columns and processing config.
+   *
+   * The `new Worker(new URL(...))` expression must live in your code (not the
+   * library) so your bundler can statically discover and bundle the worker
+   * entry file.
+   *
+   * @example
+   * ```ts
+   * createWorker: () =>
+   *   new Worker(new URL('./table.worker.ts', import.meta.url), {
+   *     type: 'module',
+   *   })
+   * ```
+   */
+  createWorker: () => Worker;
+}
+interface TableWorkerBridge {
+  worker: Worker | null;
+  /** The worker errored (load failure or uncaught throw); stop posting. */
+  failed: boolean;
+  lastData: unknown;
+  dataVersion: number;
+  requestId: number;
+  resultRequestId: number;
+  /** A process request has been posted and its result has not arrived yet. */
+  inFlight: boolean;
+  /** State changed since the last posted request; post when possible. */
+  needsProcess: boolean;
+  sentAt: number;
+  /** The stages registered on this table (grows as factories initialize). */
+  stages: Set<TableWorkerStage>;
+  /** Snapshot of state refs + stage count captured at the last post. */
+  sentState: Record<string, unknown> | null;
+  sentStageCount: number;
+  /** Latest observed state refs, posted on the trailing edge if in flight. */
+  lastState: Record<string, unknown>;
+  results: { [K in TableWorkerStage]?: TableWorkerDataPayload };
+  /** Bumped per stage only when that stage's payload actually changed. */
+  stageVersions: { [K in TableWorkerStage]?: number };
+}
+type AnyTable = Table<any, any>;
+/**
+ * A handle shared by every worker-backed row model on a table. It owns the
+ * worker instance and the per-table request/result bookkeeping, so registering
+ * one stage or four costs exactly one worker and one round trip per change.
+ */
+interface TableWorker {
+  _options: TableWorkerOptions;
+  _bridges: WeakMap<object, TableWorkerBridge>;
+  _liveBridges: Set<TableWorkerBridge>;
+  /**
+   * Terminates every worker created through this handle and resets the
+   * bookkeeping. Safe to call at any time: the next row model read lazily
+   * recreates the worker and re-sends the data (self-healing). Note that
+   * nothing calls this automatically yet; React StrictMode double-mounts and
+   * HMR updates still leak a worker in development until the reactivity
+   * bindings grow a real `unmount` hook.
+   */
+  terminate: () => void;
+}
+/**
+ * Registers the `workerRowModels` state slice
+ * (`{ version, isPending, lastComputeMs, lastRoundTripMs }`). Worker results
+ * land by bumping `version`, so re-renders flow through the exact same state
+ * mechanism as every other table state change.
+ */
+declare const workerRowModelsFeature: TableFeature;
+/**
+ * Creates the shared worker handle for a table's worker-backed row models.
+ * Pass it to `createWorkerRowModel()` once per stage you want offloaded.
+ */
+declare function createTableWorker(options: TableWorkerOptions): TableWorker;
+declare function getTableWorkerBridge(tableWorker: TableWorker, table: AnyTable): TableWorkerBridge;
+/**
+ * Pull-based sync, called at the top of every worker-backed row model read
+ * (i.e. every render). Posts data on identity change and a single-flight
+ * process request on state change; both are cheap no-ops otherwise, and
+ * multiple stages sharing the handle dedupe onto one request.
+ */
+declare function syncTableWorker(tableWorker: TableWorker, table: AnyTable): void;
+//#endregion
+export { TableWorker, TableWorkerBridge, TableWorkerOptions, createTableWorker, getTableWorkerBridge, syncTableWorker, workerRowModelsFeature };
+//# sourceMappingURL=createTableWorker.d.cts.map

package/dist/worker/createTableWorker.d.ts

@@ -0,0 +1,102 @@
+import { TableState_WorkerRowModels, TableWorkerStage } from "./tableWorkerProtocol.js";
+import { Table } from "../types/Table.js";
+import { TableFeature } from "../types/TableFeatures.js";
+import { TableWorkerDataPayload } from "./rebuildRowModel.js";
+
+//#region src/worker/createTableWorker.d.ts
+declare module '../types/TableFeatures' {
+  interface Plugins {
+    workerRowModelsFeature: TableFeature;
+  }
+}
+declare module '../types/TableState' {
+  interface TableState_FeatureMap {
+    workerRowModelsFeature: TableState_WorkerRowModels;
+  }
+}
+interface TableWorkerOptions {
+  /**
+   * Creates the dedicated worker that runs the shadow table. The worker entry
+   * must call `initTableWorker` with the same columns and processing config.
+   *
+   * The `new Worker(new URL(...))` expression must live in your code (not the
+   * library) so your bundler can statically discover and bundle the worker
+   * entry file.
+   *
+   * @example
+   * ```ts
+   * createWorker: () =>
+   *   new Worker(new URL('./table.worker.ts', import.meta.url), {
+   *     type: 'module',
+   *   })
+   * ```
+   */
+  createWorker: () => Worker;
+}
+interface TableWorkerBridge {
+  worker: Worker | null;
+  /** The worker errored (load failure or uncaught throw); stop posting. */
+  failed: boolean;
+  lastData: unknown;
+  dataVersion: number;
+  requestId: number;
+  resultRequestId: number;
+  /** A process request has been posted and its result has not arrived yet. */
+  inFlight: boolean;
+  /** State changed since the last posted request; post when possible. */
+  needsProcess: boolean;
+  sentAt: number;
+  /** The stages registered on this table (grows as factories initialize). */
+  stages: Set<TableWorkerStage>;
+  /** Snapshot of state refs + stage count captured at the last post. */
+  sentState: Record<string, unknown> | null;
+  sentStageCount: number;
+  /** Latest observed state refs, posted on the trailing edge if in flight. */
+  lastState: Record<string, unknown>;
+  results: { [K in TableWorkerStage]?: TableWorkerDataPayload };
+  /** Bumped per stage only when that stage's payload actually changed. */
+  stageVersions: { [K in TableWorkerStage]?: number };
+}
+type AnyTable = Table<any, any>;
+/**
+ * A handle shared by every worker-backed row model on a table. It owns the
+ * worker instance and the per-table request/result bookkeeping, so registering
+ * one stage or four costs exactly one worker and one round trip per change.
+ */
+interface TableWorker {
+  _options: TableWorkerOptions;
+  _bridges: WeakMap<object, TableWorkerBridge>;
+  _liveBridges: Set<TableWorkerBridge>;
+  /**
+   * Terminates every worker created through this handle and resets the
+   * bookkeeping. Safe to call at any time: the next row model read lazily
+   * recreates the worker and re-sends the data (self-healing). Note that
+   * nothing calls this automatically yet; React StrictMode double-mounts and
+   * HMR updates still leak a worker in development until the reactivity
+   * bindings grow a real `unmount` hook.
+   */
+  terminate: () => void;
+}
+/**
+ * Registers the `workerRowModels` state slice
+ * (`{ version, isPending, lastComputeMs, lastRoundTripMs }`). Worker results
+ * land by bumping `version`, so re-renders flow through the exact same state
+ * mechanism as every other table state change.
+ */
+declare const workerRowModelsFeature: TableFeature;
+/**
+ * Creates the shared worker handle for a table's worker-backed row models.
+ * Pass it to `createWorkerRowModel()` once per stage you want offloaded.
+ */
+declare function createTableWorker(options: TableWorkerOptions): TableWorker;
+declare function getTableWorkerBridge(tableWorker: TableWorker, table: AnyTable): TableWorkerBridge;
+/**
+ * Pull-based sync, called at the top of every worker-backed row model read
+ * (i.e. every render). Posts data on identity change and a single-flight
+ * process request on state change; both are cheap no-ops otherwise, and
+ * multiple stages sharing the handle dedupe onto one request.
+ */
+declare function syncTableWorker(tableWorker: TableWorker, table: AnyTable): void;
+//#endregion
+export { TableWorker, TableWorkerBridge, TableWorkerOptions, createTableWorker, getTableWorkerBridge, syncTableWorker, workerRowModelsFeature };
+//# sourceMappingURL=createTableWorker.d.ts.map