fastapi-rtk 0.1.12 → 0.1.14

package/dist/external/cjs/@tanstack_query-core@5.75.0/node_modules/@tanstack/query-core/build/modern/utils.cjs

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var isServer = typeof window === "undefined" || "Deno" in globalThis;
+function noop() {
+}
+function functionalUpdate(updater, input) {
+  return typeof updater === "function" ? updater(input) : updater;
+}
+function isValidTimeout(value) {
+  return typeof value === "number" && value >= 0 && value !== Infinity;
+}
+function timeUntilStale(updatedAt, staleTime) {
+  return Math.max(updatedAt + (staleTime || 0) - Date.now(), 0);
+}
+function resolveStaleTime(staleTime, query) {
+  return typeof staleTime === "function" ? staleTime(query) : staleTime;
+}
+function resolveEnabled(enabled, query) {
+  return typeof enabled === "function" ? enabled(query) : enabled;
+}
+function matchQuery(filters, query) {
+  const {
+    type = "all",
+    exact,
+    fetchStatus,
+    predicate,
+    queryKey,
+    stale
+  } = filters;
+  if (queryKey) {
+    if (exact) {
+      if (query.queryHash !== hashQueryKeyByOptions(queryKey, query.options)) {
+        return false;
+      }
+    } else if (!partialMatchKey(query.queryKey, queryKey)) {
+      return false;
+    }
+  }
+  if (type !== "all") {
+    const isActive = query.isActive();
+    if (type === "active" && !isActive) {
+      return false;
+    }
+    if (type === "inactive" && isActive) {
+      return false;
+    }
+  }
+  if (typeof stale === "boolean" && query.isStale() !== stale) {
+    return false;
+  }
+  if (fetchStatus && fetchStatus !== query.state.fetchStatus) {
+    return false;
+  }
+  if (predicate && !predicate(query)) {
+    return false;
+  }
+  return true;
+}
+function matchMutation(filters, mutation) {
+  const { exact, status, predicate, mutationKey } = filters;
+  if (mutationKey) {
+    if (!mutation.options.mutationKey) {
+      return false;
+    }
+    if (exact) {
+      if (hashKey(mutation.options.mutationKey) !== hashKey(mutationKey)) {
+        return false;
+      }
+    } else if (!partialMatchKey(mutation.options.mutationKey, mutationKey)) {
+      return false;
+    }
+  }
+  if (status && mutation.state.status !== status) {
+    return false;
+  }
+  if (predicate && !predicate(mutation)) {
+    return false;
+  }
+  return true;
+}
+function hashQueryKeyByOptions(queryKey, options) {
+  const hashFn = (options == null ? void 0 : options.queryKeyHashFn) || hashKey;
+  return hashFn(queryKey);
+}
+function hashKey(queryKey) {
+  return JSON.stringify(
+    queryKey,
+    (_, val) => isPlainObject(val) ? Object.keys(val).sort().reduce((result, key) => {
+      result[key] = val[key];
+      return result;
+    }, {}) : val
+  );
+}
+function partialMatchKey(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (typeof a !== typeof b) {
+    return false;
+  }
+  if (a && b && typeof a === "object" && typeof b === "object") {
+    return Object.keys(b).every((key) => partialMatchKey(a[key], b[key]));
+  }
+  return false;
+}
+function replaceEqualDeep(a, b) {
+  if (a === b) {
+    return a;
+  }
+  const array = isPlainArray(a) && isPlainArray(b);
+  if (array || isPlainObject(a) && isPlainObject(b)) {
+    const aItems = array ? a : Object.keys(a);
+    const aSize = aItems.length;
+    const bItems = array ? b : Object.keys(b);
+    const bSize = bItems.length;
+    const copy = array ? [] : {};
+    let equalItems = 0;
+    for (let i = 0; i < bSize; i++) {
+      const key = array ? i : bItems[i];
+      if ((!array && aItems.includes(key) || array) && a[key] === void 0 && b[key] === void 0) {
+        copy[key] = void 0;
+        equalItems++;
+      } else {
+        copy[key] = replaceEqualDeep(a[key], b[key]);
+        if (copy[key] === a[key] && a[key] !== void 0) {
+          equalItems++;
+        }
+      }
+    }
+    return aSize === bSize && equalItems === aSize ? a : copy;
+  }
+  return b;
+}
+function shallowEqualObjects(a, b) {
+  if (!b || Object.keys(a).length !== Object.keys(b).length) {
+    return false;
+  }
+  for (const key in a) {
+    if (a[key] !== b[key]) {
+      return false;
+    }
+  }
+  return true;
+}
+function isPlainArray(value) {
+  return Array.isArray(value) && value.length === Object.keys(value).length;
+}
+function isPlainObject(o) {
+  if (!hasObjectPrototype(o)) {
+    return false;
+  }
+  const ctor = o.constructor;
+  if (ctor === void 0) {
+    return true;
+  }
+  const prot = ctor.prototype;
+  if (!hasObjectPrototype(prot)) {
+    return false;
+  }
+  if (!prot.hasOwnProperty("isPrototypeOf")) {
+    return false;
+  }
+  if (Object.getPrototypeOf(o) !== Object.prototype) {
+    return false;
+  }
+  return true;
+}
+function hasObjectPrototype(o) {
+  return Object.prototype.toString.call(o) === "[object Object]";
+}
+function sleep(timeout) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, timeout);
+  });
+}
+function replaceData(prevData, data, options) {
+  if (typeof options.structuralSharing === "function") {
+    return options.structuralSharing(prevData, data);
+  } else if (options.structuralSharing !== false) {
+    if (process.env.NODE_ENV !== "production") {
+      try {
+        return replaceEqualDeep(prevData, data);
+      } catch (error) {
+        console.error(
+          `Structural sharing requires data to be JSON serializable. To fix this, turn off structuralSharing or return JSON-serializable data from your queryFn. [${options.queryHash}]: ${error}`
+        );
+        throw error;
+      }
+    }
+    return replaceEqualDeep(prevData, data);
+  }
+  return data;
+}
+function keepPreviousData(previousData) {
+  return previousData;
+}
+function addToEnd(items, item, max = 0) {
+  const newItems = [...items, item];
+  return max && newItems.length > max ? newItems.slice(1) : newItems;
+}
+function addToStart(items, item, max = 0) {
+  const newItems = [item, ...items];
+  return max && newItems.length > max ? newItems.slice(0, -1) : newItems;
+}
+var skipToken = Symbol();
+function ensureQueryFn(options, fetchOptions) {
+  if (process.env.NODE_ENV !== "production") {
+    if (options.queryFn === skipToken) {
+      console.error(
+        `Attempted to invoke queryFn when set to skipToken. This is likely a configuration error. Query hash: '${options.queryHash}'`
+      );
+    }
+  }
+  if (!options.queryFn && (fetchOptions == null ? void 0 : fetchOptions.initialPromise)) {
+    return () => fetchOptions.initialPromise;
+  }
+  if (!options.queryFn || options.queryFn === skipToken) {
+    return () => Promise.reject(new Error(`Missing queryFn: '${options.queryHash}'`));
+  }
+  return options.queryFn;
+}
+exports.addToEnd = addToEnd;
+exports.addToStart = addToStart;
+exports.ensureQueryFn = ensureQueryFn;
+exports.functionalUpdate = functionalUpdate;
+exports.hashKey = hashKey;
+exports.hashQueryKeyByOptions = hashQueryKeyByOptions;
+exports.isPlainArray = isPlainArray;
+exports.isPlainObject = isPlainObject;
+exports.isServer = isServer;
+exports.isValidTimeout = isValidTimeout;
+exports.keepPreviousData = keepPreviousData;
+exports.matchMutation = matchMutation;
+exports.matchQuery = matchQuery;
+exports.noop = noop;
+exports.partialMatchKey = partialMatchKey;
+exports.replaceData = replaceData;
+exports.replaceEqualDeep = replaceEqualDeep;
+exports.resolveEnabled = resolveEnabled;
+exports.resolveStaleTime = resolveStaleTime;
+exports.shallowEqualObjects = shallowEqualObjects;
+exports.skipToken = skipToken;
+exports.sleep = sleep;
+exports.timeUntilStale = timeUntilStale;

package/dist/external/cjs/@tanstack_react-query@5.75.1_react@18.3.1/node_modules/@tanstack/react-query/build/modern/QueryClientProvider.cjs

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const React = require("react");
+const jsxRuntime = require("react/jsx-runtime");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const React__namespace = /* @__PURE__ */ _interopNamespaceDefault(React);
+var QueryClientContext = React__namespace.createContext(
+  void 0
+);
+var useQueryClient = (queryClient) => {
+  const client = React__namespace.useContext(QueryClientContext);
+  if (!client) {
+    throw new Error("No QueryClient set, use QueryClientProvider to set one");
+  }
+  return client;
+};
+var QueryClientProvider = ({
+  client,
+  children
+}) => {
+  React__namespace.useEffect(() => {
+    client.mount();
+    return () => {
+      client.unmount();
+    };
+  }, [client]);
+  return /* @__PURE__ */ jsxRuntime.jsx(QueryClientContext.Provider, { value: client, children });
+};
+exports.QueryClientContext = QueryClientContext;
+exports.QueryClientProvider = QueryClientProvider;
+exports.useQueryClient = useQueryClient;

package/dist/external/cjs/@tanstack_react-query@5.75.1_react@18.3.1/node_modules/@tanstack/react-query/build/modern/QueryErrorResetBoundary.cjs

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const React = require("react");
+require("react/jsx-runtime");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const React__namespace = /* @__PURE__ */ _interopNamespaceDefault(React);
+function createValue() {
+  let isReset = false;
+  return {
+    clearReset: () => {
+      isReset = false;
+    },
+    reset: () => {
+      isReset = true;
+    },
+    isReset: () => {
+      return isReset;
+    }
+  };
+}
+var QueryErrorResetBoundaryContext = React__namespace.createContext(createValue());
+var useQueryErrorResetBoundary = () => React__namespace.useContext(QueryErrorResetBoundaryContext);
+exports.useQueryErrorResetBoundary = useQueryErrorResetBoundary;

package/dist/external/cjs/@tanstack_react-query@5.75.1_react@18.3.1/node_modules/@tanstack/react-query/build/modern/errorBoundaryUtils.cjs

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const React = require("react");
+const utils = require("./utils.cjs");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const React__namespace = /* @__PURE__ */ _interopNamespaceDefault(React);
+var ensurePreventErrorBoundaryRetry = (options, errorResetBoundary) => {
+  if (options.suspense || options.throwOnError || options.experimental_prefetchInRender) {
+    if (!errorResetBoundary.isReset()) {
+      options.retryOnMount = false;
+    }
+  }
+};
+var useClearResetErrorBoundary = (errorResetBoundary) => {
+  React__namespace.useEffect(() => {
+    errorResetBoundary.clearReset();
+  }, [errorResetBoundary]);
+};
+var getHasError = ({
+  result,
+  errorResetBoundary,
+  throwOnError,
+  query,
+  suspense
+}) => {
+  return result.isError && !errorResetBoundary.isReset() && !result.isFetching && query && (suspense && result.data === void 0 || utils.shouldThrowError(throwOnError, [result.error, query]));
+};
+exports.ensurePreventErrorBoundaryRetry = ensurePreventErrorBoundaryRetry;
+exports.getHasError = getHasError;
+exports.useClearResetErrorBoundary = useClearResetErrorBoundary;

package/dist/external/cjs/@tanstack_react-query@5.75.1_react@18.3.1/node_modules/@tanstack/react-query/build/modern/isRestoring.cjs

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const React = require("react");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const React__namespace = /* @__PURE__ */ _interopNamespaceDefault(React);
+var IsRestoringContext = React__namespace.createContext(false);
+var useIsRestoring = () => React__namespace.useContext(IsRestoringContext);
+IsRestoringContext.Provider;
+exports.useIsRestoring = useIsRestoring;

package/dist/external/cjs/@tanstack_react-query@5.75.1_react@18.3.1/node_modules/@tanstack/react-query/build/modern/suspense.cjs

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var ensureSuspenseTimers = (defaultedOptions) => {
+  const originalStaleTime = defaultedOptions.staleTime;
+  if (defaultedOptions.suspense) {
+    defaultedOptions.staleTime = typeof originalStaleTime === "function" ? (...args) => Math.max(originalStaleTime(...args), 1e3) : Math.max(originalStaleTime ?? 1e3, 1e3);
+    if (typeof defaultedOptions.gcTime === "number") {
+      defaultedOptions.gcTime = Math.max(defaultedOptions.gcTime, 1e3);
+    }
+  }
+};
+var willFetch = (result, isRestoring) => result.isLoading && result.isFetching && !isRestoring;
+var shouldSuspend = (defaultedOptions, result) => (defaultedOptions == null ? void 0 : defaultedOptions.suspense) && result.isPending;
+var fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).catch(() => {
+  errorResetBoundary.clearReset();
+});
+exports.ensureSuspenseTimers = ensureSuspenseTimers;
+exports.fetchOptimistic = fetchOptimistic;
+exports.shouldSuspend = shouldSuspend;
+exports.willFetch = willFetch;

package/dist/external/cjs/@tanstack_react-query@5.75.1_react@18.3.1/node_modules/@tanstack/react-query/build/modern/useBaseQuery.cjs

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const React = require("react");
+const notifyManager = require("../../../../../../@tanstack_query-core@5.75.0/node_modules/@tanstack/query-core/build/modern/notifyManager.cjs");
+const utils$1 = require("../../../../../../@tanstack_query-core@5.75.0/node_modules/@tanstack/query-core/build/modern/utils.cjs");
+const QueryClientProvider = require("./QueryClientProvider.cjs");
+const QueryErrorResetBoundary = require("./QueryErrorResetBoundary.cjs");
+const errorBoundaryUtils = require("./errorBoundaryUtils.cjs");
+const isRestoring = require("./isRestoring.cjs");
+const suspense = require("./suspense.cjs");
+const utils = require("./utils.cjs");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const React__namespace = /* @__PURE__ */ _interopNamespaceDefault(React);
+function useBaseQuery(options, Observer, queryClient) {
+  var _a, _b, _c, _d, _e;
+  if (process.env.NODE_ENV !== "production") {
+    if (typeof options !== "object" || Array.isArray(options)) {
+      throw new Error(
+        'Bad argument type. Starting with v5, only the "Object" form is allowed when calling query related functions. Please use the error stack to find the culprit call. More info here: https://tanstack.com/query/latest/docs/react/guides/migrating-to-v5#supports-a-single-signature-one-object'
+      );
+    }
+  }
+  const client = QueryClientProvider.useQueryClient();
+  const isRestoring$1 = isRestoring.useIsRestoring();
+  const errorResetBoundary = QueryErrorResetBoundary.useQueryErrorResetBoundary();
+  const defaultedOptions = client.defaultQueryOptions(options);
+  (_b = (_a = client.getDefaultOptions().queries) == null ? void 0 : _a._experimental_beforeQuery) == null ? void 0 : _b.call(
+    _a,
+    defaultedOptions
+  );
+  if (process.env.NODE_ENV !== "production") {
+    if (!defaultedOptions.queryFn) {
+      console.error(
+        `[${defaultedOptions.queryHash}]: No queryFn was passed as an option, and no default queryFn was found. The queryFn parameter is only optional when using a default queryFn. More info here: https://tanstack.com/query/latest/docs/framework/react/guides/default-query-function`
+      );
+    }
+  }
+  defaultedOptions._optimisticResults = isRestoring$1 ? "isRestoring" : "optimistic";
+  suspense.ensureSuspenseTimers(defaultedOptions);
+  errorBoundaryUtils.ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary);
+  errorBoundaryUtils.useClearResetErrorBoundary(errorResetBoundary);
+  const isNewCacheEntry = !client.getQueryCache().get(defaultedOptions.queryHash);
+  const [observer] = React__namespace.useState(
+    () => new Observer(
+      client,
+      defaultedOptions
+    )
+  );
+  const result = observer.getOptimisticResult(defaultedOptions);
+  const shouldSubscribe = !isRestoring$1 && options.subscribed !== false;
+  React__namespace.useSyncExternalStore(
+    React__namespace.useCallback(
+      (onStoreChange) => {
+        const unsubscribe = shouldSubscribe ? observer.subscribe(notifyManager.notifyManager.batchCalls(onStoreChange)) : utils.noop;
+        observer.updateResult();
+        return unsubscribe;
+      },
+      [observer, shouldSubscribe]
+    ),
+    () => observer.getCurrentResult(),
+    () => observer.getCurrentResult()
+  );
+  React__namespace.useEffect(() => {
+    observer.setOptions(defaultedOptions);
+  }, [defaultedOptions, observer]);
+  if (suspense.shouldSuspend(defaultedOptions, result)) {
+    throw suspense.fetchOptimistic(defaultedOptions, observer, errorResetBoundary);
+  }
+  if (errorBoundaryUtils.getHasError({
+    result,
+    errorResetBoundary,
+    throwOnError: defaultedOptions.throwOnError,
+    query: client.getQueryCache().get(defaultedOptions.queryHash),
+    suspense: defaultedOptions.suspense
+  })) {
+    throw result.error;
+  }
+  (_d = (_c = client.getDefaultOptions().queries) == null ? void 0 : _c._experimental_afterQuery) == null ? void 0 : _d.call(
+    _c,
+    defaultedOptions,
+    result
+  );
+  if (defaultedOptions.experimental_prefetchInRender && !utils$1.isServer && suspense.willFetch(result, isRestoring$1)) {
+    const promise = isNewCacheEntry ? (
+      // Fetch immediately on render in order to ensure `.promise` is resolved even if the component is unmounted
+      suspense.fetchOptimistic(defaultedOptions, observer, errorResetBoundary)
+    ) : (
+      // subscribe to the "cache promise" so that we can finalize the currentThenable once data comes in
+      (_e = client.getQueryCache().get(defaultedOptions.queryHash)) == null ? void 0 : _e.promise
+    );
+    promise == null ? void 0 : promise.catch(utils.noop).finally(() => {
+      observer.updateResult();
+    });
+  }
+  return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
+}
+exports.useBaseQuery = useBaseQuery;

package/dist/external/cjs/@tanstack_react-query@5.75.1_react@18.3.1/node_modules/@tanstack/react-query/build/modern/useQuery.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const queryObserver = require("../../../../../../@tanstack_query-core@5.75.0/node_modules/@tanstack/query-core/build/modern/queryObserver.cjs");
+const useBaseQuery = require("./useBaseQuery.cjs");
+function useQuery(options, queryClient) {
+  return useBaseQuery.useBaseQuery(options, queryObserver.QueryObserver);
+}
+exports.useQuery = useQuery;

package/dist/external/cjs/@tanstack_react-query@5.75.1_react@18.3.1/node_modules/@tanstack/react-query/build/modern/utils.cjs

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function shouldThrowError(throwError, params) {
+  if (typeof throwError === "function") {
+    return throwError(...params);
+  }
+  return !!throwError;
+}
+function noop() {
+}
+exports.noop = noop;
+exports.shouldThrowError = shouldThrowError;

package/dist/external/cjs/@tanstack_react-table@8.20.5_react-dom@18.3.1_react@18.3.1/node_modules/@tanstack/react-table/build/lib/index.cjs

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const React = require("react");
+const index = require("../../../../../../@tanstack_table-core@8.20.5/node_modules/@tanstack/table-core/build/lib/index.cjs");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const React__namespace = /* @__PURE__ */ _interopNamespaceDefault(React);
+/**
+   * react-table
+   *
+   * Copyright (c) TanStack
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE.md file in the root directory of this source tree.
+   *
+   * @license MIT
+   */
+function useReactTable(options) {
+  const resolvedOptions = {
+    state: {},
+    // Dummy state
+    onStateChange: () => {
+    },
+    // noop
+    renderFallbackValue: null,
+    ...options
+  };
+  const [tableRef] = React__namespace.useState(() => ({
+    current: index.createTable(resolvedOptions)
+  }));
+  const [state, setState] = React__namespace.useState(() => tableRef.current.initialState);
+  tableRef.current.setOptions((prev) => ({
+    ...prev,
+    ...options,
+    state: {
+      ...state,
+      ...options.state
+    },
+    // Similarly, we'll maintain both our internal state and any user-provided
+    // state.
+    onStateChange: (updater) => {
+      setState(updater);
+      options.onStateChange == null || options.onStateChange(updater);
+    }
+  }));
+  return tableRef.current;
+}
+exports.ColumnFaceting = index.ColumnFaceting;
+exports.ColumnFiltering = index.ColumnFiltering;
+exports.ColumnGrouping = index.ColumnGrouping;
+exports.ColumnOrdering = index.ColumnOrdering;
+exports.ColumnPinning = index.ColumnPinning;
+exports.ColumnSizing = index.ColumnSizing;
+exports.ColumnVisibility = index.ColumnVisibility;
+exports.GlobalFaceting = index.GlobalFaceting;
+exports.GlobalFiltering = index.GlobalFiltering;
+exports.Headers = index.Headers;
+exports.RowExpanding = index.RowExpanding;
+exports.RowPagination = index.RowPagination;
+exports.RowPinning = index.RowPinning;
+exports.RowSelection = index.RowSelection;
+exports.RowSorting = index.RowSorting;
+exports._getVisibleLeafColumns = index._getVisibleLeafColumns;
+exports.aggregationFns = index.aggregationFns;
+exports.buildHeaderGroups = index.buildHeaderGroups;
+exports.createCell = index.createCell;
+exports.createColumn = index.createColumn;
+exports.createRow = index.createRow;
+exports.createTable = index.createTable;
+exports.defaultColumnSizing = index.defaultColumnSizing;
+exports.expandRows = index.expandRows;
+exports.filterFns = index.filterFns;
+exports.flattenBy = index.flattenBy;
+exports.functionalUpdate = index.functionalUpdate;
+exports.getCoreRowModel = index.getCoreRowModel;
+exports.getExpandedRowModel = index.getExpandedRowModel;
+exports.getFacetedMinMaxValues = index.getFacetedMinMaxValues;
+exports.getFacetedRowModel = index.getFacetedRowModel;
+exports.getFacetedUniqueValues = index.getFacetedUniqueValues;
+exports.getFilteredRowModel = index.getFilteredRowModel;
+exports.getGroupedRowModel = index.getGroupedRowModel;
+exports.getMemoOptions = index.getMemoOptions;
+exports.getPaginationRowModel = index.getPaginationRowModel;
+exports.getSortedRowModel = index.getSortedRowModel;
+exports.isFunction = index.isFunction;
+exports.isNumberArray = index.isNumberArray;
+exports.isRowSelected = index.isRowSelected;
+exports.isSubRowSelected = index.isSubRowSelected;
+exports.makeStateUpdater = index.makeStateUpdater;
+exports.memo = index.memo;
+exports.orderColumns = index.orderColumns;
+exports.passiveEventSupported = index.passiveEventSupported;
+exports.reSplitAlphaNumeric = index.reSplitAlphaNumeric;
+exports.selectRowsFn = index.selectRowsFn;
+exports.shouldAutoRemoveFilter = index.shouldAutoRemoveFilter;
+exports.sortingFns = index.sortingFns;
+exports.useReactTable = useReactTable;