@kubb/core 1.1.7 → 1.1.9

package/dist/index.js

@@ -1,6 +1,6 @@
 import { createRequire } from 'module';
 import crypto from 'node:crypto';
-import { promises } from 'node:fs';
+import fs from 'fs-extra';
 import pathParser2 from 'node:path';
 import { camelCase, camelCaseTransformMerge } from 'change-case';
 import { rimraf } from 'rimraf';
@@ -15,13 +15,13 @@ function isPromise(result) {
 }
 async function safeWriteFileToPath(path, data) {
   const passedPath = pathParser2.dirname(pathParser2.resolve(path));
-  await promises.mkdir(passedPath, { recursive: true });
-  return promises.writeFile(pathParser2.resolve(path), data, { encoding: "utf-8" });
+  await fs.mkdir(passedPath, { recursive: true });
+  return fs.writeFile(pathParser2.resolve(path), data, { encoding: "utf-8" });
 }
 async function write(data, path) {
   try {
-    await promises.stat(path);
-    const oldContent = await promises.readFile(path, { encoding: "utf-8" });
+    await fs.stat(path);
+    const oldContent = await fs.readFile(path, { encoding: "utf-8" });
     if (oldContent?.toString() === data) {
       return;
     }
@@ -39,15 +39,17 @@ function createPluginCache(cache) {
     },
     get(id) {
       const item = cache[id];
-      if (!item)
+      if (!item) {
         return null;
+      }
       item[0] = 0;
       return item[1];
     },
     has(id) {
       const item = cache[id];
-      if (!item)
+      if (!item) {
         return false;
+      }
       item[0] = 0;
       return true;
     },
@@ -56,19 +58,19 @@ function createPluginCache(cache) {
     }
   };
 }
-function slash(path) {
-  const isExtendedLengthPath = /^\\\\\?\\/.test(path);
-  if (isExtendedLengthPath) {
-    return path;
+function slash(path, platform = "linux") {
+  const isWindowsPath = /^\\\\\?\\/.test(path);
+  if (["linux", "mac"].includes(platform) && !isWindowsPath) {
+    return path.replaceAll(/\\/g, "/").replace("../", "").trimEnd();
   }
-  return path.replace(/\\/g, "/");
+  return path.replaceAll(/\\/g, "/").replace("../", "").trimEnd();
 }
-function getRelativePath(rootDir, filePath) {
+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}`);
+    throw new Error(`Root and file should be filled in when retrieving the relativePath, ${rootDir || ""} ${filePath || ""}`);
   }
   const relativePath = pathParser2.relative(rootDir, filePath);
-  const path = slash(relativePath).replace("../", "").trimEnd();
+  const path = slash(relativePath, platform);
   if (path.startsWith("../")) {
     return path.replace(pathParser2.basename(path), pathParser2.basename(path, pathParser2.extname(filePath)));
   }
@@ -81,12 +83,7 @@ function getPathMode(path) {
   return pathParser2.extname(path) ? "file" : "directory";
 }
 async function read(path) {
-  try {
-    return promises.readFile(path, { encoding: "utf8" });
-  } catch (err) {
-    console.error(err);
-    throw err;
-  }
+  return fs.readFile(path, { encoding: "utf8" });
 }
 
 // src/utils/isURL.ts
@@ -174,9 +171,10 @@ var Queue = class {
       this.work();
     });
   }
-  async work() {
-    if (this.workerCount >= this.maxParallel)
+  work() {
+    if (this.workerCount >= this.maxParallel) {
       return;
+    }
     this.workerCount++;
     let entry;
     while (entry = this.queue.shift()) {
@@ -223,10 +221,13 @@ var TreeNode = class {
     return child;
   }
   find(data) {
+    if (!data) {
+      return null;
+    }
     if (data === this.data) {
       return this;
     }
-    if (this.children) {
+    if (this.children?.length) {
       for (let i = 0, { length } = this.children, target = null; i < length; i++) {
         target = this.children[i].find(data);
         if (target) {
@@ -236,23 +237,23 @@ var TreeNode = class {
     }
     return null;
   }
-  leaves() {
+  get leaves() {
     if (!this.children || this.children.length === 0) {
       return [this];
     }
     const leaves = [];
     if (this.children) {
       for (let i = 0, { length } = this.children; i < length; i++) {
-        leaves.push.apply(leaves, this.children[i].leaves());
+        leaves.push.apply(leaves, this.children[i].leaves);
       }
     }
     return leaves;
   }
-  root() {
+  get root() {
     if (!this.parent) {
       return this;
     }
-    return this.parent.root();
+    return this.parent.root;
   }
   forEach(callback) {
     if (typeof callback !== "function") {
@@ -267,21 +268,26 @@ var TreeNode = class {
     return this;
   }
   static build(path, options = {}) {
-    const filteredTree = dirTree(path, { extensions: options?.extensions, exclude: options.exclude });
-    if (!filteredTree) {
-      return null;
-    }
-    const treeNode = new TreeNode({ name: filteredTree.name, path: filteredTree.path, type: filteredTree.type });
-    const recurse = (node, item) => {
-      const subNode = node.addChild({ name: item.name, path: item.path, type: item.type });
-      if (item.children?.length) {
-        item.children?.forEach((child) => {
-          recurse(subNode, child);
-        });
+    try {
+      const exclude = Array.isArray(options.exclude) ? options.exclude : [options.exclude].filter(Boolean);
+      const filteredTree = dirTree(path, { extensions: options.extensions, exclude: [/node_modules/, ...exclude] });
+      if (!filteredTree) {
+        return null;
       }
-    };
-    filteredTree.children?.forEach((child) => recurse(treeNode, child));
-    return treeNode;
+      const treeNode = new TreeNode({ name: filteredTree.name, path: filteredTree.path, type: filteredTree.type || getPathMode(filteredTree.path) });
+      const recurse = (node, item) => {
+        const subNode = node.addChild({ name: item.name, path: item.path, type: item.type || getPathMode(item.path) });
+        if (item.children?.length) {
+          item.children?.forEach((child) => {
+            recurse(subNode, child);
+          });
+        }
+      };
+      filteredTree.children?.forEach((child) => recurse(treeNode, child));
+      return treeNode;
+    } catch (e) {
+      throw new Error("Something went wrong with creating index files with the TreehNode class", { cause: e });
+    }
   }
 };
 
@@ -394,6 +400,9 @@ function getStackTrace(belowFn) {
   return v8StackTrace;
 }
 
+// src/utils/uniqueId.ts
+var uniqueId = ((counter) => (str = "") => `${str}${++counter}`)(0);
+
 // src/managers/fileManager/FileManager.ts
 var FileManager = class {
   cache = /* @__PURE__ */ new Map();
@@ -486,18 +495,18 @@ ${file.source}`,
     return read(...params);
   }
 };
-function writeIndexes(root, options) {
+function writeIndexes(root, options = {}) {
   const tree = TreeNode.build(root, { extensions: /\.ts/, ...options });
   if (!tree) {
-    return void 0;
+    return null;
   }
-  const fileReducer = (files2, item) => {
-    if (!item.children) {
+  const fileReducer = (files2, currentTree) => {
+    if (!currentTree.children) {
       return [];
     }
-    if (item.children?.length > 1) {
-      const path = pathParser2.resolve(item.data.path, "index.ts");
-      const exports = item.children.map((file) => {
+    if (currentTree.children?.length > 1) {
+      const path = pathParser2.resolve(currentTree.data.path, "index.ts");
+      const exports = currentTree.children.map((file) => {
         if (!file) {
           return void 0;
         }
@@ -514,8 +523,8 @@ function writeIndexes(root, options) {
         exports
       });
     } else {
-      item.children?.forEach((child) => {
-        const path = pathParser2.resolve(item.data.path, "index.ts");
+      currentTree.children?.forEach((child) => {
+        const path = pathParser2.resolve(currentTree.data.path, "index.ts");
         const importPath = child.data.type === "directory" ? `./${child.data.name}` : `./${child.data.name.replace(/\.[^.]*$/, "")}`;
         files2.push({
           path,
@@ -525,7 +534,7 @@ function writeIndexes(root, options) {
         });
       });
     }
-    item.children.forEach((childItem) => {
+    currentTree.children.forEach((childItem) => {
       fileReducer(files2, childItem);
     });
     return files2;
@@ -535,9 +544,6 @@ function writeIndexes(root, options) {
 }
 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];
@@ -562,19 +568,19 @@ function getFileSource(file) {
   const imports = [];
   const exports = [];
   file.imports?.forEach((curr) => {
-    const exists = imports.find((imp) => imp.path === curr.path);
-    if (!exists) {
+    const existingImport = imports.find((imp) => imp.path === curr.path);
+    if (!existingImport) {
       imports.push({
         ...curr,
         name: Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name
       });
     }
-    if (exists && !Array.isArray(exists.name) && exists.name !== curr.name) {
+    if (existingImport && !Array.isArray(existingImport.name) && existingImport.name !== curr.name) {
       imports.push(curr);
     }
-    if (exists && Array.isArray(exists.name)) {
+    if (existingImport && Array.isArray(existingImport.name)) {
       if (Array.isArray(curr.name)) {
-        exists.name = [.../* @__PURE__ */ new Set([...exists.name, ...curr.name])];
+        existingImport.name = [.../* @__PURE__ */ new Set([...existingImport.name, ...curr.name])];
       }
     }
   });
@@ -600,7 +606,7 @@ function getFileSource(file) {
   }, []);
   const importSource = print(importNodes);
   const exportNodes = exports.reduce((prev, curr) => {
-    return [...prev, createExportDeclaration({ name: curr.name, path: curr.path, asAlias: curr.asAlias })];
+    return [...prev, createExportDeclaration({ name: curr.name, path: curr.path, isTypeOnly: curr.isTypeOnly, asAlias: curr.asAlias })];
   }, []);
   const exportSource = print(exportNodes);
   if (importSource) {
@@ -638,10 +644,12 @@ var definePlugin = createPlugin((options) => {
     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)
+        if (a.name.length < b.name.length) {
           return 1;
-        if (a.name.length > b.name.length)
+        }
+        if (a.name.length > b.name.length) {
           return -1;
+        }
         return 0;
       });
       const pluginName = plugins?.[0].name;
@@ -813,8 +821,9 @@ var PluginManager = class {
   }) {
     let promise = Promise.resolve(null);
     for (const plugin of this.getSortedPlugins(hookName)) {
-      if (skipped && skipped.has(plugin))
+      if (skipped && skipped.has(plugin)) {
         continue;
+      }
       promise = promise.then(async (parseResult) => {
         if (parseResult?.result != null) {
           return parseResult;
@@ -844,8 +853,9 @@ var PluginManager = class {
   }) {
     let parseResult = null;
     for (const plugin of this.getSortedPlugins(hookName)) {
-      if (skipped && skipped.has(plugin))
+      if (skipped && skipped.has(plugin)) {
         continue;
+      }
       parseResult = {
         result: this.executeSync({
           strategy: "hookFirst",
@@ -1071,7 +1081,7 @@ async function build(options) {
       await read(config.input.path);
     }
   } catch (e) {
-    throw new Error("Cannot read file defined in `input.path` or set with --input in the CLI of your Kubb config", { cause: e });
+    throw new Error("Cannot read file/URL defined in `input.path` or set with --input in the CLI of your Kubb config", { cause: e });
   }
   if (config.output.clean) {
     await clean(config.output.path);
@@ -1154,4 +1164,4 @@ var SchemaGenerator = class extends Generator {
 // src/index.ts
 var src_default = build;
 
-export { FileManager, Generator, ParallelPluginError, PluginError, PluginManager, Queue, SchemaGenerator, TreeNode, ValidationPluginError, build, clean, combineFiles, createJSDocBlockText, createPlugin, createPluginCache, src_default as default, defineConfig, getEncodedText, getFileSource, getPathMode, getRelativePath, getStackTrace, getUniqueName, hooks, isPromise, isURL, name, nameSorter, objectToParameters, read, renderTemplate, timeout, transformReservedWord, validatePlugins, write, writeIndexes };
+export { FileManager, Generator, ParallelPluginError, PluginError, PluginManager, Queue, SchemaGenerator, TreeNode, ValidationPluginError, build, clean, combineFiles, createJSDocBlockText, createPlugin, createPluginCache, src_default as default, defineConfig, getEncodedText, getFileSource, getPathMode, getRelativePath, getStackTrace, getUniqueName, hooks, isPromise, isURL, name, nameSorter, objectToParameters, read, renderTemplate, timeout, transformReservedWord, uniqueId, validatePlugins, write, writeIndexes };

package/package.json

@@ -1,7 +1,13 @@
 {
   "name": "@kubb/core",
-  "version": "1.1.7",
+  "version": "1.1.9",
   "description": "Generator core",
+  "keywords": [
+    "typescript",
+    "plugins",
+    "kubb",
+    "codegen"
+  ],
   "repository": {
     "type": "git",
     "url": "git://github.com/kubb-project/kubb.git",
@@ -9,17 +15,8 @@
   },
   "license": "MIT",
   "author": "Stijn Van Hulle <stijn@stijnvanhulle.be",
-  "keywords": [
-    "typescript",
-    "plugins",
-    "kubb",
-    "codegen"
-  ],
   "sideEffects": false,
   "type": "module",
-  "main": "dist/index.js",
-  "module": "dist/index.js",
-  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -29,6 +26,9 @@
     },
     "./package.json": "./package.json"
   },
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "./dist/index.d.ts",
   "typesVersions": {
     "*": {}
   },
@@ -42,33 +42,39 @@
   "dependencies": {
     "change-case": "^4.1.2",
     "directory-tree": "^3.5.1",
+    "graceful-fs": "^4.2.11",
+    "fs-extra": "^11.1.1",
     "rimraf": "^5.0.1",
-    "@kubb/ts-codegen": "1.1.7"
+    "@kubb/ts-codegen": "1.1.9"
   },
   "devDependencies": {
+    "@types/fs-extra": "^11.0.1",
     "eslint": "^8.42.0",
-    "tsup": "^6.7.0",
     "ora": "^6.3.1",
+    "tsup": "^6.7.0",
     "typescript": "^5.1.3",
-    "@kubb/tsup-config": "0.1.0",
-    "@kubb/eslint-config": "0.1.0"
+    "@kubb/eslint-config": "1.1.8",
+    "@kubb/ts-config": "0.1.0",
+    "@kubb/tsup-config": "1.1.8"
+  },
+  "packageManager": "pnpm@8.3.0",
+  "engines": {
+    "node": ">=18",
+    "pnpm": ">=8.3.0"
   },
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "engines": {
-    "node": ">=18",
-    "pnpm": ">=8"
-  },
   "scripts": {
     "build": "tsup",
-    "start": "tsup --watch",
-    "release": "pnpm publish --no-git-check",
-    "lint": "eslint \"**/*.{ts,tsx}\"",
+    "clean": "rimraf ./dist",
+    "lint": "ESLINT_USE_FLAT_CONFIG=true eslint \"**/*.{ts,tsx}\"",
     "lint-fix": "eslint \"**/*.{ts,tsx}\" --quiet --fix",
+    "release": "pnpm publish --no-git-check",
+    "start": "tsup --watch",
     "test": "vitest --passWithNoTests",
-    "upgrade": "pnpm update",
-    "typecheck": "tsc -p ./tsconfig.json --noEmit --emitDeclarationOnly false"
+    "typecheck": "tsc -p ./tsconfig.json --noEmit --emitDeclarationOnly false",
+    "upgrade": "pnpm update"
   }
 }

package/src/build.ts

@@ -1,4 +1,3 @@
-/* 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'
@@ -23,6 +22,7 @@ async function transformReducer(
   this: PluginContext,
   _previousCode: string,
   result: TransformResult | Promise<TransformResult>,
+
   _plugin: KubbPlugin
 ): Promise<string | null> {
   return result
@@ -36,7 +36,7 @@ export async function build(options: BuildOptions): Promise<BuildOutput> {
       await read(config.input.path)
     }
   } catch (e: any) {
-    throw new Error('Cannot read file defined in `input.path` or set with --input in the CLI of your Kubb config', { cause: e })
+    throw new Error('Cannot read file/URL defined in `input.path` or set with --input in the CLI of your Kubb config', { cause: e })
   }
 
   if (config.output.clean) {

package/src/index.ts

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-empty-interface */
 import { build } from './build.ts'
 
 export * from './config.ts'

package/src/managers/fileManager/utils.ts

@@ -9,21 +9,23 @@ 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) {
-  const tree = TreeNode.build<{ type: PathMode; path: Path; name: string }>(root, { extensions: /\.ts/, ...options })
+type TreeNodeData = { type: PathMode; path: Path; name: string }
+
+export function writeIndexes(root: string, options: TreeNodeOptions = {}): File[] | null {
+  const tree = TreeNode.build<TreeNodeData>(root, { extensions: /\.ts/, ...options })
 
   if (!tree) {
-    return undefined
+    return null
   }
 
-  const fileReducer = (files: File[], item: typeof tree) => {
-    if (!item.children) {
+  const fileReducer = (files: File[], currentTree: typeof tree) => {
+    if (!currentTree.children) {
       return []
     }
 
-    if (item.children?.length > 1) {
-      const path = pathParser.resolve(item.data.path, 'index.ts')
-      const exports = item.children
+    if (currentTree.children?.length > 1) {
+      const path = pathParser.resolve(currentTree.data.path, 'index.ts')
+      const exports = currentTree.children
         .map((file) => {
           if (!file) {
             return undefined
@@ -47,8 +49,8 @@ export function writeIndexes(root: string, options: TreeNodeOptions) {
         exports,
       })
     } else {
-      item.children?.forEach((child) => {
-        const path = pathParser.resolve(item.data.path, 'index.ts')
+      currentTree.children?.forEach((child) => {
+        const path = pathParser.resolve(currentTree.data.path, 'index.ts')
         const importPath = child.data.type === 'directory' ? `./${child.data.name}` : `./${child.data.name.replace(/\.[^.]*$/, '')}`
 
         files.push({
@@ -60,7 +62,7 @@ export function writeIndexes(root: string, options: TreeNodeOptions) {
       })
     }
 
-    item.children.forEach((childItem) => {
+    currentTree.children.forEach((childItem) => {
       fileReducer(files, childItem)
     })
 
@@ -72,11 +74,8 @@ export function writeIndexes(root: string, options: TreeNodeOptions) {
   return files
 }
 
-export function combineFiles(files: Array<File | null>) {
-  return files.filter(Boolean).reduce((acc, curr: File | null) => {
-    if (!curr) {
-      return acc
-    }
+export function combineFiles(files: Array<File | null>): File[] {
+  return (files.filter(Boolean) as File[]).reduce((acc, curr: File) => {
     const prevIndex = acc.findIndex((item) => item.path === curr.path)
 
     if (prevIndex !== -1) {
@@ -95,7 +94,7 @@ export function combineFiles(files: Array<File | null>) {
   }, [] as File[])
 }
 
-export function getFileSource(file: File) {
+export function getFileSource(file: File): string {
   let { source } = file
 
   // TODO make generic check
@@ -106,21 +105,22 @@ export function getFileSource(file: File) {
   const exports: File['exports'] = []
 
   file.imports?.forEach((curr) => {
-    const exists = imports.find((imp) => imp.path === curr.path)
-    if (!exists) {
+    const existingImport = imports.find((imp) => imp.path === curr.path)
+
+    if (!existingImport) {
       imports.push({
         ...curr,
         name: Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name,
       })
     }
 
-    if (exists && !Array.isArray(exists.name) && exists.name !== curr.name) {
+    if (existingImport && !Array.isArray(existingImport.name) && existingImport.name !== curr.name) {
       imports.push(curr)
     }
 
-    if (exists && Array.isArray(exists.name)) {
+    if (existingImport && Array.isArray(existingImport.name)) {
       if (Array.isArray(curr.name)) {
-        exists.name = [...new Set([...exists.name, ...curr.name])]
+        existingImport.name = [...new Set([...existingImport.name, ...curr.name])]
       }
     }
   })
@@ -151,7 +151,7 @@ export function getFileSource(file: File) {
   const importSource = print(importNodes)
 
   const exportNodes = exports.reduce((prev, curr) => {
-    return [...prev, createExportDeclaration({ name: curr.name, path: curr.path, asAlias: curr.asAlias })]
+    return [...prev, createExportDeclaration({ name: curr.name, path: curr.path, isTypeOnly: curr.isTypeOnly, asAlias: curr.asAlias })]
   }, [] as ts.ExportDeclaration[])
   const exportSource = print(exportNodes)
 

package/src/managers/pluginManager/PluginManager.ts

@@ -1,6 +1,4 @@
 /* eslint-disable @typescript-eslint/ban-types */
-/* eslint-disable no-await-in-loop */
-/* eslint-disable no-restricted-syntax */
 
 import { definePlugin } from '../../plugin.ts'
 import { isPromise } from '../../utils/isPromise.ts'
@@ -160,10 +158,12 @@ export class PluginManager {
     parameters: Parameters<PluginLifecycle[H]>
     skipped?: ReadonlySet<KubbPlugin> | null
   }): Promise<SafeParseResult<H>> {
-    let promise: Promise<SafeParseResult<H>> = Promise.resolve(null as any)
+    let promise: Promise<SafeParseResult<H>> = Promise.resolve(null as unknown as SafeParseResult<H>)
 
     for (const plugin of this.getSortedPlugins(hookName)) {
-      if (skipped && skipped.has(plugin)) continue
+      if (skipped && skipped.has(plugin)) {
+        continue
+      }
       promise = promise.then(async (parseResult) => {
         if (parseResult?.result != null) {
           return parseResult
@@ -201,7 +201,9 @@ export class PluginManager {
     let parseResult: SafeParseResult<H> = null as unknown as SafeParseResult<H>
 
     for (const plugin of this.getSortedPlugins(hookName)) {
-      if (skipped && skipped.has(plugin)) continue
+      if (skipped && skipped.has(plugin)) {
+        continue
+      }
 
       parseResult = {
         result: this.executeSync<H>({
@@ -371,10 +373,10 @@ export class PluginManager {
         }
 
         if (typeof hook === 'function') {
-          const hookResult = (hook as Function).apply(this.core.api, parameters)
+          const hookResult = (hook as Function).apply(this.core.api, parameters) as TResult
 
           if (isPromise(hookResult)) {
-            return Promise.resolve(hookResult).then((result) => {
+            return Promise.resolve(hookResult).then((result: TResult) => {
               this.addExecuter({
                 strategy,
                 hookName,
@@ -433,9 +435,8 @@ export class PluginManager {
         plugin,
       }
 
-      // eslint-disable-next-line @typescript-eslint/ban-types
       if (typeof hook === 'function') {
-        const fn = (hook as Function).apply(this.core.api, parameters)
+        const fn = (hook as Function).apply(this.core.api, parameters) as ReturnType<ParseResult<H>>
 
         this.addExecuter({
           strategy,

package/src/plugin.ts

@@ -56,8 +56,12 @@ export const definePlugin = createPlugin<CorePluginOptions>((options) => {
       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
+          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

package/src/utils/Queue.ts

@@ -1,5 +1,3 @@
-/* eslint-disable no-cond-assign */
-
 export type QueueTask<T = unknown> = {
   (...args: unknown[]): Promise<T>
 }
@@ -29,8 +27,10 @@ export class Queue {
     })
   }
 
-  private async work(): Promise<void> {
-    if (this.workerCount >= this.maxParallel) return
+  private work(): void {
+    if (this.workerCount >= this.maxParallel) {
+      return
+    }
     this.workerCount++
 
     let entry: QueueItem | undefined