@kubb/core 3.0.0-alpha.5 → 3.0.0-alpha.6

package/src/PluginManager.ts

@@ -1,5 +1,4 @@
-import { readSync } from '@kubb/fs'
-import { FileManager, type ResolvedFile } from './FileManager.ts'
+import { FileManager } from './FileManager.ts'
 import { isPromise, isPromiseRejectedResult } from './PromiseManager.ts'
 import { PromiseManager } from './PromiseManager.ts'
 import { ValidationPluginError } from './errors.ts'
@@ -81,6 +80,7 @@ export class PluginManager {
 
   readonly executed: Array<Executer> = []
   readonly logger: Logger
+  readonly options: Options
   readonly #core: Plugin<PluginCore>
 
   readonly #usedPluginNames: Record<string, number> = {}
@@ -88,6 +88,7 @@ export class PluginManager {
 
   constructor(config: Config, options: Options) {
     this.config = config
+    this.options = options
     this.logger = options.logger
     this.fileManager = new FileManager()
     this.#promiseManager = new PromiseManager({
@@ -117,7 +118,6 @@ export class PluginManager {
   }
 
   getFile<TOptions = object>({ name, mode, extName, pluginKey, options }: GetFileProps<TOptions>): KubbFile.File<{ pluginKey: Plugin['key'] }> {
-    let source = ''
     const baseName = `${name}${extName}` as const
     const path = this.resolvePath({ baseName, mode, pluginKey, options })
 
@@ -125,19 +125,13 @@ export class PluginManager {
       throw new Error(`Filepath should be defined for resolvedName "${name}" and pluginKey [${JSON.stringify(pluginKey)}]`)
     }
 
-    try {
-      source = readSync(path)
-    } catch (_e) {
-      //
-    }
-
     return {
       path,
       baseName,
       meta: {
         pluginKey,
       },
-      source,
+      sources: [],
     }
   }
 
@@ -150,11 +144,13 @@ export class PluginManager {
       })
 
       if (paths && paths?.length > 1) {
-        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`,
-        ])
+        this.logger.emit('debug', {
+          logs: [
+            `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)
@@ -173,11 +169,13 @@ export class PluginManager {
       })
 
       if (names && names?.length > 1) {
-        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`,
-        ])
+        this.logger.emit('debug', {
+          logs: [
+            `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)
@@ -201,7 +199,7 @@ export class PluginManager {
   /**
    * Run a specific hookName for plugin x.
    */
-  hookForPlugin<H extends PluginLifecycleHooks>({
+  async hookForPlugin<H extends PluginLifecycleHooks>({
     pluginKey,
     hookName,
     parameters,
@@ -209,9 +207,11 @@ export class PluginManager {
     pluginKey: Plugin['key']
     hookName: H
     parameters: PluginParameter<H>
-  }): Promise<Array<ReturnType<ParseResult<H>> | null>> | null {
+  }): Promise<Array<ReturnType<ParseResult<H>> | null>> {
     const plugins = this.getPluginsByKey(hookName, pluginKey)
 
+    this.logger.emit('progress_start', { id: hookName, size: plugins.length })
+
     const promises = plugins
       .map((plugin) => {
         return this.#execute<H>({
@@ -223,7 +223,11 @@ export class PluginManager {
       })
       .filter(Boolean)
 
-    return Promise.all(promises)
+    const items = await Promise.all(promises)
+
+    this.logger.emit('progress_stop', { id: hookName })
+
+    return items
   }
   /**
    * Run a specific hookName for plugin x.
@@ -240,7 +244,7 @@ export class PluginManager {
   }): Array<ReturnType<ParseResult<H>>> | null {
     const plugins = this.getPluginsByKey(hookName, pluginKey)
 
-    return plugins
+    const result = plugins
       .map((plugin) => {
         return this.#executeSync<H>({
           strategy: 'hookFirst',
@@ -250,6 +254,8 @@ export class PluginManager {
         })
       })
       .filter(Boolean)
+
+    return result
   }
 
   /**
@@ -264,27 +270,33 @@ export class PluginManager {
     parameters: PluginParameter<H>
     skipped?: ReadonlySet<Plugin> | null
   }): Promise<SafeParseResult<H>> {
-    const promises = this.#getSortedPlugins()
-      .filter((plugin) => {
-        return skipped ? skipped.has(plugin) : true
-      })
-      .map((plugin) => {
-        return async () => {
-          const value = await this.#execute<H>({
-            strategy: 'hookFirst',
-            hookName,
-            parameters,
-            plugin,
-          })
+    const plugins = this.#getSortedPlugins(hookName).filter((plugin) => {
+      return skipped ? skipped.has(plugin) : true
+    })
 
-          return Promise.resolve({
-            plugin,
-            result: value,
-          } as SafeParseResult<H>)
-        }
-      })
+    this.logger.emit('progress_start', { id: hookName, size: plugins.length })
 
-    return this.#promiseManager.run('first', promises)
+    const promises = plugins.map((plugin) => {
+      return async () => {
+        const value = await this.#execute<H>({
+          strategy: 'hookFirst',
+          hookName,
+          parameters,
+          plugin,
+        })
+
+        return Promise.resolve({
+          plugin,
+          result: value,
+        } as SafeParseResult<H>)
+      }
+    })
+
+    const result = await this.#promiseManager.run('first', promises)
+
+    this.logger.emit('progress_stop', { id: hookName })
+
+    return result
   }
 
   /**
@@ -300,12 +312,11 @@ export class PluginManager {
     skipped?: ReadonlySet<Plugin> | null
   }): SafeParseResult<H> {
     let parseResult: SafeParseResult<H> = null as unknown as SafeParseResult<H>
+    const plugins = this.#getSortedPlugins(hookName).filter((plugin) => {
+      return skipped ? skipped.has(plugin) : true
+    })
 
-    for (const plugin of this.#getSortedPlugins()) {
-      if (skipped?.has(plugin)) {
-        continue
-      }
-
+    for (const plugin of plugins) {
       parseResult = {
         result: this.#executeSync<H>({
           strategy: 'hookFirst',
@@ -320,6 +331,7 @@ export class PluginManager {
         break
       }
     }
+
     return parseResult
   }
 
@@ -333,7 +345,10 @@ export class PluginManager {
     hookName: H
     parameters?: Parameters<RequiredPluginLifecycle[H]> | undefined
   }): Promise<Awaited<TOuput>[]> {
-    const promises = this.#getSortedPlugins().map((plugin) => {
+    const plugins = this.#getSortedPlugins(hookName)
+    this.logger.emit('progress_start', { id: hookName, size: plugins.length })
+
+    const promises = plugins.map((plugin) => {
       return () =>
         this.#execute({
           strategy: 'hookParallel',
@@ -347,12 +362,14 @@ export class PluginManager {
 
     results.forEach((result, index) => {
       if (isPromiseRejectedResult<Error>(result)) {
-        const plugin = this.#getSortedPlugins()[index]
+        const plugin = this.#getSortedPlugins(hookName)[index]
 
         this.#catcher<H>(result.reason, plugin, hookName)
       }
     })
 
+    this.logger.emit('progress_stop', { id: hookName })
+
     return results.filter((result) => result.status === 'fulfilled').map((result) => (result as PromiseFulfilledResult<Awaited<TOuput>>).value)
   }
 
@@ -369,9 +386,10 @@ export class PluginManager {
     reduce: (reduction: Argument0<H>, result: ReturnType<ParseResult<H>>, plugin: Plugin) => PossiblePromise<Argument0<H> | null>
   }): Promise<Argument0<H>> {
     const [argument0, ...rest] = parameters
+    const plugins = this.#getSortedPlugins(hookName)
 
     let promise: Promise<Argument0<H>> = Promise.resolve(argument0)
-    for (const plugin of this.#getSortedPlugins()) {
+    for (const plugin of plugins) {
       promise = promise
         .then((arg0) => {
           const value = this.#execute({
@@ -392,7 +410,10 @@ export class PluginManager {
    * Chains plugins
    */
   async hookSeq<H extends PluginLifecycleHooks>({ hookName, parameters }: { hookName: H; parameters?: PluginParameter<H> }): Promise<void> {
-    const promises = this.#getSortedPlugins().map((plugin) => {
+    const plugins = this.#getSortedPlugins(hookName)
+    this.logger.emit('progress_start', { id: hookName, size: plugins.length })
+
+    const promises = plugins.map((plugin) => {
       return () =>
         this.#execute({
           strategy: 'hookSeq',
@@ -402,7 +423,9 @@ export class PluginManager {
         })
     })
 
-    return this.#promiseManager.run('seq', promises)
+    await this.#promiseManager.run('seq', promises)
+
+    this.logger.emit('progress_stop', { id: hookName })
   }
 
   #getSortedPlugins(hookName?: keyof PluginLifecycle): Plugin[] {
@@ -411,7 +434,7 @@ export class PluginManager {
     if (hookName) {
       const containsHookName = plugins.some((item) => item[hookName])
       if (!containsHookName) {
-        this.logger.emit('info', `No hook ${hookName} found`)
+        this.logger.emit('debug', { logs: [`No hook ${hookName} found`] })
       }
 
       return plugins.filter((item) => item[hookName])
@@ -466,9 +489,13 @@ export class PluginManager {
       const corePlugin = plugins.find((plugin) => plugin.name === 'core' && plugin[hookName])
 
       if (corePlugin) {
-        this.logger.emit('warning', `No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, falling back on the '@kubb/core' plugin`)
+        this.logger.emit('debug', {
+          logs: [`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, falling back on the '@kubb/core' plugin`],
+        })
       } else {
-        this.logger.emit('warning', `No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, no fallback found in the '@kubb/core' plugin`)
+        this.logger.emit('debug', {
+          logs: [`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, no fallback found in the '@kubb/core' plugin`],
+        })
       }
       return corePlugin ? [corePlugin] : []
     }
@@ -480,6 +507,8 @@ export class PluginManager {
     if (executer) {
       this.events.emit('executed', executer)
       this.executed.push(executer)
+
+      this.logger.emit('progress', { id: executer.hookName, data: `${executer.plugin.name}` })
     }
   }
 
@@ -509,8 +538,11 @@ export class PluginManager {
     }
 
     this.events.emit('execute', { strategy, hookName, parameters, plugin })
+    const promise = new Promise((resolve) => {
+      resolve(undefined)
+    })
 
-    const task = Promise.resolve()
+    const task = promise
       .then(() => {
         if (typeof hook === 'function') {
           const possiblePromiseResult = (hook as Function).apply({ ...this.#core.context, plugin }, parameters) as Promise<ReturnType<ParseResult<H>>>

package/src/build.ts

@@ -1,10 +1,10 @@
 import c from 'tinyrainbow'
 
-import { clean, read, write } from '@kubb/fs'
+import { clean, read } from '@kubb/fs'
 import { type FileManager, processFiles } from './FileManager.ts'
 import { PluginManager } from './PluginManager.ts'
 import { isInputPath } from './config.ts'
-import { createLogger, randomCliColour } from './logger.ts'
+import { createLogger } from './logger.ts'
 import { URLPath } from './utils/URLPath.ts'
 
 import type { Logger } from './logger.ts'
@@ -49,23 +49,7 @@ async function setup(options: BuildOptions): Promise<PluginManager> {
     await clean(config.output.path)
   }
 
-  const pluginManager = new PluginManager(config, { logger })
-
-  pluginManager.on('executed', (executer) => {
-    const { hookName, plugin, output, parameters } = executer
-
-    const logs = [
-      `${randomCliColour(plugin.name)} Executing ${hookName}`,
-      parameters && `${c.bgWhite('Parameters')} ${randomCliColour(plugin.name)} ${hookName}`,
-      JSON.stringify(parameters, undefined, 2),
-      output && `${c.bgWhite('Output')} ${randomCliColour(plugin.name)} ${hookName}`,
-      output,
-    ].filter(Boolean)
-
-    logger.emit('debug', logs as string[])
-  })
-
-  return pluginManager
+  return new PluginManager(config, { logger })
 }
 
 export async function build(options: BuildOptions): Promise<BuildOutput> {
@@ -77,6 +61,7 @@ export async function build(options: BuildOptions): Promise<BuildOutput> {
   })
 
   const files = await processFiles({
+    config: options.config,
     dryRun: !options.config.output.write,
     files: pluginManager.fileManager.files,
     logger: pluginManager.logger,
@@ -100,7 +85,9 @@ export async function safeBuild(options: BuildOptions): Promise<BuildOutput> {
       parameters: [options.config],
     })
 
+    //TODO set extName here instead of the files, extName is private. All exports will have extName, it's up the the process to hide.override the name
     files = await processFiles({
+      config: options.config,
       dryRun: !options.config.output.write,
       files: pluginManager.fileManager.files,
       logger: pluginManager.logger,

package/src/logger.ts

@@ -3,18 +3,20 @@ import c, { createColors } from 'tinyrainbow'
 
 import { EventEmitter } from './utils/EventEmitter.ts'
 
-import { type ConsolaInstance, createConsola, type LogLevel } from 'consola'
-import type { Formatter } from 'tinyrainbow'
 import type * as KubbFile from '@kubb/fs/src/types.ts'
+import { type ConsolaInstance, type LogLevel, createConsola } from 'consola'
+import type { Formatter } from 'tinyrainbow'
 
 type Events = {
   start: [message: string]
   success: [message: string]
   error: [message: string, cause: Error]
   warning: [message: string]
-  debug: [logs: string[]]
+  debug: [{ logs: string[]; override?: boolean; fileName?: string }]
   info: [message: string]
-  progress: [{ count: number; size: number; file: KubbFile.File }]
+  progress_start: [{ id: string; size: number }]
+  progress: [{ id: string; count?: number; data?: string }]
+  progress_stop: [{ id: string }]
 }
 
 export const LogMapper = {
@@ -73,10 +75,6 @@ export function createLogger({ logLevel = 3, name, consola: _consola }: Props =
     consola.info(c.yellow(message))
   })
 
-  events.on('debug', (message) => {
-    consola.debug(c.yellow(message))
-  })
-
   events.on('error', (message, cause) => {
     const error = new Error(message || 'Something went wrong')
     error.cause = cause

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

@@ -261,7 +261,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

package/src/utils/TreeNode.ts

@@ -1,28 +1,30 @@
-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
+import { FileManager } from '../FileManager.ts'
 
-type BarrelData = { type: KubbFile.Mode; path: KubbFile.Path; name: string }
+type BarrelData = {
+  file?: KubbFile.File
+  /**
+   * @deprecated use file instead
+   */
+  type: KubbFile.Mode
+  path: string
+  name: string
+}
 
-export class TreeNode<T = BarrelData> {
-  public data: T
+export class TreeNode {
+  public data: BarrelData
 
-  public parent?: TreeNode<T>
+  public parent?: TreeNode
 
-  public children: Array<TreeNode<T>> = []
+  public children: Array<TreeNode> = []
 
-  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,7 +33,7 @@ export class TreeNode<T = BarrelData> {
     return child
   }
 
-  find(data?: T): TreeNode<T> | null {
+  find(data?: BarrelData): TreeNode | null {
     if (!data) {
       return null
     }
@@ -41,7 +43,7 @@ export class TreeNode<T = BarrelData> {
     }
 
     if (this.children?.length) {
-      for (let i = 0, { length } = this.children, target: TreeNode<T> | null = null; i < length; i++) {
+      for (let i = 0, { length } = this.children, target: TreeNode | null = null; i < length; i++) {
         target = this.children[i]!.find(data)
         if (target) {
           return target
@@ -52,14 +54,14 @@ export class TreeNode<T = BarrelData> {
     return null
   }
 
-  get leaves(): TreeNode<T>[] {
+  get leaves(): Array<TreeNode> {
     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>[] = []
+    const leaves: TreeNode[] = []
     if (this.children) {
       for (let i = 0, { length } = this.children; i < length; i++) {
         leaves.push.apply(leaves, this.children[i]!.leaves)
@@ -68,14 +70,14 @@ export class TreeNode<T = BarrelData> {
     return leaves
   }
 
-  get root(): TreeNode<T> {
+  get root(): TreeNode {
     if (!this.parent) {
       return this
     }
     return this.parent.root
   }
 
-  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 +95,9 @@ export class TreeNode<T = BarrelData> {
     return this
   }
 
-  public static build(path: string, options: TreeNodeOptions = {}): TreeNode | null {
+  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 +106,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 +114,7 @@ export class TreeNode<T = BarrelData> {
         const subNode = node.addChild({
           name: item.name,
           path: item.path,
+          file: item.file,
           type: FileManager.getMode(item.path),
         })
 
@@ -133,3 +133,68 @@ export class TreeNode<T = BarrelData> {
     }
   }
 }
+
+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, createFile, createFileParser } from './parser.ts'
+export type { ParserModule } from './parser.ts'