Merge pull request TanStack#3 from ardeora/luke/reformat

reformat with prettier

packages/solid-query/src/QueryClientProvider.tsx

@@ -1,48 +1,56 @@
-import type { QueryClient } from "@tanstack/query-core";
-import { Component, Context, createContext, useContext, JSX, onMount, onCleanup } from "solid-js";
-import { ContextOptions } from "./types";
+import type { QueryClient } from '@tanstack/query-core'
+import {
+  Component,
+  Context,
+  createContext,
+  useContext,
+  JSX,
+  onMount,
+  onCleanup,
+} from 'solid-js'
+import { ContextOptions } from './types'
 
 declare global {
   interface Window {
     SolidQueryClientContext?: Context<QueryClient | undefined>
   }
 }
 
-export const QueryClientContext = createContext<QueryClient>();
+export const QueryClientContext = createContext<QueryClient>()
 export const QueryClientSharingContext = createContext<boolean>(false)
 
 interface Props {
-  client: QueryClient;
-  children: JSX.Element;
+  client: QueryClient
+  children: JSX.Element
 }
 
 // Simple Query Client Context Provider
 export const QueryClientProvider: Component<Props> = (props) => {
   if (!props.client) {
-    throw new Error("No queryClient found.");
+    throw new Error('No queryClient found.')
   }
 
-  onMount(() => props.client.mount());
-  onCleanup(() => props.client.unmount());
+  onMount(() => props.client.mount())
+  onCleanup(() => props.client.unmount())
 
   return (
     <QueryClientContext.Provider value={props.client}>
       {props.children}
     </QueryClientContext.Provider>
-  );
-};
+  )
+}
 
 function getQueryClientContext(
   context: Context<QueryClient | undefined> | undefined,
-  contextSharing: boolean
+  contextSharing: boolean,
 ) {
   if (context) {
-    return context;
+    return context
   }
 
   if (contextSharing && typeof window !== 'undefined') {
     if (!window.SolidQueryClientContext) {
-      window.SolidQueryClientContext = QueryClientContext;
+      window.SolidQueryClientContext = QueryClientContext
     }
 
     return window.SolidQueryClientContext
@@ -53,12 +61,12 @@ function getQueryClientContext(
 
 export const useQueryClient = ({ context }: ContextOptions = {}) => {
   const queryClient = useContext(
-    getQueryClientContext(context, useContext(QueryClientSharingContext))
-  );
+    getQueryClientContext(context, useContext(QueryClientSharingContext)),
+  )
 
   if (!queryClient) {
-    throw new Error('No QueryClient set, use QueryClientProvider to set one');
+    throw new Error('No QueryClient set, use QueryClientProvider to set one')
   }
-  
-  return queryClient;
-};
+
+  return queryClient
+}

packages/solid-query/src/createBaseQuery.ts

@@ -1,17 +1,24 @@
 import { QueryObserver } from '@tanstack/query-core'
 import type { QueryKey, QueryObserverResult } from '@tanstack/query-core'
-import {  CreateBaseQueryOptions } from './types'
-import { useQueryClient } from "./QueryClientProvider";
-import { onMount, onCleanup, createComputed, createResource, createEffect, batch } from 'solid-js';
-import { createStore } from 'solid-js/store';
+import { CreateBaseQueryOptions } from './types'
+import { useQueryClient } from './QueryClientProvider'
+import {
+  onMount,
+  onCleanup,
+  createComputed,
+  createResource,
+  createEffect,
+  batch,
+} from 'solid-js'
+import { createStore } from 'solid-js/store'
 
 // Base Query Function that is used to create the query.
 export function createBaseQuery<
   TQueryFnData,
   TError,
   TData,
   TQueryData,
-  TQueryKey extends QueryKey
+  TQueryKey extends QueryKey,
 >(
   options: CreateBaseQueryOptions<
     TQueryFnData,
@@ -20,55 +27,57 @@ export function createBaseQuery<
     TQueryData,
     TQueryKey
   >,
-  Observer: typeof QueryObserver
+  Observer: typeof QueryObserver,
 ): QueryObserverResult<TData, TError> {
-
-  const queryClient = useQueryClient();
+  const queryClient = useQueryClient()
 
   const defaultedOptions = queryClient.defaultQueryOptions(options)
-  defaultedOptions._optimisticResults = 'optimistic';
-  const observer = new QueryObserver(queryClient, defaultedOptions);
+  defaultedOptions._optimisticResults = 'optimistic'
+  const observer = new QueryObserver(queryClient, defaultedOptions)
 
   const [state, setState] = createStore<QueryObserverResult<TData, TError>>(
     // @ts-ignore
     observer.getOptimisticResult(defaultedOptions),
-  );
+  )
 
-  const [ dataResource, { refetch } ] = createResource(() => {
+  const [dataResource, { refetch }] = createResource(() => {
     return new Promise((resolve, reject) => {
       if (state.isSuccess) resolve(state.data)
-      if (state.isError && !state.isFetching) { 
+      if (state.isError && !state.isFetching) {
         throw state.error
       }
     })
-  });
+  })
 
   const unsubscribe = observer.subscribe((result) => {
-    const reconciledResult = result;
+    const reconciledResult = result
     // @ts-ignore
-    setState(reconciledResult);
-    refetch();
-  });
+    setState(reconciledResult)
+    refetch()
+  })
 
-  onCleanup(() => unsubscribe());
+  onCleanup(() => unsubscribe())
 
   onMount(() => {
-    observer.setOptions(defaultedOptions, { listeners: false });
-  });
+    observer.setOptions(defaultedOptions, { listeners: false })
+  })
 
   createComputed(() => {
     const defaultedOptions = queryClient.defaultQueryOptions(options)
     observer.setOptions(defaultedOptions)
   })
 
   const handler = {
-    get(target: QueryObserverResult<TData, TError>, prop: (keyof QueryObserverResult<TData, TError>)): any {
+    get(
+      target: QueryObserverResult<TData, TError>,
+      prop: keyof QueryObserverResult<TData, TError>,
+    ): any {
       if (prop === 'data') {
-        return dataResource();
+        return dataResource()
       }
-      return Reflect.get(target, prop);
-    }
+      return Reflect.get(target, prop)
+    },
   }
 
-  return new Proxy(state, handler) as QueryObserverResult<TData, TError>;
-}
+  return new Proxy(state, handler) as QueryObserverResult<TData, TError>
+}

packages/solid-query/src/createMutation.ts

@@ -11,7 +11,7 @@ import {
   CreateMutationResult,
 } from './types'
 import { createComputed, onCleanup } from 'solid-js'
-import { createStore } from 'solid-js/store';
+import { createStore } from 'solid-js/store'
 
 // HOOK
 export function createMutation<
@@ -82,17 +82,21 @@ export function createMutation<
     options,
   )
 
-  const mutate: CreateMutateFunction<TData, TError, TVariables, TContext> = 
-  (variables, mutateOptions) => {
+  const mutate: CreateMutateFunction<TData, TError, TVariables, TContext> = (
+    variables,
+    mutateOptions,
+  ) => {
     observer.mutate(variables, mutateOptions).catch(noop)
   }
-
-  const [state, setState] = createStore<CreateMutationResult<TData, TError, TVariables, TContext>>({
+
+  const [state, setState] = createStore<
+    CreateMutationResult<TData, TError, TVariables, TContext>
+  >({
     ...observer.getCurrentResult(),
     mutate,
-    mutateAsync: observer.getCurrentResult().mutate
+    mutateAsync: observer.getCurrentResult().mutate,
   })
-    
+
   createComputed(() => {
     const newParsedOptions = parseMutationArgs(arg1, arg2, arg3)
     setOptions(newParsedOptions)
@@ -103,7 +107,7 @@ export function createMutation<
     setState({
       ...result,
       mutate,
-      mutateAsync: result.mutate
+      mutateAsync: result.mutate,
     })
   })
 
@@ -113,4 +117,4 @@ export function createMutation<
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-function
-function noop() {}
+function noop() {}

packages/solid-query/src/createQuery.ts

@@ -1,9 +1,9 @@
-import { QueryObserver, QueryFunction } from '@tanstack/query-core';
+import { QueryObserver, QueryFunction } from '@tanstack/query-core'
 import { CreateQueryOptions, CreateQueryResult, SolidQueryKey } from './types'
 import { createComputed } from 'solid-js'
-import { createStore } from 'solid-js/store';
+import { createStore } from 'solid-js/store'
 import { parseQueryArgs } from './utils'
-import { createBaseQuery } from './createBaseQuery';
+import { createBaseQuery } from './createBaseQuery'
 
 // There are several ways to create a query.
 // 1. createQuery(options: CreateQueryOptions)
@@ -14,56 +14,58 @@ export function createQuery<
   TQueryFnData = unknown,
   TError = unknown,
   TData = TQueryFnData,
-  TQueryKey extends () => readonly unknown[] = SolidQueryKey
+  TQueryKey extends () => readonly unknown[] = SolidQueryKey,
 >(
-  options: CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>
+  options: CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
 ): CreateQueryResult<TData, TError>
 export function createQuery<
   TQueryFnData = unknown,
   TError = unknown,
   TData = TQueryFnData,
-  TQueryKey extends () => readonly unknown[] = SolidQueryKey
+  TQueryKey extends () => readonly unknown[] = SolidQueryKey,
 >(
   queryKey: SolidQueryKey,
   options?: Omit<
     CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
     'queryKey'
-  >
+  >,
 ): CreateQueryResult<TData, TError>
 export function createQuery<
   TQueryFnData = unknown,
   TError = unknown,
   TData = TQueryFnData,
-  TQueryKey extends () => readonly unknown[] = SolidQueryKey
+  TQueryKey extends () => readonly unknown[] = SolidQueryKey,
 >(
   queryKey: TQueryKey,
   queryFn: QueryFunction<TQueryFnData, ReturnType<TQueryKey>>,
   options?: Omit<
     CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
     'queryKey' | 'queryFn'
-  >
+  >,
 ): CreateQueryResult<TData, TError>
 export function createQuery<
   TQueryFnData,
   TError,
   TData = TQueryFnData,
-  TQueryKey extends () => readonly unknown[] = SolidQueryKey
+  TQueryKey extends () => readonly unknown[] = SolidQueryKey,
 >(
   arg1: TQueryKey | CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
   arg2?:
     | QueryFunction<TQueryFnData, ReturnType<TQueryKey>>
     | CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-  arg3?: CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>
+  arg3?: CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
 ): CreateQueryResult<TData, TError> {
   // 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))
+  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);
+  return createBaseQuery(parsedOptions, QueryObserver)
 }

packages/solid-query/src/index.ts

@@ -2,7 +2,7 @@
 export * from '@tanstack/query-core'
 
 // Solid Query
-export * from "./types"
+export * from './types'
 // export { useQueries } from './useQueries'
 // export type { QueriesResults, QueriesOptions } from './useQueries'
 export { createQuery } from './createQuery'