package-management 0.0.1

package/dist/index.cjs

@@ -0,0 +1,314 @@
+'use strict';
+
+const installPkg = require('@antfu/install-pkg');
+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');
+
+async function resolveModule(m) {
+  const resolved = await m;
+  return resolved.default || resolved;
+}
+
+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();
+  }
+  return option;
+}
+
+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 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) => localPkg.isPackageExists(name));
+}
+
+async function ensurePackage(name, options) {
+  if (isPackageDependency(name))
+    return;
+  await installPkg.installPackage(name, options);
+}
+
+function definePackageManager(config) {
+  const { command, args: agentArgs, options: agentOptions } = config;
+  const findLockfilePath = asyncCacheFn.asyncCacheFn(async (options) => {
+    const { cwd } = options ?? {};
+    const lockfiles = toArray(config.meta.lockfile);
+    return await findUp.findUp(lockfiles, { cwd });
+  });
+  return {
+    id: config.id,
+    config,
+    findLockfilePath,
+    hasLockfile: asyncCacheFn.asyncCacheFn(async (...args) => {
+      const lockfilePath = await findLockfilePath.noCache(...args);
+      return Boolean(lockfilePath);
+    }),
+    readLockfile: asyncCacheFn.asyncCacheFn(async (...args) => {
+      const lockfilePath = await findLockfilePath.noCache(...args);
+      if (!lockfilePath)
+        return void 0;
+      return promises.readFile(lockfilePath, "utf8");
+    }),
+    globalVersion: asyncCacheFn.asyncCacheFn(async (...args) => {
+      const [options] = args;
+      try {
+        const { stdout } = await $$({
+          command,
+          args: [agentOptions.version],
+          ...options
+        });
+        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) => {
+      });
+    }
+  };
+}
+async function $$(options) {
+  const { command, args = [], silent = true, cwd, shellOptions } = options;
+  return execa.execa(command, args.filter(notFalsy), {
+    cwd,
+    ...shellOptions,
+    stdio: silent ? "ignore" : "inherit"
+  });
+}
+
+const bun = definePackageManager({
+  id: "bun",
+  name: "Bun",
+  command: "bun",
+  runner: "bunx",
+  meta: {
+    lockfile: "bun.lockb"
+  },
+  args: {
+    install: {
+      command: "install",
+      options: {
+        isDevDependency: "-D",
+        preferOffline: "--prefer-offline"
+      }
+    },
+    uninstall: {
+      command: "uninstall"
+    }
+  },
+  options: {
+    version: "--version"
+  }
+});
+
+const npm = definePackageManager({
+  id: "npm",
+  name: "NPM",
+  command: "npm",
+  runner: "npx",
+  meta: {
+    lockfile: ["package-lock.json", "npm-shrinkwrap.json"]
+  },
+  args: {
+    install: {
+      command: "install",
+      options: {
+        isDevDependency: "-D",
+        preferOffline: "--prefer-offline"
+      }
+    },
+    uninstall: {
+      command: "uninstall"
+    }
+  },
+  options: {
+    version: "--version"
+  }
+});
+
+const pnpm = definePackageManager({
+  id: "pnpm",
+  name: "PNPM",
+  command: "pnpm",
+  runner: "pnpx",
+  meta: {
+    lockfile: "pnpm-lock.yaml"
+  },
+  args: {
+    install: {
+      command: "install",
+      options: {
+        isDevDependency: "-D",
+        preferOffline: "--prefer-offline"
+      }
+    },
+    uninstall: {
+      command: "uninstall"
+    }
+  },
+  options: {
+    version: "--version"
+  }
+});
+
+const yarn = definePackageManager({
+  id: "yarn",
+  name: "Yarn",
+  command: "yarn",
+  runner: "yarn dlx",
+  meta: {
+    lockfile: "yarn.lock"
+  },
+  args: {
+    install: {
+      command: "add",
+      options: {
+        isDevDependency: "-D",
+        preferOffline: "--prefer-offline"
+      }
+    },
+    uninstall: {
+      command: "remove"
+    }
+  },
+  options: {
+    version: "--version"
+  }
+});
+
+const packageManagers = fromEntries(
+  [pnpm, yarn, bun, npm].map((e) => [e.id, e])
+);
+
+async function findPackageManager(options) {
+  const { ...rest } = options ?? {};
+  const packageManager = await findPackageManagerSafely(rest);
+  invariant(packageManager, "No package manager found");
+  return packageManager;
+}
+async function findPackageManagerSafely(options) {
+  const lockfilePm = (await detectLockfilePackageManagers(options))[0];
+  if (lockfilePm) {
+    return lockfilePm;
+  }
+  const globalPm = (await detectGlobalPackageManagers(options))[0];
+  return globalPm;
+}
+async function detectPackageManagers(options) {
+  return [
+    ...await detectLockfilePackageManagers(options),
+    ...await detectGlobalPackageManagers(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 filterPackageManagers(filterFn, options) {
+  const allowedPackageManagers = Object.entries(packageManagers).filter(
+    ([key]) => {
+      if (!options?.allowed)
+        return true;
+      return key in options.allowed;
+    }
+  );
+  return (await Promise.all(
+    allowedPackageManagers.map(async ([key, pm]) => {
+      const valid = await filterFn(pm);
+      return valid ? pm : void 0;
+    })
+  )).filter(notFalsy);
+}
+
+exports.detectGlobalPackageManagers = detectGlobalPackageManagers;
+exports.detectLockfilePackageManagers = detectLockfilePackageManagers;
+exports.detectPackageManagers = detectPackageManagers;
+exports.ensurePackage = ensurePackage;
+exports.filterPackageManagers = filterPackageManagers;
+exports.findPackageManager = findPackageManager;
+exports.findPackageManagerSafely = findPackageManagerSafely;
+exports.importMap = importMap;
+exports.importer = importer;
+exports.isPackageDependency = isPackageDependency;
+exports.packageManagers = packageManagers;
+exports.resolveModule = resolveModule;

package/dist/index.d.cts

@@ -0,0 +1,227 @@
+import { InstallPackageOptions } from '@antfu/install-pkg';
+import { AsyncCacheFn as AsyncCacheFn$1 } from 'async-cache-fn';
+import { Options } from 'execa';
+
+interface ImportPackageOption<T = any> {
+    /**
+     * The name of the package to import. This should match the name used in the import statement.
+     */
+    name: string;
+    /**
+     * When enabled, the package will be installed if it is not found
+     * @default true
+     */
+    install?: boolean;
+    /**
+     * The import statement for the package.
+     */
+    import: () => ImportStatement<T>;
+    /**
+     * When enabled, the package will be installed as a dev dependency
+     */
+    isDevDependency?: boolean;
+    /**
+     * Additional installation options
+     */
+    installOptions?: Omit<InstallPackageOptions, "dev">;
+}
+type ImportMap = Record<string, ImportOption>;
+type ImportList = ImportOption[];
+type ImportOption<T = any> = ImportStatement<T> | (() => ImportStatement<T>) | ImportPackageOption<T>;
+type ImportStatement<T = any> = Promise<T>;
+type ResolvedImportOption<T extends ImportOption> = ResolvedPromise<ExtractImportStatement<T>>;
+type ResolvedImportMap<$Imports extends ImportMap> = {
+    [P in keyof $Imports]: ResolvedImportOption<$Imports[P]>;
+};
+type ResolvedImportMapPromise<T extends ImportMap> = Promise<ResolvedImportMap<T>>;
+type ResolvedImportList<$Imports extends ImportList> = {
+    [P in keyof $Imports]: ResolvedImportOption<$Imports[P]>;
+};
+type ResolvedImportListPromise<T extends ImportList> = Promise<ResolvedImportList<T>>;
+type ExtractImportStatement<T extends ImportOption> = ExtractImport<T> extends () => infer I ? I : T;
+type ExtractImport<T extends ImportOption> = T extends {
+    import: infer I;
+} ? I : T;
+
+type __<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type Awaitable<T> = T | Promise<T>;
+type ResolvedPromise<T> = T extends Promise<infer U> ? U : never;
+type KeyOf<T, K> = K extends keyof T ? K : never;
+type KeyOfValue<T, K> = T[KeyOf<T, K>];
+type SelectionMap<T> = __<{
+    [K in keyof T]?: boolean;
+}>;
+type PickByValue<T, V> = {
+    [K in keyof T as T[K] extends V ? K : never]: T[K];
+};
+type Entry<key extends PropertyKey = PropertyKey, value = unknown> = readonly [key: key, value: value];
+type EntryOf<O> = {
+    [k in keyof O]-?: [k, O[k] & ({} | null)];
+}[O extends readonly unknown[] ? keyof O & number : keyof O] & unknown;
+type FromEntries<entries extends readonly Entry[]> = {
+    [entry in entries[number] as entry[0]]: entry[1];
+};
+type UnionizedSelectionMap<T, TSelection extends SelectionMap<T>, V> = __<V & {
+    [K in keyof T as IsExactBoolean<TSelection[K]> extends true ? K : never]?: T[K];
+}>;
+type Select<T, TSelection extends SelectionMap<T>, TMode extends "pick" | "omit"> = __<UnionizedSelectionMap<T, TSelection, TMode extends "pick" ? Pick<T, KeyOf<T, keyof PickByValue<TSelection, true>>> : Omit<T, KeyOf<T, keyof PickByValue<TSelection, true>>>>>;
+type IsExactBoolean<T> = true extends T ? false extends T ? true : false : false;
+type IsUnion<T, U = T> = T extends U ? [U] extends [T] ? false : true : never;
+type MergeObject<T extends object, O extends object | unknown = unknown> = __<T & (O extends object ? O : Record<never, never>)>;
+type AsyncCacheFn<TReturn = unknown, TOption extends object | undefined = undefined, C extends "required" | "optional" = "optional"> = AsyncCacheFn$1<TReturn, C extends "optional" ? [TOption | undefined] | [] : [TOption]>;
+
+interface ImporterOptions {
+    /**
+     * When enabled, the default behavior is to install packages that are not found.
+     * The name of the package is inferred from the key of the import map.
+     * @default true
+     */
+    install?: boolean;
+}
+/**
+ * Dynamically imports modules and returns their exports in a tuple.
+ * This function ensures type safety and maintains the order of imports.
+ *
+ * @param imports An array of dynamic import promises.
+ * @returns A promise that resolves to a tuple containing the default exports of the imported modules.
+ *
+ * @example
+ * ```typescript
+ * // Usage example with dynamic imports
+ * const [package1, package2] = await importer([
+ *   import('@antfu/eslint-config'),
+ *   import('@antfu/install-pkg')
+ * ]);
+ *
+ * // package1 and package2 will be the default exports of the respective modules
+ * ```
+ *
+ * @typeparam Imports An array type representing the dynamic imports.
+ */
+declare function importer<T extends ImportList>(imports: [...T], options?: ImporterOptions): Promise<ResolvedImportList<T>>;
+
+/**
+ * Asynchronously imports modules from a record of dynamic import promises.
+ * Returns a promise that resolves to a record with the same keys, each mapped to the resolved import.
+ * This function maintains the key-value mapping and ensures type safety.
+ *
+ * @param importMap A record where each key is associated with a dynamic import promise.
+ * @returns A promise that resolves to a record containing the default exports of the imported modules,
+ *          maintaining the original key structure.
+ *
+ * @example
+ * ```typescript
+ * // Usage example with a record of dynamic imports
+ *
+ * const { package1, package2 } = await importMap({
+ *   package1: import('package-1'),
+ *   package2: import('package-2')
+ * });
+ *
+ * // importedModules.config and importedModules.pkg will be the default exports of the respective modules
+ * ```
+ *
+ */
+declare function importMap<T extends ImportMap>(importMap: T, options?: ImporterOptions): Promise<ResolvedImportMap<T>>;
+
+declare function ensurePackage(name: string | string[], options?: InstallPackageOptions): Promise<void>;
+
+/**
+ * Asynchronously handles the resolution of a module, extracting its default export if available.
+ * If the module does not have a default export, it returns the module itself.
+ *
+ * @param m A promise representing a module import (either ES Module or CommonJS).
+ * @returns A promise that resolves to either the default export of the module or the module itself.
+ *
+ * @typeparam T The type of the module being imported.
+ *
+ * @example
+ * ```typescript
+ * // Usage example with dynamic import
+ * const module = await interopDefault(import('some-module'));
+ *
+ * // 'module' will be either the default export of 'some-module' or the module itself if no default export exists
+ * ```
+ */
+declare function resolveModule<T>(m: Awaitable<T>): Promise<T extends {
+    default: infer U;
+} ? U : T>;
+
+declare function isPackageDependency(packageName: string | string[]): boolean;
+
+interface PackageManagerConfig<ID extends string = string> {
+    id: ID;
+    command: string;
+    name: string;
+    meta: {
+        lockfile: string | string[];
+    };
+    runner: string;
+    args: {
+        install: {
+            command: string;
+            options: {
+                preferOffline: string;
+                isDevDependency: string;
+            };
+        };
+        uninstall: {
+            command: string;
+        };
+    };
+    options: {
+        version: string;
+    };
+}
+type PackageManagerCommands = PackageManagerConfig["args"];
+type PackageManagerCommandName = keyof PackageManagerCommands;
+type PackageManagerCommandSpec<K> = KeyOfValue<PackageManagerCommands, K> extends {
+    options: infer O;
+} ? SelectionMap<O> : Record<never, never>;
+
+type ScriptOptions<K extends PackageManagerCommandName | undefined = undefined> = __<{
+    cwd?: string;
+    silent?: boolean;
+    shellOptions?: Options;
+} & PackageManagerCommandSpec<K>>;
+interface PackageManager<ID extends string = PackageManagerId> {
+    id: ID;
+    config: PackageManagerConfig;
+    findLockfilePath: AsyncCacheFn<string | undefined, {
+        cwd?: string;
+    }>;
+    hasLockfile: AsyncCacheFn<boolean, {
+        cwd?: string;
+    }>;
+    readLockfile: AsyncCacheFn<string | undefined, {
+        cwd?: string;
+    }>;
+    globalVersion: AsyncCacheFn<string | undefined, ScriptOptions>;
+    uninstallPackage: (packageNames: string | string[], options?: ScriptOptions<"uninstall">) => Promise<void>;
+    installPackage: (packageNames: string | string[], options?: ScriptOptions<"install">) => Promise<void>;
+}
+
+type PackageManagerId = keyof typeof packageManagers;
+declare const packageManagers: {
+    pnpm: PackageManager<"pnpm"> | PackageManager<"yarn"> | PackageManager<"bun"> | PackageManager<"npm">;
+    yarn: PackageManager<"pnpm"> | PackageManager<"yarn"> | PackageManager<"bun"> | PackageManager<"npm">;
+    bun: PackageManager<"pnpm"> | PackageManager<"yarn"> | PackageManager<"bun"> | PackageManager<"npm">;
+    npm: PackageManager<"pnpm"> | PackageManager<"yarn"> | PackageManager<"bun"> | PackageManager<"npm">;
+};
+
+interface DetectPackageManagerOptions {
+    allowed?: SelectionMap<typeof packageManagers>;
+    cwd?: string;
+}
+declare function findPackageManager(options?: DetectPackageManagerOptions): Promise<PackageManager<"pnpm"> | PackageManager<"yarn"> | PackageManager<"bun"> | PackageManager<"npm">>;
+declare function findPackageManagerSafely<TAssert extends boolean = true>(options?: DetectPackageManagerOptions & {
+    assert?: TAssert;
+}): Promise<PackageManager<"pnpm"> | PackageManager<"yarn"> | PackageManager<"bun"> | PackageManager<"npm"> | undefined>;
+declare function detectPackageManagers(options?: DetectPackageManagerOptions): Promise<(PackageManager<"pnpm"> | PackageManager<"yarn"> | PackageManager<"bun"> | PackageManager<"npm">)[]>;
+declare function detectLockfilePackageManagers(options?: DetectPackageManagerOptions): Promise<(PackageManager<"pnpm"> | PackageManager<"yarn"> | PackageManager<"bun"> | PackageManager<"npm">)[]>;
+declare function detectGlobalPackageManagers(options?: DetectPackageManagerOptions): Promise<(PackageManager<"pnpm"> | PackageManager<"yarn"> | PackageManager<"bun"> | PackageManager<"npm">)[]>;
+declare function filterPackageManagers(filterFn: (packageManager: PackageManager) => Promise<unknown>, options?: DetectPackageManagerOptions): Promise<(PackageManager<"pnpm"> | PackageManager<"yarn"> | PackageManager<"bun"> | PackageManager<"npm">)[]>;
+
+export { type AsyncCacheFn, type Awaitable, type Entry, type EntryOf, type FromEntries, type ImportList, type ImportMap, type ImportOption, type ImportPackageOption, type ImportStatement, type ImporterOptions, type IsExactBoolean, type IsUnion, type KeyOf, type KeyOfValue, type MergeObject, type PackageManagerCommandName, type PackageManagerCommandSpec, type PackageManagerCommands, type PackageManagerConfig, type PackageManagerId, type PickByValue, type ResolvedImportList, type ResolvedImportListPromise, type ResolvedImportMap, type ResolvedImportMapPromise, type ResolvedImportOption, type ResolvedPromise, type Select, type SelectionMap, type __, detectGlobalPackageManagers, detectLockfilePackageManagers, detectPackageManagers, ensurePackage, filterPackageManagers, findPackageManager, findPackageManagerSafely, importMap, importer, isPackageDependency, packageManagers, resolveModule };

package/dist/index.d.mts

@@ -0,0 +1,227 @@
+import { InstallPackageOptions } from '@antfu/install-pkg';
+import { AsyncCacheFn as AsyncCacheFn$1 } from 'async-cache-fn';
+import { Options } from 'execa';
+
+interface ImportPackageOption<T = any> {
+    /**
+     * The name of the package to import. This should match the name used in the import statement.
+     */
+    name: string;
+    /**
+     * When enabled, the package will be installed if it is not found
+     * @default true
+     */
+    install?: boolean;
+    /**
+     * The import statement for the package.
+     */
+    import: () => ImportStatement<T>;
+    /**
+     * When enabled, the package will be installed as a dev dependency
+     */
+    isDevDependency?: boolean;
+    /**
+     * Additional installation options
+     */
+    installOptions?: Omit<InstallPackageOptions, "dev">;
+}
+type ImportMap = Record<string, ImportOption>;
+type ImportList = ImportOption[];
+type ImportOption<T = any> = ImportStatement<T> | (() => ImportStatement<T>) | ImportPackageOption<T>;
+type ImportStatement<T = any> = Promise<T>;
+type ResolvedImportOption<T extends ImportOption> = ResolvedPromise<ExtractImportStatement<T>>;
+type ResolvedImportMap<$Imports extends ImportMap> = {
+    [P in keyof $Imports]: ResolvedImportOption<$Imports[P]>;
+};
+type ResolvedImportMapPromise<T extends ImportMap> = Promise<ResolvedImportMap<T>>;
+type ResolvedImportList<$Imports extends ImportList> = {
+    [P in keyof $Imports]: ResolvedImportOption<$Imports[P]>;
+};
+type ResolvedImportListPromise<T extends ImportList> = Promise<ResolvedImportList<T>>;
+type ExtractImportStatement<T extends ImportOption> = ExtractImport<T> extends () => infer I ? I : T;
+type ExtractImport<T extends ImportOption> = T extends {
+    import: infer I;
+} ? I : T;
+
+type __<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type Awaitable<T> = T | Promise<T>;
+type ResolvedPromise<T> = T extends Promise<infer U> ? U : never;
+type KeyOf<T, K> = K extends keyof T ? K : never;
+type KeyOfValue<T, K> = T[KeyOf<T, K>];
+type SelectionMap<T> = __<{
+    [K in keyof T]?: boolean;
+}>;
+type PickByValue<T, V> = {
+    [K in keyof T as T[K] extends V ? K : never]: T[K];
+};
+type Entry<key extends PropertyKey = PropertyKey, value = unknown> = readonly [key: key, value: value];
+type EntryOf<O> = {
+    [k in keyof O]-?: [k, O[k] & ({} | null)];
+}[O extends readonly unknown[] ? keyof O & number : keyof O] & unknown;
+type FromEntries<entries extends readonly Entry[]> = {
+    [entry in entries[number] as entry[0]]: entry[1];
+};
+type UnionizedSelectionMap<T, TSelection extends SelectionMap<T>, V> = __<V & {
+    [K in keyof T as IsExactBoolean<TSelection[K]> extends true ? K : never]?: T[K];
+}>;
+type Select<T, TSelection extends SelectionMap<T>, TMode extends "pick" | "omit"> = __<UnionizedSelectionMap<T, TSelection, TMode extends "pick" ? Pick<T, KeyOf<T, keyof PickByValue<TSelection, true>>> : Omit<T, KeyOf<T, keyof PickByValue<TSelection, true>>>>>;
+type IsExactBoolean<T> = true extends T ? false extends T ? true : false : false;
+type IsUnion<T, U = T> = T extends U ? [U] extends [T] ? false : true : never;
+type MergeObject<T extends object, O extends object | unknown = unknown> = __<T & (O extends object ? O : Record<never, never>)>;
+type AsyncCacheFn<TReturn = unknown, TOption extends object | undefined = undefined, C extends "required" | "optional" = "optional"> = AsyncCacheFn$1<TReturn, C extends "optional" ? [TOption | undefined] | [] : [TOption]>;
+
+interface ImporterOptions {
+    /**
+     * When enabled, the default behavior is to install packages that are not found.
+     * The name of the package is inferred from the key of the import map.
+     * @default true
+     */
+    install?: boolean;
+}
+/**
+ * Dynamically imports modules and returns their exports in a tuple.
+ * This function ensures type safety and maintains the order of imports.
+ *
+ * @param imports An array of dynamic import promises.
+ * @returns A promise that resolves to a tuple containing the default exports of the imported modules.
+ *
+ * @example
+ * ```typescript
+ * // Usage example with dynamic imports
+ * const [package1, package2] = await importer([
+ *   import('@antfu/eslint-config'),
+ *   import('@antfu/install-pkg')
+ * ]);
+ *
+ * // package1 and package2 will be the default exports of the respective modules
+ * ```
+ *
+ * @typeparam Imports An array type representing the dynamic imports.
+ */
+declare function importer<T extends ImportList>(imports: [...T], options?: ImporterOptions): Promise<ResolvedImportList<T>>;
+
+/**
+ * Asynchronously imports modules from a record of dynamic import promises.
+ * Returns a promise that resolves to a record with the same keys, each mapped to the resolved import.
+ * This function maintains the key-value mapping and ensures type safety.
+ *
+ * @param importMap A record where each key is associated with a dynamic import promise.
+ * @returns A promise that resolves to a record containing the default exports of the imported modules,
+ *          maintaining the original key structure.
+ *
+ * @example
+ * ```typescript
+ * // Usage example with a record of dynamic imports
+ *
+ * const { package1, package2 } = await importMap({
+ *   package1: import('package-1'),
+ *   package2: import('package-2')
+ * });
+ *
+ * // importedModules.config and importedModules.pkg will be the default exports of the respective modules
+ * ```
+ *
+ */
+declare function importMap<T extends ImportMap>(importMap: T, options?: ImporterOptions): Promise<ResolvedImportMap<T>>;
+
+declare function ensurePackage(name: string | string[], options?: InstallPackageOptions): Promise<void>;
+
+/**
+ * Asynchronously handles the resolution of a module, extracting its default export if available.
+ * If the module does not have a default export, it returns the module itself.
+ *
+ * @param m A promise representing a module import (either ES Module or CommonJS).
+ * @returns A promise that resolves to either the default export of the module or the module itself.
+ *
+ * @typeparam T The type of the module being imported.
+ *
+ * @example
+ * ```typescript
+ * // Usage example with dynamic import
+ * const module = await interopDefault(import('some-module'));
+ *
+ * // 'module' will be either the default export of 'some-module' or the module itself if no default export exists
+ * ```
+ */
+declare function resolveModule<T>(m: Awaitable<T>): Promise<T extends {
+    default: infer U;
+} ? U : T>;
+
+declare function isPackageDependency(packageName: string | string[]): boolean;
+
+interface PackageManagerConfig<ID extends string = string> {
+    id: ID;
+    command: string;
+    name: string;
+    meta: {
+        lockfile: string | string[];
+    };
+    runner: string;
+    args: {
+        install: {
+            command: string;
+            options: {
+                preferOffline: string;
+                isDevDependency: string;
+            };
+        };
+        uninstall: {
+            command: string;
+        };
+    };
+    options: {
+        version: string;
+    };
+}
+type PackageManagerCommands = PackageManagerConfig["args"];
+type PackageManagerCommandName = keyof PackageManagerCommands;
+type PackageManagerCommandSpec<K> = KeyOfValue<PackageManagerCommands, K> extends {
+    options: infer O;
+} ? SelectionMap<O> : Record<never, never>;
+
+type ScriptOptions<K extends PackageManagerCommandName | undefined = undefined> = __<{
+    cwd?: string;
+    silent?: boolean;
+    shellOptions?: Options;
+} & PackageManagerCommandSpec<K>>;
+interface PackageManager<ID extends string = PackageManagerId> {
+    id: ID;
+    config: PackageManagerConfig;
+    findLockfilePath: AsyncCacheFn<string | undefined, {
+        cwd?: string;
+    }>;
+    hasLockfile: AsyncCacheFn<boolean, {
+        cwd?: string;
+    }>;
+    readLockfile: AsyncCacheFn<string | undefined, {
+        cwd?: string;
+    }>;
+    globalVersion: AsyncCacheFn<string | undefined, ScriptOptions>;
+    uninstallPackage: (packageNames: string | string[], options?: ScriptOptions<"uninstall">) => Promise<void>;
+    installPackage: (packageNames: string | string[], options?: ScriptOptions<"install">) => Promise<void>;
+}
+
+type PackageManagerId = keyof typeof packageManagers;
+declare const packageManagers: {
+    pnpm: PackageManager<"pnpm"> | PackageManager<"yarn"> | PackageManager<"bun"> | PackageManager<"npm">;
+    yarn: PackageManager<"pnpm"> | PackageManager<"yarn"> | PackageManager<"bun"> | PackageManager<"npm">;
+    bun: PackageManager<"pnpm"> | PackageManager<"yarn"> | PackageManager<"bun"> | PackageManager<"npm">;
+    npm: PackageManager<"pnpm"> | PackageManager<"yarn"> | PackageManager<"bun"> | PackageManager<"npm">;
+};
+
+interface DetectPackageManagerOptions {
+    allowed?: SelectionMap<typeof packageManagers>;
+    cwd?: string;
+}
+declare function findPackageManager(options?: DetectPackageManagerOptions): Promise<PackageManager<"pnpm"> | PackageManager<"yarn"> | PackageManager<"bun"> | PackageManager<"npm">>;
+declare function findPackageManagerSafely<TAssert extends boolean = true>(options?: DetectPackageManagerOptions & {
+    assert?: TAssert;
+}): Promise<PackageManager<"pnpm"> | PackageManager<"yarn"> | PackageManager<"bun"> | PackageManager<"npm"> | undefined>;
+declare function detectPackageManagers(options?: DetectPackageManagerOptions): Promise<(PackageManager<"pnpm"> | PackageManager<"yarn"> | PackageManager<"bun"> | PackageManager<"npm">)[]>;
+declare function detectLockfilePackageManagers(options?: DetectPackageManagerOptions): Promise<(PackageManager<"pnpm"> | PackageManager<"yarn"> | PackageManager<"bun"> | PackageManager<"npm">)[]>;
+declare function detectGlobalPackageManagers(options?: DetectPackageManagerOptions): Promise<(PackageManager<"pnpm"> | PackageManager<"yarn"> | PackageManager<"bun"> | PackageManager<"npm">)[]>;
+declare function filterPackageManagers(filterFn: (packageManager: PackageManager) => Promise<unknown>, options?: DetectPackageManagerOptions): Promise<(PackageManager<"pnpm"> | PackageManager<"yarn"> | PackageManager<"bun"> | PackageManager<"npm">)[]>;
+
+export { type AsyncCacheFn, type Awaitable, type Entry, type EntryOf, type FromEntries, type ImportList, type ImportMap, type ImportOption, type ImportPackageOption, type ImportStatement, type ImporterOptions, type IsExactBoolean, type IsUnion, type KeyOf, type KeyOfValue, type MergeObject, type PackageManagerCommandName, type PackageManagerCommandSpec, type PackageManagerCommands, type PackageManagerConfig, type PackageManagerId, type PickByValue, type ResolvedImportList, type ResolvedImportListPromise, type ResolvedImportMap, type ResolvedImportMapPromise, type ResolvedImportOption, type ResolvedPromise, type Select, type SelectionMap, type __, detectGlobalPackageManagers, detectLockfilePackageManagers, detectPackageManagers, ensurePackage, filterPackageManagers, findPackageManager, findPackageManagerSafely, importMap, importer, isPackageDependency, packageManagers, resolveModule };

package/dist/index.d.ts

@@ -0,0 +1,227 @@
+import { InstallPackageOptions } from '@antfu/install-pkg';
+import { AsyncCacheFn as AsyncCacheFn$1 } from 'async-cache-fn';
+import { Options } from 'execa';
+
+interface ImportPackageOption<T = any> {
+    /**
+     * The name of the package to import. This should match the name used in the import statement.
+     */
+    name: string;
+    /**
+     * When enabled, the package will be installed if it is not found
+     * @default true
+     */
+    install?: boolean;
+    /**
+     * The import statement for the package.
+     */
+    import: () => ImportStatement<T>;
+    /**
+     * When enabled, the package will be installed as a dev dependency
+     */
+    isDevDependency?: boolean;
+    /**
+     * Additional installation options
+     */
+    installOptions?: Omit<InstallPackageOptions, "dev">;
+}
+type ImportMap = Record<string, ImportOption>;
+type ImportList = ImportOption[];
+type ImportOption<T = any> = ImportStatement<T> | (() => ImportStatement<T>) | ImportPackageOption<T>;
+type ImportStatement<T = any> = Promise<T>;
+type ResolvedImportOption<T extends ImportOption> = ResolvedPromise<ExtractImportStatement<T>>;
+type ResolvedImportMap<$Imports extends ImportMap> = {
+    [P in keyof $Imports]: ResolvedImportOption<$Imports[P]>;
+};
+type ResolvedImportMapPromise<T extends ImportMap> = Promise<ResolvedImportMap<T>>;
+type ResolvedImportList<$Imports extends ImportList> = {
+    [P in keyof $Imports]: ResolvedImportOption<$Imports[P]>;
+};
+type ResolvedImportListPromise<T extends ImportList> = Promise<ResolvedImportList<T>>;
+type ExtractImportStatement<T extends ImportOption> = ExtractImport<T> extends () => infer I ? I : T;
+type ExtractImport<T extends ImportOption> = T extends {
+    import: infer I;
+} ? I : T;
+
+type __<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type Awaitable<T> = T | Promise<T>;
+type ResolvedPromise<T> = T extends Promise<infer U> ? U : never;
+type KeyOf<T, K> = K extends keyof T ? K : never;
+type KeyOfValue<T, K> = T[KeyOf<T, K>];
+type SelectionMap<T> = __<{
+    [K in keyof T]?: boolean;
+}>;
+type PickByValue<T, V> = {
+    [K in keyof T as T[K] extends V ? K : never]: T[K];
+};
+type Entry<key extends PropertyKey = PropertyKey, value = unknown> = readonly [key: key, value: value];
+type EntryOf<O> = {
+    [k in keyof O]-?: [k, O[k] & ({} | null)];
+}[O extends readonly unknown[] ? keyof O & number : keyof O] & unknown;
+type FromEntries<entries extends readonly Entry[]> = {
+    [entry in entries[number] as entry[0]]: entry[1];
+};
+type UnionizedSelectionMap<T, TSelection extends SelectionMap<T>, V> = __<V & {
+    [K in keyof T as IsExactBoolean<TSelection[K]> extends true ? K : never]?: T[K];
+}>;
+type Select<T, TSelection extends SelectionMap<T>, TMode extends "pick" | "omit"> = __<UnionizedSelectionMap<T, TSelection, TMode extends "pick" ? Pick<T, KeyOf<T, keyof PickByValue<TSelection, true>>> : Omit<T, KeyOf<T, keyof PickByValue<TSelection, true>>>>>;
+type IsExactBoolean<T> = true extends T ? false extends T ? true : false : false;
+type IsUnion<T, U = T> = T extends U ? [U] extends [T] ? false : true : never;
+type MergeObject<T extends object, O extends object | unknown = unknown> = __<T & (O extends object ? O : Record<never, never>)>;
+type AsyncCacheFn<TReturn = unknown, TOption extends object | undefined = undefined, C extends "required" | "optional" = "optional"> = AsyncCacheFn$1<TReturn, C extends "optional" ? [TOption | undefined] | [] : [TOption]>;
+
+interface ImporterOptions {
+    /**
+     * When enabled, the default behavior is to install packages that are not found.
+     * The name of the package is inferred from the key of the import map.
+     * @default true
+     */
+    install?: boolean;
+}
+/**
+ * Dynamically imports modules and returns their exports in a tuple.
+ * This function ensures type safety and maintains the order of imports.
+ *
+ * @param imports An array of dynamic import promises.
+ * @returns A promise that resolves to a tuple containing the default exports of the imported modules.
+ *
+ * @example
+ * ```typescript
+ * // Usage example with dynamic imports
+ * const [package1, package2] = await importer([
+ *   import('@antfu/eslint-config'),
+ *   import('@antfu/install-pkg')
+ * ]);
+ *
+ * // package1 and package2 will be the default exports of the respective modules
+ * ```
+ *
+ * @typeparam Imports An array type representing the dynamic imports.
+ */
+declare function importer<T extends ImportList>(imports: [...T], options?: ImporterOptions): Promise<ResolvedImportList<T>>;
+
+/**
+ * Asynchronously imports modules from a record of dynamic import promises.
+ * Returns a promise that resolves to a record with the same keys, each mapped to the resolved import.
+ * This function maintains the key-value mapping and ensures type safety.
+ *
+ * @param importMap A record where each key is associated with a dynamic import promise.
+ * @returns A promise that resolves to a record containing the default exports of the imported modules,
+ *          maintaining the original key structure.
+ *
+ * @example
+ * ```typescript
+ * // Usage example with a record of dynamic imports
+ *
+ * const { package1, package2 } = await importMap({
+ *   package1: import('package-1'),
+ *   package2: import('package-2')
+ * });
+ *
+ * // importedModules.config and importedModules.pkg will be the default exports of the respective modules
+ * ```
+ *
+ */
+declare function importMap<T extends ImportMap>(importMap: T, options?: ImporterOptions): Promise<ResolvedImportMap<T>>;
+
+declare function ensurePackage(name: string | string[], options?: InstallPackageOptions): Promise<void>;
+
+/**
+ * Asynchronously handles the resolution of a module, extracting its default export if available.
+ * If the module does not have a default export, it returns the module itself.
+ *
+ * @param m A promise representing a module import (either ES Module or CommonJS).
+ * @returns A promise that resolves to either the default export of the module or the module itself.
+ *
+ * @typeparam T The type of the module being imported.
+ *
+ * @example
+ * ```typescript
+ * // Usage example with dynamic import
+ * const module = await interopDefault(import('some-module'));
+ *
+ * // 'module' will be either the default export of 'some-module' or the module itself if no default export exists
+ * ```
+ */
+declare function resolveModule<T>(m: Awaitable<T>): Promise<T extends {
+    default: infer U;
+} ? U : T>;
+
+declare function isPackageDependency(packageName: string | string[]): boolean;
+
+interface PackageManagerConfig<ID extends string = string> {
+    id: ID;
+    command: string;
+    name: string;
+    meta: {
+        lockfile: string | string[];
+    };
+    runner: string;
+    args: {
+        install: {
+            command: string;
+            options: {
+                preferOffline: string;
+                isDevDependency: string;
+            };
+        };
+        uninstall: {
+            command: string;
+        };
+    };
+    options: {
+        version: string;
+    };
+}
+type PackageManagerCommands = PackageManagerConfig["args"];
+type PackageManagerCommandName = keyof PackageManagerCommands;
+type PackageManagerCommandSpec<K> = KeyOfValue<PackageManagerCommands, K> extends {
+    options: infer O;
+} ? SelectionMap<O> : Record<never, never>;
+
+type ScriptOptions<K extends PackageManagerCommandName | undefined = undefined> = __<{
+    cwd?: string;
+    silent?: boolean;
+    shellOptions?: Options;
+} & PackageManagerCommandSpec<K>>;
+interface PackageManager<ID extends string = PackageManagerId> {
+    id: ID;
+    config: PackageManagerConfig;
+    findLockfilePath: AsyncCacheFn<string | undefined, {
+        cwd?: string;
+    }>;
+    hasLockfile: AsyncCacheFn<boolean, {
+        cwd?: string;
+    }>;
+    readLockfile: AsyncCacheFn<string | undefined, {
+        cwd?: string;
+    }>;
+    globalVersion: AsyncCacheFn<string | undefined, ScriptOptions>;
+    uninstallPackage: (packageNames: string | string[], options?: ScriptOptions<"uninstall">) => Promise<void>;
+    installPackage: (packageNames: string | string[], options?: ScriptOptions<"install">) => Promise<void>;
+}
+
+type PackageManagerId = keyof typeof packageManagers;
+declare const packageManagers: {
+    pnpm: PackageManager<"pnpm"> | PackageManager<"yarn"> | PackageManager<"bun"> | PackageManager<"npm">;
+    yarn: PackageManager<"pnpm"> | PackageManager<"yarn"> | PackageManager<"bun"> | PackageManager<"npm">;
+    bun: PackageManager<"pnpm"> | PackageManager<"yarn"> | PackageManager<"bun"> | PackageManager<"npm">;
+    npm: PackageManager<"pnpm"> | PackageManager<"yarn"> | PackageManager<"bun"> | PackageManager<"npm">;
+};
+
+interface DetectPackageManagerOptions {
+    allowed?: SelectionMap<typeof packageManagers>;
+    cwd?: string;
+}
+declare function findPackageManager(options?: DetectPackageManagerOptions): Promise<PackageManager<"pnpm"> | PackageManager<"yarn"> | PackageManager<"bun"> | PackageManager<"npm">>;
+declare function findPackageManagerSafely<TAssert extends boolean = true>(options?: DetectPackageManagerOptions & {
+    assert?: TAssert;
+}): Promise<PackageManager<"pnpm"> | PackageManager<"yarn"> | PackageManager<"bun"> | PackageManager<"npm"> | undefined>;
+declare function detectPackageManagers(options?: DetectPackageManagerOptions): Promise<(PackageManager<"pnpm"> | PackageManager<"yarn"> | PackageManager<"bun"> | PackageManager<"npm">)[]>;
+declare function detectLockfilePackageManagers(options?: DetectPackageManagerOptions): Promise<(PackageManager<"pnpm"> | PackageManager<"yarn"> | PackageManager<"bun"> | PackageManager<"npm">)[]>;
+declare function detectGlobalPackageManagers(options?: DetectPackageManagerOptions): Promise<(PackageManager<"pnpm"> | PackageManager<"yarn"> | PackageManager<"bun"> | PackageManager<"npm">)[]>;
+declare function filterPackageManagers(filterFn: (packageManager: PackageManager) => Promise<unknown>, options?: DetectPackageManagerOptions): Promise<(PackageManager<"pnpm"> | PackageManager<"yarn"> | PackageManager<"bun"> | PackageManager<"npm">)[]>;
+
+export { type AsyncCacheFn, type Awaitable, type Entry, type EntryOf, type FromEntries, type ImportList, type ImportMap, type ImportOption, type ImportPackageOption, type ImportStatement, type ImporterOptions, type IsExactBoolean, type IsUnion, type KeyOf, type KeyOfValue, type MergeObject, type PackageManagerCommandName, type PackageManagerCommandSpec, type PackageManagerCommands, type PackageManagerConfig, type PackageManagerId, type PickByValue, type ResolvedImportList, type ResolvedImportListPromise, type ResolvedImportMap, type ResolvedImportMapPromise, type ResolvedImportOption, type ResolvedPromise, type Select, type SelectionMap, type __, detectGlobalPackageManagers, detectLockfilePackageManagers, detectPackageManagers, ensurePackage, filterPackageManagers, findPackageManager, findPackageManagerSafely, importMap, importer, isPackageDependency, packageManagers, resolveModule };

package/dist/index.mjs

@@ -0,0 +1,301 @@
+import { installPackage } from '@antfu/install-pkg';
+import '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';
+
+async function resolveModule(m) {
+  const resolved = await m;
+  return resolved.default || resolved;
+}
+
+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();
+  }
+  return option;
+}
+
+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 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) {
+  const { command, args: agentArgs, options: agentOptions } = config;
+  const findLockfilePath = asyncCacheFn(async (options) => {
+    const { cwd } = options ?? {};
+    const lockfiles = toArray(config.meta.lockfile);
+    return await findUp(lockfiles, { cwd });
+  });
+  return {
+    id: config.id,
+    config,
+    findLockfilePath,
+    hasLockfile: asyncCacheFn(async (...args) => {
+      const lockfilePath = await findLockfilePath.noCache(...args);
+      return Boolean(lockfilePath);
+    }),
+    readLockfile: asyncCacheFn(async (...args) => {
+      const lockfilePath = await findLockfilePath.noCache(...args);
+      if (!lockfilePath)
+        return void 0;
+      return readFile(lockfilePath, "utf8");
+    }),
+    globalVersion: asyncCacheFn(async (...args) => {
+      const [options] = args;
+      try {
+        const { stdout } = await $$({
+          command,
+          args: [agentOptions.version],
+          ...options
+        });
+        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) => {
+      });
+    }
+  };
+}
+async function $$(options) {
+  const { command, args = [], silent = true, cwd, shellOptions } = options;
+  return execa(command, args.filter(notFalsy), {
+    cwd,
+    ...shellOptions,
+    stdio: silent ? "ignore" : "inherit"
+  });
+}
+
+const bun = definePackageManager({
+  id: "bun",
+  name: "Bun",
+  command: "bun",
+  runner: "bunx",
+  meta: {
+    lockfile: "bun.lockb"
+  },
+  args: {
+    install: {
+      command: "install",
+      options: {
+        isDevDependency: "-D",
+        preferOffline: "--prefer-offline"
+      }
+    },
+    uninstall: {
+      command: "uninstall"
+    }
+  },
+  options: {
+    version: "--version"
+  }
+});
+
+const npm = definePackageManager({
+  id: "npm",
+  name: "NPM",
+  command: "npm",
+  runner: "npx",
+  meta: {
+    lockfile: ["package-lock.json", "npm-shrinkwrap.json"]
+  },
+  args: {
+    install: {
+      command: "install",
+      options: {
+        isDevDependency: "-D",
+        preferOffline: "--prefer-offline"
+      }
+    },
+    uninstall: {
+      command: "uninstall"
+    }
+  },
+  options: {
+    version: "--version"
+  }
+});
+
+const pnpm = definePackageManager({
+  id: "pnpm",
+  name: "PNPM",
+  command: "pnpm",
+  runner: "pnpx",
+  meta: {
+    lockfile: "pnpm-lock.yaml"
+  },
+  args: {
+    install: {
+      command: "install",
+      options: {
+        isDevDependency: "-D",
+        preferOffline: "--prefer-offline"
+      }
+    },
+    uninstall: {
+      command: "uninstall"
+    }
+  },
+  options: {
+    version: "--version"
+  }
+});
+
+const yarn = definePackageManager({
+  id: "yarn",
+  name: "Yarn",
+  command: "yarn",
+  runner: "yarn dlx",
+  meta: {
+    lockfile: "yarn.lock"
+  },
+  args: {
+    install: {
+      command: "add",
+      options: {
+        isDevDependency: "-D",
+        preferOffline: "--prefer-offline"
+      }
+    },
+    uninstall: {
+      command: "remove"
+    }
+  },
+  options: {
+    version: "--version"
+  }
+});
+
+const packageManagers = fromEntries(
+  [pnpm, yarn, bun, npm].map((e) => [e.id, e])
+);
+
+async function findPackageManager(options) {
+  const { ...rest } = options ?? {};
+  const packageManager = await findPackageManagerSafely(rest);
+  invariant(packageManager, "No package manager found");
+  return packageManager;
+}
+async function findPackageManagerSafely(options) {
+  const lockfilePm = (await detectLockfilePackageManagers(options))[0];
+  if (lockfilePm) {
+    return lockfilePm;
+  }
+  const globalPm = (await detectGlobalPackageManagers(options))[0];
+  return globalPm;
+}
+async function detectPackageManagers(options) {
+  return [
+    ...await detectLockfilePackageManagers(options),
+    ...await detectGlobalPackageManagers(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 filterPackageManagers(filterFn, options) {
+  const allowedPackageManagers = Object.entries(packageManagers).filter(
+    ([key]) => {
+      if (!options?.allowed)
+        return true;
+      return key in options.allowed;
+    }
+  );
+  return (await Promise.all(
+    allowedPackageManagers.map(async ([key, 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 };

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "package-management",
+  "description": "Simple type-safe utilities for programatically installing and importing packages",
+  "version": "0.0.1",
+  "private": false,
+  "files": [
+    "dist/**"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "scripts": {
+    "build": "unbuild",
+    "build:watch": "tsc --watch --preserveWatchOutput",
+    "dev": "unbuild --stub",
+    "lint": "eslint",
+    "test": "vitest",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf .tsbuildinfo .turbo coverage dist node_modules",
+    "npm-publish": "pnpm run build && npm publish  --access public --no-git-checks"
+  },
+  "devDependencies": {
+    "@types/node": "20.5.9",
+    "typescript": "^5.3.2",
+    "unbuild": "^2.0.0",
+    "vite-tsconfig-paths": "^4.3.1",
+    "vitest": "^0.34.6"
+  },
+  "dependencies": {
+    "@antfu/install-pkg": "^0.3.1",
+    "async-cache-fn": "^0.0.3",
+    "execa": "^8.0.1",
+    "find-up": "^7.0.0",
+    "local-pkg": "^0.5.0"
+  }
+}