package-management 0.0.1 → 0.0.2

package/dist/index.mjs

@@ -1,39 +1,376 @@
-import { installPackage } from '@antfu/install-pkg';
-import 'node:fs';
+import path$1, { normalize } from 'pathe';
+import { readFileSync } from 'node:fs';
 import { execa } from 'execa';
-import { isPackageExists } from 'local-pkg';
 import { asyncCacheFn } from 'async-cache-fn';
 import { findUp } from 'find-up';
 import { readFile } from 'node:fs/promises';
+import { resolvePathSync } from 'mlly';
+import { globbySync } from 'globby';
+import gitignoreParser from 'parse-gitignore';
+import * as WST from 'workspace-tools';
+import process from 'node:process';
+import path from 'node:path';
 
-async function resolveModule(m) {
-  const resolved = await m;
+const toArray = (data) => Array.isArray(data) ? data : [data];
+const entriesOf = (o) => Object.entries(o);
+const fromEntries = (entries) => Object.fromEntries(entries);
+const notFalsy = (value) => [false, null, void 0].every((v) => v !== value);
+const select = (obj, selection, mode) => {
+  if (!selection)
+    return obj;
+  const filtered = entriesOf(obj).filter(([key]) => {
+    return mode === "omit" ? !selection[key] : selection[key];
+  });
+  return fromEntries(filtered);
+};
+function normalizePath(path, option) {
+  if (typeof option === "function") {
+    return normalizePath(path);
+  }
+  if (option === false) {
+    return path;
+  }
+  return normalize(path);
+}
+const invariant = (predicate, message) => {
+  if (!predicate) {
+    throw new Error(message);
+  }
+};
+
+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 resolvePathSync(path, {
+      url: paths,
+      ...rest
+    });
+  } catch (e) {
+    return void 0;
+  }
+}
+
+const tsconfig = (tsconfigDir) => ({
+  get paths() {
+    return globbySync(["tsconfig.json", "tsconfig.*.json"], {
+      cwd: tsconfigDir
+    }) ?? [];
+  }
+});
+
+function parseGitignoreFile(gitignorePath, options) {
+  return gitignoreParser(gitignorePath, options);
+}
+function getGitignoreData(gitignorePath) {
+  const gitignoreFileContent = 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.cwd(),
+    fallbackToGitRoot = true,
+    throwIfNotFound = true
+  } = options ?? {};
+  const getFolder = fallbackToGitRoot ? WST.getWorkspaceRoot : WST.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.findPackageRoot(options?.cwd ?? process.cwd());
+}
+
+function getPackageInfo(options) {
+  const packageDir = getPackageFolder(options);
+  return readPackageInfo({ packageDir });
+}
+function readPackageInfo({
+  packageDir
+}) {
+  const packageJsonPath = path.join(packageDir, "package.json");
+  const packageJson = JSON.parse(
+    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.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$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 = true } = options ?? {};
+  const { install: defaultInstall = true, installer } = options ?? {};
   return Promise.all(
-    imports.map(async (option) => {
-      if (install && "name" in option) {
-        await ensurePackage(option.name);
+    imports.map(async (e) => {
+      const importOpt = resolveImportOption(e);
+      const shouldInstall = importOpt.install ?? defaultInstall;
+      if (shouldInstall && importOpt.name) {
+        await installImport(importOpt.name, importOpt, installer);
       }
-      const importStatement = getImportStatement(option);
-      return resolveModule(importStatement);
+      const m = await importOpt.import();
+      return resolveModule(m);
     })
   );
 }
-function getImportStatement(option) {
+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 option();
+    return {
+      import: option
+    };
   }
-  if (typeof option === "object" && "import" in option && "name" in option) {
-    return option.import();
+  if (option instanceof Promise) {
+    return {
+      import: () => option
+    };
   }
   return option;
 }
+async function installImport(packageName, options, installer) {
+  if (!packageName)
+    return;
+  const { checkExists } = options ?? {};
+  if (checkExists && isPackageDependency(packageName))
+    return;
+  const installerFn = installer ?? (await workspace.getProject("<package_folder>").findPackageManager()).installPackage;
+  await installerFn(packageName, options);
+}
 
-async function importMap(importMap2, options) {
+const importMap = async (importMap2, options) => {
   const keys = Object.keys(importMap2);
   const imported = await importer(
     keys.map((key) => importMap2[key]),
@@ -42,43 +379,55 @@ async function importMap(importMap2, options) {
   return Object.fromEntries(
     keys.map((key, index) => [key, imported[index]])
   );
-}
-
-const toArray = (data) => Array.isArray(data) ? data : [data];
-const entriesOf = (o) => Object.entries(o);
-const fromEntries = (entries) => Object.fromEntries(entries);
-const notFalsy = (value) => [false, null, void 0].every((v) => v !== value);
-const select = (obj, selection, mode) => {
-  if (!selection)
-    return obj;
-  const filtered = entriesOf(obj).filter(([key]) => {
-    return mode === "omit" ? !selection[key] : selection[key];
-  });
-  return fromEntries(filtered);
-};
-const invariant = (predicate, message) => {
-  if (!predicate) {
-    throw new Error(message);
-  }
 };
 
-function isPackageDependency(packageName) {
-  return toArray(packageName).every((name) => isPackageExists(name));
-}
-
-async function ensurePackage(name, options) {
-  if (isPackageDependency(name))
-    return;
-  await installPackage(name, options);
-}
-
-function definePackageManager(config) {
+function definePackageManager(config, options) {
+  const { cwd: defaultCwd } = options ?? {};
   const { command, args: agentArgs, options: agentOptions } = config;
-  const findLockfilePath = asyncCacheFn(async (options) => {
-    const { cwd } = options ?? {};
+  const findLockfilePath = asyncCacheFn(async (options2) => {
+    const { cwd = defaultCwd } = options2 ?? {};
     const lockfiles = toArray(config.meta.lockfile);
     return await 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,
@@ -94,50 +443,27 @@ function definePackageManager(config) {
       return readFile(lockfilePath, "utf8");
     }),
     globalVersion: 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
       });
     }
   };
@@ -151,7 +477,11 @@ async function $$(options) {
   });
 }
 
-const bun = definePackageManager({
+function definePackageManagerConfig(config) {
+  return config;
+}
+
+const bun = definePackageManagerConfig({
   id: "bun",
   name: "Bun",
   command: "bun",
@@ -163,7 +493,7 @@ const bun = definePackageManager({
     install: {
       command: "install",
       options: {
-        isDevDependency: "-D",
+        dev: "-D",
         preferOffline: "--prefer-offline"
       }
     },
@@ -176,7 +506,7 @@ const bun = definePackageManager({
   }
 });
 
-const npm = definePackageManager({
+const npm = definePackageManagerConfig({
   id: "npm",
   name: "NPM",
   command: "npm",
@@ -188,7 +518,7 @@ const npm = definePackageManager({
     install: {
       command: "install",
       options: {
-        isDevDependency: "-D",
+        dev: "-D",
         preferOffline: "--prefer-offline"
       }
     },
@@ -201,7 +531,7 @@ const npm = definePackageManager({
   }
 });
 
-const pnpm = definePackageManager({
+const pnpm = definePackageManagerConfig({
   id: "pnpm",
   name: "PNPM",
   command: "pnpm",
@@ -213,12 +543,12 @@ const pnpm = definePackageManager({
     install: {
       command: "install",
       options: {
-        isDevDependency: "-D",
+        dev: "-D",
         preferOffline: "--prefer-offline"
       }
     },
     uninstall: {
-      command: "uninstall"
+      command: "remove"
     }
   },
   options: {
@@ -226,7 +556,7 @@ const pnpm = definePackageManager({
   }
 });
 
-const yarn = definePackageManager({
+const yarn = definePackageManagerConfig({
   id: "yarn",
   name: "Yarn",
   command: "yarn",
@@ -238,7 +568,7 @@ const yarn = definePackageManager({
     install: {
       command: "add",
       options: {
-        isDevDependency: "-D",
+        dev: "-D",
         preferOffline: "--prefer-offline"
       }
     },
@@ -251,51 +581,82 @@ 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);
 }
 
-export { detectGlobalPackageManagers, detectLockfilePackageManagers, detectPackageManagers, ensurePackage, filterPackageManagers, findPackageManager, findPackageManagerSafely, importMap, importer, isPackageDependency, packageManagers, resolveModule };
+const packageManagerConfigs = [pnpm, yarn, bun, npm];
+function definePackageManagerClient(options) {
+  const configs = packageManagerConfigs.map(
+    (config) => definePackageManager(config, options)
+  );
+  return {
+    configs,
+    findPackageManager: asyncCacheFn(
+      async (options2) => await findPackageManager(configs, options2)
+    ),
+    findPackageManagerSafely: asyncCacheFn(
+      async (options2) => await findPackageManagerSafely(configs, options2)
+    ),
+    detectPackageManagers: asyncCacheFn(
+      async (options2) => await detectPackageManagers(configs, options2)
+    ),
+    detectLockfilePackageManagers: asyncCacheFn(
+      async (options2) => detectLockfilePackageManagers(configs, options2)
+    ),
+    detectGlobalPackageManagers: asyncCacheFn(
+      async (options2) => detectGlobalPackageManagers(configs, options2)
+    ),
+    filterPackageManagers: async (filterFn, options2) => filterPackageManagers(configs, filterFn, options2)
+  };
+}
+
+function isPackageDependency(packageName) {
+  return toArray(packageName).every((name) => isDependencyInPackageJson(name));
+}
+
+export { definePackage, definePackageManagerClient, detectGlobalPackageManagers, detectLockfilePackageManagers, detectPackageManagers, filterPackageManagers, findPackageManager, findPackageManagerSafely, findResolvedModulePath, importMap, importer, isPackageDependency, isPackageModuleFound, packageManagerConfigs, resolveModule, resolveModulePath, resolvePackageModulePath };