@kubb/core 1.12.0 → 1.13.0-canary.20231018T144840

package/dist/index.cjs

@@ -4,7 +4,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var pc3 = require('picocolors');
 var crypto = require('crypto');
-var pathParser2 = require('path');
+var path2 = require('path');
 var fs = require('fs-extra');
 var jsRuntime = require('js-runtime');
 var perf_hooks = require('perf_hooks');
@@ -18,20 +18,31 @@ var naturalOrderby = require('natural-orderby');
 var parser = require('@kubb/parser');
 var isEqual = require('lodash.isequal');
 var events = require('events');
+var process2 = require('process');
+var fs3 = require('fs');
+var semver = require('semver');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var pc3__default = /*#__PURE__*/_interopDefault(pc3);
 var crypto__default = /*#__PURE__*/_interopDefault(crypto);
-var pathParser2__default = /*#__PURE__*/_interopDefault(pathParser2);
+var path2__default = /*#__PURE__*/_interopDefault(path2);
 var fs__default = /*#__PURE__*/_interopDefault(fs);
 var dirTree__default = /*#__PURE__*/_interopDefault(dirTree);
 var mod__default = /*#__PURE__*/_interopDefault(mod);
 var os__default = /*#__PURE__*/_interopDefault(os);
 var seedrandom__default = /*#__PURE__*/_interopDefault(seedrandom);
 var isEqual__default = /*#__PURE__*/_interopDefault(isEqual);
+var process2__default = /*#__PURE__*/_interopDefault(process2);
+var fs3__default = /*#__PURE__*/_interopDefault(fs3);
 
-// src/build.ts
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 
 // src/utils/isPromise.ts
 function isPromise(result) {
@@ -43,37 +54,37 @@ function isPromiseFulfilledResult(result) {
 function isPromiseRejectedResult(result) {
   return result.status === "rejected";
 }
-async function saveCreateDirectory(path) {
-  const passedPath = pathParser2__default.default.dirname(pathParser2__default.default.resolve(path));
+async function saveCreateDirectory(path3) {
+  const passedPath = path2__default.default.dirname(path2__default.default.resolve(path3));
   await fs__default.default.mkdir(passedPath, { recursive: true });
 }
 var writer = jsRuntime.switcher(
   {
-    node: async (path, data) => {
+    node: async (path3, data) => {
       try {
-        await fs__default.default.stat(path);
-        const oldContent = await fs__default.default.readFile(path, { encoding: "utf-8" });
+        await fs__default.default.stat(path3);
+        const oldContent = await fs__default.default.readFile(path3, { encoding: "utf-8" });
         if (oldContent?.toString() === data) {
           return;
         }
       } catch (_err) {
       }
-      await saveCreateDirectory(path);
-      return fs__default.default.writeFile(pathParser2__default.default.resolve(path), data, { encoding: "utf-8" });
+      await saveCreateDirectory(path3);
+      return fs__default.default.writeFile(path2__default.default.resolve(path3), data, { encoding: "utf-8" });
     },
-    bun: async (path, data) => {
+    bun: async (path3, data) => {
       try {
-        await saveCreateDirectory(path);
-        await Bun.write(pathParser2__default.default.resolve(path), data);
+        await saveCreateDirectory(path3);
+        await Bun.write(path2__default.default.resolve(path3), data);
       } catch (e) {
-        console.log(e, pathParser2__default.default.resolve(path));
+        console.log(e, path2__default.default.resolve(path3));
       }
     }
   },
   "node"
 );
-async function write(data, path) {
-  return writer(path, data);
+async function write(data, path3) {
+  return writer(path3, data);
 }
 
 // src/utils/cache.ts
@@ -103,37 +114,37 @@ function createPluginCache(Store = /* @__PURE__ */ Object.create(null)) {
     }
   };
 }
-function slash(path, platform = "linux") {
-  const isWindowsPath = /^\\\\\?\\/.test(path);
+function slash(path3, platform = "linux") {
+  const isWindowsPath = /^\\\\\?\\/.test(path3);
   if (["linux", "mac"].includes(platform) && !isWindowsPath) {
-    return path.replaceAll(/\\/g, "/").replace("../", "").trimEnd();
+    return path3.replaceAll(/\\/g, "/").replace("../", "").trimEnd();
   }
-  return path.replaceAll(/\\/g, "/").replace("../", "").trimEnd();
+  return path3.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 = pathParser2__default.default.relative(rootDir, filePath);
-  const path = slash(relativePath, platform);
-  if (path.startsWith("../")) {
-    return path.replace(pathParser2__default.default.basename(path), pathParser2__default.default.basename(path, pathParser2__default.default.extname(filePath)));
+  const relativePath = path2__default.default.relative(rootDir, filePath);
+  const path3 = slash(relativePath, platform);
+  if (path3.startsWith("../")) {
+    return path3.replace(path2__default.default.basename(path3), path2__default.default.basename(path3, path2__default.default.extname(filePath)));
   }
-  return `./${path.replace(pathParser2__default.default.basename(path), pathParser2__default.default.basename(path, pathParser2__default.default.extname(filePath)))}`;
+  return `./${path3.replace(path2__default.default.basename(path3), path2__default.default.basename(path3, path2__default.default.extname(filePath)))}`;
 }
-function getPathMode(path) {
-  if (!path) {
+function getPathMode(path3) {
+  if (!path3) {
     return "directory";
   }
-  return pathParser2__default.default.extname(path) ? "file" : "directory";
+  return path2__default.default.extname(path3) ? "file" : "directory";
 }
 var reader = jsRuntime.switcher(
   {
-    node: async (path) => {
-      return fs__default.default.readFile(path, { encoding: "utf8" });
+    node: async (path3) => {
+      return fs__default.default.readFile(path3, { encoding: "utf8" });
     },
-    bun: async (path) => {
-      const file = Bun.file(path);
+    bun: async (path3) => {
+      const file = Bun.file(path3);
       return file.text();
     }
   },
@@ -141,8 +152,8 @@ var reader = jsRuntime.switcher(
 );
 var syncReader = jsRuntime.switcher(
   {
-    node: (path) => {
-      return fs__default.default.readFileSync(path, { encoding: "utf8" });
+    node: (path3) => {
+      return fs__default.default.readFileSync(path3, { encoding: "utf8" });
     },
     bun: () => {
       throw new Error("Bun cannot read sync");
@@ -150,11 +161,11 @@ var syncReader = jsRuntime.switcher(
   },
   "node"
 );
-async function read(path) {
-  return reader(path);
+async function read(path3) {
+  return reader(path3);
 }
-function readSync(path) {
-  return syncReader(path);
+function readSync(path3) {
+  return syncReader(path3);
 }
 
 // src/utils/nameSorter.ts
@@ -403,8 +414,8 @@ function renderTemplate(template, data = void 0) {
     }).trim();
   }, template) || "";
 }
-async function clean(path) {
-  return fs.remove(path);
+async function clean(path3) {
+  return fs.remove(path3);
 }
 var TreeNode = class _TreeNode {
   data;
@@ -470,10 +481,10 @@ var TreeNode = class _TreeNode {
     }
     return this;
   }
-  static build(path, options = {}) {
+  static build(path3, options = {}) {
     try {
       const exclude = Array.isArray(options.exclude) ? options.exclude : [options.exclude].filter(Boolean);
-      const filteredTree = dirTree__default.default(path, { extensions: options.extensions, exclude: [/node_modules/, ...exclude] });
+      const filteredTree = dirTree__default.default(path3, { extensions: options.extensions, exclude: [/node_modules/, ...exclude] });
       if (!filteredTree) {
         return null;
       }
@@ -503,17 +514,17 @@ function normalizeDirectory(directory) {
   }
   return directory;
 }
-function getLocation(path, cwd) {
-  let location = path;
+function getLocation(path3, cwd) {
+  let location = path3;
   if (cwd) {
     const require2 = mod__default.default.createRequire(normalizeDirectory(cwd));
-    location = require2.resolve(path);
+    location = require2.resolve(path3);
   }
   return location;
 }
-async function importModule(path, cwd) {
+async function importModule(path3, cwd) {
   try {
-    let location = getLocation(path, cwd);
+    let location = getLocation(path3, cwd);
     if (os__default.default.platform() == "win32") {
       location = url.pathToFileURL(location).href;
     }
@@ -632,8 +643,8 @@ function randomPicoColour(text, colors = defaultColours) {
 }
 var URLPath = class _URLPath {
   path;
-  constructor(path) {
-    this.path = path;
+  constructor(path3) {
+    this.path = path3;
   }
   /**
    * Convert Swagger path to URLPath(syntax of Express)
@@ -678,25 +689,25 @@ var URLPath = class _URLPath {
    * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
    * @example /account/userID => `/account/${userId}`
    */
-  static toTemplateString(path, replacer) {
+  static toTemplateString(path3, replacer) {
     const regex = /{(\w|-)*}/g;
-    const found = path.match(regex);
-    let newPath = path.replaceAll("{", "${");
+    const found = path3.match(regex);
+    let newPath = path3.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);
-      }, path);
+      }, path3);
     }
     return `\`${newPath}\``;
   }
   getParams(replacer) {
     return _URLPath.getParams(this.path, replacer);
   }
-  static getParams(path, replacer) {
+  static getParams(path3, replacer) {
     const regex = /{(\w|-)*}/g;
-    const found = path.match(regex);
+    const found = path3.match(regex);
     if (!found) {
       return void 0;
     }
@@ -705,7 +716,7 @@ var URLPath = class _URLPath {
       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;
-    }, path);
+    }, path3);
     return params;
   }
   /**
@@ -715,13 +726,13 @@ var URLPath = class _URLPath {
   toURLPath() {
     return _URLPath.toURLPath(this.path);
   }
-  static toURLPath(path) {
-    return path.replaceAll("{", ":").replaceAll("}", "");
+  static toURLPath(path3) {
+    return path3.replaceAll("{", ":").replaceAll("}", "");
   }
-  static toObject(path, { type = "path", replacer, stringify } = {}) {
+  static toObject(path3, { type = "path", replacer, stringify } = {}) {
     const object = {
-      url: type === "path" ? _URLPath.toURLPath(path) : _URLPath.toTemplateString(path, replacer),
-      params: _URLPath.getParams(path)
+      url: type === "path" ? _URLPath.toURLPath(path3) : _URLPath.toTemplateString(path3, replacer),
+      params: _URLPath.getParams(path3)
     };
     if (stringify) {
       if (type !== "template") {
@@ -731,9 +742,9 @@ var URLPath = class _URLPath {
     }
     return object;
   }
-  static isURL(path) {
+  static isURL(path3) {
     try {
-      const url = new URL(path);
+      const url = new URL(path3);
       if (url?.href) {
         return true;
       }
@@ -792,29 +803,29 @@ function getIndexes(root, options = {}) {
       return [];
     }
     if (currentTree.children?.length > 1) {
-      const path = pathParser2__default.default.resolve(currentTree.data.path, "index.ts");
+      const path3 = path2__default.default.resolve(currentTree.data.path, "index.ts");
       const exports = currentTree.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")) {
+        if (importPath.includes("index") && path3.includes("index")) {
           return void 0;
         }
         return { path: importPath };
       }).filter(Boolean);
       files2.push({
-        path,
+        path: path3,
         baseName: "index.ts",
         source: "",
         exports
       });
     } else {
       currentTree.children?.forEach((child) => {
-        const path = pathParser2__default.default.resolve(currentTree.data.path, "index.ts");
+        const path3 = path2__default.default.resolve(currentTree.data.path, "index.ts");
         const importPath = child.data.type === "directory" ? `./${child.data.name}` : `./${child.data.name.replace(/\.[^.]*$/, "")}`;
         files2.push({
-          path,
+          path: path3,
           baseName: "index.ts",
           source: "",
           exports: [{ path: importPath }]
@@ -1032,9 +1043,9 @@ ${file.source}` : "",
     }
     return this.add(file);
   }
-  append(path, file) {
-    const previousFiles = this.cache.get(path) || [];
-    this.cache.set(path, [...previousFiles, file]);
+  append(path3, file) {
+    const previousFiles = this.cache.get(path3) || [];
+    this.cache.set(path3, [...previousFiles, file]);
   }
   getCacheByUUID(UUID) {
     let cache;
@@ -1043,15 +1054,15 @@ ${file.source}` : "",
     });
     return cache;
   }
-  get(path) {
-    return this.cache.get(path);
+  get(path3) {
+    return this.cache.get(path3);
   }
-  remove(path) {
-    const cacheItem = this.get(path);
+  remove(path3) {
+    const cacheItem = this.get(path3);
     if (!cacheItem) {
       return;
     }
-    this.cache.delete(path);
+    this.cache.delete(path3);
   }
   async write(...params) {
     if (this.queue) {
@@ -1117,8 +1128,8 @@ var definePlugin = createPlugin((options) => {
       };
     },
     resolvePath(baseName) {
-      const root = pathParser2__default.default.resolve(this.config.root, this.config.output.path);
-      return pathParser2__default.default.resolve(root, baseName);
+      const root = path2__default.default.resolve(this.config.root, this.config.output.path);
+      return path2__default.default.resolve(root, baseName);
     },
     resolveName(name) {
       return name;
@@ -1576,26 +1587,28 @@ async function transformReducer(_previousCode, result, _plugin) {
 async function build(options) {
   const { config, logLevel, logger = createLogger() } = options;
   try {
-    if (!URLPath.isURL(config.input.path)) {
+    if ("path" in config.input && !URLPath.isURL(config.input.path)) {
       await read(config.input.path);
     }
   } catch (e) {
-    throw new Error(
-      "Cannot read file/URL defined in `input.path` or set with `kubb generate PATH` in the CLI of your Kubb config " + pc3__default.default.dim(config.input.path),
-      {
-        cause: e
-      }
-    );
+    if ("path" in config.input) {
+      throw new Error(
+        "Cannot read file/URL defined in `input.path` or set with `kubb generate PATH` in the CLI of your Kubb config " + pc3__default.default.dim(config.input.path),
+        {
+          cause: e
+        }
+      );
+    }
   }
   if (config.output.clean) {
     await clean(config.output.path);
   }
   const queueTask = async (file) => {
-    const { path } = file;
+    const { path: path3 } = file;
     let code = createFileSource(file);
     const { result: loadedResult } = await pluginManager.hookFirst({
       hookName: "load",
-      parameters: [path]
+      parameters: [path3]
     });
     if (loadedResult && isPromise(loadedResult)) {
       code = await loadedResult;
@@ -1606,13 +1619,13 @@ async function build(options) {
     if (code) {
       const transformedCode = await pluginManager.hookReduceArg0({
         hookName: "transform",
-        parameters: [code, path],
+        parameters: [code, path3],
         reduce: transformReducer
       });
       if (config.output.write || config.output.write === void 0) {
         await pluginManager.hookParallel({
           hookName: "writeFile",
-          parameters: [transformedCode, path]
+          parameters: [transformedCode, path3]
         });
       }
     }
@@ -1655,6 +1668,334 @@ function defineConfig(options) {
   return options;
 }
 
+// ../../node_modules/.pnpm/yocto-queue@1.0.0/node_modules/yocto-queue/index.js
+var Node = class {
+  value;
+  next;
+  constructor(value) {
+    this.value = value;
+  }
+};
+var Queue2 = class {
+  #head;
+  #tail;
+  #size;
+  constructor() {
+    this.clear();
+  }
+  enqueue(value) {
+    const node = new Node(value);
+    if (this.#head) {
+      this.#tail.next = node;
+      this.#tail = node;
+    } else {
+      this.#head = node;
+      this.#tail = node;
+    }
+    this.#size++;
+  }
+  dequeue() {
+    const current = this.#head;
+    if (!current) {
+      return;
+    }
+    this.#head = this.#head.next;
+    this.#size--;
+    return current.value;
+  }
+  clear() {
+    this.#head = void 0;
+    this.#tail = void 0;
+    this.#size = 0;
+  }
+  get size() {
+    return this.#size;
+  }
+  *[Symbol.iterator]() {
+    let current = this.#head;
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+};
+
+// ../../node_modules/.pnpm/p-limit@4.0.0/node_modules/p-limit/index.js
+function pLimit(concurrency) {
+  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
+    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+  }
+  const queue = new Queue2();
+  let activeCount = 0;
+  const next = () => {
+    activeCount--;
+    if (queue.size > 0) {
+      queue.dequeue()();
+    }
+  };
+  const run = async (fn, resolve, args) => {
+    activeCount++;
+    const result = (async () => fn(...args))();
+    resolve(result);
+    try {
+      await result;
+    } catch {
+    }
+    next();
+  };
+  const enqueue = (fn, resolve, args) => {
+    queue.enqueue(run.bind(void 0, fn, resolve, args));
+    (async () => {
+      await Promise.resolve();
+      if (activeCount < concurrency && queue.size > 0) {
+        queue.dequeue()();
+      }
+    })();
+  };
+  const generator = (fn, ...args) => new Promise((resolve) => {
+    enqueue(fn, resolve, args);
+  });
+  Object.defineProperties(generator, {
+    activeCount: {
+      get: () => activeCount
+    },
+    pendingCount: {
+      get: () => queue.size
+    },
+    clearQueue: {
+      value: () => {
+        queue.clear();
+      }
+    }
+  });
+  return generator;
+}
+
+// ../../node_modules/.pnpm/p-locate@6.0.0/node_modules/p-locate/index.js
+var EndError = class extends Error {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+};
+var testElement = async (element, tester) => tester(await element);
+var finder = async (element) => {
+  const values = await Promise.all(element);
+  if (values[1] === true) {
+    throw new EndError(values[0]);
+  }
+  return false;
+};
+async function pLocate(iterable, tester, {
+  concurrency = Number.POSITIVE_INFINITY,
+  preserveOrder = true
+} = {}) {
+  const limit = pLimit(concurrency);
+  const items = [...iterable].map((element) => [element, limit(testElement, element, tester)]);
+  const checkLimit = pLimit(preserveOrder ? 1 : Number.POSITIVE_INFINITY);
+  try {
+    await Promise.all(items.map((element) => checkLimit(finder, element)));
+  } catch (error) {
+    if (error instanceof EndError) {
+      return error.value;
+    }
+    throw error;
+  }
+}
+
+// ../../node_modules/.pnpm/locate-path@7.2.0/node_modules/locate-path/index.js
+var typeMappings = {
+  directory: "isDirectory",
+  file: "isFile"
+};
+function checkType(type) {
+  if (Object.hasOwnProperty.call(typeMappings, type)) {
+    return;
+  }
+  throw new Error(`Invalid type specified: ${type}`);
+}
+var matchType = (type, stat) => stat[typeMappings[type]]();
+var toPath = (urlOrPath) => urlOrPath instanceof URL ? url.fileURLToPath(urlOrPath) : urlOrPath;
+async function locatePath(paths, {
+  cwd = process2__default.default.cwd(),
+  type = "file",
+  allowSymlinks = true,
+  concurrency,
+  preserveOrder
+} = {}) {
+  checkType(type);
+  cwd = toPath(cwd);
+  const statFunction = allowSymlinks ? fs3.promises.stat : fs3.promises.lstat;
+  return pLocate(paths, async (path_) => {
+    try {
+      const stat = await statFunction(path2__default.default.resolve(cwd, path_));
+      return matchType(type, stat);
+    } catch {
+      return false;
+    }
+  }, { concurrency, preserveOrder });
+}
+function locatePathSync(paths, {
+  cwd = process2__default.default.cwd(),
+  type = "file",
+  allowSymlinks = true
+} = {}) {
+  checkType(type);
+  cwd = toPath(cwd);
+  const statFunction = allowSymlinks ? fs3__default.default.statSync : fs3__default.default.lstatSync;
+  for (const path_ of paths) {
+    try {
+      const stat = statFunction(path2__default.default.resolve(cwd, path_), {
+        throwIfNoEntry: false
+      });
+      if (!stat) {
+        continue;
+      }
+      if (matchType(type, stat)) {
+        return path_;
+      }
+    } catch {
+    }
+  }
+}
+
+// ../../node_modules/.pnpm/find-up@6.3.0/node_modules/find-up/index.js
+var toPath2 = (urlOrPath) => urlOrPath instanceof URL ? url.fileURLToPath(urlOrPath) : urlOrPath;
+var findUpStop = Symbol("findUpStop");
+async function findUpMultiple(name, options = {}) {
+  let directory = path2__default.default.resolve(toPath2(options.cwd) || "");
+  const { root } = path2__default.default.parse(directory);
+  const stopAt = path2__default.default.resolve(directory, options.stopAt || root);
+  const limit = options.limit || Number.POSITIVE_INFINITY;
+  const paths = [name].flat();
+  const runMatcher = async (locateOptions) => {
+    if (typeof name !== "function") {
+      return locatePath(paths, locateOptions);
+    }
+    const foundPath = await name(locateOptions.cwd);
+    if (typeof foundPath === "string") {
+      return locatePath([foundPath], locateOptions);
+    }
+    return foundPath;
+  };
+  const matches = [];
+  while (true) {
+    const foundPath = await runMatcher({ ...options, cwd: directory });
+    if (foundPath === findUpStop) {
+      break;
+    }
+    if (foundPath) {
+      matches.push(path2__default.default.resolve(directory, foundPath));
+    }
+    if (directory === stopAt || matches.length >= limit) {
+      break;
+    }
+    directory = path2__default.default.dirname(directory);
+  }
+  return matches;
+}
+function findUpMultipleSync(name, options = {}) {
+  let directory = path2__default.default.resolve(toPath2(options.cwd) || "");
+  const { root } = path2__default.default.parse(directory);
+  const stopAt = options.stopAt || root;
+  const limit = options.limit || Number.POSITIVE_INFINITY;
+  const paths = [name].flat();
+  const runMatcher = (locateOptions) => {
+    if (typeof name !== "function") {
+      return locatePathSync(paths, locateOptions);
+    }
+    const foundPath = name(locateOptions.cwd);
+    if (typeof foundPath === "string") {
+      return locatePathSync([foundPath], locateOptions);
+    }
+    return foundPath;
+  };
+  const matches = [];
+  while (true) {
+    const foundPath = runMatcher({ ...options, cwd: directory });
+    if (foundPath === findUpStop) {
+      break;
+    }
+    if (foundPath) {
+      matches.push(path2__default.default.resolve(directory, foundPath));
+    }
+    if (directory === stopAt || matches.length >= limit) {
+      break;
+    }
+    directory = path2__default.default.dirname(directory);
+  }
+  return matches;
+}
+async function findUp(name, options = {}) {
+  const matches = await findUpMultiple(name, { ...options, limit: 1 });
+  return matches[0];
+}
+function findUpSync(name, options = {}) {
+  const matches = findUpMultipleSync(name, { ...options, limit: 1 });
+  return matches[0];
+}
+var PackageManager = class {
+  cwd;
+  constructor(workspace = process.cwd()) {
+    this.cwd = workspace;
+    return this;
+  }
+  async getPackageJSON() {
+    const pkgPath = await findUp(["package.json"], {
+      cwd: this.cwd
+    });
+    if (!pkgPath) {
+      return void 0;
+    }
+    return __require(pkgPath);
+  }
+  getPackageJSONSync() {
+    const pkgPath = findUpSync(["package.json"], {
+      cwd: this.cwd
+    });
+    if (!pkgPath) {
+      return void 0;
+    }
+    return __require(pkgPath);
+  }
+  async getVersion(dependency) {
+    const packageJSON = await this.getPackageJSON();
+    if (!packageJSON) {
+      return void 0;
+    }
+    return packageJSON["dependencies"]?.[dependency] || packageJSON["devDependencies"]?.[dependency];
+  }
+  getVersionSync(dependency) {
+    const packageJSON = this.getPackageJSONSync();
+    if (!packageJSON) {
+      return void 0;
+    }
+    return packageJSON["dependencies"]?.[dependency] || packageJSON["devDependencies"]?.[dependency];
+  }
+  async isValid(dependency, version) {
+    const packageVersion = await this.getVersion(dependency);
+    if (!packageVersion) {
+      return false;
+    }
+    const semVer = semver.coerce(packageVersion);
+    if (!semVer) {
+      throw new Error(`${packageVersion} is not valid`);
+    }
+    return semver.satisfies(semVer, version);
+  }
+  isValidSync(dependency, version) {
+    const packageVersion = this.getVersionSync(dependency);
+    if (!packageVersion) {
+      return false;
+    }
+    const semVer = semver.coerce(packageVersion);
+    if (!semVer) {
+      throw new Error(`${packageVersion} is not valid`);
+    }
+    return semver.satisfies(semVer, version);
+  }
+};
+
 // src/generators/Generator.ts
 var Generator = class {
   _options = {};
@@ -1687,6 +2028,7 @@ exports.FileManager = FileManager;
 exports.FunctionParams = FunctionParams;
 exports.Generator = Generator;
 exports.LogLevel = LogLevel;
+exports.PackageManager = PackageManager;
 exports.ParallelPluginError = ParallelPluginError;
 exports.PluginError = PluginError;
 exports.PluginManager = PluginManager;