@kubb/plugin-swr 3.0.0-alpha.9 → 3.0.0-beta.2

package/src/components/SchemaType.tsx

@@ -1,63 +0,0 @@
-import { File, Type, useApp } from '@kubb/react'
-
-import { useOperation, useOperationManager } from '@kubb/plugin-oas/hooks'
-import { pluginTsName } from '@kubb/plugin-ts'
-import type { ReactNode } from 'react'
-import type { PluginSwr } from '../types.ts'
-
-type Props = {
-  factory: {
-    name: string
-  }
-}
-
-export function SchemaType({ factory }: Props): ReactNode {
-  const {
-    plugin: {
-      options: { dataReturnType },
-    },
-  } = useApp<PluginSwr>()
-  const { getSchemas } = useOperationManager()
-  const operation = useOperation()
-
-  const schemas = getSchemas(operation, { pluginKey: [pluginTsName], type: 'type' })
-
-  const [TData, TError, TRequest, TPathParams, TQueryParams, THeaderParams, TResponse] = [
-    schemas.response.name,
-    schemas.errors?.map((item) => item.name).join(' | ') || 'never',
-    schemas.request?.name || 'never',
-    schemas.pathParams?.name || 'never',
-    schemas.queryParams?.name || 'never',
-    schemas.headerParams?.name || 'never',
-    schemas.response.name,
-  ]
-
-  const clientType = `${factory.name}Client`
-
-  return (
-    <>
-      <File.Source name={clientType} isTypeOnly>
-        <Type name={clientType}>{`typeof client<${TResponse}, ${TError}, ${TRequest}>`}</Type>
-      </File.Source>
-      <File.Source name={factory.name} isTypeOnly>
-        <Type name={factory.name}>
-          {`
-        {
-          data: ${TData}
-          error: ${TError}
-          request: ${TRequest}
-          pathParams: ${TPathParams}
-          queryParams: ${TQueryParams}
-          headerParams: ${THeaderParams}
-          response: ${dataReturnType === 'data' ? TData : `Awaited<ReturnType<${clientType}>>`}
-          client: {
-            parameters: Partial<Parameters<${clientType}>[0]>
-            return: Awaited<ReturnType<${clientType}>>
-          }
-        }
-        `}
-        </Type>
-      </File.Source>
-    </>
-  )
-}

package/src/components/__snapshots__/Mutation/Pets.ts

@@ -1,46 +0,0 @@
-type CreatePetsClient = typeof client<CreatePetsMutationResponse, never, CreatePetsMutationRequest>
-
-type CreatePets = 
-            {
-              data: CreatePetsMutationResponse
-              error: never
-              request: CreatePetsMutationRequest
-              pathParams: never
-              queryParams: never
-              headerParams: never
-              response: CreatePetsMutationResponse
-              client: {
-                parameters: Partial<Parameters<CreatePetsClient>[0]>
-                return: Awaited<ReturnType<CreatePetsClient>>
-              }
-            }
-
-/**
- * @summary Create a pet
- * @link /pets
- */
-export function useCreatePets(options?: {
-            mutation?: SWRMutationConfiguration<CreatePets["response"], CreatePets["error"]>,
-            client?: CreatePets['client']['parameters'],
-            shouldFetch?: boolean,
-          }): SWRMutationResponse<CreatePets["response"], CreatePets["error"]> {
-  
-           const { mutation: mutationOptions, client: clientOptions = {}, shouldFetch = true } = options ?? {}
-    
-           const url = `/pets` as const
-           return useSWRMutation<CreatePets["response"], CreatePets["error"], typeof url | null>(
-            shouldFetch ? url : null,
-            async (_url, { arg: data }) => {
-              const res = await client<CreatePets["data"], CreatePets["error"], CreatePets["request"]>({
-                    method: "post",
-        url,
-        data,
-        ...clientOptions
-              })
-    
-              return res.data
-            },
-            mutationOptions
-          )
-        
-}

package/src/components/__snapshots__/Query/showPetById.ts

@@ -1,59 +0,0 @@
-type ShowPetByIdClient = typeof client<ShowPetByIdQueryResponse, never, never>
-
-type ShowPetById = 
-            {
-              data: ShowPetByIdQueryResponse
-              error: never
-              request: never
-              pathParams: ShowPetByIdPathParams
-              queryParams: never
-              headerParams: never
-              response: ShowPetByIdQueryResponse
-              client: {
-                parameters: Partial<Parameters<ShowPetByIdClient>[0]>
-                return: Awaited<ReturnType<ShowPetByIdClient>>
-              }
-            }
-
-export function ShowPetByIdQueryOptions<TData = ShowPetById['response']>(petId: ShowPetByIdPathParams["petId"], testId: ShowPetByIdPathParams["testId"], options: ShowPetById['client']['parameters'] = {}): SWRConfiguration<TData, ShowPetById['error']> {
-  
-          return {
-            fetcher: async () => {
-              
-              const res = await client<TData, ShowPetById['error']>({
-                    method: "get",
-        url: `/pets/${petId}`,
-        ...options
-              })
-    
-             return res.data
-            },
-          }
-    
-           
-}
-
-/**
- * @summary Info for a specific pet
- * @link /pets/:petId
- */
-export function useShowPetById<TData = ShowPetById["response"]>(petId: ShowPetByIdPathParams["petId"], testId: ShowPetByIdPathParams["testId"], options?: {
-            query?: SWRConfiguration<TData, ShowPetById["error"]>,
-            client?: ShowPetById['client']['parameters'],
-            shouldFetch?: boolean,
-          }): SWRResponse<TData, ShowPetById["error"]> {
-  
-           const { query: queryOptions, client: clientOptions = {}, shouldFetch = true } = options ?? {}
-    
-           const url = `/pets/${petId}`
-           const query = useSWR<TData, ShowPetById["error"], typeof url | null>(
-            shouldFetch ? url : null,
-            {
-              ...ShowPetByIdQueryOptions<TData>(petId, testId, clientOptions),
-              ...queryOptions
-            }
-           )
-    
-           return query
-           
-}