@tanstack/solid-query 4.39.0 → 4.39.2

package/build/solid/createQueries.js

@@ -0,0 +1,39 @@
+import { createComputed, onCleanup, onMount } from 'solid-js';
+import { QueriesObserver } from '@tanstack/query-core';
+import { createStore, unwrap } from 'solid-js/store';
+import { useQueryClient } from './QueryClientProvider';
+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,12 @@
+/* istanbul ignore file */
+// 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,2 @@
+/* istanbul ignore file */
+export {};

package/build/solid/useIsFetching.js

@@ -0,0 +1,23 @@
+import { createComputed, createMemo, createSignal, onCleanup } from 'solid-js';
+import { useQueryClient } from './QueryClientProvider';
+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 { createSignal, onCleanup } from 'solid-js';
+import { useQueryClient } from './QueryClientProvider';
+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);
+}