Rename transformers to chunk-transformers (ampproject#284)

* Rename transformers to chunk-transformers
* Type information for SourceTransform
* Remove self = this references
* Support Source and Chunk Transforms
* dynamic test was missing advanced mode:
* Start of mangling imports
* Begin effort to repair sourcemaps using remapper
* Fix all tests, flag source transforms as unstable and decommit
* Create seperate file for sourcemapping
* Move from travis to github actions
* Disable code coverage temporarily
* Dont run tests on Windows, need to normalize cr versus lr

Author: kristoferbaxter

.github/disable_workflows/codecoverage.yml

@@ -0,0 +1,22 @@
+name: Tests
+
+on: [pull_request]
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        platform: [ubuntu-latest]
+        node-version: [12.x]
+    runs-on: ${{ matrix.platform }}
+    steps:
+    - uses: actions/checkout@v1
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
+    - run: yarn install
+    - run: yarn pretest
+    - run: yarn c8 ava
+    - run: yarn c8 report --reporter=lcovonly
+    - run: yarn codecov

.github/workflows/test.yml

@@ -0,0 +1,19 @@
+name: Tests
+
+on: [pull_request]
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        platform: [ubuntu-latest, macos-latest]
+        node-version: [12.x]
+    runs-on: ${{ matrix.platform }}
+    steps:
+    - uses: actions/checkout@v1
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
+    - run: yarn install
+    - run: yarn test

.travis.yml

@@ -25,7 +25,7 @@
     "precoverage": "yarn pretest && c8 ava",
     "coverage": "c8 report --reporter=html",
     "postcoverage": "sirv coverage/",
-    "build": "rimraf dist transpile && tsc -p tsconfig.json & wait",
+    "build": "rimraf dist transpile transpile-tests && tsc -p tsconfig.json & wait",
     "postbuild": "rollup -c",
     "release": "np",
     "prepublishOnly": "npm-run-all build"
@@ -34,8 +34,9 @@
     "rollup": ">=1.27"
   },
   "dependencies": {
+    "@ampproject/remapping": "0.2.0",
+    "@kristoferbaxter/estree-walker": "2.0.0",
     "acorn": "7.1.0",
-    "acorn-dynamic-import": "4.0.0",
     "acorn-walk": "7.0.0",
     "google-closure-compiler": "20200112.0.0",
     "magic-string": "0.25.6",
@@ -62,12 +63,10 @@
   },
   "lint-staged": {
     "*.ts": [
-      "prettier --config .prettierrc --write",
-      "git add"
+      "prettier --config .prettierrc --write"
     ],
     "*.test.js": [
-      "prettier --config .prettierrc --write",
-      "git add"
+      "prettier --config .prettierrc --write"
     ]
   },
   "husky": {

package.json

@@ -0,0 +1,132 @@
+/**
+ * Copyright 2020 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.
+ */
+
+declare module 'acorn-walk' {
+  type NodeType = import('estree').Node['type'];
+  type DiscriminateUnion<T, K extends keyof T, V extends T[K] = T[K]> = T extends Record<K, V>
+    ? T
+    : never;
+  type NarrowNode<K extends NodeType> = DiscriminateUnion<import('estree').Node, 'type', K>;
+
+  type FullWalkerCallback<TState> = (
+    node: import('estree').Node,
+    state: TState,
+    type: NodeType,
+  ) => void;
+
+  type FullAncestorWalkerCallback<TState> = (
+    node: import('estree').Node,
+    state: TState | import('estree').Node[],
+    ancestors: import('estree').Node[],
+    type: NodeType,
+  ) => void;
+  type WalkerCallback<TState> = (node: import('estree').Node, state: TState) => void;
+
+  type SimpleWalkerFn<K extends NodeType, TState> = (node: NarrowNode<K>, state: TState) => void;
+
+  type AncestorWalkerFn<K extends NodeType, TState> = (
+    node: NarrowNode<K>,
+    state: TState | import('estree').Node[],
+    ancestors: import('estree').Node[],
+  ) => void;
+
+  type RecursiveWalkerFn<K extends NodeType, TState> = (
+    node: NarrowNode<K>,
+    state: TState,
+    callback: WalkerCallback<TState>,
+  ) => void;
+
+  type SimpleVisitors<Types extends NodeType, TState> = {
+    [Type in Types]: SimpleWalkerFn<Type, TState>;
+  };
+
+  type AncestorVisitors<Types extends NodeType, TState> = {
+    [Type in Types]: AncestorWalkerFn<Type, TState>;
+  };
+
+  type RecursiveVisitors<Types extends NodeType, TState> = {
+    [Type in Types]: RecursiveWalkerFn<Type, TState>;
+  };
+
+  type FindPredicate = (type: NodeType, node: import('estree').Node) => boolean;
+
+  interface Found<Type extends NodeType, TState> {
+    node: NarrowNode<Type>;
+    state: TState;
+  }
+
+  export function simple<TState, K extends NodeType>(
+    node: import('estree').Node,
+    visitors: SimpleVisitors<K, TState>,
+    base?: RecursiveVisitors<NodeType, TState>,
+    state?: TState,
+  ): void;
+
+  export function ancestor<TState, K extends NodeType>(
+    node: import('estree').Node,
+    visitors: AncestorVisitors<K, TState>,
+    base?: RecursiveVisitors<NodeType, TState>,
+    state?: TState,
+  ): void;
+
+  export function recursive<TState, K extends NodeType>(
+    node: import('estree').Node,
+    state: TState,
+    functions: RecursiveVisitors<K, TState>,
+    base?: RecursiveVisitors<NodeType, TState>,
+  ): void;
+
+  export function full<TState>(
+    node: import('estree').Node,
+    callback: FullWalkerCallback<TState>,
+    base?: RecursiveVisitors<NodeType, TState>,
+    state?: TState,
+  ): void;
+
+  export function fullAncestor<TState>(
+    node: import('estree').Node,
+    callback: FullAncestorWalkerCallback<TState>,
+    base?: RecursiveVisitors<NodeType, TState>,
+    state?: TState,
+  ): void;
+
+  export function make<TState, K extends NodeType>(
+    functions: RecursiveVisitors<K, TState>,
+    base?: RecursiveVisitors<NodeType, TState>,
+  ): RecursiveVisitors<NodeType, TState>;
+
+  export function findNodeAt<TState, K extends NodeType>(
+    node: import('estree').Node,
+    start: number | undefined,
+    end: number | undefined,
+    type: K,
+    base?: RecursiveVisitors<NodeType, TState>,
+    state?: TState,
+  ): Found<K, TState> | undefined;
+
+  export function findNodeAt<TState>(
+    node: import('estree').Node,
+    start: number | undefined,
+    end: number | undefined,
+    type?: FindPredicate,
+    base?: RecursiveVisitors<NodeType, TState>,
+    state?: TState,
+  ): Found<NodeType, TState> | undefined;
+
+  export const findNodeAround: typeof findNodeAt;
+
+  export const findNodeAfter: typeof findNodeAt;
+}

src/acorn-walk.d.ts

@@ -14,32 +14,92 @@
  * limitations under the License.
  */
 
-import { Program } from 'estree';
-import { DYNAMIC_IMPORT_DECLARATION } from './types';
-const acorn = require('acorn');
+import {
+  Program,
+  BaseNode,
+  Identifier,
+  ImportDeclaration,
+  VariableDeclarator,
+  BlockStatement,
+  ExportNamedDeclaration,
+  ExportDefaultDeclaration,
+  ExportAllDeclaration,
+  FunctionDeclaration,
+  VariableDeclaration,
+  ClassDeclaration,
+  ExportSpecifier,
+} from 'estree';
+// import { DYNAMIC_IMPORT_DECLARATION } from './types';
+import * as acorn from 'acorn';
+// const acorn = require('acorn');
 const acornWalk = require('acorn-walk');
-const dynamicImport = require('acorn-dynamic-import');
+// const dynamicImport = require('acorn-dynamic-import');
 
-const DYNAMIC_IMPORT_BASEVISITOR = Object.assign({}, acornWalk.base, {
-  [DYNAMIC_IMPORT_DECLARATION]: () => {},
-});
+// const DYNAMIC_IMPORT_BASEVISITOR = Object.assign({}, acornWalk.base, {
+//   [DYNAMIC_IMPORT_DECLARATION]: () => {},
+// });
 
 export const walk = {
-  simple(node: Program, visitors: any): void {
-    acornWalk.simple(node, visitors, DYNAMIC_IMPORT_BASEVISITOR);
-  },
-  ancestor(node: Program, visitors: any): void {
-    acornWalk.ancestor(node, visitors, DYNAMIC_IMPORT_BASEVISITOR);
-  },
+  simple: acornWalk.simple,
+  ancestor: acornWalk.ancestor,
+  // simple(node: Program, visitors: any): void {
+  //   acornWalk.simple(node, visitors, DYNAMIC_IMPORT_BASEVISITOR);
+  // },
+  // ancestor(node: Program, visitors: any): void {
+  //   acornWalk.ancestor(node, visitors, DYNAMIC_IMPORT_BASEVISITOR);
+  // },
 };
 
 const DEFAULT_ACORN_OPTIONS = {
-  ecmaVersion: 2019,
-  sourceType: 'module',
+  ecmaVersion: 2020 as any,
+  sourceType: 'module' as any,
   preserveParens: false,
   ranges: true,
 };
 
 export function parse(source: string): Program {
-  return acorn.Parser.extend(dynamicImport.default).parse(source, DEFAULT_ACORN_OPTIONS);
+  return (acorn.parse(source, DEFAULT_ACORN_OPTIONS) as unknown) as Program;
+  // return acorn.Parser.extend(dynamicImport.default).parse(source, DEFAULT_ACORN_OPTIONS);
+}
+
+export function isIdentifier(node: BaseNode): node is Identifier {
+  return node.type === 'Identifier';
+}
+export function isImportDeclaration(node: BaseNode): node is ImportDeclaration {
+  return node.type === 'ImportDeclaration';
+}
+export function isImportExpression(node: BaseNode): boolean {
+  // @types/estree does not yet support 2020 addons to ECMA.
+  // This includes ImportExpression ... import("thing")
+  return node.type === 'ImportExpression';
+}
+export function isVariableDeclarator(node: BaseNode): node is VariableDeclarator {
+  return node.type === 'VariableDeclarator';
+}
+export function isBlockStatement(node: BaseNode): node is BlockStatement {
+  return node.type === 'BlockStatement';
+}
+export function isProgram(node: BaseNode): node is Program {
+  return node.type === 'Program';
+}
+export function isExportNamedDeclaration(node: BaseNode): node is ExportNamedDeclaration {
+  return node.type === 'ExportNamedDeclaration';
+}
+export function isExportDefaultDeclaration(node: BaseNode): node is ExportDefaultDeclaration {
+  return node.type === 'ExportDefaultDeclaration';
+}
+export function isExportAllDeclaration(node: BaseNode): node is ExportAllDeclaration {
+  return node.type === 'ExportAllDeclaration';
+}
+export function isFunctionDeclaration(node: BaseNode): node is FunctionDeclaration {
+  return node.type === 'FunctionDeclaration';
+}
+export function isVariableDeclaration(node: BaseNode): node is VariableDeclaration {
+  return node.type === 'VariableDeclaration';
+}
+export function isClassDeclaration(node: BaseNode): node is ClassDeclaration {
+  return node.type === 'ClassDeclaration';
+}
+export function isExportSpecifier(node: BaseNode): node is ExportSpecifier {
+  return node.type === 'ExportSpecifier';
 }

src/acorn.ts

@@ -19,9 +19,9 @@ const {
   getNativeImagePath,
   getFirstSupportedPlatform,
 } = require('google-closure-compiler/lib/utils.js');
-import { Transform } from './types';
-import { postCompilation } from './transforms';
+import { postCompilation } from './transformers/chunk/transforms';
 import { RenderedChunk } from 'rollup';
+import { ChunkTransform } from './transform';
 
 enum Platform {
   NATIVE = 'native',
@@ -73,7 +73,7 @@ function orderPlatforms(platformPreference: Platform | string): Array<Platform>
 export default function(
   compileOptions: CompileOptions,
   chunk: RenderedChunk,
-  transforms: Array<Transform>,
+  transforms: Array<ChunkTransform>,
 ): Promise<string> {
   return new Promise((resolve: (stdOut: string) => void, reject: (error: any) => void) => {
     const [config, platform] = filterContent(compileOptions);
@@ -97,7 +97,8 @@ export default function(
       } else if (exitCode !== 0) {
         reject(new Error(`Google Closure Compiler exit ${exitCode}: ${stdErr}`));
       } else {
-        resolve(await postCompilation(code, chunk, transforms));
+        const postCompiled = await postCompilation(code, chunk, transforms);
+        resolve(postCompiled.code);
       }
     });
   });