@kubb/plugin-swr 5.0.0-beta.42 → 5.0.0-beta.64

package/src/components/Mutation.tsx

@@ -1,155 +0,0 @@
-import { ast } from '@kubb/core'
-import type { ResolverTs } from '@kubb/plugin-ts'
-import { functionPrinter } from '@kubb/plugin-ts'
-import { File, Function, Type } from '@kubb/renderer-jsx'
-import type { KubbReactNode } from '@kubb/renderer-jsx/types'
-import type { PluginSwr } from '../types.ts'
-import { buildRequestConfigType, getComments, resolveErrorNames } from '../utils.ts'
-
-type Props = {
-  name: string
-  clientName: string
-  mutationKeyName: string
-  mutationKeyTypeName: string
-  mutationArgTypeName: string
-  node: ast.OperationNode
-  tsResolver: ResolverTs
-  paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
-  paramsType: PluginSwr['resolvedOptions']['paramsType']
-  pathParamsType: PluginSwr['resolvedOptions']['pathParamsType']
-  dataReturnType: PluginSwr['resolvedOptions']['client']['dataReturnType']
-}
-
-const declarationPrinter = functionPrinter({ mode: 'declaration' })
-const callPrinter = functionPrinter({ mode: 'call' })
-const keysPrinter = functionPrinter({ mode: 'keys' })
-
-function createMutationArgParams(
-  node: ast.OperationNode,
-  options: {
-    paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
-    resolver: ResolverTs
-  },
-): ast.FunctionParametersNode {
-  return ast.createOperationParams(node, {
-    paramsType: 'inline',
-    pathParamsType: 'inline',
-    paramsCasing: options.paramsCasing,
-    resolver: options.resolver,
-  })
-}
-
-function buildMutationParamsNode(
-  node: ast.OperationNode,
-  options: {
-    paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
-    dataReturnType: PluginSwr['resolvedOptions']['client']['dataReturnType']
-    mutationKeyTypeName: string
-    mutationArgTypeName: string
-    resolver: ResolverTs
-  },
-): ast.FunctionParametersNode {
-  const { dataReturnType, mutationKeyTypeName, mutationArgTypeName, resolver } = options
-  const responseName = resolver.resolveResponseName(node)
-  const errorNames = resolveErrorNames(node, resolver)
-
-  const TData = dataReturnType === 'data' ? responseName : `ResponseConfig<${responseName}>`
-  const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(' | ') : 'Error'}>`
-
-  return ast.createFunctionParameters({
-    params: [
-      ast.createFunctionParameter({
-        name: 'options',
-        type: ast.createParamsType({
-          variant: 'reference',
-          name: `{
-  mutation?: SWRMutationConfiguration<${TData}, ${TError}, ${mutationKeyTypeName} | null, ${mutationArgTypeName}> & { throwOnError?: boolean },
-  client?: ${buildRequestConfigType(node, resolver)},
-  shouldFetch?: boolean,
-}`,
-        }),
-        default: '{}',
-      }),
-    ],
-  })
-}
-
-export function Mutation({
-  name,
-  clientName,
-  mutationKeyName,
-  mutationKeyTypeName,
-  mutationArgTypeName,
-  paramsCasing,
-  paramsType,
-  pathParamsType,
-  dataReturnType,
-  node,
-  tsResolver,
-}: Props): KubbReactNode {
-  const responseName = tsResolver.resolveResponseName(node)
-  const errorNames = resolveErrorNames(node, tsResolver)
-
-  const TData = dataReturnType === 'data' ? responseName : `ResponseConfig<${responseName}>`
-  const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(' | ') : 'Error'}>`
-
-  const mutationArgParamsNode = createMutationArgParams(node, { paramsCasing, resolver: tsResolver })
-  const hasMutationParams = mutationArgParamsNode.params.length > 0
-  const argTypeBody = hasMutationParams ? (declarationPrinter.print(mutationArgParamsNode) ?? '') : ''
-  const argKeysStr = hasMutationParams ? (keysPrinter.print(mutationArgParamsNode) ?? '') : ''
-
-  const generics = [TData, TError, `${mutationKeyTypeName} | null`, mutationArgTypeName]
-
-  const paramsNode = buildMutationParamsNode(node, {
-    paramsCasing,
-    dataReturnType,
-    mutationKeyTypeName,
-    mutationArgTypeName,
-    resolver: tsResolver,
-  })
-  const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
-
-  const clientCallParamsNode = ast.createOperationParams(node, {
-    paramsType,
-    pathParamsType: paramsType === 'object' ? 'object' : pathParamsType === 'object' ? 'object' : 'inline',
-    paramsCasing,
-    resolver: tsResolver,
-    extraParams: [
-      ast.createFunctionParameter({
-        name: 'config',
-        type: ast.createParamsType({
-          variant: 'reference',
-          name: buildRequestConfigType(node, tsResolver),
-        }),
-        default: '{}',
-      }),
-    ],
-  })
-  const clientCallStr = callPrinter.print(clientCallParamsNode) ?? ''
-
-  return (
-    <>
-      <File.Source name={mutationArgTypeName} isExportable isIndexable isTypeOnly>
-        <Type name={mutationArgTypeName} export>
-          {hasMutationParams ? `{ ${argTypeBody} }` : 'never'}
-        </Type>
-      </File.Source>
-      <File.Source name={name} isExportable isIndexable>
-        <Function name={name} export params={paramsSignature} JSDoc={{ comments: getComments(node) }}>
-          {`
-        const { mutation: mutationOptions, client: config = {}, shouldFetch = true } = options ?? {}
-        const mutationKey = ${mutationKeyName}()
-
-        return useSWRMutation<${generics.join(', ')}>(
-          shouldFetch ? mutationKey : null,
-          async (_url${hasMutationParams ? `, { arg: { ${argKeysStr} } }` : ''}) => {
-            return ${clientName}(${clientCallStr})
-          },
-          mutationOptions
-        )
-    `}
-        </Function>
-      </File.Source>
-    </>
-  )
-}

package/src/components/MutationKey.tsx

@@ -1,25 +0,0 @@
-import type { Transformer } from '@internals/tanstack-query'
-import { MutationKey as SharedMutationKey } from '@internals/tanstack-query'
-import type { ast } from '@kubb/core'
-import { File, Type } from '@kubb/renderer-jsx'
-import type { KubbReactNode } from '@kubb/renderer-jsx/types'
-
-type Props = {
-  name: string
-  typeName: string
-  node: ast.OperationNode
-  paramsCasing: 'camelcase' | undefined
-  pathParamsType: 'object' | 'inline'
-  transformer: Transformer | undefined
-}
-
-export function MutationKey({ name, typeName, node, paramsCasing, pathParamsType, transformer }: Props): KubbReactNode {
-  return (
-    <>
-      <SharedMutationKey name={name} node={node} paramsCasing={paramsCasing} pathParamsType={pathParamsType} transformer={transformer} />
-      <File.Source name={typeName} isExportable isIndexable isTypeOnly>
-        <Type export name={typeName}>{`ReturnType<typeof ${name}>`}</Type>
-      </File.Source>
-    </>
-  )
-}

package/src/components/Query.tsx

@@ -1,128 +0,0 @@
-import { ast } from '@kubb/core'
-import type { ResolverTs } from '@kubb/plugin-ts'
-import { functionPrinter } from '@kubb/plugin-ts'
-import { File, Function } from '@kubb/renderer-jsx'
-import type { KubbReactNode } from '@kubb/renderer-jsx/types'
-import { getEnabledParamNames, markParamsOptional } from '@internals/tanstack-query'
-import type { PluginSwr } from '../types.ts'
-import { buildQueryKeyParams, getComments, resolveErrorNames } from '../utils.ts'
-import { getQueryOptionsParams } from './QueryOptions.tsx'
-
-type Props = {
-  name: string
-  queryOptionsName: string
-  queryKeyName: string
-  queryKeyTypeName: string
-  node: ast.OperationNode
-  tsResolver: ResolverTs
-  paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
-  paramsType: PluginSwr['resolvedOptions']['paramsType']
-  pathParamsType: PluginSwr['resolvedOptions']['pathParamsType']
-  dataReturnType: PluginSwr['resolvedOptions']['client']['dataReturnType']
-}
-
-const declarationPrinter = functionPrinter({ mode: 'declaration' })
-const callPrinter = functionPrinter({ mode: 'call' })
-
-function buildQueryParamsNode(
-  node: ast.OperationNode,
-  options: {
-    paramsType: PluginSwr['resolvedOptions']['paramsType']
-    paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
-    pathParamsType: PluginSwr['resolvedOptions']['pathParamsType']
-    dataReturnType: PluginSwr['resolvedOptions']['client']['dataReturnType']
-    resolver: ResolverTs
-  },
-): ast.FunctionParametersNode {
-  const { paramsType, paramsCasing, pathParamsType, dataReturnType, resolver } = options
-  const responseName = resolver.resolveResponseName(node)
-  const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : undefined
-  const errorNames = resolveErrorNames(node, resolver)
-
-  const TData = dataReturnType === 'data' ? responseName : `ResponseConfig<${responseName}>`
-  const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(' | ') : 'Error'}>`
-
-  const optionsParam = ast.createFunctionParameter({
-    name: 'options',
-    type: ast.createParamsType({
-      variant: 'reference',
-      name: `{
-  query?: SWRConfiguration<${[TData, TError].join(', ')}>,
-  client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : 'Partial<RequestConfig> & { client?: Client }'},
-  shouldFetch?: boolean,
-  immutable?: boolean
-}`,
-    }),
-    default: '{}',
-  })
-
-  return ast.createOperationParams(node, {
-    paramsType,
-    pathParamsType: paramsType === 'object' ? 'object' : pathParamsType === 'object' ? 'object' : 'inline',
-    paramsCasing,
-    resolver,
-    extraParams: [optionsParam],
-  })
-}
-
-export function Query({
-  name,
-  queryKeyTypeName,
-  queryOptionsName,
-  queryKeyName,
-  paramsType,
-  paramsCasing,
-  pathParamsType,
-  dataReturnType,
-  node,
-  tsResolver,
-}: Props): KubbReactNode {
-  const responseName = tsResolver.resolveResponseName(node)
-  const errorNames = resolveErrorNames(node, tsResolver)
-
-  const TData = dataReturnType === 'data' ? responseName : `ResponseConfig<${responseName}>`
-  const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(' | ') : 'Error'}>`
-  const generics = [TData, TError, `${queryKeyTypeName} | null`]
-
-  const queryKeyParamsNode = buildQueryKeyParams(node, { pathParamsType, paramsCasing, resolver: tsResolver })
-  const queryKeyParamsCall = callPrinter.print(queryKeyParamsNode) ?? ''
-  const enabledNames = getEnabledParamNames(queryKeyParamsNode)
-
-  const queryOptionsParamsNode = getQueryOptionsParams(node, { paramsType, paramsCasing, pathParamsType, resolver: tsResolver })
-  const queryOptionsParamsCall = callPrinter.print(queryOptionsParamsNode) ?? ''
-
-  const paramsNode = markParamsOptional(
-    buildQueryParamsNode(node, { paramsType, paramsCasing, pathParamsType, dataReturnType, resolver: tsResolver }),
-    enabledNames,
-  )
-  const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
-
-  // SWR has no `enabled` option; fold the param-presence check into the null-key gate
-  // so passing `undefined` for a required param disables the request (mirrors React Query #60).
-  const shouldFetchExpr = enabledNames.length ? `shouldFetch && !!(${enabledNames.join(' && ')})` : 'shouldFetch'
-
-  return (
-    <File.Source name={name} isExportable isIndexable>
-      <Function name={name} export params={paramsSignature} JSDoc={{ comments: getComments(node) }}>
-        {`
-       const { query: queryOptions, client: config = {}, shouldFetch = true, immutable } = options ?? {}
-
-       const queryKey = ${queryKeyName}(${queryKeyParamsCall})
-
-       return useSWR<${generics.join(', ')}>(
-        ${shouldFetchExpr} ? queryKey : null,
-        {
-          ...${queryOptionsName}(${queryOptionsParamsCall}),
-          ...(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'

package/src/components/QueryOptions.tsx

@@ -1,74 +0,0 @@
-import { ast } from '@kubb/core'
-import type { ResolverTs } from '@kubb/plugin-ts'
-import { functionPrinter } from '@kubb/plugin-ts'
-import { File, Function } from '@kubb/renderer-jsx'
-import type { KubbReactNode } from '@kubb/renderer-jsx/types'
-import { getEnabledParamNames, injectNonNullAssertions, markParamsOptional } from '@internals/tanstack-query'
-import type { PluginSwr } from '../types.ts'
-import { buildQueryKeyParams } from '../utils.ts'
-
-type Props = {
-  name: string
-  clientName: string
-  node: ast.OperationNode
-  tsResolver: ResolverTs
-  paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
-  paramsType: PluginSwr['resolvedOptions']['paramsType']
-  pathParamsType: PluginSwr['resolvedOptions']['pathParamsType']
-}
-
-const declarationPrinter = functionPrinter({ mode: 'declaration' })
-const callPrinter = functionPrinter({ mode: 'call' })
-
-export function getQueryOptionsParams(
-  node: ast.OperationNode,
-  options: {
-    paramsType: PluginSwr['resolvedOptions']['paramsType']
-    paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
-    pathParamsType: PluginSwr['resolvedOptions']['pathParamsType']
-    resolver: ResolverTs
-  },
-): ast.FunctionParametersNode {
-  const { paramsType, paramsCasing, pathParamsType, resolver } = options
-  const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : undefined
-
-  return ast.createOperationParams(node, {
-    paramsType,
-    pathParamsType: paramsType === 'object' ? 'object' : pathParamsType === 'object' ? 'object' : 'inline',
-    paramsCasing,
-    resolver,
-    extraParams: [
-      ast.createFunctionParameter({
-        name: 'config',
-        type: ast.createParamsType({
-          variant: 'reference',
-          name: requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : 'Partial<RequestConfig> & { client?: Client }',
-        }),
-        default: '{}',
-      }),
-    ],
-  })
-}
-
-export function QueryOptions({ name, clientName, node, tsResolver, paramsCasing, paramsType, pathParamsType }: Props): KubbReactNode {
-  const queryKeyParamsNode = buildQueryKeyParams(node, { pathParamsType, paramsCasing, resolver: tsResolver })
-  const enabledNames = getEnabledParamNames(queryKeyParamsNode)
-
-  const paramsNode = markParamsOptional(getQueryOptionsParams(node, { paramsType, paramsCasing, pathParamsType, resolver: tsResolver }), enabledNames)
-  const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
-  const clientCallStr = injectNonNullAssertions(callPrinter.print(paramsNode) ?? '', enabledNames)
-
-  return (
-    <File.Source name={name} isExportable isIndexable>
-      <Function name={name} export params={paramsSignature}>
-        {`
-      return {
-        fetcher: async () => {
-          return ${clientName}(${clientCallStr})
-        },
-      }
-`}
-      </Function>
-    </File.Source>
-  )
-}

package/src/components/index.ts

@@ -1,5 +0,0 @@
-export { Mutation } from './Mutation.tsx'
-export { MutationKey } from './MutationKey.tsx'
-export { Query } from './Query.tsx'
-export { QueryKey } from './QueryKey.tsx'
-export { QueryOptions } from './QueryOptions.tsx'

package/src/generators/index.ts

@@ -1,2 +0,0 @@
-export { mutationGenerator } from './mutationGenerator.tsx'
-export { queryGenerator } from './queryGenerator.tsx'

package/src/generators/mutationGenerator.tsx

@@ -1,162 +0,0 @@
-import path from 'node:path'
-import { resolveOperationTypeNames } from '@internals/shared'
-import { resolveZodSchemaNames } from '@internals/tanstack-query'
-import { ast, defineGenerator } from '@kubb/core'
-import { Client, pluginClientName } from '@kubb/plugin-client'
-import { pluginTsName } from '@kubb/plugin-ts'
-import { pluginZodName } from '@kubb/plugin-zod'
-import { File, jsxRenderer } from '@kubb/renderer-jsx'
-import { Mutation, MutationKey } from '../components'
-import type { PluginSwr } from '../types'
-
-export const mutationGenerator = defineGenerator<PluginSwr>({
-  name: 'swr-mutation',
-  renderer: jsxRenderer,
-  operation(node, ctx) {
-    if (!ast.isHttpOperationNode(node)) return null
-    const { config, driver, resolver, root } = ctx
-    const { output, query, mutation, paramsCasing, paramsType, pathParamsType, parser, client: clientOptions, group } = ctx.options
-
-    const pluginTs = driver.getPlugin(pluginTsName)
-    if (!pluginTs) return null
-    const tsResolver = driver.getResolver(pluginTsName)
-
-    const isQuery = query === false || (!!query && query.methods.some((method) => node.method.toLowerCase() === method.toLowerCase()))
-    const queryMethods = new Set(query ? query.methods : [])
-    const isMutation =
-      mutation !== false &&
-      !isQuery &&
-      (mutation ? mutation.methods : []).some((method) => !queryMethods.has(method) && node.method.toLowerCase() === method.toLowerCase())
-
-    if (!isMutation) return null
-
-    const importPath = mutation ? mutation.importPath : 'swr/mutation'
-
-    const mutationHookName = resolver.resolveMutationName(node)
-    const mutationKeyName = resolver.resolveMutationKeyName(node)
-    const mutationKeyTypeName = resolver.resolveMutationKeyTypeName(node)
-    const mutationArgTypeName = resolver.resolveMutationArgTypeName(node)
-    const clientName = resolver.resolveClientName(node)
-
-    const meta = {
-      file: resolver.resolveFile({ name: mutationHookName, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group }),
-      fileTs: tsResolver.resolveFile(
-        { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
-        { root, output: pluginTs.options?.output ?? output, group: pluginTs.options?.group },
-      ),
-    }
-
-    const importedTypeNames = resolveOperationTypeNames(node, tsResolver, { paramsCasing, order: 'body-response-first' })
-
-    const pluginZod = parser === 'zod' ? driver.getPlugin(pluginZodName) : undefined
-    const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : undefined
-    const fileZod = zodResolver
-      ? zodResolver.resolveFile(
-          { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
-          { root, output: pluginZod?.options?.output ?? output, group: pluginZod?.options?.group },
-        )
-      : undefined
-    const zodSchemaNames = resolveZodSchemaNames(node, zodResolver)
-
-    const clientPlugin = driver.getPlugin(pluginClientName)
-    const hasClientPlugin = clientPlugin?.name === pluginClientName
-    const shouldUseClientPlugin = hasClientPlugin && clientOptions.clientType !== 'class'
-    const clientResolver = shouldUseClientPlugin ? driver.getResolver(pluginClientName) : undefined
-
-    const clientFile = shouldUseClientPlugin
-      ? clientResolver?.resolveFile(
-          { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
-          {
-            root,
-            output: clientPlugin?.options?.output ?? output,
-            group: clientPlugin?.options?.group,
-          },
-        )
-      : undefined
-
-    const resolvedClientName = shouldUseClientPlugin ? (clientResolver?.resolveName(node.operationId) ?? clientName) : clientName
-
-    return (
-      <File
-        baseName={meta.file.baseName}
-        path={meta.file.path}
-        meta={meta.file.meta}
-        banner={resolver.resolveBanner(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}
-        footer={resolver.resolveFooter(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}
-      >
-        {fileZod && zodSchemaNames.length > 0 && <File.Import name={zodSchemaNames} root={meta.file.path} path={fileZod.path} />}
-        {clientOptions.importPath ? (
-          <>
-            {!shouldUseClientPlugin && <File.Import name={'client'} path={clientOptions.importPath} />}
-            <File.Import name={['Client', 'RequestConfig', 'ResponseErrorConfig']} path={clientOptions.importPath} isTypeOnly />
-            {clientOptions.dataReturnType === 'full' && <File.Import name={['ResponseConfig']} path={clientOptions.importPath} isTypeOnly />}
-          </>
-        ) : (
-          <>
-            {!shouldUseClientPlugin && <File.Import name={['client']} root={meta.file.path} path={path.resolve(root, '.kubb/client.ts')} />}
-            <File.Import
-              name={['Client', 'RequestConfig', 'ResponseErrorConfig']}
-              root={meta.file.path}
-              path={path.resolve(root, '.kubb/client.ts')}
-              isTypeOnly
-            />
-            {clientOptions.dataReturnType === 'full' && (
-              <File.Import name={['ResponseConfig']} root={meta.file.path} path={path.resolve(root, '.kubb/client.ts')} isTypeOnly />
-            )}
-          </>
-        )}
-        {shouldUseClientPlugin && clientFile && <File.Import name={[resolvedClientName]} root={meta.file.path} path={clientFile.path} />}
-        {!shouldUseClientPlugin && node.requestBody?.content?.some((e) => e.contentType === 'multipart/form-data') && (
-          <File.Import name={['buildFormData']} root={meta.file.path} path={path.resolve(root, '.kubb/config.ts')} />
-        )}
-        {meta.fileTs && importedTypeNames.length > 0 && (
-          <File.Import name={Array.from(new Set(importedTypeNames))} root={meta.file.path} path={meta.fileTs.path} isTypeOnly />
-        )}
-
-        <MutationKey
-          name={mutationKeyName}
-          typeName={mutationKeyTypeName}
-          node={node}
-          pathParamsType={pathParamsType}
-          paramsCasing={paramsCasing}
-          transformer={ctx.options.mutationKey}
-        />
-
-        {!shouldUseClientPlugin && (
-          <Client
-            name={resolvedClientName}
-            baseURL={clientOptions.baseURL}
-            dataReturnType={clientOptions.dataReturnType || 'data'}
-            paramsCasing={clientOptions.paramsCasing || paramsCasing}
-            paramsType={paramsType}
-            pathParamsType={pathParamsType}
-            parser={parser}
-            node={node}
-            tsResolver={tsResolver}
-            zodResolver={zodResolver}
-          />
-        )}
-
-        {mutation && (
-          <>
-            <File.Import name={'useSWRMutation'} path={importPath} />
-            <File.Import name={['SWRMutationConfiguration']} path={importPath} isTypeOnly />
-            <Mutation
-              name={mutationHookName}
-              clientName={resolvedClientName}
-              mutationKeyName={mutationKeyName}
-              mutationKeyTypeName={mutationKeyTypeName}
-              mutationArgTypeName={mutationArgTypeName}
-              node={node}
-              tsResolver={tsResolver}
-              dataReturnType={clientOptions.dataReturnType || 'data'}
-              paramsCasing={paramsCasing}
-              paramsType={paramsType}
-              pathParamsType={pathParamsType}
-            />
-          </>
-        )}
-      </File>
-    )
-  },
-})