@kubb/core 3.0.0-alpha.0 → 3.0.0-alpha.10

package/src/logger.ts

@@ -3,16 +3,24 @@ import c, { createColors } from 'tinyrainbow'
 
 import { EventEmitter } from './utils/EventEmitter.ts'
 
-import type { ConsolaInstance } from 'consola'
-import type { Ora } from 'ora'
+import { type ConsolaInstance, type LogLevel, createConsola } from 'consola'
 import type { Formatter } from 'tinyrainbow'
+import { write } from '@kubb/fs'
+import { resolve } from 'node:path'
 
-//TODO replace with verbose flag and debug flag
-export const LogLevel = {
-  silent: 'silent',
-  info: 'info',
-  debug: 'debug',
-} as const
+type DebugEvent = { date: Date; logs: string[]; fileName?: string }
+
+type Events = {
+  start: [message: string]
+  success: [message: string]
+  error: [message: string, cause: Error]
+  warning: [message: string]
+  debug: [DebugEvent]
+  info: [message: string]
+  progress_start: [{ id: string; size: number; message?: string }]
+  progressed: [{ id: string; message?: string }]
+  progress_stop: [{ id: string }]
+}
 
 export const LogMapper = {
   silent: Number.NEGATIVE_INFINITY,
@@ -20,54 +28,65 @@ export const LogMapper = {
   debug: 4,
 } as const
 
-export type LogLevel = keyof typeof LogLevel
-
-type Events = {
-  start: [message: string]
-  end: [message: string]
-  error: [message: string, cause: Error]
-  warning: [message: string]
-  debug: [logs: string[]]
-}
 export type Logger = {
   /**
    * Optional config name to show in CLI output
    */
   name?: string
   logLevel: LogLevel
-  spinner?: Ora
   consola?: ConsolaInstance
   on: EventEmitter<Events>['on']
   emit: EventEmitter<Events>['emit']
+  writeLogs: () => Promise<string[]>
 }
 
 type Props = {
   name?: string
-  logLevel: LogLevel
-  spinner?: Ora
+  logLevel?: LogLevel
   consola?: ConsolaInstance
 }
 
-export function createLogger({ logLevel, name, spinner, consola }: Props): Logger {
+export function createLogger({ logLevel = 3, name, consola: _consola }: Props = {}): Logger {
   const events = new EventEmitter<Events>()
+  const startDate = Date.now()
+  const cachedLogs = new Set<DebugEvent>()
+
+  const consola =
+    _consola ||
+    createConsola({
+      level: logLevel,
+      formatOptions: {
+        colors: true,
+        date: true,
+        columns: 120,
+        compact: logLevel !== LogMapper.debug,
+      },
+    }).withTag(name ? randomCliColour(name) : '')
+
+  consola?.wrapConsole()
 
   events.on('start', (message) => {
-    if (spinner) {
-      spinner.start(message)
-    }
+    consola.start(message)
   })
 
-  events.on('end', (message) => {
-    if (spinner) {
-      spinner.suffixText = ''
-      spinner.succeed(message)
-    }
+  events.on('success', (message) => {
+    consola.success(message)
   })
 
   events.on('warning', (message) => {
-    if (spinner) {
-      spinner.warn(c.yellow(message))
+    consola.warn(c.yellow(message))
+  })
+
+  events.on('info', (message) => {
+    consola.info(c.yellow(message))
+  })
+
+  events.on('debug', (message) => {
+    if (message.logs.join('\n\n').length <= 100 && logLevel === LogMapper.debug) {
+      console.log(message.logs.join('\n\n'))
     }
+
+    cachedLogs.add(message)
   })
 
   events.on('error', (message, cause) => {
@@ -77,17 +96,40 @@ export function createLogger({ logLevel, name, spinner, consola }: Props): Logge
     throw error
   })
 
+  if (consola) {
+    consola.level = logLevel
+  }
+
   const logger: Logger = {
     name,
     logLevel,
-    spinner,
     consola,
-    on: (...args) => {
+    on(...args) {
       return events.on(...args)
     },
-    emit: (...args) => {
+    emit(...args) {
       return events.emit(...args)
     },
+    async writeLogs() {
+      const files: Record<string, string[]> = {}
+
+      cachedLogs.forEach((log) => {
+        const fileName = resolve(process.cwd(), '.kubb', log.fileName || `kubb-${startDate}.log`)
+
+        if (!files[fileName]) {
+          files[fileName] = []
+        }
+
+        files[fileName] = [...files[fileName], `[${log.date.toLocaleString()}]: ${log.logs.join('\n\n')}`]
+      })
+      await Promise.all(
+        Object.entries(files).map(async ([fileName, logs]) => {
+          return write(fileName, logs.join('\n'))
+        }),
+      )
+
+      return Object.keys(files)
+    },
   }
 
   return logger

package/src/plugin.ts

@@ -37,7 +37,7 @@ export const pluginCore = createPlugin<PluginCore>((options) => {
     name: 'core',
     options,
     key: ['core'],
-    api() {
+    context() {
       return {
         get config() {
           return options.config
@@ -46,7 +46,7 @@ export const pluginCore = createPlugin<PluginCore>((options) => {
           return options.getPlugins()
         },
         get plugin() {
-          // see pluginManger.#execute where we override with `.call` the this with the correct plugin
+          // see pluginManger.#execute where we override with `.call` the context with the correct plugin
           return options.plugin as NonNullable<Options['plugin']>
         },
         logger,
@@ -67,7 +67,7 @@ export const pluginCore = createPlugin<PluginCore>((options) => {
       }
     },
     resolvePath(baseName) {
-      const root = path.resolve(this.config.root, this.config.output.path)
+      const root = path.resolve(options.config.root, options.config.output.path)
 
       return path.resolve(root, baseName)
     },

package/src/transformers/index.ts

@@ -11,7 +11,7 @@ import { searchAndReplace } from './searchAndReplace.ts'
 import { stringify, stringifyObject } from './stringify.ts'
 import { toRegExp, toRegExpString } from './toRegExp.ts'
 import { transformReservedWord } from './transformReservedWord.ts'
-import { trim, trimExtName, trimQuotes } from './trim.ts'
+import { trim, trimQuotes } from './trim.ts'
 
 export { camelCase, pascalCase, pathCase } from './casing.ts'
 export { combineCodes } from './combineCodes.ts'
@@ -23,7 +23,7 @@ export { searchAndReplace } from './searchAndReplace.ts'
 export { stringify, stringifyObject } from './stringify.ts'
 export { toRegExp, toRegExpString } from './toRegExp.ts'
 export { transformReservedWord } from './transformReservedWord.ts'
-export { trim, trimExtName, trimQuotes } from './trim.ts'
+export { trim, trimQuotes } from './trim.ts'
 export { merge } from 'remeda'
 export { orderBy } from 'natural-orderby'
 
@@ -41,7 +41,6 @@ export default {
   toRegExpString,
   trim,
   trimQuotes,
-  trimExtName,
   JSDoc: {
     createJSDocBlockText,
   },

package/src/transformers/trim.ts

@@ -16,7 +16,3 @@ export function trimQuotes(text: string): string {
 
   return text
 }
-
-export function trimExtName(text: string): string {
-  return text.replace(/\.[^/.]+$/, '')
-}

package/src/types.ts

@@ -2,7 +2,6 @@ import type * as KubbFile from '@kubb/fs/types'
 import type { PossiblePromise } from '@kubb/types'
 import type { FileManager } from './FileManager.ts'
 import type { PluginManager } from './PluginManager.ts'
-import type { OptionsPlugins, PluginUnion } from './kubb.ts'
 import type { Logger } from './logger.ts'
 import type { Cache } from './utils/cache.ts'
 
@@ -24,11 +23,9 @@ export type UserConfig = Omit<Config, 'root' | 'plugins'> & {
    */
   root?: string
   /**
-   * Plugin type can be KubbJSONPlugin or Plugin
-   * Example: ['@kubb/plugin-oas', { output: false }]
-   * Or: pluginOas({ output: false })
+   * Plugin type should be a Kubb plugin
    */
-  plugins?: Array<Omit<UnknownUserPlugin, 'api'> | UnionPlugins | [name: string, options: object]>
+  plugins?: Array<Omit<UnknownUserPlugin, 'context'>>
 }
 
 export type InputPath = {
@@ -78,6 +75,11 @@ export type Config<TInput = Input> = {
      * @default true
      */
     write?: boolean
+    /**
+     * Define what needs to exported, here you can also disable the export of barrel files
+     * @default `'barrelNamed'`
+     */
+    exportType?: 'barrel' | 'barrelNamed' | false
   }
   /**
    * Array of Kubb plugins to use.
@@ -99,10 +101,6 @@ export type Config<TInput = Input> = {
 
 // plugin
 
-export type UnionPlugins = PluginUnion
-
-export type ObjectPlugin = keyof OptionsPlugins
-
 export type PluginFactoryOptions<
   /**
    * Name to be used for the plugin, this will also be used for they key.
@@ -117,9 +115,9 @@ export type PluginFactoryOptions<
    */
   TResolvedOptions extends object = TOptions,
   /**
-   * API that you want to expose to other plugins.
+   * Context that you want to expose to other plugins.
    */
-  TAPI = any,
+  TContext = any,
   /**
    * When calling `resolvePath` you can specify better types.
    */
@@ -132,7 +130,7 @@ export type PluginFactoryOptions<
   key: PluginKey<TName | string>
   options: TOptions
   resolvedOptions: TResolvedOptions
-  api: TAPI
+  context: TContext
   resolvePathOptions: TResolvePathOptions
 }
 
@@ -153,19 +151,19 @@ export type UserPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOpti
   options: TOptions['resolvedOptions']
   /**
    * Specifies the preceding plugins for the current plugin. You can pass an array of preceding plugin names, and the current plugin will be executed after these plugins.
-   * Can be used to validate depended plugins.
+   * Can be used to validate dependent plugins.
    */
   pre?: Array<string>
   /**
    * Specifies the succeeding plugins for the current plugin. You can pass an array of succeeding plugin names, and the current plugin will be executed before these plugins.
    */
   post?: Array<string>
-} & (TOptions['api'] extends never
+} & (TOptions['context'] extends never
   ? {
-      api?: never
+      context?: never
     }
   : {
-      api: (this: TOptions['name'] extends 'core' ? null : Omit<PluginContext<TOptions>, 'addFile'>) => TOptions['api']
+      context: (this: TOptions['name'] extends 'core' ? null : Omit<PluginContext<TOptions>, 'addFile'>) => TOptions['context']
     })
 
 export type UserPluginWithLifeCycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = UserPlugin<TOptions> & PluginLifecycle<TOptions>
@@ -183,9 +181,24 @@ export type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions>
    * @private
    */
   key: TOptions['key']
+  output?: {
+    /**
+     * Output to save the clients.
+     */
+    path: string
+    /**
+     * Add an extension to the generated imports and exports, default it will not use an extension
+     */
+    extName?: KubbFile.Extname
+    /**
+     * Define what needs to exported, here you can also disable the export of barrel files
+     * @default `'barrelNamed'`
+     */
+    exportType?: 'barrel' | 'barrelNamed' | false
+  }
   /**
    * Specifies the preceding plugins for the current plugin. You can pass an array of preceding plugin names, and the current plugin will be executed after these plugins.
-   * Can be used to validate depended plugins.
+   * Can be used to validate dependent plugins.
    */
   pre?: Array<string>
   /**
@@ -197,14 +210,14 @@ export type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions>
    */
   options: TOptions['resolvedOptions']
   /**
-   * Define an api that can be used by other plugins, see `PluginManager' where we convert from `UserPlugin` to `Plugin`(used when calling `createPlugin`).
+   * Define a context that can be used by other plugins, see `PluginManager' where we convert from `UserPlugin` to `Plugin`(used when calling `createPlugin`).
    */
-} & (TOptions['api'] extends never
+} & (TOptions['context'] extends never
   ? {
-      api?: never
+      context?: never
     }
   : {
-      api: TOptions['api']
+      context: TOptions['context']
     })
 
 export type PluginWithLifeCycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = Plugin<TOptions> & PluginLifecycle<TOptions>
@@ -229,21 +242,6 @@ export type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactor
    * @example ('pet') => 'Pet'
    */
   resolveName?: (this: PluginContext<TOptions>, name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string
-  /**
-   * Makes it possible to run async logic to override the path defined previously by `resolvePath`.
-   * @type hookFirst
-   */
-  load?: (this: Omit<PluginContext<TOptions>, 'addFile'>, path: KubbFile.Path) => PossiblePromise<TransformResult | null>
-  /**
-   * Transform the source-code.
-   * @type hookReduceArg0
-   */
-  transform?: (this: Omit<PluginContext<TOptions>, 'addFile'>, source: string, path: KubbFile.Path) => PossiblePromise<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<TOptions>, 'addFile'>, path: KubbFile.Path, source: string | undefined) => PossiblePromise<string | void>
   /**
    * End of the plugin lifecycle.
    * @type hookParallel
@@ -283,7 +281,7 @@ export type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryO
   cache: Cache<PluginCache>
   fileManager: FileManager
   pluginManager: PluginManager
-  addFile: (...file: Array<KubbFile.File>) => Promise<Array<KubbFile.File>>
+  addFile: (...file: Array<KubbFile.File>) => Promise<Array<KubbFile.ResolvedFile>>
   resolvePath: (params: ResolvePathParams<TOptions['resolvePathOptions']>) => KubbFile.OptionalPath
   resolveName: (params: ResolveNameParams) => string
   logger: Logger
@@ -296,6 +294,3 @@ export type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryO
    */
   plugin: Plugin<TOptions>
 }
-
-// null will mean clear the watcher for this key
-export type TransformResult = string | null

package/src/utils/TreeNode.ts

@@ -1,28 +1,29 @@
-import dirTree from 'directory-tree'
-
-import { FileManager } from '../FileManager.ts'
-
 import type * as KubbFile from '@kubb/fs/types'
-import type { DirectoryTree, DirectoryTreeOptions } from 'directory-tree'
-
-export type TreeNodeOptions = DirectoryTreeOptions
-
-type BarrelData = { type: KubbFile.Mode; path: KubbFile.Path; name: string }
-
-export class TreeNode<T = BarrelData> {
-  public data: T
+import { FileManager } from '../FileManager.ts'
 
-  public parent?: TreeNode<T>
+type BarrelData = {
+  file?: KubbFile.File
+  /**
+   * @deprecated use file instead
+   */
+  type: KubbFile.Mode
+  path: string
+  name: string
+}
 
-  public children: Array<TreeNode<T>> = []
+export class TreeNode {
+  data: BarrelData
+  parent?: TreeNode
+  children: Array<TreeNode> = []
+  #cachedLeaves?: Array<TreeNode> = undefined
 
-  constructor(data: T, parent?: TreeNode<T>) {
+  constructor(data: BarrelData, parent?: TreeNode) {
     this.data = data
     this.parent = parent
     return this
   }
 
-  addChild(data: T): TreeNode<T> {
+  addChild(data: BarrelData): TreeNode {
     const child = new TreeNode(data, this)
     if (!this.children) {
       this.children = []
@@ -31,51 +32,37 @@ export class TreeNode<T = BarrelData> {
     return child
   }
 
-  find(data?: T): TreeNode<T> | null {
-    if (!data) {
-      return null
-    }
-
-    if (data === this.data) {
+  get root(): TreeNode {
+    if (!this.parent) {
       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
+    return this.parent.root
   }
 
-  get leaves(): TreeNode<T>[] {
+  get leaves(): Array<TreeNode> {
     if (!this.children || this.children.length === 0) {
       // this is a leaf
       return [this]
     }
 
+    if (this.#cachedLeaves) {
+      return this.#cachedLeaves
+    }
+
     // if not a leaf, return all children's leaves recursively
-    const leaves: TreeNode<T>[] = []
+    const leaves: TreeNode[] = []
     if (this.children) {
       for (let i = 0, { length } = this.children; i < length; i++) {
         leaves.push.apply(leaves, this.children[i]!.leaves)
       }
     }
-    return leaves
-  }
 
-  get root(): TreeNode<T> {
-    if (!this.parent) {
-      return this
-    }
-    return this.parent.root
+    this.#cachedLeaves = leaves
+
+    return leaves
   }
 
-  forEach(callback: (treeNode: TreeNode<T>) => void): this {
+  forEach(callback: (treeNode: TreeNode) => void): this {
     if (typeof callback !== 'function') {
       throw new TypeError('forEach() callback must be a function')
     }
@@ -93,13 +80,41 @@ export class TreeNode<T = BarrelData> {
     return this
   }
 
-  public static build(path: string, options: TreeNodeOptions = {}): TreeNode | null {
+  findDeep(predicate?: (value: TreeNode, index: number, obj: TreeNode[]) => boolean): TreeNode | undefined {
+    if (typeof predicate !== 'function') {
+      throw new TypeError('find() predicate must be a function')
+    }
+
+    return this.leaves.find(predicate)
+  }
+
+  forEachDeep(callback: (treeNode: TreeNode) => void): void {
+    if (typeof callback !== 'function') {
+      throw new TypeError('forEach() callback must be a function')
+    }
+
+    this.leaves.forEach(callback)
+  }
+
+  filterDeep(callback: (treeNode: TreeNode) => boolean): Array<TreeNode> {
+    if (typeof callback !== 'function') {
+      throw new TypeError('filter() callback must be a function')
+    }
+
+    return this.leaves.filter(callback)
+  }
+
+  mapDeep<T>(callback: (treeNode: TreeNode) => T): Array<T> {
+    if (typeof callback !== 'function') {
+      throw new TypeError('map() callback must be a function')
+    }
+
+    return this.leaves.map(callback)
+  }
+
+  public static build(files: KubbFile.File[], root?: string): TreeNode | null {
     try {
-      const exclude = Array.isArray(options.exclude) ? options.exclude : [options.exclude].filter(Boolean)
-      const filteredTree = dirTree(path, {
-        extensions: options.extensions,
-        exclude: [/node_modules/, ...exclude],
-      })
+      const filteredTree = buildDirectoryTree(files, root)
 
       if (!filteredTree) {
         return null
@@ -108,6 +123,7 @@ export class TreeNode<T = BarrelData> {
       const treeNode = new TreeNode({
         name: filteredTree.name,
         path: filteredTree.path,
+        file: filteredTree.file,
         type: FileManager.getMode(filteredTree.path),
       })
 
@@ -115,6 +131,7 @@ export class TreeNode<T = BarrelData> {
         const subNode = node.addChild({
           name: item.name,
           path: item.path,
+          file: item.file,
           type: FileManager.getMode(item.path),
         })
 
@@ -129,7 +146,72 @@ export class TreeNode<T = BarrelData> {
 
       return treeNode
     } catch (e) {
-      throw new Error('Something went wrong with creating index files with the TreehNode class', { cause: e })
+      throw new Error('Something went wrong with creating barrel files with the TreeNode class', { cause: e })
     }
   }
 }
+
+export type DirectoryTree = {
+  name: string
+  path: string
+  file?: KubbFile.File
+  children: Array<DirectoryTree>
+}
+
+export function buildDirectoryTree(files: Array<KubbFile.File>, rootFolder = ''): DirectoryTree | null {
+  const rootPrefix = rootFolder.endsWith('/') ? rootFolder : `${rootFolder}/`
+  const filteredFiles = files.filter((file) => (rootFolder ? file.path.startsWith(rootPrefix) && !file.path.endsWith('.json') : !file.path.endsWith('.json')))
+
+  if (filteredFiles.length === 0) {
+    return null // No files match the root folder
+  }
+
+  const root: DirectoryTree = {
+    name: rootFolder || '',
+    path: rootFolder || '',
+    children: [],
+  }
+
+  filteredFiles.forEach((file) => {
+    const path = file.path.slice(rootFolder.length)
+    const parts = path.split('/')
+    let currentLevel: DirectoryTree[] = root.children
+    let currentPath = rootFolder
+
+    parts.forEach((part, index) => {
+      if (index !== 0) {
+        currentPath += `/${part}`
+      } else {
+        currentPath += `${part}`
+      }
+
+      let existingNode = currentLevel.find((node) => node.name === part)
+
+      if (!existingNode) {
+        if (index === parts.length - 1) {
+          // If it's the last part, it's a file
+          existingNode = {
+            name: part,
+            file,
+            path: currentPath,
+          } as DirectoryTree
+        } else {
+          // Otherwise, it's a folder
+          existingNode = {
+            name: part,
+            path: currentPath,
+            children: [],
+          } as DirectoryTree
+        }
+        currentLevel.push(existingNode)
+      }
+
+      // Move to the next level if it's a folder
+      if (!existingNode.file) {
+        currentLevel = existingNode.children
+      }
+    })
+  })
+
+  return root
+}

package/src/utils/executeStrategies.ts

@@ -4,7 +4,7 @@ export type ValueOfPromiseFuncArray<TInput extends Array<unknown>> = TInput exte
 
 export function noReturn(): void {}
 
-type SeqOutput<TInput extends Array<PromiseFunc<TValue, null>>, TValue> = Array<Awaited<ValueOfPromiseFuncArray<TInput>>>
+type SeqOutput<TInput extends Array<PromiseFunc<TValue, null>>, TValue> = Promise<Array<Awaited<ValueOfPromiseFuncArray<TInput>>>>
 
 /**
  * Chains promises

package/src/utils/index.ts

@@ -10,4 +10,5 @@ export { timeout } from './timeout.ts'
 export { getUniqueName, setUniqueName } from './uniqueName.ts'
 export type { URLObject } from './URLPath.ts'
 export { URLPath } from './URLPath.ts'
-export { getParser } from './getParser.ts'
+export { getFileParser, createFileImport, createFileExport, createFile, createFileParser } from './parser.ts'
+export type { ParserModule } from './parser.ts'