@kubb/core 4.32.4 → 4.33.1

package/src/utils/Cache.ts

@@ -1,31 +0,0 @@
-export class Cache<T> {
-  #buffer = new Map<string, T>()
-
-  async get(key: string): Promise<T | null> {
-    return this.#buffer.get(key) ?? null
-  }
-
-  async set(key: string, value: T): Promise<void> {
-    this.#buffer.set(key, value)
-  }
-
-  async delete(key: string): Promise<void> {
-    this.#buffer.delete(key)
-  }
-
-  async clear(): Promise<void> {
-    this.#buffer.clear()
-  }
-
-  async keys(): Promise<string[]> {
-    return [...this.#buffer.keys()]
-  }
-
-  async values(): Promise<T[]> {
-    return [...this.#buffer.values()]
-  }
-
-  async flush(): Promise<void> {
-    // No-op for base cache
-  }
-}

package/src/utils/URLPath.ts

@@ -1,146 +0,0 @@
-import { camelCase, isValidVarName } from '../transformers'
-
-export type URLObject = {
-  url: string
-  params?: Record<string, string>
-}
-
-type ObjectOptions = {
-  type?: 'path' | 'template'
-  replacer?: (pathParam: string) => string
-  stringify?: boolean
-}
-
-type Options = {
-  casing?: 'camelcase'
-}
-
-export class URLPath {
-  path: string
-  #options: Options
-
-  constructor(path: string, options: Options = {}) {
-    this.path = path
-    this.#options = options
-
-    return this
-  }
-
-  /**
-   * Convert Swagger path to URLPath(syntax of Express)
-   * @example /pet/{petId} => /pet/:petId
-   */
-  get URL(): string {
-    return this.toURLPath()
-  }
-  get isURL(): boolean {
-    try {
-      const url = new URL(this.path)
-      if (url?.href) {
-        return true
-      }
-    } catch (_error) {
-      return false
-    }
-    return false
-  }
-
-  /**
-   * Convert Swagger path to template literals/ template strings(camelcase)
-   * @example /pet/{petId} => `/pet/${petId}`
-   * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
-   * @example /account/userID => `/account/${userId}`
-   */
-  get template(): string {
-    return this.toTemplateString()
-  }
-  get object(): URLObject | string {
-    return this.toObject()
-  }
-  get params(): Record<string, string> | undefined {
-    return this.getParams()
-  }
-
-  toObject({ type = 'path', replacer, stringify }: ObjectOptions = {}): URLObject | string {
-    const object = {
-      url: type === 'path' ? this.toURLPath() : this.toTemplateString({ replacer }),
-      params: this.getParams(),
-    }
-
-    if (stringify) {
-      if (type === 'template') {
-        return JSON.stringify(object).replaceAll("'", '').replaceAll(`"`, '')
-      }
-
-      if (object.params) {
-        return `{ url: '${object.url}', params: ${JSON.stringify(object.params).replaceAll("'", '').replaceAll(`"`, '')} }`
-      }
-
-      return `{ url: '${object.url}' }`
-    }
-
-    return object
-  }
-
-  /**
-   * Convert Swagger path to template literals/ template strings(camelcase)
-   * @example /pet/{petId} => `/pet/${petId}`
-   * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
-   * @example /account/userID => `/account/${userId}`
-   */
-  toTemplateString({ prefix = '', replacer }: { prefix?: string; replacer?: (pathParam: string) => string } = {}): string {
-    const regex = /{(\w|-)*}/g
-    const found = this.path.match(regex)
-    let newPath = this.path.replaceAll('{', '${')
-
-    if (found) {
-      newPath = found.reduce((prev, path) => {
-        const pathWithoutBrackets = path.replaceAll('{', '').replaceAll('}', '')
-
-        let param = isValidVarName(pathWithoutBrackets) ? pathWithoutBrackets : camelCase(pathWithoutBrackets)
-
-        if (this.#options.casing === 'camelcase') {
-          param = camelCase(param)
-        }
-
-        return prev.replace(path, `\${${replacer ? replacer(param) : param}}`)
-      }, this.path)
-    }
-
-    return `\`${prefix}${newPath}\``
-  }
-
-  getParams(replacer?: (pathParam: string) => string): Record<string, string> | undefined {
-    const regex = /{(\w|-)*}/g
-    const found = this.path.match(regex)
-
-    if (!found) {
-      return undefined
-    }
-
-    const params: Record<string, string> = {}
-    found.forEach((item) => {
-      item = item.replaceAll('{', '').replaceAll('}', '')
-
-      let param = isValidVarName(item) ? item : camelCase(item)
-
-      if (this.#options.casing === 'camelcase') {
-        param = camelCase(param)
-      }
-
-      const key = replacer ? replacer(param) : param
-
-      params[key] = key
-    }, this.path)
-
-    return params
-  }
-
-  /**
-   * Convert Swagger path to URLPath(syntax of Express)
-   * @example /pet/{petId} => /pet/:petId
-   */
-  toURLPath(): string {
-    return this.path.replaceAll('{', ':').replaceAll('}', '')
-  }
-}

package/src/utils/buildJSDoc.ts

@@ -1,34 +0,0 @@
-/**
- * Builds a JSDoc comment block with custom indentation.
- * @param comments - Array of comment strings to include in the JSDoc block
- * @param options - Configuration options for formatting
- * @returns Formatted JSDoc string or fallback string if no comments
- */
-export function buildJSDoc(
-  comments: Array<string>,
-  options: {
-    /**
-     * String to use for indenting each line of the JSDoc comment
-     * @default '   * ' (3 spaces + asterisk + space)
-     */
-    indent?: string
-    /**
-     * String to append after the closing JSDoc tag
-     * @default '\n  ' (newline + 2 spaces)
-     */
-    suffix?: string
-    /**
-     * String to return when there are no comments
-     * @default '  ' (2 spaces)
-     */
-    fallback?: string
-  } = {},
-): string {
-  const { indent = '   * ', suffix = '\n  ', fallback = '  ' } = options
-
-  if (comments.length === 0) {
-    return fallback
-  }
-
-  return `/**\n${comments.map((c) => `${indent}${c}`).join('\n')}\n   */${suffix}`
-}

package/src/utils/checkOnlineStatus.ts

@@ -1,40 +0,0 @@
-import dns from 'node:dns'
-
-/**
- * Check if the system has internet connectivity
- * Uses DNS lookup to well-known stable domains as a lightweight connectivity test
- */
-export async function isOnline(): Promise<boolean> {
-  const testDomains = [
-    'dns.google.com', // Google Public DNS
-    'cloudflare.com', // Cloudflare
-    'one.one.one.one', // Cloudflare DNS
-  ]
-
-  for (const domain of testDomains) {
-    try {
-      await dns.promises.resolve(domain)
-      return true
-    } catch {
-      // Try next domain
-    }
-  }
-
-  return false
-}
-
-/**
- * Execute a function only if online, otherwise silently skip
- */
-export async function executeIfOnline<T>(fn: () => Promise<T>): Promise<T | null> {
-  const online = await isOnline()
-  if (!online) {
-    return null
-  }
-
-  try {
-    return await fn()
-  } catch {
-    return null
-  }
-}

package/src/utils/formatHrtime.ts

@@ -1,33 +0,0 @@
-/**
- * Calculates elapsed time in milliseconds from a high-resolution start time.
- * Rounds to 2 decimal places to provide sub-millisecond precision without noise.
- */
-export function getElapsedMs(hrStart: [number, number]): number {
-  const [seconds, nanoseconds] = process.hrtime(hrStart)
-  const ms = seconds * 1000 + nanoseconds / 1e6
-  return Math.round(ms * 100) / 100
-}
-
-/**
- * Converts a millisecond duration into a human-readable string.
- * Adjusts units (ms, s, m s) based on the magnitude of the duration.
- */
-export function formatMs(ms: number): string {
-  if (ms >= 60000) {
-    const mins = Math.floor(ms / 60000)
-    const secs = ((ms % 60000) / 1000).toFixed(1)
-    return `${mins}m ${secs}s`
-  }
-
-  if (ms >= 1000) {
-    return `${(ms / 1000).toFixed(2)}s`
-  }
-  return `${Math.round(ms).toFixed(0)}ms`
-}
-
-/**
- * Convenience helper to get and format elapsed time in one step.
- */
-export function formatHrtime(hrStart: [number, number]): string {
-  return formatMs(getElapsedMs(hrStart))
-}

package/src/utils/getNestedAccessor.ts

@@ -1,25 +0,0 @@
-/**
- * Converts a param path (string with dot notation or array of strings) to a JavaScript accessor expression.
- * @param param - The param path, e.g., 'pagination.next.id' or ['pagination', 'next', 'id']
- * @param accessor - The base accessor, e.g., 'lastPage' or 'firstPage'
- * @returns A JavaScript accessor expression, e.g., "lastPage?.['pagination']?.['next']?.['id']", or undefined if param is empty
- *
- * @example
- * ```ts
- * getNestedAccessor('pagination.next.id', 'lastPage')
- * // returns: "lastPage?.['pagination']?.['next']?.['id']"
- *
- * getNestedAccessor(['pagination', 'next', 'id'], 'lastPage')
- * // returns: "lastPage?.['pagination']?.['next']?.['id']"
- *
- * getNestedAccessor('', 'lastPage')
- * // returns: undefined
- * ```
- */
-export function getNestedAccessor(param: string | string[], accessor: string): string | undefined {
-  const parts = Array.isArray(param) ? param : param.split('.')
-  if (parts.length === 0 || (parts.length === 1 && parts[0] === '')) {
-    return undefined
-  }
-  return parts.reduce((acc, part) => `${acc}?.['${part}']`, accessor)
-}

package/src/utils/index.ts

@@ -1,26 +0,0 @@
-export { AsyncEventEmitter } from './AsyncEventEmitter.ts'
-export { buildJSDoc } from './buildJSDoc.ts'
-export { Cache } from './Cache.ts'
-export { executeIfOnline, isOnline } from './checkOnlineStatus.ts'
-export type { FunctionParamsAST } from './FunctionParams.ts'
-export { FunctionParams } from './FunctionParams.ts'
-export { formatHrtime, formatMs, getElapsedMs } from './formatHrtime.ts'
-export { detectFormatter, formatters } from './formatters.ts'
-export { getBarrelFiles } from './getBarrelFiles.ts'
-export { getConfigs } from './getConfigs.ts'
-export { getNestedAccessor } from './getNestedAccessor.ts'
-export { detectLinter, linters } from './linters.ts'
-export type { PackageManagerInfo, PackageManagerName } from './packageManager.ts'
-export { detectPackageManager } from './packageManager.ts'
-export {
-  isPromise,
-  isPromiseFulfilledResult,
-  isPromiseRejectedResult,
-} from './promise.ts'
-export { renderTemplate } from './renderTemplate.ts'
-export { serializePluginOptions } from './serializePluginOptions.ts'
-export { timeout } from './timeout.ts'
-export { tokenize } from './tokenize.ts'
-export type { URLObject } from './URLPath.ts'
-export { URLPath } from './URLPath.ts'
-export { getUniqueName, setUniqueName } from './uniqueName.ts'

package/src/utils/packageManager.ts

@@ -1,58 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-
-export type PackageManagerName = 'npm' | 'pnpm' | 'yarn' | 'bun'
-
-export interface PackageManagerInfo {
-  name: PackageManagerName
-  lockFile: string
-  installCommand: string[]
-}
-
-const packageManagers: Record<PackageManagerName, PackageManagerInfo> = {
-  pnpm: {
-    name: 'pnpm',
-    lockFile: 'pnpm-lock.yaml',
-    installCommand: ['add', '-D'],
-  },
-  yarn: {
-    name: 'yarn',
-    lockFile: 'yarn.lock',
-    installCommand: ['add', '-D'],
-  },
-  bun: {
-    name: 'bun',
-    lockFile: 'bun.lockb',
-    installCommand: ['add', '-d'],
-  },
-  npm: {
-    name: 'npm',
-    lockFile: 'package-lock.json',
-    installCommand: ['install', '--save-dev'],
-  },
-}
-
-export function detectPackageManager(cwd: string = process.cwd()): PackageManagerInfo {
-  const packageJsonPath = path.join(cwd, 'package.json')
-  if (fs.existsSync(packageJsonPath)) {
-    try {
-      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'))
-      if (packageJson.packageManager) {
-        const [name] = packageJson.packageManager.split('@')
-        if (name in packageManagers) {
-          return packageManagers[name as PackageManagerName]
-        }
-      }
-    } catch {
-      // Continue to lock file detection
-    }
-  }
-
-  for (const pm of Object.values(packageManagers)) {
-    if (fs.existsSync(path.join(cwd, pm.lockFile))) {
-      return pm
-    }
-  }
-
-  return packageManagers.npm
-}

package/src/utils/promise.ts

@@ -1,13 +0,0 @@
-import type { PossiblePromise } from './types.ts'
-
-export function isPromise<T>(result: PossiblePromise<T>): result is Promise<T> {
-  return !!result && typeof (result as Promise<unknown>)?.then === 'function'
-}
-
-export function isPromiseFulfilledResult<T = unknown>(result: PromiseSettledResult<unknown>): result is PromiseFulfilledResult<T> {
-  return result.status === 'fulfilled'
-}
-
-export function isPromiseRejectedResult<T>(result: PromiseSettledResult<unknown>): result is Omit<PromiseRejectedResult, 'reason'> & { reason: T } {
-  return result.status === 'rejected'
-}

package/src/utils/renderTemplate.ts

@@ -1,31 +0,0 @@
-export function renderTemplate<TData extends Record<string, unknown> = Record<string, unknown>>(template: string, data: TData | undefined = undefined): string {
-  if (!data || !Object.keys(data).length) {
-    return template.replace(/{{(.*?)}}/g, '')
-  }
-
-  const matches = template.match(/{{(.*?)}}/g)
-
-  return (
-    matches?.reduce((prev, curr) => {
-      const index = curr.split(/{{|}}/).filter(Boolean)[0]?.trim()
-      if (index === undefined) {
-        return prev
-      }
-      const value = data[index]
-
-      if (value === undefined) {
-        return prev
-      }
-
-      return prev
-        .replace(curr, () => {
-          if (typeof value === 'boolean') {
-            return `${value.toString()}` || 'false'
-          }
-
-          return (value as string) || ''
-        })
-        .trim()
-    }, template) || ''
-  )
-}

package/src/utils/serializePluginOptions.ts

@@ -1,29 +0,0 @@
-/**
- * Serialize plugin options for safe JSON transport.
- * Strips functions, symbols, and undefined values recursively.
- */
-export function serializePluginOptions<TOptions extends object = object>(options: TOptions): TOptions {
-  if (options === null || options === undefined) {
-    return {} as TOptions
-  }
-  if (typeof options !== 'object') {
-    return options
-  }
-  if (Array.isArray(options)) {
-    return options.map(serializePluginOptions) as TOptions
-  }
-
-  const serialized: Record<string, unknown> = {}
-  for (const [key, value] of Object.entries(options)) {
-    if (typeof value === 'function' || typeof value === 'symbol' || value === undefined) {
-      continue
-    }
-    if (typeof value === 'object' && value !== null) {
-      serialized[key] = serializePluginOptions(value)
-    } else {
-      serialized[key] = value
-    }
-  }
-
-  return serialized as TOptions
-}

package/src/utils/timeout.ts

@@ -1,11 +0,0 @@
-export async function timeout(ms: number): Promise<unknown> {
-  return new Promise((resolve) => {
-    const timeout = setTimeout(() => {
-      resolve(timeout)
-    }, ms)
-  }).then((timeout) => {
-    clearTimeout(timeout as NodeJS.Timeout)
-
-    return true
-  })
-}

package/src/utils/tokenize.ts

@@ -1,23 +0,0 @@
-/** Shell-like tokenizer: splits a command string respecting single/double quotes. */
-export function tokenize(command: string): string[] {
-  const args: string[] = []
-  let current = ''
-  let quote = ''
-  for (const ch of command) {
-    if (quote) {
-      if (ch === quote) quote = ''
-      else current += ch
-    } else if (ch === '"' || ch === "'") {
-      quote = ch
-    } else if (ch === ' ' || ch === '\t') {
-      if (current) {
-        args.push(current)
-        current = ''
-      }
-    } else {
-      current += ch
-    }
-  }
-  if (current) args.push(current)
-  return args
-}

package/src/utils/types.ts

@@ -1 +0,0 @@
-export type PossiblePromise<T> = Promise<T> | T

package/src/utils/uniqueName.ts

@@ -1,20 +0,0 @@
-export function getUniqueName(originalName: string, data: Record<string, number>): string {
-  let used = data[originalName] || 0
-  if (used) {
-    data[originalName] = ++used
-    originalName += used
-  }
-  data[originalName] = 1
-  return originalName
-}
-
-export function setUniqueName(originalName: string, data: Record<string, number>): string {
-  let used = data[originalName] || 0
-  if (used) {
-    data[originalName] = ++used
-
-    return originalName
-  }
-  data[originalName] = 1
-  return originalName
-}