@kubb/core 2.0.0-beta.1 → 2.0.0-beta.10

package/dist/index.cjs

@@ -170,6 +170,24 @@ function randomPicoColour(text, colors = defaultColours) {
   }
   return formatter(text);
 }
+function slash(path5, platform = "linux") {
+  const isWindowsPath = /^\\\\\?\\/.test(path5);
+  if (["linux", "mac"].includes(platform) && !isWindowsPath) {
+    return path5.replaceAll(/\\/g, "/").replace("../", "").trimEnd();
+  }
+  return path5.replaceAll(/\\/g, "/").replace("../", "").trimEnd();
+}
+function getRelativePath(rootDir, filePath, platform = "linux") {
+  if (!rootDir || !filePath) {
+    throw new Error(`Root and file should be filled in when retrieving the relativePath, ${rootDir || ""} ${filePath || ""}`);
+  }
+  const relativePath = path4.relative(rootDir, filePath);
+  const slashedPath = slash(relativePath, platform);
+  if (slashedPath.startsWith("../")) {
+    return slashedPath.replace(path4.basename(slashedPath), path4.basename(slashedPath, path4.extname(filePath)));
+  }
+  return `./${slashedPath.replace(path4.basename(slashedPath), path4.basename(slashedPath, path4.extname(filePath)))}`;
+}
 var reader = jsRuntime.switcher(
   {
     node: async (path5) => {
@@ -196,141 +214,30 @@ jsRuntime.switcher(
 async function read(path5) {
   return reader(path5);
 }
-var URLPath = class {
-  constructor(path5) {
-    this.path = path5;
-    return this;
-  }
-  /**
-   * Convert Swagger path to URLPath(syntax of Express)
-   * @example /pet/{petId} => /pet/:petId
-   */
-  get URL() {
-    return this.toURLPath();
-  }
-  get isURL() {
-    try {
-      const url = new URL(this.path);
-      if (url?.href) {
-        return true;
-      }
-    } catch (error) {
-      return false;
-    }
-    return false;
-  }
-  /**
-   * Convert Swagger path to template literals/ template strings(camelcase)
-   * @example /pet/{petId} => `/pet/${petId}`
-   * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
-   * @example /account/userID => `/account/${userId}`
-   */
-  get template() {
-    return this.toTemplateString();
-  }
-  get object() {
-    return this.toObject();
-  }
-  get params() {
-    return this.getParams();
-  }
-  toObject({ type = "path", replacer, stringify } = {}) {
-    const object = {
-      url: type === "path" ? this.toURLPath() : this.toTemplateString(replacer),
-      params: this.getParams()
-    };
-    if (stringify) {
-      if (type === "template") {
-        return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
-      }
-      if (object.params) {
-        return `{ url: '${object.url}', params: ${JSON.stringify(object.params).replaceAll("'", "").replaceAll(`"`, "")} }`;
-      }
-      return `{ url: '${object.url}' }`;
-    }
-    return object;
-  }
-  /**
-   * Convert Swagger path to template literals/ template strings(camelcase)
-   * @example /pet/{petId} => `/pet/${petId}`
-   * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
-   * @example /account/userID => `/account/${userId}`
-   */
-  toTemplateString(replacer) {
-    const regex = /{(\w|-)*}/g;
-    const found = this.path.match(regex);
-    let newPath = this.path.replaceAll("{", "${");
-    if (found) {
-      newPath = found.reduce((prev, curr) => {
-        const pathParam = replacer ? replacer(changeCase.camelCase(curr, { delimiter: "", transform: changeCase.camelCaseTransformMerge })) : changeCase.camelCase(curr, { delimiter: "", transform: changeCase.camelCaseTransformMerge });
-        const replacement = `\${${pathParam}}`;
-        return prev.replace(curr, replacement);
-      }, this.path);
-    }
-    return `\`${newPath}\``;
-  }
-  getParams(replacer) {
-    const regex = /{(\w|-)*}/g;
-    const found = this.path.match(regex);
-    if (!found) {
-      return void 0;
-    }
-    const params = {};
-    found.forEach((item) => {
-      item = item.replaceAll("{", "").replaceAll("}", "");
-      const pathParam = replacer ? replacer(changeCase.camelCase(item, { delimiter: "", transform: changeCase.camelCaseTransformMerge })) : changeCase.camelCase(item, { delimiter: "", transform: changeCase.camelCaseTransformMerge });
-      params[pathParam] = pathParam;
-    }, this.path);
-    return params;
-  }
-  /**
-   * Convert Swagger path to URLPath(syntax of Express)
-   * @example /pet/{petId} => /pet/:petId
-   */
-  toURLPath() {
-    return this.path.replaceAll("{", ":").replaceAll("}", "");
-  }
-};
-
-// src/config.ts
-function defineConfig(options) {
-  return options;
-}
-function isInputPath(result) {
-  return !!result && "path" in result;
+function camelCase(text) {
+  return changeCase.camelCase(text, { delimiter: "", stripRegexp: /[^A-Z0-9$]/gi, transform: changeCase.camelCaseTransformMerge });
 }
-
-// src/utils/timeout.ts
-async function timeout(ms) {
-  return new Promise((resolve2) => {
-    setTimeout(() => {
-      resolve2(true);
-    }, ms);
-  });
+function pascalCase(text) {
+  return changeCase.pascalCase(text, { delimiter: "", stripRegexp: /[^A-Z0-9$]/gi, transform: changeCase.pascalCaseTransformMerge });
 }
 
-// src/utils/transformers/combineCodes.ts
+// src/transformers/combineCodes.ts
 function combineCodes(codes) {
   return codes.join("\n");
 }
 
-// src/utils/transformers/createJSDocBlockText.ts
-function createJSDocBlockText({ comments, newLine }) {
+// src/transformers/createJSDocBlockText.ts
+function createJSDocBlockText({ comments }) {
   const filteredComments = comments.filter(Boolean);
   if (!filteredComments.length) {
     return "";
   }
-  const source = `/**
+  return `/**
  * ${filteredComments.join("\n * ")}
  */`;
-  if (newLine) {
-    return `${source}
-`;
-  }
-  return source;
 }
 
-// src/utils/transformers/escape.ts
+// src/transformers/escape.ts
 function escape(text) {
   return text ? text.replaceAll("`", "\\`") : "";
 }
@@ -355,12 +262,12 @@ function jsStringEscape(input) {
   });
 }
 
-// src/utils/transformers/indent.ts
+// src/transformers/indent.ts
 function createIndent(size) {
   return Array.from({ length: size + 1 }).join(" ");
 }
 
-// src/utils/transformers/nameSorter.ts
+// src/transformers/nameSorter.ts
 function nameSorter(a, b) {
   if (a.name < b.name) {
     return -1;
@@ -371,7 +278,7 @@ function nameSorter(a, b) {
   return 0;
 }
 
-// src/utils/transformers/searchAndReplace.ts
+// src/transformers/searchAndReplace.ts
 function searchAndReplace(options) {
   const { text, replaceBy, prefix = "", key } = options;
   const searchValues = options.searchValues?.(prefix, key) || [
@@ -388,7 +295,7 @@ function searchAndReplace(options) {
   }, text);
 }
 
-// src/utils/transformers/transformReservedWord.ts
+// src/transformers/transformReservedWord.ts
 var reservedWords = [
   "abstract",
   "arguments",
@@ -481,13 +388,16 @@ function transformReservedWord(word) {
   return word;
 }
 
-// src/utils/transformers/trim.ts
+// src/transformers/trim.ts
 function trim(text) {
   return text.replaceAll(/\n/g, "").trim();
 }
+function trimExtName(text) {
+  return text.replace(/\.[^/.]+$/, "");
+}
 
-// src/utils/transformers/index.ts
-var transformers = {
+// src/transformers/index.ts
+var transformers_default = {
   combineCodes,
   escape,
   jsStringEscape,
@@ -496,10 +406,127 @@ var transformers = {
   nameSorter,
   searchAndReplace,
   trim,
+  trimExtName,
   JSDoc: {
     createJSDocBlockText
+  },
+  camelCase,
+  pascalCase
+};
+
+// src/utils/URLPath.ts
+var URLPath = class {
+  constructor(path5) {
+    this.path = path5;
+    return this;
+  }
+  /**
+   * Convert Swagger path to URLPath(syntax of Express)
+   * @example /pet/{petId} => /pet/:petId
+   */
+  get URL() {
+    return this.toURLPath();
+  }
+  get isURL() {
+    try {
+      const url = new URL(this.path);
+      if (url?.href) {
+        return true;
+      }
+    } catch (error) {
+      return false;
+    }
+    return false;
+  }
+  /**
+   * Convert Swagger path to template literals/ template strings(camelcase)
+   * @example /pet/{petId} => `/pet/${petId}`
+   * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
+   * @example /account/userID => `/account/${userId}`
+   */
+  get template() {
+    return this.toTemplateString();
+  }
+  get object() {
+    return this.toObject();
+  }
+  get params() {
+    return this.getParams();
+  }
+  toObject({ type = "path", replacer, stringify } = {}) {
+    const object = {
+      url: type === "path" ? this.toURLPath() : this.toTemplateString(replacer),
+      params: this.getParams()
+    };
+    if (stringify) {
+      if (type === "template") {
+        return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
+      }
+      if (object.params) {
+        return `{ url: '${object.url}', params: ${JSON.stringify(object.params).replaceAll("'", "").replaceAll(`"`, "")} }`;
+      }
+      return `{ url: '${object.url}' }`;
+    }
+    return object;
+  }
+  /**
+   * Convert Swagger path to template literals/ template strings(camelcase)
+   * @example /pet/{petId} => `/pet/${petId}`
+   * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
+   * @example /account/userID => `/account/${userId}`
+   */
+  toTemplateString(replacer) {
+    const regex = /{(\w|-)*}/g;
+    const found = this.path.match(regex);
+    let newPath = this.path.replaceAll("{", "${");
+    if (found) {
+      newPath = found.reduce((prev, curr) => {
+        const pathParam = replacer ? replacer(transformers_default.camelCase(curr)) : transformers_default.camelCase(curr);
+        const replacement = `\${${pathParam}}`;
+        return prev.replace(curr, replacement);
+      }, this.path);
+    }
+    return `\`${newPath}\``;
+  }
+  getParams(replacer) {
+    const regex = /{(\w|-)*}/g;
+    const found = this.path.match(regex);
+    if (!found) {
+      return void 0;
+    }
+    const params = {};
+    found.forEach((item) => {
+      item = item.replaceAll("{", "").replaceAll("}", "");
+      const pathParam = replacer ? replacer(transformers_default.camelCase(item)) : transformers_default.camelCase(item);
+      params[pathParam] = pathParam;
+    }, this.path);
+    return params;
+  }
+  /**
+   * Convert Swagger path to URLPath(syntax of Express)
+   * @example /pet/{petId} => /pet/:petId
+   */
+  toURLPath() {
+    return this.path.replaceAll("{", ":").replaceAll("}", "");
   }
 };
+
+// src/config.ts
+function defineConfig(options) {
+  return options;
+}
+function isInputPath(result) {
+  return !!result && "path" in result;
+}
+
+// src/utils/timeout.ts
+async function timeout(ms) {
+  return new Promise((resolve3) => {
+    setTimeout(() => {
+      resolve3(true);
+    }, ms);
+  });
+}
 async function saveCreateDirectory(path5) {
   const passedPath = path4.dirname(path4.resolve(path5));
   await fs2__default.default.mkdir(passedPath, { recursive: true });
@@ -650,78 +677,67 @@ var TreeNode = class _TreeNode {
 var _options;
 var BarrelManager = class {
   constructor(options = {}) {
-    __privateAdd(this, _options, {});
+    __privateAdd(this, _options, void 0);
     __privateSet(this, _options, options);
     return this;
   }
-  getIndexes(root, extName) {
-    const { treeNode = {}, isTypeOnly, filter, map, output, includeExt } = __privateGet(this, _options);
-    const extMapper = {
-      ".ts": {
-        extensions: /\.ts/,
-        exclude: [/schemas/, /json/]
-      },
-      ".json": {
-        extensions: /\.json/,
-        exclude: []
-      }
-    };
-    const tree = TreeNode.build(root, { ...extMapper[extName] || {}, ...treeNode });
+  getIndexes(pathToBuild) {
+    const { treeNode = {}, isTypeOnly, extName } = __privateGet(this, _options);
+    const tree = TreeNode.build(pathToBuild, treeNode);
     if (!tree) {
       return null;
     }
-    const fileReducer = (files2, currentTree) => {
-      if (!currentTree.children) {
+    const fileReducer = (files, treeNode2) => {
+      if (!treeNode2.children) {
         return [];
       }
-      if (currentTree.children?.length > 1) {
-        const indexPath = path4__default.default.resolve(currentTree.data.path, "index.ts");
-        const exports = currentTree.children.filter(Boolean).map((file) => {
-          const importPath = file.data.type === "directory" ? `./${file.data.name}/index` : `./${file.data.name.replace(/\.[^.]*$/, "")}`;
-          if (importPath.includes("index") && file.data.type === "file") {
+      if (treeNode2.children.length > 1) {
+        const indexPath = path4__default.default.resolve(treeNode2.data.path, "index.ts");
+        const exports = treeNode2.children.filter(Boolean).map((file) => {
+          const importPath = file.data.type === "directory" ? `./${file.data.name}/index` : `./${transformers_default.trimExtName(file.data.name)}`;
+          if (importPath.endsWith("index") && file.data.type === "file") {
             return void 0;
           }
           return {
-            path: includeExt ? `${importPath}${extName}` : importPath,
+            path: extName ? `${importPath}${extName}` : importPath,
             isTypeOnly
           };
         }).filter(Boolean);
-        files2.push({
+        files.push({
           path: indexPath,
           baseName: "index.ts",
           source: "",
-          exports: output ? exports?.filter((item) => {
-            return item.path.endsWith(output.replace(/\.[^.]*$/, ""));
-          }) : exports
+          exports,
+          meta: {
+            treeNode: treeNode2
+          }
         });
-      } else {
-        currentTree.children?.forEach((child) => {
-          const indexPath = path4__default.default.resolve(currentTree.data.path, "index.ts");
-          const importPath = child.data.type === "directory" ? `./${child.data.name}/index` : `./${child.data.name.replace(/\.[^.]*$/, "")}`;
-          const exports = [
-            {
-              path: includeExt ? `${importPath}${extName}` : importPath,
-              isTypeOnly
-            }
-          ];
-          files2.push({
-            path: indexPath,
-            baseName: "index.ts",
-            source: "",
-            exports: output ? exports?.filter((item) => {
-              return item.path.endsWith(output.replace(/\.[^.]*$/, ""));
-            }) : exports
-          });
+      } else if (treeNode2.children.length === 1) {
+        const [treeNodeChild] = treeNode2.children;
+        const indexPath = path4__default.default.resolve(treeNode2.data.path, "index.ts");
+        const importPath = treeNodeChild.data.type === "directory" ? `./${treeNodeChild.data.name}/index` : `./${transformers_default.trimExtName(treeNodeChild.data.name)}`;
+        const exports = [
+          {
+            path: extName ? `${importPath}${extName}` : importPath,
+            isTypeOnly
+          }
+        ];
+        files.push({
+          path: indexPath,
+          baseName: "index.ts",
+          source: "",
+          exports,
+          meta: {
+            treeNode: treeNode2
+          }
         });
       }
-      currentTree.children.forEach((childItem) => {
-        fileReducer(files2, childItem);
+      treeNode2.children.forEach((childItem) => {
+        fileReducer(files, childItem);
       });
-      return files2;
+      return files;
     };
-    const files = fileReducer([], tree).reverse();
-    const filteredFiles = filter ? files.filter(filter) : files;
-    return map ? filteredFiles.map(map) : filteredFiles;
+    return fileReducer([], tree).reverse();
   }
 };
 _options = new WeakMap();
@@ -730,7 +746,7 @@ _options = new WeakMap();
 exports.KubbFile = void 0;
 ((KubbFile2) => {
 })(exports.KubbFile || (exports.KubbFile = {}));
-var _cache, _task, _isWriting, _timeout, _queue, _validate, validate_fn, _add, add_fn, _addOrAppend, addOrAppend_fn;
+var _cache, _task, _isWriting, _timeout, _queue, _validate, _add, add_fn, _addOrAppend, addOrAppend_fn;
 var _FileManager = class _FileManager {
   constructor(options) {
     __privateAdd(this, _validate);
@@ -763,7 +779,6 @@ var _FileManager = class _FileManager {
   }
   async add(...files) {
     const promises = files.map((file) => {
-      __privateMethod(this, _validate, validate_fn).call(this, file);
       if (file.override) {
         return __privateMethod(this, _add, add_fn).call(this, file);
       }
@@ -775,12 +790,37 @@ var _FileManager = class _FileManager {
     }
     return resolvedFiles[0];
   }
-  async addIndexes({ root, extName = ".ts", meta, options = {} }) {
-    const barrelManager = new BarrelManager(options);
-    const files = barrelManager.getIndexes(root, extName);
+  async addIndexes({ root, output, meta, options = {} }) {
+    const { exportType = "barrel" } = output;
+    if (!exportType) {
+      return void 0;
+    }
+    const exportPath = output.path.startsWith("./") ? output.path : `./${output.path}`;
+    const barrelManager = new BarrelManager({ extName: output.extName, ...options });
+    const files = barrelManager.getIndexes(path4.resolve(root, output.path));
     if (!files) {
       return void 0;
     }
+    const rootFile = {
+      path: path4.resolve(root, "index.ts"),
+      baseName: "index.ts",
+      source: "",
+      exports: [
+        output.exportAs ? {
+          name: output.exportAs,
+          asAlias: true,
+          path: exportPath,
+          isTypeOnly: options.isTypeOnly
+        } : {
+          path: exportPath,
+          isTypeOnly: options.isTypeOnly
+        }
+      ]
+    };
+    await __privateMethod(this, _addOrAppend, addOrAppend_fn).call(this, {
+      ...rootFile,
+      meta: meta ? meta : rootFile.meta
+    });
     return await Promise.all(
       files.map((file) => {
         return __privateMethod(this, _addOrAppend, addOrAppend_fn).call(this, {
@@ -827,9 +867,22 @@ var _FileManager = class _FileManager {
     }
     const exports = file.exports ? combineExports(file.exports) : [];
     const imports = file.imports ? combineImports(file.imports, exports, file.source) : [];
-    const importNodes = imports.map((item) => factory__namespace.createImportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly }));
+    const importNodes = imports.filter((item) => {
+      return item.path !== transformers_default.trimExtName(file.path);
+    }).map((item) => {
+      return factory__namespace.createImportDeclaration({
+        name: item.name,
+        path: item.root ? getRelativePath(item.root, item.path) : item.path,
+        isTypeOnly: item.isTypeOnly
+      });
+    });
     const exportNodes = exports.map(
-      (item) => factory__namespace.createExportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly, asAlias: item.asAlias })
+      (item) => factory__namespace.createExportDeclaration({
+        name: item.name,
+        path: item.path,
+        isTypeOnly: item.isTypeOnly,
+        asAlias: item.asAlias
+      })
     );
     return [parser.print([...importNodes, ...exportNodes]), getEnvSource(file.source, file.env)].join("\n");
   }
@@ -880,18 +933,10 @@ _isWriting = new WeakMap();
 _timeout = new WeakMap();
 _queue = new WeakMap();
 _validate = new WeakSet();
-validate_fn = function(file) {
-  if (!file.validate) {
-    return;
-  }
-  if (!file.path.toLowerCase().endsWith(file.baseName.toLowerCase())) {
-    throw new Error(`${file.path} should end with the baseName ${file.baseName}`);
-  }
-};
 _add = new WeakSet();
 add_fn = async function(file) {
   const controller = new AbortController();
-  const resolvedFile = { id: crypto2__default.default.randomUUID(), ...file };
+  const resolvedFile = { id: crypto2__default.default.randomUUID(), name: transformers_default.trimExtName(file.baseName), ...file };
   __privateGet(this, _cache).set(resolvedFile.path, [{ cancel: () => controller.abort(), ...resolvedFile }]);
   if (__privateGet(this, _queue)) {
     await __privateGet(this, _queue).run(
@@ -964,7 +1009,7 @@ function combineImports(imports, exports, source) {
       return checker(importName) || exports.some(({ name: name2 }) => Array.isArray(name2) ? name2.some(checker) : checker(name2));
     };
     if (Array.isArray(name)) {
-      name = name.filter((item) => hasImportInSource(item));
+      name = name.filter((item) => typeof item === "string" ? hasImportInSource(item) : hasImportInSource(item.propertyName));
     }
     const prevByPath = prev.findLast((imp) => imp.path === curr.path && imp.isTypeOnly === curr.isTypeOnly);
     const uniquePrev = prev.findLast((imp) => imp.path === curr.path && isEqual__default.default(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly);
@@ -1010,8 +1055,8 @@ function getEnvSource(source, env) {
       throw new TypeError(`Environment should be in upperCase for ${key}`);
     }
     if (typeof replaceBy === "string") {
-      prev = transformers.searchAndReplace({ text: prev.replaceAll(`process.env.${key}`, replaceBy), replaceBy, prefix: "process.env", key });
-      prev = transformers.searchAndReplace({ text: prev.replaceAll(new RegExp(`(declare const).*
+      prev = transformers_default.searchAndReplace({ text: prev.replaceAll(`process.env.${key}`, replaceBy), replaceBy, prefix: "process.env", key });
+      prev = transformers_default.searchAndReplace({ text: prev.replaceAll(new RegExp(`(declare const).*
 `, "ig"), ""), replaceBy, key });
     }
     return prev;
@@ -1050,8 +1095,8 @@ var Queue = class {
     __privateSet(this, _debug, debug);
   }
   run(job, options = { controller: new AbortController(), name: crypto2__default.default.randomUUID(), description: "" }) {
-    return new Promise((resolve2, reject) => {
-      const item = { reject, resolve: resolve2, job, name: options.name, description: options.description || options.name };
+    return new Promise((resolve3, reject) => {
+      const item = { reject, resolve: resolve3, job, name: options.name, description: options.description || options.name };
       options.controller?.signal.addEventListener("abort", () => {
         __privateSet(this, _queue2, __privateGet(this, _queue2).filter((queueItem) => queueItem.name === item.name));
         reject("Aborted");
@@ -1061,8 +1106,8 @@ var Queue = class {
     });
   }
   runSync(job, options = { controller: new AbortController(), name: crypto2__default.default.randomUUID(), description: "" }) {
-    new Promise((resolve2, reject) => {
-      const item = { reject, resolve: resolve2, job, name: options.name, description: options.description || options.name };
+    new Promise((resolve3, reject) => {
+      const item = { reject, resolve: resolve3, job, name: options.name, description: options.description || options.name };
       options.controller?.signal.addEventListener("abort", () => {
         __privateSet(this, _queue2, __privateGet(this, _queue2).filter((queueItem) => queueItem.name === item.name));
       });
@@ -1089,13 +1134,13 @@ work_fn = function() {
   __privateWrapper(this, _workerCount)._++;
   let entry;
   while (entry = __privateGet(this, _queue2).shift()) {
-    const { reject, resolve: resolve2, job, name, description } = entry;
+    const { reject, resolve: resolve3, job, name, description } = entry;
     if (__privateGet(this, _debug)) {
       perf_hooks.performance.mark(name + "_start");
     }
     job().then((result) => {
       this.eventEmitter.emit("jobDone", result);
-      resolve2(result);
+      resolve3(result);
       if (__privateGet(this, _debug)) {
         perf_hooks.performance.mark(name + "_stop");
         perf_hooks.performance.measure(description, name + "_start", name + "_stop");
@@ -1169,8 +1214,7 @@ var definePlugin = createPlugin((options) => {
   return {
     name: pluginName,
     options,
-    key: ["controller", "core"],
-    kind: "controller",
+    key: ["core"],
     api() {
       return {
         get config() {
@@ -1306,11 +1350,14 @@ var PluginManager = class {
           hookName: "resolvePath",
           parameters: [params.baseName, params.directory, params.options]
         });
-        if (paths && paths?.length > 1) {
-          throw new Error(
+        if (paths && paths?.length > 1 && this.logger.logLevel === LogLevel.debug) {
+          this.logger.warn(
             `Cannot return a path where the 'pluginKey' ${params.pluginKey ? JSON.stringify(params.pluginKey) : '"'} is not unique enough
 
-Paths: ${JSON.stringify(paths, void 0, 2)}`
+Paths: ${JSON.stringify(paths, void 0, 2)}
+
+Falling back on the first item.
+`
           );
         }
         return paths?.at(0);
@@ -1327,11 +1374,14 @@ Paths: ${JSON.stringify(paths, void 0, 2)}`
           hookName: "resolveName",
           parameters: [params.name, params.type]
         });
-        if (names && names?.length > 1) {
-          throw new Error(
+        if (names && names?.length > 1 && this.logger.logLevel === LogLevel.debug) {
+          this.logger.warn(
             `Cannot return a name where the 'pluginKey' ${params.pluginKey ? JSON.stringify(params.pluginKey) : '"'} is not unique enough
 
-Names: ${JSON.stringify(names, void 0, 2)}`
+Names: ${JSON.stringify(names, void 0, 2)}
+
+Falling back on the first item.
+`
           );
         }
         return transformReservedWord(names?.at(0) || params.name);
@@ -1514,20 +1564,19 @@ Names: ${JSON.stringify(names, void 0, 2)}`
   }
   getPluginsByKey(hookName, pluginKey) {
     const plugins = [...this.plugins];
-    const [searchKind, searchPluginName, searchIdentifier] = pluginKey;
+    const [searchPluginName, searchIdentifier] = pluginKey;
     const pluginByPluginName = plugins.filter((plugin) => plugin[hookName]).filter((item) => {
-      const [kind, name, identifier] = item.key;
+      const [name, identifier] = item.key;
       const identifierCheck = identifier?.toString() === searchIdentifier?.toString();
-      const kindCheck = kind === searchKind;
       const nameCheck = name === searchPluginName;
       if (searchIdentifier) {
-        return identifierCheck && kindCheck && nameCheck;
+        return identifierCheck && nameCheck;
       }
-      return kindCheck && nameCheck;
+      return nameCheck;
     });
     if (!pluginByPluginName?.length) {
       const corePlugin = plugins.find((plugin) => plugin.name === "core" && plugin[hookName]);
-      if (this.logger.logLevel === "info") {
+      if (this.logger.logLevel === LogLevel.debug) {
         if (corePlugin) {
           this.logger.warn(`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, falling back on the '@kubb/core' plugin`);
         } else {
@@ -1555,7 +1604,7 @@ Names: ${JSON.stringify(names, void 0, 2)}`
   }
   // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
   static get hooks() {
-    return ["validate", "buildStart", "resolvePath", "resolveName", "load", "transform", "writeFile", "buildEnd"];
+    return ["buildStart", "resolvePath", "resolveName", "load", "transform", "writeFile", "buildEnd"];
   }
 };
 _core = new WeakMap();
@@ -1565,7 +1614,7 @@ _getSortedPlugins = new WeakSet();
 getSortedPlugins_fn = function(hookName) {
   const plugins = [...this.plugins].filter((plugin) => plugin.name !== "core");
   if (hookName) {
-    if (this.logger.logLevel === "info") {
+    if (this.logger.logLevel === LogLevel.info) {
       const containsHookName = plugins.some((item) => item[hookName]);
       if (!containsHookName) {
         this.logger.warn(`No hook ${hookName} found`);
@@ -1573,7 +1622,23 @@ getSortedPlugins_fn = function(hookName) {
     }
     return plugins.filter((item) => item[hookName]);
   }
-  return plugins;
+  return plugins.map((plugin) => {
+    if (plugin.pre) {
+      const isValid = plugin.pre.every((pluginName2) => plugins.find((pluginToFind) => pluginToFind.name === pluginName2));
+      if (!isValid) {
+        throw new ValidationPluginError(`This plugin has a pre set that is not valid(${JSON.stringify(plugin.pre, void 0, 2)})`);
+      }
+    }
+    return plugin;
+  }).sort((a, b) => {
+    if (b.pre?.includes(a.name)) {
+      return 1;
+    }
+    if (b.post?.includes(a.name)) {
+      return -1;
+    }
+    return 0;
+  });
 };
 _addExecutedToCallStack = new WeakSet();
 addExecutedToCallStack_fn = function(executer) {
@@ -1664,7 +1729,7 @@ _parse = new WeakSet();
 parse_fn = function(plugin, pluginManager, context) {
   const usedPluginNames = __privateGet(pluginManager, _usedPluginNames);
   setUniqueName(plugin.name, usedPluginNames);
-  const key = plugin.key || [plugin.kind, plugin.name, usedPluginNames[plugin.name]].filter(Boolean);
+  const key = [plugin.name, usedPluginNames[plugin.name]].filter(Boolean);
   if (plugin.name !== "core" && usedPluginNames[plugin.name] >= 2) {
     pluginManager.logger.warn("Using multiple of the same plugin is an experimental feature");
   }
@@ -1752,7 +1817,7 @@ async function setup(options) {
       if (logger.logLevel === LogLevel.info) {
         logger.spinner.start(`\u{1F4BE} Writing`);
       }
-      if (logger.logLevel === "debug") {
+      if (logger.logLevel === LogLevel.debug) {
         logger.info(`PluginKey ${pc3__default.default.dim(JSON.stringify(plugin.key))} 
 with source
 
@@ -1787,10 +1852,6 @@ ${code}`);
 async function build(options) {
   const pluginManager = await setup(options);
   const { fileManager, logger } = pluginManager;
-  await pluginManager.hookParallel({
-    hookName: "validate",
-    parameters: [pluginManager.plugins]
-  });
   await pluginManager.hookParallel({
     hookName: "buildStart",
     parameters: [options.config]
@@ -1806,10 +1867,6 @@ async function safeBuild(options) {
   const pluginManager = await setup(options);
   const { fileManager, logger } = pluginManager;
   try {
-    await pluginManager.hookParallel({
-      hookName: "validate",
-      parameters: [pluginManager.plugins]
-    });
     await pluginManager.hookParallel({
       hookName: "buildStart",
       parameters: [options.config]
@@ -1921,18 +1978,18 @@ function pLimit(concurrency) {
       queue.dequeue()();
     }
   };
-  const run = async (fn, resolve2, args) => {
+  const run = async (fn, resolve3, args) => {
     activeCount++;
     const result = (async () => fn(...args))();
-    resolve2(result);
+    resolve3(result);
     try {
       await result;
     } catch {
     }
     next();
   };
-  const enqueue = (fn, resolve2, args) => {
-    queue.enqueue(run.bind(void 0, fn, resolve2, args));
+  const enqueue = (fn, resolve3, args) => {
+    queue.enqueue(run.bind(void 0, fn, resolve3, args));
     (async () => {
       await Promise.resolve();
       if (activeCount < concurrency && queue.size > 0) {
@@ -1940,8 +1997,8 @@ function pLimit(concurrency) {
       }
     })();
   };
-  const generator = (fn, ...args) => new Promise((resolve2) => {
-    enqueue(fn, resolve2, args);
+  const generator = (fn, ...args) => new Promise((resolve3) => {
+    enqueue(fn, resolve3, args);
   });
   Object.defineProperties(generator, {
     activeCount: {
@@ -2251,10 +2308,6 @@ match_fn = function(packageJSON, dependency) {
 __privateAdd(_PackageManager, _cache2, {});
 var PackageManager = _PackageManager;
 
-// src/SchemaGenerator.ts
-var SchemaGenerator = class extends Generator {
-};
-
 // src/index.ts
 var src_default = build;
 
@@ -2263,7 +2316,6 @@ exports.Generator = Generator;
 exports.PackageManager = PackageManager;
 exports.PluginManager = PluginManager;
 exports.PromiseManager = PromiseManager;
-exports.SchemaGenerator = SchemaGenerator;
 exports.ValidationPluginError = ValidationPluginError;
 exports.Warning = Warning;
 exports.build = build;