Using with @rollup/plugin-multi-entry plugin and custom transform

[enes-kaplan]

Hello. I am new to rollup and its plugin usage and environment. Sorry if this already has a solution, I have not came across.

I have a library written in JS and some classes in TS. I have a custom transform plugin, which goes through all the needed JS files and combines/minifies in a single output file. This is what I wanted and all is good.

However, I also want to have my TS files compiled into JS as seperate modules. To handle multiple inputs, I've used @rollup/plugin-multi-entry plugin. This changed how I handled the transform plugin a little bit, due to loaded content being a list of files to be exported instead of singular input file's content. However, I cannot process the rest of my files once I return from transform. I get a .d.ts file per .ts file, but not the implementation codes. I get the implementation code correctly if I plain run it without my custom plugin for combining the dependencies. Here is the code:

import fs from "fs";
import path from "path";
import terser from "@rollup/plugin-terser";
import typescript from "@rollup/plugin-typescript";
import multi from "@rollup/plugin-multi-entry";

export default {
  input: ["javascript/src/js/lib.js", "javascript/test.ts"],
  output: [
    {
      file: "javascript/output/lib.js",
      format: "cjs", // es | cjs
      strict: false,
    },
    {
      file: "javascript/output/lib.min.js",
      format: "cjs", // es | cjs
      strict: false,
      plugins: [terser()],
    },
    {
      dir: "javascript/output",
      format: "cjs", // es | cjs
      preserveModules: true,
      preserveModulesRoot: "javascript",
    },
  ],
  plugins: [
    handleDependencies(),
    multi(),
    typescript({ tsconfig: "./tsconfig.json" }),
  ],
};

// Custom plugin to combine all files
function handleDependencies() {
  return {
    name: "handleDependencies",
    transform(content) {
      const splitContent = content.split("\n"); // each line is a file export like (export * from "D:\foo\bar.js")
      for (let i = 0; i < splitContent.length; i++) {
        const exportStatement = splitContent[i];
        const fileContent = readFileContent(exportStatement);
        if (exportStatement.includes("js-input.js")) {
          const deps = getDependencies(fileContent);
          const combined = combineDependencies(deps);
          return combined;
        }
      }
    },
  };
}

function readFileContent(exportStatement) {
  const filePath = exportStatement.match(/"(.*?)"/)[1];
  const content = fs.readFileSync(filePath, "utf8");
  return content;
}

// Find required files from entry file (lib.js)
// There are include statements in this js file to state library's modules, like "lib.include(filePath)"
// We get the list of files by matching them with regex
// Then read their content and combine them in combineDependencies method
function getDependencies(content) {
  let deps = content
    .match(/lib\.include\([^"']+["'](.*?)["']/gi)
    .map((str) => str.match(/lib\.include\([^"']+["'](.*?)["']/)[1]);
  deps = ["./js/lib.js"].concat(deps.slice(0));

  return deps;
}

// Combine all files' content to one output file
function combineDependencies(dependencies) {
  let code = "";
  for (const file of dependencies) {
    const filePath = path.join(process.cwd(), "/javascript/src/", file);
    const content = fs.readFileSync(filePath, "utf8");

    code += content;
  }

  return code;
}

[potatohoney-p]

return combined replaces the whole module being transformed, not just the line currently being visited. With multi(), that module is a generated entry containing re-exports of both inputs. Replacing it with only the concatenated library removes the reference to test.ts. preserveModules cannot restore a module that is no longer in Rollup's graph. The TypeScript plugin can still emit declarations for files in its TypeScript program, which explains why a .d.ts is not proof that the implementation reached Rollup's output.

For the two different outputs you describe, use two configurations: one for the existing concatenated/minified library, one for the TypeScript modules. Neither needs multi():

// rollup.config.mjs
import fs from 'node:fs'; // used by the existing concatenation helpers
import path from 'node:path';
import terser from '@rollup/plugin-terser';
import typescript from '@rollup/plugin-typescript';

const legacyEntry = path.resolve('javascript/src/js/lib.js');

function handleDependencies() {
  return {
    name: 'handleDependencies',
    transform(content, id) {
      if (id !== legacyEntry) return null;
      // content is now the actual legacy entry source, not export statements.
      return {
        code: combineDependencies(getDependencies(content)),
        map: null,
      };
    },
  };
}

export default [
  {
    input: legacyEntry,
    plugins: [handleDependencies()],
    output: [
      { file: 'javascript/output/lib.js', format: 'cjs', strict: false },
      {
        file: 'javascript/output/lib.min.js',
        format: 'cjs', strict: false, plugins: [terser()],
      },
    ],
  },
  {
    // List every TS file that must be an entry, even if nothing imports it.
    input: ['javascript/test.ts'],
    plugins: [typescript({ tsconfig: './tsconfig.json' })],
    output: {
      dir: 'javascript/output',
      format: 'cjs',
      preserveModules: true,
      preserveModulesRoot: 'javascript',
    },
  },
];
// Keep your getDependencies/combineDependencies helpers here.

A minimal matching tsconfig.json is:

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "ESNext",
    "rootDir": "javascript",
    "declaration": true,
    "declarationDir": "javascript/output/types"
  },
  "include": ["javascript/**/*.ts"],
  "exclude": ["javascript/output"]
}

Keep the declaration output under the Rollup output directory. Avoid output-name collisions when adding entries. If your package uses "type": "module", use .cjs filenames for the CommonJS outputs (including entryFileNames: '[name].cjs' in the second config).

The important custom-plugin change is the id guard before any parsing or file reads. transform also receives ordinary module source, so treating every line as export * from "..." is unsafe. Also reconcile js-input.js in the condition with lib.js in the configured input; they differ in the example. Guard failed regex matches too: both match(...)[1] and match(...).map(...) throw when there is no match. The existing include-parser/concatenator still needs to produce valid JS; this change does not repair that parser.

I checked the graph-loss behavior with a minimal fixture on Rollup 4.52.5, @rollup/plugin-multi-entry 6.0.1, @rollup/plugin-typescript 12.3.0, TypeScript 5.9.3, tslib 2.8.1 and @rollup/plugin-terser 0.4.4 (Node 24.22.1). Replacing the virtual entry produced the declaration but no class implementation. The separated builds produced a working regular library, minified library, exported class module and declaration. This isolates the build-graph issue rather than reproducing your unavailable library files.

References: transform hook, preserveModules, multi-entry documentation.