@kubb/core 1.1.11 → 1.1.13

package/src/types.ts

@@ -1,253 +0,0 @@
-/* eslint-disable @typescript-eslint/no-empty-interface */
-import type { File, FileManager } from './managers/fileManager/index.ts'
-import type { PluginManager, SafeParseResult } from './managers/index.ts'
-import type { Cache } from './utils/cache.ts'
-
-export interface Register {}
-
-export type MaybePromise<T> = Promise<T> | T
-
-/**
- * Config used in `kubb.config.js`
- *
- * @example import { defineConfig } from '@kubb/core'
- * export default defineConfig({
- * ...
- * })
- */
-export type KubbUserConfig = Omit<KubbConfig, 'root' | 'plugins'> & {
-  /**
-   * Project root directory. Can be an absolute path, or a path relative from
-   * the location of the config file itself.
-   * @default process.cwd()
-   */
-  root?: string
-  /**
-   * Plugin type can be KubbJSONPlugin or KubbPlugin
-   * Example: ['@kubb/swagger', { output: false }]
-   * Or: createSwagger({ output: false })
-   */
-  plugins?: KubbPlugin[] | KubbJSONPlugin[] | KubbObjectPlugin
-}
-
-/**
- * Global/internal config used through out the full generation.
- */
-export type KubbConfig = {
-  /**
-   * Project root directory. Can be an absolute path, or a path relative from
-   * the location of the config file itself.
-   * @default process.cwd()
-   */
-  root: string
-  input: {
-    /**
-     * Path to be used as the input. Can be an absolute path, or a path relative from
-     * the defined root option.
-     */
-    path: string
-  }
-  output: {
-    /**
-     * Path to be used to export all generated files. Can be an absolute path, or a path relative based of the defined root option.
-     */
-    path: string
-    /**
-     * Remove previous generated files and folders.
-     */
-    clean?: boolean
-    /**
-     * Enabled or disable the writing to the filesystem. This is being used for the playground.
-     * @default true
-     */
-    write?: boolean
-  }
-  /**
-   * Array of Kubb plugins to use.
-   * The plugin/package can forsee some options that you need to pass through.
-   * Sometimes a plugin is depended on another plugin, if that's the case you will get an error back from the plugin you installed.
-   */
-  plugins?: KubbPlugin[]
-  /**
-   * Hooks that will be called when a specific action is triggered in Kubb.
-   */
-  hooks?: {
-    /**
-     * Hook that will be triggerend at the end of all executions.
-     * Useful for running Prettier or ESLint to use your own linting structure.
-     */
-    done?: string | string[]
-  }
-  /**
-   * Log level to report when using the CLI
-   * Under construction, only info is implemented.
-   * @default `silent`
-   */
-  logLevel?: LogLevel
-}
-
-export type CLIOptions = {
-  /**
-   * Path to `kubb.config.js`
-   */
-  config?: string
-  /**
-   * Enable debug mode
-   */
-  debug?: boolean
-  /**
-   * Watch changes on input
-   */
-  watch?: string
-  /**
-   * Override `input` defined in `kubb.config.js`
-   */
-  input?: string
-
-  /**
-   * Override `logLevel` defined in `kubb.config.js`
-   * @default `'silent'`
-   */
-  logLevel?: LogLevel
-  init?: unknown
-}
-
-export type BuildOutput = {
-  files: FileManager['files']
-  pluginManager: PluginManager
-}
-
-// plugin
-
-export type KubbPluginKind = 'schema' | 'controller'
-
-export type KubbJSONPlugin = [plugin: keyof Register | string, options: Register[keyof Register] | object]
-
-export type KubbObjectPlugin = {
-  [K in keyof Register]: Register[K] | object
-}
-
-export type KubbPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
-  /**
-   * Unique name used for the plugin
-   * @example @kubb/typescript
-   */
-  name: string
-  /**
-   * Kind/type for the plugin
-   * Type 'schema' can be used for JSON schema's, TypeScript types, ...
-   * Type 'controller' can be used to create generate API calls, React-Query hooks, Axios controllers, ...
-   * @default undefined
-   */
-  kind?: KubbPluginKind
-  /**
-   * Defined an api that can be used by other plugins
-   */
-  api?: TOptions['api']
-  /**
-   * Options set for a specific plugin(see kubb.config.js)
-   */
-  options?: TOptions['options']
-} & Partial<PluginLifecycle<TOptions>>
-
-// use of type objects
-export type PluginFactoryOptions<Options = unknown, Nested extends boolean = false, API = any, resolvePathOptions = Record<string, any>> = {
-  options: Options
-  nested: Nested
-  api: API
-  resolvePathOptions: resolvePathOptions
-}
-
-export type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
-  /**
-   * Valdiate all plugins to see if their depended plugins are installed and configured.
-   * @type hookParallel
-   */
-  validate: (this: Omit<PluginContext, 'addFile'>, plugins: KubbPlugin[]) => MaybePromise<true>
-  /**
-   * Start of the lifecycle of a plugin.
-   * @type hookParallel
-   */
-  buildStart: (this: PluginContext, kubbConfig: KubbConfig) => MaybePromise<void>
-  /**
-   * Resolve to a Path based on a fileName(example: `./Pet.ts`) and directory(example: `./models`).
-   * Options can als be included.
-   * @type hookFirst
-   * @example ('./Pet.ts', './src/gen/') => '/src/gen/Pet.ts'
-   */
-  resolvePath: (this: PluginContext, fileName: string, directory?: string, options?: TOptions['resolvePathOptions']) => OptionalPath
-  /**
-   * Resolve to a name based on a string.
-   * Useful when converting to PascalCase or camelCase.
-   * @type hookFirst
-   * @example ('pet') => 'Pet'
-   */
-  resolveName: (this: PluginContext, name: string) => string
-  /**
-   * Makes it possible to run async logic to override the path defined previously by `resolvePath`.
-   * @type hookFirst
-   */
-  load: (this: Omit<PluginContext, 'addFile'>, path: Path) => MaybePromise<TransformResult | null>
-  /**
-   * Transform the source-code.
-   * @type hookReduceArg0
-   */
-  transform: (this: Omit<PluginContext, 'addFile'>, source: string, path: Path) => MaybePromise<TransformResult>
-  /**
-   * Write the result to the file-system based on the id(defined by `resolvePath` or changed by `load`).
-   * @type hookParallel
-   */
-  writeFile: (this: Omit<PluginContext, 'addFile'>, source: string | undefined, path: Path) => MaybePromise<void>
-  /**
-   * End of the plugin lifecycle.
-   * @type hookParallel
-   */
-  buildEnd: (this: PluginContext) => MaybePromise<void>
-}
-
-export type PluginLifecycleHooks = keyof PluginLifecycle
-
-export type ResolvePathParams<TOptions = Record<string, any>> = {
-  /**
-   * When set, resolvePath will only call resolvePath of the name of the plugin set here.
-   * If not defined it will fall back on the resolvePath of the core plugin.
-   */
-  pluginName?: string
-  fileName: string
-  directory?: string | undefined
-  /**
-   * Options to be passed to 'resolvePath' 3th parameter
-   */
-  options?: TOptions
-}
-
-export type ResolveNameParams = {
-  /**
-   * When set, resolvePath will only call resolvePath of the name of the plugin set here.
-   * If not defined it will fall back on the resolvePath of the core plugin.
-   */
-  pluginName?: string
-  name: string
-}
-
-export type PluginContext<TOptions = Record<string, any>> = {
-  config: KubbConfig
-  cache: Cache
-  fileManager: FileManager
-  addFile: (...file: File[]) => Promise<File[]>
-  resolvePath: (params: ResolvePathParams<TOptions>) => OptionalPath
-  resolveName: (params: ResolveNameParams) => string | null | undefined
-  load: (id: string) => Promise<SafeParseResult<'load'>>
-}
-
-// null will mean clear the watcher for this key
-export type TransformResult = string | null
-
-/**
- * @description Computing the name of a file or directory together with its position in relation to other directories traced back in a line to the root
- */
-export type Path = string
-export type OptionalPath = Path | null | undefined
-export type FileName = string | null | undefined
-
-export type LogLevel = 'error' | 'info' | 'silent'

package/src/utils/Queue.ts

@@ -1,46 +0,0 @@
-export type QueueTask<T = unknown> = {
-  (...args: unknown[]): Promise<T> | Promise<void>
-}
-
-interface QueueItem {
-  reject: <T>(reason?: T) => void
-  resolve: <T>(value: T | PromiseLike<T>) => void
-  task: QueueTask<unknown>
-}
-
-export class Queue {
-  private readonly queue: QueueItem[] = []
-
-  workerCount = 0
-
-  private maxParallel: number
-
-  constructor(maxParallel: number) {
-    this.maxParallel = maxParallel
-  }
-
-  run<T>(task: QueueTask<T>): Promise<T> {
-    return new Promise<T>((resolve, reject) => {
-      const item: QueueItem = { reject, resolve, task } as QueueItem
-      this.queue.push(item)
-      this.work()
-    })
-  }
-
-  private work(): void {
-    if (this.workerCount >= this.maxParallel) {
-      return
-    }
-    this.workerCount++
-
-    let entry: QueueItem | undefined
-    while ((entry = this.queue.shift())) {
-      const { reject, resolve, task } = entry
-      task()
-        .then((result) => resolve(result))
-        .catch((err) => reject(err))
-    }
-
-    this.workerCount--
-  }
-}

package/src/utils/TreeNode.ts

@@ -1,122 +0,0 @@
-import dirTree from 'directory-tree'
-
-import { getPathMode } from '../utils/read.ts'
-
-import type { DirectoryTree, DirectoryTreeOptions } from 'directory-tree'
-
-export type TreeNodeOptions = DirectoryTreeOptions
-
-export class TreeNode<T = unknown> {
-  public data: T
-
-  public parent?: TreeNode<T>
-
-  public children: Array<TreeNode<T>> = []
-
-  constructor(data: T, parent?: TreeNode<T>) {
-    this.data = data
-    this.parent = parent
-    return this
-  }
-
-  addChild(data: T): TreeNode<T> {
-    const child = new TreeNode(data, this)
-    if (!this.children) {
-      this.children = []
-    }
-    this.children.push(child)
-    return child
-  }
-
-  find(data?: T): TreeNode<T> | null {
-    if (!data) {
-      return null
-    }
-
-    if (data === this.data) {
-      return this
-    }
-
-    if (this.children?.length) {
-      for (let i = 0, { length } = this.children, target: TreeNode<T> | null = null; i < length; i++) {
-        target = this.children[i].find(data)
-        if (target) {
-          return target
-        }
-      }
-    }
-
-    return null
-  }
-
-  get leaves(): TreeNode<T>[] {
-    if (!this.children || this.children.length === 0) {
-      // this is a leaf
-      return [this]
-    }
-
-    // if not a leaf, return all children's leaves recursively
-    const leaves: TreeNode<T>[] = []
-    if (this.children) {
-      for (let i = 0, { length } = this.children; i < length; i++) {
-        // eslint-disable-next-line prefer-spread
-        leaves.push.apply(leaves, this.children[i].leaves)
-      }
-    }
-    return leaves
-  }
-
-  get root(): TreeNode<T> {
-    if (!this.parent) {
-      return this
-    }
-    return this.parent.root
-  }
-
-  forEach(callback: (treeNode: TreeNode<T>) => void): this {
-    if (typeof callback !== 'function') {
-      throw new TypeError('forEach() callback must be a function')
-    }
-
-    // run this node through function
-    callback(this)
-
-    // do the same for all children
-    if (this.children) {
-      for (let i = 0, { length } = this.children; i < length; i++) {
-        this.children[i].forEach(callback)
-      }
-    }
-
-    return this
-  }
-
-  public static build<T = unknown>(path: string, options: TreeNodeOptions = {}): TreeNode<T> | null {
-    try {
-      const exclude = Array.isArray(options.exclude) ? options.exclude : ([options.exclude].filter(Boolean) as RegExp[])
-      const filteredTree = dirTree(path, { extensions: options.extensions, exclude: [/node_modules/, ...exclude] })
-
-      if (!filteredTree) {
-        return null
-      }
-
-      const treeNode = new TreeNode({ name: filteredTree.name, path: filteredTree.path, type: filteredTree.type || getPathMode(filteredTree.path) })
-
-      const recurse = (node: typeof treeNode, item: DirectoryTree) => {
-        const subNode = node.addChild({ name: item.name, path: item.path, type: item.type || getPathMode(item.path) })
-
-        if (item.children?.length) {
-          item.children?.forEach((child) => {
-            recurse(subNode, child)
-          })
-        }
-      }
-
-      filteredTree.children?.forEach((child) => recurse(treeNode, child))
-
-      return treeNode as TreeNode<T>
-    } catch (e) {
-      throw new Error('Something went wrong with creating index files with the TreehNode class', { cause: e })
-    }
-  }
-}

package/src/utils/cache.ts

@@ -1,33 +0,0 @@
-export interface Cache<TStore extends object = object> {
-  delete(id: keyof TStore): boolean
-  get(id: keyof TStore): TStore[keyof TStore] | null
-  has(id: keyof TStore): boolean
-  set(id: keyof TStore, value: unknown): void
-}
-
-export function createPluginCache<TStore extends Record<string, [number, unknown]>>(Store: TStore): Cache<TStore> {
-  return {
-    set(id, value): void {
-      Store[id] = [0, value] as TStore[keyof TStore]
-    },
-    get(id): TStore[keyof TStore] | null {
-      const item = Store[id]
-      if (!item) {
-        return null
-      }
-      item[0] = 0
-      return item[1] as TStore[keyof TStore]
-    },
-    has(id): boolean {
-      const item = Store[id]
-      if (!item) {
-        return false
-      }
-      item[0] = 0
-      return true
-    },
-    delete(id: keyof TStore): boolean {
-      return delete Store[id]
-    },
-  }
-}

package/src/utils/clean.ts

@@ -1,5 +0,0 @@
-import { rimraf } from 'rimraf'
-
-export async function clean(path: string) {
-  return rimraf(path)
-}

package/src/utils/getEncodedText.ts

@@ -1,3 +0,0 @@
-export function getEncodedText(text?: string): string {
-  return text ? text.replaceAll('`', '\\`') : ''
-}

package/src/utils/getStackTrace.ts

@@ -1,20 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-// eslint-disable-next-line @typescript-eslint/ban-types
-export function getStackTrace(belowFn?: Function): NodeJS.CallSite[] {
-  const oldLimit = Error.stackTraceLimit
-  Error.stackTraceLimit = Infinity
-
-  const dummyObject = {} as any
-
-  const v8Handler = Error.prepareStackTrace
-  Error.prepareStackTrace = function prepareStackTrace(dummyObject, v8StackTrace) {
-    return v8StackTrace
-  }
-  Error.captureStackTrace(dummyObject as object, belowFn || getStackTrace)
-
-  const v8StackTrace = dummyObject.stack
-  Error.prepareStackTrace = v8Handler
-  Error.stackTraceLimit = oldLimit
-
-  return v8StackTrace as NodeJS.CallSite[]
-}

package/src/utils/getUniqueName.ts

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

package/src/utils/index.ts

@@ -1,19 +0,0 @@
-export * from './isPromise.ts'
-export * from './write.ts'
-export * from './cache.ts'
-export * from './read.ts'
-export * from './isURL.ts'
-export * from './objectToParameters.ts'
-export * from './nameSorter.ts'
-export * from './jsdoc.ts'
-export * from './getUniqueName.ts'
-export * from './timeout.ts'
-export * from './Queue.ts'
-export * from './getEncodedText.ts'
-export * from './renderTemplate.ts'
-export * from './clean.ts'
-export * from './TreeNode.ts'
-export * from './transformReservedWord.ts'
-export * from './getStackTrace.ts'
-export * from './uniqueId.ts'
-export * from './throttle.ts'

package/src/utils/isPromise.ts

@@ -1,5 +0,0 @@
-import type { MaybePromise } from '../types.ts'
-
-export function isPromise<T>(result: MaybePromise<T>): result is Promise<T> {
-  return typeof (result as Promise<unknown>)?.then === 'function'
-}

package/src/utils/isURL.ts

@@ -1,11 +0,0 @@
-export function isURL(data: string) {
-  try {
-    const url = new URL(data)
-    if (url?.href) {
-      return true
-    }
-  } catch (error) {
-    return false
-  }
-  return false
-}

package/src/utils/jsdoc.ts

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

package/src/utils/nameSorter.ts

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

package/src/utils/objectToParameters.ts

@@ -1,28 +0,0 @@
-import { camelCase, camelCaseTransformMerge } from 'change-case'
-
-type Data = string[][]
-
-type Options = {
-  typed?: boolean
-}
-/**
- * Convert an string array to a string of parameters that can be used inside a function
- * The parameter name is converted to `camelcase`
- */
-export function objectToParameters(data: Data, options: Options = {}) {
-  const { typed } = options
-
-  return data
-    .reduce((acc, [key, value]) => {
-      const parameterName = camelCase(key, { delimiter: '', transform: camelCaseTransformMerge })
-
-      if (typed) {
-        acc.push(`${parameterName}: ${value}["${key}"]`)
-      } else {
-        acc.push(`${parameterName}`)
-      }
-
-      return acc
-    }, [] as string[])
-    .join(', ')
-}

package/src/utils/read.ts

@@ -1,45 +0,0 @@
-import pathParser from 'node:path'
-import fs from 'fs-extra'
-
-function slash(path: string, platform: 'windows' | 'mac' | 'linux' = 'linux') {
-  const isWindowsPath = /^\\\\\?\\/.test(path)
-
-  if (['linux', 'mac'].includes(platform) && !isWindowsPath) {
-    // linux and mac
-    return path.replaceAll(/\\/g, '/').replace('../', '').trimEnd()
-  }
-
-  // windows
-  return path.replaceAll(/\\/g, '/').replace('../', '').trimEnd()
-}
-
-export function getRelativePath(rootDir?: string | null, filePath?: string | null, platform: 'windows' | 'mac' | 'linux' = 'linux') {
-  if (!rootDir || !filePath) {
-    throw new Error(`Root and file should be filled in when retrieving the relativePath, ${rootDir || ''} ${filePath || ''}`)
-  }
-
-  const relativePath = pathParser.relative(rootDir, filePath)
-
-  // On Windows, paths are separated with a "\"
-  // However, web browsers use "/" no matter the platform
-  const path = slash(relativePath, platform)
-
-  if (path.startsWith('../')) {
-    return path.replace(pathParser.basename(path), pathParser.basename(path, pathParser.extname(filePath)))
-  }
-
-  return `./${path.replace(pathParser.basename(path), pathParser.basename(path, pathParser.extname(filePath)))}`
-}
-
-export type PathMode = 'file' | 'directory'
-
-export function getPathMode(path: string | undefined | null): PathMode {
-  if (!path) {
-    return 'directory'
-  }
-  return pathParser.extname(path) ? 'file' : 'directory'
-}
-
-export async function read(path: string) {
-  return fs.readFile(path, { encoding: 'utf8' })
-}

package/src/utils/renderTemplate.ts

@@ -1,11 +0,0 @@
-export function renderTemplate<TData extends Record<string, string> = Record<string, string>>(template: string, data: TData | undefined = undefined) {
-  if (!data) {
-    return template.replace(/{{(.*?)}}/g, '')
-  }
-
-  return template.replace(/{{(.*?)}}/g, (match) => {
-    const value = data[match.split(/{{|}}/).filter(Boolean)[0].trim()]
-
-    return value || ''
-  })
-}

package/src/utils/throttle.ts

@@ -1,30 +0,0 @@
-export const throttle = <R, A extends any[]>(fn: (...args: A) => R, delay: number): [(...args: A) => R | undefined, () => void] => {
-  let wait = false
-  let timeout: NodeJS.Timeout
-  let cancelled = false
-
-  return [
-    (...args: A) => {
-      if (cancelled) {
-        return undefined
-      }
-      if (wait) {
-        return undefined
-      }
-
-      const val = fn(...args)
-
-      wait = true
-
-      timeout = setTimeout(() => {
-        wait = false
-      }, delay)
-
-      return val
-    },
-    () => {
-      cancelled = true
-      clearTimeout(timeout)
-    },
-  ]
-}

package/src/utils/timeout.ts

@@ -1,7 +0,0 @@
-export async function timeout(ms: number) {
-  return new Promise((resolve) => {
-    setTimeout(() => {
-      resolve(true)
-    }, ms)
-  })
-}