@kubb/core 1.1.5 → 1.1.7

package/src/managers/fileManager/FileManager.ts

@@ -1,9 +1,9 @@
 import crypto from 'node:crypto'
 
-import { write, read } from '../../utils/index.ts'
+import { read, write } from '../../utils/index.ts'
 
-import type { QueueTask, Queue } from '../../utils/index.ts'
-import type { CacheStore, UUID, Status, File } from './types.ts'
+import type { Queue, QueueTask } from '../../utils/index.ts'
+import type { CacheStore, File, Status, UUID } from './types.ts'
 
 export class FileManager {
   private cache: Map<CacheStore['id'], CacheStore> = new Map()
@@ -12,7 +12,7 @@ export class FileManager {
 
   private queue?: Queue
 
-  constructor(options?: { queue: Queue; task: QueueTask<unknown> }) {
+  constructor(options?: { queue: Queue; task?: QueueTask<unknown> }) {
     if (options) {
       this.task = options.task
       this.queue = options.queue
@@ -43,6 +43,15 @@ export class FileManager {
     return files
   }
 
+  get cachedFiles() {
+    const files: CacheStore[] = []
+    this.cache.forEach((item) => {
+      files.push(item)
+    })
+
+    return files
+  }
+
   async add(file: File) {
     const cacheItem = { id: crypto.randomUUID(), file, status: 'new' as Status }
 

package/src/managers/fileManager/utils.ts

@@ -1,12 +1,12 @@
 import pathParser from 'node:path'
 
-import { createImportDeclaration, createExportDeclaration, print } from '@kubb/ts-codegen'
+import { createExportDeclaration, createImportDeclaration, print } from '@kubb/ts-codegen'
 
 import { TreeNode } from '../../utils/index.ts'
 
-import type { PathMode, TreeNodeOptions } from '../../utils/index.ts'
-import type { Path } from '../../types.ts'
 import type ts from 'typescript'
+import type { Path } from '../../types.ts'
+import type { PathMode, TreeNodeOptions } from '../../utils/index.ts'
 import type { File } from './types.ts'
 
 export function writeIndexes(root: string, options: TreeNodeOptions) {

package/src/managers/pluginManager/PluginManager.ts

@@ -2,18 +2,17 @@
 /* eslint-disable no-await-in-loop */
 /* eslint-disable no-restricted-syntax */
 
-import { PluginError } from './PluginError.ts'
-import { ParallelPluginError } from './ParallelPluginError.ts'
-
 import { definePlugin } from '../../plugin.ts'
-import { FileManager } from '../fileManager/FileManager.ts'
-import { Queue } from '../../utils/Queue.ts'
 import { isPromise } from '../../utils/isPromise.ts'
+import { Queue } from '../../utils/Queue.ts'
+import { FileManager } from '../fileManager/FileManager.ts'
+import { ParallelPluginError } from './ParallelPluginError.ts'
+import { PluginError } from './PluginError.ts'
 
-import type { QueueTask } from '../../utils/Queue.ts'
-import type { Argument0, Strategy, Executer, OnExecute, ParseResult, SafeParseResult } from './types.ts'
-import type { KubbConfig, KubbPlugin, PluginLifecycleHooks, PluginLifecycle, MaybePromise, ResolvePathParams, ResolveNameParams } from '../../types.ts'
 import type { CorePluginOptions } from '../../plugin.ts'
+import type { KubbConfig, KubbPlugin, MaybePromise, PluginLifecycle, PluginLifecycleHooks, ResolveNameParams, ResolvePathParams } from '../../types.ts'
+import type { QueueTask } from '../../utils/Queue.ts'
+import type { Argument0, Executer, OnExecute, ParseResult, SafeParseResult, Strategy } from './types.ts'
 
 // inspired by: https://github.com/rollup/rollup/blob/master/src/utils/PluginDriver.ts#
 
@@ -165,9 +164,9 @@ export class PluginManager {
 
     for (const plugin of this.getSortedPlugins(hookName)) {
       if (skipped && skipped.has(plugin)) continue
-      promise = promise.then(async (result) => {
-        if (result != null) {
-          return result
+      promise = promise.then(async (parseResult) => {
+        if (parseResult?.result != null) {
+          return parseResult
         }
         const value = await this.execute<H>({
           strategy: 'hookFirst',
@@ -179,7 +178,7 @@ export class PluginManager {
         return Promise.resolve({
           plugin,
           result: value,
-        } as typeof result)
+        } as typeof parseResult)
       })
     }
 
@@ -199,28 +198,32 @@ export class PluginManager {
     parameters: Parameters<PluginLifecycle[H]>
     skipped?: ReadonlySet<KubbPlugin> | null
   }): SafeParseResult<H> {
-    let result: SafeParseResult<H> = null as unknown as SafeParseResult<H>
+    let parseResult: SafeParseResult<H> = null as unknown as SafeParseResult<H>
 
     for (const plugin of this.getSortedPlugins(hookName)) {
       if (skipped && skipped.has(plugin)) continue
 
-      result = {
+      parseResult = {
         result: this.executeSync<H>({
           strategy: 'hookFirst',
           hookName,
           parameters,
           plugin,
         }),
+        plugin,
       } as SafeParseResult<H>
 
-      if (result != null) {
+      if (parseResult?.result != null) {
         break
       }
     }
-    return result as SafeParseResult<H>
+    return parseResult
   }
 
-  // parallel
+  /**
+   *
+   * Parallel, runs all plugins
+   */
   async hookParallel<H extends PluginLifecycleHooks, TOuput = void>({
     hookName,
     parameters,
@@ -231,21 +234,21 @@ export class PluginManager {
     const parallelPromises: Promise<TOuput>[] = []
 
     for (const plugin of this.getSortedPlugins(hookName)) {
-      if ((plugin[hookName] as { sequential?: boolean })?.sequential) {
-        await Promise.all(parallelPromises)
-        parallelPromises.length = 0
-        await this.execute({
-          strategy: 'hookParallel',
-          hookName,
-          parameters,
-          plugin,
-        })
-      } else {
-        const promise: Promise<TOuput> | null = this.execute({ strategy: 'hookParallel', hookName, parameters, plugin })
-
-        if (promise) {
-          parallelPromises.push(promise)
-        }
+      // TODO implement sequential with `buildStart` as an object({ sequential: boolean; handler: PluginContext["buildStart"] })
+      // if ((plugin[hookName] as { sequential?: boolean })?.sequential) {
+      //   await Promise.all(parallelPromises)
+      //   parallelPromises.length = 0
+      //   await this.execute({
+      //     strategy: 'hookParallel',
+      //     hookName,
+      //     parameters,
+      //     plugin,
+      //   })
+      // }
+      const promise: Promise<TOuput> | null = this.execute({ strategy: 'hookParallel', hookName, parameters, plugin })
+
+      if (promise) {
+        parallelPromises.push(promise)
       }
     }
     const results = await Promise.allSettled(parallelPromises)
@@ -258,7 +261,10 @@ export class PluginManager {
     return results.filter((result) => result.status === 'fulfilled').map((result) => (result as PromiseFulfilledResult<Awaited<TOuput>>).value)
   }
 
-  // chains, reduces returned value, handling the reduced value as the first hook argument
+  /**
+   *
+   * Chains, reduces returned value, handling the reduced value as the first hook argument
+   */
   hookReduceArg0<H extends PluginLifecycleHooks>({
     hookName,
     parameters,
@@ -273,11 +279,11 @@ export class PluginManager {
     let promise: Promise<Argument0<H>> = Promise.resolve(argument0)
     for (const plugin of this.getSortedPlugins(hookName)) {
       promise = promise
-        .then((argument0) => {
+        .then((arg0) => {
           const value = this.execute({
             strategy: 'hookReduceArg0',
             hookName,
-            parameters: [argument0, ...rest] as Parameters<PluginLifecycle[H]>,
+            parameters: [arg0, ...rest] as Parameters<PluginLifecycle[H]>,
             plugin,
           })
           return value
@@ -287,8 +293,9 @@ export class PluginManager {
     return promise
   }
 
-  // chains
-
+  /**
+   * Chains plugins
+   */
   hookSeq<H extends PluginLifecycleHooks>({ hookName, parameters }: { hookName: H; parameters?: Parameters<PluginLifecycle[H]> }) {
     let promise: Promise<void | null> = Promise.resolve()
     for (const plugin of this.getSortedPlugins(hookName)) {
@@ -310,7 +317,7 @@ export class PluginManager {
     return plugins
   }
 
-  private getPlugin(hookName: keyof PluginLifecycle, pluginName: string): KubbPlugin {
+  public getPlugin(hookName: keyof PluginLifecycle, pluginName: string): KubbPlugin {
     const plugins = [...this.plugins]
 
     const pluginByPluginName = plugins.find((item) => item.name === pluginName && item[hookName])

package/src/managers/pluginManager/types.ts

@@ -1,5 +1,6 @@
-import type { PluginManager } from './PluginManager.ts'
 import type { KubbPlugin, PluginLifecycle, PluginLifecycleHooks } from '../../types.ts'
+import type { PluginManager } from './PluginManager.ts'
+
 /**
  * Get the type of the first argument in a function.
  * @example Arg0<(a: string, b: number) => void> -> string

package/src/plugin.ts

@@ -2,9 +2,9 @@ import pathParser from 'node:path'
 
 import { createPluginCache, getStackTrace, transformReservedWord } from './utils/index.ts'
 
-import type { Executer } from './managers/index.ts'
 import type { FileManager } from './managers/fileManager/FileManager.ts'
-import type { PluginContext, KubbPlugin, PluginFactoryOptions, PluginLifecycleHooks } from './types.ts'
+import type { Executer } from './managers/index.ts'
+import type { KubbPlugin, PluginContext, PluginFactoryOptions, PluginLifecycleHooks } from './types.ts'
 
 type KubbPluginFactory<T extends PluginFactoryOptions = PluginFactoryOptions> = (
   options: T['options']

package/src/types.ts

@@ -1,6 +1,6 @@
 /* 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 { FileManager, File } from './managers/fileManager/index.ts'
 import type { Cache } from './utils/cache.ts'
 
 export interface Register {}

package/src/utils/getStackTrace.ts

@@ -9,7 +9,7 @@ export function getStackTrace(belowFn?: Function): NodeJS.CallSite[] {
   Error.prepareStackTrace = function prepareStackTrace(dummyObject, v8StackTrace) {
     return v8StackTrace
   }
-  Error.captureStackTrace(dummyObject, belowFn || getStackTrace)
+  Error.captureStackTrace(dummyObject as object, belowFn || getStackTrace)
 
   const v8StackTrace = dummyObject.stack
   Error.prepareStackTrace = v8Handler

package/src/utils/read.ts

@@ -1,5 +1,5 @@
-import pathParser from 'node:path'
 import { promises as fs } from 'node:fs'
+import pathParser from 'node:path'
 
 function slash(path: string) {
   const isExtendedLengthPath = /^\\\\\?\\/.test(path)