feat(typescript): Implement cached incremental code (#535)

* Implement using cached incremental code

* Fix windows paths issue

Co-authored-by: Fabio Torchetti <[email protected]>
Co-authored-by: shellscape <[email protected]>

Author: 3 people

.gitignore

@@ -9,6 +9,7 @@ output/
 coverage.lcov
 pnpm-debug.log
 .idea
+.rollup.cache
 
 !packages/node-resolve/test/fixtures/**/node_modules
 !packages/commonjs/test/**/node_modules

packages/typescript/README.md

@@ -188,6 +188,21 @@ typescript({
 });
 ```
 
+### `cacheDir`
+
+Type: `String`<br>
+Default: _.rollup.cache_
+
+When compiling with `incremental` or `composite` options the plugin will
+store compiled files in this folder. This allows the use of incremental
+compilation.
+
+```js
+typescript({
+  cacheDir: '.rollup.tscache'
+});
+```
+
 ### Typescript compiler options
 
 Some of Typescript's [CompilerOptions](https://www.typescriptlang.org/docs/handbook/compiler-options.html) affect how Rollup builds files.

packages/typescript/src/index.ts

@@ -9,18 +9,21 @@ import createModuleResolver from './moduleResolution';
 import getPluginOptions from './options/plugin';
 import { emitParsedOptionsErrors, parseTypescriptConfig } from './options/tsconfig';
 import { validatePaths, validateSourceMap } from './options/validate';
-import findTypescriptOutput from './outputFile';
+import findTypescriptOutput, { getEmittedFile } from './outputFile';
 import createWatchProgram, { WatchProgramHelper } from './watchProgram';
+import TSCache from './tscache';
 
 export default function typescript(options: RollupTypescriptOptions = {}): Plugin {
   const {
+    cacheDir,
+    compilerOptions,
     filter,
+    transformers,
     tsconfig,
-    compilerOptions,
     tslib,
-    typescript: ts,
-    transformers
+    typescript: ts
   } = getPluginOptions(options);
+  const tsCache = new TSCache(cacheDir);
   const emittedFiles = new Map<string, string>();
   const watchProgramHelper = new WatchProgramHelper();
 
@@ -49,6 +52,9 @@ export default function typescript(options: RollupTypescriptOptions = {}): Plugi
           resolveModule,
           parsedOptions,
           writeFile(fileName, data) {
+            if (parsedOptions.options.composite || parsedOptions.options.incremental) {
+              tsCache.cacheCode(fileName, data);
+            }
             emittedFiles.set(fileName, data);
           },
           status(diagnostic) {
@@ -103,16 +109,16 @@ export default function typescript(options: RollupTypescriptOptions = {}): Plugi
 
       await watchProgramHelper.wait();
 
-      const output = findTypescriptOutput(ts, parsedOptions, id, emittedFiles);
+      const output = findTypescriptOutput(ts, parsedOptions, id, emittedFiles, tsCache);
 
       return output.code != null ? (output as SourceDescription) : null;
     },
 
     generateBundle(outputOptions) {
       parsedOptions.fileNames.forEach((fileName) => {
-        const output = findTypescriptOutput(ts, parsedOptions, fileName, emittedFiles);
+        const output = findTypescriptOutput(ts, parsedOptions, fileName, emittedFiles, tsCache);
         output.declarations.forEach((id) => {
-          const code = emittedFiles.get(id);
+          const code = getEmittedFile(id, emittedFiles, tsCache);
           if (!code) return;
 
           this.emitFile({

packages/typescript/src/options/plugin.ts

@@ -16,18 +16,20 @@ import getTsLibPath from '../tslib';
  */
 export default function getPluginOptions(options: RollupTypescriptOptions) {
   const {
-    include,
+    cacheDir,
     exclude,
+    include,
+    transformers,
     tsconfig,
-    typescript,
     tslib,
-    transformers,
+    typescript,
     ...compilerOptions
   } = options;
 
   const filter = createFilter(include || ['*.ts+(|x)', '**/*.ts+(|x)'], exclude);
 
   return {
+    cacheDir,
     filter,
     tsconfig,
     compilerOptions: compilerOptions as PartialCompilerOptions,

packages/typescript/src/outputFile.ts

@@ -1,5 +1,7 @@
 import { SourceDescription } from 'rollup';
 
+import TSCache from './tscache';
+
 export interface TypescriptSourceDescription extends Partial<SourceDescription> {
   declarations: string[];
 }
@@ -18,6 +20,29 @@ function isMapOutputFile(name: string): boolean {
   return name.endsWith('.map');
 }
 
+/**
+ * Returns the content of a filename either from the current
+ * typescript compiler instance or from the cached content.
+ * @param fileName The filename for the contents to retrieve
+ * @param emittedFiles The files emitted in the current typescript instance
+ * @param tsCache A cache to files cached by Typescript
+ */
+export function getEmittedFile(
+  fileName: string | undefined,
+  emittedFiles: ReadonlyMap<string, string>,
+  tsCache: TSCache
+): string | undefined {
+  let code: string | undefined;
+  if (fileName) {
+    if (emittedFiles.has(fileName)) {
+      code = emittedFiles.get(fileName);
+    } else {
+      code = tsCache.getCached(fileName);
+    }
+  }
+  return code;
+}
+
 /**
  * Finds the corresponding emitted Javascript files for a given Typescript file.
  * @param id Path to the Typescript file.
@@ -28,7 +53,8 @@ export default function findTypescriptOutput(
   ts: typeof import('typescript'),
   parsedOptions: import('typescript').ParsedCommandLine,
   id: string,
-  emittedFiles: ReadonlyMap<string, string>
+  emittedFiles: ReadonlyMap<string, string>,
+  tsCache: TSCache
 ): TypescriptSourceDescription {
   const emittedFileNames = ts.getOutputFileNames(
     parsedOptions,
@@ -40,8 +66,8 @@ export default function findTypescriptOutput(
   const mapFile = emittedFileNames.find(isMapOutputFile);
 
   return {
-    code: emittedFiles.get(codeFile!),
-    map: emittedFiles.get(mapFile!),
+    code: getEmittedFile(codeFile, emittedFiles, tsCache),
+    map: getEmittedFile(mapFile, emittedFiles, tsCache),
     declarations: emittedFileNames.filter((name) => name !== codeFile && name !== mapFile)
   };
 }

packages/typescript/src/tscache.ts

@@ -0,0 +1,42 @@
+import path from 'path';
+import fs from 'fs';
+
+/** Creates the folders needed given a path to a file to be saved*/
+const createFileFolder = (filePath: string): void => {
+  const folderPath = path.dirname(filePath);
+  fs.mkdirSync(folderPath, { recursive: true });
+};
+
+export default class TSCache {
+  private _cacheFolder: string;
+
+  constructor(cacheFolder = '.rollup.cache') {
+    this._cacheFolder = cacheFolder;
+  }
+
+  /** Returns the path to the cached file */
+  cachedFilename(fileName: string): string {
+    return path.join(this._cacheFolder, fileName.replace(/^([A-Z]+):/, '$1'));
+  }
+
+  /** Emits a file in the cache folder */
+  cacheCode(fileName: string, code: string): void {
+    const cachedPath = this.cachedFilename(fileName);
+    createFileFolder(cachedPath);
+    fs.writeFileSync(cachedPath, code);
+  }
+
+  /** Checks if a file is in the cache */
+  isCached(fileName: string): boolean {
+    return fs.existsSync(this.cachedFilename(fileName));
+  }
+
+  /** Read a file from the cache given the output name*/
+  getCached(fileName: string): string | undefined {
+    let code: string | undefined;
+    if (this.isCached(fileName)) {
+      code = fs.readFileSync(this.cachedFilename(fileName), { encoding: 'utf-8' });
+    }
+    return code;
+  }
+}

packages/typescript/test/fixtures/incremental/main.ts

@@ -1,3 +1,6 @@
-const answer = '42';
+type AnswerToQuestion = string | undefined;
+
+const answer: AnswerToQuestion = '42';
+
 // eslint-disable-next-line no-console
 console.log(`the answer is ${answer}`);

packages/typescript/test/test.js

@@ -846,6 +846,33 @@ test.serial('supports incremental rebuild', async (t) => {
   );
 });
 
+test.serial('supports consecutive incremental rebuilds', async (t) => {
+  process.chdir('fixtures/incremental');
+
+  const firstBundle = await rollup({
+    input: 'main.ts',
+    plugins: [typescript()],
+    onwarn
+  });
+
+  const firstRun = await getCode(firstBundle, { format: 'esm', dir: 'dist' }, true);
+  t.deepEqual(
+    firstRun.map((out) => out.fileName),
+    ['main.js', '.tsbuildinfo']
+  );
+
+  const secondBundle = await rollup({
+    input: 'main.ts',
+    plugins: [typescript()],
+    onwarn
+  });
+  const secondRun = await getCode(secondBundle, { format: 'esm', dir: 'dist' }, true);
+  t.deepEqual(
+    secondRun.map((out) => out.fileName),
+    ['main.js', '.tsbuildinfo']
+  );
+});
+
 test.serial.skip('supports project references', async (t) => {
   process.chdir('fixtures/project-references');
 

packages/typescript/types/index.d.ts

@@ -3,6 +3,12 @@ import { Plugin } from 'rollup';
 import { CompilerOptions, CustomTransformers } from 'typescript';
 
 export interface RollupTypescriptPluginOptions {
+  /**
+   * If using incremental this is the folder where the cached
+   * files will be created and kept for Typescript incremental
+   * compilation.
+   */
+  cacheDir?: string;
   /**
    * Determine which files are transpiled by Typescript (all `.ts` and
    * `.tsx` files by default).