feat(typescript): process .js when allowJs is enabled (#1920)

* feat(typescript): honor allowJs and transform .js files\n\n- Expand default include to JS/JSX/MJS/CJS when  is enabled\n- Avoid TS5055 by redirecting JS emit to a temp outDir when none is set\n- Add tests for downleveling JS (direct entry and TS->JS import)\n- Document behavior in README

* feat(typescript): auto-include JS when allowJs is set; use temp outDir and clean up\n\n- Use brace expansion in default include glob\n- Create per-build temp outDir under os.tmpdir(), exclude it from filter, and remove on build end\n- Document behavior in README

* fix(typescript): exclude effective outDir from filter to avoid re-processing outputs\n\n- Exclude user-configured or auto temp outDir from the plugin filter\n- Guard against excluding sources when outDir contains the filter root (e.g., outDir='.' with rootDir='src')\n\nImplements review feedback to avoid feedback loops with allowJs and user outDir.

* fix(typescript): use path.relative for robust outDir containment check

- Replace brittle startsWith-based check with path.relative to detect containment
- Address ESLint prefer-template with template literal

Refs #1920

* test(typescript): add regression ensuring user-configured outDir is excluded with allowJs

* fix(typescript): gate temp outDir cleanup to non-watch; cleanup in closeWatcher; harden outDir exclusion\n\n- Clean temp outDir only when not watching; perform final cleanup in closeWatcher to avoid watch-mode churn\n- Robust containment check for excluding outDir using drive-root equality + path.relative + !isAbsolute (handles Windows cross-drive)\n- When filterRoot=false, use CWD fallback for containment to avoid over-excluding sources (e.g., outDir='.')\n- Docs: clarify cleanup timing in README (non-watch vs watch)

* test(typescript): harden user outDir exclusion test (robust path check, guaranteed cleanup)

* fix(typescript): robust outDir containment; gate temp outDir cleanup in watch mode\n\n- Guard containment with cross-drive root check and absolute-relative detection\n- Skip over-exclusion when filterRoot is false by falling back to process.cwd()\n- Delete temp outDir only for non-watch builds; clean up in closeWatcher for watch\n- Docs: clarify effective outDir exclusion and watch-mode cleanup timing\n\nRefs #1920

# Conflicts:
#	packages/typescript/README.md
#	packages/typescript/src/index.ts

* test(typescript): make isInside helper treat equal path as inside; mirror plugin containment semantics

* test(typescript): remove REBUILD_WITH_WATCH_OFF from incremental-watch-off fixture

Drop the unused export from the fixture. It was only there to force a change and is no longer needed. No behavior change; keeps the test fixture minimal and avoids pointless noise.

* fix(typescript): guard string-only filterRoot base; close watch program on shutdown\n\n- Treat only string values of  as a base path; fall back to tsconfig  otherwise to avoid resolving boolean  to 'true'\n- Align 's  option with the same guard to prevent passing non-string truthy values\n- Close the TypeScript watch program in  to release resources in watch mode\n\nRefs #1920

* fix(typescript): normalize Windows drive roots in containment; exclude node_modules by default when auto‑including JS\n\n- Normalize drive‑letter case when comparing roots in outDir containment (win32)\n- When allowJs expands include and user did not set include/exclude, add '**/node_modules/**' to exclude to avoid transforming third‑party code\n\nRefs #1920

* docs(typescript): note default node_modules exclusion when allowJs expands include

* fix(typescript): default filter resolve to cwd when rootDir unset\n\n- Align runtime with README for  default:  when  is not a string and resolution is enabled\n- Prevents  from receiving  base in edge configs\n\nRefs #1920

* refactor(typescript): centralize temp outDir cleanup into a helper

- Deduplicate try/catch cleanup in buildEnd and closeWatcher via local function
- No behavior change; preserves watch vs non-watch cleanup semantics

Refs #1920

* refactor(typescript): unify program close + temp outDir cleanup via helper

- Add local closeProgramAndCleanup() that always cleans in finally
- Use in buildEnd (non-watch) and closeWatcher (watch)

Refs #1920

---------

Co-authored-by: CharlieHelps <[email protected]>

Author: charliecreates[bot]

packages/typescript/README.md

@@ -77,7 +77,11 @@ A [picomatch pattern](https://github.com/micromatch/picomatch), or array of patt
 Type: `String` | `Array[...String]`<br>
 Default: `null`
 
-A [picomatch pattern](https://github.com/micromatch/picomatch), or array of patterns, which specifies the files in the build the plugin should operate on. By default all `.ts` and `.tsx` files are targeted.
+A [picomatch pattern](https://github.com/micromatch/picomatch), or array of patterns, which specifies the files in the build the plugin should operate on. By default all `.ts` and `.tsx` files are targeted. If your `tsconfig.json` (or plugin `compilerOptions`) sets `allowJs: true`, the default include expands to also cover `.js`, `.jsx`, `.mjs`, and `.cjs` files so that JavaScript sources are downleveled by TypeScript as well.
+
+> Note: When `allowJs` is enabled and no `outDir` is configured, this plugin creates a temporary output directory for TypeScript emit to avoid TS5055 (overwriting input files). The effective `outDir` (whether user-provided or the temporary one) is excluded from plugin processing to prevent re-processing emitted files. The temporary directory is removed after a non-watch build completes; in watch mode it is removed when the watcher stops.
+>
+> When `allowJs` expands the default include and you have not specified patterns via `include`/`exclude`, the plugin also excludes `**/node_modules/**` by default to avoid transforming third-party code.
 
 ### `filterRoot`
 

packages/typescript/src/index.ts

@@ -1,4 +1,6 @@
 import * as path from 'path';
+import * as fs from 'fs';
+import * as os from 'os';
 
 import { createFilter } from '@rollup/pluginutils';
 
@@ -40,10 +42,101 @@ export default function typescript(options: RollupTypescriptOptions = {}): Plugi
   const tsCache = new TSCache(cacheDir);
   const emittedFiles = new Map<string, string>();
   const watchProgramHelper = new WatchProgramHelper();
+  let autoOutDir: string | null = null;
+  // Centralize temp outDir cleanup to avoid duplication/drift across hooks
+  const cleanupAutoOutDir = () => {
+    if (!autoOutDir) return;
+    try {
+      fs.rmSync(autoOutDir, { recursive: true, force: true });
+    } catch {
+      // ignore cleanup failures
+    }
+    autoOutDir = null;
+  };
+  // Ensure the TypeScript watch program is closed and temp outDir is cleaned
+  // even if closing throws. Call this from lifecycle hooks that need teardown.
+  const closeProgramAndCleanup = () => {
+    try {
+      // ESLint doesn't understand optional chaining
+      // eslint-disable-next-line
+      program?.close();
+    } finally {
+      cleanupAutoOutDir();
+    }
+  };
 
   const parsedOptions = parseTypescriptConfig(ts, tsconfig, compilerOptions, noForceEmit);
-  const filter = createFilter(include || '{,**/}*.(cts|mts|ts|tsx)', exclude, {
-    resolve: filterRoot ?? parsedOptions.options.rootDir
+
+  // When processing JS via allowJs, redirect emit output away from source files
+  // to avoid TS5055 (cannot write file because it would overwrite input file).
+  // We only set a temp outDir if the user did not configure one.
+  if (parsedOptions.options.allowJs && !parsedOptions.options.outDir) {
+    // Create a unique temporary outDir to avoid TS5055 when emitting JS
+    autoOutDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rollup-plugin-typescript-allowjs-'));
+    parsedOptions.options.outDir = autoOutDir;
+  }
+
+  // Determine default include pattern. By default we only process TS files.
+  // When the consumer enables `allowJs` in their tsconfig/compiler options,
+  // also include common JS extensions so modern JS syntax in .js files is
+  // downleveled by TypeScript as expected.
+  const defaultInclude = parsedOptions.options.allowJs
+    ? '{,**/}*.{cts,mts,ts,tsx,js,jsx,mjs,cjs}'
+    : '{,**/}*.{cts,mts,ts,tsx}';
+
+  // Build filter exclusions, ensuring we never re-process TypeScript emit outputs.
+  // Always exclude the effective outDir (user-provided or the auto-created temp dir).
+  const filterExclude = Array.isArray(exclude) ? [...exclude] : exclude ? [exclude] : [];
+  // When auto-expanding to include JS (allowJs) and the user did not provide
+  // custom include/exclude patterns, avoid transforming third-party code by
+  // default by excluding node_modules.
+  if (parsedOptions.options.allowJs && !include && !exclude) {
+    filterExclude.push('**/node_modules/**');
+  }
+  const effectiveOutDir = parsedOptions.options.outDir
+    ? path.resolve(parsedOptions.options.outDir)
+    : null;
+  // Determine the base used for containment checks. If pattern resolution is disabled
+  // (filterRoot === false), fall back to process.cwd() so we don't accidentally
+  // exclude sources when e.g. outDir='.'.
+  const willResolvePatterns = filterRoot !== false;
+  // Only treat string values of `filterRoot` as a base directory; booleans (e.g., true)
+  // should not flow into path resolution. Fallback to the tsconfig `rootDir` when not set.
+  const configuredBase = willResolvePatterns
+    ? typeof filterRoot === 'string'
+      ? filterRoot
+      : parsedOptions.options.rootDir
+    : null;
+  const filterBaseAbs = configuredBase ? path.resolve(configuredBase) : null;
+  if (effectiveOutDir) {
+    // Avoid excluding sources: skip when the filter base (or cwd fallback) lives inside outDir.
+    // Use path.relative with root equality guard for cross-platform correctness.
+    const baseForContainment = filterBaseAbs ?? process.cwd();
+    const outDirContainsFilterBase = (() => {
+      // Different roots (e.g., drive letters on Windows) cannot be in a parent/child relationship.
+      // Normalize Windows drive-letter case before comparison to avoid false mismatches.
+      const getRoot = (p: string) => {
+        const r = path.parse(p).root;
+        return process.platform === 'win32' ? r.toLowerCase() : r;
+      };
+      if (getRoot(effectiveOutDir) !== getRoot(baseForContainment)) return false;
+      const rel = path.relative(effectiveOutDir, baseForContainment);
+      // rel === '' -> same dir; absolute or '..' => outside
+      return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+    })();
+    if (!outDirContainsFilterBase) {
+      filterExclude.push(normalizePath(path.join(effectiveOutDir, '**')));
+    }
+  }
+  const filter = createFilter(include || defaultInclude, filterExclude, {
+    // Guard against non-string truthy values (e.g., boolean true). Only strings are valid
+    // for `resolve`; `false` disables resolution. Otherwise, fall back to `rootDir`.
+    resolve:
+      typeof filterRoot === 'string'
+        ? filterRoot
+        : filterRoot === false
+        ? false
+        : parsedOptions.options.rootDir || process.cwd()
   });
   parsedOptions.fileNames = parsedOptions.fileNames.filter(filter);
 
@@ -100,12 +193,15 @@ export default function typescript(options: RollupTypescriptOptions = {}): Plugi
 
     buildEnd() {
       if (this.meta.watchMode !== true) {
-        // ESLint doesn't understand optional chaining
-        // eslint-disable-next-line
-        program?.close();
+        closeProgramAndCleanup();
       }
     },
 
+    // Ensure program is closed and temp outDir is removed exactly once when watch stops
+    closeWatcher() {
+      closeProgramAndCleanup();
+    },
+
     renderStart(outputOptions) {
       validateSourceMap(this, parsedOptions.options, outputOptions, parsedOptions.autoSetSourceMap);
       validatePaths(this, parsedOptions.options, outputOptions);

packages/typescript/test/fixtures/allow-js-downlevel/src/main.js

@@ -0,0 +1,7 @@
+export default function run() {
+  const obj = { prop: { nested: 1 } };
+  const a = obj.prop?.nested;
+  const b = {};
+  b.timeout ??= 123;
+  return [a, b.timeout];
+}

packages/typescript/test/fixtures/allow-js-downlevel/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "checkJs": false,
+    "target": "ES2018",
+    "module": "ESNext",
+    "lib": ["es6"]
+  },
+  "include": ["src/**/*"]
+}

packages/typescript/test/fixtures/allow-js-from-ts/src/main.ts

@@ -0,0 +1,5 @@
+import util from './util.js';
+
+export default function main() {
+  return util();
+}

packages/typescript/test/fixtures/allow-js-from-ts/src/util.js

@@ -0,0 +1,7 @@
+export default function util() {
+  const obj = { prop: { nested: 7 } };
+  const a = obj.prop?.nested;
+  const c = {};
+  c.timeout ??= 9;
+  return [a, c.timeout];
+}

packages/typescript/test/fixtures/allow-js-from-ts/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "checkJs": false,
+    "target": "ES2018",
+    "module": "ESNext"
+  },
+  "include": ["src/**/*"]
+}

packages/typescript/test/fixtures/incremental-single/tsconfig.tsbuildinfo

@@ -1629,3 +1629,68 @@ test.serial('observes included declarations', async (t) => {
   const files = await getCode(bundle, { format: 'es' }, true);
   t.is(files.length, 1);
 });
+
+test.serial('downlevels JS when allowJs is true (default include)', async (t) => {
+  const bundle = await rollup({
+    input: 'fixtures/allow-js-downlevel/src/main.js',
+    plugins: [typescript({ tsconfig: 'fixtures/allow-js-downlevel/tsconfig.json' })],
+    onwarn
+  });
+  const code = await getCode(bundle, { format: 'es' });
+
+  // Optional chaining and nullish coalescing assignment should be transformed
+  t.false(code.includes('?.'), code);
+  t.false(code.includes('??='), code);
+
+  const result = await evaluateBundle(bundle);
+  t.deepEqual(result(), [1, 123]);
+});
+
+test.serial('downlevels JS imported by TS when allowJs is true', async (t) => {
+  const bundle = await rollup({
+    input: 'fixtures/allow-js-from-ts/src/main.ts',
+    plugins: [typescript({ tsconfig: 'fixtures/allow-js-from-ts/tsconfig.json' })],
+    onwarn
+  });
+  const code = await getCode(bundle, { format: 'es' });
+
+  t.false(code.includes('?.'), code);
+  t.false(code.includes('??='), code);
+
+  const result = await evaluateBundle(bundle);
+  t.deepEqual(result(), [7, 9]);
+});
+
+test.serial('excludes user-configured outDir from processing when allowJs is true', async (t) => {
+  const outDir = path.join(__dirname, 'fixtures/allow-js-from-ts/.out');
+  fs.rmSync(outDir, { recursive: true, force: true });
+
+  const bundle = await rollup({
+    input: 'fixtures/allow-js-from-ts/src/main.ts',
+    plugins: [
+      typescript({
+        tsconfig: 'fixtures/allow-js-from-ts/tsconfig.json',
+        compilerOptions: { outDir }
+      })
+    ],
+    onwarn
+  });
+
+  try {
+    // Ensure Rollup did not pull any files from the outDir into the graph
+    const normalizeForCompare = (p) => {
+      const r = path.resolve(p);
+      return process.platform === 'win32' ? r.toLowerCase() : r;
+    };
+    const outDirAbs = normalizeForCompare(outDir);
+    const isInside = (parent, child) => {
+      const rel = path.relative(parent, normalizeForCompare(child));
+      // same dir or within parent
+      return !rel.startsWith('..') && !path.isAbsolute(rel);
+    };
+    t.true(bundle.watchFiles.every((f) => !isInside(outDirAbs, f)));
+  } finally {
+    await bundle.close();
+    fs.rmSync(outDir, { recursive: true, force: true });
+  }
+});