@kubb/plugin-swr 5.0.0-alpha.9 → 5.0.0-beta.103

package/dist/types-BIaGRPjD.d.ts

@@ -1,210 +0,0 @@
-import { t as __name } from "./chunk--u3MIqq1.js";
-import { Group, Output, PluginFactoryOptions, ResolveNameParams } from "@kubb/core";
-import { ClientImportPath, PluginClient } from "@kubb/plugin-client";
-import { Exclude, Include, OperationSchemas, Override, ResolvePathOptions } from "@kubb/plugin-oas";
-import { HttpMethod, Oas, Operation, contentType } from "@kubb/oas";
-import { FunctionParams } from "@kubb/react-fabric";
-import { Generator as Generator$1 } from "@kubb/plugin-oas/generators";
-import { FabricReactNode } from "@kubb/react-fabric/types";
-
-//#region ../../internals/tanstack-query/src/types.d.ts
-type ParamsCasing = 'camelcase' | undefined;
-type PathParamsType = 'object' | 'inline';
-type TransformerProps = {
-  operation: Operation;
-  schemas: OperationSchemas;
-  casing: ParamsCasing;
-};
-type Transformer = (props: TransformerProps) => unknown[];
-//#endregion
-//#region ../../internals/tanstack-query/src/components/MutationKey.d.ts
-type Props$1 = {
-  name: string;
-  typeName: string;
-  typeSchemas: OperationSchemas;
-  operation: Operation;
-  paramsCasing: ParamsCasing;
-  pathParamsType: PathParamsType;
-  transformer: Transformer | undefined;
-};
-type GetParamsProps$1 = {
-  pathParamsType: PathParamsType;
-  typeSchemas: OperationSchemas;
-};
-declare function MutationKey$1({
-  name,
-  typeSchemas,
-  pathParamsType,
-  paramsCasing,
-  operation,
-  typeName,
-  transformer
-}: Props$1): FabricReactNode;
-declare namespace MutationKey$1 {
-  var getParams: ({}: GetParamsProps$1) => FunctionParams;
-  var getTransformer: Transformer;
-}
-//#endregion
-//#region ../../internals/tanstack-query/src/components/QueryKey.d.ts
-type Props = {
-  name: string;
-  typeName: string;
-  typeSchemas: OperationSchemas;
-  operation: Operation;
-  paramsCasing: ParamsCasing;
-  pathParamsType: PathParamsType;
-  transformer: Transformer | undefined;
-};
-type GetParamsProps = {
-  paramsCasing: ParamsCasing;
-  pathParamsType: PathParamsType;
-  typeSchemas: OperationSchemas;
-};
-declare function QueryKey$1({
-  name,
-  typeSchemas,
-  paramsCasing,
-  pathParamsType,
-  operation,
-  typeName,
-  transformer
-}: Props): FabricReactNode;
-declare namespace QueryKey$1 {
-  var getParams: ({
-    pathParamsType,
-    paramsCasing,
-    typeSchemas
-  }: GetParamsProps) => FunctionParams;
-  var getTransformer: Transformer;
-}
-//#endregion
-//#region src/types.d.ts
-/**
- * Customize the queryKey
- */
-type QueryKey = Transformer;
-/**
- * Customize the mutationKey
- */
-type MutationKey = Transformer;
-type Query = {
-  /**
-   * Define which HttpMethods can be used for queries
-   * @default ['get']
-   */
-  methods?: Array<HttpMethod>;
-  /**
-   * Path to the useQuery hook for useQuery functionality.
-   * Used as `import { useQuery } from '${importPath}'`.
-   * Accepts relative and absolute paths.
-   * Path is used as-is; relative paths are based on the generated file location.
-   * @default 'swr'
-   */
-  importPath?: string;
-};
-type Mutation = {
-  /**
-   * Define which HttpMethods can be used for queries
-   * @default ['post', 'put', 'delete', 'patch']
-   */
-  methods?: Array<HttpMethod>;
-  /**
-   * Path to the useQuery hook for useQuery functionality.
-   * Used as `import { useQuery } from '${importPath}'`.
-   * Accepts relative and absolute paths.
-   * Path is used as-is; relative paths are based on the generated file location.
-   * @default 'swr/mutation'
-   */
-  importPath?: string;
-  /**
-   * When true, mutation parameters (path params, query params, headers, body) is passed via `trigger()` instead of as hook arguments.
-   * This aligns with React Query's mutation pattern where variables are passed when triggering the mutation.
-   * @default false
-   * @deprecated This will become the default behavior in v5. Set to `true` to opt-in early.
-   */
-  paramsToTrigger?: boolean;
-};
-type Options = {
-  /**
-   * Specify the export location for the files and define the behavior of the output
-   * @default { path: 'hooks', barrelType: 'named' }
-   */
-  output?: Output<Oas>;
-  /**
-   * Define which contentType should be used.
-   * By default, the first JSON valid mediaType is used
-   */
-  contentType?: contentType;
-  /**
-   * Group the SWR hooks based on the provided name.
-   */
-  group?: Group;
-  /**
-   * Array containing exclude parameters to exclude/skip tags/operations/methods/paths.
-   */
-  exclude?: Array<Exclude>;
-  /**
-   * Array containing include parameters to include tags/operations/methods/paths.
-   */
-  include?: Array<Include>;
-  /**
-   * Array containing override parameters to override `options` based on tags/operations/methods/paths.
-   */
-  override?: Array<Override<ResolvedOptions>>;
-  client?: ClientImportPath & Pick<PluginClient['options'], 'clientType' | 'dataReturnType' | 'baseURL' | 'bundle' | 'paramsCasing'>;
-  queryKey?: QueryKey;
-  query?: Query | false;
-  mutationKey?: MutationKey;
-  mutation?: Mutation | false;
-  /**
-   * How to style your params, by default no casing is applied
-   * - 'camelcase' uses camelcase for the params names
-   */
-  paramsCasing?: 'camelcase';
-  /**
-   * How to pass your params
-   * - 'object' returns the params and pathParams as an object.
-   * - 'inline' returns the params as comma separated params.
-   * @default 'inline'
-   */
-  paramsType?: 'object' | 'inline';
-  /**
-   * How to pass your pathParams.
-   * - 'object' returns the pathParams as an object.
-   * - 'inline': returns the pathParams as comma separated params.
-   * @default 'inline'
-   */
-  pathParamsType?: PluginClient['options']['pathParamsType'];
-  /**
-   * Which parser should be used before returning the data to `swr`.
-   * `'zod'` uses `@kubb/plugin-zod` to parse the data.
-   */
-  parser?: PluginClient['options']['parser'];
-  transformers?: {
-    /**
-     * Customize the names based on the type that is provided by the plugin.
-     */
-    name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
-  };
-  /**
-   * Define some generators next to the swr generators
-   */
-  generators?: Array<Generator$1<PluginSwr>>;
-};
-type ResolvedOptions = {
-  output: Output<Oas>;
-  client: Pick<PluginClient['options'], 'client' | 'clientType' | 'dataReturnType' | 'importPath' | 'baseURL' | 'bundle' | 'paramsCasing'>;
-  parser: Required<NonNullable<Options['parser']>>;
-  queryKey: QueryKey | undefined;
-  query: NonNullable<Required<Query>> | false;
-  mutationKey: MutationKey | undefined;
-  mutation: (Required<Pick<Mutation, 'methods' | 'importPath'>> & Pick<Mutation, 'paramsToTrigger'>) | false;
-  paramsCasing: Options['paramsCasing'];
-  paramsType: NonNullable<Options['paramsType']>;
-  pathParamsType: NonNullable<Options['pathParamsType']>;
-  group: Options['group'];
-};
-type PluginSwr = PluginFactoryOptions<'plugin-swr', Options, ResolvedOptions, never, ResolvePathOptions>;
-//#endregion
-export { MutationKey$1 as i, PluginSwr as n, QueryKey$1 as r, Options as t };
-//# sourceMappingURL=types-BIaGRPjD.d.ts.map

package/src/components/Mutation.tsx

@@ -1,276 +0,0 @@
-import { isOptional, type Operation } from '@kubb/oas'
-import { Client } from '@kubb/plugin-client/components'
-import type { OperationSchemas } from '@kubb/plugin-oas'
-import { getComments, getPathParams } from '@kubb/plugin-oas/utils'
-import { File, Function, FunctionParams, Type } from '@kubb/react-fabric'
-import type { FabricReactNode, Params } from '@kubb/react-fabric/types'
-import type { PluginSwr } from '../types.ts'
-import { MutationKey } from './MutationKey.tsx'
-
-type Props = {
-  /**
-   * Name of the function
-   */
-  name: string
-  typeName: string
-  clientName: string
-  mutationKeyName: string
-  mutationKeyTypeName: string
-  typeSchemas: OperationSchemas
-  operation: Operation
-  paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
-  paramsType: PluginSwr['resolvedOptions']['paramsType']
-  dataReturnType: PluginSwr['resolvedOptions']['client']['dataReturnType']
-  pathParamsType: PluginSwr['resolvedOptions']['pathParamsType']
-  /**
-   * When true, mutation parameters are passed via trigger() instead of as hook arguments
-   * @default false
-   */
-  paramsToTrigger?: boolean
-}
-
-type GetParamsProps = {
-  paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
-  pathParamsType: PluginSwr['resolvedOptions']['pathParamsType']
-  dataReturnType: PluginSwr['resolvedOptions']['client']['dataReturnType']
-  typeSchemas: OperationSchemas
-  mutationKeyTypeName: string
-}
-
-// Original getParams - used when paramsToTrigger is false (default)
-function getParams({ pathParamsType, paramsCasing, dataReturnType, typeSchemas, mutationKeyTypeName }: GetParamsProps) {
-  const TData = dataReturnType === 'data' ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`
-  const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(' | ') || 'Error'}>`
-  const TExtraArg = typeSchemas.request?.name || 'never'
-
-  return FunctionParams.factory({
-    pathParams: {
-      mode: pathParamsType === 'object' ? 'object' : 'inlineSpread',
-      children: getPathParams(typeSchemas.pathParams, { typed: true, casing: paramsCasing }),
-    },
-    params: typeSchemas.queryParams?.name
-      ? {
-          type: typeSchemas.queryParams?.name,
-          optional: isOptional(typeSchemas.queryParams?.schema),
-        }
-      : undefined,
-    headers: typeSchemas.headerParams?.name
-      ? {
-          type: typeSchemas.headerParams?.name,
-          optional: isOptional(typeSchemas.headerParams?.schema),
-        }
-      : undefined,
-    options: {
-      type: `
-{
-  mutation?: SWRMutationConfiguration<${TData}, ${TError}, ${mutationKeyTypeName} | null, ${TExtraArg}> & { throwOnError?: boolean },
-  client?: ${typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: Client }` : 'Partial<RequestConfig> & { client?: Client }'},
-  shouldFetch?: boolean,
-}
-`,
-      default: '{}',
-    },
-  })
-}
-
-type GetTriggerParamsProps = {
-  dataReturnType: PluginSwr['resolvedOptions']['client']['dataReturnType']
-  typeSchemas: OperationSchemas
-  mutationKeyTypeName: string
-  mutationArgTypeName: string
-}
-
-// New getParams - used when paramsToTrigger is true
-function getTriggerParams({ dataReturnType, typeSchemas, mutationKeyTypeName, mutationArgTypeName }: GetTriggerParamsProps) {
-  const TData = dataReturnType === 'data' ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`
-  const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(' | ') || 'Error'}>`
-
-  return FunctionParams.factory({
-    options: {
-      type: `
-{
-  mutation?: SWRMutationConfiguration<${TData}, ${TError}, ${mutationKeyTypeName} | null, ${mutationArgTypeName}> & { throwOnError?: boolean },
-  client?: ${typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: Client }` : 'Partial<RequestConfig> & { client?: Client }'},
-  shouldFetch?: boolean,
-}
-`,
-      default: '{}',
-    },
-  })
-}
-
-type GetMutationParamsProps = {
-  paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
-  typeSchemas: OperationSchemas
-}
-
-function getMutationParams({ paramsCasing, typeSchemas }: GetMutationParamsProps) {
-  return FunctionParams.factory({
-    ...getPathParams(typeSchemas.pathParams, { typed: true, casing: paramsCasing }),
-    data: typeSchemas.request?.name
-      ? {
-          type: typeSchemas.request?.name,
-          optional: isOptional(typeSchemas.request?.schema),
-        }
-      : undefined,
-    params: typeSchemas.queryParams?.name
-      ? {
-          type: typeSchemas.queryParams?.name,
-          optional: isOptional(typeSchemas.queryParams?.schema),
-        }
-      : undefined,
-    headers: typeSchemas.headerParams?.name
-      ? {
-          type: typeSchemas.headerParams?.name,
-          optional: isOptional(typeSchemas.headerParams?.schema),
-        }
-      : undefined,
-  })
-}
-
-export function Mutation({
-  name,
-  clientName,
-  mutationKeyName,
-  mutationKeyTypeName,
-  paramsType,
-  paramsCasing,
-  pathParamsType,
-  dataReturnType,
-  typeSchemas,
-  operation,
-  paramsToTrigger = false,
-}: Props): FabricReactNode {
-  const TData = dataReturnType === 'data' ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`
-  const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(' | ') || 'Error'}>`
-
-  const mutationKeyParams = MutationKey.getParams({
-    pathParamsType,
-    typeSchemas,
-  })
-
-  const clientParams = Client.getParams({
-    paramsCasing,
-    paramsType,
-    typeSchemas,
-    pathParamsType,
-    isConfigurable: true,
-  })
-
-  // Use the new trigger-based approach when paramsToTrigger is true
-  if (paramsToTrigger) {
-    // Build the mutation params type (for arg destructuring)
-    const mutationParams = getMutationParams({
-      paramsCasing,
-      typeSchemas,
-    })
-
-    // Get the arg type name
-    const mutationArgTypeName = `${mutationKeyTypeName.replace('MutationKey', '')}MutationArg`
-
-    // Check if there are any mutation params (path, data, params, headers)
-    const hasMutationParams = Object.keys(mutationParams.params).length > 0
-
-    // Build the arg type for useSWRMutation
-    const argParams = FunctionParams.factory({
-      data: {
-        mode: 'object',
-        children: Object.entries(mutationParams.params).reduce((acc, [key, value]) => {
-          if (value) {
-            acc[key] = {
-              ...value,
-              type: undefined,
-            }
-          }
-          return acc
-        }, {} as Params),
-      },
-    })
-
-    const params = getTriggerParams({
-      dataReturnType,
-      typeSchemas,
-      mutationKeyTypeName,
-      mutationArgTypeName,
-    })
-
-    const generics = [TData, TError, `${mutationKeyTypeName} | null`, mutationArgTypeName].filter(Boolean)
-
-    const mutationArg = mutationParams.toConstructor()
-
-    return (
-      <>
-        <File.Source name={mutationArgTypeName} isExportable isIndexable isTypeOnly>
-          <Type name={mutationArgTypeName} export>
-            {hasMutationParams ? `{${mutationArg}}` : 'never'}
-          </Type>
-        </File.Source>
-        <File.Source name={name} isExportable isIndexable>
-          <Function
-            name={name}
-            export
-            params={params.toConstructor()}
-            JSDoc={{
-              comments: getComments(operation),
-            }}
-          >
-            {`
-        const { mutation: mutationOptions, client: config = {}, shouldFetch = true } = options ?? {}
-        const mutationKey = ${mutationKeyName}(${mutationKeyParams.toCall()})
-
-        return useSWRMutation<${generics.join(', ')}>(
-          shouldFetch ? mutationKey : null,
-          async (_url${hasMutationParams ? `, { arg: ${argParams.toCall()} }` : ''}) => {
-            return ${clientName}(${clientParams.toCall()})
-          },
-          mutationOptions
-        )
-    `}
-          </Function>
-        </File.Source>
-      </>
-    )
-  }
-
-  // Original behavior (default)
-  const generics = [
-    TData,
-    TError,
-    `${mutationKeyTypeName} | null`,
-    typeSchemas.request?.name, // TExtraArg - the arg type for useSWRMutation
-  ].filter(Boolean)
-
-  const params = getParams({
-    paramsCasing,
-    pathParamsType,
-    dataReturnType,
-    typeSchemas,
-    mutationKeyTypeName,
-  })
-
-  return (
-    <File.Source name={name} isExportable isIndexable>
-      <Function
-        name={name}
-        export
-        params={params.toConstructor()}
-        JSDoc={{
-          comments: getComments(operation),
-        }}
-      >
-        {`
-        const { mutation: mutationOptions, client: config = {}, shouldFetch = true } = options ?? {}
-        const mutationKey = ${mutationKeyName}(${mutationKeyParams.toCall()})
-
-        return useSWRMutation<${generics.join(', ')}>(
-          shouldFetch ? mutationKey : null,
-          async (_url${typeSchemas.request?.name ? ', { arg: data }' : ''}) => {
-            return ${clientName}(${clientParams.toCall()})
-          },
-          mutationOptions
-        )
-    `}
-      </Function>
-    </File.Source>
-  )
-}

package/src/components/MutationKey.tsx

@@ -1 +0,0 @@
-export { MutationKey } from '@internals/tanstack-query'

package/src/components/Query.tsx

@@ -1,193 +0,0 @@
-import { getDefaultValue, isOptional, type Operation } from '@kubb/oas'
-import type { OperationSchemas } from '@kubb/plugin-oas'
-import { getComments, getPathParams } from '@kubb/plugin-oas/utils'
-import { File, Function, FunctionParams } from '@kubb/react-fabric'
-import type { FabricReactNode } from '@kubb/react-fabric/types'
-import type { PluginSwr } from '../types.ts'
-import { QueryKey } from './QueryKey.tsx'
-import { QueryOptions } from './QueryOptions.tsx'
-
-type Props = {
-  /**
-   * Name of the function
-   */
-  name: string
-  queryOptionsName: string
-  queryKeyName: string
-  queryKeyTypeName: string
-  typeSchemas: OperationSchemas
-  paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
-  paramsType: PluginSwr['resolvedOptions']['paramsType']
-  pathParamsType: PluginSwr['resolvedOptions']['pathParamsType']
-  dataReturnType: PluginSwr['resolvedOptions']['client']['dataReturnType']
-  operation: Operation
-}
-
-type GetParamsProps = {
-  paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
-  paramsType: PluginSwr['resolvedOptions']['paramsType']
-  pathParamsType: PluginSwr['resolvedOptions']['pathParamsType']
-  dataReturnType: PluginSwr['resolvedOptions']['client']['dataReturnType']
-  typeSchemas: OperationSchemas
-}
-
-function getParams({ paramsType, paramsCasing, pathParamsType, dataReturnType, typeSchemas }: GetParamsProps) {
-  const TData = dataReturnType === 'data' ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`
-  const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(' | ') || 'Error'}>`
-
-  if (paramsType === 'object') {
-    const pathParams = getPathParams(typeSchemas.pathParams, { typed: true, casing: paramsCasing })
-
-    const children = {
-      ...pathParams,
-      data: typeSchemas.request?.name
-        ? {
-            type: typeSchemas.request?.name,
-            optional: isOptional(typeSchemas.request?.schema),
-          }
-        : undefined,
-      params: typeSchemas.queryParams?.name
-        ? {
-            type: typeSchemas.queryParams?.name,
-            optional: isOptional(typeSchemas.queryParams?.schema),
-          }
-        : undefined,
-      headers: typeSchemas.headerParams?.name
-        ? {
-            type: typeSchemas.headerParams?.name,
-            optional: isOptional(typeSchemas.headerParams?.schema),
-          }
-        : undefined,
-    }
-
-    // Check if all children are optional or undefined
-    const allChildrenAreOptional = Object.values(children).every((child) => !child || child.optional)
-
-    return FunctionParams.factory({
-      data: {
-        mode: 'object',
-        children,
-        default: allChildrenAreOptional ? '{}' : undefined,
-      },
-      options: {
-        type: `
-{
-  query?: Parameters<typeof useSWR<${[TData, TError].join(', ')}>>[2],
-  client?: ${typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: Client }` : 'Partial<RequestConfig> & { client?: Client }'},
-  shouldFetch?: boolean,
-  immutable?: boolean
-}
-`,
-        default: '{}',
-      },
-    })
-  }
-
-  return FunctionParams.factory({
-    pathParams: typeSchemas.pathParams?.name
-      ? {
-          mode: pathParamsType === 'object' ? 'object' : 'inlineSpread',
-          children: getPathParams(typeSchemas.pathParams, { typed: true, casing: paramsCasing }),
-          default: getDefaultValue(typeSchemas.pathParams?.schema),
-        }
-      : undefined,
-    data: typeSchemas.request?.name
-      ? {
-          type: typeSchemas.request?.name,
-          optional: isOptional(typeSchemas.request?.schema),
-        }
-      : undefined,
-    params: typeSchemas.queryParams?.name
-      ? {
-          type: typeSchemas.queryParams?.name,
-          optional: isOptional(typeSchemas.queryParams?.schema),
-        }
-      : undefined,
-    headers: typeSchemas.headerParams?.name
-      ? {
-          type: typeSchemas.headerParams?.name,
-          optional: isOptional(typeSchemas.headerParams?.schema),
-        }
-      : undefined,
-    options: {
-      type: `
-{
-  query?: Parameters<typeof useSWR<${[TData, TError].join(', ')}>>[2],
-  client?: ${typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: Client }` : 'Partial<RequestConfig> & { client?: Client }'},
-  shouldFetch?: boolean,
-  immutable?: boolean
-}
-`,
-      default: '{}',
-    },
-  })
-}
-
-export function Query({
-  name,
-  typeSchemas,
-  queryKeyName,
-  queryKeyTypeName,
-  queryOptionsName,
-  operation,
-  dataReturnType,
-  paramsType,
-  paramsCasing,
-  pathParamsType,
-}: Props): FabricReactNode {
-  const TData = dataReturnType === 'data' ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`
-  const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(' | ') || 'Error'}>`
-  const generics = [TData, TError, `${queryKeyTypeName} | null`]
-
-  const queryKeyParams = QueryKey.getParams({
-    pathParamsType,
-    typeSchemas,
-    paramsCasing,
-  })
-  const params = getParams({
-    paramsCasing,
-    paramsType,
-    pathParamsType,
-    dataReturnType,
-    typeSchemas,
-  })
-
-  const queryOptionsParams = QueryOptions.getParams({
-    paramsCasing,
-    paramsType,
-    pathParamsType,
-    typeSchemas,
-  })
-
-  return (
-    <File.Source name={name} isExportable isIndexable>
-      <Function
-        name={name}
-        export
-        params={params.toConstructor()}
-        JSDoc={{
-          comments: getComments(operation),
-        }}
-      >
-        {`
-       const { query: queryOptions, client: config = {}, shouldFetch = true, immutable } = options ?? {}
-
-       const queryKey = ${queryKeyName}(${queryKeyParams.toCall()})
-
-       return useSWR<${generics.join(', ')}>(
-        shouldFetch ? queryKey : null,
-        {
-          ...${queryOptionsName}(${queryOptionsParams.toCall()}),
-          ...(immutable ? {
-              revalidateIfStale: false,
-              revalidateOnFocus: false,
-              revalidateOnReconnect: false
-            } : { }),
-          ...queryOptions
-        }
-       )
-       `}
-      </Function>
-    </File.Source>
-  )
-}

package/src/components/QueryKey.tsx

@@ -1 +0,0 @@
-export { QueryKey } from '@internals/tanstack-query'