@schematics/angular 8.1.0-beta.3 → 8.1.2

package/library/files/karma.conf.js.template

@@ -17,7 +17,7 @@ module.exports = function (config) {
     },
     coverageIstanbulReporter: {
       dir: require('path').join(__dirname, '<%= relativePathToWorkspaceRoot %>/coverage/<%= folderName %>'),
-      reports: ['html', 'lcovonly'],
+      reports: ['html', 'lcovonly', 'text-summary'],
       fixWebpackSourcePaths: true
     },
     reporters: ['progress', 'kjhtml'],

package/library/index.js

@@ -181,7 +181,7 @@ function default_1(options) {
                 commonModule: false,
                 flat: true,
                 path: sourceDir,
-                project: projectName,
+                project: options.name,
             }),
             schematics_1.schematic('component', {
                 name: options.name,
@@ -191,13 +191,13 @@ function default_1(options) {
                 flat: true,
                 path: sourceDir,
                 export: true,
-                project: projectName,
+                project: options.name,
             }),
             schematics_1.schematic('service', {
                 name: options.name,
                 flat: true,
                 path: sourceDir,
-                project: projectName,
+                project: options.name,
             }),
             options.lintFix ? lint_fix_1.applyLintFix(sourceDir) : schematics_1.noop(),
             (_tree, context) => {

package/migrations/migration-collection.json

@@ -39,6 +39,11 @@
       "version": "8.0.0-beta.14",
       "factory": "./update-8/#updateLazyModulePaths",
       "description": "Update an Angular CLI project to version 8."
+    },
+    "migration-09": {
+      "version": "9.0.0-beta.0",
+      "factory": "./update-9",
+      "description": "Update an Angular CLI project to version 9."
     }
   }
 }

package/migrations/update-8/update-dependencies.js

@@ -5,14 +5,14 @@ const latest_versions_1 = require("../../utility/latest-versions");
 function updateDependencies() {
     return (host) => {
         const dependenciesToUpdate = {
+            '@angular/pwa': latest_versions_1.latestVersions.AngularPWA,
             '@angular-devkit/build-angular': latest_versions_1.latestVersions.DevkitBuildAngular,
             '@angular-devkit/build-ng-packagr': latest_versions_1.latestVersions.DevkitBuildNgPackagr,
             '@angular-devkit/build-webpack': latest_versions_1.latestVersions.DevkitBuildWebpack,
             'zone.js': latest_versions_1.latestVersions.ZoneJs,
-            'tsickle': latest_versions_1.latestVersions.tsickle,
+            tsickle: latest_versions_1.latestVersions.tsickle,
             'ng-packagr': latest_versions_1.latestVersions.ngPackagr,
-            // FIXME: change to ^2.3.2 as soon as it's released with the pr208 fix
-            'web-animations-js': 'github:angular/web-animations-js#release_pr208',
+            'web-animations-js': '^2.3.2',
         };
         for (const [name, version] of Object.entries(dependenciesToUpdate)) {
             const current = dependencies_1.getPackageJsonDependency(host, name);

package/migrations/update-9/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Rule } from '@angular-devkit/schematics';
+export default function (): Rule;

package/migrations/update-9/index.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const schematics_1 = require("@angular-devkit/schematics");
+const update_workspace_config_1 = require("./update-workspace-config");
+function default_1() {
+    return () => {
+        return schematics_1.chain([
+            update_workspace_config_1.UpdateWorkspaceConfig(),
+        ]);
+    };
+}
+exports.default = default_1;

package/migrations/update-9/update-workspace-config.d.ts

@@ -0,0 +1,2 @@
+import { Rule } from '@angular-devkit/schematics';
+export declare function UpdateWorkspaceConfig(): Rule;

package/migrations/update-9/update-workspace-config.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+const core_1 = require("@angular-devkit/core");
+const json_utils_1 = require("../../utility/json-utils");
+function UpdateWorkspaceConfig() {
+    return (tree) => {
+        let workspaceConfigPath = 'angular.json';
+        let angularConfigContent = tree.read(workspaceConfigPath);
+        if (!angularConfigContent) {
+            workspaceConfigPath = '.angular.json';
+            angularConfigContent = tree.read(workspaceConfigPath);
+            if (!angularConfigContent) {
+                return;
+            }
+        }
+        const angularJson = core_1.parseJsonAst(angularConfigContent.toString(), core_1.JsonParseMode.Loose);
+        if (angularJson.kind !== 'object') {
+            return;
+        }
+        const projects = json_utils_1.findPropertyInAstObject(angularJson, 'projects');
+        if (!projects || projects.kind !== 'object') {
+            return;
+        }
+        // For all projects
+        const recorder = tree.beginUpdate(workspaceConfigPath);
+        for (const project of projects.properties) {
+            const projectConfig = project.value;
+            if (projectConfig.kind !== 'object') {
+                break;
+            }
+            const architect = json_utils_1.findPropertyInAstObject(projectConfig, 'architect');
+            if (!architect || architect.kind !== 'object') {
+                break;
+            }
+            const buildTarget = json_utils_1.findPropertyInAstObject(architect, 'build');
+            if (buildTarget && buildTarget.kind === 'object') {
+                const builder = json_utils_1.findPropertyInAstObject(buildTarget, 'builder');
+                // Projects who's build builder is not build-angular:browser
+                if (builder && builder.kind === 'string' && builder.value === '@angular-devkit/build-angular:browser') {
+                    updateOption('styles', recorder, buildTarget);
+                    updateOption('scripts', recorder, buildTarget);
+                }
+            }
+            const testTarget = json_utils_1.findPropertyInAstObject(architect, 'test');
+            if (testTarget && testTarget.kind === 'object') {
+                const builder = json_utils_1.findPropertyInAstObject(testTarget, 'builder');
+                // Projects who's build builder is not build-angular:browser
+                if (builder && builder.kind === 'string' && builder.value === '@angular-devkit/build-angular:karma') {
+                    updateOption('styles', recorder, testTarget);
+                    updateOption('scripts', recorder, testTarget);
+                }
+            }
+        }
+        tree.commitUpdate(recorder);
+        return tree;
+    };
+}
+exports.UpdateWorkspaceConfig = UpdateWorkspaceConfig;
+/**
+ * Helper to retreive all the options in various configurations
+ */
+function getAllOptions(builderConfig) {
+    const options = [];
+    const configurations = json_utils_1.findPropertyInAstObject(builderConfig, 'configurations');
+    if (configurations && configurations.kind === 'object') {
+        options.push(...configurations.properties.map(x => x.value));
+    }
+    options.push(json_utils_1.findPropertyInAstObject(builderConfig, 'options'));
+    return options.filter(o => o && o.kind === 'object');
+}
+function updateOption(property, recorder, builderConfig) {
+    const options = getAllOptions(builderConfig);
+    for (const option of options) {
+        const propertyOption = json_utils_1.findPropertyInAstObject(option, property);
+        if (!propertyOption || propertyOption.kind !== 'array') {
+            continue;
+        }
+        for (const node of propertyOption.elements) {
+            if (!node || node.kind !== 'object') {
+                // skip non complex objects
+                continue;
+            }
+            const lazy = json_utils_1.findPropertyInAstObject(node, 'lazy');
+            json_utils_1.removePropertyInAstObject(recorder, node, 'lazy');
+            // if lazy was not true, it is redundant hence, don't add it
+            if (lazy && lazy.kind === 'true') {
+                json_utils_1.insertPropertyInAstObjectInOrder(recorder, node, 'inject', false, 0);
+            }
+        }
+    }
+}

package/module/files/__name@dasherize@if-flat__/__name@dasherize__-routing.module.ts.template

@@ -1,7 +1,9 @@
 import { NgModule } from '@angular/core';
 import { Routes, RouterModule } from '@angular/router';
+<% if (lazyRoute) { %>
+import { <%= classify(name) %>Component } from './<%= dasherize(name) %>.component';<% } %>
 
-const routes: Routes = [];
+const routes: Routes = [<% if (lazyRoute) { %>{ path: '', component: <%= classify(name) %>Component }<% } %>];
 
 @NgModule({
   imports: [RouterModule.for<%= routingScope %>(routes)],

package/module/files/__name@dasherize@if-flat__/__name@dasherize__.module.ts.template

@@ -1,13 +1,19 @@
 import { NgModule } from '@angular/core';<% if (commonModule) { %>
-import { CommonModule } from '@angular/common';<% } %><% if (routing) { %>
-
+import { CommonModule } from '@angular/common';<% } %><% if (lazyRouteWithoutRouteModule) { %>
+import { Routes, RouterModule } from '@angular/router';<% } %>
+<% if (routing || lazyRouteWithRouteModule) { %>
 import { <%= classify(name) %>RoutingModule } from './<%= dasherize(name) %>-routing.module';<% } %>
+<% if (lazyRouteWithoutRouteModule) { %>
+const routes: Routes = [
+  { path: '', component: <%= classify(name) %>Component }
+];<% } %>
 
 @NgModule({
   declarations: [],
   imports: [<% if (commonModule) { %>
-    CommonModule<%= routing ? ',' : '' %><% } %><% if (routing) { %>
-    <%= classify(name) %>RoutingModule<% } %>
+    CommonModule<%= routing || lazyRouteWithRouteModule ? ',' : '' %><% } %><% if (routing || lazyRouteWithRouteModule) { %>
+    <%= classify(name) %>RoutingModule<% } %><%= lazyRouteWithoutRouteModule ? ',' : '' %><% if (lazyRouteWithoutRouteModule) { %>
+    RouterModule.forChild(routes)<% } %>
   ]
 })
 export class <%= classify(name) %>Module { }

package/module/index.js

@@ -16,6 +16,14 @@ const find_module_1 = require("../utility/find-module");
 const lint_fix_1 = require("../utility/lint-fix");
 const parse_name_1 = require("../utility/parse-name");
 const workspace_1 = require("../utility/workspace");
+const schema_1 = require("./schema");
+function buildRelativeModulePath(options, modulePath) {
+    const importModulePath = core_1.normalize(`/${options.path}/`
+        + (options.flat ? '' : core_1.strings.dasherize(options.name) + '/')
+        + core_1.strings.dasherize(options.name)
+        + '.module');
+    return find_module_1.buildRelativePath(modulePath, importModulePath);
+}
 function addDeclarationToNgModule(options) {
     return (host) => {
         if (!options.module) {
@@ -26,13 +34,9 @@ function addDeclarationToNgModule(options) {
         if (text === null) {
             throw new schematics_1.SchematicsException(`File ${modulePath} does not exist.`);
         }
-        const sourceText = text.toString('utf-8');
+        const sourceText = text.toString();
         const source = ts.createSourceFile(modulePath, sourceText, ts.ScriptTarget.Latest, true);
-        const importModulePath = core_1.normalize(`/${options.path}/`
-            + (options.flat ? '' : core_1.strings.dasherize(options.name) + '/')
-            + core_1.strings.dasherize(options.name)
-            + '.module');
-        const relativePath = find_module_1.buildRelativePath(modulePath, importModulePath);
+        const relativePath = buildRelativeModulePath(options, modulePath);
         const changes = ast_utils_1.addImportToModule(source, modulePath, core_1.strings.classify(`${options.name}Module`), relativePath);
         const recorder = host.beginUpdate(modulePath);
         for (const change of changes) {
@@ -44,6 +48,50 @@ function addDeclarationToNgModule(options) {
         return host;
     };
 }
+function addRouteDeclarationToNgModule(options, routingModulePath) {
+    return (host) => {
+        if (!options.route) {
+            return host;
+        }
+        if (!options.module) {
+            throw new Error('Module option required when creating a lazy loaded routing module.');
+        }
+        let path;
+        if (routingModulePath) {
+            path = routingModulePath;
+        }
+        else {
+            path = options.module;
+        }
+        const text = host.read(path);
+        if (!text) {
+            throw new Error(`Couldn't find the module nor its routing module.`);
+        }
+        const sourceText = text.toString();
+        const addDeclaration = ast_utils_1.addRouteDeclarationToModule(ts.createSourceFile(path, sourceText, ts.ScriptTarget.Latest, true), path, buildRoute(options, options.module));
+        const recorder = host.beginUpdate(path);
+        recorder.insertLeft(addDeclaration.pos, addDeclaration.toAdd);
+        host.commitUpdate(recorder);
+        return host;
+    };
+}
+function getRoutingModulePath(host, options) {
+    let path;
+    const modulePath = options.module;
+    const routingModuleName = modulePath.split('.')[0] + '-routing';
+    const { module, ...rest } = options;
+    try {
+        path = find_module_1.findModuleFromOptions(host, { module: routingModuleName, ...rest });
+    }
+    catch (_a) { }
+    return path;
+}
+function buildRoute(options, modulePath) {
+    const relativeModulePath = buildRelativeModulePath(options, modulePath);
+    const moduleName = `${core_1.strings.classify(options.name)}Module`;
+    const loadChildren = `() => import('${relativeModulePath}').then(m => m.${moduleName})`;
+    return `{ path: '${options.route}', loadChildren: ${loadChildren} }`;
+}
 function default_1(options) {
     return async (host) => {
         if (options.path === undefined) {
@@ -55,18 +103,38 @@ function default_1(options) {
         const parsedPath = parse_name_1.parseName(options.path, options.name);
         options.name = parsedPath.name;
         options.path = parsedPath.path;
+        let routingModulePath;
+        const isLazyLoadedModuleGen = options.route && options.module;
+        if (isLazyLoadedModuleGen) {
+            options.routingScope = schema_1.RoutingScope.Child;
+            routingModulePath = getRoutingModulePath(host, options);
+        }
         const templateSource = schematics_1.apply(schematics_1.url('./files'), [
-            options.routing ? schematics_1.noop() : schematics_1.filter(path => !path.endsWith('-routing.module.ts.template')),
+            options.routing || isLazyLoadedModuleGen && !!routingModulePath
+                ? schematics_1.noop()
+                : schematics_1.filter(path => !path.endsWith('-routing.module.ts.template')),
             schematics_1.applyTemplates({
                 ...core_1.strings,
                 'if-flat': (s) => options.flat ? '' : s,
+                lazyRoute: isLazyLoadedModuleGen,
+                lazyRouteWithoutRouteModule: isLazyLoadedModuleGen && !routingModulePath,
+                lazyRouteWithRouteModule: isLazyLoadedModuleGen && routingModulePath,
                 ...options,
             }),
             schematics_1.move(parsedPath.path),
         ]);
+        const moduleDasherized = core_1.strings.dasherize(options.name);
+        const modulePath = `${!options.flat ? moduleDasherized + '/' : ''}${moduleDasherized}.module.ts`;
         return schematics_1.chain([
-            addDeclarationToNgModule(options),
+            !isLazyLoadedModuleGen ? addDeclarationToNgModule(options) : schematics_1.noop(),
+            addRouteDeclarationToNgModule(options, routingModulePath),
             schematics_1.mergeWith(templateSource),
+            isLazyLoadedModuleGen
+                ? schematics_1.schematic('component', {
+                    ...options,
+                    module: modulePath,
+                })
+                : schematics_1.noop(),
             options.lintFix ? lint_fix_1.applyLintFix(options.path) : schematics_1.noop(),
         ]);
     };

package/module/schema.d.ts

@@ -30,6 +30,10 @@ export interface Schema {
      * The name of the project.
      */
     project?: string;
+    /**
+     * Creates lazy loaded routing module. Requires --module option.
+     */
+    route?: string;
     /**
      * When true, creates a routing module.
      */

package/module/schema.json

@@ -39,6 +39,10 @@
       "description": "The scope for the new routing module.",
       "default": "Child"
     },
+    "route": {
+      "type": "string",
+      "description": "Creates lazy loaded routing module. Requires --module option."
+    },
     "flat": {
       "type": "boolean",
       "description": "When true, creates the new files at the top level of the current project root. ",

package/ng-new/schema.json

@@ -130,10 +130,10 @@
         "type": "list",
         "items": [
           { "value": "css",  "label": "CSS" },
-          { "value": "scss", "label": "SCSS   [ http://sass-lang.com/documentation/file.SASS_REFERENCE.html#syntax ]" },
-          { "value": "sass", "label": "Sass   [ http://sass-lang.com/documentation/file.INDENTED_SYNTAX.html       ]" },
-          { "value": "less", "label": "Less   [ http://lesscss.org                                                 ]" },
-          { "value": "styl", "label": "Stylus [ http://stylus-lang.com                                             ] " }
+          { "value": "scss", "label": "SCSS   [ https://sass-lang.com/documentation/syntax#scss                ]" },
+          { "value": "sass", "label": "Sass   [ https://sass-lang.com/documentation/syntax#the-indented-syntax ]" },
+          { "value": "less", "label": "Less   [ http://lesscss.org                                             ]" },
+          { "value": "styl", "label": "Stylus [ http://stylus-lang.com                                         ]" }
         ]
       },
       "x-user-analytics": 5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@schematics/angular",
-  "version": "8.1.0-beta.3",
+  "version": "8.1.2",
   "description": "Schematics specific to Angular",
   "keywords": [
     "angular",
@@ -14,8 +14,8 @@
   ],
   "schematics": "./collection.json",
   "dependencies": {
-    "@angular-devkit/core": "8.1.0-beta.3",
-    "@angular-devkit/schematics": "8.1.0-beta.3"
+    "@angular-devkit/core": "8.1.2",
+    "@angular-devkit/schematics": "8.1.2"
   },
   "repository": {
     "type": "git",
@@ -33,7 +33,6 @@
   "homepage": "https://github.com/angular/angular-cli",
   "husky": {
     "hooks": {
-      "pre-commit": "lint-staged",
       "pre-push": "node ./bin/devkit-admin hooks/pre-push"
     }
   }

package/universal/files/root/__tsconfigFileName__.json.template

@@ -1,7 +1,8 @@
 {
   "extends": "./<%= tsConfigExtends %>",
   "compilerOptions": {
-    "outDir": "<%= outDir %>-server"
+    "outDir": "<%= outDir %>-server",
+    "module": "commonjs"
   },
   "angularCompilerOptions": {
     "entryModule": "./<%= rootInSrc ? '' : 'src/' %><%= appDir %>/<%= stripTsExtension(rootModuleFileName) %>#<%= rootModuleClassName %>"

package/utility/ast-utils.d.ts

@@ -55,6 +55,7 @@ export declare function getDecoratorMetadata(source: ts.SourceFile, identifier:
  * @returns the name of the first @NgModule, or `undefined` if none is found
  */
 export declare function getFirstNgModuleName(source: ts.SourceFile): string | undefined;
+export declare function getMetadataField(node: ts.ObjectLiteralExpression, metadataField: string): ts.ObjectLiteralElement[];
 export declare function addSymbolToNgModuleMetadata(source: ts.SourceFile, ngModulePath: string, metadataField: string, symbolName: string, importPath?: string | null): Change[];
 /**
  * Custom function to insert a declaration (component, pipe, directive)
@@ -85,3 +86,11 @@ export declare function addEntryComponentToModule(source: ts.SourceFile, moduleP
  * Determine if an import already exists.
  */
 export declare function isImported(source: ts.SourceFile, classifiedName: string, importPath: string): boolean;
+/**
+ * Returns the RouterModule declaration from NgModule metadata, if any.
+ */
+export declare function getRouterModuleDeclaration(source: ts.SourceFile): ts.Expression | undefined;
+/**
+ * Adds a new route declaration to a router module (i.e. has a RouterModule declaration)
+ */
+export declare function addRouteDeclarationToModule(source: ts.SourceFile, fileToAdd: string, routeLiteral: string): Change;

package/utility/ast-utils.js

@@ -292,6 +292,17 @@ function getFirstNgModuleName(source) {
     return moduleClass.name.text;
 }
 exports.getFirstNgModuleName = getFirstNgModuleName;
+function getMetadataField(node, metadataField) {
+    return node.properties
+        .filter(prop => ts.isPropertyAssignment(prop))
+        // Filter out every fields that's not "metadataField". Also handles string literals
+        // (but not expressions).
+        .filter(({ name }) => {
+        return (ts.isIdentifier(name) || ts.isStringLiteral(name))
+            && name.getText() === metadataField;
+    });
+}
+exports.getMetadataField = getMetadataField;
 function addSymbolToNgModuleMetadata(source, ngModulePath, metadataField, symbolName, importPath = null) {
     const nodes = getDecoratorMetadata(source, 'NgModule', '@angular/core');
     let node = nodes[0]; // tslint:disable-line:no-any
@@ -300,20 +311,7 @@ function addSymbolToNgModuleMetadata(source, ngModulePath, metadataField, symbol
         return [];
     }
     // Get all the children property assignment of object literals.
-    const matchingProperties = node.properties
-        .filter(prop => prop.kind == ts.SyntaxKind.PropertyAssignment)
-        // Filter out every fields that's not "metadataField". Also handles string literals
-        // (but not expressions).
-        .filter((prop) => {
-        const name = prop.name;
-        switch (name.kind) {
-            case ts.SyntaxKind.Identifier:
-                return name.getText(source) == metadataField;
-            case ts.SyntaxKind.StringLiteral:
-                return name.text == metadataField;
-        }
-        return false;
-    });
+    const matchingProperties = getMetadataField(node, metadataField);
     // Get the last node of the array literal.
     if (!matchingProperties) {
         return [];
@@ -364,6 +362,7 @@ function addSymbolToNgModuleMetadata(source, ngModulePath, metadataField, symbol
         node = arrLiteral.elements;
     }
     if (!node) {
+        // tslint:disable-next-line: no-console
         console.error('No app module found. Please add your new class to your component.');
         return [];
     }
@@ -485,3 +484,71 @@ function isImported(source, classifiedName, importPath) {
     return matchingNodes.length > 0;
 }
 exports.isImported = isImported;
+/**
+ * Returns the RouterModule declaration from NgModule metadata, if any.
+ */
+function getRouterModuleDeclaration(source) {
+    const result = getDecoratorMetadata(source, 'NgModule', '@angular/core');
+    const node = result[0];
+    const matchingProperties = getMetadataField(node, 'imports');
+    if (!matchingProperties) {
+        return;
+    }
+    const assignment = matchingProperties[0];
+    if (assignment.initializer.kind !== ts.SyntaxKind.ArrayLiteralExpression) {
+        return;
+    }
+    const arrLiteral = assignment.initializer;
+    return arrLiteral.elements
+        .filter(el => el.kind === ts.SyntaxKind.CallExpression)
+        .find(el => el.getText().startsWith('RouterModule'));
+}
+exports.getRouterModuleDeclaration = getRouterModuleDeclaration;
+/**
+ * Adds a new route declaration to a router module (i.e. has a RouterModule declaration)
+ */
+function addRouteDeclarationToModule(source, fileToAdd, routeLiteral) {
+    const routerModuleExpr = getRouterModuleDeclaration(source);
+    if (!routerModuleExpr) {
+        throw new Error(`Couldn't find a route declaration in ${fileToAdd}.`);
+    }
+    const scopeConfigMethodArgs = routerModuleExpr.arguments;
+    if (!scopeConfigMethodArgs.length) {
+        const { line } = source.getLineAndCharacterOfPosition(routerModuleExpr.getStart());
+        throw new Error(`The router module method doesn't have arguments ` +
+            `at line ${line} in ${fileToAdd}`);
+    }
+    let routesArr;
+    const routesArg = scopeConfigMethodArgs[0];
+    // Check if the route declarations array is
+    // an inlined argument of RouterModule or a standalone variable
+    if (ts.isArrayLiteralExpression(routesArg)) {
+        routesArr = routesArg;
+    }
+    else {
+        const routesVarName = routesArg.getText();
+        let routesVar;
+        if (routesArg.kind === ts.SyntaxKind.Identifier) {
+            routesVar = source.statements
+                .filter((s) => s.kind === ts.SyntaxKind.VariableStatement)
+                .find((v) => {
+                return v.declarationList.declarations[0].name.getText() === routesVarName;
+            });
+        }
+        if (!routesVar) {
+            const { line } = source.getLineAndCharacterOfPosition(routesArg.getStart());
+            throw new Error(`No route declaration array was found that corresponds ` +
+                `to router module at line ${line} in ${fileToAdd}`);
+        }
+        routesArr = findNodes(routesVar, ts.SyntaxKind.ArrayLiteralExpression, 1)[0];
+    }
+    const occurencesCount = routesArr.elements.length;
+    const text = routesArr.getFullText(source);
+    let route = routeLiteral;
+    if (occurencesCount > 0) {
+        const identation = text.match(/\r?\n(\r?)\s*/) || [];
+        route = `,${identation[0] || ' '}${routeLiteral}`;
+    }
+    return insertAfterLastOccurrence(routesArr.elements, route, fileToAdd, routesArr.elements.pos, ts.SyntaxKind.ObjectLiteralExpression);
+}
+exports.addRouteDeclarationToModule = addRouteDeclarationToModule;

package/utility/latest-versions.d.ts

@@ -14,6 +14,7 @@ export declare const latestVersions: {
     DevkitBuildAngular: string;
     DevkitBuildNgPackagr: string;
     DevkitBuildWebpack: string;
+    AngularPWA: string;
     tsickle: string;
     ngPackagr: string;
 };

package/utility/latest-versions.js

@@ -9,15 +9,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.latestVersions = {
     // These versions should be kept up to date with latest Angular peer dependencies.
-    Angular: '~8.1.0-next.2',
+    Angular: '~8.1.2',
     RxJs: '~6.4.0',
     ZoneJs: '~0.9.1',
     TypeScript: '~3.4.3',
     TsLib: '^1.9.0',
     // The versions below must be manually updated when making a new devkit release.
-    DevkitBuildAngular: '~0.801.0-beta.2',
-    DevkitBuildNgPackagr: '~0.801.0-beta.2',
-    DevkitBuildWebpack: '~0.801.0-beta.2',
+    DevkitBuildAngular: '~0.801.2',
+    DevkitBuildNgPackagr: '~0.801.2',
+    DevkitBuildWebpack: '~0.801.2',
+    AngularPWA: '~0.801.2',
     tsickle: '^0.35.0',
     ngPackagr: '^5.1.0',
 };

package/workspace/files/tslint.json.template

@@ -7,7 +7,7 @@
     "array-type": false,
     "arrow-parens": false,
     "deprecation": {
-      "severity": "warn"
+      "severity": "warning"
     },
     "import-blacklist": [
       true,
@@ -77,4 +77,4 @@
     "use-lifecycle-interface": true,
     "use-pipe-transform-interface": true
   }
-}
+}