@tanstack/solid-query 5.0.0-alpha.61 → 5.0.0-alpha.63

package/dist/source/createBaseQuery.js

@@ -0,0 +1,173 @@
+import { hydrate, notifyManager } from '@tanstack/query-core';
+import { isServer } from 'solid-js/web';
+import { createComputed, createMemo, createResource, on, onCleanup, } from 'solid-js';
+import { createStore, reconcile, unwrap } from 'solid-js/store';
+import { useQueryClient } from './QueryClientProvider';
+import { shouldThrowError } from './utils';
+function reconcileFn(store, result, reconcileOption) {
+    if (reconcileOption === false)
+        return result;
+    if (typeof reconcileOption === 'function') {
+        const newData = reconcileOption(store.data, result.data);
+        return { ...result, data: newData };
+    }
+    const newData = reconcile(result.data, { key: reconcileOption })(store.data);
+    return { ...result, data: newData };
+}
+// Base Query Function that is used to create the query.
+export function createBaseQuery(options, Observer, queryClient) {
+    const client = createMemo(() => useQueryClient(queryClient?.()));
+    const defaultedOptions = client().defaultQueryOptions(options());
+    defaultedOptions._optimisticResults = 'optimistic';
+    defaultedOptions.structuralSharing = false;
+    if (isServer) {
+        defaultedOptions.retry = false;
+        defaultedOptions.throwOnError = true;
+    }
+    const observer = new Observer(client(), defaultedOptions);
+    const [state, setState] = createStore(observer.getOptimisticResult(defaultedOptions));
+    const createServerSubscriber = (resolve, reject) => {
+        return observer.subscribe((result) => {
+            notifyManager.batchCalls(() => {
+                const query = observer.getCurrentQuery();
+                const { refetch, ...rest } = 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) {
+                    if (process.env['NODE_ENV'] === 'development') {
+                        console.error(unwrappedResult.error);
+                    }
+                    reject(unwrappedResult.error);
+                }
+                if (unwrappedResult.isSuccess) {
+                    // Use of any here is fine
+                    // We cannot include refetch since it is not serializable
+                    resolve(unwrappedResult);
+                }
+            })();
+        });
+    };
+    const createClientSubscriber = () => {
+        return observer.subscribe((result) => {
+            notifyManager.batchCalls(() => {
+                // @ts-expect-error - This will error because the reconcile option does not
+                // exist on the query-core QueryObserverResult type
+                const reconcileOptions = observer.options.reconcile;
+                // If the query has data we dont suspend but instead mutate the resource
+                // This could happen when placeholderData/initialData is defined
+                if (queryResource()?.data && result.data && !queryResource.loading) {
+                    setState((store) => {
+                        return reconcileFn(store, result, reconcileOptions === undefined ? 'id' : reconcileOptions);
+                    });
+                    mutate(state);
+                }
+                else {
+                    setState((store) => {
+                        return reconcileFn(store, result, reconcileOptions === undefined ? 'id' : reconcileOptions);
+                    });
+                    refetch();
+                }
+            })();
+        });
+    };
+    /**
+     * Unsubscribe is set lazily, so that we can subscribe after hydration when needed.
+     */
+    let unsubscribe = null;
+    const [queryResource, { refetch, mutate }] = createResource(() => {
+        return new Promise((resolve, reject) => {
+            if (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) {
+                hydrate(client(), {
+                    queries: [
+                        {
+                            queryKey: defaultedOptions.queryKey,
+                            queryHash: defaultedOptions.queryHash,
+                            state: info.value,
+                        },
+                    ],
+                });
+            }
+            if (!unsubscribe) {
+                /**
+                 * Do not refetch query on mount if query was fetched on server,
+                 * even if `staleTime` is not set.
+                 */
+                const newOptions = { ...defaultedOptions };
+                if (defaultedOptions.staleTime || !defaultedOptions.initialData) {
+                    newOptions.refetchOnMount = false;
+                }
+                // Setting the options as an immutable object to prevent
+                // wonky behavior with observer subscriptions
+                observer.setOptions(newOptions);
+                setState(observer.getOptimisticResult(newOptions));
+                unsubscribe = createClientSubscriber();
+            }
+        },
+    });
+    onCleanup(() => {
+        if (unsubscribe) {
+            unsubscribe();
+            unsubscribe = null;
+        }
+    });
+    createComputed(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,
+    }));
+    createComputed(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 !== undefined ? val : Reflect.get(target, prop);
+        },
+    };
+    return new Proxy(state, handler);
+}

package/dist/source/createInfiniteQuery.js

@@ -0,0 +1,8 @@
+import { InfiniteQueryObserver } from '@tanstack/query-core';
+import { createBaseQuery } from './createBaseQuery';
+import { createMemo } from 'solid-js';
+export function createInfiniteQuery(options, queryClient) {
+    return createBaseQuery(createMemo(() => options()), 
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+    InfiniteQueryObserver, queryClient);
+}

package/dist/source/createMutation.js

@@ -0,0 +1,38 @@
+import { MutationObserver } from '@tanstack/query-core';
+import { useQueryClient } from './QueryClientProvider';
+import { createComputed, onCleanup, on } from 'solid-js';
+import { createStore } from 'solid-js/store';
+import { shouldThrowError } from './utils';
+// HOOK
+export function createMutation(options, queryClient) {
+    const client = useQueryClient(queryClient?.());
+    const observer = new MutationObserver(client, options());
+    const mutate = (variables, mutateOptions) => {
+        observer.mutate(variables, mutateOptions).catch(noop);
+    };
+    const [state, setState] = createStore({
+        ...observer.getCurrentResult(),
+        mutate,
+        mutateAsync: observer.getCurrentResult().mutate,
+    });
+    createComputed(() => {
+        observer.setOptions(options());
+    });
+    createComputed(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,
+        });
+    });
+    onCleanup(unsubscribe);
+    return state;
+}
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+function noop() { }

package/dist/source/createQueries.js

@@ -0,0 +1,38 @@
+import { notifyManager, QueriesObserver } from '@tanstack/query-core';
+import { createComputed, onCleanup } from 'solid-js';
+import { createStore, unwrap } from 'solid-js/store';
+import { useQueryClient } from './QueryClientProvider';
+export function createQueries(queriesOptions, queryClient) {
+    const client = useQueryClient(queryClient?.());
+    const defaultedQueries = queriesOptions().queries.map((options) => {
+        const defaultedOptions = client.defaultQueryOptions(options);
+        defaultedOptions._optimisticResults = 'optimistic';
+        return defaultedOptions;
+    });
+    const observer = new QueriesObserver(client, defaultedQueries, queriesOptions().combine
+        ? {
+            combine: queriesOptions().combine,
+        }
+        : undefined);
+    // @ts-expect-error - Types issue with solid-js createStore
+    const [state, setState] = createStore(observer.getOptimisticResult(defaultedQueries)[1]());
+    const unsubscribe = observer.subscribe((result) => {
+        notifyManager.batchCalls(() => {
+            setState(unwrap(result));
+        })();
+    });
+    onCleanup(unsubscribe);
+    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,
+            }
+            : undefined, { listeners: false });
+    });
+    return state;
+}

package/dist/source/createQuery.js

@@ -0,0 +1,9 @@
+import { QueryObserver } from '@tanstack/query-core';
+import { createMemo } from 'solid-js';
+import { createBaseQuery } from './createBaseQuery';
+export function queryOptions(options) {
+    return options;
+}
+export function createQuery(options, queryClient) {
+    return createBaseQuery(createMemo(() => options()), QueryObserver, queryClient);
+}

package/dist/source/index.js

@@ -0,0 +1,15 @@
+/* istanbul ignore file */
+// Side Effects
+import './setBatchUpdatesFn';
+// Re-export core
+export * from '@tanstack/query-core';
+// Solid Query
+export * from './types';
+export { QueryClient } from './QueryClient';
+export { createQuery, queryOptions } from './createQuery';
+export { QueryClientContext, QueryClientProvider, useQueryClient, } from './QueryClientProvider';
+export { useIsFetching } from './useIsFetching';
+export { createInfiniteQuery } from './createInfiniteQuery';
+export { createMutation } from './createMutation';
+export { useIsMutating } from './useIsMutating';
+export { createQueries } from './createQueries';

package/{build/lib → dist/source}/setBatchUpdatesFn.js

@@ -1,5 +1,3 @@
 import { notifyManager } from '@tanstack/query-core';
 import { batch } from 'solid-js';
-
 notifyManager.setBatchNotifyFunction(batch);
-//# sourceMappingURL=setBatchUpdatesFn.js.map

package/dist/source/types.js

@@ -0,0 +1,2 @@
+/* istanbul ignore file */
+export {};

package/dist/source/useIsFetching.js

@@ -0,0 +1,12 @@
+import { createMemo, createSignal, onCleanup } from 'solid-js';
+import { useQueryClient } from './QueryClientProvider';
+export function useIsFetching(filters, queryClient) {
+    const client = createMemo(() => useQueryClient(queryClient?.()));
+    const queryCache = createMemo(() => client().getQueryCache());
+    const [fetches, setFetches] = createSignal(client().isFetching(filters?.()));
+    const unsubscribe = queryCache().subscribe(() => {
+        setFetches(client().isFetching(filters?.()));
+    });
+    onCleanup(unsubscribe);
+    return fetches;
+}

package/dist/source/useIsMutating.js

@@ -0,0 +1,12 @@
+import { useQueryClient } from './QueryClientProvider';
+import { createSignal, onCleanup, createMemo } from 'solid-js';
+export function useIsMutating(filters, queryClient) {
+    const client = createMemo(() => useQueryClient(queryClient?.()));
+    const mutationCache = createMemo(() => client().getMutationCache());
+    const [mutations, setMutations] = createSignal(client().isMutating(filters?.()));
+    const unsubscribe = mutationCache().subscribe((_result) => {
+        setMutations(client().isMutating(filters?.()));
+    });
+    onCleanup(unsubscribe);
+    return mutations;
+}

package/dist/source/utils.js

@@ -0,0 +1,7 @@
+export function shouldThrowError(throwError, params) {
+    // Allow throwError function to override throwing behavior on a per-error basis
+    if (typeof throwError === 'function') {
+        return throwError(...params);
+    }
+    return !!throwError;
+}

package/{build/lib → dist/types}/QueryClient.d.ts

@@ -27,4 +27,3 @@ export interface QueryClientConfig extends QueryCoreClientConfig {
 export declare class QueryClient extends QueryCoreClient {
     constructor(config?: QueryClientConfig);
 }
-//# sourceMappingURL=QueryClient.d.ts.map

package/{build/lib → dist/types}/QueryClientProvider.d.ts

@@ -1,10 +1,9 @@
 import type { QueryClient } from './QueryClient';
 import type { JSX } from 'solid-js';
-export declare const QueryClientContext: import("solid-js").Context<QueryClient | undefined>;
+export declare const QueryClientContext: import("solid-js").Context<QueryClient>;
 export declare const useQueryClient: (queryClient?: QueryClient) => QueryClient;
 export type QueryClientProviderProps = {
     client: QueryClient;
     children?: JSX.Element;
 };
 export declare const QueryClientProvider: (props: QueryClientProviderProps) => JSX.Element;
-//# sourceMappingURL=QueryClientProvider.d.ts.map

package/{build/lib → dist/types}/createBaseQuery.d.ts

@@ -3,4 +3,3 @@ import type { QueryClient } from './QueryClient';
 import type { Accessor } from 'solid-js';
 import type { CreateBaseQueryOptions } from './types';
 export declare function createBaseQuery<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: Accessor<CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>>, Observer: typeof QueryObserver, queryClient?: Accessor<QueryClient>): QueryObserverResult<TData, TError>;
-//# sourceMappingURL=createBaseQuery.d.ts.map

package/{build/lib → dist/types}/createInfiniteQuery.d.ts

@@ -3,4 +3,3 @@ import type { QueryClient } from './QueryClient';
 import type { CreateInfiniteQueryOptions, CreateInfiniteQueryResult } from './types';
 import type { Accessor } from 'solid-js';
 export 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>;
-//# sourceMappingURL=createInfiniteQuery.d.ts.map

package/{build/lib → dist/types}/createMutation.d.ts

@@ -3,4 +3,3 @@ import type { QueryClient } from './QueryClient';
 import type { CreateMutationOptions, CreateMutationResult } from './types';
 import type { Accessor } from 'solid-js';
 export 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>;
-//# sourceMappingURL=createMutation.d.ts.map

package/{build/lib → dist/types}/createQueries.d.ts

@@ -51,4 +51,3 @@ export declare function createQueries<T extends any[], TCombinedResult = Queries
     combine?: (result: QueriesResults<T>) => TCombinedResult;
 }>, queryClient?: Accessor<QueryClient>): TCombinedResult;
 export {};
-//# sourceMappingURL=createQueries.d.ts.map

package/{build/lib → dist/types}/createQuery.d.ts

@@ -12,4 +12,3 @@ export declare function queryOptions<TQueryFnData = unknown, TError = unknown, T
 export declare function createQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: () => QueryClient): CreateQueryResult<TData, TError>;
 export declare function createQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: () => QueryClient): DefinedCreateQueryResult<TData, TError>;
 export {};
-//# sourceMappingURL=createQuery.d.ts.map

package/{build/lib → dist/types}/index.d.ts

@@ -11,4 +11,3 @@ export { createInfiniteQuery } from './createInfiniteQuery';
 export { createMutation } from './createMutation';
 export { useIsMutating } from './useIsMutating';
 export { createQueries } from './createQueries';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/setBatchUpdatesFn.d.ts

@@ -0,0 +1 @@
+export {};

package/{build/lib → dist/types}/types.d.ts

@@ -32,4 +32,3 @@ type Override<A, B> = {
     [K in keyof A]: K extends keyof B ? B[K] : A[K];
 };
 export {};
-//# sourceMappingURL=types.d.ts.map

package/{build/lib → dist/types}/useIsFetching.d.ts

@@ -2,4 +2,3 @@ import type { QueryFilters } from '@tanstack/query-core';
 import type { QueryClient } from './QueryClient';
 import type { Accessor } from 'solid-js';
 export declare function useIsFetching(filters?: Accessor<QueryFilters>, queryClient?: Accessor<QueryClient>): Accessor<number>;
-//# sourceMappingURL=useIsFetching.d.ts.map

package/{build/lib → dist/types}/useIsMutating.d.ts

@@ -2,4 +2,3 @@ import type { MutationFilters } from '@tanstack/query-core';
 import type { QueryClient } from './QueryClient';
 import type { Accessor } from 'solid-js';
 export declare function useIsMutating(filters?: Accessor<MutationFilters>, queryClient?: Accessor<QueryClient>): Accessor<number>;
-//# sourceMappingURL=useIsMutating.d.ts.map

package/{build/lib → dist/types}/utils.d.ts

@@ -1,2 +1 @@
 export declare function shouldThrowError<T extends (...args: any[]) => boolean>(throwError: boolean | T | undefined, params: Parameters<T>): boolean;
-//# sourceMappingURL=utils.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/solid-query",
-  "version": "5.0.0-alpha.61",
+  "version": "5.0.0-alpha.63",
   "description": "Primitives for managing, caching and syncing asynchronous and remote data in Solid",
   "author": "tannerlinsley",
   "license": "MIT",
@@ -11,16 +11,20 @@
     "url": "https://github.com/sponsors/tannerlinsley"
   },
   "type": "module",
-  "types": "build/lib/index.d.ts",
-  "main": "build/lib/index.cjs",
-  "module": "build/lib/index.js",
+  "types": "dist/types/index.d.ts",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/esm/index.js",
   "exports": {
     ".": {
-      "types": "./build/lib/index.d.ts",
-      "solid": "./build/lib/index.js",
-      "import": "./build/lib/index.js",
-      "require": "./build/lib/index.cjs",
-      "default": "./build/lib/index.cjs"
+      "types": "./dist/types/index.d.ts",
+      "solid": "./dist/source/index.jsx",
+      "import": "./dist/esm/index.js",
+      "browser": {
+        "import": "./dist/esm/index.js",
+        "require": "./dist/cjs/index.cjs"
+      },
+      "require": "./dist/cjs/index.cjs",
+      "node": "./dist/cjs/index.cjs"
     },
     "./package.json": "./package.json"
   },
@@ -28,7 +32,7 @@
     "./src/setBatchUpdatesFn.ts"
   ],
   "files": [
-    "build",
+    "dist",
     "src"
   ],
   "dependencies": {
@@ -41,14 +45,12 @@
     "solid-js": "^1.6.13"
   },
   "scripts": {
-    "clean": "rimraf ./build && rimraf ./coverage",
+    "clean": "rimraf ./dist && rimraf ./coverage",
     "test:eslint": "eslint --ext .ts,.tsx ./src",
     "test:types": "tsc --noEmit",
     "test:lib": "vitest run --coverage",
     "test:lib:dev": "pnpm run test:lib --watch",
     "test:build": "publint --strict",
-    "build": "pnpm build:rollup && pnpm build:types",
-    "build:rollup": "rollup --config rollup.config.js",
-    "build:types": "tsc --emitDeclarationOnly"
+    "build": "rollup --config rollup.config.js"
   }
 }

package/build/lib/QueryClient.cjs

@@ -1,12 +0,0 @@
-'use strict';
-
-var queryCore = require('@tanstack/query-core');
-
-class QueryClient extends queryCore.QueryClient {
-  constructor(config = {}) {
-    super(config);
-  }
-}
-
-exports.QueryClient = QueryClient;
-//# sourceMappingURL=QueryClient.cjs.map

package/build/lib/QueryClient.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueryClient.cjs","sources":["../../src/QueryClient.ts"],"sourcesContent":["import type {\n  QueryClientConfig as QueryCoreClientConfig,\n  DefaultOptions as CoreDefaultOptions,\n  QueryObserverOptions as QueryCoreObserverOptions,\n  InfiniteQueryObserverOptions as QueryCoreInfiniteQueryObserverOptions,\n  DefaultError,\n  QueryKey,\n} from '@tanstack/query-core'\nimport { QueryClient as QueryCoreClient } from '@tanstack/query-core'\n\nexport interface QueryObserverOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = never,\n> extends Omit<\n    QueryCoreObserverOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryData,\n      TQueryKey,\n      TPageParam\n    >,\n    'structuralSharing'\n  > {\n  /**\n   * Set this to a reconciliation key to enable reconciliation between query results.\n   * Set this to `false` to disable reconciliation between query results.\n   * 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.\n   * Defaults reconciliation key to `id`.\n   */\n  reconcile?:\n    | string\n    | false\n    | ((oldData: TData | undefined, newData: TData) => TData)\n}\n\nexport interface InfiniteQueryObserverOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n> extends Omit<\n    QueryCoreInfiniteQueryObserverOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryData,\n      TQueryKey,\n      TPageParam\n    >,\n    'structuralSharing'\n  > {\n  /**\n   * Set this to a reconciliation key to enable reconciliation between query results.\n   * Set this to `false` to disable reconciliation between query results.\n   * 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.\n   * Defaults reconciliation key to `id`.\n   */\n  reconcile?:\n    | string\n    | false\n    | ((oldData: TData | undefined, newData: TData) => TData)\n}\n\nexport interface DefaultOptions<TError = DefaultError>\n  extends CoreDefaultOptions<TError> {\n  queries?: QueryObserverOptions<unknown, TError>\n}\n\nexport interface QueryClientConfig extends QueryCoreClientConfig {\n  defaultOptions?: DefaultOptions\n}\n\nexport class QueryClient extends QueryCoreClient {\n  constructor(config: QueryClientConfig = {}) {\n    super(config)\n  }\n}\n"],"names":["QueryClient","QueryCoreClient","constructor","config"],"mappings":";;;;AA+EO,MAAMA,WAAW,SAASC,qBAAe,CAAC;AAC/CC,EAAAA,WAAWA,CAACC,MAAyB,GAAG,EAAE,EAAE;IAC1C,KAAK,CAACA,MAAM,CAAC,CAAA;AACf,GAAA;AACF;;;;"}

package/build/lib/QueryClient.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueryClient.d.ts","sourceRoot":"","sources":["../../src/QueryClient.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,IAAI,qBAAqB,EAC1C,cAAc,IAAI,kBAAkB,EACpC,oBAAoB,IAAI,wBAAwB,EAChD,4BAA4B,IAAI,qCAAqC,EACrE,YAAY,EACZ,QAAQ,EACT,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,WAAW,IAAI,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAErE,MAAM,WAAW,oBAAoB,CACnC,YAAY,GAAG,OAAO,EACtB,MAAM,GAAG,YAAY,EACrB,KAAK,GAAG,YAAY,EACpB,UAAU,GAAG,YAAY,EACzB,SAAS,SAAS,QAAQ,GAAG,QAAQ,EACrC,UAAU,GAAG,KAAK,CAClB,SAAQ,IAAI,CACV,wBAAwB,CACtB,YAAY,EACZ,MAAM,EACN,KAAK,EACL,UAAU,EACV,SAAS,EACT,UAAU,CACX,EACD,mBAAmB,CACpB;IACD;;;;;OAKG;IACH,SAAS,CAAC,EACN,MAAM,GACN,KAAK,GACL,CAAC,CAAC,OAAO,EAAE,KAAK,GAAG,SAAS,EAAE,OAAO,EAAE,KAAK,KAAK,KAAK,CAAC,CAAA;CAC5D;AAED,MAAM,WAAW,4BAA4B,CAC3C,YAAY,GAAG,OAAO,EACtB,MAAM,GAAG,YAAY,EACrB,KAAK,GAAG,YAAY,EACpB,UAAU,GAAG,YAAY,EACzB,SAAS,SAAS,QAAQ,GAAG,QAAQ,EACrC,UAAU,GAAG,OAAO,CACpB,SAAQ,IAAI,CACV,qCAAqC,CACnC,YAAY,EACZ,MAAM,EACN,KAAK,EACL,UAAU,EACV,SAAS,EACT,UAAU,CACX,EACD,mBAAmB,CACpB;IACD;;;;;OAKG;IACH,SAAS,CAAC,EACN,MAAM,GACN,KAAK,GACL,CAAC,CAAC,OAAO,EAAE,KAAK,GAAG,SAAS,EAAE,OAAO,EAAE,KAAK,KAAK,KAAK,CAAC,CAAA;CAC5D;AAED,MAAM,WAAW,cAAc,CAAC,MAAM,GAAG,YAAY,CACnD,SAAQ,kBAAkB,CAAC,MAAM,CAAC;IAClC,OAAO,CAAC,EAAE,oBAAoB,CAAC,OAAO,EAAE,MAAM,CAAC,CAAA;CAChD;AAED,MAAM,WAAW,iBAAkB,SAAQ,qBAAqB;IAC9D,cAAc,CAAC,EAAE,cAAc,CAAA;CAChC;AAED,qBAAa,WAAY,SAAQ,eAAe;gBAClC,MAAM,GAAE,iBAAsB;CAG3C"}

package/build/lib/QueryClient.js

@@ -1,10 +0,0 @@
-import { QueryClient as QueryClient$1 } from '@tanstack/query-core';
-
-class QueryClient extends QueryClient$1 {
-  constructor(config = {}) {
-    super(config);
-  }
-}
-
-export { QueryClient };
-//# sourceMappingURL=QueryClient.js.map

package/build/lib/QueryClient.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueryClient.js","sources":["../../src/QueryClient.ts"],"sourcesContent":["import type {\n  QueryClientConfig as QueryCoreClientConfig,\n  DefaultOptions as CoreDefaultOptions,\n  QueryObserverOptions as QueryCoreObserverOptions,\n  InfiniteQueryObserverOptions as QueryCoreInfiniteQueryObserverOptions,\n  DefaultError,\n  QueryKey,\n} from '@tanstack/query-core'\nimport { QueryClient as QueryCoreClient } from '@tanstack/query-core'\n\nexport interface QueryObserverOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = never,\n> extends Omit<\n    QueryCoreObserverOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryData,\n      TQueryKey,\n      TPageParam\n    >,\n    'structuralSharing'\n  > {\n  /**\n   * Set this to a reconciliation key to enable reconciliation between query results.\n   * Set this to `false` to disable reconciliation between query results.\n   * 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.\n   * Defaults reconciliation key to `id`.\n   */\n  reconcile?:\n    | string\n    | false\n    | ((oldData: TData | undefined, newData: TData) => TData)\n}\n\nexport interface InfiniteQueryObserverOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n> extends Omit<\n    QueryCoreInfiniteQueryObserverOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryData,\n      TQueryKey,\n      TPageParam\n    >,\n    'structuralSharing'\n  > {\n  /**\n   * Set this to a reconciliation key to enable reconciliation between query results.\n   * Set this to `false` to disable reconciliation between query results.\n   * 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.\n   * Defaults reconciliation key to `id`.\n   */\n  reconcile?:\n    | string\n    | false\n    | ((oldData: TData | undefined, newData: TData) => TData)\n}\n\nexport interface DefaultOptions<TError = DefaultError>\n  extends CoreDefaultOptions<TError> {\n  queries?: QueryObserverOptions<unknown, TError>\n}\n\nexport interface QueryClientConfig extends QueryCoreClientConfig {\n  defaultOptions?: DefaultOptions\n}\n\nexport class QueryClient extends QueryCoreClient {\n  constructor(config: QueryClientConfig = {}) {\n    super(config)\n  }\n}\n"],"names":["QueryClient","QueryCoreClient","constructor","config"],"mappings":";;AA+EO,MAAMA,WAAW,SAASC,aAAe,CAAC;AAC/CC,EAAAA,WAAWA,CAACC,MAAyB,GAAG,EAAE,EAAE;IAC1C,KAAK,CAACA,MAAM,CAAC,CAAA;AACf,GAAA;AACF;;;;"}

package/build/lib/QueryClientProvider.cjs

@@ -1,35 +0,0 @@
-'use strict';
-
-var web = require('solid-js/web');
-var solidJs = require('solid-js');
-
-const QueryClientContext = solidJs.createContext(undefined);
-const useQueryClient = queryClient => {
-  const client = solidJs.useContext(QueryClientContext);
-  if (queryClient) {
-    return queryClient;
-  }
-  if (!client) {
-    throw new Error('No QueryClient set, use QueryClientProvider to set one');
-  }
-  return client;
-};
-const QueryClientProvider = props => {
-  solidJs.onMount(() => {
-    props.client.mount();
-  });
-  solidJs.onCleanup(() => props.client.unmount());
-  return web.createComponent(QueryClientContext.Provider, {
-    get value() {
-      return props.client;
-    },
-    get children() {
-      return props.children;
-    }
-  });
-};
-
-exports.QueryClientContext = QueryClientContext;
-exports.QueryClientProvider = QueryClientProvider;
-exports.useQueryClient = useQueryClient;
-//# sourceMappingURL=QueryClientProvider.cjs.map

package/build/lib/QueryClientProvider.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueryClientProvider.cjs","sources":["../../src/QueryClientProvider.tsx"],"sourcesContent":["import type { QueryClient } from './QueryClient'\nimport type { JSX } from 'solid-js'\nimport { createContext, useContext, onMount, onCleanup } from 'solid-js'\n\nexport const QueryClientContext = createContext<QueryClient | undefined>(\n  undefined,\n)\n\nexport const useQueryClient = (queryClient?: QueryClient) => {\n  const client = useContext(QueryClientContext)\n\n  if (queryClient) {\n    return queryClient\n  }\n\n  if (!client) {\n    throw new Error('No QueryClient set, use QueryClientProvider to set one')\n  }\n\n  return client\n}\n\nexport type QueryClientProviderProps = {\n  client: QueryClient\n  children?: JSX.Element\n}\n\nexport const QueryClientProvider = (\n  props: QueryClientProviderProps,\n): JSX.Element => {\n  onMount(() => {\n    props.client.mount()\n  })\n  onCleanup(() => props.client.unmount())\n\n  return (\n    <QueryClientContext.Provider value={props.client}>\n      {props.children}\n    </QueryClientContext.Provider>\n  )\n}\n"],"names":["QueryClientContext","createContext","undefined","useQueryClient","queryClient","client","useContext","Error","QueryClientProvider","props","onMount","mount","onCleanup","unmount","_$createComponent","Provider","value","children"],"mappings":";;;;;MAIaA,kBAAkB,GAAGC,qBAAa,CAC7CC,SACF,EAAC;AAEYC,MAAAA,cAAc,GAAIC,WAAyB,IAAK;AAC3D,EAAA,MAAMC,MAAM,GAAGC,kBAAU,CAACN,kBAAkB,CAAC,CAAA;AAE7C,EAAA,IAAII,WAAW,EAAE;AACf,IAAA,OAAOA,WAAW,CAAA;AACpB,GAAA;EAEA,IAAI,CAACC,MAAM,EAAE;AACX,IAAA,MAAM,IAAIE,KAAK,CAAC,wDAAwD,CAAC,CAAA;AAC3E,GAAA;AAEA,EAAA,OAAOF,MAAM,CAAA;AACf,EAAC;AAOYG,MAAAA,mBAAmB,GAC9BC,KAA+B,IACf;AAChBC,EAAAA,eAAO,CAAC,MAAM;AACZD,IAAAA,KAAK,CAACJ,MAAM,CAACM,KAAK,EAAE,CAAA;AACtB,GAAC,CAAC,CAAA;EACFC,iBAAS,CAAC,MAAMH,KAAK,CAACJ,MAAM,CAACQ,OAAO,EAAE,CAAC,CAAA;AAEvC,EAAA,OAAAC,mBAAA,CACGd,kBAAkB,CAACe,QAAQ,EAAA;AAAA,IAAA,IAACC,KAAKA,GAAA;MAAA,OAAEP,KAAK,CAACJ,MAAM,CAAA;AAAA,KAAA;AAAA,IAAA,IAAAY,QAAA,GAAA;MAAA,OAC7CR,KAAK,CAACQ,QAAQ,CAAA;AAAA,KAAA;AAAA,GAAA,CAAA,CAAA;AAGrB;;;;;;"}

package/build/lib/QueryClientProvider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueryClientProvider.d.ts","sourceRoot":"","sources":["../../src/QueryClientProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAChD,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA;AAGnC,eAAO,MAAM,kBAAkB,qDAE9B,CAAA;AAED,eAAO,MAAM,cAAc,iBAAkB,WAAW,gBAYvD,CAAA;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,MAAM,EAAE,WAAW,CAAA;IACnB,QAAQ,CAAC,EAAE,GAAG,CAAC,OAAO,CAAA;CACvB,CAAA;AAED,eAAO,MAAM,mBAAmB,UACvB,wBAAwB,KAC9B,WAWF,CAAA"}

package/build/lib/QueryClientProvider.js

@@ -1,31 +0,0 @@
-import { createComponent } from 'solid-js/web';
-import { createContext, useContext, onMount, onCleanup } from 'solid-js';
-
-const QueryClientContext = createContext(undefined);
-const useQueryClient = queryClient => {
-  const client = useContext(QueryClientContext);
-  if (queryClient) {
-    return queryClient;
-  }
-  if (!client) {
-    throw new Error('No QueryClient set, use QueryClientProvider to set one');
-  }
-  return client;
-};
-const QueryClientProvider = props => {
-  onMount(() => {
-    props.client.mount();
-  });
-  onCleanup(() => props.client.unmount());
-  return createComponent(QueryClientContext.Provider, {
-    get value() {
-      return props.client;
-    },
-    get children() {
-      return props.children;
-    }
-  });
-};
-
-export { QueryClientContext, QueryClientProvider, useQueryClient };
-//# sourceMappingURL=QueryClientProvider.js.map

package/build/lib/QueryClientProvider.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueryClientProvider.js","sources":["../../src/QueryClientProvider.tsx"],"sourcesContent":["import type { QueryClient } from './QueryClient'\nimport type { JSX } from 'solid-js'\nimport { createContext, useContext, onMount, onCleanup } from 'solid-js'\n\nexport const QueryClientContext = createContext<QueryClient | undefined>(\n  undefined,\n)\n\nexport const useQueryClient = (queryClient?: QueryClient) => {\n  const client = useContext(QueryClientContext)\n\n  if (queryClient) {\n    return queryClient\n  }\n\n  if (!client) {\n    throw new Error('No QueryClient set, use QueryClientProvider to set one')\n  }\n\n  return client\n}\n\nexport type QueryClientProviderProps = {\n  client: QueryClient\n  children?: JSX.Element\n}\n\nexport const QueryClientProvider = (\n  props: QueryClientProviderProps,\n): JSX.Element => {\n  onMount(() => {\n    props.client.mount()\n  })\n  onCleanup(() => props.client.unmount())\n\n  return (\n    <QueryClientContext.Provider value={props.client}>\n      {props.children}\n    </QueryClientContext.Provider>\n  )\n}\n"],"names":["QueryClientContext","createContext","undefined","useQueryClient","queryClient","client","useContext","Error","QueryClientProvider","props","onMount","mount","onCleanup","unmount","_$createComponent","Provider","value","children"],"mappings":";;;MAIaA,kBAAkB,GAAGC,aAAa,CAC7CC,SACF,EAAC;AAEYC,MAAAA,cAAc,GAAIC,WAAyB,IAAK;AAC3D,EAAA,MAAMC,MAAM,GAAGC,UAAU,CAACN,kBAAkB,CAAC,CAAA;AAE7C,EAAA,IAAII,WAAW,EAAE;AACf,IAAA,OAAOA,WAAW,CAAA;AACpB,GAAA;EAEA,IAAI,CAACC,MAAM,EAAE;AACX,IAAA,MAAM,IAAIE,KAAK,CAAC,wDAAwD,CAAC,CAAA;AAC3E,GAAA;AAEA,EAAA,OAAOF,MAAM,CAAA;AACf,EAAC;AAOYG,MAAAA,mBAAmB,GAC9BC,KAA+B,IACf;AAChBC,EAAAA,OAAO,CAAC,MAAM;AACZD,IAAAA,KAAK,CAACJ,MAAM,CAACM,KAAK,EAAE,CAAA;AACtB,GAAC,CAAC,CAAA;EACFC,SAAS,CAAC,MAAMH,KAAK,CAACJ,MAAM,CAACQ,OAAO,EAAE,CAAC,CAAA;AAEvC,EAAA,OAAAC,eAAA,CACGd,kBAAkB,CAACe,QAAQ,EAAA;AAAA,IAAA,IAACC,KAAKA,GAAA;MAAA,OAAEP,KAAK,CAACJ,MAAM,CAAA;AAAA,KAAA;AAAA,IAAA,IAAAY,QAAA,GAAA;MAAA,OAC7CR,KAAK,CAACQ,QAAQ,CAAA;AAAA,KAAA;AAAA,GAAA,CAAA,CAAA;AAGrB;;;;"}

package/build/lib/__tests__/QueryClientProvider.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=QueryClientProvider.test.d.ts.map

package/build/lib/__tests__/QueryClientProvider.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueryClientProvider.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/QueryClientProvider.test.tsx"],"names":[],"mappings":""}

package/build/lib/__tests__/createInfiniteQuery.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=createInfiniteQuery.test.d.ts.map

package/build/lib/__tests__/createInfiniteQuery.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createInfiniteQuery.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/createInfiniteQuery.test.tsx"],"names":[],"mappings":""}