@kubb/core 1.2.3 → 1.3.0

package/dist/index.d.ts

@@ -34,8 +34,6 @@ type PathMode = 'file' | 'directory';
 declare function getPathMode(path: string | undefined | null): PathMode;
 declare function read(path: string): Promise<string>;
 
-declare function isURL(data: string): boolean;
-
 type Data = string[][];
 type Options$2 = {
     typed?: boolean;
@@ -58,20 +56,23 @@ declare function getUniqueName(originalName: string, data: Record<string, number
 
 declare function timeout(ms: number): Promise<unknown>;
 
-type QueueTask<T = unknown> = {
+type QueueJob<T = unknown> = {
     (...args: unknown[]): Promise<T> | Promise<void>;
 };
 type RunOptions = {
-    name: string;
-    description: string;
+    controller?: AbortController;
+    name?: string;
+    description?: string;
 };
 declare class Queue {
-    private readonly queue;
-    workerCount: number;
+    private queue;
+    private workerCount;
     private maxParallel;
     private debug;
     constructor(maxParallel: number, debug?: boolean);
-    run<T>(task: QueueTask<T>, options?: RunOptions): Promise<T>;
+    run<T>(job: QueueJob<T>, options?: RunOptions): Promise<T>;
+    runSync<T>(job: QueueJob<T>, options?: RunOptions): void;
+    get hasJobs(): boolean;
     private work;
 }
 
@@ -146,6 +147,7 @@ declare class URLPath {
      * @example /pet/{petId} => /pet/:petId
      */
     get URL(): string;
+    get isUrl(): boolean;
     /**
      * Convert Swagger path to template literals/ template strings(camelcase)
      * @example /pet/{petId} => `/pet/${petId}`
@@ -173,6 +175,7 @@ declare class URLPath {
      */
     toURLPath(): string;
     static toURLPath(path: string): string;
+    static isURL(path: string): boolean;
 }
 
 type Import = {
@@ -219,9 +222,12 @@ type ResolvedFile = File & {
      */
     id: UUID;
 };
+type CacheItem = ResolvedFile & {
+    cancel?: () => void;
+};
 type Status = 'new' | 'success' | 'removed';
 
-declare function writeIndexes(root: string, options?: TreeNodeOptions): File[] | null;
+declare function getIndexes(root: string, options?: TreeNodeOptions): File[] | null;
 declare function combineFiles(files: Array<File | null>): File[];
 type Extension = '.ts' | '.js';
 declare const extensions: Array<Extension>;
@@ -232,11 +238,12 @@ declare class FileManager {
     private task?;
     private queue?;
     constructor(options?: {
-        queue: Queue;
-        task?: QueueTask<ResolvedFile>;
+        queue?: Queue;
+        task?: QueueJob<ResolvedFile>;
     });
     get extensions(): Extension[];
     get files(): File[];
+    get isExecuting(): boolean;
     add(file: File): Promise<ResolvedFile>;
     addOrAppend(file: File): Promise<ResolvedFile>;
     private append;
@@ -247,6 +254,15 @@ declare class FileManager {
     read(...params: Parameters<typeof read>): Promise<string>;
 }
 
+declare class PluginError extends Error {
+    pluginManager: PluginManager;
+    cause: Error;
+    constructor(message: string, options: {
+        cause: Error;
+        pluginManager: PluginManager;
+    });
+}
+
 /**
  * Get the type of the first argument in a function.
  * @example Arg0<(a: string, b: number) => void> -> string
@@ -257,10 +273,9 @@ type Executer<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
     strategy: Strategy;
     hookName: H;
     plugin: KubbPlugin;
-    input?: unknown[] | undefined;
+    parameters?: unknown[] | undefined;
     output?: unknown;
 };
-type OnExecute<H extends PluginLifecycleHooks = PluginLifecycleHooks> = (this: PluginManager, executer: Executer<H> | undefined, pluginManager: PluginManager) => void;
 type ParseResult<H extends PluginLifecycleHooks> = PluginLifecycle[H];
 type SafeParseResult<H extends PluginLifecycleHooks, Result = ReturnType<ParseResult<H>>> = {
     result: Result;
@@ -270,22 +285,26 @@ type SafeParseResult<H extends PluginLifecycleHooks, Result = ReturnType<ParseRe
 declare const hooks: [keyof PluginLifecycle<PluginFactoryOptions<string, unknown, false, any, Record<string, unknown>>>];
 type Options$1 = {
     debug?: boolean;
-    task: QueueTask<ResolvedFile>;
+    task: QueueJob<ResolvedFile>;
     logger: Logger;
-    onExecute?: OnExecute<PluginLifecycleHooks>;
+};
+type Events = {
+    execute: [executer: Executer];
+    executed: [executer: Executer];
+    error: [pluginError: PluginError];
 };
 declare class PluginManager {
     plugins: KubbPlugin[];
     readonly fileManager: FileManager;
-    private readonly onExecute?;
     private readonly core;
     queue: Queue;
     executed: Executer[];
     logger: Logger;
+    private eventEmitter;
     constructor(config: KubbConfig, options: Options$1);
     resolvePath: (params: ResolvePathParams) => OptionalPath;
     resolveName: (params: ResolveNameParams) => string;
-    load: (id: string) => Promise<SafeParseResult<'load'>>;
+    on<TEventName extends keyof Events & string>(eventName: TEventName, handler: (...eventArg: Events[TEventName]) => void): void;
     /**
      *
      * Run only hook for a specific plugin name
@@ -367,15 +386,6 @@ declare class ValidationPluginError extends Error {
 }
 declare function validatePlugins(plugins: KubbPlugin[], dependedPluginNames: string | string[]): true;
 
-declare class PluginError extends Error {
-    pluginManager: PluginManager;
-    cause: Error;
-    constructor(message: string, options: {
-        cause: Error;
-        pluginManager: PluginManager;
-    });
-}
-
 declare class ParallelPluginError extends Error {
     errors: PluginError[];
     pluginManager: PluginManager;
@@ -384,7 +394,7 @@ declare class ParallelPluginError extends Error {
         errors: PluginError[];
         pluginManager: PluginManager;
     });
-    findError<T extends Error = Error>(searchError: T): T | undefined;
+    findError<T extends Error = Error>(searchError: T | undefined): T | undefined;
 }
 
 interface Register {
@@ -629,7 +639,6 @@ type PluginContext<TOptions = Record<string, unknown>> = {
     addFile: (...file: File[]) => Promise<File[]>;
     resolvePath: (params: ResolvePathParams<TOptions>) => OptionalPath;
     resolveName: (params: ResolveNameParams) => string;
-    load: (id: string) => Promise<SafeParseResult<'load'>>;
     logger: Logger;
 };
 type TransformResult = string | null;
@@ -672,7 +681,6 @@ type Options = {
     fileManager: FileManager;
     resolvePath: PluginContext['resolvePath'];
     resolveName: PluginContext['resolveName'];
-    load: PluginContext['load'];
     logger: PluginContext['logger'];
 };
 type CorePluginOptions = PluginFactoryOptions<'core', Options, false, PluginContext>;
@@ -696,4 +704,4 @@ declare abstract class SchemaGenerator<TOptions extends object, TInput, TOutput>
     abstract build(schema: TInput, name: string, description?: string): TOutput;
 }
 
-export { Argument0, BuildOutput, CLIOptions, Cache, CorePluginOptions, Executer, Extension, File, FileManager, FileName, Generator, KubbConfig, KubbJSONPlugins, KubbObjectPlugin, KubbObjectPlugins, KubbPlugin, KubbPluginKind, KubbUserConfig, KubbUserPlugin, LogLevel, LogLevels, LogType, Logger, OnExecute, OptionalPath, ParallelPluginError, ParseResult, Path, PathMode, PluginCache, PluginContext, PluginError, PluginFactoryOptions, PluginLifecycle, PluginLifecycleHooks, PluginManager, PossiblePromise, Queue, QueueTask, Register, ResolveNameParams, ResolvePathParams, ResolvedFile, SafeParseResult, SchemaGenerator, Source, Status, Strategy, SummaryError, TransformResult, TreeNode, TreeNodeOptions, URLPath, UUID, ValidationPluginError, Warning, build, canLogHierarchy, clean, combineFiles, createJSDocBlockText, createLogger, createPlugin, createPluginCache, build as default, defaultColours, defineConfig, extensions, getEncodedText, getFileSource, getLocation, getPathMode, getRelativePath, getStackTrace, getUniqueName, hooks, importModule, isPromise, isPromiseFulfilledResult, isPromiseRejectedResult, isURL, pluginName as name, nameSorter, normalizeDirectory, objectToParameters, pluginName, randomColour, randomPicoColour, read, renderTemplate, throttle, timeout, transformReservedWord, uniqueId, validatePlugins, write, writeIndexes };
+export { Argument0, BuildOutput, CLIOptions, Cache, CacheItem, CorePluginOptions, Executer, Extension, File, FileManager, FileName, Generator, KubbConfig, KubbJSONPlugins, KubbObjectPlugin, KubbObjectPlugins, KubbPlugin, KubbPluginKind, KubbUserConfig, KubbUserPlugin, LogLevel, LogLevels, LogType, Logger, OptionalPath, ParallelPluginError, ParseResult, Path, PathMode, PluginCache, PluginContext, PluginError, PluginFactoryOptions, PluginLifecycle, PluginLifecycleHooks, PluginManager, PossiblePromise, Queue, QueueJob, Register, ResolveNameParams, ResolvePathParams, ResolvedFile, SafeParseResult, SchemaGenerator, Source, Status, Strategy, SummaryError, TransformResult, TreeNode, TreeNodeOptions, URLPath, UUID, ValidationPluginError, Warning, build, canLogHierarchy, clean, combineFiles, createJSDocBlockText, createLogger, createPlugin, createPluginCache, build as default, defaultColours, defineConfig, extensions, getEncodedText, getFileSource, getIndexes, getLocation, getPathMode, getRelativePath, getStackTrace, getUniqueName, hooks, importModule, isPromise, isPromiseFulfilledResult, isPromiseRejectedResult, pluginName as name, nameSorter, normalizeDirectory, objectToParameters, pluginName, randomColour, randomPicoColour, read, renderTemplate, throttle, timeout, transformReservedWord, uniqueId, validatePlugins, write };

package/dist/index.js

@@ -12,6 +12,7 @@ import pc3 from 'picocolors';
 export { default as pc } from 'picocolors';
 import seedrandom from 'seedrandom';
 import { createImportDeclaration, print, createExportDeclaration } from '@kubb/ts-codegen';
+import { EventEmitter as EventEmitter$1 } from 'node:events';
 
 createRequire(import.meta.url);
 
@@ -97,19 +98,6 @@ function getPathMode(path) {
 async function read(path) {
   return fs.readFile(path, { encoding: "utf8" });
 }
-
-// src/utils/isURL.ts
-function isURL(data) {
-  try {
-    const url = new URL(data);
-    if (url?.href) {
-      return true;
-    }
-  } catch (error) {
-    return false;
-  }
-  return false;
-}
 function objectToParameters(data, options = {}) {
   const { typed } = options;
   return data.reduce((acc, [key, value]) => {
@@ -176,13 +164,30 @@ var Queue = class {
     this.maxParallel = maxParallel;
     this.debug = debug;
   }
-  run(task, options = { name: crypto.randomUUID(), description: "" }) {
+  run(job, options = { controller: new AbortController(), name: crypto.randomUUID(), description: "" }) {
     return new Promise((resolve, reject) => {
-      const item = { reject, resolve, task, name: options.name, description: options.description || options.name };
+      const item = { reject, resolve, job, name: options.name, description: options.description || options.name };
+      options.controller?.signal.addEventListener("abort", () => {
+        this.queue = this.queue.filter((queueItem) => queueItem.name === item.name);
+        reject("Aborted");
+      });
       this.queue.push(item);
       this.work();
     });
   }
+  runSync(job, options = { controller: new AbortController(), name: crypto.randomUUID(), description: "" }) {
+    new Promise((resolve, reject) => {
+      const item = { reject, resolve, job, name: options.name, description: options.description || options.name };
+      options.controller?.signal.addEventListener("abort", () => {
+        this.queue = this.queue.filter((queueItem) => queueItem.name === item.name);
+      });
+      this.queue.push(item);
+      this.work();
+    });
+  }
+  get hasJobs() {
+    return this.workerCount > 0 || this.queue.length > 0;
+  }
   work() {
     if (this.workerCount >= this.maxParallel) {
       return;
@@ -190,11 +195,11 @@ var Queue = class {
     this.workerCount++;
     let entry;
     while (entry = this.queue.shift()) {
-      const { reject, resolve, task, name, description } = entry;
+      const { reject, resolve, job, name, description } = entry;
       if (this.debug) {
         performance.mark(name + "_start");
       }
-      task().then((result) => {
+      job().then((result) => {
         resolve(result);
         if (this.debug) {
           performance.mark(name + "_stop");
@@ -399,7 +404,7 @@ var reservedWords = [
   "valueOf"
 ];
 function transformReservedWord(word) {
-  if (word && reservedWords.includes(word)) {
+  if (word && reservedWords.includes(word) || word?.match(/^\d/)) {
     return `_${word}`;
   }
   return word;
@@ -567,6 +572,9 @@ var URLPath = class {
   get URL() {
     return this.toURLPath();
   }
+  get isUrl() {
+    return URLPath.isURL(this.path);
+  }
   /**
    * Convert Swagger path to template literals/ template strings(camelcase)
    * @example /pet/{petId} => `/pet/${petId}`
@@ -613,8 +621,19 @@ var URLPath = class {
   static toURLPath(path) {
     return path.replaceAll("{", ":").replaceAll("}", "");
   }
+  static isURL(path) {
+    try {
+      const url = new URL(path);
+      if (url?.href) {
+        return true;
+      }
+    } catch (error) {
+      return false;
+    }
+    return false;
+  }
 };
-function writeIndexes(root, options = {}) {
+function getIndexes(root, options = {}) {
   const tree = TreeNode.build(root, { extensions: /\.ts/, ...options });
   if (!tree) {
     return null;
@@ -800,13 +819,24 @@ var FileManager = class {
     });
     return files;
   }
+  get isExecuting() {
+    return this.queue?.hasJobs ?? false;
+  }
   async add(file) {
+    const controller = new AbortController();
     const resolvedFile = { id: crypto.randomUUID(), ...file };
-    this.cache.set(resolvedFile.path, [resolvedFile]);
+    this.cache.set(resolvedFile.path, [{ cancel: () => controller.abort(), ...resolvedFile }]);
     if (this.queue) {
-      await this.queue.run(async () => {
-        await this.task?.(resolvedFile);
-      });
+      try {
+        await this.queue.run(
+          async () => {
+            return this.task?.(resolvedFile);
+          },
+          { controller }
+        );
+      } catch {
+        return resolvedFile;
+      }
     }
     return resolvedFile;
   }
@@ -818,6 +848,7 @@ var FileManager = class {
       if (sourceAlreadyExists) {
         return Promise.resolve(previousCache);
       }
+      previousCache.cancel?.();
       this.cache.delete(previousCache.path);
       return this.add({
         ...file,
@@ -884,7 +915,7 @@ function createPlugin(factory) {
 }
 var pluginName = "core";
 var definePlugin = createPlugin((options) => {
-  const { fileManager, resolvePath, resolveName, load, logger } = options;
+  const { fileManager, resolvePath, resolveName, logger } = options;
   return {
     name: pluginName,
     options,
@@ -928,7 +959,6 @@ var definePlugin = createPlugin((options) => {
           const name = resolveName(params);
           return transformReservedWord(name);
         },
-        load,
         cache: createPluginCache()
       };
     },
@@ -953,6 +983,9 @@ var ParallelPluginError = class extends Error {
     this.pluginManager = options.pluginManager;
   }
   findError(searchError) {
+    if (!searchError) {
+      return void 0;
+    }
     return this.errors.find((error) => {
       if (error.cause) {
         if (error.cause.name == searchError.name) {
@@ -976,6 +1009,30 @@ var PluginError = class extends Error {
     this.pluginManager = options.pluginManager;
   }
 };
+var EventEmitter = class {
+  emitter = new EventEmitter$1();
+  emit(eventName, ...eventArg) {
+    this.emitter.emit(eventName, ...eventArg);
+  }
+  on(eventName, handler) {
+    this.emitter.on(eventName, handler);
+  }
+  off(eventName, handler) {
+    this.emitter.off(eventName, handler);
+  }
+};
+
+// src/managers/pluginManager/pluginParser.ts
+function pluginParser(plugin, context) {
+  if (plugin.api && typeof plugin.api === "function") {
+    const api = plugin.api.call(context);
+    return {
+      ...plugin,
+      api
+    };
+  }
+  return null;
+}
 
 // src/managers/pluginManager/PluginManager.ts
 var hookNames = {
@@ -989,41 +1046,28 @@ var hookNames = {
   buildEnd: 1
 };
 var hooks = Object.keys(hookNames);
-var convertKubbUserPluginToKubbPlugin = (plugin, context) => {
-  if (plugin.api && typeof plugin.api === "function") {
-    const api = plugin.api.call(context);
-    return {
-      ...plugin,
-      api
-    };
-  }
-  return null;
-};
 var PluginManager = class {
   plugins;
   fileManager;
-  onExecute;
   core;
   queue;
   executed = [];
   logger;
+  eventEmitter = new EventEmitter();
   constructor(config, options) {
-    this.onExecute = options.onExecute?.bind(this);
     this.logger = options.logger;
-    this.queue = new Queue(100, options.debug);
+    this.queue = new Queue(50, options.debug);
     this.fileManager = new FileManager({ task: options.task, queue: this.queue });
     const core = definePlugin({
       config,
       logger: this.logger,
       fileManager: this.fileManager,
-      load: this.load,
       resolvePath: this.resolvePath,
       resolveName: this.resolveName
     });
-    const convertedCore = convertKubbUserPluginToKubbPlugin(core, core.api.call(null));
-    this.core = convertedCore;
+    this.core = pluginParser(core, core.api.call(null));
     this.plugins = [this.core, ...config.plugins || []].reduce((prev, plugin) => {
-      const convertedApi = convertKubbUserPluginToKubbPlugin(plugin, convertedCore?.api);
+      const convertedApi = pluginParser(plugin, this.core?.api);
       if (convertedApi) {
         return [...prev, convertedApi];
       }
@@ -1056,12 +1100,9 @@ var PluginManager = class {
       parameters: [params.name]
     }).result;
   };
-  load = async (id) => {
-    return this.hookFirst({
-      hookName: "load",
-      parameters: [id]
-    });
-  };
+  on(eventName, handler) {
+    this.eventEmitter.on(eventName, handler);
+  }
   /**
    *
    * Run only hook for a specific plugin name
@@ -1234,8 +1275,8 @@ var PluginManager = class {
     return pluginByPluginName;
   }
   addExecutedToCallStack(executer) {
-    this.onExecute?.call(this, executer, this);
     if (executer) {
+      this.eventEmitter.emit("execute", executer);
       this.executed.push(executer);
     }
   }
@@ -1257,6 +1298,7 @@ var PluginManager = class {
     if (!hook) {
       return null;
     }
+    this.eventEmitter.emit("execute", { strategy, hookName, parameters, plugin });
     const task = Promise.resolve().then(() => {
       if (typeof hook === "function") {
         const possiblePromiseResult = hook.apply(this.core.api, parameters);
@@ -1274,7 +1316,7 @@ var PluginManager = class {
       return null;
     }).finally(() => {
       this.addExecutedToCallStack({
-        input: parameters,
+        parameters,
         output,
         strategy,
         hookName,
@@ -1301,6 +1343,7 @@ var PluginManager = class {
     if (!hook) {
       return null;
     }
+    this.eventEmitter.emit("execute", { strategy, hookName, parameters, plugin });
     try {
       if (typeof hook === "function") {
         const fn = hook.apply(this.core.api, parameters);
@@ -1314,7 +1357,7 @@ var PluginManager = class {
       return null;
     } finally {
       this.addExecutedToCallStack({
-        input: parameters,
+        parameters,
         output,
         strategy,
         hookName,
@@ -1325,7 +1368,9 @@ var PluginManager = class {
   catcher(e, plugin, hookName) {
     const text = `${e.message} (plugin: ${plugin.name}, hook: ${hookName})
 `;
-    throw new PluginError(text, { cause: e, pluginManager: this });
+    const pluginError = new PluginError(text, { cause: e, pluginManager: this });
+    this.eventEmitter.emit("error", pluginError);
+    throw pluginError;
   }
 };
 function noReturn() {
@@ -1364,7 +1409,7 @@ async function transformReducer(_previousCode, result, _plugin) {
 async function build(options) {
   const { config, debug, logger = createLogger() } = options;
   try {
-    if (!isURL(config.input.path)) {
+    if (!URLPath.isURL(config.input.path)) {
       await read(config.input.path);
     }
   } catch (e) {
@@ -1405,32 +1450,29 @@ async function build(options) {
       }
     }
   };
-  const onExecute = (executer) => {
-    if (!executer) {
-      return;
-    }
-    const { hookName, plugin, output, input } = executer;
+  const pluginManager = new PluginManager(config, { debug, logger, task: queueTask });
+  const { plugins, fileManager } = pluginManager;
+  pluginManager.on("execute", (executer) => {
+    const { hookName, plugin, output, parameters } = executer;
     const messsage = `${randomPicoColour(plugin.name)} Executing ${hookName}`;
-    if (config.logLevel === LogLevel.info && logger?.spinner && input) {
+    if (config.logLevel === LogLevel.info && logger?.spinner && parameters) {
       if (debug) {
         logger.info(messsage);
       } else {
         logger.spinner.suffixText = messsage;
       }
     }
-    if (config.logLevel === LogLevel.stacktrace && logger?.spinner && input) {
+    if (config.logLevel === LogLevel.stacktrace && logger?.spinner && parameters) {
       logger.info(messsage);
       const logs = [
-        input && `${pc3.bgWhite(`Input`)} ${randomPicoColour(plugin.name)} ${hookName}`,
-        JSON.stringify(input, void 0, 2),
+        parameters && `${pc3.bgWhite(`Parameters`)} ${randomPicoColour(plugin.name)} ${hookName}`,
+        JSON.stringify(parameters, void 0, 2),
         output && `${pc3.bgWhite("Output")} ${randomPicoColour(plugin.name)} ${hookName}`,
         output
       ].filter(Boolean);
       console.log(logs.join("\n"));
     }
-  };
-  const pluginManager = new PluginManager(config, { debug, logger, task: queueTask, onExecute });
-  const { plugins, fileManager } = pluginManager;
+  });
   await pluginManager.hookParallel({
     hookName: "validate",
     parameters: [plugins]
@@ -1472,6 +1514,6 @@ var SchemaGenerator = class extends Generator {
 // src/index.ts
 var src_default = build;
 
-export { FileManager, Generator, LogLevel, ParallelPluginError, PluginError, PluginManager, Queue, SchemaGenerator, SummaryError, TreeNode, URLPath, ValidationPluginError, Warning, build, canLogHierarchy, clean, combineFiles, createJSDocBlockText, createLogger, createPlugin, createPluginCache, src_default as default, defaultColours, defineConfig, extensions, getEncodedText, getFileSource, getLocation, getPathMode, getRelativePath, getStackTrace, getUniqueName, hooks, importModule, isPromise, isPromiseFulfilledResult, isPromiseRejectedResult, isURL, pluginName as name, nameSorter, normalizeDirectory, objectToParameters, pluginName, randomColour, randomPicoColour, read, renderTemplate, throttle, timeout, transformReservedWord, uniqueId, validatePlugins, write, writeIndexes };
+export { FileManager, Generator, LogLevel, ParallelPluginError, PluginError, PluginManager, Queue, SchemaGenerator, SummaryError, TreeNode, URLPath, ValidationPluginError, Warning, build, canLogHierarchy, clean, combineFiles, createJSDocBlockText, createLogger, createPlugin, createPluginCache, src_default as default, defaultColours, defineConfig, extensions, getEncodedText, getFileSource, getIndexes, getLocation, getPathMode, getRelativePath, getStackTrace, getUniqueName, hooks, importModule, isPromise, isPromiseFulfilledResult, isPromiseRejectedResult, pluginName as name, nameSorter, normalizeDirectory, objectToParameters, pluginName, randomColour, randomPicoColour, read, renderTemplate, throttle, timeout, transformReservedWord, uniqueId, validatePlugins, write };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map