@kubb/core 5.0.0-alpha.4 → 5.0.0-alpha.41

package/src/utils/FunctionParams.ts

@@ -1,155 +0,0 @@
-import { camelCase } from '@internals/utils'
-// TODO replace with @internals/utils
-import { sortBy } from 'remeda'
-
-type FunctionParamsASTWithoutType = {
-  name?: string
-  type?: string
-  /**
-   * @default true
-   */
-  required?: boolean
-  /**
-   * @default true
-   */
-  enabled?: boolean
-  default?: string
-}
-
-type FunctionParamsASTWithType = {
-  name?: never
-  type: string
-  /**
-   * @default true
-   */
-  required?: boolean
-  /**
-   * @default true
-   */
-  enabled?: boolean
-  default?: string
-}
-/**
- * @deprecated
- */
-export type FunctionParamsAST = FunctionParamsASTWithoutType | FunctionParamsASTWithType
-
-/**
- * @deprecated
- */
-export class FunctionParams {
-  #items: Array<FunctionParamsAST | FunctionParamsAST[]> = []
-
-  get items(): FunctionParamsAST[] {
-    return this.#items.flat()
-  }
-
-  add(item: FunctionParamsAST | Array<FunctionParamsAST | FunctionParamsAST[] | undefined> | undefined): FunctionParams {
-    if (!item) {
-      return this
-    }
-
-    if (Array.isArray(item)) {
-      item
-        .filter((x): x is FunctionParamsAST | FunctionParamsAST[] => x !== undefined)
-        .forEach((it) => {
-          this.#items.push(it)
-        })
-      return this
-    }
-    this.#items.push(item)
-
-    return this
-  }
-  static #orderItems(items: Array<FunctionParamsAST | FunctionParamsAST[]>) {
-    return sortBy(
-      items.filter(Boolean),
-      [(item) => Array.isArray(item), 'desc'], // arrays (rest params) first
-      [(item) => !Array.isArray(item) && (item as FunctionParamsAST).default !== undefined, 'asc'], // no-default before has-default
-      [(item) => Array.isArray(item) || ((item as FunctionParamsAST).required ?? true), 'desc'], // required before optional
-    )
-  }
-
-  static #addParams(acc: string[], item: FunctionParamsAST) {
-    const { enabled = true, name, type, required = true, ...rest } = item
-
-    if (!enabled) {
-      return acc
-    }
-
-    if (!name) {
-      // when name is not se we uses TypeScript generics
-      acc.push(`${type}${rest.default ? ` = ${rest.default}` : ''}`)
-
-      return acc
-    }
-    // TODO check why we still need the camelcase here
-    const parameterName = name.startsWith('{') ? name : camelCase(name)
-
-    if (type) {
-      if (required) {
-        acc.push(`${parameterName}: ${type}${rest.default ? ` = ${rest.default}` : ''}`)
-      } else {
-        acc.push(`${parameterName}?: ${type}`)
-      }
-    } else {
-      acc.push(`${parameterName}`)
-    }
-
-    return acc
-  }
-
-  static toObject(items: FunctionParamsAST[]): FunctionParamsAST {
-    let type: string[] = []
-    let name: string[] = []
-
-    const enabled = items.every((item) => item.enabled) ? items.at(0)?.enabled : true
-    const required = items.every((item) => item.required) ?? true
-
-    items.forEach((item) => {
-      name = FunctionParams.#addParams(name, { ...item, type: undefined })
-      if (items.some((item) => item.type)) {
-        type = FunctionParams.#addParams(type, item)
-      }
-    })
-
-    return {
-      name: `{ ${name.join(', ')} }`,
-      type: type.length ? `{ ${type.join('; ')} }` : undefined,
-      enabled,
-      required,
-    }
-  }
-
-  toObject(): FunctionParamsAST {
-    const items = FunctionParams.#orderItems(this.#items).flat()
-
-    return FunctionParams.toObject(items)
-  }
-
-  static toString(items: (FunctionParamsAST | FunctionParamsAST[])[]): string {
-    const sortedData = FunctionParams.#orderItems(items)
-
-    return sortedData
-      .reduce((acc, item) => {
-        if (Array.isArray(item)) {
-          if (item.length <= 0) {
-            return acc
-          }
-          const subItems = FunctionParams.#orderItems(item) as FunctionParamsAST[]
-          const objectItem = FunctionParams.toObject(subItems)
-
-          return FunctionParams.#addParams(acc, objectItem)
-        }
-
-        return FunctionParams.#addParams(acc, item)
-      }, [] as string[])
-      .join(', ')
-  }
-
-  toString(): string {
-    const items = FunctionParams.#orderItems(this.#items)
-
-    return FunctionParams.toString(items)
-  }
-}

package/src/utils/formatters.ts

@@ -1,56 +0,0 @@
-import { x } from 'tinyexec'
-import type { formatters } from '../constants.ts'
-
-type Formatter = keyof typeof formatters
-
-/**
- * Check if a formatter command is available in the system.
- *
- * @param formatter - The formatter to check ('biome', 'prettier', or 'oxfmt')
- * @returns Promise that resolves to true if the formatter is available, false otherwise
- *
- * @remarks
- * This function checks availability by running `<formatter> --version` command.
- * All supported formatters (biome, prettier, oxfmt) implement the --version flag.
- */
-async function isFormatterAvailable(formatter: Formatter): Promise<boolean> {
-  try {
-    // Try to get the version of the formatter to check if it's installed
-    await x(formatter, ['--version'], { nodeOptions: { stdio: 'ignore' } })
-    return true
-  } catch {
-    return false
-  }
-}
-
-/**
- * Detect which formatter is available in the system.
- *
- * @returns Promise that resolves to the first available formatter or undefined if none are found
- *
- * @remarks
- * Checks in order of preference: biome, oxfmt, prettier.
- * Uses the `--version` flag to detect if each formatter command is available.
- * This is a reliable method as all supported formatters implement this flag.
- *
- * @example
- * ```typescript
- * const formatter = await detectFormatter()
- * if (formatter) {
- *   console.log(`Using ${formatter} for formatting`)
- * } else {
- *   console.log('No formatter found')
- * }
- * ```
- */
-export async function detectFormatter(): Promise<Formatter | undefined> {
-  const formatterNames: Formatter[] = ['biome', 'oxfmt', 'prettier']
-
-  for (const formatter of formatterNames) {
-    if (await isFormatterAvailable(formatter)) {
-      return formatter
-    }
-  }
-
-  return undefined
-}

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: Partial<TOptions>
-}
-
-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
-}