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

package/src/merge-proxy.ts

@@ -3,15 +3,18 @@ function trueFn() {
 }
 
 const $PROXY = Symbol('merge-proxy')
+const $SOURCES = Symbol('merge-proxy-sources')
 
 // https://github.com/solidjs/solid/blob/c20ca4fd8c36bc0522fedb2c7f38a110b7ee2663/packages/solid/src/render/component.ts#L51-L118
 const propTraps: ProxyHandler<{
   get: (k: string | number | symbol) => any
   has: (k: string | number | symbol) => boolean
-  keys: () => string[]
+  keys: () => Array<string>
+  sources: Array<any>
 }> = {
   get(_, property, receiver) {
     if (property === $PROXY) return receiver
+    if (property === $SOURCES) return _.sources
     return _.get(property)
   },
   has(_, property) {
@@ -36,46 +39,94 @@ const propTraps: ProxyHandler<{
 }
 
 type UnboxLazy<T> = T extends () => infer U ? U : T
-type BoxedTupleTypes<T extends any[]> = {
+type BoxedTupleTypes<T extends Array<any>> = {
   [P in keyof T]: [UnboxLazy<T[P]>]
-}[Exclude<keyof T, keyof any[]>]
-type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
-  k: infer I
+}[Exclude<keyof T, keyof Array<any>>]
+type UnionToIntersection<T> = (T extends any ? (k: T) => void : never) extends (
+  k: infer I,
 ) => void
   ? I
   : never
 type UnboxIntersection<T> = T extends { 0: infer U } ? U : never
-type MergeProxy<T extends any[]> = UnboxIntersection<
+type MergeProxy<T extends Array<any>> = UnboxIntersection<
   UnionToIntersection<BoxedTupleTypes<T>>
 >
 
 function resolveSource(s: any) {
-  return 'value' in s ? s.value : s
+  return s && typeof s === 'object' && 'value' in s ? s.value : s
 }
 
-export function mergeProxy<T extends any[]>(...sources: T): MergeProxy<T>
+export function mergeProxy<T extends Array<any>>(...sources: T): MergeProxy<T>
 export function mergeProxy(...sources: any): any {
+  const flattenedSources = sources.flatMap((source: any) => {
+    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: string | number | symbol) {
-        for (let i = sources.length - 1; i >= 0; i--) {
-          const v = resolveSource(sources[i])[property]
+        for (let i = flattenedSources.length - 1; i >= 0; i--) {
+          const v = resolveSource(flattenedSources[i])[property]
           if (v !== undefined) return v
         }
       },
       has(property: string | number | symbol) {
-        for (let i = sources.length - 1; i >= 0; i--) {
-          if (property in resolveSource(sources[i])) return true
+        for (let i = flattenedSources.length - 1; i >= 0; i--) {
+          if (property in resolveSource(flattenedSources[i])) return true
         }
         return false
       },
       keys() {
         const keys = []
-        for (let i = 0; i < sources.length; i++)
-          keys.push(...Object.keys(resolveSource(sources[i])))
+        for (const source of flattenedSources)
+          keys.push(...Object.keys(resolveSource(source)))
         return [...Array.from(new Set(keys))]
       },
     },
-    propTraps
+    propTraps,
   )
 }
+
+/**
+ * Merges objects together by eagerly resolving all values into a flat object.
+ *
+ * Unlike `mergeProxy`, this does not preserve lazy proxy getters. Use this for
+ * repeated option update paths so each merge produces a plain object instead
+ * of accumulating a longer source list over time.
+ */
+export function flatMerge<T>(source: T): T
+export function flatMerge<T, U>(source: T, source1: U): T & U
+export function flatMerge<T, U, V>(source: T, source1: U, source2: V): T & U & V
+export function flatMerge<T, U, V, W>(
+  source: T,
+  source1: U,
+  source2: V,
+  source3: W,
+): T & U & V & W
+export function flatMerge(...sources: any): any {
+  const result: Record<PropertyKey, unknown> = {}
+
+  for (let source of sources) {
+    source = resolveSource(source)
+    if (!source) continue
+
+    for (const key of Reflect.ownKeys(source)) {
+      const value = (source as Record<PropertyKey, unknown>)[key]
+      if (value !== undefined) {
+        result[key] = value
+      }
+    }
+  }
+
+  return result
+}

package/src/reactivity.ts

@@ -0,0 +1,115 @@
+import {
+  computed,
+  getCurrentScope,
+  onScopeDispose,
+  shallowRef,
+  watch,
+} from 'vue'
+import { batch, createAtom } from '@tanstack/vue-store'
+import type {
+  TableAtomOptions,
+  TableReactivityBindings,
+} from '@tanstack/table-core/reactivity'
+import type { Atom, Observer, ReadonlyAtom } from '@tanstack/vue-store'
+import type { ComputedRef, ShallowRef } from 'vue'
+
+const optionsStoreDebugName = 'table/optionsStore'
+
+function observerToCallback<T>(
+  observerOrNext: Observer<T> | ((value: T) => void),
+): (value: T) => void {
+  return typeof observerOrNext === 'function'
+    ? observerOrNext
+    : (value) => observerOrNext.next?.(value)
+}
+
+function refToReadonlyAtom<T>(
+  source: ComputedRef<T> | ShallowRef<T>,
+): ReadonlyAtom<T> {
+  return Object.assign(source, {
+    get: () => source.value,
+    subscribe: ((observerOrNext: Observer<T> | ((value: T) => void)) => {
+      const stop = watch(source, observerToCallback(observerOrNext), {
+        flush: 'sync',
+      })
+      return { unsubscribe: stop }
+    }) as ReadonlyAtom<T>['subscribe'],
+  })
+}
+
+function refToWritableAtom<T>(source: ShallowRef<T>): Atom<T> {
+  return Object.assign(source, {
+    set: (updater: T | ((prevVal: T) => T)) => {
+      source.value =
+        typeof updater === 'function'
+          ? (updater as (prevVal: T) => T)(source.value)
+          : updater
+    },
+    get: () => source.value,
+    subscribe: ((observerOrNext: Observer<T> | ((value: T) => void)) => {
+      const stop = watch(source, observerToCallback(observerOrNext), {
+        flush: 'sync',
+      })
+      return { unsubscribe: stop }
+    }) as Atom<T>['subscribe'],
+  })
+}
+
+/**
+ * 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.
+ */
+export function vueReactivity(): TableReactivityBindings {
+  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: <T>(fn: () => T, _options?: TableAtomOptions<T>) => {
+      const storeAtom = createAtom(() => fn(), {
+        compare: _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: <T>(
+      value: T,
+      _options?: TableAtomOptions<T>,
+    ): Atom<T> => {
+      if (_options?.debugName === optionsStoreDebugName) {
+        return refToWritableAtom(shallowRef(value) as ShallowRef<T>)
+      }
+
+      return createAtom(value, {
+        compare: _options?.compare,
+      })
+    },
+    untrack: (fn) => fn(),
+    batch,
+  }
+}

package/src/static-functions.ts

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

package/src/useTable.ts

@@ -0,0 +1,251 @@
+import { unref, watch } from 'vue'
+import { constructTable } from '@tanstack/table-core'
+import { shallow, useSelector } from '@tanstack/vue-store'
+import { flatMerge, mergeProxy } from './merge-proxy'
+import { vueReactivity } from './reactivity'
+import type {
+  Atom,
+  ReadonlyAtom,
+  ReadonlyStore,
+  Store,
+} from '@tanstack/vue-store'
+import type {
+  NoInfer,
+  RowData,
+  Table,
+  TableFeatures,
+  TableOptions,
+  TableState,
+} from '@tanstack/table-core'
+import type { MaybeRef, VNode } from 'vue'
+
+export type SubscribeSource<TValue> =
+  | Atom<TValue>
+  | ReadonlyAtom<TValue>
+  | Store<TValue>
+  | ReadonlyStore<TValue>
+
+export 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]>
+}
+
+function getOptionsWithReactiveValues<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(options: TableOptionsWithReactiveData<TFeatures, TData>) {
+  const resolvedOptions: Record<string, unknown> = {}
+
+  for (const key of Object.keys(options)) {
+    resolvedOptions[key] = unref(
+      options[key as keyof TableOptionsWithReactiveData<TFeatures, TData>],
+    )
+  }
+
+  return mergeProxy(options, resolvedOptions)
+}
+
+function getReactiveOptionDeps<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(options: TableOptionsWithReactiveData<TFeatures, TData>) {
+  return Object.keys(options).map((key) =>
+    unref(options[key as keyof TableOptionsWithReactiveData<TFeatures, TData>]),
+  )
+}
+
+export 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
+ * ```
+ */
+export 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> {
+  const syncTableOptions = (
+    table: Table<TFeatures, TData>,
+    options: TableOptionsWithReactiveData<TFeatures, TData>,
+  ) => {
+    table.setOptions((prev) =>
+      flatMerge(prev, getOptionsWithReactiveValues(options)),
+    )
+  }
+
+  const mergedOptions = mergeProxy(tableOptions, {
+    features: {
+      coreReativityFeature: vueReactivity(),
+      ...(unref(tableOptions.features) ?? {}),
+    },
+  }) as TableOptionsWithReactiveData<TFeatures, TData>
+
+  const resolvedOptions = mergeProxy(
+    getOptionsWithReactiveValues(mergedOptions),
+    {
+      // Remove state and onStateChange - store handles it internally
+      mergeOptions: (
+        defaultOptions: TableOptions<TFeatures, TData>,
+        newOptions: Partial<TableOptions<TFeatures, TData>>,
+      ) => {
+        return flatMerge(defaultOptions, newOptions)
+      },
+    },
+  ) as TableOptions<TFeatures, TData>
+
+  const coreTable = constructTable(resolvedOptions)
+  const table = coreTable as unknown as VueTable<TFeatures, TData, TSelected>
+
+  watch(
+    () => getReactiveOptionDeps(mergedOptions),
+    () => {
+      syncTableOptions(coreTable, mergedOptions)
+    },
+    { immediate: true },
+  )
+
+  watch(
+    () => {
+      const controlledState = unref(tableOptions.state) as
+        | Record<string, unknown>
+        | undefined
+      const controlledAtoms = unref(tableOptions.atoms) as
+        | Record<string, unknown>
+        | undefined
+
+      if (!controlledState) {
+        return []
+      }
+
+      const controlledValues: Array<unknown> = []
+
+      for (const key of Object.keys(table.initialState)) {
+        if (!(key in controlledState) || controlledAtoms?.[key] !== undefined) {
+          continue
+        }
+
+        // Reading only controlled state slices here lets Vue subscribe to
+        // getters/computed values that are passed through `options.state`.
+        controlledValues.push(controlledState[key])
+      }
+
+      return controlledValues
+    },
+    (controlledValues) => {
+      if (controlledValues.length > 0) {
+        syncTableOptions(coreTable, mergedOptions)
+      }
+    },
+    { immediate: true },
+  )
+
+  table.Subscribe = ((props: {
+    source?: SubscribeSource<unknown>
+    selector?: ((state: unknown) => unknown) | undefined
+    children:
+      | ((state: Readonly<unknown>) => VNode | Array<VNode>)
+      | VNode
+      | Array<VNode>
+  }) => {
+    const source = props.source ?? table.store
+    const selected = useSelector(source as never, props.selector as never, {
+      compare: shallow,
+    })
+    if (typeof props.children === 'function') {
+      return props.children(selected.value as Readonly<unknown>)
+    }
+    return props.children
+  }) as VueTable<TFeatures, TData, TSelected>['Subscribe']
+
+  const stateStore = useSelector(table.store, selector)
+
+  return {
+    ...table,
+    get state() {
+      return stateStore.value
+    },
+  }
+}

package/dist/cjs/index.cjs

@@ -1,68 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const tableCore = require("@tanstack/table-core");
-const vue = require("vue");
-const mergeProxy = require("./merge-proxy.cjs");
-const FlexRender = vue.defineComponent({
-  props: ["render", "props"],
-  setup: (props) => {
-    return () => {
-      if (typeof props.render === "function" || typeof props.render === "object") {
-        return vue.h(props.render, props.props);
-      }
-      return props.render;
-    };
-  }
-});
-function useTable(options) {
-  const resolvedOptions = mergeProxy.mergeProxy(
-    {
-      state: {},
-      // Dummy state
-      onStateChange: () => {
-      },
-      // noop
-      renderFallbackValue: null,
-      mergeOptions(defaultOptions, options2) {
-        return mergeProxy.mergeProxy(defaultOptions, options2);
-      }
-    },
-    options
-  );
-  const table = tableCore._createTable(resolvedOptions);
-  const state = vue.ref(table.initialState);
-  vue.watchEffect(() => {
-    table.setOptions((prev) => {
-      const stateProxy = new Proxy({}, {
-        get: (_, prop) => state.value[prop]
-      });
-      return mergeProxy.mergeProxy(prev, options, {
-        // merge the initialState and `options.state`
-        // create a new proxy on each `setOptions` call
-        // and get the value from state on each property access
-        state: mergeProxy.mergeProxy(stateProxy, options.state ?? {}),
-        // Similarly, we'll maintain both our internal state and any user-provided
-        // state.
-        onStateChange: (updater) => {
-          var _a;
-          if (updater instanceof Function) {
-            state.value = updater(state.value);
-          } else {
-            state.value = updater;
-          }
-          (_a = options.onStateChange) == null ? void 0 : _a.call(options, updater);
-        }
-      });
-    });
-  });
-  return table;
-}
-exports.FlexRender = FlexRender;
-exports.useTable = useTable;
-Object.keys(tableCore).forEach((k) => {
-  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: () => tableCore[k]
-  });
-});
-//# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs","sources":["../../src/index.ts"],"sourcesContent":["import {\n  TableOptions,\n  _createTable,\n  TableOptionsResolved,\n  RowData,\n} from '@tanstack/table-core'\nimport { h, watchEffect, ref, defineComponent } from 'vue'\nimport { mergeProxy } from './merge-proxy'\n\nexport * from '@tanstack/table-core'\n\nexport const FlexRender = defineComponent({\n  props: ['render', 'props'],\n  setup: (props: { render: any; props: any }) => {\n    return () => {\n      if (\n        typeof props.render === 'function' ||\n        typeof props.render === 'object'\n      ) {\n        return h(props.render, props.props)\n      }\n\n      return props.render\n    }\n  },\n})\n\nexport function useTable<TData extends RowData>(options: TableOptions<TData>) {\n  const resolvedOptions: TableOptionsResolved<TData> = mergeProxy(\n    {\n      state: {}, // Dummy state\n      onStateChange: () => {}, // noop\n      renderFallbackValue: null,\n      mergeOptions(\n        defaultOptions: TableOptions<TData>,\n        options: TableOptions<TData>\n      ) {\n        return mergeProxy(defaultOptions, options)\n      },\n    },\n    options\n  )\n\n  const table = _createTable<TData>(resolvedOptions)\n  // can't use `reactive` because update needs to be immutable\n  const state = ref(table.initialState)\n\n  watchEffect(() => {\n    table.setOptions(prev => {\n      const stateProxy = new Proxy({} as typeof state.value, {\n        get: (_, prop) => state.value[prop as keyof typeof state.value],\n      })\n\n      return mergeProxy(prev, options, {\n        // merge the initialState and `options.state`\n        // create a new proxy on each `setOptions` call\n        // and get the value from state on each property access\n        state: mergeProxy(stateProxy, options.state ?? {}),\n        // Similarly, we'll maintain both our internal state and any user-provided\n        // state.\n        onStateChange: (updater: any) => {\n          if (updater instanceof Function) {\n            state.value = updater(state.value)\n          } else {\n            state.value = updater\n          }\n\n          options.onStateChange?.(updater)\n        },\n      })\n    })\n  })\n\n  return table\n}\n"],"names":["defineComponent","h","mergeProxy","options","_createTable","ref","watchEffect"],"mappings":";;;;;AAWO,MAAM,aAAaA,IAAAA,gBAAgB;AAAA,EACxC,OAAO,CAAC,UAAU,OAAO;AAAA,EACzB,OAAO,CAAC,UAAuC;AAC7C,WAAO,MAAM;AACX,UACE,OAAO,MAAM,WAAW,cACxB,OAAO,MAAM,WAAW,UACxB;AACA,eAAOC,IAAE,EAAA,MAAM,QAAQ,MAAM,KAAK;AAAA,MACpC;AAEA,aAAO,MAAM;AAAA,IAAA;AAAA,EAEjB;AACF,CAAC;AAEM,SAAS,SAAgC,SAA8B;AAC5E,QAAM,kBAA+CC,WAAA;AAAA,IACnD;AAAA,MACE,OAAO,CAAC;AAAA;AAAA,MACR,eAAe,MAAM;AAAA,MAAC;AAAA;AAAA,MACtB,qBAAqB;AAAA,MACrB,aACE,gBACAC,UACA;AACO,eAAAD,WAAA,WAAW,gBAAgBC,QAAO;AAAA,MAC3C;AAAA,IACF;AAAA,IACA;AAAA,EAAA;AAGI,QAAA,QAAQC,uBAAoB,eAAe;AAE3C,QAAA,QAAQC,IAAAA,IAAI,MAAM,YAAY;AAEpCC,MAAAA,YAAY,MAAM;AAChB,UAAM,WAAW,CAAQ,SAAA;AACvB,YAAM,aAAa,IAAI,MAAM,IAA0B;AAAA,QACrD,KAAK,CAAC,GAAG,SAAS,MAAM,MAAM,IAAgC;AAAA,MAAA,CAC/D;AAEM,aAAAJ,WAAA,WAAW,MAAM,SAAS;AAAA;AAAA;AAAA;AAAA,QAI/B,OAAOA,WAAAA,WAAW,YAAY,QAAQ,SAAS,CAAA,CAAE;AAAA;AAAA;AAAA,QAGjD,eAAe,CAAC,YAAiB;;AAC/B,cAAI,mBAAmB,UAAU;AACzB,kBAAA,QAAQ,QAAQ,MAAM,KAAK;AAAA,UAAA,OAC5B;AACL,kBAAM,QAAQ;AAAA,UAChB;AAEA,wBAAQ,kBAAR,iCAAwB;AAAA,QAC1B;AAAA,MAAA,CACD;AAAA,IAAA,CACF;AAAA,EAAA,CACF;AAEM,SAAA;AACT;;;;;;;;;"}

package/dist/cjs/index.d.cts

@@ -1,14 +0,0 @@
-import { TableOptions, RowData } from '@tanstack/table-core';
-
-export * from '@tanstack/table-core';
-export declare const FlexRender: import('vue').DefineComponent<Readonly<{
-    props?: any;
-    render?: any;
-}>, () => any, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<Readonly<{
-    props?: any;
-    render?: any;
-}>>>, {
-    readonly props?: any;
-    readonly render?: any;
-}, {}>;
-export declare function useTable<TData extends RowData>(options: TableOptions<TData>): import('@tanstack/table-core').Table<TData>;

package/dist/cjs/merge-proxy.cjs

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-function trueFn() {
-  return true;
-}
-const $PROXY = Symbol("merge-proxy");
-const propTraps = {
-  get(_, property, receiver) {
-    if (property === $PROXY) return receiver;
-    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 "value" in s ? s.value : s;
-}
-function mergeProxy(...sources) {
-  return new Proxy(
-    {
-      get(property) {
-        for (let i = sources.length - 1; i >= 0; i--) {
-          const v = resolveSource(sources[i])[property];
-          if (v !== void 0) return v;
-        }
-      },
-      has(property) {
-        for (let i = sources.length - 1; i >= 0; i--) {
-          if (property in resolveSource(sources[i])) return true;
-        }
-        return false;
-      },
-      keys() {
-        const keys = [];
-        for (let i = 0; i < sources.length; i++)
-          keys.push(...Object.keys(resolveSource(sources[i])));
-        return [...Array.from(new Set(keys))];
-      }
-    },
-    propTraps
-  );
-}
-exports.mergeProxy = mergeProxy;
-//# sourceMappingURL=merge-proxy.cjs.map

package/dist/cjs/merge-proxy.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"merge-proxy.cjs","sources":["../../src/merge-proxy.ts"],"sourcesContent":["function trueFn() {\n  return true\n}\n\nconst $PROXY = Symbol('merge-proxy')\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: () => string[]\n}> = {\n  get(_, property, receiver) {\n    if (property === $PROXY) return receiver\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 any[]> = {\n  [P in keyof T]: [UnboxLazy<T[P]>]\n}[Exclude<keyof T, keyof any[]>]\ntype UnionToIntersection<U> = (U extends any ? (k: U) => 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 any[]> = UnboxIntersection<\n  UnionToIntersection<BoxedTupleTypes<T>>\n>\n\nfunction resolveSource(s: any) {\n  return 'value' in s ? s.value : s\n}\n\nexport function mergeProxy<T extends any[]>(...sources: T): MergeProxy<T>\nexport function mergeProxy(...sources: any): any {\n  return new Proxy(\n    {\n      get(property: string | number | symbol) {\n        for (let i = sources.length - 1; i >= 0; i--) {\n          const v = resolveSource(sources[i])[property]\n          if (v !== undefined) return v\n        }\n      },\n      has(property: string | number | symbol) {\n        for (let i = sources.length - 1; i >= 0; i--) {\n          if (property in resolveSource(sources[i])) return true\n        }\n        return false\n      },\n      keys() {\n        const keys = []\n        for (let i = 0; i < sources.length; i++)\n          keys.push(...Object.keys(resolveSource(sources[i])))\n        return [...Array.from(new Set(keys))]\n      },\n    },\n    propTraps\n  )\n}\n"],"names":[],"mappings":";;AAAA,SAAS,SAAS;AACT,SAAA;AACT;AAEA,MAAM,SAAS,OAAO,aAAa;AAGnC,MAAM,YAID;AAAA,EACH,IAAI,GAAG,UAAU,UAAU;AACrB,QAAA,aAAa,OAAe,QAAA;AACzB,WAAA,EAAE,IAAI,QAAQ;AAAA,EACvB;AAAA,EACA,IAAI,GAAG,UAAU;AACR,WAAA,EAAE,IAAI,QAAQ;AAAA,EACvB;AAAA,EACA,KAAK;AAAA,EACL,gBAAgB;AAAA,EAChB,yBAAyB,GAAG,UAAU;AAC7B,WAAA;AAAA,MACL,cAAc;AAAA,MACd,YAAY;AAAA,MACZ,MAAM;AACG,eAAA,EAAE,IAAI,QAAQ;AAAA,MACvB;AAAA,MACA,KAAK;AAAA,MACL,gBAAgB;AAAA,IAAA;AAAA,EAEpB;AAAA,EACA,QAAQ,GAAG;AACT,WAAO,EAAE;EACX;AACF;AAgBA,SAAS,cAAc,GAAQ;AACtB,SAAA,WAAW,IAAI,EAAE,QAAQ;AAClC;AAGO,SAAS,cAAc,SAAmB;AAC/C,SAAO,IAAI;AAAA,IACT;AAAA,MACE,IAAI,UAAoC;AACtC,iBAAS,IAAI,QAAQ,SAAS,GAAG,KAAK,GAAG,KAAK;AAC5C,gBAAM,IAAI,cAAc,QAAQ,CAAC,CAAC,EAAE,QAAQ;AACxC,cAAA,MAAM,OAAkB,QAAA;AAAA,QAC9B;AAAA,MACF;AAAA,MACA,IAAI,UAAoC;AACtC,iBAAS,IAAI,QAAQ,SAAS,GAAG,KAAK,GAAG,KAAK;AAC5C,cAAI,YAAY,cAAc,QAAQ,CAAC,CAAC,EAAU,QAAA;AAAA,QACpD;AACO,eAAA;AAAA,MACT;AAAA,MACA,OAAO;AACL,cAAM,OAAO,CAAA;AACb,iBAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ;AAC7B,eAAA,KAAK,GAAG,OAAO,KAAK,cAAc,QAAQ,CAAC,CAAC,CAAC,CAAC;AAC9C,eAAA,CAAC,GAAG,MAAM,KAAK,IAAI,IAAI,IAAI,CAAC,CAAC;AAAA,MACtC;AAAA,IACF;AAAA,IACA;AAAA,EAAA;AAEJ;;"}

package/dist/cjs/merge-proxy.d.cts

@@ -1,11 +0,0 @@
-type UnboxLazy<T> = T extends () => infer U ? U : T;
-type BoxedTupleTypes<T extends any[]> = {
-    [P in keyof T]: [UnboxLazy<T[P]>];
-}[Exclude<keyof T, keyof any[]>];
-type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-type UnboxIntersection<T> = T extends {
-    0: infer U;
-} ? U : never;
-type MergeProxy<T extends any[]> = UnboxIntersection<UnionToIntersection<BoxedTupleTypes<T>>>;
-export declare function mergeProxy<T extends any[]>(...sources: T): MergeProxy<T>;
-export {};

package/dist/esm/index.d.ts

@@ -1,14 +0,0 @@
-import { TableOptions, RowData } from '@tanstack/table-core';
-
-export * from '@tanstack/table-core';
-export declare const FlexRender: import('vue').DefineComponent<Readonly<{
-    props?: any;
-    render?: any;
-}>, () => any, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<Readonly<{
-    props?: any;
-    render?: any;
-}>>>, {
-    readonly props?: any;
-    readonly render?: any;
-}, {}>;
-export declare function useTable<TData extends RowData>(options: TableOptions<TData>): import('@tanstack/table-core').Table<TData>;