@kubb/plugin-cypress 5.0.0-beta.10 → 5.0.0-beta.100

package/src/plugin.ts

@@ -1,95 +0,0 @@
-import { camelCase } from '@internals/utils'
-import { definePlugin, type Group } from '@kubb/core'
-import { pluginTsName } from '@kubb/plugin-ts'
-import { cypressGenerator } from './generators/cypressGenerator.tsx'
-import { resolverCypress } from './resolvers/resolverCypress.ts'
-import type { PluginCypress } from './types.ts'
-
-/**
- * Canonical plugin name for `@kubb/plugin-cypress`, used to identify the plugin
- * in driver lookups and warnings.
- */
-export const pluginCypressName = 'plugin-cypress' satisfies PluginCypress['name']
-
-/**
- * The `@kubb/plugin-cypress` plugin factory.
- *
- * Generates Cypress `cy.request()` test functions from an OpenAPI/AST `RootNode`.
- * Walks operations, delegates rendering to the active generators,
- * and writes barrel files based on `output.barrelType`.
- *
- * @example
- * ```ts
- * import pluginCypress from '@kubb/plugin-cypress'
- *
- * export default defineConfig({
- *   plugins: [pluginCypress({ output: { path: 'cypress' } })],
- * })
- * ```
- */
-export const pluginCypress = definePlugin<PluginCypress>((options) => {
-  const {
-    output = { path: 'cypress', barrelType: 'named' },
-    group,
-    exclude = [],
-    include,
-    override = [],
-    dataReturnType = 'data',
-    baseURL,
-    paramsCasing,
-    paramsType = 'inline',
-    pathParamsType = paramsType === 'object' ? 'object' : options.pathParamsType || 'inline',
-    resolver: userResolver,
-    transformer: userTransformer,
-    generators: userGenerators = [],
-  } = options
-
-  const groupConfig = group
-    ? ({
-        ...group,
-        name: group.name
-          ? group.name
-          : (ctx: { group: string }) => {
-              if (group.type === 'path') {
-                return `${ctx.group.split('/')[1]}`
-              }
-              return `${camelCase(ctx.group)}Requests`
-            },
-      } satisfies Group)
-    : undefined
-
-  return {
-    name: pluginCypressName,
-    options,
-    dependencies: [pluginTsName],
-    hooks: {
-      'kubb:plugin:setup'(ctx) {
-        const resolver = userResolver ? { ...resolverCypress, ...userResolver } : resolverCypress
-
-        ctx.setOptions({
-          output,
-          exclude,
-          include,
-          override,
-          dataReturnType,
-          group: groupConfig,
-          baseURL,
-          paramsCasing,
-          paramsType,
-          pathParamsType,
-          resolver,
-        })
-        ctx.setResolver(resolver)
-        if (userTransformer) {
-          ctx.setTransformer(userTransformer)
-        }
-        ctx.addGenerator(cypressGenerator)
-        for (const gen of userGenerators) {
-          ctx.addGenerator(gen)
-        }
-      },
-    },
-  }
-})
-
-export default pluginCypress

package/src/resolvers/resolverCypress.ts

@@ -1,25 +0,0 @@
-import { camelCase } from '@internals/utils'
-import { defineResolver } from '@kubb/core'
-import type { PluginCypress } from '../types.ts'
-
-/**
- * Naming convention resolver for Cypress plugin.
- *
- * Provides default naming helpers using camelCase for functions and file paths.
- *
- * @example
- * `resolverCypress.default('list pets', 'function')  // → 'listPets'`
- */
-export const resolverCypress = defineResolver<PluginCypress>(() => ({
-  name: 'default',
-  pluginName: 'plugin-cypress',
-  default(name, type) {
-    return camelCase(name, { isFile: type === 'file' })
-  },
-  resolveName(name) {
-    return this.default(name, 'function')
-  },
-  resolvePathName(name, type) {
-    return this.default(name, type)
-  },
-}))

package/src/types.ts

@@ -1,119 +0,0 @@
-import type { ast, Exclude, Generator, Group, Include, Output, Override, PluginFactoryOptions, Resolver } from '@kubb/core'
-
-/**
- * Resolver for Cypress that provides naming methods for test functions.
- */
-export type ResolverCypress = Resolver & {
-  /**
-   * Resolves the function name for an operation.
-   *
-   * @example Resolving function names
-   * `resolver.resolveName('show pet by id') // -> 'showPetById'`
-   */
-  resolveName(this: ResolverCypress, name: string): string
-  /**
-   * Resolves the output file name for a Cypress request module.
-   */
-  resolvePathName(this: ResolverCypress, name: string, type?: 'file' | 'function' | 'type' | 'const'): string
-}
-
-/**
- * Parameter handling mode that determines how path params and query/body params are arranged in function signatures.
- */
-type ParamsTypeOptions =
-  | {
-      /**
-       * All parameters merged into a single destructured object.
-       */
-      paramsType: 'object'
-      /**
-       * Not applicable when all parameters are merged into a single object.
-       */
-      pathParamsType?: never
-    }
-  | {
-      /**
-       * Each parameter group emitted as a separate function argument.
-       */
-      paramsType?: 'inline'
-      /**
-       * How path parameters are arranged: grouped in an object or spread inline.
-       *
-       * @default 'inline'
-       */
-      pathParamsType?: 'object' | 'inline'
-    }
-
-export type Options = {
-  /**
-   * Specify the export location for the files and define the behavior of the output.
-   * @default { path: 'cypress', barrelType: 'named' }
-   */
-  output?: Output
-  /**
-   * Return type when calling cy.request: response data only or full response.
-   *
-   * @default 'data'
-   */
-  dataReturnType?: 'data' | 'full'
-  /**
-   * Apply casing to parameter names.
-   */
-  paramsCasing?: 'camelcase'
-  /**
-   * Base URL prepended to every generated request URL.
-   */
-  baseURL?: string
-  /**
-   * Group the Cypress requests based on the provided name.
-   */
-  group?: Group
-  /**
-   * Tags, operations, or paths to exclude from generation.
-   */
-  exclude?: Array<Exclude>
-  /**
-   * Tags, operations, or paths to include in generation.
-   */
-  include?: Array<Include>
-  /**
-   * Override options for specific tags, operations, or paths.
-   */
-  override?: Array<Override<ResolvedOptions>>
-  /**
-   * Override naming conventions for function names and types.
-   */
-  resolver?: Partial<ResolverCypress> & ThisType<ResolverCypress>
-  /**
-   * AST visitor to transform generated nodes.
-   */
-  transformer?: ast.Visitor
-  /**
-   * Additional generators alongside the default generators.
-   */
-  generators?: Array<Generator<PluginCypress>>
-} & ParamsTypeOptions
-
-type ResolvedOptions = {
-  output: Output
-  exclude: Array<Exclude>
-  include: Array<Include> | undefined
-  override: Array<Override<ResolvedOptions>>
-  group: Group | undefined
-  baseURL: Options['baseURL'] | undefined
-  dataReturnType: NonNullable<Options['dataReturnType']>
-  pathParamsType: NonNullable<NonNullable<Options['pathParamsType']>>
-  paramsType: NonNullable<Options['paramsType']>
-  paramsCasing: Options['paramsCasing']
-  resolver: ResolverCypress
-}
-
-export type PluginCypress = PluginFactoryOptions<'plugin-cypress', Options, ResolvedOptions, ResolverCypress>
-
-declare global {
-  namespace Kubb {
-    interface PluginRegistry {
-      'plugin-cypress': PluginCypress
-    }
-  }
-}