@tanstack/solid-query 4.4.0

package/build/lib/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sources":["../../src/utils.ts"],"sourcesContent":["import type {\n  SolidQueryKey,\n  SolidQueryFilters,\n  ParseFilterArgs,\n  ParseQueryArgs,\n} from './types'\nimport type { QueryFunction, QueryOptions } from '@tanstack/query-core'\n\nexport function isQueryKey(value: unknown): value is SolidQueryKey {\n  return typeof value === 'function'\n}\n\n// The parseQuery Args functions helps normalize the arguments into the correct form.\n// Whatever the parameters are, they are normalized into the correct form.\nexport function parseQueryArgs<\n  TOptions extends Omit<\n    QueryOptions<any, any, any, ReturnType<TQueryKey>>,\n    'queryKey'\n  > & {\n    queryKey?: TQueryKey\n  },\n  TQueryKey extends () => readonly unknown[] = SolidQueryKey,\n>(\n  arg1: TQueryKey | TOptions,\n  arg2?: QueryFunction<any, ReturnType<TQueryKey>> | TOptions,\n  arg3?: TOptions,\n): ParseQueryArgs<TOptions, TQueryKey> {\n  if (!isQueryKey(arg1)) {\n    const { queryKey: solidKey, ...opts } = arg1 as any\n    if (solidKey) {\n      return {\n        ...opts,\n        queryKey: solidKey(),\n      }\n    }\n    return arg1 as any\n  }\n\n  if (typeof arg2 === 'function') {\n    return { ...arg3, queryKey: arg1(), queryFn: arg2 } as any\n  }\n\n  return { ...arg2, queryKey: arg1() } as any\n}\n\nexport function parseFilterArgs<\n  TFilters extends SolidQueryFilters,\n  TOptions = unknown,\n>(\n  arg1?: SolidQueryKey | TFilters,\n  arg2?: TFilters | TOptions,\n  arg3?: TOptions,\n): [ParseFilterArgs<TFilters>, TOptions | undefined] {\n  return (\n    isQueryKey(arg1)\n      ? [{ ...arg2, queryKey: arg1() }, arg3]\n      : [{ ...arg1, queryKey: arg1?.queryKey?.() }, arg2]\n  ) as [ParseFilterArgs<TFilters>, TOptions]\n}\n\nexport function shouldThrowError<T extends (...args: any[]) => boolean>(\n  _useErrorBoundary: boolean | T | undefined,\n  params: Parameters<T>,\n): boolean {\n  // Allow useErrorBoundary function to override throwing behavior on a per-error basis\n  if (typeof _useErrorBoundary === 'function') {\n    return _useErrorBoundary(...params)\n  }\n\n  return !!_useErrorBoundary\n}\n\nexport function sleep(timeout: number): Promise<void> {\n  return new Promise((resolve) => {\n    setTimeout(resolve, timeout)\n  })\n}\n\n/**\n * Schedules a microtask.\n * This can be useful to schedule state updates after rendering.\n */\nexport function scheduleMicrotask(callback: () => void) {\n  sleep(0).then(callback)\n}\n"],"names":["isQueryKey","value","parseQueryArgs","arg1","arg2","arg3","queryKey","solidKey","opts","queryFn","parseFilterArgs","shouldThrowError","_useErrorBoundary","params","sleep","timeout","Promise","resolve","setTimeout","scheduleMicrotask","callback","then"],"mappings":";;;;AAQO,SAASA,UAAT,CAAoBC,KAApB,EAA4D;EACjE,OAAO,OAAOA,KAAP,KAAiB,UAAxB,CAAA;AACD;AAGD;;AACO,SAASC,cAAT,CASLC,IATK,EAULC,IAVK,EAWLC,IAXK,EAYgC;AACrC,EAAA,IAAI,CAACL,UAAU,CAACG,IAAD,CAAf,EAAuB;IACrB,MAAM;AAAEG,MAAAA,QAAQ,EAAEC,QAAZ;MAAsB,GAAGC,IAAAA;AAAzB,KAAA,GAAkCL,IAAxC,CAAA;;AACA,IAAA,IAAII,QAAJ,EAAc;MACZ,OAAO,EACL,GAAGC,IADE;AAELF,QAAAA,QAAQ,EAAEC,QAAQ,EAAA;OAFpB,CAAA;AAID,KAAA;;AACD,IAAA,OAAOJ,IAAP,CAAA;AACD,GAAA;;AAED,EAAA,IAAI,OAAOC,IAAP,KAAgB,UAApB,EAAgC;IAC9B,OAAO,EAAE,GAAGC,IAAL;MAAWC,QAAQ,EAAEH,IAAI,EAAzB;AAA6BM,MAAAA,OAAO,EAAEL,IAAAA;KAA7C,CAAA;AACD,GAAA;;EAED,OAAO,EAAE,GAAGA,IAAL;AAAWE,IAAAA,QAAQ,EAAEH,IAAI,EAAA;GAAhC,CAAA;AACD,CAAA;AAEM,SAASO,eAAT,CAILP,IAJK,EAKLC,IALK,EAMLC,IANK,EAO8C;EACnD,OACEL,UAAU,CAACG,IAAD,CAAV,GACI,CAAC,EAAE,GAAGC,IAAL;AAAWE,IAAAA,QAAQ,EAAEH,IAAI,EAAA;AAAzB,GAAD,EAAgCE,IAAhC,CADJ,GAEI,CAAC,EAAE,GAAGF,IAAL;IAAWG,QAAQ,EAAEH,IAAF,IAAEA,IAAAA,GAAAA,KAAAA,CAAAA,GAAAA,IAAI,CAAEG,QAAR,IAAA,IAAA,GAAA,KAAA,CAAA,GAAEH,IAAI,CAAEG,QAAN,EAAA;GAAtB,EAA4CF,IAA5C,CAHN,CAAA;AAKD,CAAA;AAEM,SAASO,gBAAT,CACLC,iBADK,EAELC,MAFK,EAGI;AACT;AACA,EAAA,IAAI,OAAOD,iBAAP,KAA6B,UAAjC,EAA6C;AAC3C,IAAA,OAAOA,iBAAiB,CAAC,GAAGC,MAAJ,CAAxB,CAAA;AACD,GAAA;;EAED,OAAO,CAAC,CAACD,iBAAT,CAAA;AACD,CAAA;AAEM,SAASE,KAAT,CAAeC,OAAf,EAA+C;AACpD,EAAA,OAAO,IAAIC,OAAJ,CAAaC,OAAD,IAAa;AAC9BC,IAAAA,UAAU,CAACD,OAAD,EAAUF,OAAV,CAAV,CAAA;AACD,GAFM,CAAP,CAAA;AAGD,CAAA;AAED;AACA;AACA;AACA;;AACO,SAASI,iBAAT,CAA2BC,QAA3B,EAAiD;AACtDN,EAAAA,KAAK,CAAC,CAAD,CAAL,CAASO,IAAT,CAAcD,QAAd,CAAA,CAAA;AACD;;;;;;;;;"}

package/build/lib/utils.mjs

@@ -0,0 +1,63 @@
+function isQueryKey(value) {
+  return typeof value === 'function';
+} // The parseQuery Args functions helps normalize the arguments into the correct form.
+// Whatever the parameters are, they are normalized into the correct form.
+
+function parseQueryArgs(arg1, arg2, arg3) {
+  if (!isQueryKey(arg1)) {
+    const {
+      queryKey: solidKey,
+      ...opts
+    } = arg1;
+
+    if (solidKey) {
+      return { ...opts,
+        queryKey: solidKey()
+      };
+    }
+
+    return arg1;
+  }
+
+  if (typeof arg2 === 'function') {
+    return { ...arg3,
+      queryKey: arg1(),
+      queryFn: arg2
+    };
+  }
+
+  return { ...arg2,
+    queryKey: arg1()
+  };
+}
+function parseFilterArgs(arg1, arg2, arg3) {
+  return isQueryKey(arg1) ? [{ ...arg2,
+    queryKey: arg1()
+  }, arg3] : [{ ...arg1,
+    queryKey: arg1 == null ? void 0 : arg1.queryKey == null ? void 0 : arg1.queryKey()
+  }, arg2];
+}
+function shouldThrowError(_useErrorBoundary, params) {
+  // Allow useErrorBoundary function to override throwing behavior on a per-error basis
+  if (typeof _useErrorBoundary === 'function') {
+    return _useErrorBoundary(...params);
+  }
+
+  return !!_useErrorBoundary;
+}
+function sleep(timeout) {
+  return new Promise(resolve => {
+    setTimeout(resolve, timeout);
+  });
+}
+/**
+ * Schedules a microtask.
+ * This can be useful to schedule state updates after rendering.
+ */
+
+function scheduleMicrotask(callback) {
+  sleep(0).then(callback);
+}
+
+export { isQueryKey, parseFilterArgs, parseQueryArgs, scheduleMicrotask, shouldThrowError, sleep };
+//# sourceMappingURL=utils.mjs.map

package/build/lib/utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.mjs","sources":["../../src/utils.ts"],"sourcesContent":["import type {\n  SolidQueryKey,\n  SolidQueryFilters,\n  ParseFilterArgs,\n  ParseQueryArgs,\n} from './types'\nimport type { QueryFunction, QueryOptions } from '@tanstack/query-core'\n\nexport function isQueryKey(value: unknown): value is SolidQueryKey {\n  return typeof value === 'function'\n}\n\n// The parseQuery Args functions helps normalize the arguments into the correct form.\n// Whatever the parameters are, they are normalized into the correct form.\nexport function parseQueryArgs<\n  TOptions extends Omit<\n    QueryOptions<any, any, any, ReturnType<TQueryKey>>,\n    'queryKey'\n  > & {\n    queryKey?: TQueryKey\n  },\n  TQueryKey extends () => readonly unknown[] = SolidQueryKey,\n>(\n  arg1: TQueryKey | TOptions,\n  arg2?: QueryFunction<any, ReturnType<TQueryKey>> | TOptions,\n  arg3?: TOptions,\n): ParseQueryArgs<TOptions, TQueryKey> {\n  if (!isQueryKey(arg1)) {\n    const { queryKey: solidKey, ...opts } = arg1 as any\n    if (solidKey) {\n      return {\n        ...opts,\n        queryKey: solidKey(),\n      }\n    }\n    return arg1 as any\n  }\n\n  if (typeof arg2 === 'function') {\n    return { ...arg3, queryKey: arg1(), queryFn: arg2 } as any\n  }\n\n  return { ...arg2, queryKey: arg1() } as any\n}\n\nexport function parseFilterArgs<\n  TFilters extends SolidQueryFilters,\n  TOptions = unknown,\n>(\n  arg1?: SolidQueryKey | TFilters,\n  arg2?: TFilters | TOptions,\n  arg3?: TOptions,\n): [ParseFilterArgs<TFilters>, TOptions | undefined] {\n  return (\n    isQueryKey(arg1)\n      ? [{ ...arg2, queryKey: arg1() }, arg3]\n      : [{ ...arg1, queryKey: arg1?.queryKey?.() }, arg2]\n  ) as [ParseFilterArgs<TFilters>, TOptions]\n}\n\nexport function shouldThrowError<T extends (...args: any[]) => boolean>(\n  _useErrorBoundary: boolean | T | undefined,\n  params: Parameters<T>,\n): boolean {\n  // Allow useErrorBoundary function to override throwing behavior on a per-error basis\n  if (typeof _useErrorBoundary === 'function') {\n    return _useErrorBoundary(...params)\n  }\n\n  return !!_useErrorBoundary\n}\n\nexport function sleep(timeout: number): Promise<void> {\n  return new Promise((resolve) => {\n    setTimeout(resolve, timeout)\n  })\n}\n\n/**\n * Schedules a microtask.\n * This can be useful to schedule state updates after rendering.\n */\nexport function scheduleMicrotask(callback: () => void) {\n  sleep(0).then(callback)\n}\n"],"names":["isQueryKey","value","parseQueryArgs","arg1","arg2","arg3","queryKey","solidKey","opts","queryFn","parseFilterArgs","shouldThrowError","_useErrorBoundary","params","sleep","timeout","Promise","resolve","setTimeout","scheduleMicrotask","callback","then"],"mappings":"AAQO,SAASA,UAAT,CAAoBC,KAApB,EAA4D;EACjE,OAAO,OAAOA,KAAP,KAAiB,UAAxB,CAAA;AACD;AAGD;;AACO,SAASC,cAAT,CASLC,IATK,EAULC,IAVK,EAWLC,IAXK,EAYgC;AACrC,EAAA,IAAI,CAACL,UAAU,CAACG,IAAD,CAAf,EAAuB;IACrB,MAAM;AAAEG,MAAAA,QAAQ,EAAEC,QAAZ;MAAsB,GAAGC,IAAAA;AAAzB,KAAA,GAAkCL,IAAxC,CAAA;;AACA,IAAA,IAAII,QAAJ,EAAc;MACZ,OAAO,EACL,GAAGC,IADE;AAELF,QAAAA,QAAQ,EAAEC,QAAQ,EAAA;OAFpB,CAAA;AAID,KAAA;;AACD,IAAA,OAAOJ,IAAP,CAAA;AACD,GAAA;;AAED,EAAA,IAAI,OAAOC,IAAP,KAAgB,UAApB,EAAgC;IAC9B,OAAO,EAAE,GAAGC,IAAL;MAAWC,QAAQ,EAAEH,IAAI,EAAzB;AAA6BM,MAAAA,OAAO,EAAEL,IAAAA;KAA7C,CAAA;AACD,GAAA;;EAED,OAAO,EAAE,GAAGA,IAAL;AAAWE,IAAAA,QAAQ,EAAEH,IAAI,EAAA;GAAhC,CAAA;AACD,CAAA;AAEM,SAASO,eAAT,CAILP,IAJK,EAKLC,IALK,EAMLC,IANK,EAO8C;EACnD,OACEL,UAAU,CAACG,IAAD,CAAV,GACI,CAAC,EAAE,GAAGC,IAAL;AAAWE,IAAAA,QAAQ,EAAEH,IAAI,EAAA;AAAzB,GAAD,EAAgCE,IAAhC,CADJ,GAEI,CAAC,EAAE,GAAGF,IAAL;IAAWG,QAAQ,EAAEH,IAAF,IAAEA,IAAAA,GAAAA,KAAAA,CAAAA,GAAAA,IAAI,CAAEG,QAAR,IAAA,IAAA,GAAA,KAAA,CAAA,GAAEH,IAAI,CAAEG,QAAN,EAAA;GAAtB,EAA4CF,IAA5C,CAHN,CAAA;AAKD,CAAA;AAEM,SAASO,gBAAT,CACLC,iBADK,EAELC,MAFK,EAGI;AACT;AACA,EAAA,IAAI,OAAOD,iBAAP,KAA6B,UAAjC,EAA6C;AAC3C,IAAA,OAAOA,iBAAiB,CAAC,GAAGC,MAAJ,CAAxB,CAAA;AACD,GAAA;;EAED,OAAO,CAAC,CAACD,iBAAT,CAAA;AACD,CAAA;AAEM,SAASE,KAAT,CAAeC,OAAf,EAA+C;AACpD,EAAA,OAAO,IAAIC,OAAJ,CAAaC,OAAD,IAAa;AAC9BC,IAAAA,UAAU,CAACD,OAAD,EAAUF,OAAV,CAAV,CAAA;AACD,GAFM,CAAP,CAAA;AAGD,CAAA;AAED;AACA;AACA;AACA;;AACO,SAASI,iBAAT,CAA2BC,QAA3B,EAAiD;AACtDN,EAAAA,KAAK,CAAC,CAAD,CAAL,CAASO,IAAT,CAAcD,QAAd,CAAA,CAAA;AACD;;;;"}

package/build/solid/QueryClientProvider.jsx

@@ -0,0 +1,42 @@
+import { createContext, useContext, onMount, onCleanup, mergeProps, } from 'solid-js';
+export const defaultContext = createContext(undefined);
+const QueryClientSharingContext = createContext(false);
+// If we are given a context, we will use it.
+// Otherwise, if contextSharing is on, we share the first and at least one
+// instance of the context across the window
+// to ensure that if Solid Query is used across
+// different bundles or microfrontends they will
+// all use the same **instance** of context, regardless
+// of module scoping.
+function getQueryClientContext(context, contextSharing) {
+    if (context) {
+        return context;
+    }
+    if (contextSharing && typeof window !== 'undefined') {
+        if (!window.SolidQueryClientContext) {
+            window.SolidQueryClientContext = defaultContext;
+        }
+        return window.SolidQueryClientContext;
+    }
+    return defaultContext;
+}
+export const useQueryClient = ({ context } = {}) => {
+    const queryClient = useContext(getQueryClientContext(context, useContext(QueryClientSharingContext)));
+    if (!queryClient) {
+        throw new Error('No QueryClient set, use QueryClientProvider to set one');
+    }
+    return queryClient;
+};
+export const QueryClientProvider = (props) => {
+    const mergedProps = mergeProps({
+        contextSharing: false,
+    }, props);
+    onMount(() => mergedProps.client.mount());
+    onCleanup(() => mergedProps.client.unmount());
+    const QueryClientContext = getQueryClientContext(mergedProps.context, mergedProps.contextSharing);
+    return (<QueryClientSharingContext.Provider value={!mergedProps.context && mergedProps.contextSharing}>
+      <QueryClientContext.Provider value={mergedProps.client}>
+        {mergedProps.children}
+      </QueryClientContext.Provider>
+    </QueryClientSharingContext.Provider>);
+};

package/build/solid/createBaseQuery.js

@@ -0,0 +1,69 @@
+import { useQueryClient } from './QueryClientProvider';
+import { onMount, onCleanup, createComputed, createResource, on, batch, } from 'solid-js';
+import { createStore, unwrap } from 'solid-js/store';
+import { shouldThrowError } from './utils';
+// Base Query Function that is used to create the query.
+export function createBaseQuery(options, Observer) {
+    const queryClient = useQueryClient({ context: options.context });
+    const defaultedOptions = queryClient.defaultQueryOptions(options);
+    defaultedOptions._optimisticResults = 'optimistic';
+    const observer = new Observer(queryClient, defaultedOptions);
+    const [state, setState] = createStore(
+    // @ts-ignore
+    observer.getOptimisticResult(defaultedOptions));
+    const [dataResource, { refetch, mutate }] = createResource(() => {
+        return new Promise((resolve) => {
+            if (!(state.isFetching && state.isLoading)) {
+                resolve(unwrap(state.data));
+            }
+        });
+    });
+    batch(() => {
+        mutate(() => unwrap(state.data));
+        refetch();
+    });
+    let taskQueue = [];
+    const unsubscribe = observer.subscribe((result) => {
+        taskQueue.push(() => {
+            batch(() => {
+                setState(unwrap(result));
+                mutate(() => unwrap(result.data));
+                refetch();
+            });
+        });
+        queueMicrotask(() => {
+            const taskToRun = taskQueue.pop();
+            if (taskToRun) {
+                taskToRun();
+            }
+            taskQueue = [];
+        });
+    });
+    onCleanup(() => unsubscribe());
+    onMount(() => {
+        observer.setOptions(defaultedOptions, { listeners: false });
+    });
+    createComputed(() => {
+        const newDefaultedOptions = queryClient.defaultQueryOptions(options);
+        observer.setOptions(newDefaultedOptions);
+    });
+    createComputed(on(() => state.status, () => {
+        if (state.isError &&
+            !state.isFetching &&
+            shouldThrowError(observer.options.useErrorBoundary, [
+                state.error,
+                observer.getCurrentQuery(),
+            ])) {
+            throw state.error;
+        }
+    }));
+    const handler = {
+        get(target, prop) {
+            if (prop === 'data' && target.isLoading && target.isFetching) {
+                return dataResource();
+            }
+            return Reflect.get(target, prop);
+        },
+    };
+    return new Proxy(state, handler);
+}

package/build/solid/createInfiniteQuery.js

@@ -0,0 +1,16 @@
+import { InfiniteQueryObserver } from '@tanstack/query-core';
+import { createBaseQuery } from './createBaseQuery';
+import { createComputed } from 'solid-js';
+import { createStore } from 'solid-js/store';
+import { parseQueryArgs } from './utils';
+export function createInfiniteQuery(arg1, arg2, arg3) {
+    // The parseQuery Args functions helps normalize the arguments into the correct form.
+    // Whatever the parameters are, they are normalized into the correct form.
+    const [parsedOptions, setParsedOptions] = createStore(parseQueryArgs(arg1, arg2, arg3));
+    // Watch for changes in the options and update the parsed options.
+    createComputed(() => {
+        const newParsedOptions = parseQueryArgs(arg1, arg2, arg3);
+        setParsedOptions(newParsedOptions);
+    });
+    return createBaseQuery(parsedOptions, InfiniteQueryObserver);
+}

package/build/solid/createMutation.js

@@ -0,0 +1,40 @@
+import { parseMutationArgs, 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';
+export function createMutation(arg1, arg2, arg3) {
+    const [options, setOptions] = createStore(parseMutationArgs(arg1, arg2, arg3));
+    const queryClient = useQueryClient({ context: options.context });
+    const observer = new MutationObserver(queryClient, options);
+    const mutate = (variables, mutateOptions) => {
+        observer.mutate(variables, mutateOptions).catch(noop);
+    };
+    const [state, setState] = createStore({
+        ...observer.getCurrentResult(),
+        mutate,
+        mutateAsync: observer.getCurrentResult().mutate,
+    });
+    createComputed(() => {
+        const newParsedOptions = parseMutationArgs(arg1, arg2, arg3);
+        setOptions(newParsedOptions);
+        observer.setOptions(newParsedOptions);
+    });
+    createComputed(on(() => state.status, () => {
+        if (state.isError &&
+            shouldThrowError(observer.options.useErrorBoundary, [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/build/solid/createQueries.js

@@ -0,0 +1,39 @@
+import { createComputed, onCleanup, onMount } from 'solid-js';
+import { QueriesObserver } from '@tanstack/query-core';
+import { useQueryClient } from './QueryClientProvider';
+import { createStore, unwrap } from 'solid-js/store';
+import { scheduleMicrotask } from './utils';
+export function createQueries(queriesOptions) {
+    const queryClient = useQueryClient({ context: queriesOptions.context });
+    const normalizeOptions = (options) => {
+        const normalizedOptions = { ...options, queryKey: options.queryKey?.() };
+        const defaultedOptions = queryClient.defaultQueryOptions(normalizedOptions);
+        defaultedOptions._optimisticResults = 'optimistic';
+        return defaultedOptions;
+    };
+    const defaultedQueries = queriesOptions.queries.map((options) => normalizeOptions(options));
+    const observer = new QueriesObserver(queryClient, defaultedQueries);
+    const [state, setState] = createStore(observer.getOptimisticResult(defaultedQueries));
+    const taskQueue = [];
+    const unsubscribe = observer.subscribe((result) => {
+        taskQueue.push(() => {
+            setState(unwrap(result));
+        });
+        scheduleMicrotask(() => {
+            const taskToRun = taskQueue.pop();
+            if (taskToRun) {
+                taskToRun();
+                taskQueue.splice(0, taskQueue.length);
+            }
+        });
+    });
+    onCleanup(unsubscribe);
+    onMount(() => {
+        observer.setQueries(defaultedQueries, { listeners: false });
+    });
+    createComputed(() => {
+        const updateDefaultedQueries = queriesOptions.queries.map((options) => normalizeOptions(options));
+        observer.setQueries(updateDefaultedQueries);
+    });
+    return state;
+}

package/build/solid/createQuery.js

@@ -0,0 +1,16 @@
+import { QueryObserver } from '@tanstack/query-core';
+import { createComputed } from 'solid-js';
+import { createStore } from 'solid-js/store';
+import { parseQueryArgs } from './utils';
+import { createBaseQuery } from './createBaseQuery';
+export function createQuery(arg1, arg2, arg3) {
+    // The parseQuery Args functions helps normalize the arguments into the correct form.
+    // Whatever the parameters are, they are normalized into the correct form.
+    const [parsedOptions, setParsedOptions] = createStore(parseQueryArgs(arg1, arg2, arg3));
+    // Watch for changes in the options and update the parsed options.
+    createComputed(() => {
+        const newParsedOptions = parseQueryArgs(arg1, arg2, arg3);
+        setParsedOptions(newParsedOptions);
+    });
+    return createBaseQuery(parsedOptions, QueryObserver);
+}

package/build/solid/index.js

@@ -0,0 +1,11 @@
+// Re-export core
+export * from '@tanstack/query-core';
+// Solid Query
+export * from './types';
+export { createQuery } from './createQuery';
+export { defaultContext, QueryClientProvider, useQueryClient, } from './QueryClientProvider';
+export { useIsFetching } from './useIsFetching';
+export { useIsMutating } from './useIsMutating';
+export { createMutation } from './createMutation';
+export { createInfiniteQuery } from './createInfiniteQuery';
+export { createQueries } from './createQueries';

package/build/solid/types.js

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

package/build/solid/useIsFetching.js

@@ -0,0 +1,23 @@
+import { useQueryClient } from './QueryClientProvider';
+import { createSignal, onCleanup, createComputed, createMemo } from 'solid-js';
+import { parseFilterArgs } from './utils';
+export function useIsFetching(arg1, arg2, arg3) {
+    const [filtersObj, optionsObj = {}] = parseFilterArgs(arg1, arg2, arg3);
+    const [filters, setFilters] = createSignal(filtersObj);
+    const [options, setOptions] = createSignal(optionsObj);
+    const queryClient = createMemo(() => useQueryClient({ context: options().context }));
+    const queryCache = createMemo(() => queryClient().getQueryCache());
+    const [fetches, setFetches] = createSignal(queryClient().isFetching(filters));
+    createComputed(() => {
+        const [newFiltersObj, newOptionsObj = {}] = parseFilterArgs(arg1, arg2, arg3);
+        setFilters(newFiltersObj);
+        setOptions(newOptionsObj);
+    });
+    const unsubscribe = queryCache().subscribe(() => {
+        setFetches(queryClient().isFetching(filters()));
+    });
+    onCleanup(() => {
+        unsubscribe();
+    });
+    return fetches;
+}

package/build/solid/useIsMutating.js

@@ -0,0 +1,16 @@
+import { parseMutationFilterArgs } from '@tanstack/query-core';
+import { useQueryClient } from './QueryClientProvider';
+import { createSignal, onCleanup } from 'solid-js';
+export function useIsMutating(arg1, arg2, arg3) {
+    const [filters, options = {}] = parseMutationFilterArgs(arg1, arg2, arg3);
+    const queryClient = useQueryClient({ context: options.context });
+    const mutationCache = queryClient.getMutationCache();
+    const [mutations, setMutations] = createSignal(queryClient.isMutating(filters));
+    const unsubscribe = mutationCache.subscribe((_result) => {
+        setMutations(queryClient.isMutating(filters));
+    });
+    onCleanup(() => {
+        unsubscribe();
+    });
+    return mutations;
+}

package/build/solid/utils.js

@@ -0,0 +1,45 @@
+export function isQueryKey(value) {
+    return typeof value === 'function';
+}
+// The parseQuery Args functions helps normalize the arguments into the correct form.
+// Whatever the parameters are, they are normalized into the correct form.
+export function parseQueryArgs(arg1, arg2, arg3) {
+    if (!isQueryKey(arg1)) {
+        const { queryKey: solidKey, ...opts } = arg1;
+        if (solidKey) {
+            return {
+                ...opts,
+                queryKey: solidKey(),
+            };
+        }
+        return arg1;
+    }
+    if (typeof arg2 === 'function') {
+        return { ...arg3, queryKey: arg1(), queryFn: arg2 };
+    }
+    return { ...arg2, queryKey: arg1() };
+}
+export function parseFilterArgs(arg1, arg2, arg3) {
+    return (isQueryKey(arg1)
+        ? [{ ...arg2, queryKey: arg1() }, arg3]
+        : [{ ...arg1, queryKey: arg1?.queryKey?.() }, arg2]);
+}
+export function shouldThrowError(_useErrorBoundary, params) {
+    // Allow useErrorBoundary function to override throwing behavior on a per-error basis
+    if (typeof _useErrorBoundary === 'function') {
+        return _useErrorBoundary(...params);
+    }
+    return !!_useErrorBoundary;
+}
+export function sleep(timeout) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, timeout);
+    });
+}
+/**
+ * Schedules a microtask.
+ * This can be useful to schedule state updates after rendering.
+ */
+export function scheduleMicrotask(callback) {
+    sleep(0).then(callback);
+}