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

packages/typescript/README.md

@@ -77,7 +77,9 @@ 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.
 
 ### `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,69 @@ 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;
 
   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] : [];
+  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
+      if (path.parse(effectiveOutDir).root !== path.parse(baseForContainment).root) 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
   });
   parsedOptions.fileNames = parsedOptions.fileNames.filter(filter);
 
@@ -103,6 +164,28 @@ export default function typescript(options: RollupTypescriptOptions = {}): Plugi
         // ESLint doesn't understand optional chaining
         // eslint-disable-next-line
         program?.close();
+        if (autoOutDir) {
+          try {
+            fs.rmSync(autoOutDir, { recursive: true, force: true });
+          } catch {
+            // ignore cleanup failures
+          }
+          autoOutDir = null;
+        }
+      }
+    },
+
+    // Ensure program is closed and temp outDir is removed exactly once when watch stops
+    closeWatcher() {
+      // eslint-disable-next-line
+      program?.close();
+      if (autoOutDir) {
+        try {
+          fs.rmSync(autoOutDir, { recursive: true, force: true });
+        } catch {
+          // ignore cleanup failures
+        }
+        autoOutDir = null;
       }
     },
 

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/test.js

@@ -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 });
+  }
+});