package-management 0.0.1 → 0.0.3

package/dist/index.cjs

@@ -1,50 +1,42 @@
 'use strict';
 
-const installPkg = require('@antfu/install-pkg');
-require('node:fs');
+const ErrorStackParser = require('error-stack-parser');
+const path = require('pathe');
+const process = require('node:process');
+const path$1 = require('node:path');
+const node_fs = require('node:fs');
 const execa = require('execa');
-const localPkg = require('local-pkg');
 const asyncCacheFn = require('async-cache-fn');
 const findUp = require('find-up');
 const promises = require('node:fs/promises');
+const mlly = require('mlly');
+const globby = require('globby');
+const gitignoreParser = require('parse-gitignore');
+const WST = require('workspace-tools');
+const utils = require('pathe/utils');
+const os = require('node:os');
 
-async function resolveModule(m) {
-  const resolved = await m;
-  return resolved.default || resolved;
-}
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
-function importer(imports, options) {
-  const { install = true } = options ?? {};
-  return Promise.all(
-    imports.map(async (option) => {
-      if (install && "name" in option) {
-        await ensurePackage(option.name);
-      }
-      const importStatement = getImportStatement(option);
-      return resolveModule(importStatement);
-    })
-  );
-}
-function getImportStatement(option) {
-  if (typeof option === "function") {
-    return option();
-  }
-  if (typeof option === "object" && "import" in option && "name" in option) {
-    return option.import();
+function _interopNamespaceCompat(e) {
+  if (e && typeof e === 'object' && 'default' in e) return e;
+  const n = Object.create(null);
+  if (e) {
+    for (const k in e) {
+      n[k] = e[k];
+    }
   }
-  return option;
+  n.default = e;
+  return n;
 }
 
-async function importMap(importMap2, options) {
-  const keys = Object.keys(importMap2);
-  const imported = await importer(
-    keys.map((key) => importMap2[key]),
-    options
-  );
-  return Object.fromEntries(
-    keys.map((key, index) => [key, imported[index]])
-  );
-}
+const ErrorStackParser__default = /*#__PURE__*/_interopDefaultCompat(ErrorStackParser);
+const path__default$1 = /*#__PURE__*/_interopDefaultCompat(path);
+const process__default = /*#__PURE__*/_interopDefaultCompat(process);
+const path__default = /*#__PURE__*/_interopDefaultCompat(path$1);
+const gitignoreParser__default = /*#__PURE__*/_interopDefaultCompat(gitignoreParser);
+const WST__namespace = /*#__PURE__*/_interopNamespaceCompat(WST);
+const os__default = /*#__PURE__*/_interopDefaultCompat(os);
 
 const toArray = (data) => Array.isArray(data) ? data : [data];
 const entriesOf = (o) => Object.entries(o);
@@ -58,29 +50,520 @@ const select = (obj, selection, mode) => {
   });
   return fromEntries(filtered);
 };
+function normalizePath(path$1, option) {
+  if (typeof option === "function") {
+    return normalizePath(path$1);
+  }
+  if (option === false) {
+    return path$1;
+  }
+  return path.normalize(path$1);
+}
 const invariant = (predicate, message) => {
   if (!predicate) {
     throw new Error(message);
   }
 };
+function getArrayItemAtOffset(arr, index, offset = 0) {
+  if (!index || !arr)
+    return void 0;
+  return arr[index + offset];
+}
+function isMatching(a, b) {
+  if (!a || !b)
+    return false;
+  return a === b;
+}
 
-function isPackageDependency(packageName) {
-  return toArray(packageName).every((name) => localPkg.isPackageExists(name));
+function findCallerStackFrame(options) {
+  return findErrorStackFrame(options, (frame) => frame.isParentOfRootFunction);
+}
+function findErrorStackFrame(options, find) {
+  return getErrorStackFrames(options, find)[0];
+}
+function getErrorStackFrames(options, filter) {
+  const { error, rootFunctionName, startFrom = "top" } = options;
+  const frames = startFrom === "bottom" ? ErrorStackParser__default.parse(error).reverse() : ErrorStackParser__default.parse(error);
+  const { parsedFrames } = frames.reduce(
+    (acc, frame, index) => {
+      const parsed = parseFrame({
+        frame,
+        index,
+        rootFunctionName,
+        frames
+      });
+      const isValid = filter ? filter(parsed) : true;
+      if (isValid) {
+        acc.parsedFrames.push(parsed);
+      }
+      return acc;
+    },
+    { parsedFrames: [] }
+  );
+  return parsedFrames ?? [];
+}
+function parseFrame(options) {
+  const { frame, frames, index, rootFunctionName, cwd, debug } = options ?? {};
+  const functionName = parseFunctionName(frame.functionName);
+  const isRootFunction = isMatching(functionName, rootFunctionName);
+  const beforeFrameFunctionName = parseFunctionName(
+    getArrayItemAtOffset(frames, index, -1)?.functionName
+  );
+  const isParentOfRootFunction = isMatching(
+    beforeFrameFunctionName,
+    rootFunctionName
+  );
+  const fileData = frame.fileName ? getFilePathData({ filepath: frame.fileName, cwd }) : void 0;
+  const { isFileInCwd: isFrameInScope, ...restFileData } = fileData ?? {};
+  const data = {
+    ...restFileData,
+    functionName,
+    source: frame.source,
+    sourceFunctionName: frame.functionName,
+    isFrameInScope,
+    place: placeFormatter(index, frames?.length),
+    isRootFunction,
+    isParentOfRootFunction,
+    rootFunctionName
+  };
+  debug && console.log(data);
+  return data;
+}
+function getFilePathData({
+  filepath,
+  cwd
+}) {
+  const workingDir = cwd ?? process__default.cwd();
+  const filePath = path.normalize(filepath);
+  const fileBasename = path.basename(filePath);
+  const dirPath = path.dirname(filePath);
+  const dirBasename = path.basename(dirPath);
+  const relativeFilePath = path.relative(workingDir, filePath);
+  const relativeDirPath = path.dirname(relativeFilePath);
+  const isFileInCwd = filePath.startsWith(workingDir);
+  return {
+    filePath,
+    dirPath,
+    relativeFilePath,
+    relativeDirPath,
+    fileBasename,
+    dirBasename,
+    isFileInCwd
+  };
+}
+function parseFunctionName(functionName) {
+  if (!functionName)
+    return void 0;
+  return removeStart(functionName, "Module.");
+}
+function removeStart(input, value) {
+  return input.startsWith(value) ? input.slice(value.length) : input;
+}
+function placeFormatter(index, total) {
+  if (!index || !total)
+    return void 0;
+  return [index, total].join("/");
+}
+
+const _filename = (options) => {
+  const { filePath } = findCallerStackFrame({ error: new Error(), ...options }) ?? {};
+  return filePath;
+};
+const _dirname = (options) => {
+  const { dirPath } = findCallerStackFrame({ error: new Error(), ...options }) ?? {};
+  return dirPath;
+};
+
+async function resolveModule(module) {
+  const resolved = await module;
+  return resolved.default || resolved;
+}
+function isPackageModuleFound(name, options) {
+  return Boolean(resolvePackageModulePath(name, options));
+}
+function resolvePackageModulePath(name, options) {
+  const resolvedPath = findResolvedModulePath(
+    [`${name}/package.json`, name],
+    options
+  );
+  if (resolvedPath === void 0) {
+    console.error(`Could not resolve package ${name}`);
+    return void 0;
+  }
+  return resolvedPath;
+}
+function findResolvedModulePath(paths, options) {
+  for (const path of paths) {
+    const resolvedPath = resolveModulePath(path, options);
+    if (resolvedPath === void 0)
+      continue;
+    return resolvedPath;
+  }
 }
+function resolveModulePath(modulePath, options) {
+  const { normalize = true, paths, ...rest } = options ?? {};
+  try {
+    const path = normalizePath(modulePath, normalize);
+    return mlly.resolvePathSync(path, {
+      url: paths,
+      ...rest
+    });
+  } catch (e) {
+    return void 0;
+  }
+}
+
+const tsconfig = (tsconfigDir) => ({
+  get paths() {
+    return globby.globbySync(["tsconfig.json", "tsconfig.*.json"], {
+      cwd: tsconfigDir
+    }) ?? [];
+  }
+});
 
-async function ensurePackage(name, options) {
-  if (isPackageDependency(name))
+function parseGitignoreFile(gitignorePath, options) {
+  return gitignoreParser__default(gitignorePath, options);
+}
+function getGitignoreData(gitignorePath) {
+  const gitignoreFileContent = node_fs.readFileSync(gitignorePath, "utf-8");
+  const gitignores = parseGitignoreFile(gitignoreFileContent);
+  return gitignores;
+}
+const gitignore = (gitignorePath) => ({
+  get data() {
+    return getGitignoreData(gitignorePath);
+  },
+  get patterns() {
+    return getGitignoreData(gitignorePath).patterns;
+  }
+});
+
+const dependencyTypeMap = {
+  dependency: "dependencies",
+  devDependency: "devDependencies",
+  peerDependency: "peerDependencies",
+  optionalDependency: "optionalDependencies"
+};
+
+function isDependencyInPackageJson(options, packageJson) {
+  return Boolean(findDependencyInPackageJson(options, packageJson));
+}
+function findDependencyInPackageJson(option, packageJson) {
+  const { name, type } = typeof option === "string" ? { name: option, type: void 0 } : option;
+  if (!packageJson)
+    return void 0;
+  const allowedTypes = typeof type === "string" ? {
+    [type]: true
+  } : type ?? {
+    dependency: true,
+    devDependency: true
+  };
+  const allowedDependencyTypes = getAllowedDependencyTypeList(allowedTypes);
+  const matches = allowedDependencyTypes.map((type2) => {
+    return getPackageJsonDependencyItem({ name, type: type2 }, packageJson);
+  }).filter(notFalsy);
+  if (matches.length === 0)
+    return void 0;
+  return {
+    firstMatch: matches[0],
+    matches
+  };
+}
+function getPackageJsonDependencyItem({
+  name,
+  type
+}, packageJson) {
+  if (!packageJson)
+    return void 0;
+  const dependencyMap = getPackageJsonDependencyMap(type, packageJson);
+  const version = dependencyMap?.[name];
+  if (version === void 0)
+    return void 0;
+  return {
+    name,
+    version,
+    type
+  };
+}
+function getAllowedDependencyTypeList(selected) {
+  return Object.keys(dependencyTypeMap).filter(
+    (key) => selected[key]
+  );
+}
+function getPackageJsonDependencyMap(type, packageJson) {
+  return packageJson[dependencyTypeMap[type]];
+}
+
+function getWorkspaceFolder(options) {
+  const {
+    cwd = process__default.cwd(),
+    fallbackToGitRoot = true,
+    throwIfNotFound = true
+  } = options ?? {};
+  const getFolder = fallbackToGitRoot ? WST__namespace.getWorkspaceRoot : WST__namespace.getWorkspaceRoot;
+  const folder = getFolder(cwd);
+  if (folder === void 0 && throwIfNotFound) {
+    throw new Error(`Could not find workspace folder`);
+  }
+  return folder;
+}
+getWorkspaceFolder();
+
+function getPackageFolder(options) {
+  return WST__namespace.findPackageRoot(options?.cwd ?? process__default.cwd());
+}
+
+function getPackageInfo(options) {
+  const packageDir = getPackageFolder(options);
+  return readPackageInfo({ packageDir });
+}
+function readPackageInfo({
+  packageDir
+}) {
+  const packageJsonPath = path__default.join(packageDir, "package.json");
+  const packageJson = JSON.parse(
+    node_fs.readFileSync(packageJsonPath, "utf-8")
+  );
+  return {
+    name: packageJson.name,
+    path: packageJsonPath,
+    dirpath: packageDir,
+    packageJson
+  };
+}
+
+function getWorkspaceProjectInfo(options) {
+  try {
+    const workspaceDir = getWorkspaceFolder(options);
+    return readPackageInfo({ packageDir: workspaceDir });
+  } catch (e) {
+    console.error(e);
+    throw new Error("Root workspace not found");
+  }
+}
+
+function getWorkspacePackageInfoList(options) {
+  const { workspaceDir, resolveWstList } = common(options);
+  const wstList = WST__namespace.getWorkspaces(workspaceDir);
+  return resolveWstList(wstList);
+}
+function common(options) {
+  const { cwd, includeRoot: includeWorkspace } = options ?? {};
+  const workspaceDir = getWorkspaceFolder({ cwd });
+  function resolveWstList(list) {
+    if (!workspaceDir)
+      return [];
+    if (includeWorkspace)
+      return [getWorkspaceProjectInfo(), ...list];
+    return list;
+  }
+  return {
+    workspaceDir,
+    includeWorkspace,
+    resolveWstList
+  };
+}
+
+function getWorkspacePackageInfoMap(options) {
+  const workspaceInfo = getWorkspacePackageInfoList(options);
+  const entries = workspaceInfo.map((info) => [info.name, info]);
+  return Object.fromEntries(entries);
+}
+
+function getProjectInfoByName(name, options) {
+  const { cwd } = options ?? {};
+  return getWorkspacePackageInfoMap({ cwd })[name];
+}
+
+function getProjectInfo(folder, options) {
+  if (isWorkspaceFolderTypeOption(folder)) {
+    return getWorkspaceProjectInfo(
+      parseWorkspaceFolderTypeOptions(folder, options)
+    );
+  }
+  if (folder === "<package_folder>") {
+    return getPackageInfo(options);
+  }
+  if (folder === "<gitroot_folder>") {
+    return getPackageInfo(options);
+  }
+  return getProjectInfoByName(folder.packageName, options);
+}
+function isWorkspaceFolderTypeOption(option) {
+  return Boolean(
+    option === "<workspace_folder>" || typeof option === "object" && "<workspace_folder>" in option
+  );
+}
+function parseWorkspaceFolderTypeOptions(option, defaultOptions) {
+  if (typeof option === "string") {
+    return defaultOptions ?? {};
+  }
+  return { ...defaultOptions, ...option["<workspace_folder>"] };
+}
+getProjectInfo({
+  "<workspace_folder>": {}
+});
+
+const project = (...args) => {
+  const [source, projectOptions] = args;
+  const { packageJson, packageJsonPath, packageName, projectDir } = info();
+  const {
+    findPackageManager: findPackageManager2,
+    detectPackageManagers,
+    detectLockfilePackageManagers,
+    detectGlobalPackageManagers,
+    filterPackageManagers
+  } = definePackageManagerClient({ cwd: projectDir });
+  return {
+    packageJson,
+    packageJsonPath,
+    packageName,
+    projectDir,
+    findPackageManager: findPackageManager2,
+    detectPackageManagers,
+    detectGlobalPackageManagers,
+    detectLockfilePackageManagers,
+    tsconfig: tsconfig(projectDir ?? ""),
+    gitignore: gitignore(path__default$1.join(projectDir ?? "", ".gitignore")),
+    filterPackageManagers,
+    getPackageJson: () => get("packageJson"),
+    findDependencyInPackageJson: (options) => findDependencyInPackageJson(options, get("packageJson")),
+    isDependencyInPackageJson: (options) => isDependencyInPackageJson(options, get("packageJson"))
+  };
+  function info() {
+    const {
+      packageJson: packageJson2,
+      name: packageName2,
+      dirpath: projectDir2,
+      path: packageJsonPath2
+    } = getProjectInfo(source, projectOptions) ?? {};
+    return {
+      packageJson: packageJson2,
+      packageJsonPath: packageJsonPath2,
+      packageName: packageName2,
+      projectDir: projectDir2
+    };
+  }
+  function get(key) {
+    return info()[key];
+  }
+};
+
+function getWorkspacePackageNames(options) {
+  return getWorkspacePackageInfoList(options).map((e) => e.name);
+}
+
+const workspace = {
+  packageNames: getWorkspacePackageNames,
+  packageGraph: getWorkspacePackageInfoMap,
+  packageList: getWorkspacePackageInfoList,
+  workspaceRootDir: getWorkspaceFolder,
+  getProject: project
+};
+
+function importer(imports, options) {
+  const { install: defaultInstall = true, installer } = options ?? {};
+  return Promise.all(
+    imports.map(async (e) => {
+      const importOpt = resolveImportOption(e);
+      const shouldInstall = importOpt.install ?? defaultInstall;
+      if (shouldInstall && importOpt.name) {
+        await installImport(importOpt.name, importOpt, installer);
+      }
+      const m = await importOpt.import();
+      return resolveModule(m);
+    })
+  );
+}
+const definePackage = (option) => {
+  const { name, ...rest } = typeof option === "string" ? { name: option } : option;
+  return {
+    name,
+    import: () => import(name),
+    ...rest
+  };
+};
+function resolveImportOption(option) {
+  if (typeof option === "function") {
+    return {
+      import: option
+    };
+  }
+  if (option instanceof Promise) {
+    return {
+      import: () => option
+    };
+  }
+  return option;
+}
+async function installImport(packageName, options, installer) {
+  if (!packageName)
     return;
-  await installPkg.installPackage(name, options);
+  const { checkExists } = options ?? {};
+  if (checkExists && isPackageDependency(packageName))
+    return;
+  const installerFn = installer ?? (await workspace.getProject("<package_folder>").findPackageManager()).installPackage;
+  await installerFn(packageName, options);
 }
 
-function definePackageManager(config) {
+const importMap = async (importMap2, options) => {
+  const keys = Object.keys(importMap2);
+  const imported = await importer(
+    keys.map((key) => importMap2[key]),
+    options
+  );
+  return Object.fromEntries(
+    keys.map((key, index) => [key, imported[index]])
+  );
+};
+
+function definePackageManager(config, options) {
+  const { cwd: defaultCwd } = options ?? {};
   const { command, args: agentArgs, options: agentOptions } = config;
-  const findLockfilePath = asyncCacheFn.asyncCacheFn(async (options) => {
-    const { cwd } = options ?? {};
+  const findLockfilePath = asyncCacheFn.asyncCacheFn(async (options2) => {
+    const { cwd = defaultCwd } = options2 ?? {};
     const lockfiles = toArray(config.meta.lockfile);
     return await findUp.findUp(lockfiles, { cwd });
   });
+  const installPackage = async (packageName, options2) => {
+    const install = agentArgs.install;
+    const { dev, preferOffline } = select(
+      install.options,
+      {
+        preferOffline: true,
+        cwd: defaultCwd,
+        ...options2
+      },
+      "pick"
+    );
+    const packageNames = toArray(packageName);
+    try {
+      await $$({
+        command,
+        args: [install.command, dev, preferOffline, ...packageNames],
+        cwd: defaultCwd,
+        ...options2
+      });
+    } catch (e) {
+      throw new Error(`Failed to install: ${packageNames.join(", ")}`);
+    }
+  };
+  const uninstallPackage = async (packageName, options2) => {
+    const uninstall = agentArgs.uninstall;
+    await Promise.all(
+      toArray(packageName).map(async (name) => {
+        try {
+          await $$({
+            command,
+            args: [uninstall.command, name],
+            cwd: defaultCwd,
+            ...options2
+          });
+        } catch (e) {
+        }
+      })
+    );
+  };
   return {
     id: config.id,
     config,
@@ -96,50 +579,27 @@ function definePackageManager(config) {
       return promises.readFile(lockfilePath, "utf8");
     }),
     globalVersion: asyncCacheFn.asyncCacheFn(async (...args) => {
-      const [options] = args;
+      const [options2] = args;
       try {
         const { stdout } = await $$({
           command,
           args: [agentOptions.version],
-          ...options
+          cwd: defaultCwd,
+          ...options2
         });
         return `${stdout}`;
       } catch (e) {
         return void 0;
       }
     }),
-    installPackage: async (packageName, options) => {
-      const install = agentArgs.install;
-      const { isDevDependency, preferOffline } = select(
-        install.options,
-        options ?? {},
-        "pick"
-      );
-      const packageNames = toArray(packageName);
-      try {
-        await $$({
-          command,
-          args: [
-            install.command,
-            isDevDependency,
-            preferOffline,
-            ...packageNames
-          ],
-          ...options
-        });
-      } catch (e) {
-        throw new Error(`Failed to install: ${packageNames.join(", ")}`);
-      }
-    },
-    uninstallPackage: async (packageName, options) => {
-      const uninstall = agentArgs.uninstall;
-      if (!isPackageDependency(packageName))
-        return;
-      await $$({
-        command,
-        args: [uninstall.command, ...toArray(packageName)],
-        ...options
-      }).catch((e) => {
+    definePackage,
+    installPackage,
+    uninstallPackage,
+    defineImportMap(imports, options2) {
+      const { install = true } = options2 ?? {};
+      return importMap(imports, {
+        install,
+        installer: installPackage
       });
     }
   };
@@ -153,7 +613,11 @@ async function $$(options) {
   });
 }
 
-const bun = definePackageManager({
+function definePackageManagerConfig(config) {
+  return config;
+}
+
+const bun = definePackageManagerConfig({
   id: "bun",
   name: "Bun",
   command: "bun",
@@ -165,7 +629,7 @@ const bun = definePackageManager({
     install: {
       command: "install",
       options: {
-        isDevDependency: "-D",
+        dev: "-D",
         preferOffline: "--prefer-offline"
       }
     },
@@ -178,7 +642,7 @@ const bun = definePackageManager({
   }
 });
 
-const npm = definePackageManager({
+const npm = definePackageManagerConfig({
   id: "npm",
   name: "NPM",
   command: "npm",
@@ -190,7 +654,7 @@ const npm = definePackageManager({
     install: {
       command: "install",
       options: {
-        isDevDependency: "-D",
+        dev: "-D",
         preferOffline: "--prefer-offline"
       }
     },
@@ -203,7 +667,7 @@ const npm = definePackageManager({
   }
 });
 
-const pnpm = definePackageManager({
+const pnpm = definePackageManagerConfig({
   id: "pnpm",
   name: "PNPM",
   command: "pnpm",
@@ -215,12 +679,12 @@ const pnpm = definePackageManager({
     install: {
       command: "install",
       options: {
-        isDevDependency: "-D",
+        dev: "-D",
         preferOffline: "--prefer-offline"
       }
     },
     uninstall: {
-      command: "uninstall"
+      command: "remove"
     }
   },
   options: {
@@ -228,7 +692,7 @@ const pnpm = definePackageManager({
   }
 });
 
-const yarn = definePackageManager({
+const yarn = definePackageManagerConfig({
   id: "yarn",
   name: "Yarn",
   command: "yarn",
@@ -240,7 +704,7 @@ const yarn = definePackageManager({
     install: {
       command: "add",
       options: {
-        isDevDependency: "-D",
+        dev: "-D",
         preferOffline: "--prefer-offline"
       }
     },
@@ -253,62 +717,289 @@ const yarn = definePackageManager({
   }
 });
 
-const packageManagers = fromEntries(
-  [pnpm, yarn, bun, npm].map((e) => [e.id, e])
-);
-
-async function findPackageManager(options) {
+async function findPackageManager(packageManagers, options) {
   const { ...rest } = options ?? {};
-  const packageManager = await findPackageManagerSafely(rest);
+  const packageManager = await findPackageManagerSafely(packageManagers, rest);
   invariant(packageManager, "No package manager found");
   return packageManager;
 }
-async function findPackageManagerSafely(options) {
-  const lockfilePm = (await detectLockfilePackageManagers(options))[0];
+async function findPackageManagerSafely(packageManagers, options) {
+  const lockfilePm = (await detectLockfilePackageManagers(packageManagers, options))[0];
   if (lockfilePm) {
     return lockfilePm;
   }
-  const globalPm = (await detectGlobalPackageManagers(options))[0];
+  const globalPm = (await detectGlobalPackageManagers(packageManagers, options))[0];
   return globalPm;
 }
-async function detectPackageManagers(options) {
+async function detectPackageManagers(packageManagers, options) {
   return [
-    ...await detectLockfilePackageManagers(options),
-    ...await detectGlobalPackageManagers(options)
+    ...await detectLockfilePackageManagers(packageManagers, options),
+    ...await detectGlobalPackageManagers(packageManagers, options)
   ];
 }
-async function detectLockfilePackageManagers(options) {
-  ({ cwd: options?.cwd });
-  return filterPackageManagers((e) => e.hasLockfile(options), options);
-}
-async function detectGlobalPackageManagers(options) {
-  return filterPackageManagers(async (e) => e.globalVersion(options), options);
+async function detectLockfilePackageManagers(packageManagers, options) {
+  return filterPackageManagers(
+    packageManagers,
+    (e) => e.hasLockfile(options),
+    options
+  );
 }
-async function filterPackageManagers(filterFn, options) {
-  const allowedPackageManagers = Object.entries(packageManagers).filter(
-    ([key]) => {
-      if (!options?.allowed)
-        return true;
-      return key in options.allowed;
-    }
+async function detectGlobalPackageManagers(packageManagers, options) {
+  return filterPackageManagers(
+    packageManagers,
+    async (e) => Boolean(e.globalVersion(options)),
+    options
   );
+}
+async function filterPackageManagers(packageManagers, filterFn, options) {
+  const allowedPackageManagers = packageManagers.filter(({ id }) => {
+    if (!options?.allowed)
+      return true;
+    return id in options.allowed;
+  });
   return (await Promise.all(
-    allowedPackageManagers.map(async ([key, pm]) => {
+    allowedPackageManagers.map(async (pm) => {
       const valid = await filterFn(pm);
       return valid ? pm : void 0;
     })
   )).filter(notFalsy);
 }
 
+const packageManagerConfigs = [pnpm, yarn, bun, npm];
+function definePackageManagerClient(options) {
+  const configs = packageManagerConfigs.map(
+    (config) => definePackageManager(config, options)
+  );
+  return {
+    configs,
+    findPackageManager: asyncCacheFn.asyncCacheFn(
+      async (options2) => await findPackageManager(configs, options2)
+    ),
+    findPackageManagerSafely: asyncCacheFn.asyncCacheFn(
+      async (options2) => await findPackageManagerSafely(configs, options2)
+    ),
+    detectPackageManagers: asyncCacheFn.asyncCacheFn(
+      async (options2) => await detectPackageManagers(configs, options2)
+    ),
+    detectLockfilePackageManagers: asyncCacheFn.asyncCacheFn(
+      async (options2) => detectLockfilePackageManagers(configs, options2)
+    ),
+    detectGlobalPackageManagers: asyncCacheFn.asyncCacheFn(
+      async (options2) => detectGlobalPackageManagers(configs, options2)
+    ),
+    filterPackageManagers: async (filterFn, options2) => filterPackageManagers(configs, filterFn, options2)
+  };
+}
+
+function isPackageDependency(packageName) {
+  return toArray(packageName).every((name) => isDependencyInPackageJson(name));
+}
+
+function definePathAliases(aliasDefinitions) {
+  const aliasMap = getAliasMap(aliasDefinitions);
+  function getFilePath(options, aliases) {
+    return getAliasedFilePath(
+      { ...aliasMap, ...aliases },
+      options
+    );
+  }
+  return {
+    aliasDefinitions,
+    aliasMap,
+    getFilePath
+  };
+}
+function getAliasedFilePath(aliasMap, options) {
+  try {
+    if (typeof options === "string" || Array.isArray(options)) {
+      return resolvePathTo(options, { aliasMap });
+    }
+    const opts = { ...options, aliasMap };
+    if (opts.startingFrom) {
+      return resolveRelativePathTo(opts.to, opts.startingFrom, opts);
+    }
+    return resolvePathTo(opts.to, opts);
+  } catch (e) {
+    return void 0;
+  }
+}
+function resolveRelativePathTo(to, from, options) {
+  const pathFrom = resolvePathTo(from, options);
+  const pathTo = resolvePathTo(to, options);
+  return path__default$1.relative(pathFrom, pathTo);
+}
+function resolvePathTo(pathTo, { cwd, checkExistence, glob, aliasMap }) {
+  const normalized = normalizePathTo(pathTo, { cwd, aliasMap });
+  if (glob) {
+    const globPaths = globby.globbySync(normalized, { cwd });
+    if (!globPaths[0])
+      throw new Error(`No paths found for glob: ${normalized}`);
+    return globPaths[0];
+  }
+  if (!glob && checkExistence && !node_fs.existsSync(normalized))
+    throw new Error(`Path does not exist: ${normalized}`);
+  return normalized;
+}
+function normalizePathTo(pathTo, options) {
+  const { cwd, aliasMap } = options ?? {};
+  if (Array.isArray(pathTo)) {
+    const [baseDir] = pathTo;
+    const aliasedPath = path__default$1.join(...pathTo.filter(isNotNull));
+    return utils.resolveAlias(aliasedPath, {
+      [baseDir]: executeMapFn(aliasMap, baseDir, [{ cwd }])
+    });
+  }
+  return pathTo;
+}
+function executeMapFn(map, key, args) {
+  if (!map || !key || !(key in map))
+    return void 0;
+  const fnArgs = Array.isArray(args) ? args : [args];
+  const resolver = map?.[key];
+  return typeof resolver === "function" ? resolver?.(...fnArgs) : resolver;
+}
+function getAliasMap(aliasDefs) {
+  return Object.fromEntries(
+    Object.entries(aliasDefs).flatMap(([alias, v]) => {
+      const { resolve, subpaths = [] } = v;
+      return [
+        [alias, resolve],
+        ...subpaths.map(({ to }) => {
+          const subpathAlias = path__default$1.join(alias, to);
+          return [
+            subpathAlias,
+            (opts) => utils.resolveAlias(subpathAlias, { [alias]: resolve(opts) })
+          ];
+        })
+      ];
+    })
+  );
+}
+function isNotNull(value) {
+  return value !== null && value !== void 0;
+}
+
+const predefinedPathAliases = {
+  "<workspace_folder>": {
+    resolve: (opts) => getWorkspaceFolder(opts),
+    subpaths: [
+      {
+        to: "node_modules"
+      },
+      {
+        to: "node_modules/.bin"
+      }
+    ]
+  },
+  "<workspace_folder?>": {
+    resolve: (opts) => getWorkspaceFolder(opts),
+    subpaths: [
+      {
+        to: "node_modules"
+      },
+      {
+        to: "node_modules/.bin"
+      }
+    ]
+  },
+  "<package_folder>": {
+    resolve: (opts) => getPackageFolder(opts),
+    subpaths: [
+      {
+        to: "node_modules"
+      },
+      {
+        to: "node_modules/.bin"
+      },
+      {
+        to: "src"
+      }
+    ]
+  },
+  "<gitroot_folder>": {
+    resolve: (opts) => getGitRootFolder(opts),
+    subpaths: [
+      {
+        to: "node_modules"
+      },
+      {
+        to: "node_modules/.bin"
+      },
+      {
+        to: ".vscode"
+      }
+    ]
+  },
+  "<user_home>": {
+    resolve: () => os__default.homedir(),
+    subpaths: []
+  },
+  "<user_tmpdir>": {
+    resolve: () => os__default.tmpdir(),
+    subpaths: []
+  },
+  "<cwd>": {
+    resolve: () => process__default.cwd(),
+    subpaths: []
+  },
+  "<current_file>": {
+    // resolve: () => fileURLToPath(import.meta.url),
+    resolve: () => _filename({ rootFunctionName: "getFilePath" }) ?? "",
+    subpaths: []
+  },
+  "<current_folder>": {
+    // resolve: () => fileURLToPath(import.meta.url),
+    resolve: () => _dirname({ rootFunctionName: "getFilePath" }) ?? "",
+    subpaths: []
+  }
+};
+
+const getPath = definePathAliases(predefinedPathAliases).getFilePath;
+getPath(["<workspace_folder>/node_modules/.bin"]);
+
+function getFolderByPackageName(name, options) {
+  const infoMap = getWorkspacePackageInfoMap({ ...options, includeRoot: true });
+  const info = infoMap?.[name];
+  return info?.dirpath;
+}
+
+function getGitRootFolder(options) {
+  const output = execa.execaSync(`git rev-parse --show-toplevel`, {
+    ...options,
+    reject: false
+  });
+  if (!output.stdout) {
+    console.warn(`Directory "${output.cwd}" is not in a git repository`);
+    return void 0;
+  }
+  return path__default$1.normalize(output.stdout);
+}
+
+exports._dirname = _dirname;
+exports._filename = _filename;
+exports.definePackage = definePackage;
+exports.definePackageManagerClient = definePackageManagerClient;
+exports.definePathAliases = definePathAliases;
 exports.detectGlobalPackageManagers = detectGlobalPackageManagers;
 exports.detectLockfilePackageManagers = detectLockfilePackageManagers;
 exports.detectPackageManagers = detectPackageManagers;
-exports.ensurePackage = ensurePackage;
 exports.filterPackageManagers = filterPackageManagers;
 exports.findPackageManager = findPackageManager;
 exports.findPackageManagerSafely = findPackageManagerSafely;
+exports.findResolvedModulePath = findResolvedModulePath;
+exports.getAliasMap = getAliasMap;
+exports.getFolderByPackageName = getFolderByPackageName;
+exports.getGitRootFolder = getGitRootFolder;
+exports.getPackageFolder = getPackageFolder;
+exports.getPath = getPath;
+exports.getWorkspaceFolder = getWorkspaceFolder;
 exports.importMap = importMap;
 exports.importer = importer;
 exports.isPackageDependency = isPackageDependency;
-exports.packageManagers = packageManagers;
+exports.isPackageModuleFound = isPackageModuleFound;
+exports.packageManagerConfigs = packageManagerConfigs;
+exports.predefinedPathAliases = predefinedPathAliases;
 exports.resolveModule = resolveModule;
+exports.resolveModulePath = resolveModulePath;
+exports.resolvePackageModulePath = resolvePackageModulePath;
+exports.workspace = workspace;