@angular-devkit/build-optimizer 0.1101.4 → 0.1102.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-devkit/build-optimizer",
-  "version": "0.1101.4",
+  "version": "0.1102.0",
   "description": "Angular Build Optimizer",
   "experimental": true,
   "main": "src/index.js",

package/src/transforms/wrap-enums.js

@@ -21,7 +21,7 @@ function getWrapEnumsTransformer() {
     return (context) => {
         const transformer = sf => {
             const result = visitBlockStatements(sf.statements, context);
-            return ts.updateSourceFileNode(sf, ts.setTextRange(result, sf.statements));
+            return context.factory.updateSourceFile(sf, ts.setTextRange(result, sf.statements));
         };
         return transformer;
     };
@@ -30,6 +30,7 @@ exports.getWrapEnumsTransformer = getWrapEnumsTransformer;
 function visitBlockStatements(statements, context) {
     // copy of statements to modify; lazy initialized
     let updatedStatements;
+    const nodeFactory = context.factory;
     const visitor = (node) => {
         if (isBlockLike(node)) {
             let result = visitBlockStatements(node.statements, context);
@@ -39,13 +40,13 @@ function visitBlockStatements(statements, context) {
             result = ts.setTextRange(result, node.statements);
             switch (node.kind) {
                 case ts.SyntaxKind.Block:
-                    return ts.updateBlock(node, result);
+                    return nodeFactory.updateBlock(node, result);
                 case ts.SyntaxKind.ModuleBlock:
-                    return ts.updateModuleBlock(node, result);
+                    return nodeFactory.updateModuleBlock(node, result);
                 case ts.SyntaxKind.CaseClause:
-                    return ts.updateCaseClause(node, node.expression, result);
+                    return nodeFactory.updateCaseClause(node, node.expression, result);
                 case ts.SyntaxKind.DefaultClause:
-                    return ts.updateDefaultClause(node, result);
+                    return nodeFactory.updateDefaultClause(node, result);
                 default:
                     return node;
             }
@@ -85,7 +86,7 @@ function visitBlockStatements(statements, context) {
                     if (iife) {
                         // update IIFE and replace variable statement and old IIFE
                         oldStatementsLength = 2;
-                        newStatement = updateEnumIife(currentStatement, iife[0], iife[1]);
+                        newStatement = updateEnumIife(nodeFactory, currentStatement, iife[0], iife[1]);
                         // skip IIFE statement
                         oIndex++;
                     }
@@ -98,7 +99,7 @@ function visitBlockStatements(statements, context) {
                         continue;
                     }
                     oldStatementsLength = classStatements.length;
-                    newStatement = createWrappedClass(variableDeclaration, classStatements);
+                    newStatement = createWrappedClass(nodeFactory, variableDeclaration, classStatements);
                     oIndex += classStatements.length - 1;
                 }
             }
@@ -110,8 +111,8 @@ function visitBlockStatements(statements, context) {
                 continue;
             }
             oldStatementsLength = classStatements.length;
-            newStatement = createWrappedClass(currentStatement, classStatements);
-            oIndex += classStatements.length - 1;
+            newStatement = createWrappedClass(nodeFactory, currentStatement, classStatements);
+            oIndex += oldStatementsLength - 1;
         }
         if (newStatement && newStatement.length > 0) {
             if (!updatedStatements) {
@@ -132,7 +133,7 @@ function visitBlockStatements(statements, context) {
     }
     // if changes, return updated statements
     // otherwise, return original array instance
-    return updatedStatements ? ts.createNodeArray(updatedStatements) : statements;
+    return updatedStatements ? nodeFactory.createNodeArray(updatedStatements) : statements;
 }
 // TS 2.3 enums have statements that are inside a IIFE.
 function findEnumIife(name, statement) {
@@ -196,11 +197,11 @@ function findEnumIife(name, statement) {
     }
     return [callExpression, exportExpression];
 }
-function updateHostNode(hostNode, expression) {
+function updateHostNode(nodeFactory, hostNode, expression) {
     // Update existing host node with the pure comment before the variable declaration initializer.
     const variableDeclaration = hostNode.declarationList.declarations[0];
-    const outerVarStmt = ts.updateVariableStatement(hostNode, hostNode.modifiers, ts.updateVariableDeclarationList(hostNode.declarationList, [
-        ts.updateVariableDeclaration(variableDeclaration, variableDeclaration.name, variableDeclaration.type, expression),
+    const outerVarStmt = nodeFactory.updateVariableStatement(hostNode, hostNode.modifiers, nodeFactory.updateVariableDeclarationList(hostNode.declarationList, [
+        nodeFactory.updateVariableDeclaration(variableDeclaration, variableDeclaration.name, variableDeclaration.exclamationToken, variableDeclaration.type, expression),
     ]));
     return outerVarStmt;
 }
@@ -265,7 +266,7 @@ function findStatements(name, statements, statementIndex, offset = 0) {
     }
     return undefined;
 }
-function updateEnumIife(hostNode, iife, exportAssignment) {
+function updateEnumIife(nodeFactory, hostNode, iife, exportAssignment) {
     if (!ts.isParenthesizedExpression(iife.expression)
         || !ts.isFunctionExpression(iife.expression.expression)) {
         throw new Error('Invalid IIFE Structure');
@@ -276,55 +277,40 @@ function updateEnumIife(hostNode, iife, exportAssignment) {
         exportAssignment = undefined;
     }
     const expression = iife.expression.expression;
-    const updatedFunction = ts.updateFunctionExpression(expression, expression.modifiers, expression.asteriskToken, expression.name, expression.typeParameters, expression.parameters, expression.type, ts.updateBlock(expression.body, [
+    const updatedFunction = nodeFactory.updateFunctionExpression(expression, expression.modifiers, expression.asteriskToken, expression.name, expression.typeParameters, expression.parameters, expression.type, nodeFactory.updateBlock(expression.body, [
         ...expression.body.statements,
-        ts.createReturn(expression.parameters[0].name),
+        nodeFactory.createReturnStatement(expression.parameters[0].name),
     ]));
-    let arg = ts.createObjectLiteral();
+    let arg = nodeFactory.createObjectLiteralExpression();
     if (exportAssignment) {
-        arg = ts.createBinary(exportAssignment, ts.SyntaxKind.BarBarToken, arg);
+        arg = nodeFactory.createBinaryExpression(exportAssignment, ts.SyntaxKind.BarBarToken, arg);
     }
-    const updatedIife = ts.updateCall(iife, ts.updateParen(iife.expression, updatedFunction), iife.typeArguments, [arg]);
+    const updatedIife = nodeFactory.updateCallExpression(iife, nodeFactory.updateParenthesizedExpression(iife.expression, updatedFunction), iife.typeArguments, [arg]);
     let value = ast_utils_1.addPureComment(updatedIife);
     if (exportAssignment) {
-        value = ts.createBinary(exportAssignment, ts.SyntaxKind.FirstAssignment, updatedIife);
+        value = nodeFactory.createBinaryExpression(exportAssignment, ts.SyntaxKind.FirstAssignment, updatedIife);
     }
-    return [updateHostNode(hostNode, value)];
+    return [updateHostNode(nodeFactory, hostNode, value)];
 }
-function createWrappedEnum(name, hostNode, statements, literalInitializer = ts.createObjectLiteral(), addExportModifier = false) {
-    const node = addExportModifier
-        ? ts.updateVariableStatement(hostNode, [ts.createToken(ts.SyntaxKind.ExportKeyword)], hostNode.declarationList)
-        : hostNode;
-    const innerVarStmt = ts.createVariableStatement(undefined, ts.createVariableDeclarationList([
-        ts.createVariableDeclaration(name, undefined, literalInitializer),
-    ]));
-    const innerReturn = ts.createReturn(ts.createIdentifier(name));
-    const iife = ts.createImmediatelyInvokedFunctionExpression([
-        innerVarStmt,
-        ...statements,
-        innerReturn,
-    ]);
-    return [updateHostNode(node, ast_utils_1.addPureComment(ts.createParen(iife)))];
-}
-function createWrappedClass(hostNode, statements) {
+function createWrappedClass(nodeFactory, hostNode, statements) {
     const name = hostNode.name.text;
     const updatedStatements = [...statements];
     if (ts.isClassDeclaration(hostNode)) {
-        updatedStatements[0] = ts.createClassDeclaration(hostNode.decorators, undefined, hostNode.name, hostNode.typeParameters, hostNode.heritageClauses, hostNode.members);
+        updatedStatements[0] = nodeFactory.createClassDeclaration(hostNode.decorators, undefined, hostNode.name, hostNode.typeParameters, hostNode.heritageClauses, hostNode.members);
     }
-    const pureIife = ast_utils_1.addPureComment(ts.createImmediatelyInvokedArrowFunction([
+    const pureIife = ast_utils_1.addPureComment(nodeFactory.createImmediatelyInvokedArrowFunction([
         ...updatedStatements,
-        ts.createReturn(ts.createIdentifier(name)),
+        nodeFactory.createReturnStatement(nodeFactory.createIdentifier(name)),
     ]));
     const modifiers = hostNode.modifiers;
     const isDefault = !!modifiers
         && modifiers.some(x => x.kind === ts.SyntaxKind.DefaultKeyword);
     const newStatement = [];
-    newStatement.push(ts.createVariableStatement(isDefault ? undefined : modifiers, ts.createVariableDeclarationList([
-        ts.createVariableDeclaration(name, undefined, pureIife),
+    newStatement.push(nodeFactory.createVariableStatement(isDefault ? undefined : modifiers, nodeFactory.createVariableDeclarationList([
+        nodeFactory.createVariableDeclaration(name, undefined, undefined, pureIife),
     ], ts.NodeFlags.Let)));
     if (isDefault) {
-        newStatement.push(ts.createExportAssignment(undefined, undefined, false, ts.createIdentifier(name)));
+        newStatement.push(nodeFactory.createExportAssignment(undefined, undefined, false, nodeFactory.createIdentifier(name)));
     }
     return newStatement;
 }