package-management 0.0.1 → 0.0.2

package/dist/index.cjs

@@ -1,50 +1,37 @@
 'use strict';
 
-const installPkg = require('@antfu/install-pkg');
-require('node:fs');
+const path = require('pathe');
+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 process = require('node:process');
+const path$1 = require('node:path');
 
-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 path__default$1 = /*#__PURE__*/_interopDefaultCompat(path);
+const gitignoreParser__default = /*#__PURE__*/_interopDefaultCompat(gitignoreParser);
+const WST__namespace = /*#__PURE__*/_interopNamespaceCompat(WST);
+const process__default = /*#__PURE__*/_interopDefaultCompat(process);
+const path__default = /*#__PURE__*/_interopDefaultCompat(path$1);
 
 const toArray = (data) => Array.isArray(data) ? data : [data];
 const entriesOf = (o) => Object.entries(o);
@@ -58,29 +45,411 @@ 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 isPackageDependency(packageName) {
-  return toArray(packageName).every((name) => localPkg.isPackageExists(name));
+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
+    }) ?? [];
+  }
+});
+
+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);
 }
 
-async function ensurePackage(name, options) {
-  if (isPackageDependency(name))
+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 +465,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 +499,11 @@ async function $$(options) {
   });
 }
 
-const bun = definePackageManager({
+function definePackageManagerConfig(config) {
+  return config;
+}
+
+const bun = definePackageManagerConfig({
   id: "bun",
   name: "Bun",
   command: "bun",
@@ -165,7 +515,7 @@ const bun = definePackageManager({
     install: {
       command: "install",
       options: {
-        isDevDependency: "-D",
+        dev: "-D",
         preferOffline: "--prefer-offline"
       }
     },
@@ -178,7 +528,7 @@ const bun = definePackageManager({
   }
 });
 
-const npm = definePackageManager({
+const npm = definePackageManagerConfig({
   id: "npm",
   name: "NPM",
   command: "npm",
@@ -190,7 +540,7 @@ const npm = definePackageManager({
     install: {
       command: "install",
       options: {
-        isDevDependency: "-D",
+        dev: "-D",
         preferOffline: "--prefer-offline"
       }
     },
@@ -203,7 +553,7 @@ const npm = definePackageManager({
   }
 });
 
-const pnpm = definePackageManager({
+const pnpm = definePackageManagerConfig({
   id: "pnpm",
   name: "PNPM",
   command: "pnpm",
@@ -215,12 +565,12 @@ const pnpm = definePackageManager({
     install: {
       command: "install",
       options: {
-        isDevDependency: "-D",
+        dev: "-D",
         preferOffline: "--prefer-offline"
       }
     },
     uninstall: {
-      command: "uninstall"
+      command: "remove"
     }
   },
   options: {
@@ -228,7 +578,7 @@ const pnpm = definePackageManager({
   }
 });
 
-const yarn = definePackageManager({
+const yarn = definePackageManagerConfig({
   id: "yarn",
   name: "Yarn",
   command: "yarn",
@@ -240,7 +590,7 @@ const yarn = definePackageManager({
     install: {
       command: "add",
       options: {
-        isDevDependency: "-D",
+        dev: "-D",
         preferOffline: "--prefer-offline"
       }
     },
@@ -253,62 +603,98 @@ 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));
+}
+
+exports.definePackage = definePackage;
+exports.definePackageManagerClient = definePackageManagerClient;
 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.importMap = importMap;
 exports.importer = importer;
 exports.isPackageDependency = isPackageDependency;
-exports.packageManagers = packageManagers;
+exports.isPackageModuleFound = isPackageModuleFound;
+exports.packageManagerConfigs = packageManagerConfigs;
 exports.resolveModule = resolveModule;
+exports.resolveModulePath = resolveModulePath;
+exports.resolvePackageModulePath = resolvePackageModulePath;