@kubb/core 5.0.0-alpha.7 → 5.0.0-alpha.71

package/src/utils/getConfigs.ts

@@ -1,30 +0,0 @@
-import type { CLIOptions, ConfigInput } from '../config.ts'
-import type { Config, UserConfig } from '../types.ts'
-import { getPlugins } from './getPlugins.ts'
-
-/**
- * Converting UserConfig to Config Array without a change in the object beside the JSON convert.
- */
-export async function getConfigs(config: ConfigInput | UserConfig, args: CLIOptions): Promise<Array<Config>> {
-  const resolvedConfig: Promise<UserConfig | Array<UserConfig>> =
-    typeof config === 'function' ? Promise.resolve(config(args as CLIOptions)) : Promise.resolve(config)
-
-  let userConfigs = await resolvedConfig
-
-  if (!Array.isArray(userConfigs)) {
-    userConfigs = [userConfigs]
-  }
-
-  const results: Array<Config> = []
-
-  for (const item of userConfigs) {
-    const plugins = item.plugins ? await getPlugins(item.plugins) : undefined
-
-    results.push({
-      ...item,
-      plugins,
-    } as Config)
-  }
-
-  return results
-}

package/src/utils/getPlugins.ts

@@ -1,23 +0,0 @@
-import type { UnknownUserPlugin, UserConfig } from '../types.ts'
-
-type PluginsArray = Array<Omit<UnknownUserPlugin, 'inject'>>
-
-function isJSONPlugins(plugins: UserConfig['plugins']): boolean {
-  return Array.isArray(plugins) && plugins.some((plugin) => Array.isArray(plugin) && typeof (plugin as unknown[])[0] === 'string')
-}
-
-function isObjectPlugins(plugins: UserConfig['plugins']): boolean {
-  return plugins instanceof Object && !Array.isArray(plugins)
-}
-
-export function getPlugins(plugins: UserConfig['plugins']): Promise<PluginsArray | undefined> {
-  if (isObjectPlugins(plugins)) {
-    throw new Error('Object plugins are not supported anymore, best to use http://kubb.dev/getting-started/configure#json')
-  }
-
-  if (isJSONPlugins(plugins)) {
-    throw new Error('JSON plugins are not supported anymore, best to use http://kubb.dev/getting-started/configure#json')
-  }
-
-  return Promise.resolve(plugins)
-}

package/src/utils/linters.ts

@@ -1,25 +0,0 @@
-import { x } from 'tinyexec'
-import type { linters } from '../constants.ts'
-
-type Linter = keyof typeof linters
-
-async function isLinterAvailable(linter: Linter): Promise<boolean> {
-  try {
-    await x(linter, ['--version'], { nodeOptions: { stdio: 'ignore' } })
-    return true
-  } catch {
-    return false
-  }
-}
-
-export async function detectLinter(): Promise<Linter | undefined> {
-  const linterNames: Linter[] = ['biome', 'oxlint', 'eslint']
-
-  for (const linter of linterNames) {
-    if (await isLinterAvailable(linter)) {
-      return linter
-    }
-  }
-
-  return undefined
-}

package/src/utils/resolveOptions.ts

@@ -1,93 +0,0 @@
-import { isOperationNode, isSchemaNode } from '@kubb/ast'
-import type { Node, OperationNode, SchemaNode } from '@kubb/ast/types'
-
-type FilterItem = {
-  type: string
-  pattern: string | RegExp
-}
-
-type OverrideItem<TOptions> = FilterItem & {
-  options: Omit<Partial<TOptions>, 'override'>
-}
-
-type ResolveOptionsContext<TOptions> = {
-  options: TOptions
-  exclude?: Array<FilterItem>
-  include?: Array<FilterItem>
-  override?: Array<OverrideItem<TOptions>>
-}
-
-function matchesOperationPattern(node: OperationNode, type: string, pattern: string | RegExp): boolean {
-  switch (type) {
-    case 'tag':
-      return node.tags.some((tag) => !!tag.match(pattern))
-    case 'operationId':
-      return !!node.operationId.match(pattern)
-    case 'path':
-      return !!node.path.match(pattern)
-    case 'method':
-      return !!(node.method.toLowerCase() as string).match(pattern)
-    default:
-      return false
-  }
-}
-
-function matchesSchemaPattern(node: SchemaNode, type: string, pattern: string | RegExp): boolean | null {
-  switch (type) {
-    case 'schemaName':
-      return node.name ? !!node.name.match(pattern) : false
-    default:
-      return null
-  }
-}
-
-/**
- * Resolves the effective plugin options for a given AST node by applying
- * `exclude`, `include`, and `override` rules from the plugin configuration.
- *
- * Returns `null` when the node is excluded or not matched by `include`.
- * Returns the merged options (base options merged with any matching `override`) otherwise.
- *
- * Supported filter types for `OperationNode`: `tag`, `operationId`, `path`, `method`.
- * Supported filter types for `SchemaNode`: `schemaName`.
- *
- * @example
- * const resolved = resolveOptions(operationNode, { options, exclude, include, override })
- * if (!resolved) return // excluded
- */
-export function resolveOptions<TOptions>(node: Node, { options, exclude = [], include, override = [] }: ResolveOptionsContext<TOptions>): TOptions | null {
-  if (isOperationNode(node)) {
-    const isExcluded = exclude.some(({ type, pattern }) => matchesOperationPattern(node, type, pattern))
-    if (isExcluded) {
-      return null
-    }
-
-    if (include && !include.some(({ type, pattern }) => matchesOperationPattern(node, type, pattern))) {
-      return null
-    }
-
-    const overrideOptions = override.find(({ type, pattern }) => matchesOperationPattern(node, type, pattern))?.options
-
-    return { ...options, ...overrideOptions }
-  }
-
-  if (isSchemaNode(node)) {
-    if (exclude.some(({ type, pattern }) => matchesSchemaPattern(node, type, pattern) === true)) {
-      return null
-    }
-
-    if (include) {
-      const results = include.map(({ type, pattern }) => matchesSchemaPattern(node, type, pattern))
-      const applicable = results.filter((r) => r !== null)
-      if (applicable.length > 0 && !applicable.includes(true)) {
-        return null
-      }
-    }
-
-    const overrideOptions = override.find(({ type, pattern }) => matchesSchemaPattern(node, type, pattern) === true)?.options
-
-    return { ...options, ...overrideOptions }
-  }
-
-  return options
-}