@tanstack/svelte-query-persist-client 5.0.0-beta.26

package/dist/__tests__/PersistQueryClientProvider.test.js

@@ -0,0 +1,294 @@
+import { render, waitFor } from '@testing-library/svelte';
+import { describe, expect, test, vi } from 'vitest';
+import { persistQueryClientSave } from '@tanstack/query-persist-client-core';
+import { get, writable } from 'svelte/store';
+import AwaitOnSuccess from './AwaitOnSuccess/Provider.svelte';
+import FreshData from './FreshData/Provider.svelte';
+import OnSuccess from './OnSuccess/Provider.svelte';
+import InitialData from './InitialData/Provider.svelte';
+import RemoveCache from './RemoveCache/Provider.svelte';
+import RestoreCache from './RestoreCache/Provider.svelte';
+import UseQueries from './UseQueries/Provider.svelte';
+import { createQueryClient, queryKey, sleep } from './utils';
+const createMockPersister = () => {
+    let storedState;
+    return {
+        async persistClient(persistClient) {
+            storedState = persistClient;
+        },
+        async restoreClient() {
+            await sleep(10);
+            return storedState;
+        },
+        removeClient() {
+            storedState = undefined;
+        },
+    };
+};
+const createMockErrorPersister = (removeClient) => {
+    const error = new Error('restore failed');
+    return [
+        error,
+        {
+            async persistClient() {
+                // noop
+            },
+            async restoreClient() {
+                await sleep(10);
+                throw error;
+            },
+            removeClient,
+        },
+    ];
+};
+describe('PersistQueryClientProvider', () => {
+    test('restores cache from persister', async () => {
+        const key = queryKey();
+        const states = writable([]);
+        const queryClient = createQueryClient();
+        await queryClient.prefetchQuery({
+            queryKey: key,
+            queryFn: () => Promise.resolve('hydrated'),
+        });
+        const persister = createMockPersister();
+        await persistQueryClientSave({ queryClient, persister });
+        queryClient.clear();
+        const rendered = render(RestoreCache, {
+            props: {
+                queryClient,
+                persistOptions: { persister },
+                key,
+                states,
+            },
+        });
+        await waitFor(() => rendered.getByText('fetchStatus: idle'));
+        await waitFor(() => rendered.getByText('hydrated'));
+        await waitFor(() => rendered.getByText('fetched'));
+        const states_ = get(states);
+        expect(states_).toHaveLength(4);
+        expect(states_[0]).toMatchObject({
+            status: 'pending',
+            fetchStatus: 'idle',
+            data: undefined,
+        });
+        expect(states_[1]).toMatchObject({
+            status: 'success',
+            fetchStatus: 'fetching',
+            data: 'hydrated',
+        });
+        expect(states_[2]).toMatchObject({
+            status: 'success',
+            fetchStatus: 'fetching',
+            data: 'hydrated',
+        });
+        expect(states_[3]).toMatchObject({
+            status: 'success',
+            fetchStatus: 'idle',
+            data: 'fetched',
+        });
+    });
+    test('should also put useQueries into idle state', async () => {
+        const key = queryKey();
+        const states = writable([]);
+        const queryClient = createQueryClient();
+        await queryClient.prefetchQuery({
+            queryKey: key,
+            queryFn: () => Promise.resolve('hydrated'),
+        });
+        const persister = createMockPersister();
+        await persistQueryClientSave({ queryClient, persister });
+        queryClient.clear();
+        const rendered = render(UseQueries, {
+            props: {
+                queryClient,
+                persistOptions: { persister },
+                key,
+                states,
+            },
+        });
+        await waitFor(() => rendered.getByText('fetchStatus: idle'));
+        await waitFor(() => rendered.getByText('hydrated'));
+        await waitFor(() => rendered.getByText('fetched'));
+        const states_ = get(states);
+        expect(states_).toHaveLength(4);
+        expect(states_[0]).toMatchObject({
+            status: 'pending',
+            fetchStatus: 'idle',
+            data: undefined,
+        });
+        expect(states_[1]).toMatchObject({
+            status: 'success',
+            fetchStatus: 'fetching',
+            data: 'hydrated',
+        });
+        expect(states_[2]).toMatchObject({
+            status: 'success',
+            fetchStatus: 'fetching',
+            data: 'hydrated',
+        });
+        expect(states_[3]).toMatchObject({
+            status: 'success',
+            fetchStatus: 'idle',
+            data: 'fetched',
+        });
+    });
+    test('should show initialData while restoring', async () => {
+        const key = queryKey();
+        const states = writable([]);
+        const queryClient = createQueryClient();
+        await queryClient.prefetchQuery({
+            queryKey: key,
+            queryFn: () => Promise.resolve('hydrated'),
+        });
+        const persister = createMockPersister();
+        await persistQueryClientSave({ queryClient, persister });
+        queryClient.clear();
+        const rendered = render(InitialData, {
+            props: {
+                queryClient,
+                persistOptions: { persister },
+                key,
+                states,
+            },
+        });
+        await waitFor(() => rendered.getByText('initial'));
+        await waitFor(() => rendered.getByText('hydrated'));
+        await waitFor(() => rendered.getByText('fetched'));
+        const states_ = get(states);
+        expect(states_).toHaveLength(4);
+        expect(states_[0]).toMatchObject({
+            status: 'success',
+            fetchStatus: 'idle',
+            data: 'initial',
+        });
+        expect(states_[1]).toMatchObject({
+            status: 'success',
+            fetchStatus: 'fetching',
+            data: 'hydrated',
+        });
+        expect(states_[2]).toMatchObject({
+            status: 'success',
+            fetchStatus: 'fetching',
+            data: 'hydrated',
+        });
+        expect(states_[3]).toMatchObject({
+            status: 'success',
+            fetchStatus: 'idle',
+            data: 'fetched',
+        });
+    });
+    test('should not refetch after restoring when data is fresh', async () => {
+        const key = queryKey();
+        const states = writable([]);
+        const queryClient = createQueryClient();
+        await queryClient.prefetchQuery({
+            queryKey: key,
+            queryFn: () => Promise.resolve('hydrated'),
+        });
+        const persister = createMockPersister();
+        await persistQueryClientSave({ queryClient, persister });
+        queryClient.clear();
+        const fetched = writable(false);
+        const rendered = render(FreshData, {
+            props: {
+                queryClient,
+                persistOptions: { persister },
+                key,
+                states,
+                fetched,
+            },
+        });
+        await waitFor(() => rendered.getByText('data: null'));
+        await waitFor(() => rendered.getByText('data: hydrated'));
+        const states_ = get(states);
+        expect(states_).toHaveLength(2);
+        expect(get(fetched)).toBe(false);
+        expect(states_[0]).toMatchObject({
+            status: 'pending',
+            fetchStatus: 'idle',
+            data: undefined,
+        });
+        expect(states_[1]).toMatchObject({
+            status: 'success',
+            fetchStatus: 'idle',
+            data: 'hydrated',
+        });
+    });
+    test('should call onSuccess after successful restoring', async () => {
+        const key = queryKey();
+        const queryClient = createQueryClient();
+        await queryClient.prefetchQuery({
+            queryKey: key,
+            queryFn: () => Promise.resolve('hydrated'),
+        });
+        const persister = createMockPersister();
+        await persistQueryClientSave({ queryClient, persister });
+        queryClient.clear();
+        const onSuccess = vi.fn();
+        const rendered = render(OnSuccess, {
+            props: {
+                queryClient,
+                persistOptions: { persister },
+                key,
+                onSuccess,
+            },
+        });
+        expect(onSuccess).toHaveBeenCalledTimes(0);
+        await waitFor(() => rendered.getByText('hydrated'));
+        expect(onSuccess).toHaveBeenCalledTimes(1);
+        await waitFor(() => rendered.getByText('fetched'));
+    });
+    test('should await onSuccess after successful restoring', async () => {
+        const key = queryKey();
+        const queryClient = createQueryClient();
+        await queryClient.prefetchQuery({
+            queryKey: key,
+            queryFn: () => Promise.resolve('hydrated'),
+        });
+        const persister = createMockPersister();
+        await persistQueryClientSave({ queryClient, persister });
+        queryClient.clear();
+        const states = writable([]);
+        const rendered = render(AwaitOnSuccess, {
+            props: {
+                queryClient,
+                persistOptions: { persister },
+                key,
+                states,
+                onSuccess: async () => {
+                    states.update((s) => [...s, 'onSuccess']);
+                    await sleep(20);
+                    states.update((s) => [...s, 'onSuccess done']);
+                },
+            },
+        });
+        await waitFor(() => rendered.getByText('hydrated'));
+        await waitFor(() => rendered.getByText('fetched'));
+        expect(get(states)).toEqual([
+            'onSuccess',
+            'onSuccess done',
+            'fetching',
+            'fetched',
+        ]);
+    });
+    test('should remove cache after non-successful restoring', async () => {
+        const key = queryKey();
+        const consoleMock = vi.spyOn(console, 'error');
+        const consoleWarn = vi
+            .spyOn(console, 'warn')
+            .mockImplementation(() => undefined);
+        consoleMock.mockImplementation(() => undefined);
+        const queryClient = createQueryClient();
+        const removeClient = vi.fn();
+        const [error, persister] = createMockErrorPersister(removeClient);
+        const rendered = render(RemoveCache, {
+            props: { queryClient, persistOptions: { persister }, key },
+        });
+        await waitFor(() => rendered.getByText('fetched'));
+        expect(removeClient).toHaveBeenCalledTimes(1);
+        expect(consoleMock).toHaveBeenCalledTimes(1);
+        expect(consoleMock).toHaveBeenNthCalledWith(1, error);
+        consoleMock.mockRestore();
+        consoleWarn.mockRestore();
+    });
+});

package/dist/__tests__/RemoveCache/Provider.svelte

@@ -0,0 +1,10 @@
+<script>import PersistQueryClientProvider from "../../PersistQueryClientProvider.svelte";
+import RemoveCache from "./RemoveCache.svelte";
+export let queryClient;
+export let persistOptions;
+export let key;
+</script>
+
+<PersistQueryClientProvider client={queryClient} {persistOptions}>
+  <RemoveCache {key} />
+</PersistQueryClientProvider>

package/dist/__tests__/RemoveCache/Provider.svelte.d.ts

@@ -0,0 +1,21 @@
+import { SvelteComponentTyped } from "svelte";
+import type { QueryClient } from '@tanstack/svelte-query';
+import type { PersistQueryClientOptions } from '@tanstack/query-persist-client-core';
+declare const __propDef: {
+    props: {
+        queryClient: QueryClient;
+        persistOptions: Omit<PersistQueryClientOptions, 'queryClient'>;
+        key: Array<string>;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type ProviderProps = typeof __propDef.props;
+export type ProviderEvents = typeof __propDef.events;
+export type ProviderSlots = typeof __propDef.slots;
+export default class Provider extends SvelteComponentTyped<ProviderProps, ProviderEvents, ProviderSlots> {
+}
+export {};
+//# sourceMappingURL=Provider.svelte.d.ts.map

package/dist/__tests__/RemoveCache/Provider.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Provider.svelte.d.ts","sourceRoot":"","sources":["../../../../src/__tests__/RemoveCache/Provider.svelte"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAE5C;AAGD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AACzD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,qCAAqC,CAAA;AAmBpF,QAAA,MAAM,SAAS;;qBADyF,WAAW;wBAAkB,KAAK,yBAAyB,EAAE,aAAa,CAAC;aAAO,MAAM,MAAM,CAAC;;;;;;CAChJ,CAAC;AACxD,MAAM,MAAM,aAAa,GAAG,OAAO,SAAS,CAAC,KAAK,CAAC;AACnD,MAAM,MAAM,cAAc,GAAG,OAAO,SAAS,CAAC,MAAM,CAAC;AACrD,MAAM,MAAM,aAAa,GAAG,OAAO,SAAS,CAAC,KAAK,CAAC;AAEnD,MAAM,CAAC,OAAO,OAAO,QAAS,SAAQ,oBAAoB,CAAC,aAAa,EAAE,cAAc,EAAE,aAAa,CAAC;CACvG"}

package/dist/__tests__/RemoveCache/RemoveCache.svelte

@@ -0,0 +1,23 @@
+<script>import { createQuery } from "@tanstack/svelte-query";
+import { get } from "svelte/store";
+import { sleep } from "../utils";
+export let key;
+const state = createQuery({
+  queryKey: key,
+  queryFn: async () => {
+    await sleep(10);
+    return "fetched";
+  }
+});
+let data = get(state).data;
+let fetchStatus = get(state).fetchStatus;
+state.subscribe((s) => {
+  data = s.data;
+  fetchStatus = s.fetchStatus;
+});
+</script>
+
+<div>
+  <h1>{data}</h1>
+  <h2>fetchStatus: {fetchStatus}</h2>
+</div>

package/dist/__tests__/RemoveCache/RemoveCache.svelte.d.ts

@@ -0,0 +1,17 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        key: Array<string>;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type RemoveCacheProps = typeof __propDef.props;
+export type RemoveCacheEvents = typeof __propDef.events;
+export type RemoveCacheSlots = typeof __propDef.slots;
+export default class RemoveCache extends SvelteComponentTyped<RemoveCacheProps, RemoveCacheEvents, RemoveCacheSlots> {
+}
+export {};
+//# sourceMappingURL=RemoveCache.svelte.d.ts.map

package/dist/__tests__/RemoveCache/RemoveCache.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RemoveCache.svelte.d.ts","sourceRoot":"","sources":["../../../../src/__tests__/RemoveCache/RemoveCache.svelte"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAE5C;AAmCD,QAAA,MAAM,SAAS;;aADqB,MAAM,MAAM,CAAC;;;;;;CACM,CAAC;AACxD,MAAM,MAAM,gBAAgB,GAAG,OAAO,SAAS,CAAC,KAAK,CAAC;AACtD,MAAM,MAAM,iBAAiB,GAAG,OAAO,SAAS,CAAC,MAAM,CAAC;AACxD,MAAM,MAAM,gBAAgB,GAAG,OAAO,SAAS,CAAC,KAAK,CAAC;AAEtD,MAAM,CAAC,OAAO,OAAO,WAAY,SAAQ,oBAAoB,CAAC,gBAAgB,EAAE,iBAAiB,EAAE,gBAAgB,CAAC;CACnH"}

package/dist/__tests__/RestoreCache/Provider.svelte

@@ -0,0 +1,11 @@
+<script>import PersistQueryClientProvider from "../../PersistQueryClientProvider.svelte";
+import RestoreCache from "./RestoreCache.svelte";
+export let queryClient;
+export let persistOptions;
+export let key;
+export let states;
+</script>
+
+<PersistQueryClientProvider client={queryClient} {persistOptions}>
+  <RestoreCache {key} {states} />
+</PersistQueryClientProvider>

package/dist/__tests__/RestoreCache/Provider.svelte.d.ts

@@ -0,0 +1,24 @@
+import { SvelteComponentTyped } from "svelte";
+import type { QueryClient } from '@tanstack/svelte-query';
+import type { PersistQueryClientOptions } from '@tanstack/query-persist-client-core';
+import type { Writable } from 'svelte/store';
+import type { StatusResult } from '../utils';
+declare const __propDef: {
+    props: {
+        queryClient: QueryClient;
+        persistOptions: Omit<PersistQueryClientOptions, 'queryClient'>;
+        key: Array<string>;
+        states: Writable<Array<StatusResult<string>>>;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type ProviderProps = typeof __propDef.props;
+export type ProviderEvents = typeof __propDef.events;
+export type ProviderSlots = typeof __propDef.slots;
+export default class Provider extends SvelteComponentTyped<ProviderProps, ProviderEvents, ProviderSlots> {
+}
+export {};
+//# sourceMappingURL=Provider.svelte.d.ts.map

package/dist/__tests__/RestoreCache/Provider.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Provider.svelte.d.ts","sourceRoot":"","sources":["../../../../src/__tests__/RestoreCache/Provider.svelte"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAE5C;AAGD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AACzD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,qCAAqC,CAAA;AACpF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAsB5C,QAAA,MAAM,SAAS;;qBAD0G,WAAW;wBAAkB,KAAK,yBAAyB,EAAE,aAAa,CAAC;aAAO,MAAM,MAAM,CAAC;gBAAU,SAAS,MAAM,aAAa,MAAM,CAAC,CAAC,CAAC;;;;;;CAChN,CAAC;AACxD,MAAM,MAAM,aAAa,GAAG,OAAO,SAAS,CAAC,KAAK,CAAC;AACnD,MAAM,MAAM,cAAc,GAAG,OAAO,SAAS,CAAC,MAAM,CAAC;AACrD,MAAM,MAAM,aAAa,GAAG,OAAO,SAAS,CAAC,KAAK,CAAC;AAEnD,MAAM,CAAC,OAAO,OAAO,QAAS,SAAQ,oBAAoB,CAAC,aAAa,EAAE,cAAc,EAAE,aAAa,CAAC;CACvG"}

package/dist/__tests__/RestoreCache/RestoreCache.svelte

@@ -0,0 +1,28 @@
+<script>import { createQuery } from "@tanstack/svelte-query";
+import { get } from "svelte/store";
+import { sleep } from "../utils";
+export let key;
+export let states;
+const state = createQuery({
+  queryKey: key,
+  queryFn: async () => {
+    await sleep(10);
+    return "fetched";
+  }
+});
+let data = get(state).data;
+let fetchStatus = get(state).fetchStatus;
+state.subscribe((s) => {
+  states.update((prev) => [
+    ...prev,
+    { status: s.status, data: s.data, fetchStatus: s.fetchStatus }
+  ]);
+  data = s.data;
+  fetchStatus = s.fetchStatus;
+});
+</script>
+
+<div>
+  <h1>{data}</h1>
+  <h2>fetchStatus: {fetchStatus}</h2>
+</div>

package/dist/__tests__/RestoreCache/RestoreCache.svelte.d.ts

@@ -0,0 +1,20 @@
+import { SvelteComponentTyped } from "svelte";
+import type { Writable } from 'svelte/store';
+import type { StatusResult } from '../utils';
+declare const __propDef: {
+    props: {
+        key: Array<string>;
+        states: Writable<Array<StatusResult<string>>>;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type RestoreCacheProps = typeof __propDef.props;
+export type RestoreCacheEvents = typeof __propDef.events;
+export type RestoreCacheSlots = typeof __propDef.slots;
+export default class RestoreCache extends SvelteComponentTyped<RestoreCacheProps, RestoreCacheEvents, RestoreCacheSlots> {
+}
+export {};
+//# sourceMappingURL=RestoreCache.svelte.d.ts.map

package/dist/__tests__/RestoreCache/RestoreCache.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RestoreCache.svelte.d.ts","sourceRoot":"","sources":["../../../../src/__tests__/RestoreCache/RestoreCache.svelte"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAE5C;AAID,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAuC5C,QAAA,MAAM,SAAS;;aADsC,MAAM,MAAM,CAAC;gBAAU,SAAS,MAAM,aAAa,MAAM,CAAC,CAAC,CAAC;;;;;;CAC1D,CAAC;AACxD,MAAM,MAAM,iBAAiB,GAAG,OAAO,SAAS,CAAC,KAAK,CAAC;AACvD,MAAM,MAAM,kBAAkB,GAAG,OAAO,SAAS,CAAC,MAAM,CAAC;AACzD,MAAM,MAAM,iBAAiB,GAAG,OAAO,SAAS,CAAC,KAAK,CAAC;AAEvD,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,oBAAoB,CAAC,iBAAiB,EAAE,kBAAkB,EAAE,iBAAiB,CAAC;CACvH"}

package/dist/__tests__/UseQueries/Provider.svelte

@@ -0,0 +1,11 @@
+<script>import PersistQueryClientProvider from "../../PersistQueryClientProvider.svelte";
+import UseQueries from "./UseQueries.svelte";
+export let queryClient;
+export let persistOptions;
+export let key;
+export let states;
+</script>
+
+<PersistQueryClientProvider client={queryClient} {persistOptions}>
+  <UseQueries {key} {states} />
+</PersistQueryClientProvider>

package/dist/__tests__/UseQueries/Provider.svelte.d.ts

@@ -0,0 +1,24 @@
+import { SvelteComponentTyped } from "svelte";
+import type { QueryClient } from '@tanstack/svelte-query';
+import type { PersistQueryClientOptions } from '@tanstack/query-persist-client-core';
+import type { Writable } from 'svelte/store';
+import type { StatusResult } from '../utils';
+declare const __propDef: {
+    props: {
+        queryClient: QueryClient;
+        persistOptions: Omit<PersistQueryClientOptions, 'queryClient'>;
+        key: Array<string>;
+        states: Writable<Array<StatusResult<string>>>;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type ProviderProps = typeof __propDef.props;
+export type ProviderEvents = typeof __propDef.events;
+export type ProviderSlots = typeof __propDef.slots;
+export default class Provider extends SvelteComponentTyped<ProviderProps, ProviderEvents, ProviderSlots> {
+}
+export {};
+//# sourceMappingURL=Provider.svelte.d.ts.map

package/dist/__tests__/UseQueries/Provider.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Provider.svelte.d.ts","sourceRoot":"","sources":["../../../../src/__tests__/UseQueries/Provider.svelte"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAE5C;AAGD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AACzD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,qCAAqC,CAAA;AACpF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAsB5C,QAAA,MAAM,SAAS;;qBAD0G,WAAW;wBAAkB,KAAK,yBAAyB,EAAE,aAAa,CAAC;aAAO,MAAM,MAAM,CAAC;gBAAU,SAAS,MAAM,aAAa,MAAM,CAAC,CAAC,CAAC;;;;;;CAChN,CAAC;AACxD,MAAM,MAAM,aAAa,GAAG,OAAO,SAAS,CAAC,KAAK,CAAC;AACnD,MAAM,MAAM,cAAc,GAAG,OAAO,SAAS,CAAC,MAAM,CAAC;AACrD,MAAM,MAAM,aAAa,GAAG,OAAO,SAAS,CAAC,KAAK,CAAC;AAEnD,MAAM,CAAC,OAAO,OAAO,QAAS,SAAQ,oBAAoB,CAAC,aAAa,EAAE,cAAc,EAAE,aAAa,CAAC;CACvG"}

package/dist/__tests__/UseQueries/UseQueries.svelte

@@ -0,0 +1,32 @@
+<script>import { createQueries } from "@tanstack/svelte-query";
+import { get } from "svelte/store";
+import { sleep } from "../utils";
+export let key;
+export let states;
+const state = createQueries({
+  queries: [
+    {
+      queryKey: key,
+      queryFn: async () => {
+        await sleep(10);
+        return "fetched";
+      }
+    }
+  ]
+});
+let data = get(state)[0].data;
+let fetchStatus = get(state)[0].fetchStatus;
+state.subscribe(([s]) => {
+  states.update((prev) => [
+    ...prev,
+    { status: s.status, data: s.data, fetchStatus: s.fetchStatus }
+  ]);
+  data = s.data;
+  fetchStatus = s.fetchStatus;
+});
+</script>
+
+<div>
+  <h1>{data}</h1>
+  <h2>fetchStatus: {fetchStatus}</h2>
+</div>

package/dist/__tests__/UseQueries/UseQueries.svelte.d.ts

@@ -0,0 +1,20 @@
+import { SvelteComponentTyped } from "svelte";
+import type { Writable } from 'svelte/store';
+import type { StatusResult } from '../utils';
+declare const __propDef: {
+    props: {
+        key: Array<string>;
+        states: Writable<Array<StatusResult<string>>>;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type UseQueriesProps = typeof __propDef.props;
+export type UseQueriesEvents = typeof __propDef.events;
+export type UseQueriesSlots = typeof __propDef.slots;
+export default class UseQueries extends SvelteComponentTyped<UseQueriesProps, UseQueriesEvents, UseQueriesSlots> {
+}
+export {};
+//# sourceMappingURL=UseQueries.svelte.d.ts.map

package/dist/__tests__/UseQueries/UseQueries.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UseQueries.svelte.d.ts","sourceRoot":"","sources":["../../../../src/__tests__/UseQueries/UseQueries.svelte"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAE5C;AAID,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AA2C5C,QAAA,MAAM,SAAS;;aADsC,MAAM,MAAM,CAAC;gBAAU,SAAS,MAAM,aAAa,MAAM,CAAC,CAAC,CAAC;;;;;;CAC1D,CAAC;AACxD,MAAM,MAAM,eAAe,GAAG,OAAO,SAAS,CAAC,KAAK,CAAC;AACrD,MAAM,MAAM,gBAAgB,GAAG,OAAO,SAAS,CAAC,MAAM,CAAC;AACvD,MAAM,MAAM,eAAe,GAAG,OAAO,SAAS,CAAC,KAAK,CAAC;AAErD,MAAM,CAAC,OAAO,OAAO,UAAW,SAAQ,oBAAoB,CAAC,eAAe,EAAE,gBAAgB,EAAE,eAAe,CAAC;CAC/G"}

package/dist/__tests__/utils.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { QueryClient } from '@tanstack/svelte-query';
+import type { QueryClientConfig } from '@tanstack/svelte-query';
+export declare function createQueryClient(config?: QueryClientConfig): QueryClient;
+export declare function queryKey(): Array<string>;
+export declare function sleep(timeout: number): Promise<void>;
+export declare function setActTimeout(fn: () => void, ms?: number): NodeJS.Timeout;
+export type StatusResult<T = unknown> = {
+    status: string;
+    fetchStatus: string;
+    data: T | undefined;
+};
+//# sourceMappingURL=utils.d.ts.map

package/dist/__tests__/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/__tests__/utils.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAGpD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAE/D,wBAAgB,iBAAiB,CAAC,MAAM,CAAC,EAAE,iBAAiB,GAAG,WAAW,CAEzE;AAGD,wBAAgB,QAAQ,IAAI,KAAK,CAAC,MAAM,CAAC,CAGxC;AAED,wBAAgB,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAIpD;AAED,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,IAAI,EAAE,EAAE,CAAC,EAAE,MAAM,kBAMxD;AAED,MAAM,MAAM,YAAY,CAAC,CAAC,GAAG,OAAO,IAAI;IACtC,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,CAAC,GAAG,SAAS,CAAA;CACpB,CAAA"}

package/dist/__tests__/utils.js

@@ -0,0 +1,22 @@
+import { QueryClient } from '@tanstack/svelte-query';
+import { act } from '@testing-library/svelte';
+export function createQueryClient(config) {
+    return new QueryClient(config);
+}
+let queryKeyCount = 0;
+export function queryKey() {
+    queryKeyCount++;
+    return [`query_${queryKeyCount}`];
+}
+export function sleep(timeout) {
+    return new Promise((resolve, _reject) => {
+        setTimeout(resolve, timeout);
+    });
+}
+export function setActTimeout(fn, ms) {
+    return setTimeout(() => {
+        act(() => {
+            fn();
+        });
+    }, ms);
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from '@tanstack/query-persist-client-core';
+export { default as PersistQueryClientProvider } from './PersistQueryClientProvider.svelte';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,cAAc,qCAAqC,CAAA;AACnD,OAAO,EAAE,OAAO,IAAI,0BAA0B,EAAE,MAAM,qCAAqC,CAAA"}

package/dist/index.js

@@ -0,0 +1,3 @@
+// Re-export core
+export * from '@tanstack/query-persist-client-core';
+export { default as PersistQueryClientProvider } from './PersistQueryClientProvider.svelte';