@kubb/core 1.1.5 → 1.1.7

package/dist/index.js

@@ -1,34 +1,14 @@
 import { createRequire } from 'module';
-import pathParser2 from 'node:path';
+import crypto from 'node:crypto';
 import { promises } from 'node:fs';
+import pathParser2 from 'node:path';
 import { camelCase, camelCaseTransformMerge } from 'change-case';
 import { rimraf } from 'rimraf';
 import dirTree from 'directory-tree';
-import crypto from 'node:crypto';
 import { createImportDeclaration, print, createExportDeclaration } from '@kubb/ts-codegen';
 
 createRequire(import.meta.url);
 
-// src/managers/pluginManager/PluginError.ts
-var PluginError = class extends Error {
-  pluginManager;
-  constructor(message, options) {
-    super(message, { cause: options.cause });
-    this.pluginManager = options.pluginManager;
-  }
-};
-
-// src/managers/pluginManager/ParallelPluginError.ts
-var ParallelPluginError = class extends Error {
-  errors;
-  pluginManager;
-  constructor(message, options) {
-    super(message, { cause: options.cause });
-    this.errors = options.errors;
-    this.pluginManager = options.pluginManager;
-  }
-};
-
 // src/utils/isPromise.ts
 function isPromise(result) {
   return typeof result?.then === "function";
@@ -414,76 +394,7 @@ function getStackTrace(belowFn) {
   return v8StackTrace;
 }
 
-// src/plugin.ts
-function createPlugin(factory) {
-  return (options) => {
-    const plugin = factory(options);
-    if (Array.isArray(plugin)) {
-      throw new Error("Not implemented");
-    }
-    if (!plugin.transform) {
-      plugin.transform = function transform(code) {
-        return code;
-      };
-    }
-    return plugin;
-  };
-}
-var name = "core";
-var definePlugin = createPlugin((options) => {
-  const { fileManager, resolvePath, resolveName, load } = options;
-  const api = {
-    get config() {
-      return options.config;
-    },
-    fileManager,
-    async addFile(...files) {
-      const trace = getStackTrace();
-      const plugins = options.config.plugins?.filter((plugin) => trace[1].getFileName()?.includes(plugin.name)).sort((a, b) => {
-        if (a.name.length < b.name.length)
-          return 1;
-        if (a.name.length > b.name.length)
-          return -1;
-        return 0;
-      });
-      const pluginName = plugins?.[0].name;
-      return Promise.all(
-        files.map((file) => {
-          const fileWithMeta = {
-            ...file,
-            meta: {
-              ...file.meta || {},
-              pluginName
-            }
-          };
-          if (file.override) {
-            return fileManager.add(fileWithMeta);
-          }
-          return fileManager.addOrAppend(fileWithMeta);
-        })
-      );
-    },
-    resolvePath,
-    resolveName: (params) => {
-      const name2 = resolveName(params);
-      return transformReservedWord(name2);
-    },
-    load,
-    cache: createPluginCache(/* @__PURE__ */ Object.create(null))
-  };
-  return {
-    name,
-    options,
-    api,
-    resolvePath(fileName) {
-      const root = pathParser2.resolve(this.config.root, this.config.output.path);
-      return pathParser2.resolve(root, fileName);
-    },
-    resolveName(name2) {
-      return name2;
-    }
-  };
-});
+// src/managers/fileManager/FileManager.ts
 var FileManager = class {
   cache = /* @__PURE__ */ new Map();
   task;
@@ -513,6 +424,13 @@ var FileManager = class {
     });
     return files;
   }
+  get cachedFiles() {
+    const files = [];
+    this.cache.forEach((item) => {
+      files.push(item);
+    });
+    return files;
+  }
   async add(file) {
     const cacheItem = { id: crypto.randomUUID(), file, status: "new" };
     this.cache.set(cacheItem.id, cacheItem);
@@ -568,6 +486,222 @@ ${file.source}`,
     return read(...params);
   }
 };
+function writeIndexes(root, options) {
+  const tree = TreeNode.build(root, { extensions: /\.ts/, ...options });
+  if (!tree) {
+    return void 0;
+  }
+  const fileReducer = (files2, item) => {
+    if (!item.children) {
+      return [];
+    }
+    if (item.children?.length > 1) {
+      const path = pathParser2.resolve(item.data.path, "index.ts");
+      const exports = item.children.map((file) => {
+        if (!file) {
+          return void 0;
+        }
+        const importPath = file.data.type === "directory" ? `./${file.data.name}` : `./${file.data.name.replace(/\.[^.]*$/, "")}`;
+        if (importPath.includes("index") && path.includes("index")) {
+          return void 0;
+        }
+        return { path: importPath };
+      }).filter(Boolean);
+      files2.push({
+        path,
+        fileName: "index.ts",
+        source: "",
+        exports
+      });
+    } else {
+      item.children?.forEach((child) => {
+        const path = pathParser2.resolve(item.data.path, "index.ts");
+        const importPath = child.data.type === "directory" ? `./${child.data.name}` : `./${child.data.name.replace(/\.[^.]*$/, "")}`;
+        files2.push({
+          path,
+          fileName: "index.ts",
+          source: "",
+          exports: [{ path: importPath }]
+        });
+      });
+    }
+    item.children.forEach((childItem) => {
+      fileReducer(files2, childItem);
+    });
+    return files2;
+  };
+  const files = fileReducer([], tree);
+  return files;
+}
+function combineFiles(files) {
+  return files.filter(Boolean).reduce((acc, curr) => {
+    if (!curr) {
+      return acc;
+    }
+    const prevIndex = acc.findIndex((item) => item.path === curr.path);
+    if (prevIndex !== -1) {
+      const prev = acc[prevIndex];
+      acc[prevIndex] = {
+        ...curr,
+        source: `${prev.source}
+${curr.source}`,
+        imports: [...prev.imports || [], ...curr.imports || []],
+        exports: [...prev.exports || [], ...curr.exports || []]
+      };
+    } else {
+      acc.push(curr);
+    }
+    return acc;
+  }, []);
+}
+function getFileSource(file) {
+  let { source } = file;
+  if (!file.fileName.endsWith(".ts")) {
+    return file.source;
+  }
+  const imports = [];
+  const exports = [];
+  file.imports?.forEach((curr) => {
+    const exists = imports.find((imp) => imp.path === curr.path);
+    if (!exists) {
+      imports.push({
+        ...curr,
+        name: Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name
+      });
+    }
+    if (exists && !Array.isArray(exists.name) && exists.name !== curr.name) {
+      imports.push(curr);
+    }
+    if (exists && Array.isArray(exists.name)) {
+      if (Array.isArray(curr.name)) {
+        exists.name = [.../* @__PURE__ */ new Set([...exists.name, ...curr.name])];
+      }
+    }
+  });
+  file.exports?.forEach((curr) => {
+    const exists = exports.find((imp) => imp.path === curr.path);
+    if (!exists) {
+      exports.push({
+        ...curr,
+        name: Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name
+      });
+    }
+    if (exists && !Array.isArray(exists.name) && exists.name !== curr.name && exists.asAlias === curr.asAlias) {
+      exports.push(curr);
+    }
+    if (exists && Array.isArray(exists.name)) {
+      if (Array.isArray(curr.name)) {
+        exists.name = [.../* @__PURE__ */ new Set([...exists.name, ...curr.name])];
+      }
+    }
+  });
+  const importNodes = imports.reduce((prev, curr) => {
+    return [...prev, createImportDeclaration({ name: curr.name, path: curr.path, isTypeOnly: curr.isTypeOnly })];
+  }, []);
+  const importSource = print(importNodes);
+  const exportNodes = exports.reduce((prev, curr) => {
+    return [...prev, createExportDeclaration({ name: curr.name, path: curr.path, asAlias: curr.asAlias })];
+  }, []);
+  const exportSource = print(exportNodes);
+  if (importSource) {
+    source = `${importSource}
+${source}`;
+  }
+  if (exportSource) {
+    source = `${exportSource}
+${source}`;
+  }
+  return source;
+}
+function createPlugin(factory) {
+  return (options) => {
+    const plugin = factory(options);
+    if (Array.isArray(plugin)) {
+      throw new Error("Not implemented");
+    }
+    if (!plugin.transform) {
+      plugin.transform = function transform(code) {
+        return code;
+      };
+    }
+    return plugin;
+  };
+}
+var name = "core";
+var definePlugin = createPlugin((options) => {
+  const { fileManager, resolvePath, resolveName, load } = options;
+  const api = {
+    get config() {
+      return options.config;
+    },
+    fileManager,
+    async addFile(...files) {
+      const trace = getStackTrace();
+      const plugins = options.config.plugins?.filter((plugin) => trace[1].getFileName()?.includes(plugin.name)).sort((a, b) => {
+        if (a.name.length < b.name.length)
+          return 1;
+        if (a.name.length > b.name.length)
+          return -1;
+        return 0;
+      });
+      const pluginName = plugins?.[0].name;
+      return Promise.all(
+        files.map((file) => {
+          const fileWithMeta = {
+            ...file,
+            meta: {
+              ...file.meta || {},
+              pluginName
+            }
+          };
+          if (file.override) {
+            return fileManager.add(fileWithMeta);
+          }
+          return fileManager.addOrAppend(fileWithMeta);
+        })
+      );
+    },
+    resolvePath,
+    resolveName: (params) => {
+      const name2 = resolveName(params);
+      return transformReservedWord(name2);
+    },
+    load,
+    cache: createPluginCache(/* @__PURE__ */ Object.create(null))
+  };
+  return {
+    name,
+    options,
+    api,
+    resolvePath(fileName) {
+      const root = pathParser2.resolve(this.config.root, this.config.output.path);
+      return pathParser2.resolve(root, fileName);
+    },
+    resolveName(name2) {
+      return name2;
+    }
+  };
+});
+
+// src/managers/pluginManager/ParallelPluginError.ts
+var ParallelPluginError = class extends Error {
+  errors;
+  pluginManager;
+  constructor(message, options) {
+    super(message, { cause: options.cause });
+    this.errors = options.errors;
+    this.pluginManager = options.pluginManager;
+  }
+};
+
+// src/managers/pluginManager/PluginError.ts
+var PluginError = class extends Error {
+  pluginManager;
+  constructor(message, options) {
+    super(message, { cause: options.cause });
+    this.pluginManager = options.pluginManager;
+  }
+};
 
 // src/managers/pluginManager/PluginManager.ts
 var hookNames = {
@@ -681,9 +815,9 @@ var PluginManager = class {
     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({
           strategy: "hookFirst",
@@ -708,45 +842,38 @@ var PluginManager = class {
     parameters,
     skipped
   }) {
-    let result = null;
+    let parseResult = null;
     for (const plugin of this.getSortedPlugins(hookName)) {
       if (skipped && skipped.has(plugin))
         continue;
-      result = {
+      parseResult = {
         result: this.executeSync({
           strategy: "hookFirst",
           hookName,
           parameters,
           plugin
-        })
+        }),
+        plugin
       };
-      if (result != null) {
+      if (parseResult?.result != null) {
         break;
       }
     }
-    return result;
+    return parseResult;
   }
-  // parallel
+  /**
+   *
+   * Parallel, runs all plugins
+   */
   async hookParallel({
     hookName,
     parameters
   }) {
     const parallelPromises = [];
     for (const plugin of this.getSortedPlugins(hookName)) {
-      if (plugin[hookName]?.sequential) {
-        await Promise.all(parallelPromises);
-        parallelPromises.length = 0;
-        await this.execute({
-          strategy: "hookParallel",
-          hookName,
-          parameters,
-          plugin
-        });
-      } else {
-        const promise = this.execute({ strategy: "hookParallel", hookName, parameters, plugin });
-        if (promise) {
-          parallelPromises.push(promise);
-        }
+      const promise = this.execute({ strategy: "hookParallel", hookName, parameters, plugin });
+      if (promise) {
+        parallelPromises.push(promise);
       }
     }
     const results = await Promise.allSettled(parallelPromises);
@@ -756,7 +883,10 @@ var PluginManager = class {
     }
     return results.filter((result) => result.status === "fulfilled").map((result) => result.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({
     hookName,
     parameters,
@@ -765,11 +895,11 @@ var PluginManager = class {
     const [argument0, ...rest] = parameters;
     let promise = Promise.resolve(argument0);
     for (const plugin of this.getSortedPlugins(hookName)) {
-      promise = promise.then((argument02) => {
+      promise = promise.then((arg0) => {
         const value = this.execute({
           strategy: "hookReduceArg0",
           hookName,
-          parameters: [argument02, ...rest],
+          parameters: [arg0, ...rest],
           plugin
         });
         return value;
@@ -777,7 +907,9 @@ var PluginManager = class {
     }
     return promise;
   }
-  // chains
+  /**
+   * Chains plugins
+   */
   hookSeq({ hookName, parameters }) {
     let promise = Promise.resolve();
     for (const plugin of this.getSortedPlugins(hookName)) {
@@ -927,139 +1059,9 @@ function validatePlugins(plugins, dependedPluginNames) {
   });
   return true;
 }
-function writeIndexes(root, options) {
-  const tree = TreeNode.build(root, { extensions: /\.ts/, ...options });
-  if (!tree) {
-    return void 0;
-  }
-  const fileReducer = (files2, item) => {
-    if (!item.children) {
-      return [];
-    }
-    if (item.children?.length > 1) {
-      const path = pathParser2.resolve(item.data.path, "index.ts");
-      const exports = item.children.map((file) => {
-        if (!file) {
-          return void 0;
-        }
-        const importPath = file.data.type === "directory" ? `./${file.data.name}` : `./${file.data.name.replace(/\.[^.]*$/, "")}`;
-        if (importPath.includes("index") && path.includes("index")) {
-          return void 0;
-        }
-        return { path: importPath };
-      }).filter(Boolean);
-      files2.push({
-        path,
-        fileName: "index.ts",
-        source: "",
-        exports
-      });
-    } else {
-      item.children?.forEach((child) => {
-        const path = pathParser2.resolve(item.data.path, "index.ts");
-        const importPath = child.data.type === "directory" ? `./${child.data.name}` : `./${child.data.name.replace(/\.[^.]*$/, "")}`;
-        files2.push({
-          path,
-          fileName: "index.ts",
-          source: "",
-          exports: [{ path: importPath }]
-        });
-      });
-    }
-    item.children.forEach((childItem) => {
-      fileReducer(files2, childItem);
-    });
-    return files2;
-  };
-  const files = fileReducer([], tree);
-  return files;
-}
-function combineFiles(files) {
-  return files.filter(Boolean).reduce((acc, curr) => {
-    if (!curr) {
-      return acc;
-    }
-    const prevIndex = acc.findIndex((item) => item.path === curr.path);
-    if (prevIndex !== -1) {
-      const prev = acc[prevIndex];
-      acc[prevIndex] = {
-        ...curr,
-        source: `${prev.source}
-${curr.source}`,
-        imports: [...prev.imports || [], ...curr.imports || []],
-        exports: [...prev.exports || [], ...curr.exports || []]
-      };
-    } else {
-      acc.push(curr);
-    }
-    return acc;
-  }, []);
-}
-function getFileSource(file) {
-  let { source } = file;
-  if (!file.fileName.endsWith(".ts")) {
-    return file.source;
-  }
-  const imports = [];
-  const exports = [];
-  file.imports?.forEach((curr) => {
-    const exists = imports.find((imp) => imp.path === curr.path);
-    if (!exists) {
-      imports.push({
-        ...curr,
-        name: Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name
-      });
-    }
-    if (exists && !Array.isArray(exists.name) && exists.name !== curr.name) {
-      imports.push(curr);
-    }
-    if (exists && Array.isArray(exists.name)) {
-      if (Array.isArray(curr.name)) {
-        exists.name = [.../* @__PURE__ */ new Set([...exists.name, ...curr.name])];
-      }
-    }
-  });
-  file.exports?.forEach((curr) => {
-    const exists = exports.find((imp) => imp.path === curr.path);
-    if (!exists) {
-      exports.push({
-        ...curr,
-        name: Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name
-      });
-    }
-    if (exists && !Array.isArray(exists.name) && exists.name !== curr.name && exists.asAlias === curr.asAlias) {
-      exports.push(curr);
-    }
-    if (exists && Array.isArray(exists.name)) {
-      if (Array.isArray(curr.name)) {
-        exists.name = [.../* @__PURE__ */ new Set([...exists.name, ...curr.name])];
-      }
-    }
-  });
-  const importNodes = imports.reduce((prev, curr) => {
-    return [...prev, createImportDeclaration({ name: curr.name, path: curr.path, isTypeOnly: curr.isTypeOnly })];
-  }, []);
-  const importSource = print(importNodes);
-  const exportNodes = exports.reduce((prev, curr) => {
-    return [...prev, createExportDeclaration({ name: curr.name, path: curr.path, asAlias: curr.asAlias })];
-  }, []);
-  const exportSource = print(exportNodes);
-  if (importSource) {
-    source = `${importSource}
-${source}`;
-  }
-  if (exportSource) {
-    source = `${exportSource}
-${source}`;
-  }
-  return source;
-}
 
 // src/build.ts
 async function transformReducer(_previousCode, result, _plugin) {
-  if (result === null) {
-    return null;
-  }
   return result;
 }
 async function build(options) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/core",
-  "version": "1.1.5",
+  "version": "1.1.7",
   "description": "Generator core",
   "repository": {
     "type": "git",
@@ -43,27 +43,30 @@
     "change-case": "^4.1.2",
     "directory-tree": "^3.5.1",
     "rimraf": "^5.0.1",
-    "@kubb/ts-codegen": "1.1.5"
+    "@kubb/ts-codegen": "1.1.7"
   },
   "devDependencies": {
+    "eslint": "^8.42.0",
     "tsup": "^6.7.0",
     "ora": "^6.3.1",
-    "typescript": "^5.1.3"
+    "typescript": "^5.1.3",
+    "@kubb/tsup-config": "0.1.0",
+    "@kubb/eslint-config": "0.1.0"
   },
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
   "engines": {
-    "node": ">=16",
+    "node": ">=18",
     "pnpm": ">=8"
   },
   "scripts": {
     "build": "tsup",
     "start": "tsup --watch",
     "release": "pnpm publish --no-git-check",
-    "pre-commit": "echo 'pre-commit not configured'",
-    "pre-push": "pnpm typecheck",
+    "lint": "eslint \"**/*.{ts,tsx}\"",
+    "lint-fix": "eslint \"**/*.{ts,tsx}\" --quiet --fix",
     "test": "vitest --passWithNoTests",
     "upgrade": "pnpm update",
     "typecheck": "tsc -p ./tsconfig.json --noEmit --emitDeclarationOnly false"

package/src/build.ts

@@ -1,14 +1,14 @@
 /* eslint-disable no-async-promise-executor */
+import { getFileSource } from './managers/fileManager/index.ts'
 import { PluginManager } from './managers/pluginManager/index.ts'
 import { clean, isURL, read } from './utils/index.ts'
-import { getFileSource } from './managers/fileManager/index.ts'
 import { isPromise } from './utils/isPromise.ts'
 
-import type { OnExecute } from './managers/pluginManager/index.ts'
+import type { Ora } from 'ora'
 import type { File } from './managers/fileManager/index.ts'
+import type { OnExecute } from './managers/pluginManager/index.ts'
+import type { BuildOutput, KubbPlugin, LogLevel, PluginContext, TransformResult } from './types.ts'
 import type { QueueTask } from './utils/index.ts'
-import type { PluginContext, TransformResult, LogLevel, KubbPlugin, BuildOutput } from './types.ts'
-import type { Ora } from 'ora'
 
 export type Logger = {
   log: (message: string, logLevel: LogLevel) => void
@@ -25,9 +25,6 @@ async function transformReducer(
   result: TransformResult | Promise<TransformResult>,
   _plugin: KubbPlugin
 ): Promise<string | null> {
-  if (result === null) {
-    return null
-  }
   return result
 }
 

package/src/config.ts

@@ -1,4 +1,4 @@
-import type { MaybePromise, KubbUserConfig, CLIOptions } from './types.ts'
+import type { CLIOptions, KubbUserConfig, MaybePromise } from './types.ts'
 
 /**
  * Type helper to make it easier to use kubb.config.js

package/src/generators/SchemaGenerator.ts

@@ -1,4 +1,5 @@
 import { Generator } from './Generator.ts'
+
 /**
  * Abstract class that contains the building blocks for plugins to create their own SchemaGenerator
  */