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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/core",
-  "version": "3.0.0-alpha.3",
+  "version": "3.0.0-alpha.5",
   "description": "Generator core",
   "keywords": [
     "typescript",
@@ -84,23 +84,22 @@
     "seedrandom": "^3.0.5",
     "semver": "^7.6.3",
     "unraw": "^3.0.0",
-    "@kubb/fs": "3.0.0-alpha.3",
-    "@kubb/parser-ts": "3.0.0-alpha.3",
-    "@kubb/types": "3.0.0-alpha.3"
+    "@kubb/fs": "3.0.0-alpha.5",
+    "@kubb/parser-ts": "3.0.0-alpha.5",
+    "@kubb/types": "3.0.0-alpha.5"
   },
   "devDependencies": {
     "@types/react": "^18.3.4",
     "@types/seedrandom": "^3.0.8",
     "@types/semver": "^7.5.8",
     "consola": "^3.2.3",
-    "ora": "^8.0.1",
     "prettier": "^3.3.3",
     "tinyrainbow": "^1.2.0",
     "tsup": "^8.2.4",
     "typescript": "^5.5.4",
-    "@kubb/config-biome": "3.0.0-alpha.3",
-    "@kubb/config-ts": "3.0.0-alpha.3",
-    "@kubb/config-tsup": "3.0.0-alpha.3"
+    "@kubb/config-biome": "3.0.0-alpha.5",
+    "@kubb/config-ts": "3.0.0-alpha.5",
+    "@kubb/config-tsup": "3.0.0-alpha.5"
   },
   "engines": {
     "node": ">=20"

package/src/BarrelManager.ts

@@ -17,6 +17,9 @@ export type BarrelManagerOptions = {
   extName?: KubbFile.Extname
 }
 
+/**
+ * Replace with the use of the FileManager exports/imports
+ */
 export class BarrelManager {
   #options: BarrelManagerOptions
 
@@ -26,6 +29,10 @@ export class BarrelManager {
     return this
   }
 
+  /**
+   * Loop through the file and find all exports(with the help of the ts printer)
+   * Important: a real file is needed(cannot work from memory/FileManager)
+   */
   getNamedExport(root: string, item: KubbFile.Export): KubbFile.Export[] {
     const exportedNames = getExports(path.resolve(root, item.path))
 
@@ -33,7 +40,7 @@ export class BarrelManager {
       return [item]
     }
 
-    return exportedNames.reduce(
+    const exports = exportedNames.reduce(
       (prev, curr) => {
         if (!prev[0]?.name || !prev[1]?.name) {
           return prev
@@ -60,6 +67,8 @@ export class BarrelManager {
         },
       ] as KubbFile.Export[],
     )
+
+    return exports
   }
 
   getNamedExports(root: string, exports: KubbFile.Export[]): KubbFile.Export[] {

package/src/FileManager.ts

@@ -1,8 +1,7 @@
 import crypto from 'node:crypto'
-import { extname, resolve } from 'node:path'
+import path, { extname, resolve } from 'node:path'
 
 import { orderBy } from 'natural-orderby'
-import PQueue from 'p-queue'
 import { isDeepEqual } from 'remeda'
 
 import { getRelativePath, read, write } from '@kubb/fs'
@@ -19,6 +18,7 @@ import type { Logger } from './logger.ts'
 import transformers from './transformers/index.ts'
 import type { Plugin } from './types.ts'
 import { getParser } from './utils'
+import PQueue from 'p-queue'
 
 export type ResolvedFile<TMeta extends FileMetaBase = FileMetaBase, TBaseName extends BaseName = BaseName> = File<TMeta, TBaseName> & {
   /**
@@ -61,24 +61,12 @@ type AddIndexesProps = {
   }
   logger: Logger
   options?: BarrelManagerOptions
-  meta?: FileWithMeta['meta']
-}
-
-type Options = {
-  queue?: PQueue
-  task?: (file: ResolvedFile) => Promise<ResolvedFile>
+  plugin: Plugin
 }
 
 export class FileManager {
   #cache: Map<KubbFile.Path, CacheItem[]> = new Map()
-
-  #task: Options['task']
-  #queue: PQueue
-
-  constructor({ task = async (file) => file, queue = new PQueue() }: Options = {}) {
-    this.#task = task
-    this.#queue = queue
-
+  constructor() {
     return this
   }
 
@@ -90,9 +78,6 @@ export class FileManager {
 
     return files
   }
-  get isExecuting(): boolean {
-    return this.#queue.size !== 0 && this.#queue.pending !== 0
-  }
 
   async add<T extends Array<FileWithMeta> = Array<FileWithMeta>>(...files: T): AddResult<T> {
     const promises = combineFiles(files).map((file) => {
@@ -136,12 +121,7 @@ export class FileManager {
 
     this.#cache.set(resolvedFile.path, [{ cancel: () => controller.abort(), ...resolvedFile }])
 
-    return this.#queue.add(
-      async () => {
-        return this.#task?.(resolvedFile)
-      },
-      { signal: controller.signal },
-    ) as Promise<ResolvedFile>
+    return resolvedFile
   }
 
   async #addOrAppend(file: FileWithMeta): Promise<ResolvedFile> {
@@ -162,18 +142,17 @@ export class FileManager {
     return this.#add(file)
   }
 
-  async addIndexes({ root, output, meta, logger, options = {} }: AddIndexesProps): Promise<void> {
+  async getIndexFiles({ plugin, root, output, logger, options = {} }: AddIndexesProps): Promise<ResolvedFile[]> {
     const { exportType = 'barrel' } = output
-    //        ^?
     if (exportType === false) {
-      return undefined
+      return []
     }
 
     const pathToBuildFrom = resolve(root, output.path)
 
     if (transformers.trimExtName(pathToBuildFrom).endsWith('index')) {
       logger.emit('warning', 'Output has the same fileName as the barrelFiles, please disable barrel generation')
-      return
+      return []
     }
 
     const exportPath = output.path.startsWith('./') ? trimExtName(output.path) : `./${trimExtName(output.path)}`
@@ -185,30 +164,9 @@ export class FileManager {
     let files = barrelManager.getIndexes(pathToBuildFrom)
 
     if (!files) {
-      return undefined
-    }
-
-    if (exportType === 'barrelNamed') {
-      files = files.map((file) => {
-        if (file.exports) {
-          return {
-            ...file,
-            exports: barrelManager.getNamedExports(pathToBuildFrom, file.exports),
-          }
-        }
-        return file
-      })
+      return []
     }
 
-    await Promise.all(
-      files.map((file) => {
-        return this.#addOrAppend({
-          ...file,
-          meta: meta ? meta : file.meta,
-        })
-      }),
-    )
-
     const rootPath = mode === 'split' ? `${exportPath}/index${output.extName || ''}` : `${exportPath}${output.extName || ''}`
     const rootFile: FileWithMeta = {
       path: resolve(root, 'index.ts'),
@@ -230,14 +188,53 @@ export class FileManager {
       exportable: true,
     }
 
-    if (exportType === 'barrelNamed' && !output.exportAs && rootFile.exports?.[0]) {
-      rootFile.exports = barrelManager.getNamedExport(root, rootFile.exports[0])
+    if (exportType === 'barrelNamed') {
+      files = files.map((file) => {
+        if (file.exports) {
+          return {
+            ...file,
+            exports: barrelManager.getNamedExports(pathToBuildFrom, file.exports),
+          }
+        }
+        return file
+      })
+
+      const barrelExportRoot = rootFile.exports?.[0]
+
+      if (!output.exportAs && barrelExportRoot) {
+        const exportFile = files.find((file) => {
+          return trimExtName(file.path) === path.resolve(root, barrelExportRoot.path)
+        })
+
+        if (exportFile?.exports) {
+          rootFile.exports = exportFile.exports.map((exportItem) => {
+            return {
+              ...exportItem,
+              path: getRelativePath(rootFile.path, exportFile.path),
+            }
+          })
+        }
+      }
     }
 
-    await this.#addOrAppend({
-      ...rootFile,
-      meta: meta ? meta : rootFile.meta,
-    })
+    return [
+      ...(await Promise.all(
+        files.map((file) => {
+          return this.#addOrAppend({
+            ...file,
+            meta: {
+              pluginKey: plugin.key,
+            },
+          })
+        }),
+      )),
+      await this.#addOrAppend({
+        ...rootFile,
+        meta: {
+          pluginKey: plugin.key,
+        },
+      }),
+    ]
   }
 
   getCacheByUUID(UUID: KubbFile.UUID): FileWithMeta | undefined {
@@ -262,20 +259,20 @@ export class FileManager {
     this.#cache.delete(path)
   }
 
-  async write(...params: Parameters<typeof write>): Promise<string | undefined> {
+  async write(...params: Parameters<typeof write>): ReturnType<typeof write> {
     return write(...params)
   }
 
-  async read(...params: Parameters<typeof read>): Promise<string> {
+  async read(...params: Parameters<typeof read>): ReturnType<typeof read> {
     return read(...params)
   }
 
-  // statics
-
-  static async getSource<TMeta extends FileMetaBase = FileMetaBase>(file: FileWithMeta<TMeta>): Promise<string> {
-    return getSource<TMeta>(file)
+  async processFiles(...params: Parameters<typeof processFiles>): ReturnType<typeof processFiles> {
+    return processFiles(...params)
   }
 
+  // statics
+
   static combineFiles<TMeta extends FileMetaBase = FileMetaBase>(files: Array<FileWithMeta<TMeta> | null>): Array<FileWithMeta<TMeta>> {
     return combineFiles<TMeta>(files)
   }
@@ -520,3 +517,50 @@ function getEnvSource(source: string, env: NodeJS.ProcessEnv | undefined): strin
     return prev
   }, source)
 }
+
+type WriteFilesProps = {
+  files: KubbFile.File[]
+  logger: Logger
+  dryRun?: boolean
+}
+/**
+ * Global queue
+ */
+const queue = new PQueue({ concurrency: 10 })
+
+export async function processFiles({ dryRun, logger, files }: WriteFilesProps) {
+  const mergedFiles: Array<KubbFile.File<FileMetaBase>> = await Promise.all(
+    files.map(async (file) => ({
+      ...file,
+      source: await getSource(file),
+    })),
+  )
+  const orderedFiles = orderBy(mergedFiles, [(v) => !v.meta?.pluginKey, (v) => v.path.length, (v) => trimExtName(v.path).endsWith('index')], ['desc', 'desc'])
+
+  logger.emit(
+    'debug',
+    orderedFiles.map((item) => `[${item.meta?.pluginKey || 'unknown'}]${item.path}: \n${item.source}`),
+  )
+
+  if (!dryRun) {
+    logger.consola?.pauseLogs()
+    const size = orderedFiles.length
+
+    const promises = orderedFiles.map(async (file, index) => {
+      await queue.add(async () => {
+        logger.emit('progress', { count: index, size, file })
+        await write(file.path, file.source, { sanity: false })
+        await new Promise((resolve) => {
+          setTimeout(resolve, 0)
+        })
+        logger.emit('progress', { count: index + 1, size, file })
+      })
+    })
+
+    await Promise.all(promises)
+
+    logger.consola?.resumeLogs()
+  }
+
+  return mergedFiles
+}

package/src/PluginManager.ts

@@ -1,11 +1,8 @@
-import PQueue from 'p-queue'
-
 import { readSync } from '@kubb/fs'
 import { FileManager, type ResolvedFile } from './FileManager.ts'
 import { isPromise, isPromiseRejectedResult } from './PromiseManager.ts'
 import { PromiseManager } from './PromiseManager.ts'
 import { ValidationPluginError } from './errors.ts'
-import { LogLevel } from './logger.ts'
 import { pluginCore } from './plugin.ts'
 import { transformReservedWord } from './transformers/transformReservedWord.ts'
 import { EventEmitter } from './utils/EventEmitter.ts'
@@ -59,11 +56,6 @@ type SafeParseResult<H extends PluginLifecycleHooks, Result = ReturnType<ParseRe
 
 type Options = {
   logger: Logger
-
-  /**
-   * Task for the FileManager
-   */
-  task: (file: ResolvedFile) => Promise<ResolvedFile>
 }
 
 type Events = {
@@ -94,16 +86,10 @@ export class PluginManager {
   readonly #usedPluginNames: Record<string, number> = {}
   readonly #promiseManager: PromiseManager
 
-  readonly queue: PQueue
-
   constructor(config: Config, options: Options) {
     this.config = config
     this.logger = options.logger
-    this.queue = new PQueue({ concurrency: 1 })
-    this.fileManager = new FileManager({
-      task: options.task,
-      queue: this.queue,
-    })
+    this.fileManager = new FileManager()
     this.#promiseManager = new PromiseManager({
       nullCheck: (state: SafeParseResult<'resolveName'> | null) => !!state?.result,
     })
@@ -423,11 +409,9 @@ export class PluginManager {
     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.emit('warning', `No hook ${hookName} found`)
-        }
+      const containsHookName = plugins.some((item) => item[hookName])
+      if (!containsHookName) {
+        this.logger.emit('info', `No hook ${hookName} found`)
       }
 
       return plugins.filter((item) => item[hookName])
@@ -482,9 +466,9 @@ export class PluginManager {
       const corePlugin = plugins.find((plugin) => plugin.name === 'core' && plugin[hookName])
 
       if (corePlugin) {
-        this.logger.emit('debug', [`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, falling back on the '@kubb/core' plugin`])
+        this.logger.emit('warning', `No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, falling back on the '@kubb/core' plugin`)
       } else {
-        this.logger.emit('debug', [`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, no fallback found in the '@kubb/core' plugin`])
+        this.logger.emit('warning', `No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, no fallback found in the '@kubb/core' plugin`)
       }
       return corePlugin ? [corePlugin] : []
     }

package/src/build.ts

@@ -1,15 +1,14 @@
 import c from 'tinyrainbow'
 
-import { clean, read } from '@kubb/fs'
-import { FileManager, type ResolvedFile } from './FileManager.ts'
+import { clean, read, write } from '@kubb/fs'
+import { type FileManager, processFiles } from './FileManager.ts'
 import { PluginManager } from './PluginManager.ts'
 import { isInputPath } from './config.ts'
-import { LogLevel, createLogger, randomCliColour, LogMapper } from './logger.ts'
+import { createLogger, randomCliColour } from './logger.ts'
 import { URLPath } from './utils/URLPath.ts'
 
 import type { Logger } from './logger.ts'
 import type { PluginContext } from './types.ts'
-import { createConsola } from 'consola'
 
 type BuildOptions = {
   config: PluginContext['config']
@@ -29,16 +28,7 @@ type BuildOutput = {
 }
 
 async function setup(options: BuildOptions): Promise<PluginManager> {
-  const {
-    config,
-    logger = createLogger({
-      logLevel: LogLevel.silent,
-      consola: createConsola({
-        level: 3,
-      }),
-    }),
-  } = options
-  let count = 0
+  const { config, logger = createLogger() } = options
 
   try {
     if (isInputPath(config) && !new URLPath(config.input.path).isURL) {
@@ -59,59 +49,7 @@ async function setup(options: BuildOptions): Promise<PluginManager> {
     await clean(config.output.path)
   }
 
-  const task = async (file: ResolvedFile): Promise<ResolvedFile> => {
-    const { path } = file
-
-    const source: string | null = await FileManager.getSource(file)
-
-    if (source) {
-      if (config.output.write || config.output.write === undefined) {
-        await pluginManager.fileManager.write(path, source, { sanity: false })
-      }
-    }
-
-    return {
-      ...file,
-      source: source || '',
-    }
-  }
-
-  const pluginManager = new PluginManager(config, { logger, task })
-
-  pluginManager.queue.on('add', () => {
-    if (logger.logLevel !== LogLevel.info) {
-      return
-    }
-
-    if (count === 0) {
-      logger.emit('start', '💾 Writing')
-    }
-  })
-
-  pluginManager.queue.on('active', () => {
-    if (logger.logLevel !== LogLevel.info) {
-      return
-    }
-
-    if (logger.spinner && pluginManager.queue.size > 0) {
-      const text = `Item: ${count} Size: ${pluginManager.queue.size}  Pending: ${pluginManager.queue.pending}`
-
-      logger.spinner.suffixText = c.dim(text)
-    }
-    ++count
-  })
-
-  pluginManager.queue.on('completed', () => {
-    if (logger.logLevel !== LogLevel.info) {
-      return
-    }
-
-    if (logger.spinner) {
-      const text = `Item: ${count} Size: ${pluginManager.queue.size}  Pending: ${pluginManager.queue.pending}`
-
-      logger.spinner.suffixText = c.dim(text)
-    }
-  })
+  const pluginManager = new PluginManager(config, { logger })
 
   pluginManager.on('executed', (executer) => {
     const { hookName, plugin, output, parameters } = executer
@@ -133,25 +71,18 @@ async function setup(options: BuildOptions): Promise<PluginManager> {
 export async function build(options: BuildOptions): Promise<BuildOutput> {
   const pluginManager = await setup(options)
 
-  const { fileManager, logger } = pluginManager
-
   await pluginManager.hookParallel({
     hookName: 'buildStart',
     parameters: [options.config],
   })
 
-  await pluginManager.hookParallel({ hookName: 'buildEnd' })
-
-  if (logger.logLevel === LogLevel.info) {
-    logger.emit('end', '💾 Writing completed')
-  }
+  const files = await processFiles({
+    dryRun: !options.config.output.write,
+    files: pluginManager.fileManager.files,
+    logger: pluginManager.logger,
+  })
 
-  const files = await Promise.all(
-    fileManager.files.map(async (file) => ({
-      ...file,
-      source: await FileManager.getSource(file),
-    })),
-  )
+  await pluginManager.hookParallel({ hookName: 'buildEnd' })
 
   return {
     files,
@@ -161,8 +92,7 @@ export async function build(options: BuildOptions): Promise<BuildOutput> {
 
 export async function safeBuild(options: BuildOptions): Promise<BuildOutput> {
   const pluginManager = await setup(options)
-
-  const { fileManager, logger } = pluginManager
+  let files = []
 
   try {
     await pluginManager.hookParallel({
@@ -170,33 +100,21 @@ export async function safeBuild(options: BuildOptions): Promise<BuildOutput> {
       parameters: [options.config],
     })
 
-    await pluginManager.hookParallel({ hookName: 'buildEnd' })
+    files = await processFiles({
+      dryRun: !options.config.output.write,
+      files: pluginManager.fileManager.files,
+      logger: pluginManager.logger,
+    })
 
-    if (logger.logLevel === LogLevel.info) {
-      logger.emit('end', '💾 Writing completed')
-    }
+    await pluginManager.hookParallel({ hookName: 'buildEnd' })
   } catch (e) {
-    const files = await Promise.all(
-      fileManager.files.map(async (file) => ({
-        ...file,
-        source: await FileManager.getSource(file),
-      })),
-    )
-
     return {
-      files,
+      files: [],
       pluginManager,
       error: e as Error,
     }
   }
 
-  const files = await Promise.all(
-    fileManager.files.map(async (file) => ({
-      ...file,
-      source: await FileManager.getSource(file),
-    })),
-  )
-
   return {
     files,
     pluginManager,

package/src/errors.ts

@@ -1,12 +1 @@
-/**
- * Behaves as an Error to log a warning in the console(still stops the execution)
- */
-export class Warning extends Error {
-  constructor(message?: string, options?: { cause: Error }) {
-    super(message, { cause: options?.cause })
-
-    this.name = 'Warning'
-  }
-}
-
 export class ValidationPluginError extends Error {}

package/src/index.ts

@@ -1,6 +1,5 @@
 export { build, build as default, safeBuild } from './build.ts'
 export { defineConfig, isInputPath } from './config.ts'
-export { Warning } from './errors.ts'
 export { FileManager } from './FileManager.ts'
 export type { FileMetaBase } from './FileManager.ts'
 export { Generator } from './Generator.ts'