@tanstack/table-core 9.0.0-beta.52 → 9.0.0-beta.53

package/dist/worker/createTableWorker.cjs

@@ -1,189 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,102 +0,0 @@
-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.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createTableWorker.js","names":[],"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/createWorkerRowModel.cjs

@@ -1,78 +0,0 @@
-const require_utils = require('../utils.cjs');
-const require_tableWorkerProtocol = require('./tableWorkerProtocol.cjs');
-const require_createTableWorker = require('./createTableWorker.cjs');
-const require_rebuildRowModel = require('./rebuildRowModel.cjs');
-
-//#region src/worker/createWorkerRowModel.ts
-function capitalize(stage) {
-	return stage.charAt(0).toUpperCase() + stage.slice(1);
-}
-/**
-* Turns any row model stage into a worker-backed one. The returned factory
-* plugs into the standard feature slot for that stage, so it composes with
-* the rest of the pipeline exactly like the sync factory it replaces.
-*
-* Register only the stages you want offloaded; each import is independent and
-* tree-shakable. All stages on a table share one worker and one round trip
-* per state change via the `tableWorker` handle. Until a result lands, the
-* stage returns its pre-stage model (stale-while-revalidate).
-*
-* Offloaded stages must form a contiguous prefix of the pipeline
-* (filtered -> grouped -> sorted -> expanded): a stage's worker result encodes
-* everything upstream as computed in the worker, so any upstream stage
-* registered on the main thread must be offloaded too. A dev warning fires on
-* mismatches.
-*
-* @example
-* ```ts
-* const tableWorker = createTableWorker({ createWorker })
-*
-* const features = tableFeatures({
-*   rowSortingFeature,
-*   columnGroupingFeature,
-*   workerRowModelsFeature,
-*   filteredRowModel: createWorkerRowModel(tableWorker, 'filtered'),
-*   groupedRowModel: createWorkerRowModel(tableWorker, 'grouped'),
-*   sortedRowModel: createWorkerRowModel(tableWorker, 'sorted'),
-* })
-* ```
-*/
-function createWorkerRowModel(tableWorker, stage) {
-	return (_table) => {
-		const table = _table;
-		require_createTableWorker.getTableWorkerBridge(tableWorker, table).stages.add(stage);
-		let warned = false;
-		const warnOnce = (message) => {
-			if (process.env.NODE_ENV === "development" && !warned) {
-				warned = true;
-				console.warn(`[table-worker] ${message}`);
-			}
-		};
-		const memoized = require_utils.tableMemo({
-			table,
-			fnName: `table.get${capitalize(stage)}RowModel`,
-			memoDeps: () => [table.getCoreRowModel(), require_createTableWorker.getTableWorkerBridge(tableWorker, table).stageVersions[stage]],
-			fn: () => {
-				const bridge = require_createTableWorker.getTableWorkerBridge(tableWorker, table);
-				const payload = bridge.results[stage];
-				if (!payload) {
-					if (bridge.resultRequestId > 0) warnOnce(`The worker returned no '${stage}' result. Make sure the worker's initTableWorker() config registers a ${stage}RowModel factory.`);
-					return table[`getPre${capitalize(stage)}RowModel`]();
-				}
-				if (bridge.resultRequestId > 0) for (const upstream of require_tableWorkerProtocol.tableWorkerPipeline) {
-					if (upstream === stage) break;
-					if (table.options.features[`${upstream}RowModel`] && !bridge.results[upstream]) warnOnce(`This table has a ${upstream}RowModel, but the worker result for '${stage}' was computed without an offloaded '${upstream}' stage, so it is bypassed. Offload it too with createWorkerRowModel(tableWorker, '${upstream}').`);
-				}
-				return require_rebuildRowModel.rebuildRowModel(table, payload, stage !== "filtered");
-			}
-		});
-		return () => {
-			require_createTableWorker.syncTableWorker(tableWorker, table);
-			return memoized();
-		};
-	};
-}
-
-//#endregion
-exports.createWorkerRowModel = createWorkerRowModel;
-//# sourceMappingURL=createWorkerRowModel.cjs.map

package/dist/worker/createWorkerRowModel.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createWorkerRowModel.cjs","names":["tableMemo","getTableWorkerBridge","tableWorkerPipeline","rebuildRowModel"],"sources":["../../src/worker/createWorkerRowModel.ts"],"sourcesContent":["import { tableMemo } from '../utils'\nimport { getTableWorkerBridge, syncTableWorker } from './createTableWorker'\nimport { rebuildRowModel } from './rebuildRowModel'\nimport { tableWorkerPipeline } from './tableWorkerProtocol'\nimport type { RowModel } from '../core/row-models/coreRowModelsFeature.types'\nimport type { Table, Table_Internal } from '../types/Table'\nimport type { TableFeatures } from '../types/TableFeatures'\nimport type { RowData } from '../types/type-utils'\nimport type { TableWorker } from './createTableWorker'\nimport type { TableWorkerStage } from './tableWorkerProtocol'\n\ntype AnyTable = Table_Internal<any, any>\n\nfunction capitalize(stage: string) {\n  return stage.charAt(0).toUpperCase() + stage.slice(1)\n}\n\n/**\n * Turns any row model stage into a worker-backed one. The returned factory\n * plugs into the standard feature slot for that stage, so it composes with\n * the rest of the pipeline exactly like the sync factory it replaces.\n *\n * Register only the stages you want offloaded; each import is independent and\n * tree-shakable. All stages on a table share one worker and one round trip\n * per state change via the `tableWorker` handle. Until a result lands, the\n * stage returns its pre-stage model (stale-while-revalidate).\n *\n * Offloaded stages must form a contiguous prefix of the pipeline\n * (filtered -> grouped -> sorted -> expanded): a stage's worker result encodes\n * everything upstream as computed in the worker, so any upstream stage\n * registered on the main thread must be offloaded too. A dev warning fires on\n * mismatches.\n *\n * @example\n * ```ts\n * const tableWorker = createTableWorker({ createWorker })\n *\n * const features = tableFeatures({\n *   rowSortingFeature,\n *   columnGroupingFeature,\n *   workerRowModelsFeature,\n *   filteredRowModel: createWorkerRowModel(tableWorker, 'filtered'),\n *   groupedRowModel: createWorkerRowModel(tableWorker, 'grouped'),\n *   sortedRowModel: createWorkerRowModel(tableWorker, 'sorted'),\n * })\n * ```\n */\nexport function createWorkerRowModel(\n  tableWorker: TableWorker,\n  stage: TableWorkerStage,\n) {\n  return <TFeatures extends TableFeatures, TData extends RowData>(\n    _table: Table<TFeatures, TData>,\n  ): (() => RowModel<TFeatures, TData>) => {\n    const table = _table as unknown as AnyTable\n    // Stages register per table as their factories initialize (first read).\n    // The first render may therefore fire one extra coalesced request while\n    // the stage set grows; single-flight makes it a cheap trailing request.\n    getTableWorkerBridge(tableWorker, table).stages.add(stage)\n    let warned = false\n\n    const warnOnce = (message: string) => {\n      if (process.env.NODE_ENV === 'development' && !warned) {\n        warned = true\n        console.warn(`[table-worker] ${message}`)\n      }\n    }\n\n    const memoized = tableMemo({\n      table,\n      fnName: `table.get${capitalize(stage)}RowModel`,\n      // The per-stage version bumps only when this stage's payload actually\n      // changed, so stages the worker reported as `unchanged` skip the O(n)\n      // rebuild entirely (the re-render itself rides the state slice bump).\n      memoDeps: () => [\n        table.getCoreRowModel(),\n        getTableWorkerBridge(tableWorker, table).stageVersions[stage],\n      ],\n      fn: () => {\n        const bridge = getTableWorkerBridge(tableWorker, table)\n        const payload = bridge.results[stage]\n        if (!payload) {\n          if (bridge.resultRequestId > 0) {\n            warnOnce(\n              `The worker returned no '${stage}' result. Make sure the ` +\n                `worker's initTableWorker() config registers a ` +\n                `${stage}RowModel factory.`,\n            )\n          }\n          return (table as any)[`getPre${capitalize(stage)}RowModel`]()\n        }\n        // Contiguous-prefix check: any upstream stage registered on this\n        // table must also have a worker result, or it is silently bypassed.\n        if (bridge.resultRequestId > 0) {\n          for (const upstream of tableWorkerPipeline) {\n            if (upstream === stage) break\n            if (\n              (table.options.features as Record<string, unknown>)[\n                `${upstream}RowModel`\n              ] &&\n              !bridge.results[upstream]\n            ) {\n              warnOnce(\n                `This table has a ${upstream}RowModel, but the worker result ` +\n                  `for '${stage}' was computed without an offloaded ` +\n                  `'${upstream}' stage, so it is bypassed. Offload it too ` +\n                  `with createWorkerRowModel(tableWorker, '${upstream}').`,\n              )\n            }\n          }\n        }\n        return rebuildRowModel(table, payload, stage !== 'filtered')\n      },\n    })\n\n    return () => {\n      syncTableWorker(tableWorker, table)\n      return memoized()\n    }\n  }\n}\n"],"mappings":";;;;;;AAaA,SAAS,WAAW,OAAe;CACjC,OAAO,MAAM,OAAO,CAAC,CAAC,CAAC,YAAY,IAAI,MAAM,MAAM,CAAC;AACtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,SAAgB,qBACd,aACA,OACA;CACA,QACE,WACuC;EACvC,MAAM,QAAQ;EAId,+CAAqB,aAAa,KAAK,CAAC,CAAC,OAAO,IAAI,KAAK;EACzD,IAAI,SAAS;EAEb,MAAM,YAAY,YAAoB;GACpC,IAAI,QAAQ,IAAI,aAAa,iBAAiB,CAAC,QAAQ;IACrD,SAAS;IACT,QAAQ,KAAK,kBAAkB,SAAS;GAC1C;EACF;EAEA,MAAM,WAAWA,wBAAU;GACzB;GACA,QAAQ,YAAY,WAAW,KAAK,EAAE;GAItC,gBAAgB,CACd,MAAM,gBAAgB,GACtBC,+CAAqB,aAAa,KAAK,CAAC,CAAC,cAAc,MACzD;GACA,UAAU;IACR,MAAM,SAASA,+CAAqB,aAAa,KAAK;IACtD,MAAM,UAAU,OAAO,QAAQ;IAC/B,IAAI,CAAC,SAAS;KACZ,IAAI,OAAO,kBAAkB,GAC3B,SACE,2BAA2B,MAAM,wEAE5B,MAAM,kBACb;KAEF,OAAQ,MAAc,SAAS,WAAW,KAAK,EAAE,UAAU,CAAC;IAC9D;IAGA,IAAI,OAAO,kBAAkB,GAC3B,KAAK,MAAM,YAAYC,iDAAqB;KAC1C,IAAI,aAAa,OAAO;KACxB,IACG,MAAM,QAAQ,SACb,GAAG,SAAS,cAEd,CAAC,OAAO,QAAQ,WAEhB,SACE,oBAAoB,SAAS,uCACnB,MAAM,uCACV,SAAS,qFAC8B,SAAS,IACxD;IAEJ;IAEF,OAAOC,wCAAgB,OAAO,SAAS,UAAU,UAAU;GAC7D;EACF,CAAC;EAED,aAAa;GACX,0CAAgB,aAAa,KAAK;GAClC,OAAO,SAAS;EAClB;CACF;AACF"}

package/dist/worker/createWorkerRowModel.d.cts

@@ -1,42 +0,0 @@
-import { RowData } from "../types/type-utils.cjs";
-import { TableWorkerStage } from "./tableWorkerProtocol.cjs";
-import { RowModel } from "../core/row-models/coreRowModelsFeature.types.cjs";
-import { Table } from "../types/Table.cjs";
-import { TableFeatures } from "../types/TableFeatures.cjs";
-import { TableWorker } from "./createTableWorker.cjs";
-
-//#region src/worker/createWorkerRowModel.d.ts
-/**
- * Turns any row model stage into a worker-backed one. The returned factory
- * plugs into the standard feature slot for that stage, so it composes with
- * the rest of the pipeline exactly like the sync factory it replaces.
- *
- * Register only the stages you want offloaded; each import is independent and
- * tree-shakable. All stages on a table share one worker and one round trip
- * per state change via the `tableWorker` handle. Until a result lands, the
- * stage returns its pre-stage model (stale-while-revalidate).
- *
- * Offloaded stages must form a contiguous prefix of the pipeline
- * (filtered -> grouped -> sorted -> expanded): a stage's worker result encodes
- * everything upstream as computed in the worker, so any upstream stage
- * registered on the main thread must be offloaded too. A dev warning fires on
- * mismatches.
- *
- * @example
- * ```ts
- * const tableWorker = createTableWorker({ createWorker })
- *
- * const features = tableFeatures({
- *   rowSortingFeature,
- *   columnGroupingFeature,
- *   workerRowModelsFeature,
- *   filteredRowModel: createWorkerRowModel(tableWorker, 'filtered'),
- *   groupedRowModel: createWorkerRowModel(tableWorker, 'grouped'),
- *   sortedRowModel: createWorkerRowModel(tableWorker, 'sorted'),
- * })
- * ```
- */
-declare function createWorkerRowModel(tableWorker: TableWorker, stage: TableWorkerStage): <TFeatures extends TableFeatures, TData extends RowData>(_table: Table<TFeatures, TData>) => (() => RowModel<TFeatures, TData>);
-//#endregion
-export { createWorkerRowModel };
-//# sourceMappingURL=createWorkerRowModel.d.cts.map

package/dist/worker/createWorkerRowModel.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createWorkerRowModel.js","names":[],"sources":["../../src/worker/createWorkerRowModel.ts"],"sourcesContent":["import { tableMemo } from '../utils'\nimport { getTableWorkerBridge, syncTableWorker } from './createTableWorker'\nimport { rebuildRowModel } from './rebuildRowModel'\nimport { tableWorkerPipeline } from './tableWorkerProtocol'\nimport type { RowModel } from '../core/row-models/coreRowModelsFeature.types'\nimport type { Table, Table_Internal } from '../types/Table'\nimport type { TableFeatures } from '../types/TableFeatures'\nimport type { RowData } from '../types/type-utils'\nimport type { TableWorker } from './createTableWorker'\nimport type { TableWorkerStage } from './tableWorkerProtocol'\n\ntype AnyTable = Table_Internal<any, any>\n\nfunction capitalize(stage: string) {\n  return stage.charAt(0).toUpperCase() + stage.slice(1)\n}\n\n/**\n * Turns any row model stage into a worker-backed one. The returned factory\n * plugs into the standard feature slot for that stage, so it composes with\n * the rest of the pipeline exactly like the sync factory it replaces.\n *\n * Register only the stages you want offloaded; each import is independent and\n * tree-shakable. All stages on a table share one worker and one round trip\n * per state change via the `tableWorker` handle. Until a result lands, the\n * stage returns its pre-stage model (stale-while-revalidate).\n *\n * Offloaded stages must form a contiguous prefix of the pipeline\n * (filtered -> grouped -> sorted -> expanded): a stage's worker result encodes\n * everything upstream as computed in the worker, so any upstream stage\n * registered on the main thread must be offloaded too. A dev warning fires on\n * mismatches.\n *\n * @example\n * ```ts\n * const tableWorker = createTableWorker({ createWorker })\n *\n * const features = tableFeatures({\n *   rowSortingFeature,\n *   columnGroupingFeature,\n *   workerRowModelsFeature,\n *   filteredRowModel: createWorkerRowModel(tableWorker, 'filtered'),\n *   groupedRowModel: createWorkerRowModel(tableWorker, 'grouped'),\n *   sortedRowModel: createWorkerRowModel(tableWorker, 'sorted'),\n * })\n * ```\n */\nexport function createWorkerRowModel(\n  tableWorker: TableWorker,\n  stage: TableWorkerStage,\n) {\n  return <TFeatures extends TableFeatures, TData extends RowData>(\n    _table: Table<TFeatures, TData>,\n  ): (() => RowModel<TFeatures, TData>) => {\n    const table = _table as unknown as AnyTable\n    // Stages register per table as their factories initialize (first read).\n    // The first render may therefore fire one extra coalesced request while\n    // the stage set grows; single-flight makes it a cheap trailing request.\n    getTableWorkerBridge(tableWorker, table).stages.add(stage)\n    let warned = false\n\n    const warnOnce = (message: string) => {\n      if (process.env.NODE_ENV === 'development' && !warned) {\n        warned = true\n        console.warn(`[table-worker] ${message}`)\n      }\n    }\n\n    const memoized = tableMemo({\n      table,\n      fnName: `table.get${capitalize(stage)}RowModel`,\n      // The per-stage version bumps only when this stage's payload actually\n      // changed, so stages the worker reported as `unchanged` skip the O(n)\n      // rebuild entirely (the re-render itself rides the state slice bump).\n      memoDeps: () => [\n        table.getCoreRowModel(),\n        getTableWorkerBridge(tableWorker, table).stageVersions[stage],\n      ],\n      fn: () => {\n        const bridge = getTableWorkerBridge(tableWorker, table)\n        const payload = bridge.results[stage]\n        if (!payload) {\n          if (bridge.resultRequestId > 0) {\n            warnOnce(\n              `The worker returned no '${stage}' result. Make sure the ` +\n                `worker's initTableWorker() config registers a ` +\n                `${stage}RowModel factory.`,\n            )\n          }\n          return (table as any)[`getPre${capitalize(stage)}RowModel`]()\n        }\n        // Contiguous-prefix check: any upstream stage registered on this\n        // table must also have a worker result, or it is silently bypassed.\n        if (bridge.resultRequestId > 0) {\n          for (const upstream of tableWorkerPipeline) {\n            if (upstream === stage) break\n            if (\n              (table.options.features as Record<string, unknown>)[\n                `${upstream}RowModel`\n              ] &&\n              !bridge.results[upstream]\n            ) {\n              warnOnce(\n                `This table has a ${upstream}RowModel, but the worker result ` +\n                  `for '${stage}' was computed without an offloaded ` +\n                  `'${upstream}' stage, so it is bypassed. Offload it too ` +\n                  `with createWorkerRowModel(tableWorker, '${upstream}').`,\n              )\n            }\n          }\n        }\n        return rebuildRowModel(table, payload, stage !== 'filtered')\n      },\n    })\n\n    return () => {\n      syncTableWorker(tableWorker, table)\n      return memoized()\n    }\n  }\n}\n"],"mappings":";;;;;;AAaA,SAAS,WAAW,OAAe;CACjC,OAAO,MAAM,OAAO,CAAC,CAAC,CAAC,YAAY,IAAI,MAAM,MAAM,CAAC;AACtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,SAAgB,qBACd,aACA,OACA;CACA,QACE,WACuC;EACvC,MAAM,QAAQ;EAId,qBAAqB,aAAa,KAAK,CAAC,CAAC,OAAO,IAAI,KAAK;EACzD,IAAI,SAAS;EAEb,MAAM,YAAY,YAAoB;GACpC,IAAI,QAAQ,IAAI,aAAa,iBAAiB,CAAC,QAAQ;IACrD,SAAS;IACT,QAAQ,KAAK,kBAAkB,SAAS;GAC1C;EACF;EAEA,MAAM,WAAW,UAAU;GACzB;GACA,QAAQ,YAAY,WAAW,KAAK,EAAE;GAItC,gBAAgB,CACd,MAAM,gBAAgB,GACtB,qBAAqB,aAAa,KAAK,CAAC,CAAC,cAAc,MACzD;GACA,UAAU;IACR,MAAM,SAAS,qBAAqB,aAAa,KAAK;IACtD,MAAM,UAAU,OAAO,QAAQ;IAC/B,IAAI,CAAC,SAAS;KACZ,IAAI,OAAO,kBAAkB,GAC3B,SACE,2BAA2B,MAAM,wEAE5B,MAAM,kBACb;KAEF,OAAQ,MAAc,SAAS,WAAW,KAAK,EAAE,UAAU,CAAC;IAC9D;IAGA,IAAI,OAAO,kBAAkB,GAC3B,KAAK,MAAM,YAAY,qBAAqB;KAC1C,IAAI,aAAa,OAAO;KACxB,IACG,MAAM,QAAQ,SACb,GAAG,SAAS,cAEd,CAAC,OAAO,QAAQ,WAEhB,SACE,oBAAoB,SAAS,uCACnB,MAAM,uCACV,SAAS,qFAC8B,SAAS,IACxD;IAEJ;IAEF,OAAO,gBAAgB,OAAO,SAAS,UAAU,UAAU;GAC7D;EACF,CAAC;EAED,aAAa;GACX,gBAAgB,aAAa,KAAK;GAClC,OAAO,SAAS;EAClB;CACF;AACF"}

package/dist/worker/initTableWorker.cjs

@@ -1,100 +0,0 @@
-const require_utils = require('../utils.cjs');
-const require_constructTable = require('../core/table/constructTable.cjs');
-const require_store_reactivity_bindings = require('../store-reactivity-bindings.cjs');
-const require_serializeRowModel = require('./serializeRowModel.cjs');
-
-//#region src/worker/initTableWorker.ts
-function capitalize(stage) {
-	return stage.charAt(0).toUpperCase() + stage.slice(1);
-}
-/** Flatten column-group defs to leaf defs (mirrors core's id resolution). */
-function flattenColumnDefs(defs) {
-	return defs.flatMap((def) => def.columns ? flattenColumnDefs(def.columns) : [def]);
-}
-/**
-* Runs a headless "shadow table" inside a dedicated Web Worker.
-*
-* Call this from a user-authored worker entry file, passing the same columns
-* and processing features used on the main thread. The shadow table runs the
-* real table-core row model pipeline (real fns, real Row objects) off the
-* main thread and posts back one payload per stage the main thread requested:
-* a transferable index permutation for flat results, a serialized row tree
-* (with eagerly computed aggregates) when grouping produces synthetic rows.
-*
-* Everything passed here must be thread-portable: `accessorKey` columns or
-* accessors defined in a shared module, and fns from registries or shared
-* modules (no closures over app state).
-*
-* @example
-* ```ts
-* // table.worker.ts
-* import { initTableWorker } from '@tanstack/table-core/experimental-worker-plugin'
-* import { columns, sharedFeatures } from './tableConfig'
-*
-* initTableWorker({ features: sharedFeatures, columns })
-* ```
-*/
-function initTableWorker(config) {
-	let table;
-	let dataVersion = 0;
-	let coreIndexById = require_utils.makeObjectMap();
-	let aggregateColumnIds = [];
-	let lastSentModels = {};
-	self.onmessage = (event) => {
-		const message = event.data;
-		if (message.type === "data") {
-			dataVersion = message.dataVersion;
-			lastSentModels = {};
-			if (!table) {
-				table = require_constructTable.constructTable({
-					...config,
-					features: {
-						coreReactivityFeature: require_store_reactivity_bindings.storeReactivityBindings(),
-						...config.features
-					},
-					data: message.data
-				});
-				aggregateColumnIds = flattenColumnDefs(config.columns).filter((def) => def.aggregationFn != null || def.aggregatedCell != null).map((def) => def.id ?? (typeof def.accessorKey === "string" ? def.accessorKey.replaceAll(".", "_") : void 0)).filter((id) => id != null);
-			} else table.setOptions((prev) => ({
-				...prev,
-				data: message.data
-			}));
-			const coreFlatRows = table.getCoreRowModel().flatRows;
-			coreIndexById = require_utils.makeObjectMap();
-			for (let i = 0; i < coreFlatRows.length; i++) coreIndexById[coreFlatRows[i].id] = i;
-			return;
-		}
-		if (!table) return;
-		const start = performance.now();
-		table._reactivity.batch(() => {
-			for (const [key, value] of Object.entries(message.state)) {
-				const baseAtom = table.baseAtoms[key];
-				if (baseAtom && value !== void 0) baseAtom.set(value);
-			}
-		});
-		const stages = {};
-		const transfer = [];
-		for (const stage of message.stages) {
-			if (!config.features[`${stage}RowModel`]) continue;
-			const model = table[`get${capitalize(stage)}RowModel`]();
-			if (lastSentModels[stage] === model) {
-				stages[stage] = { kind: "unchanged" };
-				continue;
-			}
-			lastSentModels[stage] = model;
-			stages[stage] = require_serializeRowModel.serializeRowModel(model, coreIndexById, aggregateColumnIds, transfer);
-		}
-		const response = {
-			type: "result",
-			requestId: message.requestId,
-			dataVersion,
-			stages,
-			computeMs: performance.now() - start
-		};
-		postMessage(response, { transfer });
-	};
-}
-
-//#endregion
-exports.initTableWorker = initTableWorker;
-//# sourceMappingURL=initTableWorker.cjs.map

package/dist/worker/initTableWorker.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"initTableWorker.cjs","names":["makeObjectMap","constructTable","storeReactivityBindings","serializeRowModel"],"sources":["../../src/worker/initTableWorker.ts"],"sourcesContent":["import { constructTable } from '../core/table/constructTable'\nimport { storeReactivityBindings } from '../store-reactivity-bindings'\nimport { makeObjectMap } from '../utils'\nimport { serializeRowModel } from './serializeRowModel'\nimport type { RowData } from '../types/type-utils'\nimport type { TableFeatures } from '../types/TableFeatures'\nimport type { TableOptions } from '../types/TableOptions'\nimport type { Table_Internal } from '../types/Table'\nimport type {\n  TableWorkerRequest,\n  TableWorkerResult,\n  TableWorkerStage,\n  TableWorkerStagePayload,\n} from './tableWorkerProtocol'\n\nexport type TableWorkerConfig<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n> = Omit<TableOptions<TFeatures, TData>, 'data'>\n\nfunction capitalize(stage: string) {\n  return stage.charAt(0).toUpperCase() + stage.slice(1)\n}\n\n/** Flatten column-group defs to leaf defs (mirrors core's id resolution). */\nfunction flattenColumnDefs(defs: Array<any>): Array<any> {\n  return defs.flatMap((def) =>\n    def.columns ? flattenColumnDefs(def.columns) : [def],\n  )\n}\n\n/**\n * Runs a headless \"shadow table\" inside a dedicated Web Worker.\n *\n * Call this from a user-authored worker entry file, passing the same columns\n * and processing features used on the main thread. The shadow table runs the\n * real table-core row model pipeline (real fns, real Row objects) off the\n * main thread and posts back one payload per stage the main thread requested:\n * a transferable index permutation for flat results, a serialized row tree\n * (with eagerly computed aggregates) when grouping produces synthetic rows.\n *\n * Everything passed here must be thread-portable: `accessorKey` columns or\n * accessors defined in a shared module, and fns from registries or shared\n * modules (no closures over app state).\n *\n * @example\n * ```ts\n * // table.worker.ts\n * import { initTableWorker } from '@tanstack/table-core/experimental-worker-plugin'\n * import { columns, sharedFeatures } from './tableConfig'\n *\n * initTableWorker({ features: sharedFeatures, columns })\n * ```\n */\nexport function initTableWorker<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(config: TableWorkerConfig<TFeatures, TData>): void {\n  let table: Table_Internal<TFeatures, TData> | undefined\n  let dataVersion = 0\n  let coreIndexById: Record<string, number> = makeObjectMap()\n  let aggregateColumnIds: Array<string> = []\n  // Last-sent model identity per stage: the memoized getters return stable\n  // objects when their inputs did not change, so identity equality is exactly\n  // \"this stage's result is unchanged\".\n  let lastSentModels: { [K in TableWorkerStage]?: unknown } = {}\n\n  self.onmessage = (event: MessageEvent<TableWorkerRequest<TData>>) => {\n    const message = event.data\n\n    if (message.type === 'data') {\n      dataVersion = message.dataVersion\n      lastSentModels = {}\n      if (!table) {\n        table = constructTable<TFeatures, TData>({\n          ...(config as TableOptions<TFeatures, TData>),\n          features: {\n            coreReactivityFeature: storeReactivityBindings(),\n            ...config.features,\n          },\n          data: message.data,\n        })\n        // Only columns with an explicit aggregation get eagerly aggregated\n        // per group. Sync tables aggregate lazily (visible cells only), so\n        // auto-aggregating every column would explode on high-cardinality\n        // grouping for values nothing renders. Read the RAW column defs:\n        // rowAggregationFeature injects default aggregatedCell/aggregationFn\n        // into every resolved columnDef, so the resolved defs can't tell\n        // explicit from default.\n        aggregateColumnIds = flattenColumnDefs(config.columns as Array<any>)\n          .filter(\n            (def) => def.aggregationFn != null || def.aggregatedCell != null,\n          )\n          .map(\n            (def) =>\n              def.id ??\n              (typeof def.accessorKey === 'string'\n                ? def.accessorKey.replaceAll('.', '_')\n                : undefined),\n          )\n          .filter((id): id is string => id != null)\n      } else {\n        table.setOptions((prev) => ({ ...prev, data: message.data }))\n      }\n      // Map row ids to data positions once per dataset; serialization uses it\n      // to express every stage result in terms of core row positions.\n      const coreFlatRows = table.getCoreRowModel().flatRows\n      coreIndexById = makeObjectMap()\n      for (let i = 0; i < coreFlatRows.length; i++) {\n        coreIndexById[coreFlatRows[i]!.id] = i\n      }\n      return\n    }\n\n    if (!table) return\n\n    const start = performance.now()\n\n    // Apply the serializable state slices to the shadow table's base atoms.\n    table._reactivity.batch(() => {\n      for (const [key, value] of Object.entries(message.state)) {\n        const baseAtom = (table!.baseAtoms as Record<string, any>)[key]\n        if (baseAtom && value !== undefined) {\n          baseAtom.set(value)\n        }\n      }\n    })\n\n    // Compute exactly the stages the main thread requested, skipping any this\n    // shadow table has no row model factory for (the main thread warns).\n    const stages: { [K in TableWorkerStage]?: TableWorkerStagePayload } = {}\n    const transfer: Array<Transferable> = []\n\n    for (const stage of message.stages) {\n      if (!(config.features as Record<string, unknown>)[`${stage}RowModel`]) {\n        continue\n      }\n      const model = (table as any)[`get${capitalize(stage)}RowModel`]()\n      // Memoized getters return the same object when inputs are unchanged;\n      // skip re-serializing (and the main thread skips rebuilding). Safe under\n      // single-flight: results are never dropped within a dataVersion.\n      if (lastSentModels[stage] === model) {\n        stages[stage] = { kind: 'unchanged' }\n        continue\n      }\n      lastSentModels[stage] = model\n      stages[stage] = serializeRowModel(\n        model,\n        coreIndexById,\n        aggregateColumnIds,\n        transfer,\n      )\n    }\n\n    const response: TableWorkerResult = {\n      type: 'result',\n      requestId: message.requestId,\n      dataVersion,\n      stages,\n      computeMs: performance.now() - start,\n    }\n    postMessage(response, { transfer })\n  }\n}\n"],"mappings":";;;;;;AAoBA,SAAS,WAAW,OAAe;CACjC,OAAO,MAAM,OAAO,CAAC,CAAC,CAAC,YAAY,IAAI,MAAM,MAAM,CAAC;AACtD;;AAGA,SAAS,kBAAkB,MAA8B;CACvD,OAAO,KAAK,SAAS,QACnB,IAAI,UAAU,kBAAkB,IAAI,OAAO,IAAI,CAAC,GAAG,CACrD;AACF;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,SAAgB,gBAGd,QAAmD;CACnD,IAAI;CACJ,IAAI,cAAc;CAClB,IAAI,gBAAwCA,4BAAc;CAC1D,IAAI,qBAAoC,CAAC;CAIzC,IAAI,iBAAwD,CAAC;CAE7D,KAAK,aAAa,UAAmD;EACnE,MAAM,UAAU,MAAM;EAEtB,IAAI,QAAQ,SAAS,QAAQ;GAC3B,cAAc,QAAQ;GACtB,iBAAiB,CAAC;GAClB,IAAI,CAAC,OAAO;IACV,QAAQC,sCAAiC;KACvC,GAAI;KACJ,UAAU;MACR,uBAAuBC,0DAAwB;MAC/C,GAAG,OAAO;KACZ;KACA,MAAM,QAAQ;IAChB,CAAC;IAQD,qBAAqB,kBAAkB,OAAO,OAAqB,CAAC,CACjE,QACE,QAAQ,IAAI,iBAAiB,QAAQ,IAAI,kBAAkB,IAC9D,CAAC,CACA,KACE,QACC,IAAI,OACH,OAAO,IAAI,gBAAgB,WACxB,IAAI,YAAY,WAAW,KAAK,GAAG,IACnC,OACR,CAAC,CACA,QAAQ,OAAqB,MAAM,IAAI;GAC5C,OACE,MAAM,YAAY,UAAU;IAAE,GAAG;IAAM,MAAM,QAAQ;GAAK,EAAE;GAI9D,MAAM,eAAe,MAAM,gBAAgB,CAAC,CAAC;GAC7C,gBAAgBF,4BAAc;GAC9B,KAAK,IAAI,IAAI,GAAG,IAAI,aAAa,QAAQ,KACvC,cAAc,aAAa,EAAE,CAAE,MAAM;GAEvC;EACF;EAEA,IAAI,CAAC,OAAO;EAEZ,MAAM,QAAQ,YAAY,IAAI;EAG9B,MAAM,YAAY,YAAY;GAC5B,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,QAAQ,KAAK,GAAG;IACxD,MAAM,WAAY,MAAO,UAAkC;IAC3D,IAAI,YAAY,UAAU,QACxB,SAAS,IAAI,KAAK;GAEtB;EACF,CAAC;EAID,MAAM,SAAgE,CAAC;EACvE,MAAM,WAAgC,CAAC;EAEvC,KAAK,MAAM,SAAS,QAAQ,QAAQ;GAClC,IAAI,CAAE,OAAO,SAAqC,GAAG,MAAM,YACzD;GAEF,MAAM,QAAS,MAAc,MAAM,WAAW,KAAK,EAAE,UAAU,CAAC;GAIhE,IAAI,eAAe,WAAW,OAAO;IACnC,OAAO,SAAS,EAAE,MAAM,YAAY;IACpC;GACF;GACA,eAAe,SAAS;GACxB,OAAO,SAASG,4CACd,OACA,eACA,oBACA,QACF;EACF;EAEA,MAAM,WAA8B;GAClC,MAAM;GACN,WAAW,QAAQ;GACnB;GACA;GACA,WAAW,YAAY,IAAI,IAAI;EACjC;EACA,YAAY,UAAU,EAAE,SAAS,CAAC;CACpC;AACF"}