@tanstack/table-core 9.0.0-alpha.6 → 9.0.0-beta.1

package/dist/utils.js

@@ -0,0 +1,232 @@
+//#region src/utils.ts
+/**
+* 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.
+*/
+function functionalUpdate(updater, input) {
+	return typeof updater === "function" ? updater(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.
+*/
+function cloneState(value) {
+	if (Array.isArray(value)) return value.map(cloneState);
+	if (value && typeof value === "object") {
+		const proto = Object.getPrototypeOf(value);
+		if (proto !== Object.prototype && proto !== null) return value;
+		const copy = {};
+		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;
+}
+/**
+* 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.
+*/
+function makeStateUpdater(key, instance) {
+	return (updater) => {
+		var _atoms;
+		(((_atoms = instance.options.atoms) === null || _atoms === void 0 ? void 0 : _atoms[key]) ?? instance.baseAtoms[key]).set((old) => functionalUpdate(updater, old));
+	};
+}
+/**
+* Returns whether a value is a function.
+*/
+function isFunction(d) {
+	return d instanceof Function;
+}
+/**
+* Flattens a tree of nodes by recursively reading child nodes.
+*
+* The original nodes are preserved in depth-first order.
+*/
+function flattenBy(arr, getChildren) {
+	const flat = [];
+	const recurse = (subArr) => {
+		subArr.forEach((item) => {
+			flat.push(item);
+			const children = getChildren(item);
+			if (children.length) recurse(children);
+		});
+	};
+	recurse(arr);
+	return flat;
+}
+/**
+* Creates a dependency-tracked memoized function for table internals.
+*
+* The memo recomputes only when its dependency tuple changes and can emit debug timing information.
+*/
+const memo = ({ fn, memoDeps, onAfterCompare, onAfterUpdate, onBeforeCompare, onBeforeUpdate }) => {
+	let deps = [];
+	let result;
+	const memoizedFn = (depArgs) => {
+		onBeforeCompare === null || onBeforeCompare === void 0 || onBeforeCompare();
+		const newDeps = memoDeps === null || memoDeps === void 0 ? void 0 : memoDeps(depArgs);
+		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;
+		onBeforeUpdate === null || onBeforeUpdate === void 0 || onBeforeUpdate();
+		result = fn(...newDeps ?? []);
+		onAfterUpdate === null || onAfterUpdate === void 0 || onAfterUpdate(result);
+		return result;
+	};
+	return memoizedFn;
+};
+const pad = (str, num) => {
+	str = String(str);
+	while (str.length < num) str = " " + str;
+	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.
+*/
+function tableMemo({ feature, fnName, objectId, onAfterUpdate, table, ...memoOptions }) {
+	let beforeCompareTime;
+	let afterCompareTime;
+	let startCalcTime;
+	let endCalcTime;
+	let runCount = 0;
+	let debug;
+	let debugCache;
+	if (process.env.NODE_ENV === "development") {
+		const { debugCache: _debugCache, debugAll } = table.options;
+		debugCache = _debugCache;
+		const { parentName } = getFunctionNameInfo(fnName, ".");
+		debug = debugAll || table.options[`debug${(parentName != "table" ? parentName + "s" : parentName).replace(parentName, parentName.charAt(0).toUpperCase() + parentName.slice(1))}`] || (feature ? table.options[`debug${feature.charAt(0).toUpperCase() + feature.slice(1)}`] : false);
+	}
+	function logTime(time, depsChanged) {
+		var _memoOptions$memoDeps;
+		const runType = runCount === 0 ? "(1st run)" : depsChanged ? "(rerun #" + runCount + ")" : "(cache)";
+		runCount++;
+		console.groupCollapsed(`%c⏱ ${pad(`${time.toFixed(1)} ms`, 12)} %c${runType}%c ${fnName}%c ${objectId ? `(${fnName.split(".")[0]}Id: ${objectId})` : ""}`, `font-size: .6rem; font-weight: bold; ${depsChanged ? `color: hsl(
+        ${Math.max(0, Math.min(120 - Math.log10(time) * 60, 120))}deg 100% 31%);` : ""} `, `color: ${runCount < 2 ? "#FF00FF" : "#FF1493"}`, "color: #666", "color: #87CEEB");
+		console.info({
+			feature,
+			state: table.store.state,
+			deps: (_memoOptions$memoDeps = memoOptions.memoDeps) === null || _memoOptions$memoDeps === void 0 ? void 0 : _memoOptions$memoDeps.toString()
+		});
+		console.trace();
+		console.groupEnd();
+	}
+	const onAfterUpdateHandler = () => {
+		if (!onAfterUpdate) return;
+		const { schedule, untrack } = table._reactivity;
+		schedule(() => untrack(() => onAfterUpdate()));
+	};
+	const debugOptions = process.env.NODE_ENV === "development" ? {
+		onBeforeCompare: () => {
+			if (debugCache) beforeCompareTime = performance.now();
+		},
+		onAfterCompare: (depsChanged) => {
+			if (debugCache) {
+				afterCompareTime = performance.now();
+				const compareTime = Math.round((afterCompareTime - beforeCompareTime) * 100) / 100;
+				if (!depsChanged) logTime(compareTime, depsChanged);
+			}
+		},
+		onBeforeUpdate: () => {
+			if (debug) startCalcTime = performance.now();
+		},
+		onAfterUpdate: () => {
+			if (debug) {
+				endCalcTime = performance.now();
+				logTime(Math.round((endCalcTime - startCalcTime) * 100) / 100, true);
+			}
+			onAfterUpdateHandler();
+		}
+	} : { onAfterUpdate: () => {
+		onAfterUpdateHandler();
+	} };
+	return memo({
+		...memoOptions,
+		...debugOptions
+	});
+}
+/**
+* Assumes that a function name is in the format of `parentName_fnKey` and returns the `fnKey` and `fnName` in the format of `parentName.fnKey`.
+*/
+function getFunctionNameInfo(staticFnName, splitBy = "_") {
+	const [parentName, fnKey] = staticFnName.split(splitBy);
+	return {
+		fnKey,
+		fnName: `${parentName}.${fnKey}`,
+		parentName
+	};
+}
+/**
+* Assigns Table API methods directly to the table instance.
+* Unlike row/cell/column/header, the table is a singleton so methods are assigned directly.
+*/
+function assignTableAPIs(feature, table, apis) {
+	for (const [staticFnName, { fn, memoDeps }] of Object.entries(apis)) {
+		const { fnKey, fnName } = getFunctionNameInfo(staticFnName);
+		table[fnKey] = memoDeps ? tableMemo({
+			memoDeps,
+			fn,
+			fnName,
+			table,
+			feature
+		}) : fn;
+	}
+}
+/**
+* Assigns API methods to a prototype object for memory-efficient method sharing.
+* All instances created with this prototype will share the same method references.
+*
+* For memoized methods, the memo state is lazily created and stored on each instance.
+* This provides the best of both worlds: shared method code + per-instance caching.
+*/
+function assignPrototypeAPIs(feature, prototype, table, apis) {
+	for (const [staticFnName, { fn, memoDeps }] of Object.entries(apis)) {
+		const { fnKey, fnName } = getFunctionNameInfo(staticFnName);
+		if (memoDeps) {
+			const memoKey = `_memo_${fnKey}`;
+			prototype[fnKey] = function(...args) {
+				if (!this[memoKey]) {
+					const self = this;
+					this[memoKey] = tableMemo({
+						memoDeps: (depArgs) => memoDeps(self, depArgs),
+						fn: (...deps) => fn(self, ...deps),
+						fnName,
+						objectId: self.id,
+						table,
+						feature
+					});
+				}
+				return this[memoKey](...args);
+			};
+		} else prototype[fnKey] = function(...args) {
+			return fn(this, ...args);
+		};
+	}
+}
+/**
+* Looks to run the memoized function with the builder pattern on the object if it exists, otherwise fallback to the static method passed in.
+*/
+function callMemoOrStaticFn(obj, fnKey, staticFn, ...args) {
+	var _obj$fnKey;
+	return ((_obj$fnKey = obj[fnKey]) === null || _obj$fnKey === void 0 ? void 0 : _obj$fnKey.call(obj, ...args)) ?? staticFn(obj, ...args);
+}
+
+//#endregion
+export { assignPrototypeAPIs, assignTableAPIs, callMemoOrStaticFn, cloneState, flattenBy, functionalUpdate, getFunctionNameInfo, isFunction, makeStateUpdater, memo, tableMemo };
+//# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -0,0 +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  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.6",
+  "version": "9.0.0-beta.1",
   "description": "Headless UI for building powerful tables & datagrids for TS/JS.",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -18,34 +18,61 @@
     "react",
     "vue",
     "solid",
+    "svelte",
+    "lit",
+    "angular",
     "table",
     "table-core",
-    "datagrid"
+    "datagrid",
+    "tanstack-intent"
   ],
   "type": "module",
-  "types": "dist/esm/index.d.ts",
-  "main": "dist/cjs/index.cjs",
-  "module": "dist/esm/index.js",
+  "types": "./dist/index.d.cts",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
   "exports": {
     ".": {
-      "import": {
-        "types": "./dist/esm/index.d.ts",
-        "default": "./dist/esm/index.js"
-      },
-      "require": {
-        "types": "./dist/cjs/index.d.cts",
-        "default": "./dist/cjs/index.cjs"
-      }
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./flex-render": {
+      "import": "./dist/flex-render.js",
+      "require": "./dist/flex-render.cjs"
+    },
+    "./reactivity": {
+      "import": "./dist/reactivity.js",
+      "require": "./dist/reactivity.cjs"
+    },
+    "./static-functions": {
+      "import": "./dist/static-functions.js",
+      "require": "./dist/static-functions.cjs"
+    },
+    "./store-reactivity-bindings": {
+      "import": "./dist/store-reactivity-bindings.js",
+      "require": "./dist/store-reactivity-bindings.cjs"
     },
     "./package.json": "./package.json"
   },
   "sideEffects": false,
   "engines": {
-    "node": ">=12"
+    "node": ">=16"
   },
   "files": [
     "dist/",
-    "src"
+    "src",
+    "skills"
   ],
-  "scripts": {}
+  "dependencies": {
+    "@tanstack/store": "^0.11.0"
+  },
+  "scripts": {
+    "clean": "rimraf ./build && rimraf ./dist",
+    "lint:fix": "eslint ./src --fix",
+    "test:eslint": "eslint ./src",
+    "test:lib": "vitest",
+    "test:lib:dev": "pnpm test:lib --watch",
+    "test:types": "tsc && tsc -p tests/tsconfig.declaration-emit.json",
+    "test:build": "publint --strict",
+    "build": "tsdown"
+  }
 }

package/skills/column-definitions/SKILL.md

@@ -0,0 +1,333 @@
+---
+name: column-definitions
+description: >
+  Define TanStack Table v9 columns with `createColumnHelper<typeof features, TData>()`.
+  Covers `columnHelper.accessor` (key + function forms), `columnHelper.display`,
+  `columnHelper.group`, `columnHelper.columns`, the `ColumnDef`/`AccessorKeyColumnDef`/
+  `AccessorFnColumnDef`/`DisplayColumnDef`/`GroupColumnDef` types, `accessorKey` with
+  `DeepKeys`, `accessorFn`, the `header`/`cell`/`footer`/`aggregatedCell` renderers,
+  required `id` rules, and `getRowId` for stable row identity.
+type: core
+library: tanstack-table
+library_version: '9.0.0-alpha.48'
+sources:
+  - TanStack/table:docs/guide/column-defs.md
+  - TanStack/table:docs/guide/columns.md
+  - TanStack/table:packages/table-core/src/helpers/columnHelper.ts
+  - TanStack/table:packages/table-core/src/core/columns/constructColumn.ts
+  - TanStack/table:examples/react/basic-use-table/src/main.tsx
+---
+
+## Setup
+
+`createColumnHelper` takes TWO generics in v9: the features type (so accessor keys, sort/filter strings, etc. are typed against your registered features) and the row data type.
+
+```ts
+import {
+  createColumnHelper,
+  tableFeatures,
+  rowSortingFeature,
+} from '@tanstack/table-core'
+
+type Person = {
+  id: string
+  firstName: string
+  lastName: string
+  age: number
+  visits: number
+}
+
+const features = tableFeatures({ rowSortingFeature })
+
+// TFeatures FIRST, TData SECOND
+const columnHelper = createColumnHelper<typeof features, Person>()
+
+const columns = columnHelper.columns([
+  // accessorKey — deep keys via DeepKeys (dot paths) are supported
+  columnHelper.accessor('firstName', { header: 'First Name' }),
+  columnHelper.accessor('lastName', { header: 'Last Name' }),
+  columnHelper.accessor('age', { header: 'Age' }),
+
+  // accessorFn — needs an explicit `id`
+  columnHelper.accessor((row) => `${row.firstName} ${row.lastName}`, {
+    id: 'fullName',
+    header: 'Full Name',
+    cell: (info) => info.getValue(),
+  }),
+
+  // display column — no value extraction, just rendering
+  columnHelper.display({
+    id: 'actions',
+    header: 'Actions',
+    cell: ({ row }) => `Edit ${row.original.id}`,
+  }),
+
+  // group column — wraps child columns under a shared header
+  columnHelper.group({
+    id: 'stats',
+    header: 'Stats',
+    columns: [columnHelper.accessor('visits', { header: 'Visits' })],
+  }),
+])
+```
+
+## Core Patterns
+
+### Stable row identity with `getRowId`
+
+```ts
+const table = useTable({
+  features,
+  rowModels: {},
+  columns,
+  data,
+  getRowId: (row) => row.id, // ← stable from row's own data
+})
+```
+
+Without `getRowId`, `row.id` defaults to the row's array index. Row-keyed state (selection, expansion, pinning) then attaches to whatever happens to be at that index after a sort/filter/refetch.
+
+### Accessor key with deep path
+
+```ts
+type User = { name: { first: string; last: string } }
+
+const columnHelper = createColumnHelper<typeof features, User>()
+
+columnHelper.accessor('name.first', { header: 'First' })
+columnHelper.accessor('name.last', { header: 'Last' })
+```
+
+For nested objects with non-optional intermediate keys, the dotted `accessorKey` form works and infers the right value type. Switch to `accessorFn` when intermediates are optional (see Common Mistakes below).
+
+### Header / cell / footer renderers
+
+```ts
+columnHelper.accessor('age', {
+  header: () => 'Age',
+  cell: (info) => info.getValue(),
+  footer: (info) => `${info.table.getRowModel().rows.length} rows`,
+})
+```
+
+Renderers accept string, JSX (in framework adapters), or function forms. Render via `flexRender(def, ctx)` or `<table.FlexRender header={header} />` so all three forms work uniformly.
+
+### `columnHelper.columns([...])` for module-scope stability
+
+```ts
+// Outside any component / hook — stable reference forever
+const columns = columnHelper.columns([
+  columnHelper.accessor('firstName', { header: 'First' }),
+  columnHelper.accessor('lastName', { header: 'Last' }),
+])
+```
+
+`columnHelper.columns` returns the array as-is but preserves the precise tuple types. Hoist to module scope or wrap in `useMemo` — the table compares `columns` by reference.
+
+## Common Mistakes
+
+### [CRITICAL] Passing only `TData` to `createColumnHelper`
+
+Wrong:
+
+```ts
+// v8 signature — TData ends up in the TFeatures slot
+const columnHelper = createColumnHelper<Person>()
+```
+
+Correct:
+
+```ts
+const features = tableFeatures({ rowSortingFeature })
+const columnHelper = createColumnHelper<typeof features, Person>()
+```
+
+v9 changed the generic order: `<TFeatures, TData>`. The compiler error is noisy because `Person` lands in the `TFeatures` slot and breaks every column type that follows.
+
+Source: packages/table-core/src/helpers/columnHelper.ts; docs/framework/react/guide/migrating.md
+
+### [HIGH] Accessor function returns an object or array
+
+Wrong:
+
+```ts
+// returns an object — built-in alphanumeric sort and includesString filter break
+columnHelper.accessor((row) => row.name, {
+  id: 'name',
+  cell: (info) => `${info.getValue().first} ${info.getValue().last}`,
+})
+```
+
+Correct:
+
+```ts
+// accessor returns a primitive; cell can still format it
+columnHelper.accessor((row) => `${row.name.first} ${row.name.last}`, {
+  id: 'fullName',
+  cell: (info) => info.getValue(),
+})
+```
+
+The accessed value drives sorting, filtering, faceting, and grouping. Built-in `sortFn`/`filterFn`/`aggregationFn` expect a primitive `string` / `number` / `Date`. Return a primitive — or supply a matching custom function.
+
+Source: docs/guide/column-defs.md
+
+### [CRITICAL] Omitting `id` on an `accessorFn` column
+
+Wrong:
+
+```tsx
+// accessorFn + JSX header => no id can be derived
+columnHelper.accessor((row) => row.lastName, {
+  header: () => <span>Last Name</span>,
+  cell: (info) => info.getValue(),
+})
+```
+
+Correct:
+
+```tsx
+columnHelper.accessor((row) => row.lastName, {
+  id: 'lastName', // required when there's no string accessorKey or string header
+  header: () => <span>Last Name</span>,
+  cell: (info) => info.getValue(),
+})
+```
+
+The constructor throws "coreColumnsFeature require an id when using an accessorFn" in development. The same applies to non-string `header` values without a fallback `id`.
+
+Source: packages/table-core/src/core/columns/constructColumn.ts
+
+### [CRITICAL] Defining `columns` inside the component without `useMemo`
+
+Wrong:
+
+```tsx
+function MyTable() {
+  // new array reference every render → infinite render loop
+  const columns = [
+    columnHelper.accessor('firstName', { header: 'First' }),
+    columnHelper.accessor('lastName', { header: 'Last' }),
+  ]
+  const table = useTable({ features, rowModels: {}, columns, data })
+}
+```
+
+Correct:
+
+```tsx
+function MyTable() {
+  const columns = React.useMemo(
+    () =>
+      columnHelper.columns([
+        columnHelper.accessor('firstName', { header: 'First' }),
+        columnHelper.accessor('lastName', { header: 'Last' }),
+      ]),
+    [],
+  )
+  const table = useTable({ features, rowModels: {}, columns, data })
+}
+```
+
+TanStack Table compares `columns` and `data` by reference. The #1 FAQ entry across versions.
+
+Source: docs/faq.md; examples/react/basic-subscribe/src/main.tsx
+
+### [HIGH] Using array-index row IDs with mutating data
+
+Wrong:
+
+```ts
+// no getRowId — rowSelection survives data updates but maps to wrong rows
+const table = useTable({
+  features,
+  rowModels: {},
+  columns,
+  data,
+  enableRowSelection: true,
+})
+```
+
+Correct:
+
+```ts
+const table = useTable({
+  features,
+  rowModels: {},
+  columns,
+  data,
+  getRowId: (row) => row.id,
+  enableRowSelection: true,
+})
+```
+
+When `data` reorders, filters, or items are removed/refetched, row-keyed state (selection, expansion, pinning) attaches to the wrong row.
+
+Source: docs/guide/rows.md; packages/table-core/src/core/rows/coreRowsFeature.utils.ts
+
+### [MEDIUM] `accessorKey` with optional path strips `undefined` from `getValue` type
+
+Wrong:
+
+```ts
+// amount inferred as `number` even though salary is optional
+columnHelper.accessor('user.salary.amount', {
+  cell: (info) => {
+    const amount = info.getValue() // type: number (WRONG)
+    return amount.toFixed(2) // crashes when salary is undefined
+  },
+})
+```
+
+Correct:
+
+```ts
+columnHelper.accessor((row) => row.user.salary?.amount, {
+  id: 'salary',
+  cell: (info) => {
+    const amount = info.getValue() // type: number | undefined
+    return amount?.toFixed(2) ?? '-'
+  },
+})
+```
+
+The `DeepValue` type doesn't propagate `undefined` through optional intermediates. Use `accessorFn` when any segment is optional — the type follows the expression.
+
+Source: https://github.com/TanStack/table/issues/6238
+
+### [MEDIUM] `columnHelper.accessor` nested inside `columnHelper.group` loses `getValue` inference
+
+Wrong:
+
+```ts
+// info.getValue() inferred as unknown
+columnHelper.group({
+  id: 'name',
+  columns: [
+    columnHelper.accessor('firstName', {
+      cell: (info) => info.getValue(), // unknown
+    }),
+  ],
+})
+```
+
+Correct:
+
+```ts
+// Hoist accessor definitions out of the group
+const firstNameCol = columnHelper.accessor('firstName', {
+  cell: (info) => info.getValue(), // string
+})
+
+columnHelper.group({ id: 'name', columns: [firstNameCol] })
+```
+
+The group helper's overloads don't thread `TData` through correctly when accessors are defined inline.
+
+Source: https://github.com/TanStack/table/issues/5860
+
+## See also
+
+- `tanstack-table/setup` — how `features` and `rowModels` thread through `useTable`
+- `tanstack-table/customizing-feature-behavior` — per-column `sortFn`/`filterFn`/`aggregationFn`
+- `tanstack-table/row-selection` — why `getRowId` is essentially mandatory