@angular/build 21.0.0-next.4 → 21.0.0-next.6

package/src/builders/unit-test/schema.d.ts

@@ -2,6 +2,11 @@
  * Unit testing options for Angular applications.
  */
 export type Schema = {
+    /**
+     * Specifies the browser viewport dimensions for browser-based tests in the format
+     * `widthxheight`.
+     */
+    browserViewport?: string;
     /**
      * Specifies the browsers to use for test execution. When not specified, tests are run in a
      * Node.js environment using jsdom. For both Vitest and Karma, browser names ending with
@@ -10,25 +15,45 @@ export type Schema = {
     browsers?: string[];
     /**
      * Specifies the build target to use for the unit test build in the format
-     * `project:target[:configuration]`. You can also pass a comma-separated list of
+     * `project:target[:configuration]`. This defaults to the `build` target of the current
+     * project with the `development` configuration. You can also pass a comma-separated list of
      * configurations. Example: `project:target:production,staging`.
      */
-    buildTarget: string;
+    buildTarget?: string;
     /**
-     * Enables code coverage reporting for tests.
+     * Enables coverage reporting for tests.
      */
-    codeCoverage?: boolean;
+    coverage?: boolean;
     /**
-     * Specifies glob patterns of files to exclude from the code coverage report.
+     * Includes all files that match the `coverageInclude` pattern in the coverage report, not
+     * just those touched by tests.
      */
-    codeCoverageExclude?: string[];
+    coverageAll?: boolean;
     /**
-     * Specifies the reporters to use for code coverage results. Each reporter can be a string
+     * Specifies glob patterns of files to exclude from the coverage report.
+     */
+    coverageExclude?: string[];
+    /**
+     * Specifies glob patterns of files to include in the coverage report.
+     */
+    coverageInclude?: string[];
+    /**
+     * Specifies the reporters to use for coverage results. Each reporter can be a string
      * representing its name, or a tuple containing the name and an options object. Built-in
      * reporters include 'html', 'lcov', 'lcovonly', 'text', 'text-summary', 'cobertura',
      * 'json', and 'json-summary'.
      */
-    codeCoverageReporters?: SchemaCodeCoverageReporter[];
+    coverageReporters?: SchemaCoverageReporter[];
+    /**
+     * Specifies minimum coverage thresholds that must be met. If thresholds are not met, the
+     * builder will exit with an error.
+     */
+    coverageThresholds?: CoverageThresholds;
+    /**
+     * Specifies coverage watermarks for the HTML reporter. These determine the color coding for
+     * high, medium, and low coverage.
+     */
+    coverageWatermarks?: CoverageWatermarks;
     /**
      * Enables debugging mode for tests, allowing the use of the Node Inspector.
      */
@@ -53,6 +78,11 @@ export type Schema = {
      * within) and file paths (includes the corresponding `.spec` file if one exists).
      */
     include?: string[];
+    /**
+     * Lists all discovered test files and exits the process without building or executing the
+     * tests.
+     */
+    listTests?: boolean;
     /**
      * Specifies a file path for the test report, applying only to the first reporter. To
      * configure output files for multiple reporters, use the tuple format `['reporter-name', {
@@ -87,20 +117,22 @@ export type Schema = {
      */
     setupFiles?: string[];
     /**
-     * The path to the TypeScript configuration file, relative to the workspace root.
+     * The path to the TypeScript configuration file, relative to the workspace root. Defaults
+     * to `tsconfig.spec.json` in the project root if it exists. If not specified and the
+     * default does not exist, the `tsConfig` from the specified `buildTarget` will be used.
      */
-    tsConfig: string;
+    tsConfig?: string;
     /**
      * Enables watch mode, which re-runs tests when source files change. Defaults to `true` in
      * TTY environments and `false` otherwise.
      */
     watch?: boolean;
 };
-export type SchemaCodeCoverageReporter = CodeCoverageReporterCodeCoverageReporter[] | CoverageReporters;
-export type CodeCoverageReporterCodeCoverageReporter = CoverageReporters | {
+export type SchemaCoverageReporter = CoverageReporterCoverageReporterUnion[] | CoverageReporterEnum;
+export type CoverageReporterCoverageReporterUnion = CoverageReporterEnum | {
     [key: string]: any;
 };
-export declare enum CoverageReporters {
+export declare enum CoverageReporterEnum {
     Cobertura = "cobertura",
     Html = "html",
     Json = "json",
@@ -110,6 +142,54 @@ export declare enum CoverageReporters {
     Text = "text",
     TextSummary = "text-summary"
 }
+/**
+ * Specifies minimum coverage thresholds that must be met. If thresholds are not met, the
+ * builder will exit with an error.
+ */
+export type CoverageThresholds = {
+    /**
+     * Minimum percentage of branches covered.
+     */
+    branches?: number;
+    /**
+     * Minimum percentage of functions covered.
+     */
+    functions?: number;
+    /**
+     * Minimum percentage of lines covered.
+     */
+    lines?: number;
+    /**
+     * When true, thresholds are enforced for each file individually.
+     */
+    perFile?: boolean;
+    /**
+     * Minimum percentage of statements covered.
+     */
+    statements?: number;
+};
+/**
+ * Specifies coverage watermarks for the HTML reporter. These determine the color coding for
+ * high, medium, and low coverage.
+ */
+export type CoverageWatermarks = {
+    /**
+     * The high and low watermarks for branches coverage. `[low, high]`
+     */
+    branches?: number[];
+    /**
+     * The high and low watermarks for functions coverage. `[low, high]`
+     */
+    functions?: number[];
+    /**
+     * The high and low watermarks for lines coverage. `[low, high]`
+     */
+    lines?: number[];
+    /**
+     * The high and low watermarks for statements coverage. `[low, high]`
+     */
+    statements?: number[];
+};
 export type SchemaReporter = ReporterReporter[] | string;
 export type ReporterReporter = {
     [key: string]: any;

package/src/builders/unit-test/schema.js

@@ -2,18 +2,18 @@
 // THIS FILE IS AUTOMATICALLY GENERATED. TO UPDATE THIS FILE YOU NEED TO CHANGE THE
 // CORRESPONDING JSON SCHEMA FILE, THEN RUN devkit-admin build (or bazel build ...).
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Runner = exports.CoverageReporters = void 0;
-var CoverageReporters;
-(function (CoverageReporters) {
-    CoverageReporters["Cobertura"] = "cobertura";
-    CoverageReporters["Html"] = "html";
-    CoverageReporters["Json"] = "json";
-    CoverageReporters["JsonSummary"] = "json-summary";
-    CoverageReporters["Lcov"] = "lcov";
-    CoverageReporters["Lcovonly"] = "lcovonly";
-    CoverageReporters["Text"] = "text";
-    CoverageReporters["TextSummary"] = "text-summary";
-})(CoverageReporters || (exports.CoverageReporters = CoverageReporters = {}));
+exports.Runner = exports.CoverageReporterEnum = void 0;
+var CoverageReporterEnum;
+(function (CoverageReporterEnum) {
+    CoverageReporterEnum["Cobertura"] = "cobertura";
+    CoverageReporterEnum["Html"] = "html";
+    CoverageReporterEnum["Json"] = "json";
+    CoverageReporterEnum["JsonSummary"] = "json-summary";
+    CoverageReporterEnum["Lcov"] = "lcov";
+    CoverageReporterEnum["Lcovonly"] = "lcovonly";
+    CoverageReporterEnum["Text"] = "text";
+    CoverageReporterEnum["TextSummary"] = "text-summary";
+})(CoverageReporterEnum || (exports.CoverageReporterEnum = CoverageReporterEnum = {}));
 /**
  * Specifies the test runner to use for test execution.
  */

package/src/builders/unit-test/schema.json

@@ -6,12 +6,12 @@
   "properties": {
     "buildTarget": {
       "type": "string",
-      "description": "Specifies the build target to use for the unit test build in the format `project:target[:configuration]`. You can also pass a comma-separated list of configurations. Example: `project:target:production,staging`.",
+      "description": "Specifies the build target to use for the unit test build in the format `project:target[:configuration]`. This defaults to the `build` target of the current project with the `development` configuration. You can also pass a comma-separated list of configurations. Example: `project:target:production,staging`.",
       "pattern": "^[^:\\s]*:[^:\\s]*(:[^\\s]+)?$"
     },
     "tsConfig": {
       "type": "string",
-      "description": "The path to the TypeScript configuration file, relative to the workspace root."
+      "description": "The path to the TypeScript configuration file, relative to the workspace root. Defaults to `tsconfig.spec.json` in the project root if it exists. If not specified and the default does not exist, the `tsConfig` from the specified `buildTarget` will be used."
     },
     "runner": {
       "type": "string",
@@ -26,6 +26,11 @@
       },
       "minItems": 1
     },
+    "browserViewport": {
+      "description": "Specifies the browser viewport dimensions for browser-based tests in the format `widthxheight`.",
+      "type": "string",
+      "pattern": "^\\d+x\\d+$"
+    },
     "include": {
       "type": "array",
       "items": {
@@ -54,25 +59,46 @@
       "description": "Enables debugging mode for tests, allowing the use of the Node Inspector.",
       "default": false
     },
-    "codeCoverage": {
+    "coverage": {
       "type": "boolean",
-      "description": "Enables code coverage reporting for tests.",
+      "description": "Enables coverage reporting for tests.",
       "default": false
     },
-    "codeCoverageExclude": {
+    "coverageAll": {
+      "type": "boolean",
+      "description": "Includes all files that match the `coverageInclude` pattern in the coverage report, not just those touched by tests.",
+      "default": true
+    },
+    "coverageInclude": {
+      "type": "array",
+      "description": "Specifies glob patterns of files to include in the coverage report.",
+      "items": {
+        "type": "string"
+      }
+    },
+    "coverageExclude": {
       "type": "array",
-      "description": "Specifies glob patterns of files to exclude from the code coverage report.",
+      "description": "Specifies glob patterns of files to exclude from the coverage report.",
       "items": {
         "type": "string"
       }
     },
-    "codeCoverageReporters": {
+    "coverageReporters": {
       "type": "array",
-      "description": "Specifies the reporters to use for code coverage results. Each reporter can be a string representing its name, or a tuple containing the name and an options object. Built-in reporters include 'html', 'lcov', 'lcovonly', 'text', 'text-summary', 'cobertura', 'json', and 'json-summary'.",
+      "description": "Specifies the reporters to use for coverage results. Each reporter can be a string representing its name, or a tuple containing the name and an options object. Built-in reporters include 'html', 'lcov', 'lcovonly', 'text', 'text-summary', 'cobertura', 'json', and 'json-summary'.",
       "items": {
         "oneOf": [
           {
-            "$ref": "#/definitions/coverage-reporters"
+            "enum": [
+              "html",
+              "lcov",
+              "lcovonly",
+              "text",
+              "text-summary",
+              "cobertura",
+              "json",
+              "json-summary"
+            ]
           },
           {
             "type": "array",
@@ -80,7 +106,16 @@
             "maxItems": 2,
             "items": [
               {
-                "$ref": "#/definitions/coverage-reporters"
+                "enum": [
+                  "html",
+                  "lcov",
+                  "lcovonly",
+                  "text",
+                  "text-summary",
+                  "cobertura",
+                  "json",
+                  "json-summary"
+                ]
               },
               {
                 "type": "object"
@@ -90,6 +125,68 @@
         ]
       }
     },
+    "coverageThresholds": {
+      "type": "object",
+      "description": "Specifies minimum coverage thresholds that must be met. If thresholds are not met, the builder will exit with an error.",
+      "properties": {
+        "perFile": {
+          "type": "boolean",
+          "description": "When true, thresholds are enforced for each file individually."
+        },
+        "statements": {
+          "type": "number",
+          "description": "Minimum percentage of statements covered."
+        },
+        "branches": {
+          "type": "number",
+          "description": "Minimum percentage of branches covered."
+        },
+        "functions": {
+          "type": "number",
+          "description": "Minimum percentage of functions covered."
+        },
+        "lines": {
+          "type": "number",
+          "description": "Minimum percentage of lines covered."
+        }
+      },
+      "additionalProperties": false
+    },
+    "coverageWatermarks": {
+      "type": "object",
+      "description": "Specifies coverage watermarks for the HTML reporter. These determine the color coding for high, medium, and low coverage.",
+      "properties": {
+        "statements": {
+          "type": "array",
+          "description": "The high and low watermarks for statements coverage. `[low, high]`",
+          "items": { "type": "number" },
+          "minItems": 2,
+          "maxItems": 2
+        },
+        "branches": {
+          "type": "array",
+          "description": "The high and low watermarks for branches coverage. `[low, high]`",
+          "items": { "type": "number" },
+          "minItems": 2,
+          "maxItems": 2
+        },
+        "functions": {
+          "type": "array",
+          "description": "The high and low watermarks for functions coverage. `[low, high]`",
+          "items": { "type": "number" },
+          "minItems": 2,
+          "maxItems": 2
+        },
+        "lines": {
+          "type": "array",
+          "description": "The high and low watermarks for lines coverage. `[low, high]`",
+          "items": { "type": "number" },
+          "minItems": 2,
+          "maxItems": 2
+        }
+      },
+      "additionalProperties": false
+    },
     "reporters": {
       "type": "array",
       "description": "Specifies the reporters to use during test execution. Each reporter can be a string representing its name, or a tuple containing the name and an options object. Built-in reporters include 'default', 'verbose', 'dots', 'json', 'junit', 'tap', 'tap-flat', and 'html'. You can also provide a path to a custom reporter.",
@@ -98,10 +195,10 @@
           {
             "anyOf": [
               {
-                "$ref": "#/definitions/reporters-enum"
+                "type": "string"
               },
               {
-                "type": "string"
+                "enum": ["default", "verbose", "dots", "json", "junit", "tap", "tap-flat", "html"]
               }
             ]
           },
@@ -113,10 +210,19 @@
               {
                 "anyOf": [
                   {
-                    "$ref": "#/definitions/reporters-enum"
+                    "type": "string"
                   },
                   {
-                    "type": "string"
+                    "enum": [
+                      "default",
+                      "verbose",
+                      "dots",
+                      "json",
+                      "junit",
+                      "tap",
+                      "tap-flat",
+                      "html"
+                    ]
                   }
                 ]
               },
@@ -148,6 +254,11 @@
       "type": "boolean",
       "description": "Shows build progress information in the console. Defaults to the `progress` setting of the specified `buildTarget`."
     },
+    "listTests": {
+      "type": "boolean",
+      "description": "Lists all discovered test files and exits the process without building or executing the tests.",
+      "default": false
+    },
     "dumpVirtualFiles": {
       "type": "boolean",
       "description": "Dumps build output files to the `.angular/cache` directory for debugging purposes.",
@@ -156,23 +267,5 @@
     }
   },
   "additionalProperties": false,
-  "required": ["buildTarget", "tsConfig", "runner"],
-  "definitions": {
-    "coverage-reporters": {
-      "enum": [
-        "html",
-        "lcov",
-        "lcovonly",
-        "text",
-        "text-summary",
-        "cobertura",
-        "json",
-        "json-summary"
-      ]
-    },
-    "reporters-enum": {
-      "type": "string",
-      "enum": ["default", "verbose", "dots", "json", "junit", "tap", "tap-flat", "html"]
-    }
-  }
+  "required": ["runner"]
 }

package/src/builders/unit-test/test-discovery.d.ts

@@ -5,4 +5,28 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.dev/license
  */
-export { findTests, getTestEntrypoints } from '../karma/find-tests';
+/**
+ * Finds all test files in the project.
+ *
+ * @param include Glob patterns of files to include.
+ * @param exclude Glob patterns of files to exclude.
+ * @param workspaceRoot The absolute path to the workspace root.
+ * @param projectSourceRoot The absolute path to the project's source root.
+ * @returns A unique set of absolute paths to all test files.
+ */
+export declare function findTests(include: string[], exclude: string[], workspaceRoot: string, projectSourceRoot: string): Promise<string[]>;
+interface TestEntrypointsOptions {
+    projectSourceRoot: string;
+    workspaceRoot: string;
+    removeTestExtension?: boolean;
+}
+/**
+ * Generates unique, dash-delimited bundle names for a set of test files.
+ * This is used to create distinct output files for each test.
+ *
+ * @param testFiles An array of absolute paths to test files.
+ * @param options Configuration options for generating entry points.
+ * @returns A map where keys are the generated unique bundle names and values are the original file paths.
+ */
+export declare function getTestEntrypoints(testFiles: string[], { projectSourceRoot, workspaceRoot, removeTestExtension }: TestEntrypointsOptions): Map<string, string>;
+export {};

package/src/builders/unit-test/test-discovery.js

@@ -7,8 +7,197 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTestEntrypoints = exports.findTests = void 0;
-// TODO: This should eventually contain the implementations for these
-var find_tests_1 = require("../karma/find-tests");
-Object.defineProperty(exports, "findTests", { enumerable: true, get: function () { return find_tests_1.findTests; } });
-Object.defineProperty(exports, "getTestEntrypoints", { enumerable: true, get: function () { return find_tests_1.getTestEntrypoints; } });
+exports.findTests = findTests;
+exports.getTestEntrypoints = getTestEntrypoints;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const tinyglobby_1 = require("tinyglobby");
+const path_1 = require("../../utils/path");
+/**
+ * Finds all test files in the project.
+ *
+ * @param include Glob patterns of files to include.
+ * @param exclude Glob patterns of files to exclude.
+ * @param workspaceRoot The absolute path to the workspace root.
+ * @param projectSourceRoot The absolute path to the project's source root.
+ * @returns A unique set of absolute paths to all test files.
+ */
+async function findTests(include, exclude, workspaceRoot, projectSourceRoot) {
+    const staticMatches = new Set();
+    const dynamicPatterns = [];
+    const normalizedExcludes = exclude.map((p) => normalizePattern(p, workspaceRoot, projectSourceRoot));
+    // 1. Separate static and dynamic patterns
+    for (const pattern of include) {
+        const normalized = normalizePattern(pattern, workspaceRoot, projectSourceRoot);
+        if ((0, tinyglobby_1.isDynamicPattern)(normalized)) {
+            dynamicPatterns.push(normalized);
+        }
+        else {
+            const result = await handleStaticPattern(normalized, projectSourceRoot);
+            if (Array.isArray(result)) {
+                result.forEach((file) => staticMatches.add(file));
+            }
+            else {
+                // It was a static path that didn't resolve to a spec, treat as dynamic
+                dynamicPatterns.push(result);
+            }
+        }
+    }
+    // 2. Execute a single glob for all dynamic patterns
+    if (dynamicPatterns.length > 0) {
+        const globMatches = await (0, tinyglobby_1.glob)(dynamicPatterns, {
+            cwd: projectSourceRoot,
+            absolute: true,
+            ignore: ['**/node_modules/**', ...normalizedExcludes],
+        });
+        for (const match of globMatches) {
+            staticMatches.add(match);
+        }
+    }
+    // 3. Combine and de-duplicate results
+    return [...staticMatches];
+}
+/**
+ * Generates unique, dash-delimited bundle names for a set of test files.
+ * This is used to create distinct output files for each test.
+ *
+ * @param testFiles An array of absolute paths to test files.
+ * @param options Configuration options for generating entry points.
+ * @returns A map where keys are the generated unique bundle names and values are the original file paths.
+ */
+function getTestEntrypoints(testFiles, { projectSourceRoot, workspaceRoot, removeTestExtension }) {
+    const seen = new Set();
+    const roots = [projectSourceRoot, workspaceRoot];
+    return new Map(Array.from(testFiles, (testFile) => {
+        const fileName = generateNameFromPath(testFile, roots, !!removeTestExtension);
+        const baseName = `spec-${fileName}`;
+        let uniqueName = baseName;
+        let suffix = 2;
+        while (seen.has(uniqueName)) {
+            uniqueName = `${baseName}-${suffix}`.replace(/([^\w](?:spec|test))-([\d]+)$/, '-$2$1');
+            ++suffix;
+        }
+        seen.add(uniqueName);
+        return [uniqueName, testFile];
+    }));
+}
+/**
+ * Generates a unique, dash-delimited name from a file path.
+ * This is used to create a consistent and readable bundle name for a given test file.
+ * @param testFile The absolute path to the test file.
+ * @param roots An array of root paths to remove from the beginning of the test file path.
+ * @param removeTestExtension Whether to remove the `.spec` or `.test` extension from the result.
+ * @returns A dash-cased name derived from the relative path of the test file.
+ */
+function generateNameFromPath(testFile, roots, removeTestExtension) {
+    const relativePath = removeRoots(testFile, roots);
+    let startIndex = 0;
+    // Skip leading dots and slashes
+    while (startIndex < relativePath.length && /^[./\\]$/.test(relativePath[startIndex])) {
+        startIndex++;
+    }
+    let endIndex = relativePath.length;
+    if (removeTestExtension) {
+        const match = relativePath.match(/\.(spec|test)\.[^.]+$/);
+        if (match?.index) {
+            endIndex = match.index;
+        }
+    }
+    else {
+        const extIndex = relativePath.lastIndexOf('.');
+        if (extIndex > startIndex) {
+            endIndex = extIndex;
+        }
+    }
+    // Build the final string in a single pass
+    let result = '';
+    for (let i = startIndex; i < endIndex; i++) {
+        const char = relativePath[i];
+        result += char === '/' || char === '\\' ? '-' : char;
+    }
+    return result;
+}
+const removeLeadingSlash = (pattern) => {
+    if (pattern.charAt(0) === '/') {
+        return pattern.substring(1);
+    }
+    return pattern;
+};
+const removeRelativeRoot = (path, root) => {
+    if (path.startsWith(root)) {
+        return path.substring(root.length);
+    }
+    return path;
+};
+/**
+ * Removes potential root paths from a file path, returning a relative path.
+ * If no root path matches, it returns the file's basename.
+ */
+function removeRoots(path, roots) {
+    for (const root of roots) {
+        if (path.startsWith(root)) {
+            return path.substring(root.length);
+        }
+    }
+    return (0, node_path_1.basename)(path);
+}
+/**
+ * Normalizes a glob pattern by converting it to a POSIX path, removing leading slashes,
+ * and making it relative to the project source root.
+ *
+ * @param pattern The glob pattern to normalize.
+ * @param workspaceRoot The absolute path to the workspace root.
+ * @param projectSourceRoot The absolute path to the project's source root.
+ * @returns A normalized glob pattern.
+ */
+function normalizePattern(pattern, workspaceRoot, projectSourceRoot) {
+    // normalize pattern, glob lib only accepts forward slashes
+    let normalizedPattern = (0, path_1.toPosixPath)(pattern);
+    normalizedPattern = removeLeadingSlash(normalizedPattern);
+    const relativeProjectRoot = (0, path_1.toPosixPath)((0, node_path_1.relative)(workspaceRoot, projectSourceRoot) + '/');
+    // remove relativeProjectRoot to support relative paths from root
+    // such paths are easy to get when running scripts via IDEs
+    return removeRelativeRoot(normalizedPattern, relativeProjectRoot);
+}
+/**
+ * Handles static (non-glob) patterns by attempting to resolve them to a directory
+ * of spec files or a corresponding `.spec` file.
+ *
+ * @param pattern The static path pattern.
+ * @param projectSourceRoot The absolute path to the project's source root.
+ * @returns A promise that resolves to either an array of found spec files, a new glob pattern,
+ * or the original pattern if no special handling was applied.
+ */
+async function handleStaticPattern(pattern, projectSourceRoot) {
+    const fullPath = (0, node_path_1.join)(projectSourceRoot, pattern);
+    if (await isDirectory(fullPath)) {
+        return `${pattern}/**/*.spec.@(ts|tsx)`;
+    }
+    const fileExt = (0, node_path_1.extname)(pattern);
+    // Replace extension to `.spec.ext`. Example: `src/app/app.component.ts`-> `src/app/app.component.spec.ts`
+    const potentialSpec = (0, node_path_1.join)(projectSourceRoot, (0, node_path_1.dirname)(pattern), `${(0, node_path_1.basename)(pattern, fileExt)}.spec${fileExt}`);
+    if (await exists(potentialSpec)) {
+        return [potentialSpec];
+    }
+    return pattern;
+}
+/** Checks if a path exists and is a directory. */
+async function isDirectory(path) {
+    try {
+        const stats = await node_fs_1.promises.stat(path);
+        return stats.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** Checks if a path exists on the file system. */
+async function exists(path) {
+    try {
+        await node_fs_1.promises.access(path, node_fs_1.constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/src/tools/angular/transformers/jit-bootstrap-transformer.js

@@ -30,7 +30,7 @@ function replaceBootstrap(getTypeChecker) {
                 if (target.text === PLATFORM_BROWSER_DYNAMIC_NAME) {
                     if (!bootstrapNamespace) {
                         bootstrapNamespace = nodeFactory.createUniqueName('__NgCli_bootstrap_');
-                        bootstrapImport = nodeFactory.createImportDeclaration(undefined, nodeFactory.createImportClause(false, undefined, nodeFactory.createNamespaceImport(bootstrapNamespace)), nodeFactory.createStringLiteral('@angular/platform-browser'));
+                        bootstrapImport = nodeFactory.createImportDeclaration(undefined, nodeFactory.createImportClause(undefined, undefined, nodeFactory.createNamespaceImport(bootstrapNamespace)), nodeFactory.createStringLiteral('@angular/platform-browser'));
                     }
                     replacedNodes.push(target);
                     return nodeFactory.updateCallExpression(node, nodeFactory.createPropertyAccessExpression(bootstrapNamespace, 'platformBrowser'), node.typeArguments, node.arguments);