@tanstack/vue-table 9.0.0-alpha.9 → 9.0.0-beta.2

package/dist/index.cjs

@@ -0,0 +1,17 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_FlexRender = require('./FlexRender.cjs');
+const require_useTable = require('./useTable.cjs');
+const require_createTableHook = require('./createTableHook.cjs');
+
+exports.AppFlexRender = require_createTableHook.AppFlexRender;
+exports.FlexRender = require_FlexRender.FlexRender;
+exports.createTableHook = require_createTableHook.createTableHook;
+exports.flexRender = require_FlexRender.flexRender;
+exports.useTable = require_useTable.useTable;
+var _tanstack_table_core = require("@tanstack/table-core");
+Object.keys(_tanstack_table_core).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return _tanstack_table_core[k]; }
+  });
+});

package/dist/index.d.cts

@@ -0,0 +1,5 @@
+import { FlexRender, flexRender } from "./FlexRender.cjs";
+import { SubscribeSource, TableOptionsWithReactiveData, VueTable, useTable } from "./useTable.cjs";
+import { AppCellContext, AppCellProps, AppColumnDefBase, AppColumnDefTemplate, AppColumnHelper, AppDisplayColumnDef, AppFlexRender, AppGroupColumnDef, AppHeaderContext, AppHeaderProps, AppTableProps, AppVueTable, ComponentType, CreateTableHookOptions, createTableHook } from "./createTableHook.cjs";
+export * from "@tanstack/table-core";
+export { AppCellContext, AppCellProps, AppColumnDefBase, AppColumnDefTemplate, AppColumnHelper, AppDisplayColumnDef, AppFlexRender, AppGroupColumnDef, AppHeaderContext, AppHeaderProps, AppTableProps, AppVueTable, ComponentType, CreateTableHookOptions, FlexRender, SubscribeSource, TableOptionsWithReactiveData, VueTable, createTableHook, flexRender, useTable };

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { FlexRender, flexRender } from "./FlexRender.js";
+import { SubscribeSource, TableOptionsWithReactiveData, VueTable, useTable } from "./useTable.js";
+import { AppCellContext, AppCellProps, AppColumnDefBase, AppColumnDefTemplate, AppColumnHelper, AppDisplayColumnDef, AppFlexRender, AppGroupColumnDef, AppHeaderContext, AppHeaderProps, AppTableProps, AppVueTable, ComponentType, CreateTableHookOptions, createTableHook } from "./createTableHook.js";
+export * from "@tanstack/table-core";
+export { AppCellContext, AppCellProps, AppColumnDefBase, AppColumnDefTemplate, AppColumnHelper, AppDisplayColumnDef, AppFlexRender, AppGroupColumnDef, AppHeaderContext, AppHeaderProps, AppTableProps, AppVueTable, ComponentType, CreateTableHookOptions, FlexRender, SubscribeSource, TableOptionsWithReactiveData, VueTable, createTableHook, flexRender, useTable };

package/dist/index.js

@@ -0,0 +1,7 @@
+import { FlexRender, flexRender } from "./FlexRender.js";
+import { useTable } from "./useTable.js";
+import { AppFlexRender, createTableHook } from "./createTableHook.js";
+
+export * from "@tanstack/table-core"
+
+export { AppFlexRender, FlexRender, createTableHook, flexRender, useTable };

package/dist/merge-proxy.cjs

@@ -0,0 +1,77 @@
+
+//#region src/merge-proxy.ts
+function trueFn() {
+	return true;
+}
+const $PROXY = Symbol("merge-proxy");
+const $SOURCES = Symbol("merge-proxy-sources");
+const propTraps = {
+	get(_, property, receiver) {
+		if (property === $PROXY) return receiver;
+		if (property === $SOURCES) return _.sources;
+		return _.get(property);
+	},
+	has(_, property) {
+		return _.has(property);
+	},
+	set: trueFn,
+	deleteProperty: trueFn,
+	getOwnPropertyDescriptor(_, property) {
+		return {
+			configurable: true,
+			enumerable: true,
+			get() {
+				return _.get(property);
+			},
+			set: trueFn,
+			deleteProperty: trueFn
+		};
+	},
+	ownKeys(_) {
+		return _.keys();
+	}
+};
+function resolveSource(s) {
+	return s && typeof s === "object" && "value" in s ? s.value : s;
+}
+function mergeProxy(...sources) {
+	const flattenedSources = sources.flatMap((source) => {
+		if (typeof source === "object" && source !== null && $SOURCES in source && Array.isArray(source[$SOURCES])) return source[$SOURCES];
+		return [source];
+	});
+	return new Proxy({
+		sources: flattenedSources,
+		get(property) {
+			for (let i = flattenedSources.length - 1; i >= 0; i--) {
+				const v = resolveSource(flattenedSources[i])[property];
+				if (v !== void 0) return v;
+			}
+		},
+		has(property) {
+			for (let i = flattenedSources.length - 1; i >= 0; i--) if (property in resolveSource(flattenedSources[i])) return true;
+			return false;
+		},
+		keys() {
+			const keys = [];
+			for (const source of flattenedSources) keys.push(...Object.keys(resolveSource(source)));
+			return [...Array.from(new Set(keys))];
+		}
+	}, propTraps);
+}
+function flatMerge(...sources) {
+	const result = {};
+	for (let source of sources) {
+		source = resolveSource(source);
+		if (!source) continue;
+		for (const key of Reflect.ownKeys(source)) {
+			const value = source[key];
+			if (value !== void 0) result[key] = value;
+		}
+	}
+	return result;
+}
+
+//#endregion
+exports.flatMerge = flatMerge;
+exports.mergeProxy = mergeProxy;
+//# sourceMappingURL=merge-proxy.cjs.map

package/dist/merge-proxy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-proxy.cjs","names":[],"sources":["../src/merge-proxy.ts"],"sourcesContent":["function trueFn() {\n  return true\n}\n\nconst $PROXY = Symbol('merge-proxy')\nconst $SOURCES = Symbol('merge-proxy-sources')\n\n// https://github.com/solidjs/solid/blob/c20ca4fd8c36bc0522fedb2c7f38a110b7ee2663/packages/solid/src/render/component.ts#L51-L118\nconst propTraps: ProxyHandler<{\n  get: (k: string | number | symbol) => any\n  has: (k: string | number | symbol) => boolean\n  keys: () => Array<string>\n  sources: Array<any>\n}> = {\n  get(_, property, receiver) {\n    if (property === $PROXY) return receiver\n    if (property === $SOURCES) return _.sources\n    return _.get(property)\n  },\n  has(_, property) {\n    return _.has(property)\n  },\n  set: trueFn,\n  deleteProperty: trueFn,\n  getOwnPropertyDescriptor(_, property) {\n    return {\n      configurable: true,\n      enumerable: true,\n      get() {\n        return _.get(property)\n      },\n      set: trueFn,\n      deleteProperty: trueFn,\n    }\n  },\n  ownKeys(_) {\n    return _.keys()\n  },\n}\n\ntype UnboxLazy<T> = T extends () => infer U ? U : T\ntype BoxedTupleTypes<T extends Array<any>> = {\n  [P in keyof T]: [UnboxLazy<T[P]>]\n}[Exclude<keyof T, keyof Array<any>>]\ntype UnionToIntersection<T> = (T extends any ? (k: T) => void : never) extends (\n  k: infer I,\n) => void\n  ? I\n  : never\ntype UnboxIntersection<T> = T extends { 0: infer U } ? U : never\ntype MergeProxy<T extends Array<any>> = UnboxIntersection<\n  UnionToIntersection<BoxedTupleTypes<T>>\n>\n\nfunction resolveSource(s: any) {\n  return s && typeof s === 'object' && 'value' in s ? s.value : s\n}\n\nexport function mergeProxy<T extends Array<any>>(...sources: T): MergeProxy<T>\nexport function mergeProxy(...sources: any): any {\n  const flattenedSources = sources.flatMap((source: any) => {\n    if (\n      typeof source === 'object' &&\n      source !== null &&\n      $SOURCES in source &&\n      Array.isArray(source[$SOURCES])\n    ) {\n      return source[$SOURCES]\n    }\n\n    return [source]\n  })\n\n  return new Proxy(\n    {\n      sources: flattenedSources,\n      get(property: string | number | symbol) {\n        for (let i = flattenedSources.length - 1; i >= 0; i--) {\n          const v = resolveSource(flattenedSources[i])[property]\n          if (v !== undefined) return v\n        }\n      },\n      has(property: string | number | symbol) {\n        for (let i = flattenedSources.length - 1; i >= 0; i--) {\n          if (property in resolveSource(flattenedSources[i])) return true\n        }\n        return false\n      },\n      keys() {\n        const keys = []\n        for (const source of flattenedSources)\n          keys.push(...Object.keys(resolveSource(source)))\n        return [...Array.from(new Set(keys))]\n      },\n    },\n    propTraps,\n  )\n}\n\n/**\n * Merges objects together by eagerly resolving all values into a flat object.\n *\n * Unlike `mergeProxy`, this does not preserve lazy proxy getters. Use this for\n * repeated option update paths so each merge produces a plain object instead\n * of accumulating a longer source list over time.\n */\nexport function flatMerge<T>(source: T): T\nexport function flatMerge<T, U>(source: T, source1: U): T & U\nexport function flatMerge<T, U, V>(source: T, source1: U, source2: V): T & U & V\nexport function flatMerge<T, U, V, W>(\n  source: T,\n  source1: U,\n  source2: V,\n  source3: W,\n): T & U & V & W\nexport function flatMerge(...sources: any): any {\n  const result: Record<PropertyKey, unknown> = {}\n\n  for (let source of sources) {\n    source = resolveSource(source)\n    if (!source) continue\n\n    for (const key of Reflect.ownKeys(source)) {\n      const value = (source as Record<PropertyKey, unknown>)[key]\n      if (value !== undefined) {\n        result[key] = value\n      }\n    }\n  }\n\n  return result\n}\n"],"mappings":";;AAAA,SAAS,SAAS;CAChB,OAAO;AACT;AAEA,MAAM,SAAS,OAAO,aAAa;AACnC,MAAM,WAAW,OAAO,qBAAqB;AAG7C,MAAM,YAKD;CACH,IAAI,GAAG,UAAU,UAAU;EACzB,IAAI,aAAa,QAAQ,OAAO;EAChC,IAAI,aAAa,UAAU,OAAO,EAAE;EACpC,OAAO,EAAE,IAAI,QAAQ;CACvB;CACA,IAAI,GAAG,UAAU;EACf,OAAO,EAAE,IAAI,QAAQ;CACvB;CACA,KAAK;CACL,gBAAgB;CAChB,yBAAyB,GAAG,UAAU;EACpC,OAAO;GACL,cAAc;GACd,YAAY;GACZ,MAAM;IACJ,OAAO,EAAE,IAAI,QAAQ;GACvB;GACA,KAAK;GACL,gBAAgB;EAClB;CACF;CACA,QAAQ,GAAG;EACT,OAAO,EAAE,KAAK;CAChB;AACF;AAgBA,SAAS,cAAc,GAAQ;CAC7B,OAAO,KAAK,OAAO,MAAM,YAAY,WAAW,IAAI,EAAE,QAAQ;AAChE;AAGA,SAAgB,WAAW,GAAG,SAAmB;CAC/C,MAAM,mBAAmB,QAAQ,SAAS,WAAgB;EACxD,IACE,OAAO,WAAW,YAClB,WAAW,QACX,YAAY,UACZ,MAAM,QAAQ,OAAO,SAAS,GAE9B,OAAO,OAAO;EAGhB,OAAO,CAAC,MAAM;CAChB,CAAC;CAED,OAAO,IAAI,MACT;EACE,SAAS;EACT,IAAI,UAAoC;GACtC,KAAK,IAAI,IAAI,iBAAiB,SAAS,GAAG,KAAK,GAAG,KAAK;IACrD,MAAM,IAAI,cAAc,iBAAiB,EAAE,CAAC,CAAC;IAC7C,IAAI,MAAM,QAAW,OAAO;GAC9B;EACF;EACA,IAAI,UAAoC;GACtC,KAAK,IAAI,IAAI,iBAAiB,SAAS,GAAG,KAAK,GAAG,KAChD,IAAI,YAAY,cAAc,iBAAiB,EAAE,GAAG,OAAO;GAE7D,OAAO;EACT;EACA,OAAO;GACL,MAAM,OAAO,CAAC;GACd,KAAK,MAAM,UAAU,kBACnB,KAAK,KAAK,GAAG,OAAO,KAAK,cAAc,MAAM,CAAC,CAAC;GACjD,OAAO,CAAC,GAAG,MAAM,KAAK,IAAI,IAAI,IAAI,CAAC,CAAC;EACtC;CACF,GACA,SACF;AACF;AAkBA,SAAgB,UAAU,GAAG,SAAmB;CAC9C,MAAM,SAAuC,CAAC;CAE9C,KAAK,IAAI,UAAU,SAAS;EAC1B,SAAS,cAAc,MAAM;EAC7B,IAAI,CAAC,QAAQ;EAEb,KAAK,MAAM,OAAO,QAAQ,QAAQ,MAAM,GAAG;GACzC,MAAM,QAAS,OAAwC;GACvD,IAAI,UAAU,QACZ,OAAO,OAAO;EAElB;CACF;CAEA,OAAO;AACT"}

package/dist/merge-proxy.js

@@ -0,0 +1,75 @@
+//#region src/merge-proxy.ts
+function trueFn() {
+	return true;
+}
+const $PROXY = Symbol("merge-proxy");
+const $SOURCES = Symbol("merge-proxy-sources");
+const propTraps = {
+	get(_, property, receiver) {
+		if (property === $PROXY) return receiver;
+		if (property === $SOURCES) return _.sources;
+		return _.get(property);
+	},
+	has(_, property) {
+		return _.has(property);
+	},
+	set: trueFn,
+	deleteProperty: trueFn,
+	getOwnPropertyDescriptor(_, property) {
+		return {
+			configurable: true,
+			enumerable: true,
+			get() {
+				return _.get(property);
+			},
+			set: trueFn,
+			deleteProperty: trueFn
+		};
+	},
+	ownKeys(_) {
+		return _.keys();
+	}
+};
+function resolveSource(s) {
+	return s && typeof s === "object" && "value" in s ? s.value : s;
+}
+function mergeProxy(...sources) {
+	const flattenedSources = sources.flatMap((source) => {
+		if (typeof source === "object" && source !== null && $SOURCES in source && Array.isArray(source[$SOURCES])) return source[$SOURCES];
+		return [source];
+	});
+	return new Proxy({
+		sources: flattenedSources,
+		get(property) {
+			for (let i = flattenedSources.length - 1; i >= 0; i--) {
+				const v = resolveSource(flattenedSources[i])[property];
+				if (v !== void 0) return v;
+			}
+		},
+		has(property) {
+			for (let i = flattenedSources.length - 1; i >= 0; i--) if (property in resolveSource(flattenedSources[i])) return true;
+			return false;
+		},
+		keys() {
+			const keys = [];
+			for (const source of flattenedSources) keys.push(...Object.keys(resolveSource(source)));
+			return [...Array.from(new Set(keys))];
+		}
+	}, propTraps);
+}
+function flatMerge(...sources) {
+	const result = {};
+	for (let source of sources) {
+		source = resolveSource(source);
+		if (!source) continue;
+		for (const key of Reflect.ownKeys(source)) {
+			const value = source[key];
+			if (value !== void 0) result[key] = value;
+		}
+	}
+	return result;
+}
+
+//#endregion
+export { flatMerge, mergeProxy };
+//# sourceMappingURL=merge-proxy.js.map

package/dist/merge-proxy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-proxy.js","names":[],"sources":["../src/merge-proxy.ts"],"sourcesContent":["function trueFn() {\n  return true\n}\n\nconst $PROXY = Symbol('merge-proxy')\nconst $SOURCES = Symbol('merge-proxy-sources')\n\n// https://github.com/solidjs/solid/blob/c20ca4fd8c36bc0522fedb2c7f38a110b7ee2663/packages/solid/src/render/component.ts#L51-L118\nconst propTraps: ProxyHandler<{\n  get: (k: string | number | symbol) => any\n  has: (k: string | number | symbol) => boolean\n  keys: () => Array<string>\n  sources: Array<any>\n}> = {\n  get(_, property, receiver) {\n    if (property === $PROXY) return receiver\n    if (property === $SOURCES) return _.sources\n    return _.get(property)\n  },\n  has(_, property) {\n    return _.has(property)\n  },\n  set: trueFn,\n  deleteProperty: trueFn,\n  getOwnPropertyDescriptor(_, property) {\n    return {\n      configurable: true,\n      enumerable: true,\n      get() {\n        return _.get(property)\n      },\n      set: trueFn,\n      deleteProperty: trueFn,\n    }\n  },\n  ownKeys(_) {\n    return _.keys()\n  },\n}\n\ntype UnboxLazy<T> = T extends () => infer U ? U : T\ntype BoxedTupleTypes<T extends Array<any>> = {\n  [P in keyof T]: [UnboxLazy<T[P]>]\n}[Exclude<keyof T, keyof Array<any>>]\ntype UnionToIntersection<T> = (T extends any ? (k: T) => void : never) extends (\n  k: infer I,\n) => void\n  ? I\n  : never\ntype UnboxIntersection<T> = T extends { 0: infer U } ? U : never\ntype MergeProxy<T extends Array<any>> = UnboxIntersection<\n  UnionToIntersection<BoxedTupleTypes<T>>\n>\n\nfunction resolveSource(s: any) {\n  return s && typeof s === 'object' && 'value' in s ? s.value : s\n}\n\nexport function mergeProxy<T extends Array<any>>(...sources: T): MergeProxy<T>\nexport function mergeProxy(...sources: any): any {\n  const flattenedSources = sources.flatMap((source: any) => {\n    if (\n      typeof source === 'object' &&\n      source !== null &&\n      $SOURCES in source &&\n      Array.isArray(source[$SOURCES])\n    ) {\n      return source[$SOURCES]\n    }\n\n    return [source]\n  })\n\n  return new Proxy(\n    {\n      sources: flattenedSources,\n      get(property: string | number | symbol) {\n        for (let i = flattenedSources.length - 1; i >= 0; i--) {\n          const v = resolveSource(flattenedSources[i])[property]\n          if (v !== undefined) return v\n        }\n      },\n      has(property: string | number | symbol) {\n        for (let i = flattenedSources.length - 1; i >= 0; i--) {\n          if (property in resolveSource(flattenedSources[i])) return true\n        }\n        return false\n      },\n      keys() {\n        const keys = []\n        for (const source of flattenedSources)\n          keys.push(...Object.keys(resolveSource(source)))\n        return [...Array.from(new Set(keys))]\n      },\n    },\n    propTraps,\n  )\n}\n\n/**\n * Merges objects together by eagerly resolving all values into a flat object.\n *\n * Unlike `mergeProxy`, this does not preserve lazy proxy getters. Use this for\n * repeated option update paths so each merge produces a plain object instead\n * of accumulating a longer source list over time.\n */\nexport function flatMerge<T>(source: T): T\nexport function flatMerge<T, U>(source: T, source1: U): T & U\nexport function flatMerge<T, U, V>(source: T, source1: U, source2: V): T & U & V\nexport function flatMerge<T, U, V, W>(\n  source: T,\n  source1: U,\n  source2: V,\n  source3: W,\n): T & U & V & W\nexport function flatMerge(...sources: any): any {\n  const result: Record<PropertyKey, unknown> = {}\n\n  for (let source of sources) {\n    source = resolveSource(source)\n    if (!source) continue\n\n    for (const key of Reflect.ownKeys(source)) {\n      const value = (source as Record<PropertyKey, unknown>)[key]\n      if (value !== undefined) {\n        result[key] = value\n      }\n    }\n  }\n\n  return result\n}\n"],"mappings":";AAAA,SAAS,SAAS;CAChB,OAAO;AACT;AAEA,MAAM,SAAS,OAAO,aAAa;AACnC,MAAM,WAAW,OAAO,qBAAqB;AAG7C,MAAM,YAKD;CACH,IAAI,GAAG,UAAU,UAAU;EACzB,IAAI,aAAa,QAAQ,OAAO;EAChC,IAAI,aAAa,UAAU,OAAO,EAAE;EACpC,OAAO,EAAE,IAAI,QAAQ;CACvB;CACA,IAAI,GAAG,UAAU;EACf,OAAO,EAAE,IAAI,QAAQ;CACvB;CACA,KAAK;CACL,gBAAgB;CAChB,yBAAyB,GAAG,UAAU;EACpC,OAAO;GACL,cAAc;GACd,YAAY;GACZ,MAAM;IACJ,OAAO,EAAE,IAAI,QAAQ;GACvB;GACA,KAAK;GACL,gBAAgB;EAClB;CACF;CACA,QAAQ,GAAG;EACT,OAAO,EAAE,KAAK;CAChB;AACF;AAgBA,SAAS,cAAc,GAAQ;CAC7B,OAAO,KAAK,OAAO,MAAM,YAAY,WAAW,IAAI,EAAE,QAAQ;AAChE;AAGA,SAAgB,WAAW,GAAG,SAAmB;CAC/C,MAAM,mBAAmB,QAAQ,SAAS,WAAgB;EACxD,IACE,OAAO,WAAW,YAClB,WAAW,QACX,YAAY,UACZ,MAAM,QAAQ,OAAO,SAAS,GAE9B,OAAO,OAAO;EAGhB,OAAO,CAAC,MAAM;CAChB,CAAC;CAED,OAAO,IAAI,MACT;EACE,SAAS;EACT,IAAI,UAAoC;GACtC,KAAK,IAAI,IAAI,iBAAiB,SAAS,GAAG,KAAK,GAAG,KAAK;IACrD,MAAM,IAAI,cAAc,iBAAiB,EAAE,CAAC,CAAC;IAC7C,IAAI,MAAM,QAAW,OAAO;GAC9B;EACF;EACA,IAAI,UAAoC;GACtC,KAAK,IAAI,IAAI,iBAAiB,SAAS,GAAG,KAAK,GAAG,KAChD,IAAI,YAAY,cAAc,iBAAiB,EAAE,GAAG,OAAO;GAE7D,OAAO;EACT;EACA,OAAO;GACL,MAAM,OAAO,CAAC;GACd,KAAK,MAAM,UAAU,kBACnB,KAAK,KAAK,GAAG,OAAO,KAAK,cAAc,MAAM,CAAC,CAAC;GACjD,OAAO,CAAC,GAAG,MAAM,KAAK,IAAI,IAAI,IAAI,CAAC,CAAC;EACtC;CACF,GACA,SACF;AACF;AAkBA,SAAgB,UAAU,GAAG,SAAmB;CAC9C,MAAM,SAAuC,CAAC;CAE9C,KAAK,IAAI,UAAU,SAAS;EAC1B,SAAS,cAAc,MAAM;EAC7B,IAAI,CAAC,QAAQ;EAEb,KAAK,MAAM,OAAO,QAAQ,QAAQ,MAAM,GAAG;GACzC,MAAM,QAAS,OAAwC;GACvD,IAAI,UAAU,QACZ,OAAO,OAAO;EAElB;CACF;CAEA,OAAO;AACT"}

package/dist/reactivity.cjs

@@ -0,0 +1,73 @@
+let vue = require("vue");
+let _tanstack_vue_store = require("@tanstack/vue-store");
+
+//#region src/reactivity.ts
+const optionsStoreDebugName = "table/optionsStore";
+function observerToCallback(observerOrNext) {
+	return typeof observerOrNext === "function" ? observerOrNext : (value) => {
+		var _observerOrNext$next;
+		return (_observerOrNext$next = observerOrNext.next) === null || _observerOrNext$next === void 0 ? void 0 : _observerOrNext$next.call(observerOrNext, value);
+	};
+}
+function refToReadonlyAtom(source) {
+	return Object.assign(source, {
+		get: () => source.value,
+		subscribe: ((observerOrNext) => {
+			return { unsubscribe: (0, vue.watch)(source, observerToCallback(observerOrNext), { flush: "sync" }) };
+		})
+	});
+}
+function refToWritableAtom(source) {
+	return Object.assign(source, {
+		set: (updater) => {
+			source.value = typeof updater === "function" ? updater(source.value) : updater;
+		},
+		get: () => source.value,
+		subscribe: ((observerOrNext) => {
+			return { unsubscribe: (0, vue.watch)(source, observerToCallback(observerOrNext), { flush: "sync" }) };
+		})
+	});
+}
+/**
+* Creates the table-core reactivity bindings used by the Vue adapter.
+*
+* Table state atoms are backed by TanStack Store atoms. The options store stays
+* framework-native because row-model APIs read `table.options` directly during
+* render. Readonly table atoms bridge Store dependency tracking into Vue computed
+* refs.
+*/
+function vueReactivity() {
+	return {
+		createOptionsStore: true,
+		wrapExternalAtoms: false,
+		addSubscription: () => {
+			throw new Error("Feature not supported in current reactivity implementation");
+		},
+		unmount: () => {
+			throw new Error("Feature not supported in current reactivity implementation");
+		},
+		schedule: (fn) => queueMicrotask(() => fn()),
+		createReadonlyAtom: (fn, _options) => {
+			const storeAtom = (0, _tanstack_vue_store.createAtom)(() => fn(), { compare: _options === null || _options === void 0 ? void 0 : _options.compare });
+			const version = (0, vue.shallowRef)(0);
+			const subscription = storeAtom.subscribe(() => {
+				version.value += 1;
+			});
+			if ((0, vue.getCurrentScope)()) (0, vue.onScopeDispose)(() => subscription.unsubscribe());
+			return refToReadonlyAtom((0, vue.computed)(() => {
+				version.value;
+				return storeAtom.get();
+			}));
+		},
+		createWritableAtom: (value, _options) => {
+			if ((_options === null || _options === void 0 ? void 0 : _options.debugName) === optionsStoreDebugName) return refToWritableAtom((0, vue.shallowRef)(value));
+			return (0, _tanstack_vue_store.createAtom)(value, { compare: _options === null || _options === void 0 ? void 0 : _options.compare });
+		},
+		untrack: (fn) => fn(),
+		batch: _tanstack_vue_store.batch
+	};
+}
+
+//#endregion
+exports.vueReactivity = vueReactivity;
+//# sourceMappingURL=reactivity.cjs.map

package/dist/reactivity.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactivity.cjs","names":[],"sources":["../src/reactivity.ts"],"sourcesContent":["import {\n  computed,\n  getCurrentScope,\n  onScopeDispose,\n  shallowRef,\n  watch,\n} from 'vue'\nimport { batch, createAtom } from '@tanstack/vue-store'\nimport type {\n  TableAtomOptions,\n  TableReactivityBindings,\n} from '@tanstack/table-core/reactivity'\nimport type { Atom, Observer, ReadonlyAtom } from '@tanstack/vue-store'\nimport type { ComputedRef, ShallowRef } from 'vue'\n\nconst optionsStoreDebugName = 'table/optionsStore'\n\nfunction observerToCallback<T>(\n  observerOrNext: Observer<T> | ((value: T) => void),\n): (value: T) => void {\n  return typeof observerOrNext === 'function'\n    ? observerOrNext\n    : (value) => observerOrNext.next?.(value)\n}\n\nfunction refToReadonlyAtom<T>(\n  source: ComputedRef<T> | ShallowRef<T>,\n): ReadonlyAtom<T> {\n  return Object.assign(source, {\n    get: () => source.value,\n    subscribe: ((observerOrNext: Observer<T> | ((value: T) => void)) => {\n      const stop = watch(source, observerToCallback(observerOrNext), {\n        flush: 'sync',\n      })\n      return { unsubscribe: stop }\n    }) as ReadonlyAtom<T>['subscribe'],\n  })\n}\n\nfunction refToWritableAtom<T>(source: ShallowRef<T>): Atom<T> {\n  return Object.assign(source, {\n    set: (updater: T | ((prevVal: T) => T)) => {\n      source.value =\n        typeof updater === 'function'\n          ? (updater as (prevVal: T) => T)(source.value)\n          : updater\n    },\n    get: () => source.value,\n    subscribe: ((observerOrNext: Observer<T> | ((value: T) => void)) => {\n      const stop = watch(source, observerToCallback(observerOrNext), {\n        flush: 'sync',\n      })\n      return { unsubscribe: stop }\n    }) as Atom<T>['subscribe'],\n  })\n}\n\n/**\n * Creates the table-core reactivity bindings used by the Vue adapter.\n *\n * Table state atoms are backed by TanStack Store atoms. The options store stays\n * framework-native because row-model APIs read `table.options` directly during\n * render. Readonly table atoms bridge Store dependency tracking into Vue computed\n * refs.\n */\nexport function vueReactivity(): TableReactivityBindings {\n  return {\n    createOptionsStore: true,\n    wrapExternalAtoms: false,\n    addSubscription: () => {\n      throw new Error(\n        'Feature not supported in current reactivity implementation',\n      )\n    },\n    unmount: () => {\n      throw new Error(\n        'Feature not supported in current reactivity implementation',\n      )\n    },\n    schedule: (fn) => queueMicrotask(() => fn()),\n    createReadonlyAtom: <T>(fn: () => T, _options?: TableAtomOptions<T>) => {\n      const storeAtom = createAtom(() => fn(), {\n        compare: _options?.compare,\n      })\n      const version = shallowRef(0)\n      const subscription = storeAtom.subscribe(() => {\n        version.value += 1\n      })\n      if (getCurrentScope()) {\n        onScopeDispose(() => subscription.unsubscribe())\n      }\n\n      return refToReadonlyAtom(\n        computed(() => {\n          version.value\n          return storeAtom.get()\n        }),\n      )\n    },\n    createWritableAtom: <T>(\n      value: T,\n      _options?: TableAtomOptions<T>,\n    ): Atom<T> => {\n      if (_options?.debugName === optionsStoreDebugName) {\n        return refToWritableAtom(shallowRef(value) as ShallowRef<T>)\n      }\n\n      return createAtom(value, {\n        compare: _options?.compare,\n      })\n    },\n    untrack: (fn) => fn(),\n    batch,\n  }\n}\n"],"mappings":";;;;AAeA,MAAM,wBAAwB;AAE9B,SAAS,mBACP,gBACoB;CACpB,OAAO,OAAO,mBAAmB,aAC7B,kBACC,UAAU;;gDAAe,uGAAO,KAAK;;AAC5C;AAEA,SAAS,kBACP,QACiB;CACjB,OAAO,OAAO,OAAO,QAAQ;EAC3B,WAAW,OAAO;EAClB,aAAa,mBAAuD;GAIlE,OAAO,EAAE,4BAHU,QAAQ,mBAAmB,cAAc,GAAG,EAC7D,OAAO,OACT,CACyB,EAAE;EAC7B;CACF,CAAC;AACH;AAEA,SAAS,kBAAqB,QAAgC;CAC5D,OAAO,OAAO,OAAO,QAAQ;EAC3B,MAAM,YAAqC;GACzC,OAAO,QACL,OAAO,YAAY,aACd,QAA8B,OAAO,KAAK,IAC3C;EACR;EACA,WAAW,OAAO;EAClB,aAAa,mBAAuD;GAIlE,OAAO,EAAE,4BAHU,QAAQ,mBAAmB,cAAc,GAAG,EAC7D,OAAO,OACT,CACyB,EAAE;EAC7B;CACF,CAAC;AACH;;;;;;;;;AAUA,SAAgB,gBAAyC;CACvD,OAAO;EACL,oBAAoB;EACpB,mBAAmB;EACnB,uBAAuB;GACrB,MAAM,IAAI,MACR,4DACF;EACF;EACA,eAAe;GACb,MAAM,IAAI,MACR,4DACF;EACF;EACA,WAAW,OAAO,qBAAqB,GAAG,CAAC;EAC3C,qBAAwB,IAAa,aAAmC;GACtE,MAAM,sDAA6B,GAAG,GAAG,EACvC,6DAAS,SAAU,QACrB,CAAC;GACD,MAAM,8BAAqB,CAAC;GAC5B,MAAM,eAAe,UAAU,gBAAgB;IAC7C,QAAQ,SAAS;GACnB,CAAC;GACD,6BAAoB,GAClB,8BAAqB,aAAa,YAAY,CAAC;GAGjD,OAAO,0CACU;IACb,QAAQ;IACR,OAAO,UAAU,IAAI;GACvB,CAAC,CACH;EACF;EACA,qBACE,OACA,aACY;GACZ,yDAAI,SAAU,eAAc,uBAC1B,OAAO,sCAA6B,KAAK,CAAkB;GAG7D,2CAAkB,OAAO,EACvB,6DAAS,SAAU,QACrB,CAAC;EACH;EACA,UAAU,OAAO,GAAG;EACpB;CACF;AACF"}

package/dist/reactivity.js

@@ -0,0 +1,73 @@
+import { computed, getCurrentScope, onScopeDispose, shallowRef, watch } from "vue";
+import { batch, createAtom } from "@tanstack/vue-store";
+
+//#region src/reactivity.ts
+const optionsStoreDebugName = "table/optionsStore";
+function observerToCallback(observerOrNext) {
+	return typeof observerOrNext === "function" ? observerOrNext : (value) => {
+		var _observerOrNext$next;
+		return (_observerOrNext$next = observerOrNext.next) === null || _observerOrNext$next === void 0 ? void 0 : _observerOrNext$next.call(observerOrNext, value);
+	};
+}
+function refToReadonlyAtom(source) {
+	return Object.assign(source, {
+		get: () => source.value,
+		subscribe: ((observerOrNext) => {
+			return { unsubscribe: watch(source, observerToCallback(observerOrNext), { flush: "sync" }) };
+		})
+	});
+}
+function refToWritableAtom(source) {
+	return Object.assign(source, {
+		set: (updater) => {
+			source.value = typeof updater === "function" ? updater(source.value) : updater;
+		},
+		get: () => source.value,
+		subscribe: ((observerOrNext) => {
+			return { unsubscribe: watch(source, observerToCallback(observerOrNext), { flush: "sync" }) };
+		})
+	});
+}
+/**
+* Creates the table-core reactivity bindings used by the Vue adapter.
+*
+* Table state atoms are backed by TanStack Store atoms. The options store stays
+* framework-native because row-model APIs read `table.options` directly during
+* render. Readonly table atoms bridge Store dependency tracking into Vue computed
+* refs.
+*/
+function vueReactivity() {
+	return {
+		createOptionsStore: true,
+		wrapExternalAtoms: false,
+		addSubscription: () => {
+			throw new Error("Feature not supported in current reactivity implementation");
+		},
+		unmount: () => {
+			throw new Error("Feature not supported in current reactivity implementation");
+		},
+		schedule: (fn) => queueMicrotask(() => fn()),
+		createReadonlyAtom: (fn, _options) => {
+			const storeAtom = createAtom(() => fn(), { compare: _options === null || _options === void 0 ? void 0 : _options.compare });
+			const version = shallowRef(0);
+			const subscription = storeAtom.subscribe(() => {
+				version.value += 1;
+			});
+			if (getCurrentScope()) onScopeDispose(() => subscription.unsubscribe());
+			return refToReadonlyAtom(computed(() => {
+				version.value;
+				return storeAtom.get();
+			}));
+		},
+		createWritableAtom: (value, _options) => {
+			if ((_options === null || _options === void 0 ? void 0 : _options.debugName) === optionsStoreDebugName) return refToWritableAtom(shallowRef(value));
+			return createAtom(value, { compare: _options === null || _options === void 0 ? void 0 : _options.compare });
+		},
+		untrack: (fn) => fn(),
+		batch
+	};
+}
+
+//#endregion
+export { vueReactivity };
+//# sourceMappingURL=reactivity.js.map

package/dist/reactivity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactivity.js","names":[],"sources":["../src/reactivity.ts"],"sourcesContent":["import {\n  computed,\n  getCurrentScope,\n  onScopeDispose,\n  shallowRef,\n  watch,\n} from 'vue'\nimport { batch, createAtom } from '@tanstack/vue-store'\nimport type {\n  TableAtomOptions,\n  TableReactivityBindings,\n} from '@tanstack/table-core/reactivity'\nimport type { Atom, Observer, ReadonlyAtom } from '@tanstack/vue-store'\nimport type { ComputedRef, ShallowRef } from 'vue'\n\nconst optionsStoreDebugName = 'table/optionsStore'\n\nfunction observerToCallback<T>(\n  observerOrNext: Observer<T> | ((value: T) => void),\n): (value: T) => void {\n  return typeof observerOrNext === 'function'\n    ? observerOrNext\n    : (value) => observerOrNext.next?.(value)\n}\n\nfunction refToReadonlyAtom<T>(\n  source: ComputedRef<T> | ShallowRef<T>,\n): ReadonlyAtom<T> {\n  return Object.assign(source, {\n    get: () => source.value,\n    subscribe: ((observerOrNext: Observer<T> | ((value: T) => void)) => {\n      const stop = watch(source, observerToCallback(observerOrNext), {\n        flush: 'sync',\n      })\n      return { unsubscribe: stop }\n    }) as ReadonlyAtom<T>['subscribe'],\n  })\n}\n\nfunction refToWritableAtom<T>(source: ShallowRef<T>): Atom<T> {\n  return Object.assign(source, {\n    set: (updater: T | ((prevVal: T) => T)) => {\n      source.value =\n        typeof updater === 'function'\n          ? (updater as (prevVal: T) => T)(source.value)\n          : updater\n    },\n    get: () => source.value,\n    subscribe: ((observerOrNext: Observer<T> | ((value: T) => void)) => {\n      const stop = watch(source, observerToCallback(observerOrNext), {\n        flush: 'sync',\n      })\n      return { unsubscribe: stop }\n    }) as Atom<T>['subscribe'],\n  })\n}\n\n/**\n * Creates the table-core reactivity bindings used by the Vue adapter.\n *\n * Table state atoms are backed by TanStack Store atoms. The options store stays\n * framework-native because row-model APIs read `table.options` directly during\n * render. Readonly table atoms bridge Store dependency tracking into Vue computed\n * refs.\n */\nexport function vueReactivity(): TableReactivityBindings {\n  return {\n    createOptionsStore: true,\n    wrapExternalAtoms: false,\n    addSubscription: () => {\n      throw new Error(\n        'Feature not supported in current reactivity implementation',\n      )\n    },\n    unmount: () => {\n      throw new Error(\n        'Feature not supported in current reactivity implementation',\n      )\n    },\n    schedule: (fn) => queueMicrotask(() => fn()),\n    createReadonlyAtom: <T>(fn: () => T, _options?: TableAtomOptions<T>) => {\n      const storeAtom = createAtom(() => fn(), {\n        compare: _options?.compare,\n      })\n      const version = shallowRef(0)\n      const subscription = storeAtom.subscribe(() => {\n        version.value += 1\n      })\n      if (getCurrentScope()) {\n        onScopeDispose(() => subscription.unsubscribe())\n      }\n\n      return refToReadonlyAtom(\n        computed(() => {\n          version.value\n          return storeAtom.get()\n        }),\n      )\n    },\n    createWritableAtom: <T>(\n      value: T,\n      _options?: TableAtomOptions<T>,\n    ): Atom<T> => {\n      if (_options?.debugName === optionsStoreDebugName) {\n        return refToWritableAtom(shallowRef(value) as ShallowRef<T>)\n      }\n\n      return createAtom(value, {\n        compare: _options?.compare,\n      })\n    },\n    untrack: (fn) => fn(),\n    batch,\n  }\n}\n"],"mappings":";;;;AAeA,MAAM,wBAAwB;AAE9B,SAAS,mBACP,gBACoB;CACpB,OAAO,OAAO,mBAAmB,aAC7B,kBACC,UAAU;;gDAAe,uGAAO,KAAK;;AAC5C;AAEA,SAAS,kBACP,QACiB;CACjB,OAAO,OAAO,OAAO,QAAQ;EAC3B,WAAW,OAAO;EAClB,aAAa,mBAAuD;GAIlE,OAAO,EAAE,aAHI,MAAM,QAAQ,mBAAmB,cAAc,GAAG,EAC7D,OAAO,OACT,CACyB,EAAE;EAC7B;CACF,CAAC;AACH;AAEA,SAAS,kBAAqB,QAAgC;CAC5D,OAAO,OAAO,OAAO,QAAQ;EAC3B,MAAM,YAAqC;GACzC,OAAO,QACL,OAAO,YAAY,aACd,QAA8B,OAAO,KAAK,IAC3C;EACR;EACA,WAAW,OAAO;EAClB,aAAa,mBAAuD;GAIlE,OAAO,EAAE,aAHI,MAAM,QAAQ,mBAAmB,cAAc,GAAG,EAC7D,OAAO,OACT,CACyB,EAAE;EAC7B;CACF,CAAC;AACH;;;;;;;;;AAUA,SAAgB,gBAAyC;CACvD,OAAO;EACL,oBAAoB;EACpB,mBAAmB;EACnB,uBAAuB;GACrB,MAAM,IAAI,MACR,4DACF;EACF;EACA,eAAe;GACb,MAAM,IAAI,MACR,4DACF;EACF;EACA,WAAW,OAAO,qBAAqB,GAAG,CAAC;EAC3C,qBAAwB,IAAa,aAAmC;GACtE,MAAM,YAAY,iBAAiB,GAAG,GAAG,EACvC,6DAAS,SAAU,QACrB,CAAC;GACD,MAAM,UAAU,WAAW,CAAC;GAC5B,MAAM,eAAe,UAAU,gBAAgB;IAC7C,QAAQ,SAAS;GACnB,CAAC;GACD,IAAI,gBAAgB,GAClB,qBAAqB,aAAa,YAAY,CAAC;GAGjD,OAAO,kBACL,eAAe;IACb,QAAQ;IACR,OAAO,UAAU,IAAI;GACvB,CAAC,CACH;EACF;EACA,qBACE,OACA,aACY;GACZ,yDAAI,SAAU,eAAc,uBAC1B,OAAO,kBAAkB,WAAW,KAAK,CAAkB;GAG7D,OAAO,WAAW,OAAO,EACvB,6DAAS,SAAU,QACrB,CAAC;EACH;EACA,UAAU,OAAO,GAAG;EACpB;CACF;AACF"}

package/dist/static-functions.cjs

@@ -0,0 +1,9 @@
+
+
+var _tanstack_table_core_static_functions = require("@tanstack/table-core/static-functions");
+Object.keys(_tanstack_table_core_static_functions).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return _tanstack_table_core_static_functions[k]; }
+  });
+});

package/dist/static-functions.d.cts

@@ -0,0 +1 @@
+export * from "@tanstack/table-core/static-functions";

package/dist/static-functions.d.ts

@@ -0,0 +1 @@
+export * from "@tanstack/table-core/static-functions";

package/dist/static-functions.js

@@ -0,0 +1,3 @@
+export * from "@tanstack/table-core/static-functions"
+
+export {  };

package/dist/useTable.cjs

@@ -0,0 +1,83 @@
+const require_merge_proxy = require('./merge-proxy.cjs');
+const require_reactivity = require('./reactivity.cjs');
+let vue = require("vue");
+let _tanstack_table_core = require("@tanstack/table-core");
+let _tanstack_vue_store = require("@tanstack/vue-store");
+
+//#region src/useTable.ts
+function getOptionsWithReactiveValues(options) {
+	const resolvedOptions = {};
+	for (const key of Object.keys(options)) resolvedOptions[key] = (0, vue.unref)(options[key]);
+	return require_merge_proxy.mergeProxy(options, resolvedOptions);
+}
+function getReactiveOptionDeps(options) {
+	return Object.keys(options).map((key) => (0, vue.unref)(options[key]));
+}
+/**
+* Creates a Vue table instance backed by Vue-aware TanStack Store atoms.
+*
+* Table options may contain Vue refs or computed values. The adapter unwraps
+* those reactive inputs, watches them with synchronous flushing, and keeps the
+* table options in sync. The optional selector projects from `table.store` and
+* exposes the selected value on `table.state`.
+*
+* @example
+* ```ts
+* const table = useTable(
+*   {
+*     features,
+*     rowModels: {},
+*     columns,
+*     data,
+*   },
+*   (state) => ({ pagination: state.pagination }),
+* )
+*
+* table.state.pagination
+* ```
+*/
+function useTable(tableOptions, selector) {
+	const syncTableOptions = (table, options) => {
+		table.setOptions((prev) => require_merge_proxy.flatMerge(prev, getOptionsWithReactiveValues(options)));
+	};
+	const mergedOptions = require_merge_proxy.mergeProxy(tableOptions, { features: {
+		coreReativityFeature: require_reactivity.vueReactivity(),
+		...(0, vue.unref)(tableOptions.features) ?? {}
+	} });
+	const coreTable = (0, _tanstack_table_core.constructTable)(require_merge_proxy.mergeProxy(getOptionsWithReactiveValues(mergedOptions), { mergeOptions: (defaultOptions, newOptions) => {
+		return require_merge_proxy.flatMerge(defaultOptions, newOptions);
+	} }));
+	const table = coreTable;
+	(0, vue.watch)(() => getReactiveOptionDeps(mergedOptions), () => {
+		syncTableOptions(coreTable, mergedOptions);
+	}, { immediate: true });
+	(0, vue.watch)(() => {
+		const controlledState = (0, vue.unref)(tableOptions.state);
+		const controlledAtoms = (0, vue.unref)(tableOptions.atoms);
+		if (!controlledState) return [];
+		const controlledValues = [];
+		for (const key of Object.keys(table.initialState)) {
+			if (!(key in controlledState) || (controlledAtoms === null || controlledAtoms === void 0 ? void 0 : controlledAtoms[key]) !== void 0) continue;
+			controlledValues.push(controlledState[key]);
+		}
+		return controlledValues;
+	}, (controlledValues) => {
+		if (controlledValues.length > 0) syncTableOptions(coreTable, mergedOptions);
+	}, { immediate: true });
+	table.Subscribe = ((props) => {
+		const selected = (0, _tanstack_vue_store.useSelector)(props.source ?? table.store, props.selector, { compare: _tanstack_vue_store.shallow });
+		if (typeof props.children === "function") return props.children(selected.value);
+		return props.children;
+	});
+	const stateStore = (0, _tanstack_vue_store.useSelector)(table.store, selector);
+	return {
+		...table,
+		get state() {
+			return stateStore.value;
+		}
+	};
+}
+
+//#endregion
+exports.useTable = useTable;
+//# sourceMappingURL=useTable.cjs.map

package/dist/useTable.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTable.cjs","names":["mergeProxy","flatMerge","vueReactivity","shallow"],"sources":["../src/useTable.ts"],"sourcesContent":["import { unref, watch } from 'vue'\nimport { constructTable } from '@tanstack/table-core'\nimport { shallow, useSelector } from '@tanstack/vue-store'\nimport { flatMerge, mergeProxy } from './merge-proxy'\nimport { vueReactivity } from './reactivity'\nimport type {\n  Atom,\n  ReadonlyAtom,\n  ReadonlyStore,\n  Store,\n} from '@tanstack/vue-store'\nimport type {\n  NoInfer,\n  RowData,\n  Table,\n  TableFeatures,\n  TableOptions,\n  TableState,\n} from '@tanstack/table-core'\nimport type { MaybeRef, VNode } from 'vue'\n\nexport type SubscribeSource<TValue> =\n  | Atom<TValue>\n  | ReadonlyAtom<TValue>\n  | Store<TValue>\n  | ReadonlyStore<TValue>\n\nexport type TableOptionsWithReactiveData<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n> = {\n  [K in keyof TableOptions<TFeatures, TData>]: K extends 'data'\n    ? MaybeRef<ReadonlyArray<TData>>\n    : MaybeRef<TableOptions<TFeatures, TData>[K]>\n}\n\nfunction getOptionsWithReactiveValues<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(options: TableOptionsWithReactiveData<TFeatures, TData>) {\n  const resolvedOptions: Record<string, unknown> = {}\n\n  for (const key of Object.keys(options)) {\n    resolvedOptions[key] = unref(\n      options[key as keyof TableOptionsWithReactiveData<TFeatures, TData>],\n    )\n  }\n\n  return mergeProxy(options, resolvedOptions)\n}\n\nfunction getReactiveOptionDeps<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(options: TableOptionsWithReactiveData<TFeatures, TData>) {\n  return Object.keys(options).map((key) =>\n    unref(options[key as keyof TableOptionsWithReactiveData<TFeatures, TData>]),\n  )\n}\n\nexport type VueTable<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TSelected = TableState<TFeatures>,\n> = Omit<Table<TFeatures, TData>, 'store'> & {\n  /**\n   * @deprecated Prefer `table.state` for render reads,\n   * `table.atoms.<slice>.get()` for slice snapshots, or\n   * `table.Subscribe` / `useSelector(table.store, selector)` for explicit\n   * subscriptions. `table.store.state` is a current-value snapshot and is easy\n   * to misuse in render code.\n   */\n  readonly store: Table<TFeatures, TData>['store']\n  /**\n   * Store mode: `selector` required. Source mode: pass `source` (atom or store); omit\n   * `selector` for the whole value (identity), or pass `selector` to project. Split\n   * overloads so source-only infers `TSourceValue` for `children` (see React `Subscribe`).\n   */\n  Subscribe: {\n    <TSourceValue>(props: {\n      source: SubscribeSource<TSourceValue>\n      selector?: undefined\n      children:\n        | ((state: Readonly<TSourceValue>) => VNode | Array<VNode>)\n        | VNode\n        | Array<VNode>\n    }): VNode | Array<VNode>\n    <TSourceValue, TSubSelected>(props: {\n      source: SubscribeSource<TSourceValue>\n      selector: (state: TSourceValue) => TSubSelected\n      children:\n        | ((state: Readonly<TSubSelected>) => VNode | Array<VNode>)\n        | VNode\n        | Array<VNode>\n    }): VNode | Array<VNode>\n    <TSubSelected>(props: {\n      selector: (state: NoInfer<TableState<TFeatures>>) => TSubSelected\n      children:\n        | ((state: Readonly<TSubSelected>) => VNode | Array<VNode>)\n        | VNode\n        | Array<VNode>\n    }): VNode | Array<VNode>\n  }\n  /**\n   * The selected state of the table. This state may not match the structure of\n   * the full table state because it is selected by the selector function that\n   * you pass as the 2nd argument to `useTable`.\n   *\n   * @example\n   * const table = useTable(options, (state) => ({ globalFilter: state.globalFilter })) // only globalFilter is part of the selected state\n   *\n   * console.log(table.state.globalFilter)\n   */\n  readonly state: Readonly<TSelected>\n}\n\n/**\n * Creates a Vue table instance backed by Vue-aware TanStack Store atoms.\n *\n * Table options may contain Vue refs or computed values. The adapter unwraps\n * those reactive inputs, watches them with synchronous flushing, and keeps the\n * table options in sync. The optional selector projects from `table.store` and\n * exposes the selected value on `table.state`.\n *\n * @example\n * ```ts\n * const table = useTable(\n *   {\n *     features,\n *     rowModels: {},\n *     columns,\n *     data,\n *   },\n *   (state) => ({ pagination: state.pagination }),\n * )\n *\n * table.state.pagination\n * ```\n */\nexport function useTable<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TSelected = TableState<TFeatures>,\n>(\n  tableOptions:\n    | TableOptions<TFeatures, TData>\n    | TableOptionsWithReactiveData<TFeatures, TData>,\n  selector?: (state: TableState<TFeatures>) => TSelected,\n): VueTable<TFeatures, TData, TSelected> {\n  const syncTableOptions = (\n    table: Table<TFeatures, TData>,\n    options: TableOptionsWithReactiveData<TFeatures, TData>,\n  ) => {\n    table.setOptions((prev) =>\n      flatMerge(prev, getOptionsWithReactiveValues(options)),\n    )\n  }\n\n  const mergedOptions = mergeProxy(tableOptions, {\n    features: {\n      coreReativityFeature: vueReactivity(),\n      ...(unref(tableOptions.features) ?? {}),\n    },\n  }) as TableOptionsWithReactiveData<TFeatures, TData>\n\n  const resolvedOptions = mergeProxy(\n    getOptionsWithReactiveValues(mergedOptions),\n    {\n      // Remove state and onStateChange - store handles it internally\n      mergeOptions: (\n        defaultOptions: TableOptions<TFeatures, TData>,\n        newOptions: Partial<TableOptions<TFeatures, TData>>,\n      ) => {\n        return flatMerge(defaultOptions, newOptions)\n      },\n    },\n  ) as TableOptions<TFeatures, TData>\n\n  const coreTable = constructTable(resolvedOptions)\n  const table = coreTable as unknown as VueTable<TFeatures, TData, TSelected>\n\n  watch(\n    () => getReactiveOptionDeps(mergedOptions),\n    () => {\n      syncTableOptions(coreTable, mergedOptions)\n    },\n    { immediate: true },\n  )\n\n  watch(\n    () => {\n      const controlledState = unref(tableOptions.state) as\n        | Record<string, unknown>\n        | undefined\n      const controlledAtoms = unref(tableOptions.atoms) as\n        | Record<string, unknown>\n        | undefined\n\n      if (!controlledState) {\n        return []\n      }\n\n      const controlledValues: Array<unknown> = []\n\n      for (const key of Object.keys(table.initialState)) {\n        if (!(key in controlledState) || controlledAtoms?.[key] !== undefined) {\n          continue\n        }\n\n        // Reading only controlled state slices here lets Vue subscribe to\n        // getters/computed values that are passed through `options.state`.\n        controlledValues.push(controlledState[key])\n      }\n\n      return controlledValues\n    },\n    (controlledValues) => {\n      if (controlledValues.length > 0) {\n        syncTableOptions(coreTable, mergedOptions)\n      }\n    },\n    { immediate: true },\n  )\n\n  table.Subscribe = ((props: {\n    source?: SubscribeSource<unknown>\n    selector?: ((state: unknown) => unknown) | undefined\n    children:\n      | ((state: Readonly<unknown>) => VNode | Array<VNode>)\n      | VNode\n      | Array<VNode>\n  }) => {\n    const source = props.source ?? table.store\n    const selected = useSelector(source as never, props.selector as never, {\n      compare: shallow,\n    })\n    if (typeof props.children === 'function') {\n      return props.children(selected.value as Readonly<unknown>)\n    }\n    return props.children\n  }) as VueTable<TFeatures, TData, TSelected>['Subscribe']\n\n  const stateStore = useSelector(table.store, selector)\n\n  return {\n    ...table,\n    get state() {\n      return stateStore.value\n    },\n  }\n}\n"],"mappings":";;;;;;;AAoCA,SAAS,6BAGP,SAAyD;CACzD,MAAM,kBAA2C,CAAC;CAElD,KAAK,MAAM,OAAO,OAAO,KAAK,OAAO,GACnC,gBAAgB,sBACd,QAAQ,IACV;CAGF,OAAOA,+BAAW,SAAS,eAAe;AAC5C;AAEA,SAAS,sBAGP,SAAyD;CACzD,OAAO,OAAO,KAAK,OAAO,CAAC,CAAC,KAAK,uBACzB,QAAQ,IAA4D,CAC5E;AACF;;;;;;;;;;;;;;;;;;;;;;;;AAiFA,SAAgB,SAKd,cAGA,UACuC;CACvC,MAAM,oBACJ,OACA,YACG;EACH,MAAM,YAAY,SAChBC,8BAAU,MAAM,6BAA6B,OAAO,CAAC,CACvD;CACF;CAEA,MAAM,gBAAgBD,+BAAW,cAAc,EAC7C,UAAU;EACR,sBAAsBE,iCAAc;EACpC,kBAAU,aAAa,QAAQ,KAAK,CAAC;CACvC,EACF,CAAC;CAeD,MAAM,qDAbkBF,+BACtB,6BAA6B,aAAa,GAC1C,EAEE,eACE,gBACA,eACG;EACH,OAAOC,8BAAU,gBAAgB,UAAU;CAC7C,EACF,CAG6C,CAAC;CAChD,MAAM,QAAQ;CAEd,qBACQ,sBAAsB,aAAa,SACnC;EACJ,iBAAiB,WAAW,aAAa;CAC3C,GACA,EAAE,WAAW,KAAK,CACpB;CAEA,qBACQ;EACJ,MAAM,iCAAwB,aAAa,KAAK;EAGhD,MAAM,iCAAwB,aAAa,KAAK;EAIhD,IAAI,CAAC,iBACH,OAAO,CAAC;EAGV,MAAM,mBAAmC,CAAC;EAE1C,KAAK,MAAM,OAAO,OAAO,KAAK,MAAM,YAAY,GAAG;GACjD,IAAI,EAAE,OAAO,uFAAoB,gBAAkB,UAAS,QAC1D;GAKF,iBAAiB,KAAK,gBAAgB,IAAI;EAC5C;EAEA,OAAO;CACT,IACC,qBAAqB;EACpB,IAAI,iBAAiB,SAAS,GAC5B,iBAAiB,WAAW,aAAa;CAE7C,GACA,EAAE,WAAW,KAAK,CACpB;CAEA,MAAM,cAAc,UAOd;EAEJ,MAAM,gDADS,MAAM,UAAU,MAAM,OACS,MAAM,UAAmB,EACrE,SAASE,4BACX,CAAC;EACD,IAAI,OAAO,MAAM,aAAa,YAC5B,OAAO,MAAM,SAAS,SAAS,KAA0B;EAE3D,OAAO,MAAM;CACf;CAEA,MAAM,kDAAyB,MAAM,OAAO,QAAQ;CAEpD,OAAO;EACL,GAAG;EACH,IAAI,QAAQ;GACV,OAAO,WAAW;EACpB;CACF;AACF"}

package/dist/useTable.d.cts

@@ -0,0 +1,76 @@
+import { NoInfer, RowData, Table, TableFeatures, TableOptions, TableState } from "@tanstack/table-core";
+import { Atom, ReadonlyAtom, ReadonlyStore, Store } from "@tanstack/vue-store";
+import { MaybeRef, VNode } from "vue";
+
+//#region src/useTable.d.ts
+type SubscribeSource<TValue> = Atom<TValue> | ReadonlyAtom<TValue> | Store<TValue> | ReadonlyStore<TValue>;
+type TableOptionsWithReactiveData<TFeatures extends TableFeatures, TData extends RowData> = { [K in keyof TableOptions<TFeatures, TData>]: K extends 'data' ? MaybeRef<ReadonlyArray<TData>> : MaybeRef<TableOptions<TFeatures, TData>[K]> };
+type VueTable<TFeatures extends TableFeatures, TData extends RowData, TSelected = TableState<TFeatures>> = Omit<Table<TFeatures, TData>, 'store'> & {
+  /**
+   * @deprecated Prefer `table.state` for render reads,
+   * `table.atoms.<slice>.get()` for slice snapshots, or
+   * `table.Subscribe` / `useSelector(table.store, selector)` for explicit
+   * subscriptions. `table.store.state` is a current-value snapshot and is easy
+   * to misuse in render code.
+   */
+  readonly store: Table<TFeatures, TData>['store'];
+  /**
+   * Store mode: `selector` required. Source mode: pass `source` (atom or store); omit
+   * `selector` for the whole value (identity), or pass `selector` to project. Split
+   * overloads so source-only infers `TSourceValue` for `children` (see React `Subscribe`).
+   */
+  Subscribe: {
+    <TSourceValue>(props: {
+      source: SubscribeSource<TSourceValue>;
+      selector?: undefined;
+      children: ((state: Readonly<TSourceValue>) => VNode | Array<VNode>) | VNode | Array<VNode>;
+    }): VNode | Array<VNode>;
+    <TSourceValue, TSubSelected>(props: {
+      source: SubscribeSource<TSourceValue>;
+      selector: (state: TSourceValue) => TSubSelected;
+      children: ((state: Readonly<TSubSelected>) => VNode | Array<VNode>) | VNode | Array<VNode>;
+    }): VNode | Array<VNode>;
+    <TSubSelected>(props: {
+      selector: (state: NoInfer<TableState<TFeatures>>) => TSubSelected;
+      children: ((state: Readonly<TSubSelected>) => VNode | Array<VNode>) | VNode | Array<VNode>;
+    }): VNode | Array<VNode>;
+  };
+  /**
+   * The selected state of the table. This state may not match the structure of
+   * the full table state because it is selected by the selector function that
+   * you pass as the 2nd argument to `useTable`.
+   *
+   * @example
+   * const table = useTable(options, (state) => ({ globalFilter: state.globalFilter })) // only globalFilter is part of the selected state
+   *
+   * console.log(table.state.globalFilter)
+   */
+  readonly state: Readonly<TSelected>;
+};
+/**
+ * Creates a Vue table instance backed by Vue-aware TanStack Store atoms.
+ *
+ * Table options may contain Vue refs or computed values. The adapter unwraps
+ * those reactive inputs, watches them with synchronous flushing, and keeps the
+ * table options in sync. The optional selector projects from `table.store` and
+ * exposes the selected value on `table.state`.
+ *
+ * @example
+ * ```ts
+ * const table = useTable(
+ *   {
+ *     features,
+ *     rowModels: {},
+ *     columns,
+ *     data,
+ *   },
+ *   (state) => ({ pagination: state.pagination }),
+ * )
+ *
+ * table.state.pagination
+ * ```
+ */
+declare function useTable<TFeatures extends TableFeatures, TData extends RowData, TSelected = TableState<TFeatures>>(tableOptions: TableOptions<TFeatures, TData> | TableOptionsWithReactiveData<TFeatures, TData>, selector?: (state: TableState<TFeatures>) => TSelected): VueTable<TFeatures, TData, TSelected>;
+//#endregion
+export { SubscribeSource, TableOptionsWithReactiveData, VueTable, useTable };
+//# sourceMappingURL=useTable.d.cts.map