Merge branch 'master' of github.com:ampproject/rollup-plugin-closure-compiler

Author: kristoferbaxter

.travis.yml

@@ -5,7 +5,7 @@ node_js:
   - "lts/*"
 before_install:
   - unset _JAVA_OPTIONS  # JVM heap sizes break closure compiler. #11203.
-script: yarn test
+script: npm run test
 branches:
   only:
     - master

package-lock.json

@@ -9,16 +9,15 @@
   },
   "author": "The AMP HTML Authors",
   "engines": {
-    "yarn": ">=1",
     "node": ">=8"
   },
   "keywords": [
     "rollup-plugin"
   ],
   "license": "Apache-2.0",
   "scripts": {
-    "pretest": "yarn build",
-    "test": "ava test/*.js",
+    "pretest": "npm run build",
+    "test": "ava test/**/*.js",
     "build": "rimraf dist && tsc -p tsconfig.json",
     "lint": "tslint -c tslint.json -p tsconfig.json"
   },
@@ -27,28 +26,28 @@
     "temp-write": "^3.4.0"
   },
   "devDependencies": {
+    "@types/estree": "^0.0.39",
     "@types/google-closure-compiler": "^0.0.18",
     "@types/temp-write": "^3.3.0",
-    "ava": "^0.25.0",
-    "husky": "1.0.0-rc.9",
+    "ava": "1.0.0-beta.6",
+    "husky": "1.0.0-rc.13",
     "lint-staged": "^7.2.0",
     "prettier": "^1.13.5",
     "rimraf": "^2.6.2",
     "rollup": "^0.62.0",
-    "sourcemap-validator": "^1.1.0",
-    "tslint": "5.10.0",
+    "tslint": "^5.10.0",
     "typescript": "^2.9.2"
   },
   "lint-staged": {
     "*.ts": [
-      "yarn lint --fix",
+      "npm run lint --fix",
       "prettier --config .prettierrc --write",
       "git add"
     ]
   },
   "husky": {
     "hooks": {
-      "pre-push": "yarn test",
+      "pre-push": "npm run test",
       "pre-commit": "lint-staged"
     }
   }

package.json

@@ -0,0 +1,40 @@
+/**
+ * Copyright 2018 The AMP HTML Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS-IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { compiler, CompileOptions } from 'google-closure-compiler';
+import { Transform } from './types';
+import { postCompilation } from './transforms';
+
+/**
+ * Run Closure Compiler and `postCompilation` Transforms on input source.
+ * @param compileOptions Closure Compiler CompileOptions, normally derived from Rollup configuration
+ * @param transforms Transforms to run rollowing compilation
+ * @return Promise<string> source following compilation and Transforms.
+ */
+export default function(
+  compileOptions: CompileOptions,
+  transforms: Array<Transform>,
+): Promise<string> {
+  return new Promise((resolve: (stdOut: string) => void, reject: (error: any) => void) => {
+    new compiler(compileOptions).run(async (exitCode: number, code: string, stdErr: string) => {
+      if (exitCode !== 0) {
+        reject(new Error(`Google Closure Compiler exit ${exitCode}: ${stdErr}`));
+      } else {
+        resolve(await postCompilation(code, transforms));
+      }
+    });
+  });
+}

src/compiler.ts

@@ -14,76 +14,59 @@
  * limitations under the License.
  */
 
-import { compiler, CompileOptions } from 'google-closure-compiler';
-import { sync } from 'temp-write';
-import { readFileSync } from 'fs';
-import { OutputOptions, RawSourceMap, Plugin } from 'rollup';
+import { CompileOptions } from 'google-closure-compiler';
+import * as fs from 'fs';
+import { promisify } from 'util';
+import { OutputOptions, RawSourceMap, Plugin, OutputChunk } from 'rollup';
+import compiler from './compiler';
+import options from './options';
+import { preCompilation, createTransforms, deriveFromInputSource } from './transforms';
+import { Transform } from './types';
 
-export const defaultCompileOptions = (outputOptions: OutputOptions): CompileOptions => {
-  // Defaults for Rollup Projects are slightly different than Closure Compiler defaults.
-  // - Users of Rollup tend to transpile their code before handing it to a minifier,
-  // so no transpile is default.
-  // - When Rollup output is set to "es" it is expected the code will live in a ES Module,
-  // so safely be more aggressive in minification.
-  // - When Rollup is configured to output an iife, ensure Closure Compiler does not
-  // mangle the name of the iife wrapper.
+const readFile = promisify(fs.readFile);
 
-  let externs: string = `
 /**
- * @fileoverview Externs built via derived configuration from Rollup or input code.
- * @externs
- */`;
-
-  const options: CompileOptions = {
-    language_out: 'NO_TRANSPILE',
-    assume_function_wrapper: outputOptions.format === 'es' ? true : false,
-    warning_level: 'QUIET',
-  };
-  if (outputOptions.format === 'iife' && outputOptions.name) {
-    externs = `${externs}\nvar ${outputOptions.name} = function(){};`;
-
-    options['externs'] = sync(externs);
-  }
+ * Transform the tree-shaken code from Rollup with Closure Compiler (with derived configuration and transforms)
+ * @param compileOptions Closure Compiler compilation options from Rollup configuration.
+ * @param transforms Transforms to apply to source followin Closure Compiler completion.
+ * @param code Source to compile.
+ * @param outputOptions Rollup Output Options.
+ * @return Closure Compiled form of the Rollup Chunk
+ */
+export const transformChunk = async (
+  transforms: Array<Transform>,
+  requestedCompileOptions: CompileOptions,
+  sourceCode: string,
+  outputOptions: OutputOptions,
+): Promise<{ code: string; map: RawSourceMap } | void> => {
+  const code = await preCompilation(sourceCode, outputOptions, transforms);
+  const [compileOptions, mapFile] = options(
+    requestedCompileOptions,
+    outputOptions,
+    code,
+    transforms,
+  );
 
-  return options;
+  return compiler(compileOptions, transforms).then(
+    async code => {
+      return { code, map: JSON.parse(await readFile(mapFile, 'utf8')) };
+    },
+    (error: Error) => {
+      throw error;
+    },
+  );
 };
 
-export default function closureCompiler(compileOptions: CompileOptions = {}): Plugin {
+export default function closureCompiler(requestedCompileOptions: CompileOptions = {}): Plugin {
+  let transforms: Array<Transform>;
+
   return {
     name: 'closure-compiler',
-    transformBundle: (
-      code: string,
-      outputOptions: OutputOptions,
-    ): Promise<{ code: string; map: RawSourceMap } | void> => {
-      const temp = {
-        js: sync(code),
-        map: sync(''),
-      };
-
-      compileOptions = Object.assign(defaultCompileOptions(outputOptions), compileOptions, {
-        js: temp.js,
-        create_source_map: temp.map,
-      });
-
-      const compile: Promise<string> = new Promise((resolve, reject) => {
-        new compiler(compileOptions).run((exitCode: number, stdOut: string, stdErr: string) => {
-          if (exitCode !== 0) {
-            reject(new Error(`Google Closure Compiler exit ${exitCode}: ${stdErr}`));
-          } else {
-            resolve(stdOut);
-          }
-        });
-      });
-
-      return compile.then(
-        stdOut => {
-          const sourceMap: RawSourceMap = JSON.parse(readFileSync(temp.map, 'utf8'));
-          return { code: stdOut, map: sourceMap };
-        },
-        (error: Error) => {
-          throw error;
-        },
-      );
+    load() {
+      transforms = transforms || createTransforms(this);
     },
+    transform: async (code: string) => deriveFromInputSource(code, transforms),
+    transformChunk: async (code: string, outputOptions: OutputOptions, chunk: OutputChunk) =>
+      await transformChunk(transforms, requestedCompileOptions, code, outputOptions),
   };
 }

src/index.ts

@@ -0,0 +1,79 @@
+/**
+ * Copyright 2018 The AMP HTML Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS-IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Transform } from './types';
+import { OutputOptions } from 'rollup';
+import { CompileOptions } from 'google-closure-compiler';
+import { sync } from 'temp-write';
+
+/**
+ * Generate default Closure Compiler CompileOptions an author can override if they wish.
+ * These must be derived from configuration or input sources.
+ * @param transformers
+ * @param options
+ * @return derived CompileOptions for Closure Compiler
+ */
+export const defaults = (
+  options: OutputOptions,
+  transformers: Array<Transform> | null,
+): CompileOptions => {
+  // Defaults for Rollup Projects are slightly different than Closure Compiler defaults.
+  // - Users of Rollup tend to transpile their code before handing it to a minifier,
+  // so no transpile is default.
+  // - When Rollup output is set to "es" it is expected the code will live in a ES Module,
+  // so safely be more aggressive in minification.
+  // - When Rollup is configured to output an iife, ensure Closure Compiler does not
+  // mangle the name of the iife wrapper.
+
+  const externs = transformers
+    ? transformers.map(transform => sync(transform.extern(options)))
+    : '';
+
+  return {
+    language_out: 'NO_TRANSPILE',
+    assume_function_wrapper: options.format === 'es' ? true : false,
+    warning_level: 'QUIET',
+    externs,
+  };
+};
+
+/**
+ * Compile Options is the final configuration to pass into Closure Compiler.
+ * defaultCompileOptions are overrideable by ones passed in directly to the plugin
+ * but the js source and sourcemap are not overrideable, since this would break the output if passed.
+ * @param compileOptions
+ * @param outputOptions
+ * @param code
+ * @param transforms
+ */
+export default function(
+  compileOptions: CompileOptions,
+  outputOptions: OutputOptions,
+  code: string,
+  transforms: Array<Transform> | null,
+): [CompileOptions, string] {
+  const mapFile = sync('');
+
+  return [
+    {
+      ...defaults(outputOptions, transforms),
+      ...compileOptions,
+      js: sync(code),
+      create_source_map: mapFile,
+    },
+    mapFile,
+  ];
+}