transformChunk -> renderChunk (#67)

* transformChunk -> renderChunk

* Rename transformChunk method

Author: kristoferbaxter

package-lock.json

@@ -21,7 +21,6 @@ const {
 } = require('google-closure-compiler/lib/utils.js');
 import { Transform } from './types';
 import { postCompilation } from './transforms';
-import { OutputChunk } from '../node_modules/rollup';
 
 enum Platform {
   NATIVE = 'native',
@@ -39,7 +38,6 @@ const PLATFORM_PRECEDENCE = [Platform.NATIVE, Platform.JAVA, Platform.JAVASCRIPT
  */
 export default function(
   compileOptions: CompileOptions,
-  chunk: OutputChunk,
   transforms: Array<Transform>,
 ): Promise<string> {
   return new Promise((resolve: (stdOut: string) => void, reject: (error: any) => void) => {
@@ -64,7 +62,7 @@ export default function(
       } else if (exitCode !== 0) {
         reject(new Error(`Google Closure Compiler exit ${exitCode}: ${stdErr}`));
       } else {
-        resolve(await postCompilation(code, chunk, transforms));
+        resolve(await postCompilation(code, transforms));
       }
     });
   });

src/compiler.ts

@@ -27,3 +27,6 @@ export const logSource = (preamble: string, source: string, code?: string) => {
     }
   }
 };
+
+export const log = (preamble: string, message: string) =>
+  DEBUG_ENABLED ? console.log(preamble) && console.log(message) : null;

src/debug.ts

@@ -17,7 +17,14 @@
 import { CompileOptions } from 'google-closure-compiler';
 import * as fs from 'fs';
 import { promisify } from 'util';
-import { OutputOptions, RawSourceMap, Plugin, InputOptions, PluginContext } from 'rollup';
+import {
+  OutputOptions,
+  RawSourceMap,
+  Plugin,
+  InputOptions,
+  PluginContext,
+  RenderedChunk,
+} from 'rollup';
 import compiler from './compiler';
 import options from './options';
 import { preCompilation, createTransforms, deriveFromInputSource } from './transforms';
@@ -34,14 +41,13 @@ const readFile = promisify(fs.readFile);
  * @param outputOptions Rollup Output Options.
  * @return Closure Compiled form of the Rollup Chunk
  */
-const transformChunk = async (
+const renderChunk = async (
   transforms: Array<Transform>,
   requestedCompileOptions: CompileOptions = {},
   sourceCode: string,
-  chunk: any,
   outputOptions: OutputOptions,
 ): Promise<{ code: string; map: RawSourceMap } | void> => {
-  const code = await preCompilation(sourceCode, outputOptions, chunk, transforms);
+  const code = await preCompilation(sourceCode, outputOptions, transforms);
   logSource('transform', sourceCode, code);
   const [compileOptions, mapFile] = options(
     requestedCompileOptions,
@@ -50,7 +56,7 @@ const transformChunk = async (
     transforms,
   );
 
-  return compiler(compileOptions, chunk, transforms).then(
+  return compiler(compileOptions, transforms).then(
     async code => {
       return { code, map: JSON.parse(await readFile(mapFile, 'utf8')) };
     },
@@ -78,9 +84,9 @@ export default function closureCompiler(requestedCompileOptions: CompileOptions
         transformsDefined = true;
       }
     },
-    transformChunk: async (code: string, outputOptions: OutputOptions, chunk: any) => {
-      await deriveFromInputSource(code, chunk.id, transforms);
-      return await transformChunk(transforms, requestedCompileOptions, code, chunk, outputOptions);
+    renderChunk: async (code: string, chunk: RenderedChunk, outputOptions: OutputOptions) => {
+      await deriveFromInputSource(code, chunk, transforms);
+      return await renderChunk(transforms, requestedCompileOptions, code, outputOptions);
     },
   };
 }

src/index.ts

@@ -22,7 +22,7 @@ import {
   Node,
   ClassDeclaration,
 } from 'estree';
-import { TransformSourceDescription, OutputChunk } from 'rollup';
+import { TransformSourceDescription, RenderedChunk } from 'rollup';
 import { NamedDeclaration, DefaultDeclaration } from './parsing-utilities';
 import { isESMFormat } from '../options';
 import {
@@ -49,22 +49,22 @@ export default class ExportTransform extends Transform implements TransformInter
    * Before Closure Compiler is given a chance to look at the code, we need to
    * find and store all export statements with their correct type
    * @param code source to parse
-   * @param id Rollup id reference to the source
+   * @param chunk Rollup chunk reference to the source
    */
-  public async deriveFromInputSource(code: string, id: string): Promise<void> {
+  public async deriveFromInputSource(code: string, chunk: RenderedChunk): Promise<void> {
     const context = this.context;
     let originalExports: ExportNameToClosureMapping = {};
     const program = context.parse(code, { ranges: true });
 
     walk.simple(program, {
       ExportNamedDeclaration(node: ExportNamedDeclaration) {
-        const namedDeclarationValues = NamedDeclaration(context, id, node);
+        const namedDeclarationValues = NamedDeclaration(context, node);
         if (namedDeclarationValues !== null) {
           originalExports = { ...originalExports, ...namedDeclarationValues };
         }
       },
       ExportDefaultDeclaration(node: ExportDefaultDeclaration) {
-        const defaultDeclarationValue = DefaultDeclaration(context, id, node);
+        const defaultDeclarationValue = DefaultDeclaration(context, node);
         if (defaultDeclarationValue !== null) {
           originalExports = { ...originalExports, ...defaultDeclarationValue };
         }
@@ -92,11 +92,7 @@ export default class ExportTransform extends Transform implements TransformInter
    * @param id Rollup id reference to the source
    * @return modified input source with window scoped references.
    */
-  public async preCompilation(
-    code: string,
-    chunk: any,
-    id: string,
-  ): Promise<TransformSourceDescription> {
+  public async preCompilation(code: string): Promise<TransformSourceDescription> {
     if (this.outputOptions === null) {
       this.context.warn(
         'Rollup Plugin Closure Compiler, OutputOptions not known before Closure Compiler invocation.',
@@ -127,11 +123,7 @@ export default class ExportTransform extends Transform implements TransformInter
    * @param id Rollup identifier for the source
    * @return Promise containing the repaired source
    */
-  public async postCompilation(
-    code: string,
-    chunk: OutputChunk,
-    id: string,
-  ): Promise<TransformSourceDescription> {
+  public async postCompilation(code: string): Promise<TransformSourceDescription> {
     if (this.outputOptions === null) {
       this.context.warn(
         'Rollup Plugin Closure Compiler, OutputOptions not known before Closure Compiler invocation.',