docs(guides): fix docs

Author: amen-souissi

docs/src/pages/guides/initial-query-data.md

@@ -6,7 +6,7 @@ title: Initial Query Data
 There are many ways to supply initial data for a query to the cache before you need it:
 
 - Declaratively:
-  - Provide `initialData` to a query to prepopulate the its cache if empty
+  - Provide `initialData` to a query to prepopulate its cache if empty
 - Imperatively:
   - [Prefetch the data using `queryClient.prefetchQuery`](../prefetching)
   - [Manually place the data into the cache using `queryClient.setQueryData`](../prefetching)
@@ -42,7 +42,7 @@ By default, `initialData` is treated as totally fresh, as if it were just fetche
 
   ```js
   function Todos() {
-    // Show initialTodos immeidately, but won't refetch until another interaction event is encountered after 1000 ms
+    // Show initialTodos immediately, but won't refetch until another interaction event is encountered after 1000 ms
     return useQuery('todos', () => fetch('/todos'), {
       initialData: initialTodos,
       staleTime: 1000,
@@ -53,7 +53,7 @@ By default, `initialData` is treated as totally fresh, as if it were just fetche
 - So what if your `initialData` isn't totally fresh? That leaves us with the last configuration that is actually the most accurate and uses an option called `initialDataUpdatedAt`. This options allows you to pass a numeric JS timestamp in milliseconds of when the initialData itself was last updated, e.g. what `Date.now()` provides. Take note that if you have a unix timestamp, you'll need to convert it to a JS timestamp by multiplying it by `1000`.
   ```js
   function Todos() {
-    // Show initialTodos immeidately, but won't refetch until another interaction event is encountered after 1000 ms
+    // Show initialTodos immediately, but won't refetch until another interaction event is encountered after 1000 ms
     return useQuery('todos', () => fetch('/todos'), {
       initialData: initialTodos,
       staleTime: 60 * 1000 // 1 minute

docs/src/pages/guides/mutations.md

@@ -5,7 +5,7 @@ title: Mutations
 
 Unlike queries, mutations are typically used to create/update/delete data or perform server side-effects. For this purpose, Svelte Query exports a `useMutation` hook.
 
-Here's an example of a mutation that adds a new todo the server:
+Here's an example of a mutation that adds a new todo to the server:
 
 ```markdown
 <script>
@@ -214,7 +214,7 @@ const queryClient = new QueryClient()
 // Define the "addTodo" mutation
 queryClient.setMutationDefaults('addTodo', {
   mutationFn: addTodo,
-  onMutate: variables => {
+  onMutate: async (variables) => {
     // Cancel current queries for the todos list
     await queryClient.cancelQueries('todos')
 

docs/src/pages/guides/placeholder-query-data.md

@@ -12,7 +12,7 @@ Placeholder data allows a query to behave as if it already has data, similar to
 There are a few ways to supply placeholder data for a query to the cache before you need it:
 
 - Declaratively:
-  - Provide `placeholderData` to a query to prepopulate the its cache if empty
+  - Provide `placeholderData` to a query to prepopulate its cache if empty
 - Imperatively:
   - [Prefetch or fetch the data using `queryClient` and the `placeholderData` option](../prefetching)
 

docs/src/pages/guides/query-invalidation.md

@@ -17,7 +17,7 @@ queryClient.invalidateQueries('todos')
 When a query is invalidated with `invalidateQueries`, two things happen:
 
 - It is marked as stale. This stale state overrides any `staleTime` configurations being used in `useQuery` or related hooks
-- If the query is currently being rendered via `useQuery` or related hooks), it will also be refetched in the background
+- If the query is currently being rendered via `useQuery` or related hooks, it will also be refetched in the background
 
 ## Query Matching with `invalidateQueries`
 

docs/src/pages/reference/QueryClient.md

@@ -23,8 +23,10 @@ await queryClient.prefetchQuery('posts', fetchPosts)
 
 Its available methods are:
 
-- [`fetchQuery`](#queryclientfetchquerydata)
+- [`fetchQuery`](#queryclientfetchquery)
+- [`fetchInfiniteQuery`](#queryclientfetchinfinitequery)
 - [`prefetchQuery`](#queryclientprefetchquery)
+- [`prefetchInfiniteQuery`](#queryclientprefetchinfinitequery)
 - [`getQueryData`](#queryclientgetquerydata)
 - [`setQueryData`](#queryclientsetquerydata)
 - [`getQueryState`](#queryclientgetquerystate)
@@ -86,12 +88,33 @@ try {
 
 **Options**
 
-The options for `fetchQuery` are exactly the same as those of [`useQuery`](#usequery).
+The options for `fetchQuery` are exactly the same as those of [`useQuery`](./useQuery), except the following: `enabled, refetchInterval, refetchIntervalInBackground, refetchOnWindowFocus, refetchOnReconnect, notifyOnChangeProps, notifyOnChangePropsExclusions, onSuccess, onError, onSettled, useErrorBoundary, select, suspense, keepPreviousData, placeholderData`; which are stictly for useQuery and useInfiniteQuery. You can check the [source code](https://github.com/TanStack/svelte-query/blob/864cd6e31b19cea5483d1809d6e3afc1499b48d6/src/queryCore/core/types.ts#L83) for more clarity.
 
 **Returns**
 
 - `Promise<TData>`
 
+## `queryClient.fetchInfiniteQuery`
+
+`fetchInfiniteQuery` is similar to `fetchQuery` but can be used to fetch and cache an infinite query.
+
+```js
+try {
+  const data = await queryClient.fetchInfiniteQuery(queryKey, queryFn)
+  console.log(data.pages)
+} catch (error) {
+  console.log(error)
+}
+```
+
+**Options**
+
+The options for `fetchInfiniteQuery` are exactly the same as those of [`fetchQuery`](#queryclientfetchquery).
+
+**Returns**
+
+- `Promise<InfiniteData<TData>>`
+
 ## `queryClient.prefetchQuery`
 
 `prefetchQuery` is an asynchronous method that can be used to prefetch a query before it is needed or rendered with `useQuery` and friends. The method works the same as `fetchQuery` except that is will not throw or return any data.
@@ -108,7 +131,24 @@ await queryClient.prefetchQuery(queryKey)
 
 **Options**
 
-The options for `prefetchQuery` are exactly the same as those of [`useQuery`](#usequery).
+The options for `prefetchQuery` are exactly the same as those of [`fetchQuery`](#queryclientfetchquery).
+
+**Returns**
+
+- `Promise<void>`
+  - A promise is returned that will either immediately resolve if no fetch is needed or after the query has been executed. It will not return any data or throw any errors.
+
+## `queryClient.prefetchInfiniteQuery`
+
+`prefetchInfiniteQuery` is similar to `prefetchQuery` but can be used to prefetch and cache an infinite query.
+
+```js
+await queryClient.prefetchInfiniteQuery(queryKey, queryFn)
+```
+
+**Options**
+
+The options for `prefetchInfiniteQuery` are exactly the same as those of [`fetchQuery`](#queryclientfetchquery).
 
 **Returns**
 
@@ -270,13 +310,10 @@ queryClient.removeQueries(queryKey, { exact: true })
 
 - `queryKey?: QueryKey`: [Query Keys](../guides/query-keys)
 - `filters?: QueryFilters`: [Query Filters](../guides/query-filters)
-- `resetOptions?: ResetOptions`:
-  - `throwOnError?: boolean`
-    - When set to `true`, this method will throw if any of the query refetch tasks fail.
 
 **Returns**
 
-This method returns a promise that resolves when all active queries have been refetched.
+This method does not return anything
 
 ## `queryClient.resetQueries`
 
@@ -297,10 +334,13 @@ queryClient.resetQueries(queryKey, { exact: true })
 
 - `queryKey?: QueryKey`: [Query Keys](../guides/query-keys)
 - `filters?: QueryFilters`: [Query Filters](../guides/query-filters)
+- `resetOptions?: ResetOptions`:
+  - `throwOnError?: boolean`
+    - When set to `true`, this method will throw if any of the query refetch tasks fail.
 
 **Returns**
 
-This method does not return anything
+This method returns a promise that resolves when all active queries have been refetched.
 
 ## `queryClient.isFetching`
 
@@ -415,4 +455,4 @@ The `clear` method clears all connected caches.
 
 ```js
 queryClient.clear()
-```
+```

package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sveltestack/svelte-query",
   "private": false,
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Hooks for managing, caching and syncing asynchronous and remote data in Svelte",
   "license": "MIT",
   "svelte": "svelte/index.js",

src/queryCore/core/query.ts

@@ -171,7 +171,7 @@ export class Query<
     this.clearGcTimeout()
 
     if (isValidTimeout(this.cacheTime)) {
-     // @ts-ignore
+      // @ts-ignore
       this.gcTimeout = setTimeout(() => {
         this.optionalRemove()
       }, this.cacheTime)
@@ -465,18 +465,18 @@ export class Query<
 
     const hasInitialData = typeof options.initialData !== 'undefined'
 
-    const initialDataUpdatedAt =
-      hasInitialData &&
-      (typeof options.initialDataUpdatedAt === 'function'
+    const initialDataUpdatedAt = hasInitialData
+      ? typeof options.initialDataUpdatedAt === 'function'
         ? (options.initialDataUpdatedAt as () => number | undefined)()
-        : options.initialDataUpdatedAt)
+        : options.initialDataUpdatedAt
+      : 0
 
     const hasData = typeof data !== 'undefined'
 
     return {
       data,
       dataUpdateCount: 0,
-      dataUpdatedAt: hasData ? initialDataUpdatedAt || Date.now() : 0,
+      dataUpdatedAt: hasData ? initialDataUpdatedAt ?? Date.now() : 0,
       error: null,
       errorUpdateCount: 0,
       errorUpdatedAt: 0,