feat(auto-install)!: ESM only. Update Node and Rollup minimum versions

.config/vitest.config.mts

@@ -8,7 +8,13 @@ export default defineConfig({
       path.join(path.dirname(testPath), '.snapshots', path.basename(testPath) + snapExt)
   },
   resolve: {
-    // Allow importing the current package under test via `~package`
-    alias: [{ find: /^~package$/, replacement: path.resolve(process.cwd()) }]
+    // Allow importing the current package under test via `~package`.
+    // Point directly at the built entry so dynamic imports in tests work consistently.
+    alias: [
+      {
+        find: /^~package$/,
+        replacement: path.resolve(process.cwd(), 'dist/index.js')
+      }
+    ]
   }
 });

packages/auto-install/package.json

@@ -13,34 +13,33 @@
   "author": "Rich Harris",
   "homepage": "https://github.com/rollup/plugins/tree/master/packages/auto-install/#readme",
   "bugs": "https://github.com/rollup/plugins/issues",
-  "main": "./dist/cjs/index.js",
-  "module": "./dist/es/index.js",
+  "type": "module",
   "exports": {
-    "types": "./types/index.d.ts",
-    "import": "./dist/es/index.js",
-    "default": "./dist/cjs/index.js"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
   },
   "engines": {
-    "node": ">=14.0.0"
+    "node": ">=20.19.0"
   },
   "scripts": {
-    "build": "rollup -c",
+    "build": "tsc --project tsconfig.json",
     "ci:coverage": "nyc pnpm test && nyc report --reporter=text-lcov > coverage.lcov",
     "ci:lint": "pnpm build && pnpm lint",
     "ci:lint:commits": "commitlint --from=${CIRCLE_BRANCH} --to=${CIRCLE_SHA1}",
-    "ci:test": "pnpm test -- --verbose",
+    "ci:test": "pnpm test -- --reporter=verbose",
     "prebuild": "del-cli dist",
     "prepare": "if [ ! -d 'dist' ]; then pnpm build; fi",
     "prerelease": "pnpm build",
     "pretest": "pnpm build",
     "release": "pnpm --workspace-root package:release $(pwd)",
-    "test": "ava",
+    "test": "vitest --config ../../.config/vitest.config.mts run",
     "test:ts": "tsc --noEmit"
   },
   "files": [
     "dist",
-    "!dist/**/*.map",
-    "types",
     "README.md",
     "LICENSE"
   ],
@@ -53,7 +52,7 @@
     "modules"
   ],
   "peerDependencies": {
-    "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0"
+    "rollup": "^4"
   },
   "peerDependenciesMeta": {
     "rollup": {
@@ -62,13 +61,13 @@
   },
   "devDependencies": {
     "@rollup/plugin-node-resolve": "^15.0.0",
-    "@rollup/plugin-typescript": "^9.0.1",
     "del": "^6.1.1",
+    "del-cli": "^5.0.0",
     "node-noop": "^1.0.0",
-    "rollup": "^4.0.0-24",
-    "typescript": "^4.8.3"
+    "rollup": "^4.0.0",
+    "typescript": "catalog:"
   },
-  "types": "./types/index.d.ts",
+  "types": "./dist/index.d.ts",
   "ava": {
     "workerThreads": false,
     "files": [

packages/auto-install/src/index.ts

@@ -1,30 +1,63 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import mod from 'module';
-import { exec } from 'child_process';
-import { promisify } from 'util';
+import fs from 'node:fs';
+import path from 'node:path';
+import { builtinModules } from 'node:module';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
 
 import type { Plugin } from 'rollup';
 
-import type { RollupAutoInstallOptions } from '../types';
+type PackageManager = 'npm' | 'yarn' | 'pnpm';
+
+export interface RollupAutoInstallOptions {
+  /**
+   * Specifies the location on disk of the target `package.json` file.
+   * If the file doesn't exist, it will be created by the plugin,
+   * as package managers need to populate the `dependencies` property.
+   * @default '{cwd}/package.json'
+   */
+  pkgFile?: string;
+
+  /**
+   * Specifies the package manager to use.
+   * If not specified, the plugin will default to `yarn` if `yarn.lock` exists,
+   * to `pnpm` if `pnpm-lock.yaml` exists, or `npm` otherwise.
+   */
+  manager?: PackageManager;
+
+  /**
+   * Test-only override of package manager commands.
+   * @internal
+   */
+  commands?: Partial<Record<PackageManager, string>>;
+}
 
 const execAsync = promisify(exec);
 
 export default function autoInstall(opts: RollupAutoInstallOptions = {}): Plugin {
+  // Restore the historic `defaults` object (including `commands`) so tests can
+  // optionally override command strings via options.
   const defaults = {
     // intentionally undocumented options. used for tests
     commands: {
       npm: 'npm install',
-      pnpm: 'pnpm install',
+      pnpm: 'pnpm add',
       yarn: 'yarn add'
-    },
+    } as Record<PackageManager, string>,
     manager: fs.existsSync('yarn.lock') ? 'yarn' : fs.existsSync('pnpm-lock.yaml') ? 'pnpm' : 'npm',
-    pkgFile: path.resolve(opts.pkgFile || 'package.json')
+    pkgFile: 'package.json'
+  } as const;
+
+  // Shallow-merge, with a one-level deep merge for `commands` to allow partial overrides in tests
+  const options = {
+    ...defaults,
+    ...opts,
+    commands: { ...defaults.commands, ...(opts.commands || {}) }
   };
 
-  const options = Object.assign({}, defaults, opts);
-  const { manager, pkgFile } = options;
-  const validManagers = ['npm', 'yarn', 'pnpm'];
+  const { manager } = options;
+  const pkgFile = path.resolve(options.pkgFile);
+
+  const validManagers = Object.keys(options.commands) as PackageManager[];
 
   if (!validManagers.includes(manager)) {
     throw new RangeError(
@@ -41,7 +74,15 @@ export default function autoInstall(opts: RollupAutoInstallOptions = {}): Plugin
     pkg = {};
   }
 
-  const installed = new Set(Object.keys(pkg.dependencies || {}).concat(mod.builtinModules));
+  // Normalize core module names to include both `fs` and `node:fs` forms so we never try to
+  // install built-ins regardless of how Rollup reports them or how they are imported.
+  const coreModules = new Set<string>([
+    ...builtinModules,
+    ...builtinModules.filter((m) => m.startsWith('node:')).map((m) => m.slice(5)),
+    ...builtinModules.filter((m) => !m.startsWith('node:')).map((m) => `node:${m}`)
+  ]);
+
+  const installed = new Set([...Object.keys(pkg.dependencies || {}), ...coreModules]);
   const cmd = options.commands[manager];
 
   return {

packages/auto-install/test/fixtures/yarn/.gitkeep

@@ -0,0 +1 @@
+

packages/auto-install/test/npm-bare.test.ts

@@ -0,0 +1,86 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import del from 'del';
+import { it, afterAll } from 'vitest';
+import { rollup } from 'rollup';
+import nodeResolve from '@rollup/plugin-node-resolve';
+
+// Dynamically import the plugin within gated tests to avoid Node <20 execution
+
+const DIR = fileURLToPath(new URL('.', import.meta.url));
+const cwd = path.join(DIR, 'fixtures/npm-bare');
+const file = path.join(cwd, 'output/bundle.js');
+// Use a local input inside the cwd so Node resolution finds packages installed
+// by the test (e.g., on Windows where upward-only resolution won't see
+// `npm-bare/node_modules` from `fixtures/input.js`).
+const input = path.join(cwd, 'input.local.js');
+const pkgFile = path.join(cwd, 'package.json');
+
+// Helper to temporarily disable slow npm features during the test
+function stubNpmQuietEnv() {
+  const keys = [
+    'npm_config_audit',
+    'npm_config_fund',
+    'npm_config_progress',
+    'npm_config_update_notifier',
+    'npm_config_loglevel'
+  ] as const;
+  const prev: Record<string, string | undefined> = {};
+  for (const k of keys) prev[k] = process.env[k];
+  process.env.npm_config_audit = 'false';
+  process.env.npm_config_fund = 'false';
+  process.env.npm_config_progress = 'false';
+  process.env.npm_config_update_notifier = 'false';
+  process.env.npm_config_loglevel = 'error';
+  return () => {
+    for (const k of keys) {
+      const v = prev[k];
+      if (v == null) delete (process.env as any)[k];
+      else (process.env as any)[k] = v;
+    }
+  };
+}
+const [NODE_MAJOR, NODE_MINOR] = process.versions.node.split('.').map(Number);
+const RUN_ON_THIS_NODE = NODE_MAJOR > 20 || (NODE_MAJOR === 20 && NODE_MINOR >= 19);
+
+// npm installs can be slower than pnpm/yarn on CI; allow extra time.
+it.runIf(RUN_ON_THIS_NODE)(
+  'npm, bare',
+  async () => {
+    const restoreEnv = stubNpmQuietEnv();
+    const prevCwd = process.cwd();
+    // Create a local copy of the shared input so resolution starts from `cwd`.
+    fs.copyFileSync(path.join(cwd, '../input.js'), input);
+    process.chdir(cwd);
+    try {
+      const { default: autoInstall } = await import('~package');
+      const bundle = await rollup({
+        input,
+        // @ts-expect-error - rollup() ignores output here but tests kept it historically
+        output: { file, format: 'es' },
+        plugins: [autoInstall({ pkgFile, manager: 'npm' }), nodeResolve()]
+      });
+      await bundle.close();
+
+      const json = JSON.parse(fs.readFileSync(pkgFile, 'utf-8'));
+      if (!json.dependencies || !json.dependencies['node-noop']) {
+        throw new Error('Expected node-noop to be added to dependencies');
+      }
+    } finally {
+      process.chdir(prevCwd);
+      try {
+        fs.unlinkSync(input);
+      } catch {
+        /* ignore cleanup errors */
+      }
+      restoreEnv();
+    }
+  },
+  60000
+);
+
+afterAll(async () => {
+  await del(['node_modules', 'package.json', 'package-lock.json'], { cwd });
+});