Option to remove strict mode declarations (#319)

Author: kristoferbaxter

src/index.ts

@@ -45,7 +45,13 @@ export default function closureCompiler(requestedCompileOptions: CompileOptions
     options: options => (inputOptions = options),
     buildStart() {
       context = this;
-      sourceTransforms = createSourceTransforms(context, mangler, inputOptions, {});
+      sourceTransforms = createSourceTransforms(
+        context,
+        requestedCompileOptions,
+        mangler,
+        inputOptions,
+        {},
+      );
       if (
         'compilation_level' in requestedCompileOptions &&
         requestedCompileOptions.compilation_level === 'ADVANCED_OPTIMIZATIONS' &&
@@ -68,6 +74,7 @@ export default function closureCompiler(requestedCompileOptions: CompileOptions
 
       const renderChunkTransforms = createChunkTransforms(
         context,
+        requestedCompileOptions,
         mangler,
         inputOptions,
         outputOptions,

src/options.ts

@@ -19,11 +19,13 @@ import { OutputOptions } from 'rollup';
 import { CompileOptions } from 'google-closure-compiler';
 import { writeTempFile } from './temp-file';
 import { log } from './debug';
+import { PluginOptions } from './types';
 
 export const ERROR_WARNINGS_ENABLED_LANGUAGE_OUT_UNSPECIFIED =
   'Providing the warning_level=VERBOSE compile option also requires a valid language_out compile option.';
 export const ERROR_WARNINGS_ENABLED_LANGUAGE_OUT_INVALID =
   'Providing the warning_level=VERBOSE and language_out=NO_TRANSPILE compile options will remove warnings.';
+const OPTIONS_TO_REMOVE_FOR_CLOSURE = ['remove_strict_directive'];
 
 /**
  * Checks if output format is ESM
@@ -48,6 +50,61 @@ function validateCompileOptions(compileOptions: CompileOptions): void {
   }
 }
 
+/**
+ * Normalize the compile options given by the user into something usable.
+ * @param compileOptions
+ */
+function normalizeExternOptions(compileOptions: CompileOptions): [Array<string>, CompileOptions] {
+  validateCompileOptions(compileOptions);
+  let externs: Array<string> = [];
+
+  if ('externs' in compileOptions) {
+    switch (typeof compileOptions.externs) {
+      case 'boolean':
+        externs = [];
+        break;
+      case 'string':
+        externs = [compileOptions.externs as string];
+        break;
+      default:
+        externs = compileOptions.externs as Array<string>;
+        break;
+    }
+
+    delete compileOptions.externs;
+  }
+
+  if (compileOptions) {
+    for (const optionToDelete of OPTIONS_TO_REMOVE_FOR_CLOSURE) {
+      if (optionToDelete in compileOptions) {
+        // @ts-ignore
+        delete compileOptions[optionToDelete];
+      }
+    }
+  }
+
+  return [externs, compileOptions];
+}
+
+/**
+ * Pluck the PluginOptions from the CompileOptions
+ * @param compileOptions
+ */
+export function pluckPluginOptions(compileOptions: CompileOptions): PluginOptions {
+  const pluginOptions: PluginOptions = {};
+  if (!compileOptions) {
+    return pluginOptions;
+  }
+
+  for (const optionToDelete of OPTIONS_TO_REMOVE_FOR_CLOSURE) {
+    if (optionToDelete in compileOptions) {
+      // @ts-ignore
+      pluginOptions[optionToDelete] = compileOptions[optionToDelete];
+    }
+  }
+  return pluginOptions;
+}
+
 /**
  * Generate default Closure Compiler CompileOptions an author can override if they wish.
  * These must be derived from configuration or input sources.
@@ -100,25 +157,7 @@ export default async function(
   transforms: Array<ChunkTransform> | null,
 ): Promise<[CompileOptions, string]> {
   const mapFile: string = await writeTempFile('', '', false);
-  const compileOptions: CompileOptions = { ...incomingCompileOptions };
-  let externs: Array<string> = [];
-
-  validateCompileOptions(compileOptions);
-  if ('externs' in compileOptions) {
-    switch (typeof compileOptions.externs) {
-      case 'boolean':
-        externs = [];
-        break;
-      case 'string':
-        externs = [compileOptions.externs as string];
-        break;
-      default:
-        externs = compileOptions.externs as Array<string>;
-        break;
-    }
-
-    delete compileOptions.externs;
-  }
+  const [externs, compileOptions] = normalizeExternOptions({ ...incomingCompileOptions });
 
   const options = {
     ...(await defaults(outputOptions, externs, transforms)),

src/transform.ts

@@ -15,7 +15,7 @@
  */
 
 import { logTransformChain } from './debug';
-import { TransformInterface } from './types';
+import { TransformInterface, PluginOptions } from './types';
 import { PluginContext, InputOptions, OutputOptions, TransformSourceDescription } from 'rollup';
 import { Mangle } from './transformers/mangle';
 import * as path from 'path';
@@ -25,18 +25,21 @@ import { createDecodedSourceMap, createExistingRawSourceMap } from './source-map
 
 class Transform implements TransformInterface {
   protected context: PluginContext;
+  protected pluginOptions: PluginOptions;
   protected mangler: Mangle;
   protected inputOptions: InputOptions;
   protected outputOptions: OutputOptions;
   public name: string = 'Transform';
 
   constructor(
     context: PluginContext,
+    pluginOptions: PluginOptions,
     mangler: Mangle,
     inputOptions: InputOptions,
     outputOptions: OutputOptions,
   ) {
     this.context = context;
+    this.pluginOptions = pluginOptions;
     this.mangler = mangler;
     this.inputOptions = inputOptions;
     this.outputOptions = outputOptions;

src/transformers/chunk/strict.ts

@@ -15,12 +15,33 @@
  */
 
 import { ChunkTransform } from '../../transform';
-import { Range, TransformInterface } from '../../types';
+import { Range, TransformInterface, PluginOptions } from '../../types';
 import { isESMFormat } from '../../options';
 import MagicString from 'magic-string';
 import { walk, parse } from '../../acorn';
 import { ExpressionStatement, SimpleLiteral } from 'estree';
 import { extname } from 'path';
+import { OutputOptions } from 'rollup';
+
+/**
+ * Determines if Strict Mode should be removed from output.
+ * @param pluginOptions
+ * @param outputOptions
+ * @param path
+ */
+function shouldRemoveStrictModeDeclarations(
+  pluginOptions: PluginOptions,
+  outputOptions: OutputOptions,
+  path: string | undefined,
+): boolean {
+  if ('remove_strict_directive' in pluginOptions) {
+    const removeDirective = pluginOptions['remove_strict_directive'];
+    return removeDirective === undefined || removeDirective === true;
+  }
+
+  const isESMOutput: boolean = !!(path && extname(path) === '.mjs');
+  return isESMFormat(outputOptions) || isESMOutput;
+}
 
 export default class StrictTransform extends ChunkTransform implements TransformInterface {
   public name = 'StrictTransform';
@@ -34,7 +55,7 @@ export default class StrictTransform extends ChunkTransform implements Transform
   public async post(source: MagicString): Promise<MagicString> {
     const { file } = this.outputOptions;
 
-    if (isESMFormat(this.outputOptions) || (file && extname(file) === '.mjs')) {
+    if (shouldRemoveStrictModeDeclarations(this.pluginOptions, this.outputOptions, file)) {
       const program = parse(source.toString());
 
       walk.simple(program, {

src/transformers/chunk/transforms.ts

@@ -30,6 +30,8 @@ import StrictTransform from './strict';
 import ConstTransform from './const';
 import { ChunkTransform, chunkLifecycle } from '../../transform';
 import { Mangle } from '../mangle';
+import { CompileOptions } from 'google-closure-compiler';
+import { pluckPluginOptions } from '../../options';
 
 const TRANSFORMS: Array<typeof ChunkTransform> = [
   ConstTransform,
@@ -44,17 +46,24 @@ const TRANSFORMS: Array<typeof ChunkTransform> = [
 /**
  * Instantiate transform class instances for the plugin invocation.
  * @param context Plugin context to bind for each transform instance.
+ * @param requestedCompileOptions Originally requested compile options from configuration.
+ * @param mangler Mangle instance used for this transform instance.
  * @param inputOptions Rollup input options
  * @param outputOptions Rollup output options
  * @return Instantiated transform class instances for the given entry point.
  */
-export const create = (
+export function create(
   context: PluginContext,
+  requestedCompileOptions: CompileOptions,
   mangler: Mangle,
   inputOptions: InputOptions,
   outputOptions: OutputOptions,
-): Array<ChunkTransform> =>
-  TRANSFORMS.map(transform => new transform(context, mangler, inputOptions, outputOptions));
+): Array<ChunkTransform> {
+  const pluginOptions = pluckPluginOptions(requestedCompileOptions);
+  return TRANSFORMS.map(
+    transform => new transform(context, pluginOptions, mangler, inputOptions, outputOptions),
+  );
+}
 
 /**
  * Run each transform's `preCompilation` phase.

src/transformers/source/transforms.ts

@@ -19,6 +19,7 @@ import { SourceTransform, sourceLifecycle } from '../../transform';
 // import { ExportTransform } from './exports';
 import { Mangle } from '../mangle';
 import { PluginContext, InputOptions, OutputOptions, TransformSourceDescription } from 'rollup';
+import { CompileOptions } from 'google-closure-compiler';
 
 const TRANSFORMS: Array<typeof SourceTransform> = [];
 // Temporarily disabling SourceTransforms, aligning for future release.
@@ -27,17 +28,20 @@ const TRANSFORMS: Array<typeof SourceTransform> = [];
 /**
  * Instantiate transform class instances for the plugin invocation.
  * @param context Plugin context to bind for each transform instance.
+ * @param requestedCompileOptions Originally requested compile options from configuration.
+ * @param mangler Mangle instance used for this transform instance.
  * @param inputOptions Rollup input options
  * @param outputOptions Rollup output options
  * @return Instantiated transform class instances for the given entry point.
  */
 export const create = (
   context: PluginContext,
+  requestedCompileOptions: CompileOptions,
   mangler: Mangle,
   inputOptions: InputOptions,
   outputOptions: OutputOptions,
 ): Array<SourceTransform> =>
-  TRANSFORMS.map(transform => new transform(context, mangler, inputOptions, outputOptions));
+  TRANSFORMS.map(transform => new transform(context, {}, mangler, inputOptions, outputOptions));
 
 /**
  * Run each transform's `transform` lifecycle.

src/types.ts

@@ -62,3 +62,7 @@ export type TransformMethod = (code: string) => Promise<MagicString>;
 export interface TransformInterface {
   name: string;
 }
+
+export interface PluginOptions {
+  [key: string]: string | boolean;
+}

test/strict-removal/fixtures/option.iife.default.js

@@ -0,0 +1 @@
+(function(a){a.thing=1;return a})({});

test/strict-removal/fixtures/option.js

@@ -0,0 +1,3 @@
+'use strict';
+
+export const thing = 1;

test/strict-removal/option.test.js

@@ -0,0 +1,31 @@
+/**
+ * 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 {
+  generator,
+  DEFAULT_CLOSURE_OPTIONS,
+  PRETTY_PRINT_CLOSURE_OPTIONS,
+  ADVANCED_CLOSURE_OPTIONS,
+  ES5_STRICT_CLOSURE_OPTIONS,
+} from '../generator';
+
+const closureOptions = {
+  default: Object.assign({}, DEFAULT_CLOSURE_OPTIONS.default, {
+    remove_strict_directive: true,
+  }),
+};
+
+generator('strict-removal', 'option', undefined, ['iife'], closureOptions);