@kubb/core 2.4.0 → 2.5.0

package/src/PluginManager.ts

@@ -17,18 +17,18 @@ import type { KubbFile } from './FileManager.ts'
 import type { Logger } from './logger.ts'
 import type { CorePluginOptions } from './plugin.ts'
 import type {
+  Config,
   GetPluginFactoryOptions,
-  KubbConfig,
-  KubbPlugin,
-  KubbPluginWithLifeCycle,
-  KubbUserPlugin,
-  KubbUserPluginWithLifeCycle,
+  Plugin,
   PluginFactoryOptions,
   PluginLifecycle,
   PluginLifecycleHooks,
   PluginParameter,
+  PluginWithLifeCycle,
   ResolveNameParams,
   ResolvePathParams,
+  UserPlugin,
+  UserPluginWithLifeCycle,
 } from './types.ts'
 
 type RequiredPluginLifecycle = Required<PluginLifecycle>
@@ -44,7 +44,7 @@ type Strategy = 'hookFirst' | 'hookForPlugin' | 'hookParallel' | 'hookReduceArg0
 type Executer<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
   strategy: Strategy
   hookName: H
-  plugin: KubbPlugin
+  plugin: Plugin
   parameters?: unknown[] | undefined
   output?: unknown
 }
@@ -53,7 +53,7 @@ type ParseResult<H extends PluginLifecycleHooks> = RequiredPluginLifecycle[H]
 
 type SafeParseResult<H extends PluginLifecycleHooks, Result = ReturnType<ParseResult<H>>> = {
   result: Result
-  plugin: KubbPlugin
+  plugin: Plugin
 }
 
 // inspired by: https://github.com/rollup/rollup/blob/master/src/utils/PluginDriver.ts#
@@ -74,22 +74,22 @@ type Events = {
 }
 
 export class PluginManager {
-  readonly plugins: KubbPluginWithLifeCycle[]
+  readonly plugins: PluginWithLifeCycle[]
   readonly fileManager: FileManager
   readonly events: EventEmitter<Events> = new EventEmitter()
 
-  readonly config: KubbConfig
+  readonly config: Config
 
   readonly executed: Array<Executer> = []
   readonly logger: Logger
-  readonly #core: KubbPlugin<CorePluginOptions>
+  readonly #core: Plugin<CorePluginOptions>
 
   readonly #usedPluginNames: Record<string, number> = {}
   readonly #promiseManager: PromiseManager
 
   readonly queue: PQueue
 
-  constructor(config: KubbConfig, options: Options) {
+  constructor(config: Config, options: Options) {
     this.config = config
     this.logger = options.logger
     this.queue = new PQueue({ concurrency: 1 })
@@ -109,10 +109,10 @@ export class PluginManager {
     })
 
     // call core.api.call with empty context so we can transform `api()` to `api: {}`
-    this.#core = this.#parse(core as unknown as KubbUserPlugin, this as any, core.api.call(null as any)) as KubbPlugin<CorePluginOptions>
+    this.#core = this.#parse(core as unknown as UserPlugin, this as any, core.api.call(null as any)) as Plugin<CorePluginOptions>
 
     this.plugins = [this.#core, ...plugins].map((plugin) => {
-      return this.#parse(plugin as KubbUserPlugin, this, this.#core.api)
+      return this.#parse(plugin as UserPlugin, this, this.#core.api)
     })
 
     return this
@@ -127,11 +127,11 @@ export class PluginManager {
       })
 
       if (paths && paths?.length > 1 && this.logger.logLevel === LogLevel.debug) {
-        this.logger.debug(
+        this.logger.emit('debug', [
           `Cannot return a path where the 'pluginKey' ${params.pluginKey ? JSON.stringify(params.pluginKey) : '"'} is not unique enough\n\nPaths: ${
             JSON.stringify(paths, undefined, 2)
           }\n\nFalling back on the first item.\n`,
-        )
+        ])
       }
 
       return paths?.at(0)
@@ -150,11 +150,11 @@ export class PluginManager {
       })
 
       if (names && names?.length > 1 && this.logger.logLevel === LogLevel.debug) {
-        this.logger.debug(
+        this.logger.emit('debug', [
           `Cannot return a name where the 'pluginKey' ${params.pluginKey ? JSON.stringify(params.pluginKey) : '"'} is not unique enough\n\nNames: ${
             JSON.stringify(names, undefined, 2)
           }\n\nFalling back on the first item.\n`,
-        )
+        ])
       }
 
       return transformReservedWord(names?.at(0) || params.name)
@@ -183,7 +183,7 @@ export class PluginManager {
     hookName,
     parameters,
   }: {
-    pluginKey: KubbPlugin['key']
+    pluginKey: Plugin['key']
     hookName: H
     parameters: PluginParameter<H>
   }): Promise<Array<ReturnType<ParseResult<H>> | null>> | null {
@@ -211,7 +211,7 @@ export class PluginManager {
     hookName,
     parameters,
   }: {
-    pluginKey: KubbPlugin['key']
+    pluginKey: Plugin['key']
     hookName: H
     parameters: PluginParameter<H>
   }): Array<ReturnType<ParseResult<H>>> | null {
@@ -239,7 +239,7 @@ export class PluginManager {
   }: {
     hookName: H
     parameters: PluginParameter<H>
-    skipped?: ReadonlySet<KubbPlugin> | null
+    skipped?: ReadonlySet<Plugin> | null
   }): Promise<SafeParseResult<H>> {
     const promises = this.#getSortedPlugins().filter(plugin => {
       return skipped ? skipped.has(plugin) : true
@@ -274,7 +274,7 @@ export class PluginManager {
   }: {
     hookName: H
     parameters: PluginParameter<H>
-    skipped?: ReadonlySet<KubbPlugin> | null
+    skipped?: ReadonlySet<Plugin> | null
   }): SafeParseResult<H> {
     let parseResult: SafeParseResult<H> = null as unknown as SafeParseResult<H>
 
@@ -338,7 +338,7 @@ export class PluginManager {
   }: {
     hookName: H
     parameters: PluginParameter<H>
-    reduce: (reduction: Argument0<H>, result: ReturnType<ParseResult<H>>, plugin: KubbPlugin) => PossiblePromise<Argument0<H> | null>
+    reduce: (reduction: Argument0<H>, result: ReturnType<ParseResult<H>>, plugin: Plugin) => PossiblePromise<Argument0<H> | null>
   }): Promise<Argument0<H>> {
     const [argument0, ...rest] = parameters
 
@@ -377,14 +377,14 @@ export class PluginManager {
     return this.#promiseManager.run('seq', promises)
   }
 
-  #getSortedPlugins(hookName?: keyof PluginLifecycle): KubbPlugin[] {
+  #getSortedPlugins(hookName?: keyof PluginLifecycle): Plugin[] {
     const plugins = [...this.plugins].filter((plugin) => plugin.name !== 'core')
 
     if (hookName) {
       if (this.logger.logLevel === LogLevel.info) {
         const containsHookName = plugins.some((item) => item[hookName])
         if (!containsHookName) {
-          this.logger.warn(`No hook ${hookName} found`)
+          this.logger.emit('warning', `No hook ${hookName} found`)
         }
       }
 
@@ -413,7 +413,7 @@ export class PluginManager {
     })
   }
 
-  getPluginsByKey(hookName: keyof PluginLifecycle, pluginKey: KubbPlugin['key']): KubbPlugin[] {
+  getPluginsByKey(hookName: keyof PluginLifecycle, pluginKey: Plugin['key']): Plugin[] {
     const plugins = [...this.plugins]
     const [searchPluginName, searchIdentifier] = pluginKey
 
@@ -439,9 +439,9 @@ export class PluginManager {
 
       if (this.logger.logLevel === LogLevel.debug) {
         if (corePlugin) {
-          this.logger.debug(`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, falling back on the '@kubb/core' plugin`)
+          this.logger.emit('debug', [`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, falling back on the '@kubb/core' plugin`])
         } else {
-          this.logger.debug(`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, no fallback found in the '@kubb/core' plugin`)
+          this.logger.emit('debug', [`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, no fallback found in the '@kubb/core' plugin`])
         }
       }
 
@@ -474,7 +474,7 @@ export class PluginManager {
     strategy: Strategy
     hookName: H
     parameters: unknown[] | undefined
-    plugin: KubbPluginWithLifeCycle
+    plugin: PluginWithLifeCycle
   }): Promise<ReturnType<ParseResult<H>> | null> | null {
     const hook = plugin[hookName]
     let output: unknown
@@ -536,7 +536,7 @@ export class PluginManager {
     strategy: Strategy
     hookName: H
     parameters: PluginParameter<H>
-    plugin: KubbPluginWithLifeCycle
+    plugin: PluginWithLifeCycle
   }): ReturnType<ParseResult<H>> | null {
     const hook = plugin[hookName]
     let output: unknown
@@ -573,18 +573,18 @@ export class PluginManager {
     }
   }
 
-  #catcher<H extends PluginLifecycleHooks>(e: Error, plugin?: KubbPlugin, hookName?: H) {
+  #catcher<H extends PluginLifecycleHooks>(e: Error, plugin?: Plugin, hookName?: H) {
     const text = `${e.message} (plugin: ${plugin?.name || 'unknown'}, hook: ${hookName || 'unknown'})\n`
 
-    this.logger.error(text)
+    this.logger.emit('error', text)
     this.events.emit('error', e)
   }
 
-  #parse<TPlugin extends KubbUserPluginWithLifeCycle>(
+  #parse<TPlugin extends UserPluginWithLifeCycle>(
     plugin: TPlugin,
     pluginManager: PluginManager,
     context: CorePluginOptions['api'] | undefined,
-  ): KubbPlugin<GetPluginFactoryOptions<TPlugin>> {
+  ): Plugin<GetPluginFactoryOptions<TPlugin>> {
     const usedPluginNames = pluginManager.#usedPluginNames
 
     setUniqueName(plugin.name, usedPluginNames)
@@ -605,23 +605,23 @@ export class PluginManager {
         ...plugin,
         key,
         api,
-      } as unknown as KubbPlugin<GetPluginFactoryOptions<TPlugin>>
+      } as unknown as Plugin<GetPluginFactoryOptions<TPlugin>>
     }
 
     return {
       ...plugin,
       key,
-    } as unknown as KubbPlugin<GetPluginFactoryOptions<TPlugin>>
+    } as unknown as Plugin<GetPluginFactoryOptions<TPlugin>>
   }
 
   static getDependedPlugins<
     T1 extends PluginFactoryOptions,
     T2 extends PluginFactoryOptions = never,
     T3 extends PluginFactoryOptions = never,
-    TOutput = T3 extends never ? T2 extends never ? [T1: KubbPlugin<T1>]
-      : [T1: KubbPlugin<T1>, T2: KubbPlugin<T2>]
-      : [T1: KubbPlugin<T1>, T2: KubbPlugin<T2>, T3: KubbPlugin<T3>],
-  >(plugins: Array<KubbPlugin>, dependedPluginNames: string | string[]): TOutput {
+    TOutput = T3 extends never ? T2 extends never ? [T1: Plugin<T1>]
+      : [T1: Plugin<T1>, T2: Plugin<T2>]
+      : [T1: Plugin<T1>, T2: Plugin<T2>, T3: Plugin<T3>],
+  >(plugins: Array<Plugin>, dependedPluginNames: string | string[]): TOutput {
     let pluginNames: string[] = []
     if (typeof dependedPluginNames === 'string') {
       pluginNames = [dependedPluginNames]

package/src/build.ts

@@ -11,7 +11,7 @@ import { isPromise } from './PromiseManager.ts'
 
 import type { KubbFile } from './FileManager.ts'
 import type { Logger } from './logger.ts'
-import type { KubbPlugin, PluginContext, PluginParameter, TransformResult } from './types.ts'
+import type { Plugin, PluginContext, PluginParameter, TransformResult } from './types.ts'
 
 type BuildOptions = {
   config: PluginContext['config']
@@ -34,7 +34,7 @@ async function transformReducer(
   this: PluginContext,
   _previousCode: string,
   result: TransformResult | Promise<TransformResult>,
-  _plugin: KubbPlugin,
+  _plugin: Plugin,
 ): Promise<string | null> {
   return result
 }
@@ -113,11 +113,11 @@ async function setup(options: BuildOptions): Promise<PluginManager> {
   pluginManager.on('execute', (executer) => {
     const { hookName, parameters, plugin } = executer
 
-    if (hookName === 'writeFile' && logger.spinner) {
+    if (hookName === 'writeFile') {
       const [code] = parameters as PluginParameter<'writeFile'>
 
       if (logger.logLevel === LogLevel.debug) {
-        logger.debug(`PluginKey ${c.dim(JSON.stringify(plugin.key))} \nwith source\n\n${code}`)
+        logger.emit('debug', [`PluginKey ${c.dim(JSON.stringify(plugin.key))} \nwith source\n\n${code}`])
       }
     }
   })
@@ -127,8 +127,8 @@ async function setup(options: BuildOptions): Promise<PluginManager> {
       return
     }
 
-    if (logger.spinner && count === 0) {
-      logger.spinner?.start(`💾 Writing`)
+    if (count === 0) {
+      logger.emit('start', `💾 Writing`)
     }
   })
 
@@ -169,7 +169,7 @@ async function setup(options: BuildOptions): Promise<PluginManager> {
         output,
       ].filter(Boolean)
 
-      logger.debug(logs.join('\n'))
+      logger.emit('debug', logs as string[])
     }
   })
 
@@ -188,9 +188,8 @@ export async function build(options: BuildOptions): Promise<BuildOutput> {
 
   await pluginManager.hookParallel({ hookName: 'buildEnd' })
 
-  if (logger.logLevel === LogLevel.info && logger.spinner) {
-    logger.spinner.suffixText = ''
-    logger.spinner.succeed(`💾 Writing completed`)
+  if (logger.logLevel === LogLevel.info) {
+    logger.emit('end', `💾 Writing completed`)
   }
 
   return { files: fileManager.files.map((file) => ({ ...file, source: FileManager.getSource(file) })), pluginManager }
@@ -209,9 +208,8 @@ export async function safeBuild(options: BuildOptions): Promise<BuildOutput> {
 
     await pluginManager.hookParallel({ hookName: 'buildEnd' })
 
-    if (logger.logLevel === LogLevel.info && logger.spinner) {
-      logger.spinner.suffixText = ''
-      logger.spinner.succeed(`💾 Writing completed`)
+    if (logger.logLevel === LogLevel.info) {
+      logger.emit('end', `💾 Writing completed`)
     }
   } catch (e) {
     return { files: fileManager.files.map((file) => ({ ...file, source: FileManager.getSource(file) })), pluginManager, error: e as Error }

package/src/config.ts

@@ -1,22 +1,22 @@
 import type { PossiblePromise } from '@kubb/types'
-import type { CLIOptions, InputPath, KubbConfig, KubbUserConfig } from './types.ts'
+import type { CLIOptions, Config, InputPath, UserConfig } from './types.ts'
 
 /**
  * Type helper to make it easier to use kubb.config.js
- * accepts a direct {@link KubbConfig} object, or a function that returns it.
+ * accepts a direct {@link Config} object, or a function that returns it.
  * The function receives a {@link ConfigEnv} object that exposes two properties:
  */
 export function defineConfig(
   options:
-    | PossiblePromise<KubbUserConfig | Array<KubbUserConfig>>
+    | PossiblePromise<UserConfig | Array<UserConfig>>
     | ((
       /** The options derived from the CLI flags */
       cliOptions: CLIOptions,
-    ) => PossiblePromise<KubbUserConfig | Array<KubbUserConfig>>),
+    ) => PossiblePromise<UserConfig | Array<UserConfig>>),
 ): typeof options {
   return options
 }
 
-export function isInputPath(result: KubbConfig | undefined): result is KubbConfig<InputPath> {
+export function isInputPath(result: Config | undefined): result is Config<InputPath> {
   return !!result && 'path' in (result as any)
 }

package/src/index.ts

@@ -1,8 +1,4 @@
-import { build } from './build.ts'
-
-import type { ObjValueTuple, TupleToUnion } from '@kubb/types'
-
-export { build, safeBuild } from './build.ts'
+export { build, build as default, safeBuild } from './build.ts'
 export { defineConfig, isInputPath } from './config.ts'
 export { Warning } from './errors.ts'
 export { FileManager, KubbFile } from './FileManager.ts'
@@ -12,16 +8,8 @@ export { PackageManager } from './PackageManager.ts'
 export { createPlugin, pluginName as name, pluginName } from './plugin.ts'
 export { PluginManager } from './PluginManager.ts'
 export { PromiseManager } from './PromiseManager.ts'
-export type * from './types.ts'
+export type { CLIOptions, Config, Plugin, PluginFactoryOptions, ResolveNameParams, ResolvePathParams, UserConfig } from './types.ts'
 
 export interface _Register {}
-export type Plugins = _Register
-export type OptionsPlugins = { [K in keyof Plugins]: Plugins[K]['options'] }
-
-export type OptionsOfPlugin<K extends keyof Plugins> = Plugins[K]['options']
-
-export type PluginUnion = TupleToUnion<ObjValueTuple<OptionsPlugins>>
-
-export type Plugin = keyof Plugins
 
-export default build
+export * as Kubb from './kubb.ts'

package/src/kubb.ts

@@ -0,0 +1,11 @@
+import type { ObjValueTuple, TupleToUnion } from '@kubb/types'
+import type { _Register } from './index.ts'
+
+export type Plugins = _Register
+export type OptionsPlugins = { [K in keyof Plugins]: Plugins[K]['options'] }
+
+export type OptionsOfPlugin<K extends keyof Plugins> = Plugins[K]['options']
+
+export type PluginUnion = TupleToUnion<ObjValueTuple<OptionsPlugins>>
+
+export type Plugin = keyof Plugins

package/src/logger.ts

@@ -2,6 +2,7 @@ import seedrandom from 'seedrandom'
 import c, { createColors } from 'tinyrainbow'
 
 import { writeLog } from './fs/write.ts'
+import { EventEmitter } from './utils/EventEmitter.ts'
 
 import type { Ora } from 'ora'
 import type { Formatter } from 'tinyrainbow'
@@ -14,19 +15,23 @@ export const LogLevel = {
 
 export type LogLevel = keyof typeof LogLevel
 
+type Events = {
+  start: [message: string]
+  end: [message: string]
+  error: [message: string]
+  warning: [message: string]
+  debug: [logs: string[]]
+}
 export type Logger = {
   /**
    * Optional config name to show in CLI output
    */
   name?: string
   logLevel: LogLevel
-  log: (message: string | null) => void
-  error: (message: string | null) => void
-  info: (message: string | null) => void
-  warn: (message: string | null) => void
-  debug: (message: string | null) => Promise<void>
+
   spinner?: Ora
-  logs: string[]
+  on: EventEmitter<Events>['on']
+  emit: EventEmitter<Events>['emit']
 }
 
 type Props = {
@@ -36,50 +41,45 @@ type Props = {
 }
 
 export function createLogger({ logLevel, name, spinner }: Props): Logger {
-  const logs: string[] = []
-  const log: Logger['log'] = (message) => {
-    if (message && spinner) {
-      spinner.text = message
-      logs.push(message)
+  const events = new EventEmitter<Events>()
+
+  events.on('start', (message) => {
+    if (spinner) {
+      spinner.start(message)
     }
-  }
+  })
 
-  const error: Logger['error'] = (message) => {
-    if (message) {
-      throw new Error(message || 'Something went wrong')
+  events.on('end', (message) => {
+    if (spinner) {
+      spinner.suffixText = ''
+      spinner.succeed(message)
     }
-  }
+  })
 
-  const warn: Logger['warn'] = (message) => {
-    if (message && spinner) {
+  events.on('warning', (message) => {
+    if (spinner) {
       spinner.warn(c.yellow(message))
-      logs.push(message)
     }
-  }
+  })
 
-  const info: Logger['warn'] = (message) => {
-    if (message && spinner && logLevel !== LogLevel.silent) {
-      spinner.info(message)
-      logs.push(message)
-    }
-  }
+  events.on('error', (message) => {
+    throw new Error(message || 'Something went wrong')
+  })
 
-  const debug: Logger['debug'] = async (message) => {
-    if (message) {
-      await writeLog(message)
-    }
-  }
+  events.on('debug', async (messages) => {
+    await writeLog(messages.join('\n'))
+  })
 
   const logger: Logger = {
     name,
     logLevel,
-    log,
-    error,
-    warn,
-    info,
-    debug,
     spinner,
-    logs,
+    on: (...args) => {
+      return events.on(...args)
+    },
+    emit: (...args) => {
+      return events.emit(...args)
+    },
   }
 
   return logger

package/src/plugin.ts

@@ -4,12 +4,12 @@ import { createPluginCache } from './utils/cache.ts'
 
 import type { FileManager } from './FileManager.ts'
 import type { PluginManager } from './PluginManager.ts'
-import type { KubbPlugin, KubbUserPluginWithLifeCycle, PluginContext, PluginFactoryOptions } from './types.ts'
+import type { Plugin, PluginContext, PluginFactoryOptions, UserPluginWithLifeCycle } from './types.ts'
 
-type KubbPluginFactory<T extends PluginFactoryOptions = PluginFactoryOptions> = (options: T['options']) => KubbUserPluginWithLifeCycle<T>
+type PluginFactory<T extends PluginFactoryOptions = PluginFactoryOptions> = (options: T['options']) => UserPluginWithLifeCycle<T>
 
-export function createPlugin<T extends PluginFactoryOptions = PluginFactoryOptions>(factory: KubbPluginFactory<T>) {
-  return (options: T['options']): ReturnType<KubbPluginFactory<T>> => {
+export function createPlugin<T extends PluginFactoryOptions = PluginFactoryOptions>(factory: PluginFactory<T>) {
+  return (options: T['options']): ReturnType<PluginFactory<T>> => {
     return factory(options)
   }
 }
@@ -21,7 +21,7 @@ type Options = {
   resolvePath: PluginContext['resolvePath']
   resolveName: PluginContext['resolveName']
   logger: PluginContext['logger']
-  getPlugins: () => Array<KubbPlugin>
+  getPlugins: () => Array<Plugin>
   plugin?: PluginContext['plugin']
 }
 

package/src/transformers/casing.ts

@@ -1,9 +1,37 @@
-import { camelCase as changeCaseCamel, pascalCase as changePascalCase } from 'change-case'
+import { camelCase as changeCamelCase, pascalCase as changePascalCase, pathCase as changePathCase } from 'change-case'
 
-export function camelCase(text: string): string {
-  return changeCaseCamel(text, { delimiter: '', mergeAmbiguousCharacters: true })
+type Options = {
+  /**
+   * When set it will replace all `.` with `/`.
+   */
+  isFile?: boolean
+  prefix?: string
+  suffix?: string
 }
 
-export function pascalCase(text: string): string {
-  return changePascalCase(text, { delimiter: '', mergeAmbiguousCharacters: true })
+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 changeCamelCase(`${prefix} ${text} ${suffix}`, { delimiter: '', mergeAmbiguousCharacters: true })
+}
+
+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 changePascalCase(`${prefix} ${text} ${suffix}`, { delimiter: '', mergeAmbiguousCharacters: true })
+}
+
+export function pathCase(text: string, { isFile, prefix = '', suffix = '' }: Options = {}): string {
+  if (isFile) {
+    const splitArray = text.split('.')
+    return splitArray.map((item, i) => i === splitArray.length - 1 ? pathCase(item, { prefix, suffix }) : camelCase(item)).join('/')
+  }
+
+  return changePathCase(`${prefix} ${text} ${suffix}`, { delimiter: '' })
 }

package/src/transformers/index.ts

@@ -1,4 +1,4 @@
-import { camelCase, pascalCase } from './casing.ts'
+import { camelCase, pascalCase, pathCase } from './casing.ts'
 import { combineCodes } from './combineCodes.ts'
 import { createJSDocBlockText } from './createJSDocBlockText.ts'
 import { escape, jsStringEscape } from './escape.ts'
@@ -8,7 +8,7 @@ import { searchAndReplace } from './searchAndReplace.ts'
 import { transformReservedWord } from './transformReservedWord.ts'
 import { trim, trimExtName } from './trim.ts'
 
-export { camelCase, pascalCase } from './casing.ts'
+export { camelCase, pascalCase, pathCase } from './casing.ts'
 export { combineCodes } from './combineCodes.ts'
 export { createJSDocBlockText } from './createJSDocBlockText.ts'
 export { escape, jsStringEscape } from './escape.ts'
@@ -33,4 +33,5 @@ export default {
   },
   camelCase,
   pascalCase,
+  pathCase,
 } as const