@kubb/core 3.15.1 → 3.16.1

package/src/__snapshots__/barrel.json

@@ -1,4 +1,22 @@
 [
+  {
+    "path": "src/test.ts",
+    "baseName": "test.ts",
+    "sources": [
+      {
+        "name": "test",
+        "value": "export const test = 2;",
+        "isExportable": true,
+        "isIndexable": true
+      }
+    ],
+    "id": "f8e2d98f76d6e33f21aa686d674544b5c7d6fa3e",
+    "name": "test",
+    "extname": ".ts",
+    "imports": [],
+    "exports": [],
+    "meta": {}
+  },
   {
     "path": "src/index.ts",
     "baseName": "index.ts",
@@ -40,17 +58,53 @@
     "meta": {}
   },
   {
-    "path": "src/sub/index.ts",
-    "baseName": "index.ts",
-    "exports": [
+    "path": "src/sub/hello.ts",
+    "baseName": "hello.ts",
+    "sources": [
       {
-        "path": "./hello.ts"
-      },
+        "name": "hello",
+        "value": "export const hello = 2;",
+        "isExportable": true,
+        "isIndexable": true
+      }
+    ],
+    "id": "4b588b3e31d5ea58e60ceedfcf54b9292fbf6986",
+    "name": "hello",
+    "extname": ".ts",
+    "imports": [],
+    "exports": [],
+    "meta": {}
+  },
+  {
+    "path": "src/sub/world.ts",
+    "baseName": "world.ts",
+    "sources": [
       {
-        "path": "./world.ts"
+        "name": "world",
+        "value": "export const world = 2;",
+        "isExportable": true,
+        "isIndexable": true
       }
     ],
+    "id": "53fb0d18b280dd7edc4a2bc5bbf71ea203680f70",
+    "name": "world",
+    "extname": ".ts",
+    "imports": [],
+    "exports": [],
+    "meta": {}
+  },
+  {
+    "path": "src/sub/index.ts",
+    "baseName": "index.ts",
     "sources": [
+      {
+        "name": "hello",
+        "value": ""
+      },
+      {
+        "name": "world",
+        "value": ""
+      },
       {
         "name": "hello",
         "value": "",
@@ -64,6 +118,26 @@
         "isIndexable": false
       }
     ],
+    "exports": [
+      {
+        "path": "./hello.ts"
+      },
+      {
+        "path": "./world.ts"
+      },
+      {
+        "name": [
+          "hello"
+        ],
+        "path": "./sub/hello.ts"
+      },
+      {
+        "name": [
+          "world"
+        ],
+        "path": "./sub/world.ts"
+      }
+    ],
     "id": "c67967bd2363dd9637437671f6fe1ed146debdbf",
     "name": "index",
     "extname": ".ts",

package/src/build.ts

@@ -1,17 +1,16 @@
-import { clean, exists } from './fs/index.ts'
+import { clean, exists, getRelativePath } from './fs/index.ts'
 import type { KubbFile } from './fs/index.ts'
-import { type FileManager, processFiles } from './FileManager.ts'
 import { PluginManager } from './PluginManager.ts'
 import { isInputPath } from './config.ts'
 import { createLogger } from './logger.ts'
 import { URLPath } from './utils/URLPath.ts'
 
 import { join, resolve } from 'node:path'
-import { getRelativePath } from './fs/index.ts'
 import type { Logger } from './logger.ts'
 import type { Config, Output, UserConfig } from './types.ts'
 import consola from 'consola'
 import { colors } from 'consola/utils'
+import { isDeepEqual } from 'remeda'
 
 type BuildOptions = {
   config: UserConfig
@@ -23,7 +22,7 @@ type BuildOptions = {
 }
 
 type BuildOutput = {
-  files: FileManager['files']
+  files: Array<KubbFile.ResolvedFile>
   pluginManager: PluginManager
   /**
    * Only for safeBuild
@@ -77,7 +76,7 @@ export async function setup(options: BuildOptions): Promise<PluginManager> {
     await clean(join(definedConfig.root, '.kubb'))
   }
 
-  return new PluginManager(definedConfig, { logger })
+  return new PluginManager(definedConfig, { logger, concurrency: 5 })
 }
 
 export async function build(options: BuildOptions): Promise<BuildOutput> {
@@ -93,7 +92,6 @@ export async function build(options: BuildOptions): Promise<BuildOutput> {
 }
 
 export async function safeBuild(options: BuildOptions): Promise<BuildOutput> {
-  let files = []
   const pluginManager = await setup(options)
   const config = pluginManager.config
 
@@ -115,64 +113,73 @@ export async function safeBuild(options: BuildOptions): Promise<BuildOutput> {
       message: 'buildStart',
     })
 
-    // create root barrel file
-    const root = resolve(config.root)
-    const rootPath = resolve(root, config.output.path, 'index.ts')
-    const barrelFiles = pluginManager.fileManager.files.filter((file) => {
-      return file.sources.some((source) => source.isIndexable)
-    })
+    if (config.output.barrelType) {
+      // create root barrel file
+      const root = resolve(config.root)
+      const rootPath = resolve(root, config.output.path, 'index.ts')
+
+      //TODO find clean method without loading all files
+      const files = await pluginManager.fileManager.getFiles()
+
+      const barrelFiles = files.filter((file) => {
+        return file.sources.some((source) => source.isIndexable)
+      })
 
-    const rootFile: KubbFile.File = {
-      path: rootPath,
-      baseName: 'index.ts',
-      exports: barrelFiles
-        .flatMap((file) => {
-          const containsOnlyTypes = file.sources?.every((source) => source.isTypeOnly)
-          return file.sources
-            ?.map((source) => {
-              if (!file.path || !source.isIndexable) {
-                return undefined
-              }
-
-              // validate of the file is coming from plugin x, needs pluginKey on every file TODO update typing
-              const plugin = [...pluginManager.plugins].find((item) => {
-                const meta = file.meta as any
-                return item.key === meta?.pluginKey
+      const rootFile: KubbFile.File = {
+        path: rootPath,
+        baseName: 'index.ts',
+        exports: barrelFiles
+          .flatMap((file) => {
+            const containsOnlyTypes = file.sources?.every((source) => source.isTypeOnly)
+
+            return file.sources
+              ?.map((source) => {
+                if (!file.path || !source.isIndexable) {
+                  return undefined
+                }
+
+                // validate of the file is coming from plugin x, needs pluginKey on every file TODO update typing
+                const plugin = [...pluginManager.plugins].find((item) => {
+                  const meta = file.meta as any
+                  return isDeepEqual(item.key, meta?.pluginKey)
+                })
+                const pluginOptions = plugin?.options as { output?: Output<any> }
+
+                if (!pluginOptions || pluginOptions?.output?.barrelType === false) {
+                  return undefined
+                }
+
+                return {
+                  name: config.output.barrelType === 'all' ? undefined : [source.name],
+                  path: getRelativePath(rootPath, file.path),
+                  isTypeOnly: config.output.barrelType === 'all' ? containsOnlyTypes : source.isTypeOnly,
+                } as KubbFile.Export
               })
-              const pluginOptions = plugin?.options as { output?: Output<any> }
-
-              if (!pluginOptions || pluginOptions?.output?.barrelType === false) {
-                return undefined
-              }
-
-              return {
-                name: config.output.barrelType === 'all' ? undefined : [source.name],
-                path: getRelativePath(rootPath, file.path),
-                isTypeOnly: config.output.barrelType === 'all' ? containsOnlyTypes : source.isTypeOnly,
-              } as KubbFile.Export
-            })
-            .filter(Boolean)
-        })
-        .filter(Boolean),
-      sources: [],
-      meta: {},
-    }
+              .filter(Boolean)
+          })
+          .filter(Boolean),
+        sources: [],
+        meta: {},
+      }
 
-    if (config.output.barrelType) {
       await pluginManager.fileManager.add(rootFile)
     }
 
-    files = await processFiles({
+    const files = await pluginManager.fileManager.processFiles({
       root: config.root,
       extension: config.output.extension,
       dryRun: !config.output.write,
-      files: pluginManager.fileManager.files,
       logger: pluginManager.logger,
     })
 
     await pluginManager.hookParallel({ hookName: 'buildEnd', message: `Build stopped for ${config.name}` })
 
-    pluginManager.fileManager.clear()
+    await pluginManager.fileManager.clear()
+
+    return {
+      files,
+      pluginManager,
+    }
   } catch (e) {
     return {
       files: [],
@@ -180,9 +187,4 @@ export async function safeBuild(options: BuildOptions): Promise<BuildOutput> {
       error: e as Error,
     }
   }
-
-  return {
-    files,
-    pluginManager,
-  }
 }

package/src/fs/types.ts

@@ -104,12 +104,6 @@ export type File<TMeta extends object = object> = {
   sources: Array<Source>
   imports?: Array<Import>
   exports?: Array<Export>
-  /**
-   * This will call fileManager.add instead of fileManager.addOrAppend, adding the source when the files already exists
-   * This will also ignore the combinefiles utils
-   * @default `false`
-   */
-  override?: boolean
   /**
    * Use extra meta, this is getting used to generate the barrel/index files.
    */

package/src/index.ts

@@ -1,6 +1,6 @@
 export { setup, build, build as default, safeBuild } from './build.ts'
 export { defineConfig, isInputPath } from './config.ts'
-export { FileManager, getSource, processFiles } from './FileManager.ts'
+export { FileManager, getSource } from './FileManager.ts'
 export type { FileMetaBase } from './FileManager.ts'
 export { BaseGenerator } from './BaseGenerator.ts'
 export { PackageManager } from './PackageManager.ts'

package/src/utils/Cache.ts

@@ -0,0 +1,31 @@
+export class Cache<T> {
+  #buffer = new Map<string, T>()
+
+  async get(key: string): Promise<T | null> {
+    return this.#buffer.get(key) ?? null
+  }
+
+  async set(key: string, value: T): Promise<void> {
+    this.#buffer.set(key, value)
+  }
+
+  async delete(key: string): Promise<void> {
+    this.#buffer.delete(key)
+  }
+
+  async clear(): Promise<void> {
+    this.#buffer.clear()
+  }
+
+  async keys(): Promise<string[]> {
+    return [...this.#buffer.keys()]
+  }
+
+  async values(): Promise<T[]> {
+    return [...this.#buffer.values()]
+  }
+
+  async flush(): Promise<void> {
+    // No-op for base cache
+  }
+}

package/src/utils/executeStrategies.ts

@@ -1,3 +1,5 @@
+import pLimit from 'p-limit'
+
 type PromiseFunc<T = unknown, T2 = never> = (state?: T) => T2 extends never ? Promise<T> : Promise<T> | T2
 
 type ValueOfPromiseFuncArray<TInput extends Array<unknown>> = TInput extends Array<PromiseFunc<infer X, infer Y>> ? X | Y : never
@@ -53,12 +55,17 @@ export function hookFirst<TInput extends Array<PromiseFunc<TValue, null>>, TValu
 type HookParallelOutput<TInput extends Array<PromiseFunc<TValue, null>>, TValue> = Promise<PromiseSettledResult<Awaited<ValueOfPromiseFuncArray<TInput>>>[]>
 
 /**
- * Run promises in parallel with allSettled
+ * Runs an array of promise functions with optional concurrency limit.
  */
 export function hookParallel<TInput extends Array<PromiseFunc<TValue, null>>, TValue = unknown, TOutput = HookParallelOutput<TInput, TValue>>(
   promises: TInput,
+  concurrency: number = Number.POSITIVE_INFINITY,
 ): TOutput {
-  return Promise.allSettled(promises.filter(Boolean).map((promise) => promise())) as TOutput
+  const limit = pLimit(concurrency)
+
+  const tasks = promises.filter(Boolean).map((promise) => limit(() => promise()))
+
+  return Promise.allSettled(tasks) as TOutput
 }
 
 export type Strategy = 'seq' | 'first' | 'parallel'

package/src/utils/index.ts

@@ -12,3 +12,4 @@ export type { URLObject } from './URLPath.ts'
 export { URLPath } from './URLPath.ts'
 export { getFileParser, createFileImport, createFileExport, createFile, createFileParser, getDefaultBanner } from './parser.ts'
 export type { ParserModule } from './parser.ts'
+export { Cache } from './Cache.ts'

package/src/utils/parser.ts

@@ -57,24 +57,23 @@ export function getDefaultBanner({ title, description, version, config }: { titl
  */
 export function createFile<TMeta extends object = object>(file: KubbFile.File<TMeta>): KubbFile.ResolvedFile<TMeta> {
   const extname = path.extname(file.baseName) as KubbFile.Extname
-
   if (!extname) {
     throw new Error(`No extname found for ${file.baseName}`)
   }
 
   const source = file.sources.map((item) => item.value).join('\n\n')
-  const exports = file.exports ? combineExports(file.exports) : []
-  const imports = file.imports && source ? combineImports(file.imports, exports, source) : []
-  const sources = file.sources ? combineSources(file.sources) : []
+  const exports = file.exports?.length ? combineExports(file.exports) : []
+  const imports = file.imports?.length && source ? combineImports(file.imports, exports, source) : []
+  const sources = file.sources?.length ? combineSources(file.sources) : []
 
   return {
     ...file,
     id: hash({ path: file.path }),
     name: trimExtName(file.baseName),
     extname,
-    imports: imports.map((item) => createFileImport(item)),
-    exports: exports.map((item) => createFileExport(item)),
-    sources: sources.map((item) => createFileSource(item)),
+    imports: imports.map(createFileImport),
+    exports: exports.map(createFileExport),
+    sources: sources.map(createFileSource),
     meta: file.meta || ({} as TMeta),
   }
 }