Dynamically generate includes

[cefn]

• Rollup Plugin Name: typescript
• Rollup Plugin Version: @rollup/plugin-typescript": "^8.1.0",

Feature Use Case

I would like to bundle a typescript file including only its source code and referenced imports, without implicitly transpiling every typescript file contained in the longest common root folder of the file and its imports, which seems to be the current behaviour.

The repository at https://github.com/cefn/testcase_rollup was constructed to clarify the problem. Having failed to find any configuration parameter which allows compiling of just a file and its imports, I'm raising it as a feature request.

A shortcut to the rollup script in the repo is...
https://github.com/cefn/testcase_rollup/blob/main/test_rollup.ts

It is intended to compile prefix.ts to a bundle called prefix.js

Feature Proposal

A configuration option to the Rollup plugin should be added, which makes it implicitly define the include tsconfig parameter, setting it to match the paths of the imported files it is about to bundle (only the file and its imports recursively).

Setting the include to be only these files would prevent typescript from implicitly transpiling everything in the whole project just to bundle a single file.

Background

Currently there are two successful ways to compile the source shown as A) and B) below. They are both problematic. This feature would provide a third case, benefiting from rollup's own modelling of recursive imports to construct a sensible list for include.

• A) Explicitly construct an include list with all *.ts files which are imported before running rollup.
  • Problem: the developer has to inspect and list the recursive imports of a file to bundle it. Leaving anything out means a failure to compile. You can see the list I calculated for prefix.ts which has to be declared here. Omitting anything means prefix.ts fails to compile.
  • This defeats the purpose. I am effectively building my own bundling library. If I already know the file path and all of its imports then could just use typescript transpile and string-concatenation to construct the bundle.
• B) Omit include (to achieve this I comment the parameter in the repro example here)
  • Problem: rollup attempts to transpile all files in the whole project
  • I believe in the case of the repro rootDir becomes implicitly the longest common path of mapreduce.js and prefix.js (which is the project root folder) and include is implicitly "*/.ts". Hence rollup transpiles all project files, including the bundling routine itself!

[shellscape]

After spending a lot of time looking into this, I'm afraid it's just not possible using our current approach. We're leveraging the BuildProgram of TypeScript and we're somewhat beholden to its rules. Try as I might, I could not find a way to make this happen for you. If you happen to run across something that we couldn't find which enables this, please do let us know.

[cefn]

@shellscape I just want to say thankyou for putting in the effort to explore this. I know what it's like battling with a problem of this nature (I battled for a while before deciding it was beyond me). I admire your willingness to do it just to help out a fellow traveller on the internet!

I'm honestly still a few textbooks behind a full understanding of how target modules get selected and resolved for compilation in Typescript but I'm trying and if I get to understand this world enough to say anything useful I'll post back.

My workaround in the short term was constructing a tsconfig.json file dedicated to the compiling of resources within a particular folder, which stops the runaway expansion of candidate modules when you target a file within that folder for compilation, assuming you point to the tsconfig.json as part of the rollup invocation...

{
  "include": ["./**/*.ts"],
}

The typescript compiler IS smart enough to selectively compile outside the folder when distant modules are explicitly imported from files within the folder.

It's a bit of a shame to have a 'gotcha' for this compile case - that the developer needs to intervene and construct more than just the source code itself, but it's liveable and fairly easy to document. The resulting transpile routine requires both a tsconfig path and a source path like...

import path from "path";
import * as rollup from "rollup";
import rollupPluginTypescript from "@rollup/plugin-typescript";

export async function transpileSource(
  sourcePath: string,
  tsconfigPath: string
) {
  const workingDir = process.cwd();
  const sourceDirRelative = path.dirname(sourcePath);
  const sourceFileAbsolute = path.resolve(workingDir, sourcePath);
  const sourceDirAbsolute = path.resolve(workingDir, sourceDirRelative);
  const input: rollup.InputOptions = {
    input: sourceFileAbsolute,
    context: sourceDirAbsolute,
    plugins: [
      rollupPluginTypescript({
        tsconfig: tsconfigPath,
        target: "es5",
        sourceMap: false,
        strict: true,
        alwaysStrict: false,
        noImplicitUseStrict: true,
      }),
    ],
    treeshake: false,
  };
  const output: rollup.OutputOptions = {
    file: sourceFileAbsolute.replace(/\.ts$/, ".js"),
    format: "es",
  };
  const bundle = await rollup.rollup(input);
  await bundle.write(output);
}