feat(typescript): expose latest Program to transformers in watch mode\n\n- Add optional getProgram to ProgramTransformerFactory.factory\n- Pass getProgram() to program-scoped transformer factories\n- Recompute custom transformers after each TS watch rebuild\n- Docs: document getProgram and watch-mode behavior\n- Test: ensure factories are recreated and getProgram returns the latest Program

Author: CharlieHelps

packages/typescript/README.md

@@ -150,7 +150,9 @@ Supported transformer factories:
   ```js
   {
     type: 'program',
-    factory: (program: Program) => TransformerFactory | CustomTransformerFactory
+    // In watch mode, the optional `getProgram` returns the latest Program
+    factory: (program: Program, getProgram?: () => Program) =>
+      TransformerFactory | CustomTransformerFactory
   }
   ```
 
@@ -167,10 +169,11 @@ typescript({
   transformers: {
     before: [
       {
-        // Allow the transformer to get a Program reference in it's factory
+        // Allow the transformer to get a Program reference in its factory
+        // and, in watch mode, access the latest Program via `getProgram()`
         type: 'program',
-        factory: (program) => {
-          return ProgramRequiringTransformerFactory(program);
+        factory: (program, getProgram) => {
+          return ProgramRequiringTransformerFactory(getProgram ? getProgram() : program);
         }
       },
       {
@@ -245,6 +248,10 @@ typescript({
 });
 ```
 
+Note on watch mode
+
+When running Rollup in watch mode, this plugin recreates custom transformer factories after each TypeScript program rebuild so they receive the current Program and TypeChecker. If your transformer needs to query the latest type information across rebuilds, prefer using the optional `getProgram()` parameter provided to `program`-based transformer factories.
+
 ### `cacheDir`
 
 Type: `String`<br>

packages/typescript/src/customTransformers.ts

@@ -37,14 +37,14 @@ export function mergeTransformers(
           if (typeof transformer.factory === 'function') {
             // Allow custom factories to grab the extra information required
             program = program || builder.getProgram();
-            typeChecker = typeChecker || program.getTypeChecker();
 
             let factory: ReturnType<typeof transformer.factory>;
 
             if (transformer.type === 'program') {
               program = program || builder.getProgram();
 
-              factory = transformer.factory(program);
+              // Pass a getter so transformers can access the latest Program in watch mode
+              factory = transformer.factory(program, () => builder.getProgram());
             } else {
               program = program || builder.getProgram();
               typeChecker = typeChecker || program.getTypeChecker();

packages/typescript/src/watchProgram.ts

@@ -162,6 +162,10 @@ function createWatchHost(
     ...baseHost,
     /** Override the created program so an in-memory emit is used */
     afterProgramCreate(program) {
+      // Ensure we recompute custom transformers for each new builder program in watch mode
+      // so factories capture the current Program/TypeChecker and any provided getters return
+      // the latest values. This avoids freezing the initial Program across rebuilds.
+      createdTransformers = undefined;
       const origEmit = program.emit;
       // eslint-disable-next-line no-param-reassign
       program.emit = (

packages/typescript/test/test.js

@@ -1694,3 +1694,81 @@ test.serial('excludes user-configured outDir from processing when allowJs is tru
     fs.rmSync(outDir, { recursive: true, force: true });
   }
 });
+
+test.serial(
+  'recreates transformers per rebuild and exposes getProgram in watch mode',
+  async (t) => {
+    const observations = [];
+
+    const dirName = path.join(__dirname, 'fixtures', 'transformers');
+    const outputJs = path.join(dirName, 'main.js');
+
+    // ensure a clean slate for emitted file
+    if (fs.existsSync(outputJs)) {
+      fs.unlinkSync(outputJs);
+    }
+
+    const bundle = await rollup({
+      input: 'fixtures/transformers/main.ts',
+      plugins: [
+        typescript({
+          tsconfig: false,
+          compilerOptions: { module: 'esnext' },
+          // Use a fake TS that simulates two watch rebuilds by calling afterProgramCreate twice
+          typescript: fakeTypescript({
+            createWatchProgram(host) {
+              const makeBuilder = (id, value) => {
+                const innerProgram = { id };
+                return {
+                  getProgram() {
+                    return innerProgram;
+                  },
+                  emit(_, writeFile) {
+                    writeFile(outputJs, `export default ${value};`);
+                  }
+                };
+              };
+
+              const p1 = makeBuilder('one', 101);
+              host.afterProgramCreate(p1);
+              p1.emit();
+
+              const p2 = makeBuilder('two', 202);
+              host.afterProgramCreate(p2);
+              p2.emit();
+
+              return { close() {} };
+            }
+          }),
+          transformers: {
+            before: [
+              {
+                type: 'program',
+                factory(program, getProgram) {
+                  observations.push({
+                    p: program && program.id,
+                    gp: getProgram ? getProgram().id : undefined
+                  });
+                  // no-op transformer
+                  return function passthroughFactory(context) {
+                    return function passthrough(source) {
+                      return ts.visitEachChild(source, (n) => n, context);
+                    };
+                  };
+                }
+              }
+            ]
+          }
+        })
+      ],
+      onwarn
+    });
+
+    await getCode(bundle, { format: 'esm', dir: dirName }, true);
+
+    t.deepEqual(observations, [
+      { p: 'one', gp: 'one' },
+      { p: 'two', gp: 'two' }
+    ]);
+  }
+);

packages/typescript/types/index.d.ts

@@ -28,7 +28,12 @@ export type CustomTransformerFactories = {
 interface ProgramTransformerFactory<T extends TransformerStage> {
   type: 'program';
 
-  factory(program: Program): StagedTransformerFactory<T>;
+  /**
+   * Factory that may receive a getter for the latest Program when running in watch mode.
+   * The second parameter is optional to preserve backwards compatibility with existing
+   * transformer factories.
+   */
+  factory(program: Program, getProgram?: () => Program): StagedTransformerFactory<T>;
 }
 
 interface TypeCheckerTransformerFactory<T extends TransformerStage> {