@kubb/core 4.33.0 → 4.33.1

package/dist/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","names":["#buffer","#items","#orderItems","#addParams"],"sources":["../src/utils/buildJSDoc.ts","../src/utils/Cache.ts","../src/utils/checkOnlineStatus.ts","../src/utils/FunctionParams.ts","../src/utils/formatters.ts","../src/utils/getPlugins.ts","../src/utils/promise.ts","../src/utils/getConfigs.ts","../src/utils/getNestedAccessor.ts","../src/utils/linters.ts","../src/utils/renderTemplate.ts","../src/utils/serializePluginOptions.ts","../src/utils/timeout.ts","../src/utils/tokenize.ts"],"sourcesContent":["/**\n * Builds a JSDoc comment block with custom indentation.\n * @param comments - Array of comment strings to include in the JSDoc block\n * @param options - Configuration options for formatting\n * @returns Formatted JSDoc string or fallback string if no comments\n */\nexport function buildJSDoc(\n  comments: Array<string>,\n  options: {\n    /**\n     * String to use for indenting each line of the JSDoc comment\n     * @default '   * ' (3 spaces + asterisk + space)\n     */\n    indent?: string\n    /**\n     * String to append after the closing JSDoc tag\n     * @default '\\n  ' (newline + 2 spaces)\n     */\n    suffix?: string\n    /**\n     * String to return when there are no comments\n     * @default '  ' (2 spaces)\n     */\n    fallback?: string\n  } = {},\n): string {\n  const { indent = '   * ', suffix = '\\n  ', fallback = '  ' } = options\n\n  if (comments.length === 0) {\n    return fallback\n  }\n\n  return `/**\\n${comments.map((c) => `${indent}${c}`).join('\\n')}\\n   */${suffix}`\n}\n","export class Cache<T> {\n  #buffer = new Map<string, T>()\n\n  async get(key: string): Promise<T | null> {\n    return this.#buffer.get(key) ?? null\n  }\n\n  async set(key: string, value: T): Promise<void> {\n    this.#buffer.set(key, value)\n  }\n\n  async delete(key: string): Promise<void> {\n    this.#buffer.delete(key)\n  }\n\n  async clear(): Promise<void> {\n    this.#buffer.clear()\n  }\n\n  async keys(): Promise<string[]> {\n    return [...this.#buffer.keys()]\n  }\n\n  async values(): Promise<T[]> {\n    return [...this.#buffer.values()]\n  }\n\n  async flush(): Promise<void> {\n    // No-op for base cache\n  }\n}\n","import dns from 'node:dns'\n\n/**\n * Check if the system has internet connectivity\n * Uses DNS lookup to well-known stable domains as a lightweight connectivity test\n */\nexport async function isOnline(): Promise<boolean> {\n  const testDomains = [\n    'dns.google.com', // Google Public DNS\n    'cloudflare.com', // Cloudflare\n    'one.one.one.one', // Cloudflare DNS\n  ]\n\n  for (const domain of testDomains) {\n    try {\n      await dns.promises.resolve(domain)\n      return true\n    } catch {\n      // Try next domain\n    }\n  }\n\n  return false\n}\n\n/**\n * Execute a function only if online, otherwise silently skip\n */\nexport async function executeIfOnline<T>(fn: () => Promise<T>): Promise<T | null> {\n  const online = await isOnline()\n  if (!online) {\n    return null\n  }\n\n  try {\n    return await fn()\n  } catch {\n    return null\n  }\n}\n","import { sortBy } from 'remeda'\nimport { camelCase } from '../transformers/casing.ts'\n\ntype FunctionParamsASTWithoutType = {\n  name?: string\n  type?: string\n  /**\n   * @default true\n   */\n  required?: boolean\n  /**\n   * @default true\n   */\n  enabled?: boolean\n  default?: string\n}\n\ntype FunctionParamsASTWithType = {\n  name?: never\n  type: string\n  /**\n   * @default true\n   */\n  required?: boolean\n  /**\n   * @default true\n   */\n  enabled?: boolean\n  default?: string\n}\n/**\n * @deprecated\n */\nexport type FunctionParamsAST = FunctionParamsASTWithoutType | FunctionParamsASTWithType\n\n/**\n * @deprecated\n */\nexport class FunctionParams {\n  #items: Array<FunctionParamsAST | FunctionParamsAST[]> = []\n  constructor() {\n    return this\n  }\n\n  get items(): FunctionParamsAST[] {\n    return this.#items.flat()\n  }\n\n  add(item: FunctionParamsAST | Array<FunctionParamsAST | FunctionParamsAST[] | undefined> | undefined): FunctionParams {\n    if (!item) {\n      return this\n    }\n\n    if (Array.isArray(item)) {\n      item.filter(Boolean).forEach((it) => {\n        this.#items.push(it)\n      })\n      return this\n    }\n    this.#items.push(item)\n\n    return this\n  }\n  static #orderItems(items: Array<FunctionParamsAST | FunctionParamsAST[]>) {\n    return sortBy(\n      items.filter(Boolean),\n      [(item) => Array.isArray(item), 'desc'], // arrays (rest params) first\n      [(item) => !Array.isArray(item) && (item as FunctionParamsAST).default !== undefined, 'asc'], // no-default before has-default\n      [(item) => Array.isArray(item) || ((item as FunctionParamsAST).required ?? true), 'desc'], // required before optional\n    )\n  }\n\n  static #addParams(acc: string[], item: FunctionParamsAST) {\n    const { enabled = true, name, type, required = true, ...rest } = item\n\n    if (!enabled) {\n      return acc\n    }\n\n    if (!name) {\n      // when name is not se we uses TypeScript generics\n      acc.push(`${type}${rest.default ? ` = ${rest.default}` : ''}`)\n\n      return acc\n    }\n    // TODO check whey we still need the camelcase here\n    const parameterName = name.startsWith('{') ? name : camelCase(name)\n\n    if (type) {\n      if (required) {\n        acc.push(`${parameterName}: ${type}${rest.default ? ` = ${rest.default}` : ''}`)\n      } else {\n        acc.push(`${parameterName}?: ${type}`)\n      }\n    } else {\n      acc.push(`${parameterName}`)\n    }\n\n    return acc\n  }\n\n  static toObject(items: FunctionParamsAST[]): FunctionParamsAST {\n    let type: string[] = []\n    let name: string[] = []\n\n    const enabled = items.every((item) => item.enabled) ? items.at(0)?.enabled : true\n    const required = items.every((item) => item.required) ?? true\n\n    items.forEach((item) => {\n      name = FunctionParams.#addParams(name, { ...item, type: undefined })\n      if (items.some((item) => item.type)) {\n        type = FunctionParams.#addParams(type, item)\n      }\n    })\n\n    return {\n      name: `{ ${name.join(', ')} }`,\n      type: type.length ? `{ ${type.join('; ')} }` : undefined,\n      enabled,\n      required,\n    }\n  }\n\n  toObject(): FunctionParamsAST {\n    const items = FunctionParams.#orderItems(this.#items).flat()\n\n    return FunctionParams.toObject(items)\n  }\n\n  static toString(items: (FunctionParamsAST | FunctionParamsAST[])[]): string {\n    const sortedData = FunctionParams.#orderItems(items)\n\n    return sortedData\n      .reduce((acc, item) => {\n        if (Array.isArray(item)) {\n          if (item.length <= 0) {\n            return acc\n          }\n          const subItems = FunctionParams.#orderItems(item) as FunctionParamsAST[]\n          const objectItem = FunctionParams.toObject(subItems)\n\n          return FunctionParams.#addParams(acc, objectItem)\n        }\n\n        return FunctionParams.#addParams(acc, item)\n      }, [] as string[])\n      .join(', ')\n  }\n\n  toString(): string {\n    const items = FunctionParams.#orderItems(this.#items)\n\n    return FunctionParams.toString(items)\n  }\n}\n","import { x } from 'tinyexec'\n\nexport const formatters = {\n  prettier: {\n    command: 'prettier',\n    args: (outputPath: string) => ['--ignore-unknown', '--write', outputPath],\n    errorMessage: 'Prettier not found',\n  },\n  biome: {\n    command: 'biome',\n    args: (outputPath: string) => ['format', '--write', outputPath],\n    errorMessage: 'Biome not found',\n  },\n  oxfmt: {\n    command: 'oxfmt',\n    args: (outputPath: string) => [outputPath],\n    errorMessage: 'Oxfmt not found',\n  },\n} as const\n\ntype Formatter = keyof typeof formatters\n\n/**\n * Check if a formatter command is available in the system.\n *\n * @param formatter - The formatter to check ('biome', 'prettier', or 'oxfmt')\n * @returns Promise that resolves to true if the formatter is available, false otherwise\n *\n * @remarks\n * This function checks availability by running `<formatter> --version` command.\n * All supported formatters (biome, prettier, oxfmt) implement the --version flag.\n */\nasync function isFormatterAvailable(formatter: Formatter): Promise<boolean> {\n  try {\n    // Try to get the version of the formatter to check if it's installed\n    await x(formatter, ['--version'], { nodeOptions: { stdio: 'ignore' } })\n    return true\n  } catch {\n    return false\n  }\n}\n\n/**\n * Detect which formatter is available in the system.\n *\n * @returns Promise that resolves to the first available formatter or undefined if none are found\n *\n * @remarks\n * Checks in order of preference: biome, oxfmt, prettier.\n * Uses the `--version` flag to detect if each formatter command is available.\n * This is a reliable method as all supported formatters implement this flag.\n *\n * @example\n * ```typescript\n * const formatter = await detectFormatter()\n * if (formatter) {\n *   console.log(`Using ${formatter} for formatting`)\n * } else {\n *   console.log('No formatter found')\n * }\n * ```\n */\nexport async function detectFormatter(): Promise<Formatter | undefined> {\n  const formatters: Formatter[] = ['biome', 'oxfmt', 'prettier']\n\n  for (const formatter of formatters) {\n    if (await isFormatterAvailable(formatter)) {\n      return formatter\n    }\n  }\n\n  return undefined\n}\n","import type { UserConfig } from '../types.ts'\n\nfunction isJSONPlugins(plugins: UserConfig['plugins']) {\n  return !!(plugins as any)?.some((plugin: any) => {\n    return Array.isArray(plugin) && typeof plugin?.at(0) === 'string'\n  })\n}\n\nfunction isObjectPlugins(plugins: UserConfig['plugins']): plugins is any {\n  return plugins instanceof Object && !Array.isArray(plugins)\n}\n\nexport function getPlugins(plugins: UserConfig['plugins']): Promise<UserConfig['plugins']> {\n  if (isObjectPlugins(plugins)) {\n    throw new Error('Object plugins are not supported anymore, best to use http://kubb.dev/getting-started/configure#json')\n  }\n\n  if (isJSONPlugins(plugins)) {\n    throw new Error('JSON plugins are not supported anymore, best to use http://kubb.dev/getting-started/configure#json')\n  }\n\n  return Promise.resolve(plugins)\n}\n","import type { PossiblePromise } from './types.ts'\n\nexport function isPromise<T>(result: PossiblePromise<T>): result is Promise<T> {\n  return !!result && typeof (result as Promise<unknown>)?.then === 'function'\n}\n\nexport function isPromiseFulfilledResult<T = unknown>(result: PromiseSettledResult<unknown>): result is PromiseFulfilledResult<T> {\n  return result.status === 'fulfilled'\n}\n\nexport function isPromiseRejectedResult<T>(result: PromiseSettledResult<unknown>): result is Omit<PromiseRejectedResult, 'reason'> & { reason: T } {\n  return result.status === 'rejected'\n}\n","import type { CLIOptions, defineConfig } from '../config.ts'\nimport type { Config, UserConfig } from '../types.ts'\nimport { getPlugins } from './getPlugins.ts'\nimport { isPromise } from './promise.ts'\n\n/**\n * Converting UserConfig to Config Array without a change in the object beside the JSON convert.\n */\nexport async function getConfigs(config: ReturnType<typeof defineConfig> | UserConfig, args: CLIOptions): Promise<Array<Config>> {\n  let kubbUserConfig = Promise.resolve(config) as Promise<UserConfig | Array<UserConfig>>\n\n  // for ts or js files\n  if (typeof config === 'function') {\n    const possiblePromise = config(args as CLIOptions)\n    if (isPromise(possiblePromise)) {\n      kubbUserConfig = possiblePromise\n    }\n    kubbUserConfig = Promise.resolve(possiblePromise)\n  }\n\n  let JSONConfig = await kubbUserConfig\n\n  if (!Array.isArray(JSONConfig)) {\n    JSONConfig = [JSONConfig]\n  }\n\n  const results: Array<Config> = []\n\n  for (const item of JSONConfig) {\n    const plugins = item.plugins ? await getPlugins(item.plugins) : undefined\n\n    results.push({\n      ...item,\n      plugins,\n    } as Config)\n  }\n\n  return results\n}\n","/**\n * Converts a param path (string with dot notation or array of strings) to a JavaScript accessor expression.\n * @param param - The param path, e.g., 'pagination.next.id' or ['pagination', 'next', 'id']\n * @param accessor - The base accessor, e.g., 'lastPage' or 'firstPage'\n * @returns A JavaScript accessor expression, e.g., \"lastPage?.['pagination']?.['next']?.['id']\", or undefined if param is empty\n *\n * @example\n * ```ts\n * getNestedAccessor('pagination.next.id', 'lastPage')\n * // returns: \"lastPage?.['pagination']?.['next']?.['id']\"\n *\n * getNestedAccessor(['pagination', 'next', 'id'], 'lastPage')\n * // returns: \"lastPage?.['pagination']?.['next']?.['id']\"\n *\n * getNestedAccessor('', 'lastPage')\n * // returns: undefined\n * ```\n */\nexport function getNestedAccessor(param: string | string[], accessor: string): string | undefined {\n  const parts = Array.isArray(param) ? param : param.split('.')\n  if (parts.length === 0 || (parts.length === 1 && parts[0] === '')) {\n    return undefined\n  }\n  return parts.reduce((acc, part) => `${acc}?.['${part}']`, accessor)\n}\n","import { x } from 'tinyexec'\n\nexport const linters = {\n  eslint: {\n    command: 'eslint',\n    args: (outputPath: string) => [outputPath, '--fix'],\n    errorMessage: 'Eslint not found',\n  },\n  biome: {\n    command: 'biome',\n    args: (outputPath: string) => ['lint', '--fix', outputPath],\n    errorMessage: 'Biome not found',\n  },\n  oxlint: {\n    command: 'oxlint',\n    args: (outputPath: string) => ['--fix', outputPath],\n    errorMessage: 'Oxlint not found',\n  },\n} as const\n\ntype Linter = keyof typeof linters\n\nasync function isLinterAvailable(linter: Linter): Promise<boolean> {\n  try {\n    await x(linter, ['--version'], { nodeOptions: { stdio: 'ignore' } })\n    return true\n  } catch {\n    return false\n  }\n}\n\nexport async function detectLinter(): Promise<Linter | undefined> {\n  const linters: Linter[] = ['biome', 'oxlint', 'eslint']\n\n  for (const linter of linters) {\n    if (await isLinterAvailable(linter)) {\n      return linter\n    }\n  }\n\n  return undefined\n}\n","export function renderTemplate<TData extends Record<string, unknown> = Record<string, unknown>>(template: string, data: TData | undefined = undefined): string {\n  if (!data || !Object.keys(data).length) {\n    return template.replace(/{{(.*?)}}/g, '')\n  }\n\n  const matches = template.match(/{{(.*?)}}/g)\n\n  return (\n    matches?.reduce((prev, curr) => {\n      const index = curr.split(/{{|}}/).filter(Boolean)[0]?.trim()\n      if (index === undefined) {\n        return prev\n      }\n      const value = data[index]\n\n      if (value === undefined) {\n        return prev\n      }\n\n      return prev\n        .replace(curr, () => {\n          if (typeof value === 'boolean') {\n            return `${value.toString()}` || 'false'\n          }\n\n          return (value as string) || ''\n        })\n        .trim()\n    }, template) || ''\n  )\n}\n","/**\n * Serialize plugin options for safe JSON transport.\n * Strips functions, symbols, and undefined values recursively.\n */\nexport function serializePluginOptions<TOptions extends object = object>(options: TOptions): TOptions {\n  if (options === null || options === undefined) {\n    return {} as TOptions\n  }\n  if (typeof options !== 'object') {\n    return options\n  }\n  if (Array.isArray(options)) {\n    return options.map(serializePluginOptions) as TOptions\n  }\n\n  const serialized: Record<string, unknown> = {}\n  for (const [key, value] of Object.entries(options)) {\n    if (typeof value === 'function' || typeof value === 'symbol' || value === undefined) {\n      continue\n    }\n    if (typeof value === 'object' && value !== null) {\n      serialized[key] = serializePluginOptions(value)\n    } else {\n      serialized[key] = value\n    }\n  }\n\n  return serialized as TOptions\n}\n","export async function timeout(ms: number): Promise<unknown> {\n  return new Promise((resolve) => {\n    const timeout = setTimeout(() => {\n      resolve(timeout)\n    }, ms)\n  }).then((timeout) => {\n    clearTimeout(timeout as NodeJS.Timeout)\n\n    return true\n  })\n}\n","/** Shell-like tokenizer: splits a command string respecting single/double quotes. */\nexport function tokenize(command: string): string[] {\n  const args: string[] = []\n  let current = ''\n  let quote = ''\n  for (const ch of command) {\n    if (quote) {\n      if (ch === quote) quote = ''\n      else current += ch\n    } else if (ch === '\"' || ch === \"'\") {\n      quote = ch\n    } else if (ch === ' ' || ch === '\\t') {\n      if (current) {\n        args.push(current)\n        current = ''\n      }\n    } else {\n      current += ch\n    }\n  }\n  if (current) args.push(current)\n  return args\n}\n"],"mappings":"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"}

package/src/BaseGenerator.ts

@@ -1,34 +0,0 @@
-/**
- * Abstract class that contains the building blocks for plugins to create their own Generator
- * @link idea based on https://github.com/colinhacks/zod/blob/master/src/types.ts#L137
- */
-export abstract class BaseGenerator<TOptions = unknown, TContext = unknown> {
-  #options: TOptions = {} as TOptions
-  #context: TContext = {} as TContext
-
-  constructor(options?: TOptions, context?: TContext) {
-    if (context) {
-      this.#context = context
-    }
-
-    if (options) {
-      this.#options = options
-    }
-
-    return this
-  }
-
-  get options(): TOptions {
-    return this.#options
-  }
-
-  get context(): TContext {
-    return this.#context
-  }
-
-  set options(options: TOptions) {
-    this.#options = { ...this.#options, ...options }
-  }
-
-  abstract build(...params: unknown[]): unknown
-}

package/src/fs/clean.ts

@@ -1,5 +0,0 @@
-import { rm } from 'node:fs/promises'
-
-export async function clean(path: string): Promise<void> {
-  return rm(path, { recursive: true, force: true })
-}

package/src/fs/exists.ts

@@ -1,16 +0,0 @@
-import fs from 'node:fs'
-import { access } from 'node:fs/promises'
-
-export async function exists(path: string): Promise<boolean> {
-  if (typeof Bun !== 'undefined') {
-    return Bun.file(path).exists()
-  }
-  return access(path).then(
-    () => true,
-    () => false,
-  )
-}
-
-export function existsSync(path: string): boolean {
-  return fs.existsSync(path)
-}

package/src/fs/index.ts

@@ -1,5 +0,0 @@
-export { clean } from './clean.ts'
-export { exists } from './exists.ts'
-export { read, readSync } from './read.ts'
-export { getRelativePath } from './utils.ts'
-export { write } from './write.ts'

package/src/fs/read.ts

@@ -1,13 +0,0 @@
-import { readFileSync } from 'node:fs'
-import { readFile } from 'node:fs/promises'
-
-export async function read(path: string): Promise<string> {
-  if (typeof Bun !== 'undefined') {
-    return Bun.file(path).text()
-  }
-  return readFile(path, { encoding: 'utf8' })
-}
-
-export function readSync(path: string): string {
-  return readFileSync(path, { encoding: 'utf8' })
-}

package/src/fs/utils.ts

@@ -1,32 +0,0 @@
-import { normalize, relative } from 'node:path'
-
-function slash(path: string, platform: 'windows' | 'mac' | 'linux' = 'linux') {
-  const isWindowsPath = /^\\\\\?\\/.test(path)
-  const normalizedPath = normalize(path)
-
-  if (['linux', 'mac'].includes(platform) && !isWindowsPath) {
-    // linux and mac
-    return normalizedPath.replaceAll(/\\/g, '/').replace('../', '')
-  }
-
-  // windows
-  return normalizedPath.replaceAll(/\\/g, '/').replace('../', '')
-}
-
-export function getRelativePath(rootDir?: string | null, filePath?: string | null, platform: 'windows' | 'mac' | 'linux' = 'linux'): string {
-  if (!rootDir || !filePath) {
-    throw new Error(`Root and file should be filled in when retrieving the relativePath, ${rootDir || ''} ${filePath || ''}`)
-  }
-
-  const relativePath = relative(rootDir, filePath)
-
-  // On Windows, paths are separated with a "\"
-  // However, web browsers use "/" no matter the platform
-  const slashedPath = slash(relativePath, platform)
-
-  if (slashedPath.startsWith('../')) {
-    return slashedPath
-  }
-
-  return `./${slashedPath}`
-}

package/src/fs/write.ts

@@ -1,46 +0,0 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises'
-import { dirname, resolve } from 'node:path'
-
-type Options = { sanity?: boolean }
-
-export async function write(path: string, data: string, options: Options = {}): Promise<string | undefined> {
-  if (data.trim() === '') {
-    return undefined
-  }
-
-  const resolved = resolve(path)
-
-  if (typeof Bun !== 'undefined') {
-    const file = Bun.file(resolved)
-    const oldContent = (await file.exists()) ? await file.text() : null
-    if (oldContent === data.trim()) {
-      return undefined
-    }
-    await Bun.write(resolved, data.trim())
-    return data.trim()
-  }
-
-  try {
-    const oldContent = await readFile(resolved, { encoding: 'utf-8' })
-    if (oldContent?.toString() === data.trim()) {
-      return undefined
-    }
-  } catch (_err) {
-    /* file doesn't exist yet */
-  }
-
-  await mkdir(dirname(resolved), { recursive: true })
-  await writeFile(resolved, data.trim(), { encoding: 'utf-8' })
-
-  if (options.sanity) {
-    const savedData = await readFile(resolved, { encoding: 'utf-8' })
-
-    if (savedData?.toString() !== data.trim()) {
-      throw new Error(`Sanity check failed for ${path}\n\nData[${data.length}]:\n${data}\n\nSaved[${savedData.length}]:\n${savedData}\n`)
-    }
-
-    return savedData
-  }
-
-  return data.trim()
-}

package/src/transformers/casing.ts

@@ -1,62 +0,0 @@
-type Options = {
-  /**
-   * When set it will replace all `.` with `/`.
-   */
-  isFile?: boolean
-  prefix?: string
-  suffix?: string
-}
-
-function toCamelOrPascal(text: string, pascal: boolean): string {
-  const normalized = text
-    .trim()
-    .replace(/([a-z\d])([A-Z])/g, '$1 $2')
-    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
-    .replace(/(\d)([a-z])/g, '$1 $2')
-
-  const words = normalized.split(/[\s\-_./\\:]+/).filter(Boolean)
-
-  return words
-    .map((word, i) => {
-      const allUpper = word.length > 1 && word === word.toUpperCase()
-      if (allUpper) return word
-      if (i === 0 && !pascal) return word[0]!.toLowerCase() + word.slice(1)
-      return word[0]!.toUpperCase() + word.slice(1)
-    })
-    .join('')
-    .replace(/[^a-zA-Z0-9]/g, '')
-}
-
-export function camelCase(text: string, { isFile, prefix = '', suffix = '' }: Options = {}): string {
-  if (isFile) {
-    const splitArray = text.split('.')
-    return splitArray.map((item, i) => (i === splitArray.length - 1 ? camelCase(item, { prefix, suffix }) : camelCase(item))).join('/')
-  }
-
-  return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false)
-}
-
-export function pascalCase(text: string, { isFile, prefix = '', suffix = '' }: Options = {}): string {
-  if (isFile) {
-    const splitArray = text.split('.')
-    return splitArray.map((item, i) => (i === splitArray.length - 1 ? pascalCase(item, { prefix, suffix }) : camelCase(item))).join('/')
-  }
-
-  return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true)
-}
-
-export function snakeCase(text: string, { prefix = '', suffix = '' }: Omit<Options, 'isFile'> = {}): string {
-  const processed = `${prefix} ${text} ${suffix}`.trim()
-  // Convert to lowercase and replace non-alphanumeric characters with underscores
-  return processed
-    .replace(/([a-z])([A-Z])/g, '$1_$2') // camelCase to snake_case
-    .replace(/[\s\-.]+/g, '_') // spaces, hyphens, dots to underscores
-    .replace(/[^a-zA-Z0-9_]/g, '') // remove other special chars
-    .toLowerCase()
-    .replace(/_+/g, '_') // collapse multiple underscores
-    .replace(/^_|_$/g, '') // trim underscores from start and end
-}
-
-export function screamingSnakeCase(text: string, { prefix = '', suffix = '' }: Omit<Options, 'isFile'> = {}): string {
-  return snakeCase(text, { prefix, suffix }).toUpperCase()
-}

package/src/transformers/combineCodes.ts

@@ -1,3 +0,0 @@
-export function combineCodes(codes: string[]): string {
-  return codes.join('\n')
-}

package/src/transformers/createJSDocBlockText.ts

@@ -1,9 +0,0 @@
-export function createJSDocBlockText({ comments }: { comments: Array<string> }): string {
-  const filteredComments = comments.filter(Boolean)
-
-  if (!filteredComments.length) {
-    return ''
-  }
-
-  return `/**\n * ${filteredComments.join('\n * ')}\n */`
-}

package/src/transformers/escape.ts

@@ -1,31 +0,0 @@
-export function escape(text?: string): string {
-  return text ? text.replaceAll('`', '\\`') : ''
-}
-
-/**
- * Escape all characters not included in SingleStringCharacters and DoubleStringCharacters on
- * @link http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4
- * @link https://github.com/joliss/js-string-escape/blob/master/index.js
- */
-
-export function jsStringEscape(input: any): string {
-  return `${input}`.replace(/["'\\\n\r\u2028\u2029]/g, (character) => {
-    switch (character) {
-      case '"':
-      case "'":
-      case '\\':
-        return `\\${character}`
-      // Four possible LineTerminator characters need to be escaped:
-      case '\n':
-        return '\\n'
-      case '\r':
-        return '\\r'
-      case '\u2028':
-        return '\\u2028'
-      case '\u2029':
-        return '\\u2029'
-      default:
-        return ''
-    }
-  })
-}

package/src/transformers/indent.ts

@@ -1,3 +0,0 @@
-export function createIndent(size: number): string {
-  return Array.from({ length: size + 1 }).join(' ')
-}

package/src/transformers/index.ts

@@ -1,46 +0,0 @@
-import { camelCase, pascalCase, screamingSnakeCase, snakeCase } from './casing.ts'
-import { combineCodes } from './combineCodes.ts'
-import { createJSDocBlockText } from './createJSDocBlockText.ts'
-import { escape, jsStringEscape } from './escape.ts'
-import { createIndent } from './indent.ts'
-import { nameSorter } from './nameSorter.ts'
-import { searchAndReplace } from './searchAndReplace.ts'
-import { stringify, stringifyObject } from './stringify.ts'
-import { toRegExpString } from './toRegExp.ts'
-import { isValidVarName, transformReservedWord } from './transformReservedWord.ts'
-import { trim, trimQuotes } from './trim.ts'
-
-export { camelCase, pascalCase, screamingSnakeCase, snakeCase } from './casing.ts'
-export { combineCodes } from './combineCodes.ts'
-export { createJSDocBlockText } from './createJSDocBlockText.ts'
-export { escape, jsStringEscape } from './escape.ts'
-export { createIndent } from './indent.ts'
-export { nameSorter } from './nameSorter.ts'
-export { searchAndReplace } from './searchAndReplace.ts'
-export { stringify, stringifyObject } from './stringify.ts'
-export { toRegExpString } from './toRegExp.ts'
-export { isValidVarName, transformReservedWord } from './transformReservedWord.ts'
-export { trim, trimQuotes } from './trim.ts'
-
-export default {
-  combineCodes,
-  escape,
-  jsStringEscape,
-  createIndent,
-  transformReservedWord,
-  isValidVarName,
-  nameSorter,
-  searchAndReplace,
-  stringify,
-  stringifyObject,
-  toRegExpString,
-  trim,
-  trimQuotes,
-  JSDoc: {
-    createJSDocBlockText,
-  },
-  camelCase,
-  pascalCase,
-  snakeCase,
-  screamingSnakeCase,
-} as const

package/src/transformers/nameSorter.ts

@@ -1,9 +0,0 @@
-export function nameSorter<T extends { name: string }>(a: T, b: T): 0 | 1 | -1 {
-  if (a.name < b.name) {
-    return -1
-  }
-  if (a.name > b.name) {
-    return 1
-  }
-  return 0
-}

package/src/transformers/searchAndReplace.ts

@@ -1,25 +0,0 @@
-type Options = {
-  text: string
-  replaceBy: string
-  prefix?: string
-  key: string
-  searchValues?: (prefix: string, key: string) => Array<RegExp | string>
-}
-
-export function searchAndReplace(options: Options): string {
-  const { text, replaceBy, prefix = '', key } = options
-
-  const searchValues = options.searchValues?.(prefix, key) || [
-    `${prefix}["${key}"]`,
-    `${prefix}['${key}']`,
-    `${prefix}[\`${key}\`]`,
-    `${prefix}"${key}"`,
-    `${prefix}'${key}'`,
-    `${prefix}\`${key}\``,
-    new RegExp(`${prefix}${key}`, 'g'),
-  ]
-
-  return searchValues.reduce((prev, searchValue) => {
-    return prev.toString().replaceAll(searchValue, replaceBy)
-  }, text) as string
-}

package/src/transformers/stringify.ts

@@ -1,25 +0,0 @@
-import { trimQuotes } from './trim'
-
-export function stringify(value: string | number | boolean | undefined): string {
-  if (value === undefined || value === null) {
-    return '""'
-  }
-
-  return JSON.stringify(trimQuotes(value.toString()))
-}
-
-export function stringifyObject(value: object): string {
-  const items = Object.entries(value)
-    .map(([key, value]) => {
-      if (typeof value === 'object') {
-        return `${key}: {
-        ${stringifyObject(value)}
-      }`
-      }
-
-      return `${key}: ${value}`
-    })
-    .filter(Boolean)
-
-  return items.join(',\n')
-}

package/src/transformers/toRegExp.ts

@@ -1,22 +0,0 @@
-import { trimQuotes } from './trim'
-
-export function toRegExpString(text: string, func: string | null = 'RegExp'): string {
-  const raw = trimQuotes(text)
-
-  const [, replacementTarget = '', matchedFlags] = raw.match(/^\^(\(\?([igmsuy]+)\))/i) ?? []
-  const cleaned = raw
-    .replace(/^\\?\//, '')
-    .replace(/\\?\/$/, '')
-    .replace(replacementTarget, '')
-
-  const regex = new RegExp(cleaned, matchedFlags)
-  const source = regex.source
-  const flags = regex.flags
-
-  if (func === null) {
-    return `/${source}/${flags}`
-  }
-
-  // return as constructor → new RegExp("pattern", "flags")
-  return `new ${func}(${JSON.stringify(source)}${flags ? `, ${JSON.stringify(flags)}` : ''})`
-}

package/src/transformers/transformReservedWord.ts

@@ -1,106 +0,0 @@
-/**
- * @link https://github.com/jonschlinkert/reserved/blob/master/index.js
- */
-const reservedWords = [
-  'abstract',
-  'arguments',
-  'boolean',
-  'break',
-  'byte',
-  'case',
-  'catch',
-  'char',
-  'class',
-  'const',
-  'continue',
-  'debugger',
-  'default',
-  'delete',
-  'do',
-  'double',
-  'else',
-  'enum',
-  'eval',
-  'export',
-  'extends',
-  'false',
-  'final',
-  'finally',
-  'float',
-  'for',
-  'function',
-  'goto',
-  'if',
-  'implements',
-  'import',
-  'in',
-  'instanceof',
-  'int',
-  'interface',
-  'let',
-  'long',
-  'native',
-  'new',
-  'null',
-  'package',
-  'private',
-  'protected',
-  'public',
-  'return',
-  'short',
-  'static',
-  'super',
-  'switch',
-  'synchronized',
-  'this',
-  'throw',
-  'throws',
-  'transient',
-  'true',
-  'try',
-  'typeof',
-  'var',
-  'void',
-  'volatile',
-  'while',
-  'with',
-  'yield',
-
-  'Array',
-  'Date',
-  'eval',
-  'function',
-  'hasOwnProperty',
-  'Infinity',
-  'isFinite',
-  'isNaN',
-  'isPrototypeOf',
-  'length',
-  'Math',
-  'name',
-  'NaN',
-  'Number',
-  'Object',
-  'prototype',
-  'String',
-  'toString',
-  'undefined',
-  'valueOf',
-]
-
-export function transformReservedWord(word: string): string {
-  if ((word && reservedWords.includes(word)) || word?.match(/^\d/)) {
-    return `_${word}`
-  }
-
-  return word
-}
-
-export function isValidVarName(name: string) {
-  try {
-    Function(`var ${name}`)
-  } catch (_e) {
-    return false
-  }
-  return true
-}

package/src/transformers/trim.ts

@@ -1,18 +0,0 @@
-export function trim(text: string): string {
-  return text.trim()
-}
-
-export function trimQuotes(text: string): string {
-  if (text.match(/^"(.*)"$/)) {
-    return text.replace(/^"(.*)"$/, '$1')
-  }
-  if (text.match(/^'(.*)'$/)) {
-    return text.replace(/^'(.*)'$/, '$1')
-  }
-
-  if (text.match(/^`(.*)`$/)) {
-    return text.replace(/^`(.*)`$/, '$1')
-  }
-
-  return text
-}

package/src/utils/AsyncEventEmitter.ts

@@ -1,48 +0,0 @@
-import { EventEmitter as NodeEventEmitter } from 'node:events'
-
-export class AsyncEventEmitter<TEvents extends Record<string, any>> {
-  constructor(maxListener = 100) {
-    this.#emitter.setMaxListeners(maxListener)
-  }
-  #emitter = new NodeEventEmitter()
-
-  async emit<TEventName extends keyof TEvents & string>(eventName: TEventName, ...eventArgs: TEvents[TEventName]): Promise<void> {
-    const listeners = this.#emitter.listeners(eventName) as Array<(...args: TEvents[TEventName]) => any>
-
-    if (listeners.length === 0) {
-      return undefined
-    }
-
-    await Promise.all(
-      listeners.map(async (listener) => {
-        try {
-          return await listener(...eventArgs)
-        } catch (err) {
-          const causedError = err as Error
-          const error = new Error(`Error in async listener for "${eventName}" with eventArgs "${eventArgs}"`, { cause: causedError })
-
-          throw error
-        }
-      }),
-    )
-  }
-
-  on<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: (...eventArg: TEvents[TEventName]) => void): void {
-    this.#emitter.on(eventName, handler as any)
-  }
-
-  onOnce<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: (...eventArgs: TEvents[TEventName]) => void): void {
-    const wrapper = (...args: TEvents[TEventName]) => {
-      this.off(eventName, wrapper)
-      handler(...args)
-    }
-    this.on(eventName, wrapper)
-  }
-
-  off<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: (...eventArg: TEvents[TEventName]) => void): void {
-    this.#emitter.off(eventName, handler as any)
-  }
-  removeAll(): void {
-    this.#emitter.removeAllListeners()
-  }
-}