@tanstack/table-core 9.0.0-beta.7 → 9.0.0-beta.71

package/dist/core/table/coreTablesFeature.utils.d.ts

@@ -1,23 +1,41 @@
 import { RowData, Updater } from "../../types/type-utils.js";
+import { TableState } from "../../types/TableState.js";
 import { TableOptions } from "../../types/TableOptions.js";
+import { Table } from "../../types/Table.js";
 import { TableFeatures } from "../../types/TableFeatures.js";
-import { Table_Internal } from "../../types/Table.js";
-
 //#region src/core/table/coreTablesFeature.utils.d.ts
 /**
  * Synchronizes externally controlled state slices into the table's base atoms.
  *
- * This keeps legacy `options.state` values reflected in the atom graph so
- * derived atoms, stores, and table APIs read a consistent snapshot.
+ * This keeps `options.state` values mirrored in the atom graph so derived
+ * atoms, stores, and table APIs read a consistent snapshot.
+ *
+ * Adapters that update options during their host's render phase pass the
+ * state snapshot captured by the committed render as `capturedState` — the
+ * shared options object may already hold values from a newer render that
+ * never commits. Pass `null` to publish nothing (a captured "no controlled
+ * state"); omitting the argument reads the current `table.options.state`
+ * instead. An optional `compare` suppresses semantically unchanged slice
+ * writes; the default remains reference equality.
  *
  * @example
  * ```ts
  * table_syncExternalStateToBaseAtoms(table)
+ * table_syncExternalStateToBaseAtoms(table, capturedState ?? null, shallow)
  * ```
  */
-declare function table_syncExternalStateToBaseAtoms<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): void;
+declare function table_syncExternalStateToBaseAtoms<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>, capturedState?: Partial<TableState<TFeatures>> | null, compare?: (currentState: unknown, externalState: unknown) => boolean): void;
+/**
+ * Publishes captured controlled state after a host framework commits.
+ *
+ * Render-phase adapters stage options without synchronizing base atoms, then
+ * pass the state captured by the committed render here. The commit signal also
+ * invalidates ownership changes when no base atom was written.
+ */
+declare function table_publishExternalState<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>, state: Partial<TableState<TFeatures>> | null, compare?: (currentState: unknown, externalState: unknown) => boolean): void;
 /**
- * Resets all internal table base atoms to `table.initialState`.
+ * Resets all internal table base atoms to `table.initialState`, then clears
+ * transient instance data through registered feature reset hooks.
  *
  * This resets internally owned state slices in a single reactivity batch. Use
  * feature-specific reset APIs when a slice may be externally owned.
@@ -27,19 +45,21 @@ declare function table_syncExternalStateToBaseAtoms<TFeatures extends TableFeatu
  * table_reset(table)
  * ```
  */
-declare function table_reset<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): void;
+declare function table_reset<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>): void;
 /**
  * Merges new table options with the current resolved options.
  *
  * If `options.mergeOptions` is provided, it owns the merge behavior; otherwise
- * options are shallow-merged.
+ * options are shallow-merged. Static options that should never change after
+ * initialization are restored on a fresh object so framework merge helpers may
+ * return readonly getter/proxy objects.
  *
  * @example
  * ```ts
  * const options = table_mergeOptions(table, nextOptions)
  * ```
  */
-declare function table_mergeOptions<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, newOptions: TableOptions<TFeatures, TData>): TableOptions<TFeatures, TData>;
+declare function table_mergeOptions<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>, newOptions: TableOptions<TFeatures, TData>): TableOptions<TFeatures, TData>;
 /**
  * Updates the table options object.
  *
@@ -49,9 +69,11 @@ declare function table_mergeOptions<TFeatures extends TableFeatures, TData exten
  * @example
  * ```ts
  * table_setOptions(table, (old) => old)
+ * table_setOptions(table, (old) => old, { syncExternalState: false })
  * ```
  */
-declare function table_setOptions<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, updater: Updater<TableOptions<TFeatures, TData>>): void;
+declare function table_setOptions<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>, updater: Updater<TableOptions<TFeatures, TData>>, options?: {
+  syncExternalState?: boolean;
+}): void;
 //#endregion
-export { table_mergeOptions, table_reset, table_setOptions, table_syncExternalStateToBaseAtoms };
-//# sourceMappingURL=coreTablesFeature.utils.d.ts.map
+export { table_mergeOptions, table_publishExternalState, table_reset, table_setOptions, table_syncExternalStateToBaseAtoms };

package/dist/core/table/coreTablesFeature.utils.js

@@ -4,28 +4,50 @@ import { cloneState, functionalUpdate } from "../../utils.js";
 /**
 * Synchronizes externally controlled state slices into the table's base atoms.
 *
-* This keeps legacy `options.state` values reflected in the atom graph so
-* derived atoms, stores, and table APIs read a consistent snapshot.
+* This keeps `options.state` values mirrored in the atom graph so derived
+* atoms, stores, and table APIs read a consistent snapshot.
+*
+* Adapters that update options during their host's render phase pass the
+* state snapshot captured by the committed render as `capturedState` — the
+* shared options object may already hold values from a newer render that
+* never commits. Pass `null` to publish nothing (a captured "no controlled
+* state"); omitting the argument reads the current `table.options.state`
+* instead. An optional `compare` suppresses semantically unchanged slice
+* writes; the default remains reference equality.
 *
 * @example
 * ```ts
 * table_syncExternalStateToBaseAtoms(table)
+* table_syncExternalStateToBaseAtoms(table, capturedState ?? null, shallow)
 * ```
 */
-function table_syncExternalStateToBaseAtoms(table) {
-	const state = table.options.state;
-	if (!state) return;
+function table_syncExternalStateToBaseAtoms(table, capturedState, compare = (currentState, externalState) => currentState === externalState) {
+	const state = capturedState === void 0 ? table.options.state : capturedState;
 	table._reactivity.batch(() => {
-		for (const key in state) {
+		if (state) for (const key in state) {
 			const baseAtom = table.baseAtoms[key];
 			if (!baseAtom) continue;
 			const externalState = state[key];
-			if (externalState !== baseAtom.get()) baseAtom.set(() => externalState);
+			if (!compare(table._reactivity.untrack(() => baseAtom.get()), externalState)) baseAtom.set(() => externalState);
 		}
 	});
 }
 /**
-* Resets all internal table base atoms to `table.initialState`.
+* Publishes captured controlled state after a host framework commits.
+*
+* Render-phase adapters stage options without synchronizing base atoms, then
+* pass the state captured by the committed render here. The commit signal also
+* invalidates ownership changes when no base atom was written.
+*/
+function table_publishExternalState(table, state, compare = (currentState, externalState) => currentState === externalState) {
+	table._reactivity.batch(() => {
+		table_syncExternalStateToBaseAtoms(table, state, compare);
+		table._reactivity.commit?.();
+	});
+}
+/**
+* Resets all internal table base atoms to `table.initialState`, then clears
+* transient instance data through registered feature reset hooks.
 *
 * This resets internally owned state slices in a single reactivity batch. Use
 * feature-specific reset APIs when a slice may be externally owned.
@@ -44,12 +66,16 @@ function table_reset(table) {
 			table.baseAtoms[key].set(snap[key]);
 		}
 	});
+	const features = Object.values(table._features);
+	for (let i = 0; i < features.length; i++) features[i].resetTableInstanceData?.(table);
 }
 /**
 * Merges new table options with the current resolved options.
 *
 * If `options.mergeOptions` is provided, it owns the merge behavior; otherwise
-* options are shallow-merged.
+* options are shallow-merged. Static options that should never change after
+* initialization are restored on a fresh object so framework merge helpers may
+* return readonly getter/proxy objects.
 *
 * @example
 * ```ts
@@ -57,11 +83,37 @@ function table_reset(table) {
 * ```
 */
 function table_mergeOptions(table, newOptions) {
-	if (table.options.mergeOptions) return table.options.mergeOptions(table.options, newOptions);
-	return {
+	const { features, atoms, initialState } = table.options;
+	if (!table.options.mergeOptions) return {
 		...table.options,
-		...newOptions
+		...newOptions,
+		features,
+		atoms,
+		initialState
 	};
+	const mergedOptions = table.options.mergeOptions(table.options, newOptions);
+	const descriptors = { ...Object.getOwnPropertyDescriptors(mergedOptions) };
+	return Object.defineProperties(Object.create(Object.getPrototypeOf(mergedOptions)), {
+		...descriptors,
+		features: {
+			value: features,
+			enumerable: true,
+			configurable: true,
+			writable: true
+		},
+		atoms: {
+			value: atoms,
+			enumerable: true,
+			configurable: true,
+			writable: true
+		},
+		initialState: {
+			value: initialState,
+			enumerable: true,
+			configurable: true,
+			writable: true
+		}
+	});
 }
 /**
 * Updates the table options object.
@@ -72,22 +124,15 @@ function table_mergeOptions(table, newOptions) {
 * @example
 * ```ts
 * table_setOptions(table, (old) => old)
+* table_setOptions(table, (old) => old, { syncExternalState: false })
 * ```
 */
-function table_setOptions(table, updater) {
-	const newOptions = functionalUpdate(updater, table.options);
-	const { rowModels, features, atoms, initialState } = table.options;
-	const mergedOptions = Object.assign(table_mergeOptions(table, newOptions), {
-		rowModels,
-		features,
-		atoms,
-		initialState
-	});
+function table_setOptions(table, updater, options) {
+	const mergedOptions = table_mergeOptions(table, functionalUpdate(updater, table.options));
 	if (table.optionsStore) table.optionsStore.set(() => mergedOptions);
 	else table.options = mergedOptions;
-	table_syncExternalStateToBaseAtoms(table);
+	if (options?.syncExternalState !== false) table_publishExternalState(table, mergedOptions.state ?? null);
 }
 
 //#endregion
-export { table_mergeOptions, table_reset, table_setOptions, table_syncExternalStateToBaseAtoms };
-//# sourceMappingURL=coreTablesFeature.utils.js.map
+export { table_mergeOptions, table_publishExternalState, table_reset, table_setOptions, table_syncExternalStateToBaseAtoms };

package/dist/experimental-worker-plugin.d.ts

@@ -0,0 +1,5 @@
+import { TableState_WorkerRowModels, TableWorkerGroupNode, TableWorkerRequest, TableWorkerResponse, TableWorkerResult, TableWorkerRowNode, TableWorkerStage, TableWorkerStagePayload, tableWorkerPipeline, tableWorkerStageStateDeps } from "./worker/tableWorkerProtocol.js";
+import { TableWorkerConfig, initTableWorker } from "./worker/initTableWorker.js";
+import { TableWorker, TableWorkerBridge, TableWorkerOptions, createTableWorker, getTableWorkerBridge, syncTableWorker, workerRowModelsFeature } from "./worker/createTableWorker.js";
+import { createWorkerRowModel } from "./worker/createWorkerRowModel.js";
+export { TableState_WorkerRowModels, TableWorker, TableWorkerBridge, TableWorkerConfig, TableWorkerGroupNode, TableWorkerOptions, TableWorkerRequest, TableWorkerResponse, TableWorkerResult, TableWorkerRowNode, TableWorkerStage, TableWorkerStagePayload, createTableWorker, createWorkerRowModel, getTableWorkerBridge, initTableWorker, syncTableWorker, tableWorkerPipeline, tableWorkerStageStateDeps, workerRowModelsFeature };

package/dist/experimental-worker-plugin.js

@@ -0,0 +1,6 @@
+import { tableWorkerPipeline, tableWorkerStageStateDeps } from "./worker/tableWorkerProtocol.js";
+import { initTableWorker } from "./worker/initTableWorker.js";
+import { createTableWorker, getTableWorkerBridge, syncTableWorker, workerRowModelsFeature } from "./worker/createTableWorker.js";
+import { createWorkerRowModel } from "./worker/createWorkerRowModel.js";
+
+export { createTableWorker, createWorkerRowModel, getTableWorkerBridge, initTableWorker, syncTableWorker, tableWorkerPipeline, tableWorkerStageStateDeps, workerRowModelsFeature };

package/dist/features/cell-selection/cellSelectionFeature.d.ts

@@ -0,0 +1,8 @@
+import { TableFeature } from "../../types/TableFeatures.js";
+//#region src/features/cell-selection/cellSelectionFeature.d.ts
+/**
+ * Feature that adds spreadsheet-style cell range selection state and APIs.
+ */
+declare const cellSelectionFeature: TableFeature;
+//#endregion
+export { cellSelectionFeature };

package/dist/features/cell-selection/cellSelectionFeature.js

@@ -0,0 +1,128 @@
+import { assignPrototypeAPIs, assignTableAPIs, callMemoOrStaticFn, makeStateUpdater } from "../../utils.js";
+import { cell_getCanSelect, cell_getIsFocused, cell_getIsSelected, cell_getSelectionEdges, cell_getSelectionExtendHandler, cell_getSelectionStartHandler, cell_getTabIndex, getDefaultCellSelectionState, table_autoResetCellSelection, table_extendCellSelection, table_getCellSelectionBounds, table_getCellSelectionColumnIds, table_getCellSelectionColumnIndexes, table_getCellSelectionMergeBounds, table_getCellSelectionRowIds, table_getFocusedCell, table_getSelectedCellCount, table_getSelectedCellIds, table_getSelectedCellRangesData, table_moveCellSelection, table_resetCellSelection, table_selectAllCells, table_selectCellRange, table_setCellSelection, table_setFocusedCell } from "./cellSelectionFeature.utils.js";
+
+//#region src/features/cell-selection/cellSelectionFeature.ts
+/**
+* Feature that adds spreadsheet-style cell range selection state and APIs.
+*/
+const cellSelectionFeature = {
+	initTableInstanceData: (table) => {
+		table._isSelectingCells = false;
+	},
+	resetTableInstanceData: (table) => {
+		table._isSelectingCells = false;
+	},
+	getInitialState: (initialState) => {
+		return {
+			cellSelection: getDefaultCellSelectionState(),
+			...initialState
+		};
+	},
+	getDefaultTableOptions: (table) => {
+		return {
+			onCellSelectionChange: makeStateUpdater("cellSelection", table),
+			autoResetCellSelection: true,
+			enableCellSelection: true,
+			enableCellRangeSelection: true,
+			enableMultiCellRangeSelection: true,
+			enableCellSelectionDrag: true,
+			isCellRangeSelectionEvent: (event) => {
+				const rangeEvent = event;
+				return Boolean(rangeEvent.shiftKey || rangeEvent.nativeEvent?.shiftKey);
+			},
+			isMultiCellRangeSelectionEvent: (event) => {
+				const multiEvent = event;
+				return Boolean(multiEvent.ctrlKey || multiEvent.metaKey || multiEvent.nativeEvent?.ctrlKey || multiEvent.nativeEvent?.metaKey);
+			}
+		};
+	},
+	assignCellPrototype: (prototype, table) => {
+		assignPrototypeAPIs("cellSelectionFeature", prototype, table, {
+			cell_getCanSelect: { fn: (cell) => cell_getCanSelect(cell) },
+			cell_getIsSelected: { fn: (cell) => cell_getIsSelected(cell) },
+			cell_getIsFocused: { fn: (cell) => cell_getIsFocused(cell) },
+			cell_getTabIndex: { fn: (cell) => cell_getTabIndex(cell) },
+			cell_getSelectionEdges: { fn: (cell) => cell_getSelectionEdges(cell) },
+			cell_getSelectionStartHandler: { fn: (cell, contextDocument) => cell_getSelectionStartHandler(cell, contextDocument) },
+			cell_getSelectionExtendHandler: { fn: (cell) => cell_getSelectionExtendHandler(cell) }
+		});
+	},
+	constructTableAPIs: (table) => {
+		assignTableAPIs("cellSelectionFeature", table, {
+			table_setCellSelection: { fn: (updater) => table_setCellSelection(table, updater) },
+			table_resetCellSelection: { fn: (defaultState) => table_resetCellSelection(table, defaultState) },
+			table_autoResetCellSelection: { fn: () => table_autoResetCellSelection(table) },
+			table_getCellSelectionColumnIndexes: {
+				fn: () => table_getCellSelectionColumnIndexes(table),
+				memoDeps: () => [
+					table.atoms.columnVisibility?.get(),
+					table.atoms.columnOrder?.get(),
+					table.atoms.columnPinning?.get(),
+					table.atoms.grouping?.get(),
+					table.options.columns,
+					table.options.groupedColumnMode
+				]
+			},
+			table_getCellSelectionMergeBounds: {
+				fn: () => table_getCellSelectionMergeBounds(table),
+				memoDeps: () => [
+					table.getCellSpanIndex?.(),
+					table.getRowsInDisplayOrder(),
+					callMemoOrStaticFn(table, "getCellSelectionColumnIndexes", table_getCellSelectionColumnIndexes)
+				]
+			},
+			table_getCellSelectionBounds: {
+				fn: () => table_getCellSelectionBounds(table),
+				memoDeps: () => [
+					table.atoms.cellSelection?.get(),
+					table.getRowsInDisplayOrder(),
+					callMemoOrStaticFn(table, "getCellSelectionColumnIndexes", table_getCellSelectionColumnIndexes),
+					callMemoOrStaticFn(table, "getCellSelectionMergeBounds", table_getCellSelectionMergeBounds)
+				]
+			},
+			table_selectCellRange: { fn: (range, opts) => table_selectCellRange(table, range, opts) },
+			table_selectAllCells: { fn: () => table_selectAllCells(table) },
+			table_setFocusedCell: { fn: (rowId, columnId) => table_setFocusedCell(table, rowId, columnId) },
+			table_getFocusedCell: { fn: () => table_getFocusedCell(table) },
+			table_moveCellSelection: { fn: (direction) => table_moveCellSelection(table, direction) },
+			table_extendCellSelection: { fn: (direction) => table_extendCellSelection(table, direction) },
+			table_getSelectedCellIds: {
+				fn: () => table_getSelectedCellIds(table),
+				memoDeps: () => [
+					callMemoOrStaticFn(table, "getCellSelectionBounds", table_getCellSelectionBounds),
+					callMemoOrStaticFn(table, "getCellSelectionMergeBounds", table_getCellSelectionMergeBounds),
+					table.getRowsInDisplayOrder(),
+					table.options.enableCellSelection
+				]
+			},
+			table_getSelectedCellRangesData: {
+				fn: () => table_getSelectedCellRangesData(table),
+				memoDeps: () => [
+					callMemoOrStaticFn(table, "getCellSelectionBounds", table_getCellSelectionBounds),
+					table.getRowsInDisplayOrder(),
+					table.options.enableCellSelection
+				]
+			},
+			table_getSelectedCellCount: {
+				fn: () => table_getSelectedCellCount(table),
+				memoDeps: () => [
+					callMemoOrStaticFn(table, "getCellSelectionBounds", table_getCellSelectionBounds),
+					callMemoOrStaticFn(table, "getCellSelectionMergeBounds", table_getCellSelectionMergeBounds),
+					table.getRowsInDisplayOrder(),
+					table.options.enableCellSelection
+				]
+			},
+			table_getCellSelectionRowIds: {
+				fn: () => table_getCellSelectionRowIds(table),
+				memoDeps: () => [callMemoOrStaticFn(table, "getCellSelectionBounds", table_getCellSelectionBounds), table.getRowsInDisplayOrder()]
+			},
+			table_getCellSelectionColumnIds: {
+				fn: () => table_getCellSelectionColumnIds(table),
+				memoDeps: () => [callMemoOrStaticFn(table, "getCellSelectionBounds", table_getCellSelectionBounds)]
+			}
+		});
+	}
+};
+
+//#endregion
+export { cellSelectionFeature };