@ngtools/webpack 11.1.4 → 11.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngtools/webpack",
-  "version": "11.1.4",
+  "version": "11.2.0",
   "description": "Webpack plugin that AoT compiles your Angular components and modules.",
   "main": "./src/index.js",
   "typings": "src/index.d.ts",
@@ -25,12 +25,12 @@
   },
   "homepage": "https://github.com/angular/angular-cli",
   "dependencies": {
-    "@angular-devkit/core": "11.1.4",
-    "enhanced-resolve": "5.6.0",
+    "@angular-devkit/core": "11.2.0",
+    "enhanced-resolve": "5.7.0",
     "webpack-sources": "2.2.0"
   },
   "peerDependencies": {
-    "@angular/compiler-cli": "^11.0.0",
+    "@angular/compiler-cli": "^11.0.0 || ^11.2.0-next",
     "typescript": "~4.0.0 || ~4.1.0",
     "webpack": "^4.0.0"
   },

package/src/angular_compiler_plugin.js

@@ -98,13 +98,13 @@ class AngularCompilerPlugin {
             basePath = path.resolve(process.cwd(), options.basePath);
         }
         // Parse the tsconfig contents.
-        const config = compiler_cli_1.readConfiguration(this._tsConfigPath);
-        if (config.errors && config.errors.length) {
-            throw new Error(compiler_cli_1.formatDiagnostics(config.errors));
+        const { errors, rootNames, options: compilerOptions } = compiler_cli_1.readConfiguration(this._tsConfigPath, options.compilerOptions);
+        if (errors && errors.length) {
+            throw new Error(compiler_cli_1.formatDiagnostics(errors));
         }
-        this._rootNames = config.rootNames;
-        this._compilerOptions = { ...config.options, ...options.compilerOptions };
-        this._basePath = config.options.basePath || basePath || '';
+        this._rootNames = rootNames;
+        this._compilerOptions = compilerOptions;
+        this._basePath = compilerOptions.basePath || basePath || '';
         // Overwrite outDir so we can find generated files next to their .ts origin in compilerHost.
         this._compilerOptions.outDir = '';
         this._compilerOptions.suppressOutputPathCheck = true;

package/src/ivy/plugin.d.ts

@@ -27,11 +27,14 @@ export declare class AngularWebpackPlugin {
     private buildTimestamp;
     private readonly lazyRouteMap;
     private readonly requiredFilesToEmit;
+    private readonly requiredFilesToEmitCache;
+    private readonly fileEmitHistory;
     constructor(options?: Partial<AngularPluginOptions>);
     get options(): AngularPluginOptions;
     apply(compiler: Compiler & {
         watchMode?: boolean;
     }): void;
+    private rebuildRequiredFiles;
     private loadConfiguration;
     private updateAotProgram;
     private updateJitProgram;

package/src/ivy/plugin.js

@@ -10,6 +10,7 @@ exports.AngularWebpackPlugin = void 0;
  */
 const compiler_cli_1 = require("@angular/compiler-cli");
 const program_1 = require("@angular/compiler-cli/src/ngtsc/program");
+const crypto_1 = require("crypto");
 const path = require("path");
 const ts = require("typescript");
 const webpack_1 = require("webpack");
@@ -34,11 +35,16 @@ function initializeNgccProcessor(compiler, tsconfig) {
     const processor = new ngcc_processor_1.NgccProcessor(mainFields, warnings, errors, compiler.context, tsconfig, inputFileSystem, (_b = webpackOptions.resolve) === null || _b === void 0 ? void 0 : _b.symlinks);
     return { processor, errors, warnings };
 }
+function hashContent(content) {
+    return crypto_1.createHash('md5').update(content).digest();
+}
 const PLUGIN_NAME = 'angular-compiler';
 class AngularWebpackPlugin {
     constructor(options = {}) {
         this.lazyRouteMap = {};
         this.requiredFilesToEmit = new Set();
+        this.requiredFilesToEmitCache = new Map();
+        this.fileEmitHistory = new Map();
         this.pluginOptions = {
             emitClassMetadata: false,
             emitNgModuleScope: false,
@@ -152,19 +158,7 @@ class AngularWebpackPlugin {
             }
             compilation.hooks.finishModules.tapPromise(PLUGIN_NAME, async (modules) => {
                 // Rebuild any remaining AOT required modules
-                const rebuild = (filename) => new Promise((resolve) => {
-                    const module = modules.find(({ resource }) => resource && paths_1.normalizePath(resource) === filename);
-                    if (!module) {
-                        resolve();
-                    }
-                    else {
-                        compilation.rebuildModule(module, resolve);
-                    }
-                });
-                for (const requiredFile of this.requiredFilesToEmit) {
-                    await rebuild(requiredFile);
-                }
-                this.requiredFilesToEmit.clear();
+                await this.rebuildRequiredFiles(modules, compilation, fileEmitter);
                 // Analyze program for unused files
                 if (compilation.errors.length > 0) {
                     return;
@@ -192,6 +186,41 @@ class AngularWebpackPlugin {
             compilation[symbol_1.AngularPluginSymbol] = fileEmitter;
         });
     }
+    async rebuildRequiredFiles(modules, compilation, fileEmitter) {
+        if (this.requiredFilesToEmit.size === 0) {
+            return;
+        }
+        const rebuild = (webpackModule) => new Promise((resolve) => compilation.rebuildModule(webpackModule, resolve));
+        const filesToRebuild = new Set();
+        for (const requiredFile of this.requiredFilesToEmit) {
+            const history = this.fileEmitHistory.get(requiredFile);
+            if (history) {
+                const emitResult = await fileEmitter(requiredFile);
+                if ((emitResult === null || emitResult === void 0 ? void 0 : emitResult.content) === undefined ||
+                    history.length !== emitResult.content.length ||
+                    emitResult.hash === undefined ||
+                    Buffer.compare(history.hash, emitResult.hash) !== 0) {
+                    // New emit result is different so rebuild using new emit result
+                    this.requiredFilesToEmitCache.set(requiredFile, emitResult);
+                    filesToRebuild.add(requiredFile);
+                }
+            }
+            else {
+                // No emit history so rebuild
+                filesToRebuild.add(requiredFile);
+            }
+        }
+        if (filesToRebuild.size > 0) {
+            for (const webpackModule of [...modules]) {
+                const resource = webpackModule.resource;
+                if (resource && filesToRebuild.has(paths_1.normalizePath(resource))) {
+                    await rebuild(webpackModule);
+                }
+            }
+        }
+        this.requiredFilesToEmit.clear();
+        this.requiredFilesToEmitCache.clear();
+    }
     loadConfiguration(compilation) {
         const { options: compilerOptions, rootNames, errors } = compiler_cli_1.readConfiguration(this.pluginOptions.tsconfig, this.pluginOptions.compilerOptions);
         compilerOptions.enableIvy = true;
@@ -355,12 +384,15 @@ class AngularWebpackPlugin {
     }
     createFileEmitter(program, transformers = {}, getExtraDependencies, onAfterEmit) {
         return async (file) => {
+            if (this.requiredFilesToEmitCache.has(file)) {
+                return this.requiredFilesToEmitCache.get(file);
+            }
             const sourceFile = program.getSourceFile(file);
             if (!sourceFile) {
                 return undefined;
             }
-            let content = undefined;
-            let map = undefined;
+            let content;
+            let map;
             program.emit(sourceFile, (filename, data) => {
                 if (filename.endsWith('.map')) {
                     map = data;
@@ -370,11 +402,17 @@ class AngularWebpackPlugin {
                 }
             }, undefined, undefined, transformers);
             onAfterEmit === null || onAfterEmit === void 0 ? void 0 : onAfterEmit(sourceFile);
+            let hash;
+            if (content !== undefined && this.watchMode) {
+                // Capture emit history info for Angular rebuild analysis
+                hash = hashContent(content);
+                this.fileEmitHistory.set(file, { length: content.length, hash });
+            }
             const dependencies = [
                 ...program.getAllDependencies(sourceFile),
                 ...getExtraDependencies(sourceFile),
             ].map(paths_1.externalizePath);
-            return { content, map, dependencies };
+            return { content, map, dependencies, hash };
         };
     }
 }

package/src/ivy/symbol.d.ts

@@ -10,5 +10,6 @@ export interface EmitFileResult {
     content?: string;
     map?: string;
     dependencies: readonly string[];
+    hash?: Uint8Array;
 }
 export declare type FileEmitter = (file: string) => Promise<EmitFileResult | undefined>;

package/src/ivy/transformation.js

@@ -60,16 +60,17 @@ function replaceBootstrap(getTypeChecker) {
         let bootstrapImport;
         let bootstrapNamespace;
         const replacedNodes = [];
+        const nodeFactory = context.factory;
         const visitNode = (node) => {
             if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
                 const target = node.expression;
                 if (target.text === 'platformBrowserDynamic') {
                     if (!bootstrapNamespace) {
-                        bootstrapNamespace = ts.createUniqueName('__NgCli_bootstrap_');
-                        bootstrapImport = ts.createImportDeclaration(undefined, undefined, ts.createImportClause(undefined, ts.createNamespaceImport(bootstrapNamespace)), ts.createLiteral('@angular/platform-browser'));
+                        bootstrapNamespace = nodeFactory.createUniqueName('__NgCli_bootstrap_');
+                        bootstrapImport = nodeFactory.createImportDeclaration(undefined, undefined, nodeFactory.createImportClause(false, undefined, nodeFactory.createNamespaceImport(bootstrapNamespace)), nodeFactory.createStringLiteral('@angular/platform-browser'));
                     }
                     replacedNodes.push(target);
-                    return ts.updateCall(node, ts.createPropertyAccess(bootstrapNamespace, 'platformBrowser'), node.typeArguments, node.arguments);
+                    return nodeFactory.updateCallExpression(node, nodeFactory.createPropertyAccessExpression(bootstrapNamespace, 'platformBrowser'), node.typeArguments, node.arguments);
                 }
             }
             return ts.visitEachChild(node, visitNode, context);
@@ -83,7 +84,7 @@ function replaceBootstrap(getTypeChecker) {
                     updatedSourceFile = ts.visitEachChild(updatedSourceFile, (node) => (removals.includes(node) ? undefined : node), context);
                 }
                 // Add new platform browser import
-                return ts.updateSourceFileNode(updatedSourceFile, ts.setTextRange(ts.createNodeArray([bootstrapImport, ...updatedSourceFile.statements]), sourceFile.statements));
+                return nodeFactory.updateSourceFile(updatedSourceFile, ts.setTextRange(nodeFactory.createNodeArray([bootstrapImport, ...updatedSourceFile.statements]), sourceFile.statements));
             }
             else {
                 return updatedSourceFile;

package/src/transformers/export_ngfactory.js

@@ -45,8 +45,8 @@ function exportNgFactory(shouldTransform, getEntryModule) {
             // Add the transform operations.
             const factoryClassName = entryModule.className + 'NgFactory';
             const factoryModulePath = normalizedEntryModulePath + '.ngfactory';
-            const namedExports = ts.createNamedExports([ts.createExportSpecifier(undefined, ts.createIdentifier(factoryClassName))]);
-            const newImport = ts.createExportDeclaration(undefined, undefined, namedExports, ts.createLiteral(factoryModulePath));
+            const namedExports = ts.factory.createNamedExports([ts.factory.createExportSpecifier(undefined, ts.factory.createIdentifier(factoryClassName))]);
+            const newImport = ts.factory.createExportDeclaration(undefined, undefined, false, namedExports, ts.factory.createStringLiteral(factoryModulePath));
             const firstNode = ast_helpers_1.getFirstNode(sourceFile);
             if (firstNode) {
                 ops.push(new interfaces_1.AddNodeOperation(sourceFile, firstNode, newImport));

package/src/transformers/import_factory.js

@@ -183,11 +183,11 @@ function replaceImport(node, context, emitWarning, fileName, typeChecker) {
     const replacementVisitor = (node) => {
         if (node === importStringLit) {
             // Transform the import string.
-            return ts.createStringLiteral(newImportString);
+            return ts.factory.createStringLiteral(newImportString);
         }
         else if (node === exportNameId) {
             // Transform the export name.
-            return ts.createIdentifier(exportNameId.text + 'NgFactory');
+            return ts.factory.createIdentifier(exportNameId.text + 'NgFactory');
         }
         return ts.visitEachChild(node, replacementVisitor, context);
     };

package/src/transformers/insert_import.js

@@ -16,9 +16,9 @@ function insertStarImport(sourceFile, identifier, modulePath, target, before = f
     const allImports = ast_helpers_1.collectDeepNodes(sourceFile, ts.SyntaxKind.ImportDeclaration);
     // We don't need to verify if the symbol is already imported, star imports should be unique.
     // Create the new import node.
-    const namespaceImport = ts.createNamespaceImport(identifier);
-    const importClause = ts.createImportClause(undefined, namespaceImport);
-    const newImport = ts.createImportDeclaration(undefined, undefined, importClause, ts.createLiteral(modulePath));
+    const namespaceImport = ts.factory.createNamespaceImport(identifier);
+    const importClause = ts.factory.createImportClause(false, undefined, namespaceImport);
+    const newImport = ts.factory.createImportDeclaration(undefined, undefined, importClause, ts.factory.createStringLiteral(modulePath));
     if (target) {
         ops.push(new interfaces_1.AddNodeOperation(sourceFile, target, before ? newImport : undefined, before ? undefined : newImport));
     }
@@ -71,13 +71,13 @@ function insertImport(sourceFile, symbolName, modulePath) {
             return ops;
         }
         // Just pick the first one and insert at the end of its identifier list.
-        ops.push(new interfaces_1.AddNodeOperation(sourceFile, maybeImports[0].elements[maybeImports[0].elements.length - 1], undefined, ts.createImportSpecifier(undefined, ts.createIdentifier(symbolName))));
+        ops.push(new interfaces_1.AddNodeOperation(sourceFile, maybeImports[0].elements[maybeImports[0].elements.length - 1], undefined, ts.factory.createImportSpecifier(undefined, ts.factory.createIdentifier(symbolName))));
     }
     else {
         // Create the new import node.
-        const namedImports = ts.createNamedImports([ts.createImportSpecifier(undefined, ts.createIdentifier(symbolName))]);
-        const importClause = ts.createImportClause(undefined, namedImports);
-        const newImport = ts.createImportDeclaration(undefined, undefined, importClause, ts.createLiteral(modulePath));
+        const namedImports = ts.factory.createNamedImports([ts.factory.createImportSpecifier(undefined, ts.factory.createIdentifier(symbolName))]);
+        const importClause = ts.factory.createImportClause(false, undefined, namedImports);
+        const newImport = ts.factory.createImportDeclaration(undefined, undefined, importClause, ts.factory.createStringLiteral(modulePath));
         if (allImports.length > 0) {
             // Find the last import and insert after.
             ops.push(new interfaces_1.AddNodeOperation(sourceFile, allImports[allImports.length - 1], undefined, newImport));

package/src/transformers/register_locale_data.js

@@ -47,15 +47,15 @@ function registerLocaleData(shouldTransform, getEntryModule, locale) {
                 return;
             }
             // Create the import node for the locale.
-            const localeNamespaceId = ts.createUniqueName('__NgCli_locale_');
+            const localeNamespaceId = ts.factory.createUniqueName('__NgCli_locale_');
             ops.push(...insert_import_1.insertStarImport(sourceFile, localeNamespaceId, `@angular/common/locales/${locale}`, firstNode, true));
             // Create the import node for the registerLocaleData function.
-            const regIdentifier = ts.createIdentifier(`registerLocaleData`);
-            const regNamespaceId = ts.createUniqueName('__NgCli_locale_');
+            const regIdentifier = ts.factory.createIdentifier(`registerLocaleData`);
+            const regNamespaceId = ts.factory.createUniqueName('__NgCli_locale_');
             ops.push(...insert_import_1.insertStarImport(sourceFile, regNamespaceId, '@angular/common', firstNode, true));
             // Create the register function call
-            const registerFunctionCall = ts.createCall(ts.createPropertyAccess(regNamespaceId, regIdentifier), undefined, [ts.createPropertyAccess(localeNamespaceId, 'default')]);
-            const registerFunctionStatement = ts.createStatement(registerFunctionCall);
+            const registerFunctionCall = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(regNamespaceId, regIdentifier), undefined, [ts.factory.createPropertyAccessExpression(localeNamespaceId, 'default')]);
+            const registerFunctionStatement = ts.factory.createExpressionStatement(registerFunctionCall);
             ops.push(new interfaces_1.AddNodeOperation(sourceFile, firstNode, registerFunctionStatement));
         });
         return ops;

package/src/transformers/replace_bootstrap.js

@@ -51,8 +51,8 @@ function replaceBootstrap(shouldTransform, getEntryModule, getTypeChecker, useFa
                 return;
             }
             const platformBrowserDynamicIdentifier = innerCallExpr.expression;
-            const idPlatformBrowser = ts.createUniqueName('__NgCli_bootstrap_');
-            const idNgFactory = ts.createUniqueName('__NgCli_bootstrap_');
+            const idPlatformBrowser = ts.factory.createUniqueName('__NgCli_bootstrap_');
+            const idNgFactory = ts.factory.createUniqueName('__NgCli_bootstrap_');
             // Add the transform operations.
             const relativeEntryModulePath = path_1.relative(path_1.dirname(sourceFile.fileName), entryModule.path);
             let className = entryModule.className;
@@ -65,9 +65,9 @@ function replaceBootstrap(shouldTransform, getEntryModule, getTypeChecker, useFa
             }
             ops.push(
             // Replace the entry module import.
-            ...insert_import_1.insertStarImport(sourceFile, idNgFactory, modulePath), new interfaces_1.ReplaceNodeOperation(sourceFile, entryModuleIdentifier, ts.createPropertyAccess(idNgFactory, ts.createIdentifier(className))), 
+            ...insert_import_1.insertStarImport(sourceFile, idNgFactory, modulePath), new interfaces_1.ReplaceNodeOperation(sourceFile, entryModuleIdentifier, ts.factory.createPropertyAccessExpression(idNgFactory, ts.factory.createIdentifier(className))), 
             // Replace the platformBrowserDynamic import.
-            ...insert_import_1.insertStarImport(sourceFile, idPlatformBrowser, '@angular/platform-browser'), new interfaces_1.ReplaceNodeOperation(sourceFile, platformBrowserDynamicIdentifier, ts.createPropertyAccess(idPlatformBrowser, 'platformBrowser')), new interfaces_1.ReplaceNodeOperation(sourceFile, bootstrapModuleIdentifier, ts.createIdentifier(bootstrapIdentifier)));
+            ...insert_import_1.insertStarImport(sourceFile, idPlatformBrowser, '@angular/platform-browser'), new interfaces_1.ReplaceNodeOperation(sourceFile, platformBrowserDynamicIdentifier, ts.factory.createPropertyAccessExpression(idPlatformBrowser, 'platformBrowser')), new interfaces_1.ReplaceNodeOperation(sourceFile, bootstrapModuleIdentifier, ts.factory.createIdentifier(bootstrapIdentifier)));
         });
         return ops;
     };

package/src/transformers/replace_resources.js

@@ -14,12 +14,13 @@ function replaceResources(shouldTransform, getTypeChecker, directTemplateLoading
         const typeChecker = getTypeChecker();
         const resourceImportDeclarations = [];
         const moduleKind = context.getCompilerOptions().module;
+        const nodeFactory = context.factory;
         const visitNode = (node) => {
             if (ts.isClassDeclaration(node)) {
                 const decorators = ts.visitNodes(node.decorators, node => ts.isDecorator(node)
-                    ? visitDecorator(node, typeChecker, directTemplateLoading, resourceImportDeclarations, moduleKind)
+                    ? visitDecorator(nodeFactory, node, typeChecker, directTemplateLoading, resourceImportDeclarations, moduleKind)
                     : node);
-                return ts.updateClassDeclaration(node, decorators, node.modifiers, node.name, node.typeParameters, node.heritageClauses, node.members);
+                return nodeFactory.updateClassDeclaration(node, decorators, node.modifiers, node.name, node.typeParameters, node.heritageClauses, node.members);
             }
             return ts.visitEachChild(node, visitNode, context);
         };
@@ -30,7 +31,7 @@ function replaceResources(shouldTransform, getTypeChecker, directTemplateLoading
             const updatedSourceFile = ts.visitNode(sourceFile, visitNode);
             if (resourceImportDeclarations.length) {
                 // Add resource imports
-                return ts.updateSourceFileNode(updatedSourceFile, ts.setTextRange(ts.createNodeArray([
+                return context.factory.updateSourceFile(updatedSourceFile, ts.setTextRange(context.factory.createNodeArray([
                     ...resourceImportDeclarations,
                     ...updatedSourceFile.statements,
                 ]), updatedSourceFile.statements));
@@ -40,7 +41,7 @@ function replaceResources(shouldTransform, getTypeChecker, directTemplateLoading
     };
 }
 exports.replaceResources = replaceResources;
-function visitDecorator(node, typeChecker, directTemplateLoading, resourceImportDeclarations, moduleKind) {
+function visitDecorator(nodeFactory, node, typeChecker, directTemplateLoading, resourceImportDeclarations, moduleKind) {
     if (!isComponentDecorator(node, typeChecker)) {
         return node;
     }
@@ -57,18 +58,18 @@ function visitDecorator(node, typeChecker, directTemplateLoading, resourceImport
     const styleReplacements = [];
     // visit all properties
     let properties = ts.visitNodes(objectExpression.properties, node => ts.isObjectLiteralElementLike(node)
-        ? visitComponentMetadata(node, styleReplacements, directTemplateLoading, resourceImportDeclarations, moduleKind)
+        ? visitComponentMetadata(nodeFactory, node, styleReplacements, directTemplateLoading, resourceImportDeclarations, moduleKind)
         : node);
     // replace properties with updated properties
     if (styleReplacements.length > 0) {
-        const styleProperty = ts.createPropertyAssignment(ts.createIdentifier('styles'), ts.createArrayLiteral(styleReplacements));
-        properties = ts.createNodeArray([...properties, styleProperty]);
+        const styleProperty = nodeFactory.createPropertyAssignment(nodeFactory.createIdentifier('styles'), nodeFactory.createArrayLiteralExpression(styleReplacements));
+        properties = nodeFactory.createNodeArray([...properties, styleProperty]);
     }
-    return ts.updateDecorator(node, ts.updateCall(decoratorFactory, decoratorFactory.expression, decoratorFactory.typeArguments, [
-        ts.updateObjectLiteral(objectExpression, properties),
+    return nodeFactory.updateDecorator(node, nodeFactory.updateCallExpression(decoratorFactory, decoratorFactory.expression, decoratorFactory.typeArguments, [
+        nodeFactory.updateObjectLiteralExpression(objectExpression, properties),
     ]));
 }
-function visitComponentMetadata(node, styleReplacements, directTemplateLoading, resourceImportDeclarations, moduleKind) {
+function visitComponentMetadata(nodeFactory, node, styleReplacements, directTemplateLoading, resourceImportDeclarations, moduleKind) {
     if (!ts.isPropertyAssignment(node) || ts.isComputedPropertyName(node.name)) {
         return node;
     }
@@ -77,11 +78,11 @@ function visitComponentMetadata(node, styleReplacements, directTemplateLoading,
         case 'moduleId':
             return undefined;
         case 'templateUrl':
-            const importName = createResourceImport(node.initializer, directTemplateLoading ? '!raw-loader!' : '', resourceImportDeclarations, moduleKind);
+            const importName = createResourceImport(nodeFactory, node.initializer, directTemplateLoading ? '!raw-loader!' : '', resourceImportDeclarations, moduleKind);
             if (!importName) {
                 return node;
             }
-            return ts.updatePropertyAssignment(node, ts.createIdentifier('template'), importName);
+            return nodeFactory.updatePropertyAssignment(node, nodeFactory.createIdentifier('template'), importName);
         case 'styles':
         case 'styleUrls':
             if (!ts.isArrayLiteralExpression(node.initializer)) {
@@ -93,9 +94,9 @@ function visitComponentMetadata(node, styleReplacements, directTemplateLoading,
                     return node;
                 }
                 if (isInlineStyles) {
-                    return ts.createLiteral(node.text);
+                    return nodeFactory.createStringLiteral(node.text);
                 }
-                return createResourceImport(node, undefined, resourceImportDeclarations, moduleKind) || node;
+                return createResourceImport(nodeFactory, node, undefined, resourceImportDeclarations, moduleKind) || node;
             });
             // Styles should be placed first
             if (isInlineStyles) {
@@ -127,18 +128,18 @@ function isComponentDecorator(node, typeChecker) {
     }
     return false;
 }
-function createResourceImport(node, loader, resourceImportDeclarations, moduleKind = ts.ModuleKind.ES2015) {
+function createResourceImport(nodeFactory, node, loader, resourceImportDeclarations, moduleKind = ts.ModuleKind.ES2015) {
     const url = getResourceUrl(node, loader);
     if (!url) {
         return null;
     }
-    const urlLiteral = ts.createLiteral(url);
+    const urlLiteral = nodeFactory.createStringLiteral(url);
     if (moduleKind < ts.ModuleKind.ES2015) {
-        return ts.createPropertyAccess(ts.createCall(ts.createIdentifier('require'), [], [urlLiteral]), 'default');
+        return nodeFactory.createPropertyAccessExpression(nodeFactory.createCallExpression(nodeFactory.createIdentifier('require'), [], [urlLiteral]), 'default');
     }
     else {
-        const importName = ts.createIdentifier(`__NG_CLI_RESOURCE__${resourceImportDeclarations.length}`);
-        resourceImportDeclarations.push(ts.createImportDeclaration(undefined, undefined, ts.createImportClause(importName, undefined), urlLiteral));
+        const importName = nodeFactory.createIdentifier(`__NG_CLI_RESOURCE__${resourceImportDeclarations.length}`);
+        resourceImportDeclarations.push(nodeFactory.createImportDeclaration(undefined, undefined, nodeFactory.createImportClause(false, importName, undefined), urlLiteral));
         return importName;
     }
 }

package/src/transformers/replace_server_bootstrap.js

@@ -57,14 +57,14 @@ function replaceServerBootstrap(shouldTransform, getEntryModule, getTypeChecker)
                         return;
                     }
                     const platformDynamicServerIdentifier = innerCallExpr.expression;
-                    const idPlatformServer = ts.createUniqueName('__NgCli_bootstrap_');
-                    const idNgFactory = ts.createUniqueName('__NgCli_bootstrap_');
+                    const idPlatformServer = ts.factory.createUniqueName('__NgCli_bootstrap_');
+                    const idNgFactory = ts.factory.createUniqueName('__NgCli_bootstrap_');
                     // Add the transform operations.
                     ops.push(
                     // Replace the entry module import.
-                    ...insert_import_1.insertStarImport(sourceFile, idNgFactory, factoryModulePath), new interfaces_1.ReplaceNodeOperation(sourceFile, entryModuleIdentifier, ts.createPropertyAccess(idNgFactory, ts.createIdentifier(factoryClassName))), 
+                    ...insert_import_1.insertStarImport(sourceFile, idNgFactory, factoryModulePath), new interfaces_1.ReplaceNodeOperation(sourceFile, entryModuleIdentifier, ts.factory.createPropertyAccessExpression(idNgFactory, ts.factory.createIdentifier(factoryClassName))), 
                     // Replace the platformBrowserDynamic import.
-                    ...insert_import_1.insertStarImport(sourceFile, idPlatformServer, '@angular/platform-server'), new interfaces_1.ReplaceNodeOperation(sourceFile, platformDynamicServerIdentifier, ts.createPropertyAccess(idPlatformServer, 'platformServer')), new interfaces_1.ReplaceNodeOperation(sourceFile, bootstrapModuleIdentifier, ts.createIdentifier('bootstrapModuleFactory')));
+                    ...insert_import_1.insertStarImport(sourceFile, idPlatformServer, '@angular/platform-server'), new interfaces_1.ReplaceNodeOperation(sourceFile, platformDynamicServerIdentifier, ts.factory.createPropertyAccessExpression(idPlatformServer, 'platformServer')), new interfaces_1.ReplaceNodeOperation(sourceFile, bootstrapModuleIdentifier, ts.factory.createIdentifier('bootstrapModuleFactory')));
                 }
                 else if (callExpr.expression.kind === ts.SyntaxKind.Identifier) {
                     // Figure out if it is renderModule
@@ -73,20 +73,20 @@ function replaceServerBootstrap(shouldTransform, getEntryModule, getTypeChecker)
                         return;
                     }
                     const renderModuleIdentifier = identifierExpr;
-                    const idPlatformServer = ts.createUniqueName('__NgCli_bootstrap_');
-                    const idNgFactory = ts.createUniqueName('__NgCli_bootstrap_');
+                    const idPlatformServer = ts.factory.createUniqueName('__NgCli_bootstrap_');
+                    const idNgFactory = ts.factory.createUniqueName('__NgCli_bootstrap_');
                     ops.push(
                     // Replace the entry module import.
-                    ...insert_import_1.insertStarImport(sourceFile, idNgFactory, factoryModulePath), new interfaces_1.ReplaceNodeOperation(sourceFile, entryModuleIdentifier, ts.createPropertyAccess(idNgFactory, ts.createIdentifier(factoryClassName))), 
+                    ...insert_import_1.insertStarImport(sourceFile, idNgFactory, factoryModulePath), new interfaces_1.ReplaceNodeOperation(sourceFile, entryModuleIdentifier, ts.factory.createPropertyAccessExpression(idNgFactory, ts.factory.createIdentifier(factoryClassName))), 
                     // Replace the renderModule import.
-                    ...insert_import_1.insertStarImport(sourceFile, idPlatformServer, '@angular/platform-server'), new interfaces_1.ReplaceNodeOperation(sourceFile, renderModuleIdentifier, ts.createPropertyAccess(idPlatformServer, 'renderModuleFactory')));
+                    ...insert_import_1.insertStarImport(sourceFile, idPlatformServer, '@angular/platform-server'), new interfaces_1.ReplaceNodeOperation(sourceFile, renderModuleIdentifier, ts.factory.createPropertyAccessExpression(idPlatformServer, 'renderModuleFactory')));
                 }
             }
             else if (entryModuleIdentifier.parent.kind === ts.SyntaxKind.PropertyAssignment) {
                 // This is for things that accept a module as a property in a config object
                 // .ie the express engine
-                const idNgFactory = ts.createUniqueName('__NgCli_bootstrap_');
-                ops.push(...insert_import_1.insertStarImport(sourceFile, idNgFactory, factoryModulePath), new interfaces_1.ReplaceNodeOperation(sourceFile, entryModuleIdentifier, ts.createPropertyAccess(idNgFactory, ts.createIdentifier(factoryClassName))));
+                const idNgFactory = ts.factory.createUniqueName('__NgCli_bootstrap_');
+                ops.push(...insert_import_1.insertStarImport(sourceFile, idNgFactory, factoryModulePath), new interfaces_1.ReplaceNodeOperation(sourceFile, entryModuleIdentifier, ts.factory.createPropertyAccessExpression(idNgFactory, ts.factory.createIdentifier(factoryClassName))));
             }
         });
         return ops;