@tanstack/solid-query 5.0.0-alpha.86 → 5.0.0-alpha.88

package/build/index.cjs

@@ -0,0 +1,351 @@
+'use strict';
+
+var queryCore = require('@tanstack/query-core');
+var solidJs = require('solid-js');
+var web = require('solid-js/web');
+var store = require('solid-js/store');
+
+// src/setBatchUpdatesFn.ts
+queryCore.notifyManager.setBatchNotifyFunction(solidJs.batch);
+exports.QueryClient = class QueryClient extends queryCore.QueryClient {
+  constructor(config = {}) {
+    super(config);
+  }
+};
+exports.QueryClientContext = solidJs.createContext(void 0);
+exports.useQueryClient = (queryClient) => {
+  if (queryClient) {
+    return queryClient;
+  }
+  const client = solidJs.useContext(exports.QueryClientContext);
+  if (!client) {
+    throw new Error("No QueryClient set, use QueryClientProvider to set one");
+  }
+  return client;
+};
+exports.QueryClientProvider = (props) => {
+  solidJs.onMount(() => {
+    props.client.mount();
+  });
+  solidJs.onCleanup(() => props.client.unmount());
+  return web.createComponent(exports.QueryClientContext.Provider, {
+    get value() {
+      return props.client;
+    },
+    get children() {
+      return props.children;
+    }
+  });
+};
+
+// src/utils.ts
+function shouldThrowError(throwError, params) {
+  if (typeof throwError === "function") {
+    return throwError(...params);
+  }
+  return !!throwError;
+}
+
+// src/createBaseQuery.ts
+function reconcileFn(store$1, result, reconcileOption) {
+  if (reconcileOption === false)
+    return result;
+  if (typeof reconcileOption === "function") {
+    const newData2 = reconcileOption(store$1.data, result.data);
+    return { ...result, data: newData2 };
+  }
+  const newData = store.reconcile(result.data, { key: reconcileOption })(store$1.data);
+  return { ...result, data: newData };
+}
+function createBaseQuery(options, Observer, queryClient) {
+  const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
+  const defaultedOptions = client().defaultQueryOptions(options());
+  defaultedOptions._optimisticResults = "optimistic";
+  defaultedOptions.structuralSharing = false;
+  if (web.isServer) {
+    defaultedOptions.retry = false;
+    defaultedOptions.throwOnError = true;
+  }
+  const observer = new Observer(client(), defaultedOptions);
+  const [state, setState] = store.createStore(
+    observer.getOptimisticResult(defaultedOptions)
+  );
+  const createServerSubscriber = (resolve, reject) => {
+    return observer.subscribe((result) => {
+      queryCore.notifyManager.batchCalls(() => {
+        const query = observer.getCurrentQuery();
+        const { refetch: refetch2, ...rest } = store.unwrap(result);
+        const unwrappedResult = {
+          ...rest,
+          // hydrate() expects a QueryState object, which is similar but not
+          // quite the same as a QueryObserverResult object. Thus, for now, we're
+          // copying over the missing properties from state in order to support hydration
+          dataUpdateCount: query.state.dataUpdateCount,
+          fetchFailureCount: query.state.fetchFailureCount,
+          // Removing these properties since they might not be serializable
+          // fetchFailureReason: query.state.fetchFailureReason,
+          // fetchMeta: query.state.fetchMeta,
+          isInvalidated: query.state.isInvalidated
+        };
+        if (unwrappedResult.isError) {
+          reject(unwrappedResult.error);
+        }
+        if (unwrappedResult.isSuccess) {
+          resolve(unwrappedResult);
+        }
+      })();
+    });
+  };
+  const createClientSubscriber = () => {
+    return observer.subscribe((result) => {
+      queryCore.notifyManager.batchCalls(() => {
+        const reconcileOptions = observer.options.reconcile;
+        if (queryResource()?.data && result.data && !queryResource.loading) {
+          setState((store) => {
+            return reconcileFn(
+              store,
+              result,
+              reconcileOptions === void 0 ? "id" : reconcileOptions
+            );
+          });
+          mutate(state);
+        } else {
+          setState((store) => {
+            return reconcileFn(
+              store,
+              result,
+              reconcileOptions === void 0 ? "id" : reconcileOptions
+            );
+          });
+          refetch();
+        }
+      })();
+    });
+  };
+  let unsubscribe = null;
+  const [queryResource, { refetch, mutate }] = solidJs.createResource(
+    () => {
+      return new Promise((resolve, reject) => {
+        if (web.isServer) {
+          unsubscribe = createServerSubscriber(resolve, reject);
+        } else {
+          if (!unsubscribe) {
+            unsubscribe = createClientSubscriber();
+          }
+        }
+        if (!state.isLoading) {
+          resolve(state);
+        }
+      });
+    },
+    {
+      initialValue: state,
+      // If initialData is provided, we resolve the resource immediately
+      ssrLoadFrom: options().initialData ? "initial" : "server",
+      get deferStream() {
+        return options().deferStream;
+      },
+      /**
+       * If this resource was populated on the server (either sync render, or streamed in over time), onHydrated
+       * will be called. This is the point at which we can hydrate the query cache state, and setup the query subscriber.
+       *
+       * Leveraging onHydrated allows us to plug into the async and streaming support that solidjs resources already support.
+       *
+       * Note that this is only invoked on the client, for queries that were originally run on the server.
+       */
+      onHydrated(_k, info) {
+        if (info.value) {
+          queryCore.hydrate(client(), {
+            queries: [
+              {
+                queryKey: defaultedOptions.queryKey,
+                queryHash: defaultedOptions.queryHash,
+                state: info.value
+              }
+            ]
+          });
+        }
+        if (!unsubscribe) {
+          const newOptions = { ...defaultedOptions };
+          if (defaultedOptions.staleTime || !defaultedOptions.initialData) {
+            newOptions.refetchOnMount = false;
+          }
+          observer.setOptions(newOptions);
+          setState(observer.getOptimisticResult(newOptions));
+          unsubscribe = createClientSubscriber();
+        }
+      }
+    }
+  );
+  solidJs.onCleanup(() => {
+    if (unsubscribe) {
+      unsubscribe();
+      unsubscribe = null;
+    }
+  });
+  solidJs.createComputed(
+    solidJs.on(
+      () => client().defaultQueryOptions(options()),
+      () => observer.setOptions(client().defaultQueryOptions(options())),
+      {
+        // Defer because we don't need to trigger on first render
+        // This only cares about changes to options after the observer is created
+        defer: true
+      }
+    )
+  );
+  solidJs.createComputed(
+    solidJs.on(
+      () => state.status,
+      () => {
+        if (state.isError && !state.isFetching && shouldThrowError(observer.options.throwOnError, [
+          state.error,
+          observer.getCurrentQuery()
+        ])) {
+          throw state.error;
+        }
+      }
+    )
+  );
+  const handler = {
+    get(target, prop) {
+      const val = queryResource()?.[prop];
+      return val !== void 0 ? val : Reflect.get(target, prop);
+    }
+  };
+  return new Proxy(state, handler);
+}
+
+// src/createQuery.ts
+function queryOptions(options) {
+  return options;
+}
+function createQuery(options, queryClient) {
+  return createBaseQuery(
+    solidJs.createMemo(() => options()),
+    queryCore.QueryObserver,
+    queryClient
+  );
+}
+function useIsFetching(filters, queryClient) {
+  const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
+  const queryCache = solidJs.createMemo(() => client().getQueryCache());
+  const [fetches, setFetches] = solidJs.createSignal(client().isFetching(filters?.()));
+  const unsubscribe = queryCache().subscribe(() => {
+    setFetches(client().isFetching(filters?.()));
+  });
+  solidJs.onCleanup(unsubscribe);
+  return fetches;
+}
+function createInfiniteQuery(options, queryClient) {
+  return createBaseQuery(
+    solidJs.createMemo(() => options()),
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+    queryCore.InfiniteQueryObserver,
+    queryClient
+  );
+}
+function createMutation(options, queryClient) {
+  const client = exports.useQueryClient(queryClient?.());
+  const observer = new queryCore.MutationObserver(
+    client,
+    options()
+  );
+  const mutate = (variables, mutateOptions) => {
+    observer.mutate(variables, mutateOptions).catch(noop);
+  };
+  const [state, setState] = store.createStore({
+    ...observer.getCurrentResult(),
+    mutate,
+    mutateAsync: observer.getCurrentResult().mutate
+  });
+  solidJs.createComputed(() => {
+    observer.setOptions(options());
+  });
+  solidJs.createComputed(
+    solidJs.on(
+      () => state.status,
+      () => {
+        if (state.isError && shouldThrowError(observer.options.throwOnError, [state.error])) {
+          throw state.error;
+        }
+      }
+    )
+  );
+  const unsubscribe = observer.subscribe((result) => {
+    setState({
+      ...result,
+      mutate,
+      mutateAsync: result.mutate
+    });
+  });
+  solidJs.onCleanup(unsubscribe);
+  return state;
+}
+function noop() {
+}
+function useIsMutating(filters, queryClient) {
+  const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
+  const mutationCache = solidJs.createMemo(() => client().getMutationCache());
+  const [mutations, setMutations] = solidJs.createSignal(
+    client().isMutating(filters?.())
+  );
+  const unsubscribe = mutationCache().subscribe((_result) => {
+    setMutations(client().isMutating(filters?.()));
+  });
+  solidJs.onCleanup(unsubscribe);
+  return mutations;
+}
+function createQueries(queriesOptions, queryClient) {
+  const client = exports.useQueryClient(queryClient?.());
+  const defaultedQueries = queriesOptions().queries.map((options) => {
+    const defaultedOptions = client.defaultQueryOptions(options);
+    defaultedOptions._optimisticResults = "optimistic";
+    return defaultedOptions;
+  });
+  const observer = new queryCore.QueriesObserver(
+    client,
+    defaultedQueries,
+    queriesOptions().combine ? {
+      combine: queriesOptions().combine
+    } : void 0
+  );
+  const [state, setState] = store.createStore(
+    observer.getOptimisticResult(defaultedQueries)[1]()
+  );
+  const unsubscribe = observer.subscribe((result) => {
+    queryCore.notifyManager.batchCalls(() => {
+      setState(store.unwrap(result));
+    })();
+  });
+  solidJs.onCleanup(unsubscribe);
+  solidJs.createComputed(() => {
+    const updatedQueries = queriesOptions().queries.map((options) => {
+      const defaultedOptions = client.defaultQueryOptions(options);
+      defaultedOptions._optimisticResults = "optimistic";
+      return defaultedOptions;
+    });
+    observer.setQueries(
+      updatedQueries,
+      queriesOptions().combine ? {
+        combine: queriesOptions().combine
+      } : void 0,
+      { listeners: false }
+    );
+  });
+  return state;
+}
+
+exports.createInfiniteQuery = createInfiniteQuery;
+exports.createMutation = createMutation;
+exports.createQueries = createQueries;
+exports.createQuery = createQuery;
+exports.queryOptions = queryOptions;
+exports.useIsFetching = useIsFetching;
+exports.useIsMutating = useIsMutating;
+Object.keys(queryCore).forEach(function (k) {
+  if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return queryCore[k]; }
+  });
+});

package/build/index.d.cts

@@ -0,0 +1,142 @@
+import { DefaultError, QueryKey, QueryObserverOptions as QueryObserverOptions$1, InfiniteQueryObserverOptions as InfiniteQueryObserverOptions$1, DefaultOptions as DefaultOptions$1, QueryClientConfig as QueryClientConfig$1, QueryClient as QueryClient$1, WithRequired, QueryObserverResult, DefinedQueryObserverResult, InfiniteQueryObserverResult, MutationObserverOptions, MutateFunction, MutationObserverResult, QueryFilters, InfiniteData, MutationFilters, QueriesPlaceholderDataFunction, QueryFunction } from '@tanstack/query-core';
+export * from '@tanstack/query-core';
+import * as solid_js from 'solid-js';
+import { JSX, Accessor } from 'solid-js';
+
+interface QueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends Omit<QueryObserverOptions$1<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, 'structuralSharing'> {
+    /**
+     * Set this to a reconciliation key to enable reconciliation between query results.
+     * Set this to `false` to disable reconciliation between query results.
+     * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom reconciliation logic.
+     * Defaults reconciliation key to `id`.
+     */
+    reconcile?: string | false | ((oldData: TData | undefined, newData: TData) => TData);
+}
+interface InfiniteQueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends Omit<InfiniteQueryObserverOptions$1<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, 'structuralSharing'> {
+    /**
+     * Set this to a reconciliation key to enable reconciliation between query results.
+     * Set this to `false` to disable reconciliation between query results.
+     * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom reconciliation logic.
+     * Defaults reconciliation key to `id`.
+     */
+    reconcile?: string | false | ((oldData: TData | undefined, newData: TData) => TData);
+}
+interface DefaultOptions<TError = DefaultError> extends DefaultOptions$1<TError> {
+    queries?: QueryObserverOptions<unknown, TError>;
+}
+interface QueryClientConfig extends QueryClientConfig$1 {
+    defaultOptions?: DefaultOptions;
+}
+declare class QueryClient extends QueryClient$1 {
+    constructor(config?: QueryClientConfig);
+}
+
+type FunctionedParams<T> = () => T;
+interface CreateBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends WithRequired<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, 'queryKey'> {
+    deferStream?: boolean;
+}
+interface SolidQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends WithRequired<CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'queryKey'> {
+}
+type CreateQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = FunctionedParams<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>>;
+type CreateBaseQueryResult<TData = unknown, TError = DefaultError> = QueryObserverResult<TData, TError>;
+type CreateQueryResult<TData = unknown, TError = DefaultError> = CreateBaseQueryResult<TData, TError>;
+type DefinedCreateBaseQueryResult<TData = unknown, TError = DefaultError> = DefinedQueryObserverResult<TData, TError>;
+type DefinedCreateQueryResult<TData = unknown, TError = DefaultError> = DefinedCreateBaseQueryResult<TData, TError>;
+interface SolidInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends Omit<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, 'queryKey'> {
+    queryKey: TQueryKey;
+    deferStream?: boolean;
+}
+type CreateInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = FunctionedParams<SolidInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey, TPageParam>>;
+type CreateInfiniteQueryResult<TData = unknown, TError = DefaultError> = InfiniteQueryObserverResult<TData, TError>;
+interface SolidMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> extends Omit<MutationObserverOptions<TData, TError, TVariables, TContext>, '_defaulted' | 'variables'> {
+}
+type CreateMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = FunctionedParams<SolidMutationOptions<TData, TError, TVariables, TContext>>;
+type CreateMutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TContext>>) => void;
+type CreateMutateAsyncFunction<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = MutateFunction<TData, TError, TVariables, TContext>;
+type CreateBaseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TContext = unknown> = Override<MutationObserverResult<TData, TError, TVariables, TContext>, {
+    mutate: CreateMutateFunction<TData, TError, TVariables, TContext>;
+}> & {
+    mutateAsync: CreateMutateAsyncFunction<TData, TError, TVariables, TContext>;
+};
+type CreateMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TContext = unknown> = CreateBaseMutationResult<TData, TError, TVariables, TContext>;
+type Override<A, B> = {
+    [K in keyof A]: K extends keyof B ? B[K] : A[K];
+};
+
+type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = FunctionedParams<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
+    initialData?: undefined;
+}>;
+type DefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = FunctionedParams<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
+    initialData: TQueryFnData | (() => TQueryFnData);
+}>;
+declare function queryOptions<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>;
+declare function queryOptions<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>;
+declare function createQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: () => QueryClient): CreateQueryResult<TData, TError>;
+declare function createQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: () => QueryClient): DefinedCreateQueryResult<TData, TError>;
+
+declare const QueryClientContext: solid_js.Context<QueryClient | undefined>;
+declare const useQueryClient: (queryClient?: QueryClient) => QueryClient;
+type QueryClientProviderProps = {
+    client: QueryClient;
+    children?: JSX.Element;
+};
+declare const QueryClientProvider: (props: QueryClientProviderProps) => JSX.Element;
+
+declare function useIsFetching(filters?: Accessor<QueryFilters>, queryClient?: Accessor<QueryClient>): Accessor<number>;
+
+declare function createInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: Accessor<QueryClient>): CreateInfiniteQueryResult<TData, TError>;
+
+declare function createMutation<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown>(options: CreateMutationOptions<TData, TError, TVariables, TContext>, queryClient?: Accessor<QueryClient>): CreateMutationResult<TData, TError, TVariables, TContext>;
+
+declare function useIsMutating(filters?: Accessor<MutationFilters>, queryClient?: Accessor<QueryClient>): Accessor<number>;
+
+type CreateQueryOptionsForCreateQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Omit<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'placeholderData'> & {
+    placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>;
+};
+type MAXIMUM_DEPTH = 20;
+type GetOptions<T> = T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+    data: infer TData;
+} ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError, TData> : T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+} ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError> : T extends {
+    data: infer TData;
+    error?: infer TError;
+} ? CreateQueryOptionsForCreateQueries<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError> : T extends [infer TQueryFnData] ? CreateQueryOptionsForCreateQueries<TQueryFnData> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>;
+    select: (data: any) => infer TData;
+} ? CreateQueryOptionsForCreateQueries<TQueryFnData, Error, TData, TQueryKey> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>;
+} ? CreateQueryOptionsForCreateQueries<TQueryFnData, Error, TQueryFnData, TQueryKey> : CreateQueryOptionsForCreateQueries;
+type GetResults<T> = T extends {
+    queryFnData: any;
+    error?: infer TError;
+    data: infer TData;
+} ? CreateQueryResult<TData, TError> : T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+} ? CreateQueryResult<TQueryFnData, TError> : T extends {
+    data: infer TData;
+    error?: infer TError;
+} ? CreateQueryResult<TData, TError> : T extends [any, infer TError, infer TData] ? CreateQueryResult<TData, TError> : T extends [infer TQueryFnData, infer TError] ? CreateQueryResult<TQueryFnData, TError> : T extends [infer TQueryFnData] ? CreateQueryResult<TQueryFnData> : T extends {
+    queryFn?: QueryFunction<unknown, any>;
+    select: (data: any) => infer TData;
+} ? CreateQueryResult<TData> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, any>;
+} ? CreateQueryResult<TQueryFnData> : CreateQueryResult;
+/**
+ * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
+ */
+type QueriesOptions<T extends any[], Result extends any[] = [], Depth extends ReadonlyArray<number> = []> = Depth['length'] extends MAXIMUM_DEPTH ? CreateQueryOptionsForCreateQueries[] : T extends [] ? [] : T extends [infer Head] ? [...Result, GetOptions<Head>] : T extends [infer Head, ...infer Tail] ? QueriesOptions<[...Tail], [...Result, GetOptions<Head>], [...Depth, 1]> : unknown[] extends T ? T : T extends CreateQueryOptionsForCreateQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>[] ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError, TData, TQueryKey>[] : CreateQueryOptionsForCreateQueries[];
+/**
+ * QueriesResults reducer recursively maps type param to results
+ */
+type QueriesResults<T extends any[], Result extends any[] = [], Depth extends ReadonlyArray<number> = []> = Depth['length'] extends MAXIMUM_DEPTH ? CreateQueryResult[] : T extends [] ? [] : T extends [infer Head] ? [...Result, GetResults<Head>] : T extends [infer Head, ...infer Tail] ? QueriesResults<[...Tail], [...Result, GetResults<Head>], [...Depth, 1]> : T extends CreateQueryOptionsForCreateQueries<infer TQueryFnData, infer TError, infer TData, any>[] ? CreateQueryResult<unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError>[] : CreateQueryResult[];
+declare function createQueries<T extends any[], TCombinedResult = QueriesResults<T>>(queriesOptions: Accessor<{
+    queries: readonly [...QueriesOptions<T>];
+    combine?: (result: QueriesResults<T>) => TCombinedResult;
+}>, queryClient?: Accessor<QueryClient>): TCombinedResult;
+
+export { CreateBaseMutationResult, CreateBaseQueryOptions, CreateBaseQueryResult, CreateInfiniteQueryOptions, CreateInfiniteQueryResult, CreateMutateAsyncFunction, CreateMutateFunction, CreateMutationOptions, CreateMutationResult, CreateQueryOptions, CreateQueryResult, DefaultOptions, DefinedCreateBaseQueryResult, DefinedCreateQueryResult, FunctionedParams, InfiniteQueryObserverOptions, QueryClient, QueryClientConfig, QueryClientContext, QueryClientProvider, QueryClientProviderProps, QueryObserverOptions, SolidInfiniteQueryOptions, SolidMutationOptions, SolidQueryOptions, createInfiniteQuery, createMutation, createQueries, createQuery, queryOptions, useIsFetching, useIsMutating, useQueryClient };

package/build/index.d.ts

@@ -0,0 +1,142 @@
+import { DefaultError, QueryKey, QueryObserverOptions as QueryObserverOptions$1, InfiniteQueryObserverOptions as InfiniteQueryObserverOptions$1, DefaultOptions as DefaultOptions$1, QueryClientConfig as QueryClientConfig$1, QueryClient as QueryClient$1, WithRequired, QueryObserverResult, DefinedQueryObserverResult, InfiniteQueryObserverResult, MutationObserverOptions, MutateFunction, MutationObserverResult, QueryFilters, InfiniteData, MutationFilters, QueriesPlaceholderDataFunction, QueryFunction } from '@tanstack/query-core';
+export * from '@tanstack/query-core';
+import * as solid_js from 'solid-js';
+import { JSX, Accessor } from 'solid-js';
+
+interface QueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends Omit<QueryObserverOptions$1<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, 'structuralSharing'> {
+    /**
+     * Set this to a reconciliation key to enable reconciliation between query results.
+     * Set this to `false` to disable reconciliation between query results.
+     * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom reconciliation logic.
+     * Defaults reconciliation key to `id`.
+     */
+    reconcile?: string | false | ((oldData: TData | undefined, newData: TData) => TData);
+}
+interface InfiniteQueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends Omit<InfiniteQueryObserverOptions$1<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, 'structuralSharing'> {
+    /**
+     * Set this to a reconciliation key to enable reconciliation between query results.
+     * Set this to `false` to disable reconciliation between query results.
+     * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom reconciliation logic.
+     * Defaults reconciliation key to `id`.
+     */
+    reconcile?: string | false | ((oldData: TData | undefined, newData: TData) => TData);
+}
+interface DefaultOptions<TError = DefaultError> extends DefaultOptions$1<TError> {
+    queries?: QueryObserverOptions<unknown, TError>;
+}
+interface QueryClientConfig extends QueryClientConfig$1 {
+    defaultOptions?: DefaultOptions;
+}
+declare class QueryClient extends QueryClient$1 {
+    constructor(config?: QueryClientConfig);
+}
+
+type FunctionedParams<T> = () => T;
+interface CreateBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends WithRequired<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, 'queryKey'> {
+    deferStream?: boolean;
+}
+interface SolidQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends WithRequired<CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'queryKey'> {
+}
+type CreateQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = FunctionedParams<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>>;
+type CreateBaseQueryResult<TData = unknown, TError = DefaultError> = QueryObserverResult<TData, TError>;
+type CreateQueryResult<TData = unknown, TError = DefaultError> = CreateBaseQueryResult<TData, TError>;
+type DefinedCreateBaseQueryResult<TData = unknown, TError = DefaultError> = DefinedQueryObserverResult<TData, TError>;
+type DefinedCreateQueryResult<TData = unknown, TError = DefaultError> = DefinedCreateBaseQueryResult<TData, TError>;
+interface SolidInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends Omit<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, 'queryKey'> {
+    queryKey: TQueryKey;
+    deferStream?: boolean;
+}
+type CreateInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = FunctionedParams<SolidInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey, TPageParam>>;
+type CreateInfiniteQueryResult<TData = unknown, TError = DefaultError> = InfiniteQueryObserverResult<TData, TError>;
+interface SolidMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> extends Omit<MutationObserverOptions<TData, TError, TVariables, TContext>, '_defaulted' | 'variables'> {
+}
+type CreateMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = FunctionedParams<SolidMutationOptions<TData, TError, TVariables, TContext>>;
+type CreateMutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TContext>>) => void;
+type CreateMutateAsyncFunction<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = MutateFunction<TData, TError, TVariables, TContext>;
+type CreateBaseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TContext = unknown> = Override<MutationObserverResult<TData, TError, TVariables, TContext>, {
+    mutate: CreateMutateFunction<TData, TError, TVariables, TContext>;
+}> & {
+    mutateAsync: CreateMutateAsyncFunction<TData, TError, TVariables, TContext>;
+};
+type CreateMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TContext = unknown> = CreateBaseMutationResult<TData, TError, TVariables, TContext>;
+type Override<A, B> = {
+    [K in keyof A]: K extends keyof B ? B[K] : A[K];
+};
+
+type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = FunctionedParams<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
+    initialData?: undefined;
+}>;
+type DefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = FunctionedParams<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
+    initialData: TQueryFnData | (() => TQueryFnData);
+}>;
+declare function queryOptions<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>;
+declare function queryOptions<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>;
+declare function createQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: () => QueryClient): CreateQueryResult<TData, TError>;
+declare function createQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: () => QueryClient): DefinedCreateQueryResult<TData, TError>;
+
+declare const QueryClientContext: solid_js.Context<QueryClient | undefined>;
+declare const useQueryClient: (queryClient?: QueryClient) => QueryClient;
+type QueryClientProviderProps = {
+    client: QueryClient;
+    children?: JSX.Element;
+};
+declare const QueryClientProvider: (props: QueryClientProviderProps) => JSX.Element;
+
+declare function useIsFetching(filters?: Accessor<QueryFilters>, queryClient?: Accessor<QueryClient>): Accessor<number>;
+
+declare function createInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: Accessor<QueryClient>): CreateInfiniteQueryResult<TData, TError>;
+
+declare function createMutation<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown>(options: CreateMutationOptions<TData, TError, TVariables, TContext>, queryClient?: Accessor<QueryClient>): CreateMutationResult<TData, TError, TVariables, TContext>;
+
+declare function useIsMutating(filters?: Accessor<MutationFilters>, queryClient?: Accessor<QueryClient>): Accessor<number>;
+
+type CreateQueryOptionsForCreateQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Omit<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'placeholderData'> & {
+    placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>;
+};
+type MAXIMUM_DEPTH = 20;
+type GetOptions<T> = T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+    data: infer TData;
+} ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError, TData> : T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+} ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError> : T extends {
+    data: infer TData;
+    error?: infer TError;
+} ? CreateQueryOptionsForCreateQueries<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError> : T extends [infer TQueryFnData] ? CreateQueryOptionsForCreateQueries<TQueryFnData> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>;
+    select: (data: any) => infer TData;
+} ? CreateQueryOptionsForCreateQueries<TQueryFnData, Error, TData, TQueryKey> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>;
+} ? CreateQueryOptionsForCreateQueries<TQueryFnData, Error, TQueryFnData, TQueryKey> : CreateQueryOptionsForCreateQueries;
+type GetResults<T> = T extends {
+    queryFnData: any;
+    error?: infer TError;
+    data: infer TData;
+} ? CreateQueryResult<TData, TError> : T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+} ? CreateQueryResult<TQueryFnData, TError> : T extends {
+    data: infer TData;
+    error?: infer TError;
+} ? CreateQueryResult<TData, TError> : T extends [any, infer TError, infer TData] ? CreateQueryResult<TData, TError> : T extends [infer TQueryFnData, infer TError] ? CreateQueryResult<TQueryFnData, TError> : T extends [infer TQueryFnData] ? CreateQueryResult<TQueryFnData> : T extends {
+    queryFn?: QueryFunction<unknown, any>;
+    select: (data: any) => infer TData;
+} ? CreateQueryResult<TData> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, any>;
+} ? CreateQueryResult<TQueryFnData> : CreateQueryResult;
+/**
+ * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
+ */
+type QueriesOptions<T extends any[], Result extends any[] = [], Depth extends ReadonlyArray<number> = []> = Depth['length'] extends MAXIMUM_DEPTH ? CreateQueryOptionsForCreateQueries[] : T extends [] ? [] : T extends [infer Head] ? [...Result, GetOptions<Head>] : T extends [infer Head, ...infer Tail] ? QueriesOptions<[...Tail], [...Result, GetOptions<Head>], [...Depth, 1]> : unknown[] extends T ? T : T extends CreateQueryOptionsForCreateQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>[] ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError, TData, TQueryKey>[] : CreateQueryOptionsForCreateQueries[];
+/**
+ * QueriesResults reducer recursively maps type param to results
+ */
+type QueriesResults<T extends any[], Result extends any[] = [], Depth extends ReadonlyArray<number> = []> = Depth['length'] extends MAXIMUM_DEPTH ? CreateQueryResult[] : T extends [] ? [] : T extends [infer Head] ? [...Result, GetResults<Head>] : T extends [infer Head, ...infer Tail] ? QueriesResults<[...Tail], [...Result, GetResults<Head>], [...Depth, 1]> : T extends CreateQueryOptionsForCreateQueries<infer TQueryFnData, infer TError, infer TData, any>[] ? CreateQueryResult<unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError>[] : CreateQueryResult[];
+declare function createQueries<T extends any[], TCombinedResult = QueriesResults<T>>(queriesOptions: Accessor<{
+    queries: readonly [...QueriesOptions<T>];
+    combine?: (result: QueriesResults<T>) => TCombinedResult;
+}>, queryClient?: Accessor<QueryClient>): TCombinedResult;
+
+export { CreateBaseMutationResult, CreateBaseQueryOptions, CreateBaseQueryResult, CreateInfiniteQueryOptions, CreateInfiniteQueryResult, CreateMutateAsyncFunction, CreateMutateFunction, CreateMutationOptions, CreateMutationResult, CreateQueryOptions, CreateQueryResult, DefaultOptions, DefinedCreateBaseQueryResult, DefinedCreateQueryResult, FunctionedParams, InfiniteQueryObserverOptions, QueryClient, QueryClientConfig, QueryClientContext, QueryClientProvider, QueryClientProviderProps, QueryObserverOptions, SolidInfiniteQueryOptions, SolidMutationOptions, SolidQueryOptions, createInfiniteQuery, createMutation, createQueries, createQuery, queryOptions, useIsFetching, useIsMutating, useQueryClient };