@tanstack/table-core 9.0.0-alpha.8 → 9.0.0-beta.2

package/dist/core/headers/coreHeadersFeature.utils.d.cts

@@ -0,0 +1,85 @@
+import { RowData } from "../../types/type-utils.cjs";
+import { HeaderGroup } from "../../types/HeaderGroup.cjs";
+import { Header } from "../../types/Header.cjs";
+import { Column } from "../../types/Column.cjs";
+import { TableFeatures } from "../../types/TableFeatures.cjs";
+import { Table_Internal } from "../../types/Table.cjs";
+//#region src/core/headers/coreHeadersFeature.utils.d.ts
+/**
+ * Walks a header tree and collects all descendant leaf headers.
+ *
+ * The header itself is included after its descendants, matching the recursive
+ * shape used by nested header groups.
+ *
+ * @example
+ * ```ts
+ * const leafHeaders = header_getLeafHeaders(header)
+ * ```
+ */
+declare function header_getLeafHeaders<TFeatures extends TableFeatures, TData extends RowData, TValue>(header: Header<TFeatures, TData, TValue>): Header<TFeatures, TData, TValue>[];
+/**
+ * Builds the render context passed to a column's `header` or `footer` template.
+ *
+ * The context contains the header, its column, and the owning table instance.
+ *
+ * @example
+ * ```ts
+ * const context = header_getContext(header)
+ * ```
+ */
+declare function header_getContext<TFeatures extends TableFeatures, TData extends RowData, TValue>(header: Header<TFeatures, TData, TValue>): {
+  column: Column<TFeatures, TData, TValue>;
+  header: Header<TFeatures, TData, TValue>;
+  table: Table_Internal<TFeatures, TData>;
+};
+/**
+ * Builds visible header groups for the current column tree.
+ *
+ * Column visibility and pinning are applied before groups are built. When no
+ * columns are pinned, the fast path skips pin partitioning.
+ *
+ * @example
+ * ```ts
+ * const headerGroups = table_getHeaderGroups(table)
+ * ```
+ */
+declare function table_getHeaderGroups<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): HeaderGroup<TFeatures, TData>[];
+/**
+ * Builds footer groups by reversing the current header groups.
+ *
+ * Footer rendering uses the same header objects and grouping structure, but
+ * renders them from leaf level back toward the root.
+ *
+ * @example
+ * ```ts
+ * const footerGroups = table_getFooterGroups(table)
+ * ```
+ */
+declare function table_getFooterGroups<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): HeaderGroup<TFeatures, TData>[];
+/**
+ * Flattens every header from every header group into one array.
+ *
+ * The result includes parent headers and placeholder headers, in header-group
+ * order from top to bottom.
+ *
+ * @example
+ * ```ts
+ * const flatHeaders = table_getFlatHeaders(table)
+ * ```
+ */
+declare function table_getFlatHeaders<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): Header<TFeatures, TData, unknown>[];
+/**
+ * Collects only the leaf headers from the current header tree.
+ *
+ * Parent/group headers are skipped, making the result suitable for rendering
+ * one header per visible leaf column.
+ *
+ * @example
+ * ```ts
+ * const leafHeaders = table_getLeafHeaders(table)
+ * ```
+ */
+declare function table_getLeafHeaders<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): Header<TFeatures, TData, unknown>[];
+//#endregion
+export { header_getContext, header_getLeafHeaders, table_getFlatHeaders, table_getFooterGroups, table_getHeaderGroups, table_getLeafHeaders };
+//# sourceMappingURL=coreHeadersFeature.utils.d.cts.map

package/dist/core/headers/coreHeadersFeature.utils.d.ts

@@ -0,0 +1,85 @@
+import { RowData } from "../../types/type-utils.js";
+import { HeaderGroup } from "../../types/HeaderGroup.js";
+import { Header } from "../../types/Header.js";
+import { Column } from "../../types/Column.js";
+import { TableFeatures } from "../../types/TableFeatures.js";
+import { Table_Internal } from "../../types/Table.js";
+//#region src/core/headers/coreHeadersFeature.utils.d.ts
+/**
+ * Walks a header tree and collects all descendant leaf headers.
+ *
+ * The header itself is included after its descendants, matching the recursive
+ * shape used by nested header groups.
+ *
+ * @example
+ * ```ts
+ * const leafHeaders = header_getLeafHeaders(header)
+ * ```
+ */
+declare function header_getLeafHeaders<TFeatures extends TableFeatures, TData extends RowData, TValue>(header: Header<TFeatures, TData, TValue>): Header<TFeatures, TData, TValue>[];
+/**
+ * Builds the render context passed to a column's `header` or `footer` template.
+ *
+ * The context contains the header, its column, and the owning table instance.
+ *
+ * @example
+ * ```ts
+ * const context = header_getContext(header)
+ * ```
+ */
+declare function header_getContext<TFeatures extends TableFeatures, TData extends RowData, TValue>(header: Header<TFeatures, TData, TValue>): {
+  column: Column<TFeatures, TData, TValue>;
+  header: Header<TFeatures, TData, TValue>;
+  table: Table_Internal<TFeatures, TData>;
+};
+/**
+ * Builds visible header groups for the current column tree.
+ *
+ * Column visibility and pinning are applied before groups are built. When no
+ * columns are pinned, the fast path skips pin partitioning.
+ *
+ * @example
+ * ```ts
+ * const headerGroups = table_getHeaderGroups(table)
+ * ```
+ */
+declare function table_getHeaderGroups<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): HeaderGroup<TFeatures, TData>[];
+/**
+ * Builds footer groups by reversing the current header groups.
+ *
+ * Footer rendering uses the same header objects and grouping structure, but
+ * renders them from leaf level back toward the root.
+ *
+ * @example
+ * ```ts
+ * const footerGroups = table_getFooterGroups(table)
+ * ```
+ */
+declare function table_getFooterGroups<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): HeaderGroup<TFeatures, TData>[];
+/**
+ * Flattens every header from every header group into one array.
+ *
+ * The result includes parent headers and placeholder headers, in header-group
+ * order from top to bottom.
+ *
+ * @example
+ * ```ts
+ * const flatHeaders = table_getFlatHeaders(table)
+ * ```
+ */
+declare function table_getFlatHeaders<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): Header<TFeatures, TData, unknown>[];
+/**
+ * Collects only the leaf headers from the current header tree.
+ *
+ * Parent/group headers are skipped, making the result suitable for rendering
+ * one header per visible leaf column.
+ *
+ * @example
+ * ```ts
+ * const leafHeaders = table_getLeafHeaders(table)
+ * ```
+ */
+declare function table_getLeafHeaders<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): Header<TFeatures, TData, unknown>[];
+//#endregion
+export { header_getContext, header_getLeafHeaders, table_getFlatHeaders, table_getFooterGroups, table_getHeaderGroups, table_getLeafHeaders };
+//# sourceMappingURL=coreHeadersFeature.utils.d.ts.map

package/dist/core/headers/coreHeadersFeature.utils.js

@@ -0,0 +1,137 @@
+import { callMemoOrStaticFn } from "../../utils.js";
+import { column_getIsVisible, table_getVisibleLeafColumns } from "../../features/column-visibility/columnVisibilityFeature.utils.js";
+import { buildHeaderGroups } from "./buildHeaderGroups.js";
+import { getDefaultColumnPinningState } from "../../features/column-pinning/columnPinningFeature.utils.js";
+
+//#region src/core/headers/coreHeadersFeature.utils.ts
+/**
+* Walks a header tree and collects all descendant leaf headers.
+*
+* The header itself is included after its descendants, matching the recursive
+* shape used by nested header groups.
+*
+* @example
+* ```ts
+* const leafHeaders = header_getLeafHeaders(header)
+* ```
+*/
+function header_getLeafHeaders(header) {
+	const leafHeaders = [];
+	const recurseHeader = (h) => {
+		if (h.subHeaders.length) h.subHeaders.map(recurseHeader);
+		leafHeaders.push(h);
+	};
+	recurseHeader(header);
+	return leafHeaders;
+}
+/**
+* Builds the render context passed to a column's `header` or `footer` template.
+*
+* The context contains the header, its column, and the owning table instance.
+*
+* @example
+* ```ts
+* const context = header_getContext(header)
+* ```
+*/
+function header_getContext(header) {
+	return {
+		column: header.column,
+		header,
+		table: header.column.table
+	};
+}
+/**
+* Builds visible header groups for the current column tree.
+*
+* Column visibility and pinning are applied before groups are built. When no
+* columns are pinned, the fast path skips pin partitioning.
+*
+* @example
+* ```ts
+* const headerGroups = table_getHeaderGroups(table)
+* ```
+*/
+function table_getHeaderGroups(table) {
+	var _table$atoms$columnPi;
+	const { left, right } = ((_table$atoms$columnPi = table.atoms.columnPinning) === null || _table$atoms$columnPi === void 0 ? void 0 : _table$atoms$columnPi.get()) ?? getDefaultColumnPinningState();
+	const allColumns = table.getAllColumns();
+	const leafColumns = callMemoOrStaticFn(table, "getVisibleLeafColumns", table_getVisibleLeafColumns);
+	if (!left.length && !right.length) return buildHeaderGroups(allColumns, leafColumns, table);
+	const leafColumnsById = table.getAllLeafColumnsById();
+	const leftColumns = [];
+	for (let i = 0; i < left.length; i++) {
+		const column = leafColumnsById[left[i]];
+		if (column && callMemoOrStaticFn(column, "getIsVisible", column_getIsVisible)) leftColumns.push(column);
+	}
+	const rightColumns = [];
+	for (let i = 0; i < right.length; i++) {
+		const column = leafColumnsById[right[i]];
+		if (column && callMemoOrStaticFn(column, "getIsVisible", column_getIsVisible)) rightColumns.push(column);
+	}
+	const centerColumns = leafColumns.filter((column) => !left.includes(column.id) && !right.includes(column.id));
+	return buildHeaderGroups(allColumns, [
+		...leftColumns,
+		...centerColumns,
+		...rightColumns
+	], table);
+}
+/**
+* Builds footer groups by reversing the current header groups.
+*
+* Footer rendering uses the same header objects and grouping structure, but
+* renders them from leaf level back toward the root.
+*
+* @example
+* ```ts
+* const footerGroups = table_getFooterGroups(table)
+* ```
+*/
+function table_getFooterGroups(table) {
+	return [...table.getHeaderGroups()].reverse();
+}
+/**
+* Flattens every header from every header group into one array.
+*
+* The result includes parent headers and placeholder headers, in header-group
+* order from top to bottom.
+*
+* @example
+* ```ts
+* const flatHeaders = table_getFlatHeaders(table)
+* ```
+*/
+function table_getFlatHeaders(table) {
+	const headerGroups = table.getHeaderGroups();
+	const result = [];
+	for (let i = 0; i < headerGroups.length; i++) {
+		const headers = headerGroups[i].headers;
+		for (let j = 0; j < headers.length; j++) result.push(headers[j]);
+	}
+	return result;
+}
+/**
+* Collects only the leaf headers from the current header tree.
+*
+* Parent/group headers are skipped, making the result suitable for rendering
+* one header per visible leaf column.
+*
+* @example
+* ```ts
+* const leafHeaders = table_getLeafHeaders(table)
+* ```
+*/
+function table_getLeafHeaders(table) {
+	var _table$getHeaderGroup;
+	const topHeaders = ((_table$getHeaderGroup = table.getHeaderGroups()[0]) === null || _table$getHeaderGroup === void 0 ? void 0 : _table$getHeaderGroup.headers) ?? [];
+	const result = [];
+	for (let i = 0; i < topHeaders.length; i++) {
+		const leafHeaders = topHeaders[i].getLeafHeaders();
+		for (let j = 0; j < leafHeaders.length; j++) result.push(leafHeaders[j]);
+	}
+	return result;
+}
+
+//#endregion
+export { header_getContext, header_getLeafHeaders, table_getFlatHeaders, table_getFooterGroups, table_getHeaderGroups, table_getLeafHeaders };
+//# sourceMappingURL=coreHeadersFeature.utils.js.map

package/dist/core/headers/coreHeadersFeature.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coreHeadersFeature.utils.js","names":[],"sources":["../../../src/core/headers/coreHeadersFeature.utils.ts"],"sourcesContent":["import { getDefaultColumnPinningState } from '../../features/column-pinning/columnPinningFeature.utils'\nimport {\n  column_getIsVisible,\n  table_getVisibleLeafColumns,\n} from '../../features/column-visibility/columnVisibilityFeature.utils'\nimport { callMemoOrStaticFn } from '../../utils'\nimport { buildHeaderGroups } from './buildHeaderGroups'\nimport type { Table_Internal } from '../../types/Table'\nimport type { Header } from '../../types/Header'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Header_Header } from './coreHeadersFeature.types'\nimport type { Column } from '../../types/Column'\n\n/**\n * Walks a header tree and collects all descendant leaf headers.\n *\n * The header itself is included after its descendants, matching the recursive\n * shape used by nested header groups.\n *\n * @example\n * ```ts\n * const leafHeaders = header_getLeafHeaders(header)\n * ```\n */\nexport function header_getLeafHeaders<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue,\n>(header: Header<TFeatures, TData, TValue>) {\n  const leafHeaders: Array<Header<TFeatures, TData, TValue>> = []\n\n  const recurseHeader = (h: Header_Header<TFeatures, TData, TValue>) => {\n    if (h.subHeaders.length) {\n      h.subHeaders.map(recurseHeader)\n    }\n    leafHeaders.push(h as Header<TFeatures, TData, TValue>)\n  }\n\n  recurseHeader(header)\n\n  return leafHeaders\n}\n\n/**\n * Builds the render context passed to a column's `header` or `footer` template.\n *\n * The context contains the header, its column, and the owning table instance.\n *\n * @example\n * ```ts\n * const context = header_getContext(header)\n * ```\n */\nexport function header_getContext<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue,\n>(header: Header<TFeatures, TData, TValue>) {\n  return {\n    column: header.column,\n    header,\n    table: header.column.table,\n  }\n}\n\n/**\n * Builds visible header groups for the current column tree.\n *\n * Column visibility and pinning are applied before groups are built. When no\n * columns are pinned, the fast path skips pin partitioning.\n *\n * @example\n * ```ts\n * const headerGroups = table_getHeaderGroups(table)\n * ```\n */\nexport function table_getHeaderGroups<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  const { left, right } =\n    table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState()\n  const allColumns = table.getAllColumns()\n  const leafColumns = callMemoOrStaticFn(\n    table,\n    'getVisibleLeafColumns',\n    table_getVisibleLeafColumns,\n  ) as Array<Column<TFeatures, TData, unknown>>\n\n  // Fast path: no columns are pinned — skip per-side lookups, partition, and spread.\n  if (!left.length && !right.length) {\n    return buildHeaderGroups(allColumns, leafColumns, table)\n  }\n\n  const leafColumnsById = table.getAllLeafColumnsById()\n\n  const leftColumns: typeof leafColumns = []\n  for (let i = 0; i < left.length; i++) {\n    const column = leafColumnsById[left[i]!]\n    if (\n      column &&\n      callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible)\n    ) {\n      leftColumns.push(column)\n    }\n  }\n\n  const rightColumns: typeof leafColumns = []\n  for (let i = 0; i < right.length; i++) {\n    const column = leafColumnsById[right[i]!]\n    if (\n      column &&\n      callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible)\n    ) {\n      rightColumns.push(column)\n    }\n  }\n\n  const centerColumns = leafColumns.filter(\n    (column) => !left.includes(column.id) && !right.includes(column.id),\n  )\n\n  return buildHeaderGroups(\n    allColumns,\n    [...leftColumns, ...centerColumns, ...rightColumns],\n    table,\n  )\n}\n\n/**\n * Builds footer groups by reversing the current header groups.\n *\n * Footer rendering uses the same header objects and grouping structure, but\n * renders them from leaf level back toward the root.\n *\n * @example\n * ```ts\n * const footerGroups = table_getFooterGroups(table)\n * ```\n */\nexport function table_getFooterGroups<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  const headerGroups = table.getHeaderGroups()\n  return [...headerGroups].reverse()\n}\n\n/**\n * Flattens every header from every header group into one array.\n *\n * The result includes parent headers and placeholder headers, in header-group\n * order from top to bottom.\n *\n * @example\n * ```ts\n * const flatHeaders = table_getFlatHeaders(table)\n * ```\n */\nexport function table_getFlatHeaders<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  const headerGroups = table.getHeaderGroups()\n  const result: Array<Header<TFeatures, TData, unknown>> = []\n  for (let i = 0; i < headerGroups.length; i++) {\n    const headers = headerGroups[i]!.headers\n    for (let j = 0; j < headers.length; j++) {\n      result.push(headers[j]!)\n    }\n  }\n  return result\n}\n\n/**\n * Collects only the leaf headers from the current header tree.\n *\n * Parent/group headers are skipped, making the result suitable for rendering\n * one header per visible leaf column.\n *\n * @example\n * ```ts\n * const leafHeaders = table_getLeafHeaders(table)\n * ```\n */\nexport function table_getLeafHeaders<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  const topHeaders = table.getHeaderGroups()[0]?.headers ?? []\n  const result: Array<Header<TFeatures, TData, unknown>> = []\n  for (let i = 0; i < topHeaders.length; i++) {\n    const leafHeaders = topHeaders[i]!.getLeafHeaders()\n    for (let j = 0; j < leafHeaders.length; j++) {\n      result.push(leafHeaders[j]!)\n    }\n  }\n  return result\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAyBA,SAAgB,sBAId,QAA0C;CAC1C,MAAM,cAAuD,CAAC;CAE9D,MAAM,iBAAiB,MAA+C;EACpE,IAAI,EAAE,WAAW,QACf,EAAE,WAAW,IAAI,aAAa;EAEhC,YAAY,KAAK,CAAqC;CACxD;CAEA,cAAc,MAAM;CAEpB,OAAO;AACT;;;;;;;;;;;AAYA,SAAgB,kBAId,QAA0C;CAC1C,OAAO;EACL,QAAQ,OAAO;EACf;EACA,OAAO,OAAO,OAAO;CACvB;AACF;;;;;;;;;;;;AAaA,SAAgB,sBAGd,OAAyC;;CACzC,MAAM,EAAE,MAAM,oCACZ,MAAM,MAAM,6FAAe,IAAI,MAAK,6BAA6B;CACnE,MAAM,aAAa,MAAM,cAAc;CACvC,MAAM,cAAc,mBAClB,OACA,yBACA,2BACF;CAGA,IAAI,CAAC,KAAK,UAAU,CAAC,MAAM,QACzB,OAAO,kBAAkB,YAAY,aAAa,KAAK;CAGzD,MAAM,kBAAkB,MAAM,sBAAsB;CAEpD,MAAM,cAAkC,CAAC;CACzC,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;EACpC,MAAM,SAAS,gBAAgB,KAAK;EACpC,IACE,UACA,mBAAmB,QAAQ,gBAAgB,mBAAmB,GAE9D,YAAY,KAAK,MAAM;CAE3B;CAEA,MAAM,eAAmC,CAAC;CAC1C,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;EACrC,MAAM,SAAS,gBAAgB,MAAM;EACrC,IACE,UACA,mBAAmB,QAAQ,gBAAgB,mBAAmB,GAE9D,aAAa,KAAK,MAAM;CAE5B;CAEA,MAAM,gBAAgB,YAAY,QAC/B,WAAW,CAAC,KAAK,SAAS,OAAO,EAAE,KAAK,CAAC,MAAM,SAAS,OAAO,EAAE,CACpE;CAEA,OAAO,kBACL,YACA;EAAC,GAAG;EAAa,GAAG;EAAe,GAAG;CAAY,GAClD,KACF;AACF;;;;;;;;;;;;AAaA,SAAgB,sBAGd,OAAyC;CAEzC,OAAO,CAAC,GADa,MAAM,gBACL,CAAC,CAAC,CAAC,QAAQ;AACnC;;;;;;;;;;;;AAaA,SAAgB,qBAGd,OAAyC;CACzC,MAAM,eAAe,MAAM,gBAAgB;CAC3C,MAAM,SAAmD,CAAC;CAC1D,KAAK,IAAI,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK;EAC5C,MAAM,UAAU,aAAa,EAAE,CAAE;EACjC,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAClC,OAAO,KAAK,QAAQ,EAAG;CAE3B;CACA,OAAO;AACT;;;;;;;;;;;;AAaA,SAAgB,qBAGd,OAAyC;;CACzC,MAAM,uCAAa,MAAM,gBAAgB,CAAC,CAAC,kFAAI,YAAW,CAAC;CAC3D,MAAM,SAAmD,CAAC;CAC1D,KAAK,IAAI,IAAI,GAAG,IAAI,WAAW,QAAQ,KAAK;EAC1C,MAAM,cAAc,WAAW,EAAE,CAAE,eAAe;EAClD,KAAK,IAAI,IAAI,GAAG,IAAI,YAAY,QAAQ,KACtC,OAAO,KAAK,YAAY,EAAG;CAE/B;CACA,OAAO;AACT"}

package/dist/core/reactivity/coreReactivityFeature.types.d.cts

@@ -0,0 +1,48 @@
+import { Atom, AtomOptions, ReadonlyAtom, Subscription } from "@tanstack/store";
+
+//#region src/core/reactivity/coreReactivityFeature.types.d.ts
+interface TableAtomOptions<T> extends AtomOptions<T> {
+  /**
+   * A debug name for the atom, useful for debugging.
+   */
+  debugName: string;
+}
+/**
+ * Framework reactivity bindings used by table-core.
+ *
+ * Adapters (React, Solid, Vue, etc.) provide concrete implementations so
+ * core features can create derived/writable atoms and integrate with their
+ * scheduling primitives.
+ */
+interface TableReactivityBindings {
+  createOptionsStore: boolean;
+  wrapExternalAtoms: boolean;
+  addSubscription: (subscription: Subscription) => void;
+  /**
+   * Creates a writable atom with an initial value.
+   */
+  createWritableAtom: <T>(initialValue: T, options?: TableAtomOptions<T>) => Atom<T>;
+  /**
+   * Creates a readonly/derived atom from a compute function.
+   */
+  createReadonlyAtom: <T>(fn: () => T, options?: TableAtomOptions<T>) => ReadonlyAtom<T>;
+  /**
+   * Evaluates a function without tracking reactive dependencies.
+   */
+  untrack: <T>(fn: () => T) => T;
+  /**
+   * Batches reactive updates to avoid intermediate recomputation.
+   */
+  batch: (fn: () => void) => void;
+  /**
+   * Schedules a function to run. This is used to defer updates after the current call stack (render, etc.) has finished
+   */
+  schedule: (fn: () => void) => void;
+  /**
+   * Unmounts the table, performing any necessary cleanup. This is called when the table is destroyed or unmounted in the framework adapter.
+   */
+  unmount?: () => void;
+}
+//#endregion
+export { TableAtomOptions, TableReactivityBindings };
+//# sourceMappingURL=coreReactivityFeature.types.d.cts.map

package/dist/core/reactivity/coreReactivityFeature.types.d.ts

@@ -0,0 +1,48 @@
+import { Atom, AtomOptions, ReadonlyAtom, Subscription } from "@tanstack/store";
+
+//#region src/core/reactivity/coreReactivityFeature.types.d.ts
+interface TableAtomOptions<T> extends AtomOptions<T> {
+  /**
+   * A debug name for the atom, useful for debugging.
+   */
+  debugName: string;
+}
+/**
+ * Framework reactivity bindings used by table-core.
+ *
+ * Adapters (React, Solid, Vue, etc.) provide concrete implementations so
+ * core features can create derived/writable atoms and integrate with their
+ * scheduling primitives.
+ */
+interface TableReactivityBindings {
+  createOptionsStore: boolean;
+  wrapExternalAtoms: boolean;
+  addSubscription: (subscription: Subscription) => void;
+  /**
+   * Creates a writable atom with an initial value.
+   */
+  createWritableAtom: <T>(initialValue: T, options?: TableAtomOptions<T>) => Atom<T>;
+  /**
+   * Creates a readonly/derived atom from a compute function.
+   */
+  createReadonlyAtom: <T>(fn: () => T, options?: TableAtomOptions<T>) => ReadonlyAtom<T>;
+  /**
+   * Evaluates a function without tracking reactive dependencies.
+   */
+  untrack: <T>(fn: () => T) => T;
+  /**
+   * Batches reactive updates to avoid intermediate recomputation.
+   */
+  batch: (fn: () => void) => void;
+  /**
+   * Schedules a function to run. This is used to defer updates after the current call stack (render, etc.) has finished
+   */
+  schedule: (fn: () => void) => void;
+  /**
+   * Unmounts the table, performing any necessary cleanup. This is called when the table is destroyed or unmounted in the framework adapter.
+   */
+  unmount?: () => void;
+}
+//#endregion
+export { TableAtomOptions, TableReactivityBindings };
+//# sourceMappingURL=coreReactivityFeature.types.d.ts.map

package/dist/core/reactivity/coreReactivityFeature.utils.cjs

@@ -0,0 +1,24 @@
+
+//#region src/core/reactivity/coreReactivityFeature.utils.ts
+/**
+* Bridges atom instances to the `Store`/`ReadonlyStore` API by exposing
+* a `state` getter backed by `atom.get()`, and wiring `setState` for
+* writable atoms.
+*
+* @example
+* ```ts
+* const store = atomToStore(atom)
+* ```
+*/
+function atomToStore(atom) {
+	const store = atom;
+	Object.defineProperty(atom, "state", { get() {
+		return atom.get();
+	} });
+	if ("set" in atom) store.setState = atom.set.bind(atom);
+	return store;
+}
+
+//#endregion
+exports.atomToStore = atomToStore;
+//# sourceMappingURL=coreReactivityFeature.utils.cjs.map

package/dist/core/reactivity/coreReactivityFeature.utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"coreReactivityFeature.utils.cjs","names":[],"sources":["../../../src/core/reactivity/coreReactivityFeature.utils.ts"],"sourcesContent":["import type { Atom, ReadonlyAtom, ReadonlyStore, Store } from '@tanstack/store'\n\n/**\n * Converts a writable atom to the store-compatible shape expected by core.\n *\n * @example\n * ```ts\n * const store = atomToStore(atom)\n * ```\n */\nexport function atomToStore<T>(atom: Atom<T>): Store<T>\n/**\n * Converts a readonly atom to a readonly store-compatible shape.\n *\n * @example\n * ```ts\n * const store = atomToStore(atom)\n * ```\n */\nexport function atomToStore<T>(atom: ReadonlyAtom<T>): ReadonlyStore<T>\n/**\n * Bridges atom instances to the `Store`/`ReadonlyStore` API by exposing\n * a `state` getter backed by `atom.get()`, and wiring `setState` for\n * writable atoms.\n *\n * @example\n * ```ts\n * const store = atomToStore(atom)\n * ```\n */\nexport function atomToStore<T>(\n  atom: Atom<T> | ReadonlyAtom<T>,\n): Store<T> | ReadonlyStore<T> {\n  const store: Store<T> = atom as Store<T>\n  Object.defineProperty(atom, 'state', {\n    get() {\n      return atom.get()\n    },\n  })\n  if ('set' in atom) {\n    store.setState = atom.set.bind(atom)\n  }\n  return store\n}\n"],"mappings":";;;;;;;;;;;;AA8BA,SAAgB,YACd,MAC6B;CAC7B,MAAM,QAAkB;CACxB,OAAO,eAAe,MAAM,SAAS,EACnC,MAAM;EACJ,OAAO,KAAK,IAAI;CAClB,EACF,CAAC;CACD,IAAI,SAAS,MACX,MAAM,WAAW,KAAK,IAAI,KAAK,IAAI;CAErC,OAAO;AACT"}

package/dist/core/reactivity/coreReactivityFeature.utils.d.cts

@@ -0,0 +1,24 @@
+import { Atom, ReadonlyAtom, ReadonlyStore, Store } from "@tanstack/store";
+
+//#region src/core/reactivity/coreReactivityFeature.utils.d.ts
+/**
+ * Converts a writable atom to the store-compatible shape expected by core.
+ *
+ * @example
+ * ```ts
+ * const store = atomToStore(atom)
+ * ```
+ */
+declare function atomToStore<T>(atom: Atom<T>): Store<T>;
+/**
+ * Converts a readonly atom to a readonly store-compatible shape.
+ *
+ * @example
+ * ```ts
+ * const store = atomToStore(atom)
+ * ```
+ */
+declare function atomToStore<T>(atom: ReadonlyAtom<T>): ReadonlyStore<T>;
+//#endregion
+export { atomToStore };
+//# sourceMappingURL=coreReactivityFeature.utils.d.cts.map

package/dist/core/reactivity/coreReactivityFeature.utils.d.ts

@@ -0,0 +1,24 @@
+import { Atom, ReadonlyAtom, ReadonlyStore, Store } from "@tanstack/store";
+
+//#region src/core/reactivity/coreReactivityFeature.utils.d.ts
+/**
+ * Converts a writable atom to the store-compatible shape expected by core.
+ *
+ * @example
+ * ```ts
+ * const store = atomToStore(atom)
+ * ```
+ */
+declare function atomToStore<T>(atom: Atom<T>): Store<T>;
+/**
+ * Converts a readonly atom to a readonly store-compatible shape.
+ *
+ * @example
+ * ```ts
+ * const store = atomToStore(atom)
+ * ```
+ */
+declare function atomToStore<T>(atom: ReadonlyAtom<T>): ReadonlyStore<T>;
+//#endregion
+export { atomToStore };
+//# sourceMappingURL=coreReactivityFeature.utils.d.ts.map

package/dist/core/reactivity/coreReactivityFeature.utils.js

@@ -0,0 +1,23 @@
+//#region src/core/reactivity/coreReactivityFeature.utils.ts
+/**
+* Bridges atom instances to the `Store`/`ReadonlyStore` API by exposing
+* a `state` getter backed by `atom.get()`, and wiring `setState` for
+* writable atoms.
+*
+* @example
+* ```ts
+* const store = atomToStore(atom)
+* ```
+*/
+function atomToStore(atom) {
+	const store = atom;
+	Object.defineProperty(atom, "state", { get() {
+		return atom.get();
+	} });
+	if ("set" in atom) store.setState = atom.set.bind(atom);
+	return store;
+}
+
+//#endregion
+export { atomToStore };
+//# sourceMappingURL=coreReactivityFeature.utils.js.map

package/dist/core/reactivity/coreReactivityFeature.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coreReactivityFeature.utils.js","names":[],"sources":["../../../src/core/reactivity/coreReactivityFeature.utils.ts"],"sourcesContent":["import type { Atom, ReadonlyAtom, ReadonlyStore, Store } from '@tanstack/store'\n\n/**\n * Converts a writable atom to the store-compatible shape expected by core.\n *\n * @example\n * ```ts\n * const store = atomToStore(atom)\n * ```\n */\nexport function atomToStore<T>(atom: Atom<T>): Store<T>\n/**\n * Converts a readonly atom to a readonly store-compatible shape.\n *\n * @example\n * ```ts\n * const store = atomToStore(atom)\n * ```\n */\nexport function atomToStore<T>(atom: ReadonlyAtom<T>): ReadonlyStore<T>\n/**\n * Bridges atom instances to the `Store`/`ReadonlyStore` API by exposing\n * a `state` getter backed by `atom.get()`, and wiring `setState` for\n * writable atoms.\n *\n * @example\n * ```ts\n * const store = atomToStore(atom)\n * ```\n */\nexport function atomToStore<T>(\n  atom: Atom<T> | ReadonlyAtom<T>,\n): Store<T> | ReadonlyStore<T> {\n  const store: Store<T> = atom as Store<T>\n  Object.defineProperty(atom, 'state', {\n    get() {\n      return atom.get()\n    },\n  })\n  if ('set' in atom) {\n    store.setState = atom.set.bind(atom)\n  }\n  return store\n}\n"],"mappings":";;;;;;;;;;;AA8BA,SAAgB,YACd,MAC6B;CAC7B,MAAM,QAAkB;CACxB,OAAO,eAAe,MAAM,SAAS,EACnC,MAAM;EACJ,OAAO,KAAK,IAAI;CAClB,EACF,CAAC;CACD,IAAI,SAAS,MACX,MAAM,WAAW,KAAK,IAAI,KAAK,IAAI;CAErC,OAAO;AACT"}

package/dist/core/row-models/coreRowModelsFeature.cjs

@@ -0,0 +1,36 @@
+const require_utils = require('../../utils.cjs');
+const require_coreRowModelsFeature_utils = require('./coreRowModelsFeature.utils.cjs');
+
+//#region src/core/row-models/coreRowModelsFeature.ts
+/**
+* Creates the stock core row models feature.
+*
+* The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.
+*/
+function constructCoreRowModelsFeature() {
+	return { constructTableAPIs: (table) => {
+		require_utils.assignTableAPIs("coreRowModelsFeature", table, {
+			table_getCoreRowModel: { fn: () => require_coreRowModelsFeature_utils.table_getCoreRowModel(table) },
+			table_getPreFilteredRowModel: { fn: () => require_coreRowModelsFeature_utils.table_getPreFilteredRowModel(table) },
+			table_getFilteredRowModel: { fn: () => require_coreRowModelsFeature_utils.table_getFilteredRowModel(table) },
+			table_getPreGroupedRowModel: { fn: () => require_coreRowModelsFeature_utils.table_getPreGroupedRowModel(table) },
+			table_getGroupedRowModel: { fn: () => require_coreRowModelsFeature_utils.table_getGroupedRowModel(table) },
+			table_getPreSortedRowModel: { fn: () => require_coreRowModelsFeature_utils.table_getPreSortedRowModel(table) },
+			table_getSortedRowModel: { fn: () => require_coreRowModelsFeature_utils.table_getSortedRowModel(table) },
+			table_getPreExpandedRowModel: { fn: () => require_coreRowModelsFeature_utils.table_getPreExpandedRowModel(table) },
+			table_getExpandedRowModel: { fn: () => require_coreRowModelsFeature_utils.table_getExpandedRowModel(table) },
+			table_getPrePaginatedRowModel: { fn: () => require_coreRowModelsFeature_utils.table_getPrePaginatedRowModel(table) },
+			table_getPaginatedRowModel: { fn: () => require_coreRowModelsFeature_utils.table_getPaginatedRowModel(table) },
+			table_getRowModel: { fn: () => require_coreRowModelsFeature_utils.table_getRowModel(table) }
+		});
+	} };
+}
+/**
+* The Core Row Models feature provides the core row model functionality.
+*/
+const coreRowModelsFeature = constructCoreRowModelsFeature();
+
+//#endregion
+exports.constructCoreRowModelsFeature = constructCoreRowModelsFeature;
+exports.coreRowModelsFeature = coreRowModelsFeature;
+//# sourceMappingURL=coreRowModelsFeature.cjs.map

package/dist/core/row-models/coreRowModelsFeature.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"coreRowModelsFeature.cjs","names":["table_getCoreRowModel","table_getPreFilteredRowModel","table_getFilteredRowModel","table_getPreGroupedRowModel","table_getGroupedRowModel","table_getPreSortedRowModel","table_getSortedRowModel","table_getPreExpandedRowModel","table_getExpandedRowModel","table_getPrePaginatedRowModel","table_getPaginatedRowModel","table_getRowModel"],"sources":["../../../src/core/row-models/coreRowModelsFeature.ts"],"sourcesContent":["import { assignTableAPIs } from '../../utils'\nimport {\n  table_getCoreRowModel,\n  table_getExpandedRowModel,\n  table_getFilteredRowModel,\n  table_getGroupedRowModel,\n  table_getPaginatedRowModel,\n  table_getPreExpandedRowModel,\n  table_getPreFilteredRowModel,\n  table_getPreGroupedRowModel,\n  table_getPrePaginatedRowModel,\n  table_getPreSortedRowModel,\n  table_getRowModel,\n  table_getSortedRowModel,\n} from './coreRowModelsFeature.utils'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeature, TableFeatures } from '../../types/TableFeatures'\n// import type { Table_RowModels } from './coreRowModelsFeature.types'\n\nexport interface CoreRowModelsFeatureConstructors<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n> {\n  // Table: Table_RowModels<TFeatures, TData>\n}\n\n/**\n * Creates the stock core row models feature.\n *\n * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.\n */\nexport function constructCoreRowModelsFeature<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(): TableFeature<CoreRowModelsFeatureConstructors<TFeatures, TData>> {\n  return {\n    constructTableAPIs: (table) => {\n      assignTableAPIs('coreRowModelsFeature', table, {\n        table_getCoreRowModel: {\n          fn: () => table_getCoreRowModel(table),\n        },\n        table_getPreFilteredRowModel: {\n          fn: () => table_getPreFilteredRowModel(table),\n        },\n        table_getFilteredRowModel: {\n          fn: () => table_getFilteredRowModel(table),\n        },\n        table_getPreGroupedRowModel: {\n          fn: () => table_getPreGroupedRowModel(table),\n        },\n        table_getGroupedRowModel: {\n          fn: () => table_getGroupedRowModel(table),\n        },\n        table_getPreSortedRowModel: {\n          fn: () => table_getPreSortedRowModel(table),\n        },\n        table_getSortedRowModel: {\n          fn: () => table_getSortedRowModel(table),\n        },\n        table_getPreExpandedRowModel: {\n          fn: () => table_getPreExpandedRowModel(table),\n        },\n        table_getExpandedRowModel: {\n          fn: () => table_getExpandedRowModel(table),\n        },\n        table_getPrePaginatedRowModel: {\n          fn: () => table_getPrePaginatedRowModel(table),\n        },\n        table_getPaginatedRowModel: {\n          fn: () => table_getPaginatedRowModel(table),\n        },\n        table_getRowModel: {\n          fn: () => table_getRowModel(table),\n        },\n      })\n    },\n  }\n}\n\n/**\n * The Core Row Models feature provides the core row model functionality.\n */\nexport const coreRowModelsFeature = constructCoreRowModelsFeature()\n"],"mappings":";;;;;;;;;AA+BA,SAAgB,gCAGsD;CACpE,OAAO,EACL,qBAAqB,UAAU;EAC7B,8BAAgB,wBAAwB,OAAO;GAC7C,uBAAuB,EACrB,UAAUA,yDAAsB,KAAK,EACvC;GACA,8BAA8B,EAC5B,UAAUC,gEAA6B,KAAK,EAC9C;GACA,2BAA2B,EACzB,UAAUC,6DAA0B,KAAK,EAC3C;GACA,6BAA6B,EAC3B,UAAUC,+DAA4B,KAAK,EAC7C;GACA,0BAA0B,EACxB,UAAUC,4DAAyB,KAAK,EAC1C;GACA,4BAA4B,EAC1B,UAAUC,8DAA2B,KAAK,EAC5C;GACA,yBAAyB,EACvB,UAAUC,2DAAwB,KAAK,EACzC;GACA,8BAA8B,EAC5B,UAAUC,gEAA6B,KAAK,EAC9C;GACA,2BAA2B,EACzB,UAAUC,6DAA0B,KAAK,EAC3C;GACA,+BAA+B,EAC7B,UAAUC,iEAA8B,KAAK,EAC/C;GACA,4BAA4B,EAC1B,UAAUC,8DAA2B,KAAK,EAC5C;GACA,mBAAmB,EACjB,UAAUC,qDAAkB,KAAK,EACnC;EACF,CAAC;CACH,EACF;AACF;;;;AAKA,MAAa,uBAAuB,8BAA8B"}

package/dist/core/row-models/coreRowModelsFeature.d.cts

@@ -0,0 +1,18 @@
+import { RowData } from "../../types/type-utils.cjs";
+import { TableFeature, TableFeatures } from "../../types/TableFeatures.cjs";
+
+//#region src/core/row-models/coreRowModelsFeature.d.ts
+interface CoreRowModelsFeatureConstructors<TFeatures extends TableFeatures, TData extends RowData> {}
+/**
+ * Creates the stock core row models feature.
+ *
+ * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.
+ */
+declare function constructCoreRowModelsFeature<TFeatures extends TableFeatures, TData extends RowData>(): TableFeature<CoreRowModelsFeatureConstructors<TFeatures, TData>>;
+/**
+ * The Core Row Models feature provides the core row model functionality.
+ */
+declare const coreRowModelsFeature: TableFeature<CoreRowModelsFeatureConstructors<TableFeatures, RowData>>;
+//#endregion
+export { CoreRowModelsFeatureConstructors, constructCoreRowModelsFeature, coreRowModelsFeature };
+//# sourceMappingURL=coreRowModelsFeature.d.cts.map

package/dist/core/row-models/coreRowModelsFeature.d.ts

@@ -0,0 +1,18 @@
+import { RowData } from "../../types/type-utils.js";
+import { TableFeature, TableFeatures } from "../../types/TableFeatures.js";
+
+//#region src/core/row-models/coreRowModelsFeature.d.ts
+interface CoreRowModelsFeatureConstructors<TFeatures extends TableFeatures, TData extends RowData> {}
+/**
+ * Creates the stock core row models feature.
+ *
+ * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.
+ */
+declare function constructCoreRowModelsFeature<TFeatures extends TableFeatures, TData extends RowData>(): TableFeature<CoreRowModelsFeatureConstructors<TFeatures, TData>>;
+/**
+ * The Core Row Models feature provides the core row model functionality.
+ */
+declare const coreRowModelsFeature: TableFeature<CoreRowModelsFeatureConstructors<TableFeatures, RowData>>;
+//#endregion
+export { CoreRowModelsFeatureConstructors, constructCoreRowModelsFeature, coreRowModelsFeature };
+//# sourceMappingURL=coreRowModelsFeature.d.ts.map

package/dist/core/row-models/coreRowModelsFeature.js

@@ -0,0 +1,35 @@
+import { assignTableAPIs } from "../../utils.js";
+import { table_getCoreRowModel, table_getExpandedRowModel, table_getFilteredRowModel, table_getGroupedRowModel, table_getPaginatedRowModel, table_getPreExpandedRowModel, table_getPreFilteredRowModel, table_getPreGroupedRowModel, table_getPrePaginatedRowModel, table_getPreSortedRowModel, table_getRowModel, table_getSortedRowModel } from "./coreRowModelsFeature.utils.js";
+
+//#region src/core/row-models/coreRowModelsFeature.ts
+/**
+* Creates the stock core row models feature.
+*
+* The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.
+*/
+function constructCoreRowModelsFeature() {
+	return { constructTableAPIs: (table) => {
+		assignTableAPIs("coreRowModelsFeature", table, {
+			table_getCoreRowModel: { fn: () => table_getCoreRowModel(table) },
+			table_getPreFilteredRowModel: { fn: () => table_getPreFilteredRowModel(table) },
+			table_getFilteredRowModel: { fn: () => table_getFilteredRowModel(table) },
+			table_getPreGroupedRowModel: { fn: () => table_getPreGroupedRowModel(table) },
+			table_getGroupedRowModel: { fn: () => table_getGroupedRowModel(table) },
+			table_getPreSortedRowModel: { fn: () => table_getPreSortedRowModel(table) },
+			table_getSortedRowModel: { fn: () => table_getSortedRowModel(table) },
+			table_getPreExpandedRowModel: { fn: () => table_getPreExpandedRowModel(table) },
+			table_getExpandedRowModel: { fn: () => table_getExpandedRowModel(table) },
+			table_getPrePaginatedRowModel: { fn: () => table_getPrePaginatedRowModel(table) },
+			table_getPaginatedRowModel: { fn: () => table_getPaginatedRowModel(table) },
+			table_getRowModel: { fn: () => table_getRowModel(table) }
+		});
+	} };
+}
+/**
+* The Core Row Models feature provides the core row model functionality.
+*/
+const coreRowModelsFeature = constructCoreRowModelsFeature();
+
+//#endregion
+export { constructCoreRowModelsFeature, coreRowModelsFeature };
+//# sourceMappingURL=coreRowModelsFeature.js.map