snapshot of https://github.com/TanStack/query.git (main, 2026-09-16; blobs > 131072B omitted)

packages/svelte-query/tests/createQuery/Base.svelte

@@ -0,0 +1,41 @@
+<script lang="ts">
+  import { onDestroy, onMount } from 'svelte'
+  import type { QueryClient } from '@tanstack/query-core'
+  import { createQuery, setQueryClientContext } from '../../src/index.js'
+  import type { Accessor, CreateQueryOptions } from '../../src/index.js'
+
+  type Props = {
+    queryClient: QueryClient
+    options: Accessor<CreateQueryOptions>
+  }
+
+  let { queryClient, options }: Props = $props()
+
+  setQueryClientContext(queryClient)
+
+  // QueryClientProvider normally mounts/unmounts the client; since this fixture
+  // sets the context directly, do it manually so focus/online refetching works
+  onMount(() => queryClient.mount())
+  onDestroy(() => queryClient.unmount())
+
+  const query = createQuery(options)
+</script>
+
+<button onclick={() => query.refetch()}>refetch</button>
+<button onclick={() => query.refetch({ cancelRefetch: false })}>
+  refetch no cancel
+</button>
+
+<div data-testid="status">{query.status}</div>
+<div data-testid="fetchStatus">{query.fetchStatus}</div>
+<div data-testid="data">{query.data ?? 'undefined'}</div>
+<div data-testid="dataUpdatedAt">{query.dataUpdatedAt}</div>
+<div data-testid="error">
+  {(query.error as Error | null)?.message ?? 'null'}
+</div>
+<div data-testid="isFetched">{query.isFetched}</div>
+<div data-testid="isFetchedAfterMount">{query.isFetchedAfterMount}</div>
+<div data-testid="isStale">{query.isStale}</div>
+<div data-testid="isFetching">{query.isFetching}</div>
+<div data-testid="isSuccess">{query.isSuccess}</div>
+<div data-testid="isPlaceholderData">{query.isPlaceholderData}</div>

packages/svelte-query/tests/createQuery/Counter.svelte

@@ -0,0 +1,29 @@
+<script lang="ts">
+  import type { QueryClient } from '@tanstack/query-core'
+  import { createQuery, setQueryClientContext } from '../../src/index.js'
+  import type { CreateQueryOptions } from '../../src/index.js'
+
+  type Props = {
+    queryClient: QueryClient
+    startCount?: number
+    options: (count: number) => CreateQueryOptions<number, Error>
+  }
+
+  let { queryClient, startCount = 0, options }: Props = $props()
+
+  let count = $state(startCount)
+
+  setQueryClientContext(queryClient)
+
+  const query = createQuery<number, Error>(() => options(count))
+</script>
+
+<button onclick={() => count++}>increment</button>
+<button onclick={() => query.refetch()}>refetch</button>
+
+<div data-testid="data">{query.data ?? 'undefined'}</div>
+<div data-testid="status">{query.status}</div>
+<div data-testid="fetchStatus">{query.fetchStatus}</div>
+<div data-testid="isFetching">{query.isFetching}</div>
+<div data-testid="isSuccess">{query.isSuccess}</div>
+<div data-testid="isPlaceholderData">{query.isPlaceholderData}</div>

packages/svelte-query/tests/createQuery/IsRestoring.svelte

@@ -0,0 +1,30 @@
+<script lang="ts">
+  import type { QueryClient } from '@tanstack/query-core'
+  import { queryKey } from '@tanstack/query-test-utils'
+  import {
+    setIsRestoringContext,
+    setQueryClientContext,
+  } from '../../src/context.js'
+  import { createQuery } from '../../src/index.js'
+
+  type Props = {
+    queryClient: QueryClient
+    queryFn: () => Promise<string>
+  }
+
+  let { queryClient, queryFn }: Props = $props()
+
+  setQueryClientContext(queryClient)
+  setIsRestoringContext({ current: true })
+
+  const query = createQuery(() => ({
+    queryKey: queryKey(),
+    queryFn,
+  }))
+</script>
+
+<div>
+  <div data-testid="status">{query.status}</div>
+  <div data-testid="fetchStatus">{query.fetchStatus}</div>
+  <div data-testid="data">{query.data ?? 'undefined'}</div>
+</div>

packages/svelte-query/tests/createQuery/Select.svelte

@@ -0,0 +1,24 @@
+<script lang="ts">
+  import type { QueryClient } from '@tanstack/query-core'
+  import { createQuery, setQueryClientContext } from '../../src/index.js'
+  import type { Accessor, CreateQueryOptions } from '../../src/index.js'
+
+  type Data = { name: string }
+
+  type Props = {
+    queryClient: QueryClient
+    options: Accessor<CreateQueryOptions<Data, Error, string>>
+  }
+
+  let { queryClient, options }: Props = $props()
+
+  setQueryClientContext(queryClient)
+
+  const query = createQuery<Data, Error, string>(options)
+</script>
+
+<div data-testid="status">{query.status}</div>
+<div data-testid="data">{query.data ?? 'undefined'}</div>
+<div data-testid="error">
+  {(query.error as Error | null)?.message ?? 'null'}
+</div>

packages/svelte-query/tests/createQuery/TwoQueries.svelte

@@ -0,0 +1,34 @@
+<script lang="ts">
+  import { onDestroy, onMount } from 'svelte'
+  import type { QueryClient } from '@tanstack/query-core'
+  import { createQuery, setQueryClientContext } from '../../src/index.js'
+  import type { Accessor, CreateQueryOptions } from '../../src/index.js'
+
+  type Props = {
+    queryClient: QueryClient
+    options1: Accessor<CreateQueryOptions>
+    options2: Accessor<CreateQueryOptions>
+  }
+
+  let { queryClient, options1, options2 }: Props = $props()
+
+  setQueryClientContext(queryClient)
+
+  onMount(() => queryClient.mount())
+  onDestroy(() => queryClient.unmount())
+
+  const query1 = createQuery(options1)
+  const query2 = createQuery(options2)
+</script>
+
+<button onclick={() => query1.refetch()}>refetch1</button>
+
+<div data-testid="status1">{query1.status}</div>
+<div data-testid="fetchStatus1">{query1.fetchStatus}</div>
+<div data-testid="data1">{query1.data ?? 'undefined'}</div>
+<div data-testid="isStale1">{query1.isStale}</div>
+
+<div data-testid="status2">{query2.status}</div>
+<div data-testid="fetchStatus2">{query2.fetchStatus}</div>
+<div data-testid="data2">{query2.data ?? 'undefined'}</div>
+<div data-testid="isStale2">{query2.isStale}</div>

packages/svelte-query/tests/createQuery/createQuery.test-d.ts

@@ -0,0 +1,136 @@
+import { describe, expectTypeOf, it } from 'vitest'
+import { queryKey } from '@tanstack/query-test-utils'
+import { createQuery, queryOptions } from '../../src/index.js'
+
+describe('createQuery', () => {
+  it('should return the correct states for a successful query', () => {
+    const key = queryKey()
+    const query = createQuery<string, Error>(() => ({
+      queryKey: key,
+      queryFn: () => Promise.resolve('test'),
+    }))
+
+    if (query.isPending) {
+      expectTypeOf(query.data).toEqualTypeOf<undefined>()
+      expectTypeOf(query.error).toEqualTypeOf<null>()
+    } else if (query.isLoadingError) {
+      expectTypeOf(query.data).toEqualTypeOf<undefined>()
+      expectTypeOf(query.error).toEqualTypeOf<Error>()
+    } else {
+      expectTypeOf(query.data).toEqualTypeOf<string>()
+      expectTypeOf(query.error).toEqualTypeOf<Error | null>()
+    }
+  })
+
+  describe('initialData', () => {
+    describe('Config object overload', () => {
+      it('TData should always be defined when initialData is provided as an object', () => {
+        const key = queryKey()
+        const { data } = createQuery(() => ({
+          queryKey: key,
+          queryFn: () => ({ wow: true }),
+          initialData: { wow: true },
+        }))
+
+        expectTypeOf(data).toEqualTypeOf<{ wow: boolean }>()
+      })
+
+      it('TData should be defined when passed through queryOptions', () => {
+        const key = queryKey()
+        const options = queryOptions({
+          queryKey: key,
+          queryFn: () => ({ wow: true }),
+          initialData: { wow: true },
+        })
+        const { data } = createQuery(() => options)
+
+        expectTypeOf(data).toEqualTypeOf<{ wow: boolean }>()
+      })
+
+      it('TData should have undefined in the union when initialData is NOT provided', () => {
+        const key = queryKey()
+        const { data } = createQuery(() => ({
+          queryKey: key,
+          queryFn: () => ({ wow: true }),
+        }))
+
+        expectTypeOf(data).toEqualTypeOf<{ wow: boolean } | undefined>()
+      })
+
+      it('TData should have undefined in the union when initialData is provided as a function which can return undefined', () => {
+        const key = queryKey()
+        const { data } = createQuery(() => ({
+          queryKey: key,
+          queryFn: () => ({ wow: true }),
+          initialData: () => undefined as { wow: boolean } | undefined,
+        }))
+
+        expectTypeOf(data).toEqualTypeOf<{ wow: boolean } | undefined>()
+      })
+    })
+
+    describe('Query key overload', () => {
+      it('TData should always be defined when initialData is provided', () => {
+        const key = queryKey()
+        const { data } = createQuery(() => ({
+          queryKey: key,
+          queryFn: () => ({ wow: true }),
+          initialData: { wow: true },
+        }))
+
+        expectTypeOf(data).toEqualTypeOf<{ wow: boolean }>()
+      })
+
+      it('TData should have undefined in the union when initialData is NOT provided', () => {
+        const key = queryKey()
+        const { data } = createQuery(() => ({
+          queryKey: key,
+          queryFn: () => ({ wow: true }),
+        }))
+
+        expectTypeOf(data).toEqualTypeOf<{ wow: boolean } | undefined>()
+      })
+    })
+
+    describe('Query key and func', () => {
+      it('TData should always be defined when initialData is provided', () => {
+        const key = queryKey()
+        const { data } = createQuery(() => ({
+          queryKey: key,
+          queryFn: () => ({ wow: true }),
+          initialData: { wow: true },
+        }))
+
+        expectTypeOf(data).toEqualTypeOf<{ wow: boolean }>()
+      })
+
+      it('TData should have undefined in the union when initialData is NOT provided', () => {
+        const key = queryKey()
+        const { data } = createQuery(() => ({
+          queryKey: key,
+          queryFn: () => ({ wow: true }),
+        }))
+
+        expectTypeOf(data).toEqualTypeOf<{ wow: boolean } | undefined>()
+      })
+    })
+  })
+
+  describe('generic queryFn', () => {
+    it('should infer the result type from a generic query function', () => {
+      const key = queryKey()
+
+      function queryFn<T = string>(): Promise<T> {
+        return Promise.resolve({} as T)
+      }
+
+      const query = createQuery(() => ({
+        queryKey: key,
+        queryFn: () => queryFn(),
+      }))
+
+      expectTypeOf(query.data).toEqualTypeOf<string | undefined>()
+      expectTypeOf(query.error).toEqualTypeOf<Error | null>()
+    })
+  })
+})