@angular-devkit/build-angular 12.2.0-next.0 → 12.2.0

package/src/utils/delete-output-dir.js

@@ -6,9 +6,28 @@
  * 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
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deleteOutputDir = void 0;
-const fs_1 = require("fs");
+const fs = __importStar(require("fs"));
 const path_1 = require("path");
 /**
  * Delete an output directory, but error out if it's the root of the project.
@@ -18,6 +37,13 @@ function deleteOutputDir(root, outputPath) {
     if (resolvedOutputPath === root) {
         throw new Error('Output path MUST not be project root directory!');
     }
-    fs_1.rmdirSync(resolvedOutputPath, { recursive: true, maxRetries: 3 });
+    // The below should be removed and replace with just `rmSync` when support for Node.Js 12 is removed.
+    const { rmSync, rmdirSync } = fs;
+    if (rmSync) {
+        rmSync(resolvedOutputPath, { force: true, recursive: true, maxRetries: 3 });
+    }
+    else {
+        rmdirSync(resolvedOutputPath, { recursive: true, maxRetries: 3 });
+    }
 }
 exports.deleteOutputDir = deleteOutputDir;

package/src/utils/index-file/inline-fonts.d.ts

@@ -14,5 +14,7 @@ export declare class InlineFontsProcessor {
     constructor(options: InlineFontsOptions);
     process(content: string): Promise<string>;
     private getResponse;
-    private processHrefs;
+    private processHref;
+    private getFontProviderDetails;
+    private createNormalizedUrl;
 }

package/src/utils/index-file/inline-fonts.js

@@ -42,31 +42,77 @@ const cacheFontsPath = environment_options_1.cachingDisabled
     ? undefined
     : cache_path_1.findCachePath('angular-build-fonts');
 const packageVersion = require('../../../package.json').version;
-const SUPPORTED_PROVIDERS = ['fonts.googleapis.com'];
+const SUPPORTED_PROVIDERS = {
+    'fonts.googleapis.com': {
+        seperateRequestForWOFF: true,
+        preconnectUrl: 'https://fonts.gstatic.com',
+    },
+    'use.typekit.net': {
+        seperateRequestForWOFF: false,
+        preconnectUrl: 'https://use.typekit.net',
+    },
+};
 class InlineFontsProcessor {
     constructor(options) {
         this.options = options;
     }
     async process(content) {
+        var _a;
         const hrefList = [];
+        const existingPreconnect = new Set();
         // Collector link tags with href
         const { rewriter: collectorStream } = await html_rewriting_stream_1.htmlRewritingStream(content);
         collectorStream.on('startTag', (tag) => {
-            var _a;
             const { tagName, attrs } = tag;
             if (tagName !== 'link') {
                 return;
             }
-            // <link tag with rel="stylesheet" and a href.
-            const href = attrs.find(({ name, value }) => name === 'rel' && value === 'stylesheet') &&
-                ((_a = attrs.find(({ name }) => name === 'href')) === null || _a === void 0 ? void 0 : _a.value);
-            if (href) {
-                hrefList.push(href);
+            let hrefValue;
+            let relValue;
+            for (const { name, value } of attrs) {
+                switch (name) {
+                    case 'rel':
+                        relValue = value;
+                        break;
+                    case 'href':
+                        hrefValue = value;
+                        break;
+                }
+                if (hrefValue && relValue) {
+                    switch (relValue) {
+                        case 'stylesheet':
+                            // <link rel="stylesheet" href="https://example.com/main.css">
+                            hrefList.push(hrefValue);
+                            break;
+                        case 'preconnect':
+                            // <link rel="preconnect" href="https://example.com">
+                            existingPreconnect.add(hrefValue.replace(/\/$/, ''));
+                            break;
+                    }
+                    return;
+                }
             }
         });
         await new Promise((resolve) => collectorStream.on('finish', resolve));
         // Download stylesheets
-        const hrefsContent = await this.processHrefs(hrefList);
+        const hrefsContent = new Map();
+        const newPreconnectUrls = new Set();
+        for (const hrefItem of hrefList) {
+            const url = this.createNormalizedUrl(hrefItem);
+            if (!url) {
+                continue;
+            }
+            const content = await this.processHref(url);
+            if (content === undefined) {
+                continue;
+            }
+            hrefsContent.set(hrefItem, content);
+            // Add preconnect
+            const preconnectUrl = (_a = this.getFontProviderDetails(url)) === null || _a === void 0 ? void 0 : _a.preconnectUrl;
+            if (preconnectUrl && !existingPreconnect.has(preconnectUrl)) {
+                newPreconnectUrls.add(preconnectUrl);
+            }
+        }
         if (hrefsContent.size === 0) {
             return content;
         }
@@ -74,19 +120,28 @@ class InlineFontsProcessor {
         const { rewriter, transformedContent } = await html_rewriting_stream_1.htmlRewritingStream(content);
         rewriter.on('startTag', (tag) => {
             const { tagName, attrs } = tag;
-            if (tagName !== 'link') {
-                rewriter.emitStartTag(tag);
-                return;
-            }
-            const hrefAttr = attrs.some(({ name, value }) => name === 'rel' && value === 'stylesheet') &&
-                attrs.find(({ name, value }) => name === 'href' && hrefsContent.has(value));
-            if (hrefAttr) {
-                const href = hrefAttr.value;
-                const cssContent = hrefsContent.get(href);
-                rewriter.emitRaw(`<style type="text/css">${cssContent}</style>`);
-            }
-            else {
-                rewriter.emitStartTag(tag);
+            switch (tagName) {
+                case 'head':
+                    rewriter.emitStartTag(tag);
+                    for (const url of newPreconnectUrls) {
+                        rewriter.emitRaw(`<link rel="preconnect" href="${url}" crossorigin>`);
+                    }
+                    break;
+                case 'link':
+                    const hrefAttr = attrs.some(({ name, value }) => name === 'rel' && value === 'stylesheet') &&
+                        attrs.find(({ name, value }) => name === 'href' && hrefsContent.has(value));
+                    if (hrefAttr) {
+                        const href = hrefAttr.value;
+                        const cssContent = hrefsContent.get(href);
+                        rewriter.emitRaw(`<style type="text/css">${cssContent}</style>`);
+                    }
+                    else {
+                        rewriter.emitStartTag(tag);
+                    }
+                    break;
+                default:
+                    rewriter.emitStartTag(tag);
+                    break;
             }
         });
         return transformedContent;
@@ -129,41 +184,43 @@ class InlineFontsProcessor {
         }
         return data;
     }
-    async processHrefs(hrefList) {
-        const hrefsContent = new Map();
-        for (const hrefPath of hrefList) {
-            // Need to convert '//' to 'https://' because the URL parser will fail with '//'.
-            const normalizedHref = hrefPath.startsWith('//') ? `https:${hrefPath}` : hrefPath;
-            if (!normalizedHref.startsWith('http')) {
-                // Non valid URL.
-                // Example: relative path styles.css.
-                continue;
-            }
-            const url = new url_1.URL(normalizedHref);
-            // Force HTTPS protocol
-            url.protocol = 'https:';
-            if (!SUPPORTED_PROVIDERS.includes(url.hostname)) {
-                // Provider not supported.
-                continue;
-            }
-            // The order IE -> Chrome is important as otherwise Chrome will load woff1.
-            let cssContent = '';
-            if (this.options.WOFFSupportNeeded) {
-                cssContent += await this.getResponse(url, "Mozilla/5.0 (Windows NT 10.0; Trident/7.0; rv:11. 0) like Gecko" /* IE */);
-            }
-            cssContent += await this.getResponse(url, "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.121 Safari/537.36" /* Chrome */);
-            if (this.options.minify) {
-                cssContent = cssContent
-                    // Comments.
-                    .replace(/\/\*([\s\S]*?)\*\//g, '')
-                    // New lines.
-                    .replace(/\n/g, '')
-                    // Safe spaces.
-                    .replace(/\s?[\{\:\;]\s+/g, (s) => s.trim());
-            }
-            hrefsContent.set(hrefPath, cssContent);
+    async processHref(url) {
+        const provider = this.getFontProviderDetails(url);
+        if (!provider) {
+            return undefined;
+        }
+        // The order IE -> Chrome is important as otherwise Chrome will load woff1.
+        let cssContent = '';
+        if (this.options.WOFFSupportNeeded && provider.seperateRequestForWOFF) {
+            cssContent += await this.getResponse(url, "Mozilla/5.0 (Windows NT 10.0; Trident/7.0; rv:11. 0) like Gecko" /* IE */);
+        }
+        cssContent += await this.getResponse(url, "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.121 Safari/537.36" /* Chrome */);
+        if (this.options.minify) {
+            cssContent = cssContent
+                // Comments.
+                .replace(/\/\*([\s\S]*?)\*\//g, '')
+                // New lines.
+                .replace(/\n/g, '')
+                // Safe spaces.
+                .replace(/\s?[\{\:\;]\s+/g, (s) => s.trim());
+        }
+        return cssContent;
+    }
+    getFontProviderDetails(url) {
+        return SUPPORTED_PROVIDERS[url.hostname];
+    }
+    createNormalizedUrl(value) {
+        // Need to convert '//' to 'https://' because the URL parser will fail with '//'.
+        const normalizedHref = value.startsWith('//') ? `https:${value}` : value;
+        if (!normalizedHref.startsWith('http')) {
+            // Non valid URL.
+            // Example: relative path styles.css.
+            return undefined;
         }
-        return hrefsContent;
+        const url = new url_1.URL(normalizedHref);
+        // Force HTTPS protocol
+        url.protocol = 'https:';
+        return url;
     }
 }
 exports.InlineFontsProcessor = InlineFontsProcessor;

package/src/utils/process-bundle.d.ts

@@ -7,7 +7,6 @@
  */
 /// <reference types="packages/angular_devkit/build_angular/src/babel-bazel" />
 import { PluginObj } from '@babel/core';
-import { I18nOptions } from './i18n-options';
 export interface ProcessBundleOptions {
     filename: string;
     code: string;
@@ -47,10 +46,6 @@ export declare const enum CacheKey {
     DownlevelCode = 2,
     DownlevelMap = 3
 }
-export declare function setup(data: number[] | {
-    cachePath: string;
-    i18n: I18nOptions;
-}): void;
 export declare function process(options: ProcessBundleOptions): Promise<ProcessBundleResult>;
 export declare function createI18nPlugins(locale: string, translation: unknown | undefined, missingTranslation: 'error' | 'warning' | 'ignore', shouldInline: boolean, localeDataContent?: string): Promise<{
     diagnostics: import("@angular/localize/src/tools/src/diagnostics").Diagnostics;

package/src/utils/process-bundle.js

@@ -29,31 +29,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.inlineLocales = exports.createI18nPlugins = exports.process = exports.setup = void 0;
+exports.inlineLocales = exports.createI18nPlugins = exports.process = void 0;
+const remapping_1 = __importDefault(require("@ampproject/remapping"));
 const core_1 = require("@babel/core");
 const template_1 = __importDefault(require("@babel/template"));
 const cacache = __importStar(require("cacache"));
 const crypto_1 = require("crypto");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const source_map_1 = require("source-map");
 const terser_1 = require("terser");
-const v8 = __importStar(require("v8"));
-const webpack_1 = require("webpack");
+const worker_threads_1 = require("worker_threads");
 const environment_options_1 = require("./environment-options");
-const { ConcatSource, OriginalSource, ReplaceSource, SourceMapSource } = webpack_1.sources;
+// Lazy loaded webpack-sources object
+// Webpack is only imported if needed during the processing
+let webpackSources;
 // If code size is larger than 500KB, consider lower fidelity but faster sourcemap merge
 const FAST_SOURCEMAP_THRESHOLD = 500 * 1024;
-let cachePath;
-let i18n;
-function setup(data) {
-    const options = Array.isArray(data)
-        ? v8.deserialize(Buffer.from(data))
-        : data;
-    cachePath = options.cachePath;
-    i18n = options.i18n;
-}
-exports.setup = setup;
+const { cachePath, i18n } = (worker_threads_1.workerData || {});
 async function cachePut(content, key, integrity) {
     if (cachePath && key) {
         await cacache.put(cachePath, key, content, {
@@ -62,6 +54,7 @@ async function cachePut(content, key, integrity) {
     }
 }
 async function process(options) {
+    var _a;
     if (!options.cacheKeys) {
         options.cacheKeys = [];
     }
@@ -79,9 +72,6 @@ async function process(options) {
     const downlevelFilename = filename.replace(/\-(es20\d{2}|esnext)/, '-es5');
     const downlevel = !options.optimizeOnly;
     const sourceCode = options.code;
-    const sourceMap = options.map ? JSON.parse(options.map) : undefined;
-    let downlevelCode;
-    let downlevelMap;
     if (downlevel) {
         const { supportedBrowsers: targets = [] } = options;
         // todo: revisit this in version 10, when we update our defaults browserslist
@@ -121,26 +111,15 @@ async function process(options) {
             ],
             minified: environment_options_1.allowMinify && !!options.optimize,
             compact: !environment_options_1.shouldBeautify && !!options.optimize,
-            sourceMaps: !!sourceMap,
+            sourceMaps: !!options.map,
         });
         if (!transformResult || !transformResult.code) {
             throw new Error(`Unknown error occurred processing bundle for "${options.filename}".`);
         }
-        downlevelCode = transformResult.code;
-        if (sourceMap && transformResult.map) {
-            // String length is used as an estimate for byte length
-            const fastSourceMaps = sourceCode.length > FAST_SOURCEMAP_THRESHOLD;
-            downlevelMap = await mergeSourceMaps(sourceCode, sourceMap, downlevelCode, transformResult.map, filename, 
-            // When not optimizing, the sourcemaps are significantly less complex
-            // and can use the higher fidelity merge
-            !!options.optimize && fastSourceMaps);
-        }
-    }
-    if (downlevelCode) {
         result.downlevel = await processBundle({
             ...options,
-            code: downlevelCode,
-            map: downlevelMap,
+            code: transformResult.code,
+            downlevelMap: (_a = transformResult.map) !== null && _a !== void 0 ? _a : undefined,
             filename: path.join(basePath, downlevelFilename),
             isOriginal: false,
         });
@@ -154,113 +133,46 @@ async function process(options) {
     return result;
 }
 exports.process = process;
-async function mergeSourceMaps(inputCode, inputSourceMap, resultCode, resultSourceMap, filename, fast = false) {
-    // Webpack 5 terser sourcemaps currently fail merging with the high-quality method
-    if (fast) {
-        return mergeSourceMapsFast(inputSourceMap, resultSourceMap);
-    }
-    // SourceMapSource produces high-quality sourcemaps
-    // Final sourcemap will always be available when providing the input sourcemaps
-    const finalSourceMap = new SourceMapSource(resultCode, filename, resultSourceMap, inputCode, inputSourceMap, true).map();
-    return finalSourceMap;
-}
-async function mergeSourceMapsFast(first, second) {
-    const sourceRoot = first.sourceRoot;
-    const generator = new source_map_1.SourceMapGenerator();
-    // sourcemap package adds the sourceRoot to all position source paths if not removed
-    delete first.sourceRoot;
-    await source_map_1.SourceMapConsumer.with(first, null, (originalConsumer) => {
-        return source_map_1.SourceMapConsumer.with(second, null, (newConsumer) => {
-            newConsumer.eachMapping((mapping) => {
-                if (mapping.originalLine === null) {
-                    return;
-                }
-                const originalPosition = originalConsumer.originalPositionFor({
-                    line: mapping.originalLine,
-                    column: mapping.originalColumn,
-                });
-                if (originalPosition.line === null ||
-                    originalPosition.column === null ||
-                    originalPosition.source === null) {
-                    return;
-                }
-                generator.addMapping({
-                    generated: {
-                        line: mapping.generatedLine,
-                        column: mapping.generatedColumn,
-                    },
-                    name: originalPosition.name || undefined,
-                    original: {
-                        line: originalPosition.line,
-                        column: originalPosition.column,
-                    },
-                    source: originalPosition.source,
-                });
-            });
-        });
-    });
-    const map = generator.toJSON();
-    map.file = second.file;
-    map.sourceRoot = sourceRoot;
-    // Add source content if present
-    if (first.sourcesContent) {
-        // Source content array is based on index of sources
-        const sourceContentMap = new Map();
-        for (let i = 0; i < first.sources.length; i++) {
-            // make paths "absolute" so they can be compared (`./a.js` and `a.js` are equivalent)
-            sourceContentMap.set(path.resolve('/', first.sources[i]), i);
-        }
-        map.sourcesContent = [];
-        for (let i = 0; i < map.sources.length; i++) {
-            const contentIndex = sourceContentMap.get(path.resolve('/', map.sources[i]));
-            if (contentIndex === undefined) {
-                map.sourcesContent.push('');
-            }
-            else {
-                map.sourcesContent.push(first.sourcesContent[contentIndex]);
-            }
-        }
-    }
-    // Put the sourceRoot back
-    if (sourceRoot) {
-        first.sourceRoot = sourceRoot;
-    }
-    return map;
-}
 async function processBundle(options) {
-    const { optimize, isOriginal, code, map, filename: filepath, hiddenSourceMaps, cacheKeys = [], integrityAlgorithm, } = options;
-    const rawMap = typeof map === 'string' ? JSON.parse(map) : map;
+    const { optimize, isOriginal, code, map, downlevelMap, filename: filepath, hiddenSourceMaps, cacheKeys = [], integrityAlgorithm, } = options;
     const filename = path.basename(filepath);
-    let result;
-    if (rawMap) {
-        rawMap.file = filename;
-    }
+    let resultCode = code;
+    let optimizeResult;
     if (optimize) {
-        result = await terserMangle(code, {
+        optimizeResult = await terserMangle(code, {
             filename,
-            map: rawMap,
+            sourcemap: !!map,
             compress: !isOriginal,
             ecma: isOriginal ? 2015 : 5,
         });
-    }
-    else {
-        result = {
-            map: rawMap,
-            code,
-        };
+        resultCode = optimizeResult.code;
     }
     let mapContent;
-    if (result.map) {
+    if (map) {
         if (!hiddenSourceMaps) {
-            result.code += `\n//# sourceMappingURL=${filename}.map`;
+            resultCode += `\n//# sourceMappingURL=${filename}.map`;
+        }
+        const partialSourcemaps = [];
+        if (optimizeResult && optimizeResult.map) {
+            partialSourcemaps.push(optimizeResult.map);
+        }
+        if (downlevelMap) {
+            partialSourcemaps.push(downlevelMap);
+        }
+        if (partialSourcemaps.length > 0) {
+            partialSourcemaps.push(map);
+            const fullSourcemap = remapping_1.default(partialSourcemaps, () => null);
+            mapContent = JSON.stringify(fullSourcemap);
+        }
+        else {
+            mapContent = map;
         }
-        mapContent = JSON.stringify(result.map);
         await cachePut(mapContent, cacheKeys[isOriginal ? 1 /* OriginalMap */ : 3 /* DownlevelMap */]);
         fs.writeFileSync(filepath + '.map', mapContent);
     }
-    const fileResult = createFileEntry(filepath, result.code, mapContent, integrityAlgorithm);
-    await cachePut(result.code, cacheKeys[isOriginal ? 0 /* OriginalCode */ : 2 /* DownlevelCode */], fileResult.integrity);
-    fs.writeFileSync(filepath, result.code);
+    const fileResult = createFileEntry(filepath, resultCode, mapContent, integrityAlgorithm);
+    await cachePut(resultCode, cacheKeys[isOriginal ? 0 /* OriginalCode */ : 2 /* DownlevelCode */], fileResult.integrity);
+    fs.writeFileSync(filepath, resultCode);
     return fileResult;
 }
 async function terserMangle(code, options = {}) {
@@ -278,7 +190,7 @@ async function terserMangle(code, options = {}) {
             beautify: environment_options_1.shouldBeautify,
             wrap_func_args: false,
         },
-        sourceMap: !!options.map &&
+        sourceMap: !!options.sourcemap &&
             {
                 asObject: true,
                 // typings don't include asObject option
@@ -286,12 +198,7 @@ async function terserMangle(code, options = {}) {
             },
     });
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const outputCode = minifyOutput.code;
-    let outputMap;
-    if (options.map && minifyOutput.map) {
-        outputMap = await mergeSourceMaps(code, options.map, outputCode, minifyOutput.map, options.filename || '0', code.length > FAST_SOURCEMAP_THRESHOLD);
-    }
-    return { code: outputCode, map: outputMap };
+    return { code: minifyOutput.code, map: minifyOutput.map };
 }
 function createFileEntry(filename, code, map, integrityAlgorithm) {
     return {
@@ -450,7 +357,6 @@ async function inlineLocales(options) {
         return inlineLocalesDirect(ast, options);
     }
     const diagnostics = [];
-    const inputMap = options.map && JSON.parse(options.map);
     for (const locale of i18n.inlineLocales) {
         const isSourceLocale = locale === i18n.sourceLocale;
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -474,7 +380,7 @@ async function inlineLocales(options) {
             configFile: false,
             plugins,
             compact: !environment_options_1.shouldBeautify,
-            sourceMaps: !!inputMap,
+            sourceMaps: !!options.map,
         });
         diagnostics.push(...localeDiagnostics.messages);
         if (!transformResult || !transformResult.code) {
@@ -482,8 +388,8 @@ async function inlineLocales(options) {
         }
         const outputPath = path.join(options.outputPath, i18n.flatOutput ? '' : locale, options.filename);
         fs.writeFileSync(outputPath, transformResult.code);
-        if (inputMap && transformResult.map) {
-            const outputMap = await mergeSourceMaps(options.code, inputMap, transformResult.code, transformResult.map, options.filename, options.code.length > FAST_SOURCEMAP_THRESHOLD);
+        if (options.map && transformResult.map) {
+            const outputMap = remapping_1.default([transformResult.map, options.map], () => null);
             fs.writeFileSync(outputPath + '.map', JSON.stringify(outputMap));
         }
     }
@@ -502,16 +408,20 @@ async function inlineLocalesDirect(ast, options) {
     if (positions.length === 0 && !options.setLocale) {
         return inlineCopyOnly(options);
     }
-    const inputMap = options.map && JSON.parse(options.map);
+    const inputMap = !!options.map && JSON.parse(options.map);
     // Cleanup source root otherwise it will be added to each source entry
     const mapSourceRoot = inputMap && inputMap.sourceRoot;
     if (inputMap) {
         delete inputMap.sourceRoot;
     }
+    // Load Webpack only when needed
+    if (webpackSources === undefined) {
+        webpackSources = (await Promise.resolve().then(() => __importStar(require('webpack')))).sources;
+    }
+    const { ConcatSource, OriginalSource, ReplaceSource, SourceMapSource } = webpackSources;
     for (const locale of i18n.inlineLocales) {
         const content = new ReplaceSource(inputMap
-            ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                new SourceMapSource(options.code, options.filename, inputMap)
+            ? new SourceMapSource(options.code, options.filename, inputMap)
             : new OriginalSource(options.code, options.filename));
         const isSourceLocale = locale === i18n.sourceLocale;
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -526,7 +436,7 @@ async function inlineLocalesDirect(ast, options) {
         if (options.setLocale) {
             const setLocaleText = `var $localize=Object.assign(void 0===$localize?{}:$localize,{locale:"${locale}"});\n`;
             // If locale data is provided, load it and prepend to file
-            let localeDataSource = null;
+            let localeDataSource;
             const localeDataPath = i18n.locales[locale] && i18n.locales[locale].dataPath;
             if (localeDataPath) {
                 const localeDataContent = await loadLocaleData(localeDataPath, true, options.es5);

package/src/utils/version.d.ts

@@ -5,5 +5,4 @@
  * 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 { logging } from '@angular-devkit/core';
-export declare function assertCompatibleAngularVersion(projectRoot: string, logger: logging.LoggerApi): void;
+export declare function assertCompatibleAngularVersion(projectRoot: string): void | never;

package/src/utils/version.js

@@ -8,9 +8,10 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.assertCompatibleAngularVersion = void 0;
+/* eslint-disable no-console */
 const core_1 = require("@angular-devkit/core");
 const semver_1 = require("semver");
-function assertCompatibleAngularVersion(projectRoot, logger) {
+function assertCompatibleAngularVersion(projectRoot) {
     let angularCliPkgJson;
     let angularPkgJson;
     let rxjsPkgJson;
@@ -22,13 +23,13 @@ function assertCompatibleAngularVersion(projectRoot, logger) {
         rxjsPkgJson = require(rxjsPackagePath);
     }
     catch {
-        logger.error(core_1.tags.stripIndents `
+        console.error(core_1.tags.stripIndents `
       You seem to not be depending on "@angular/core" and/or "rxjs". This is an error.
     `);
         process.exit(2);
     }
     if (!(angularPkgJson && angularPkgJson['version'] && rxjsPkgJson && rxjsPkgJson['version'])) {
-        logger.error(core_1.tags.stripIndents `
+        console.error(core_1.tags.stripIndents `
       Cannot determine versions of "@angular/core" and/or "rxjs".
       This likely means your local installation is broken. Please reinstall your packages.
     `);
@@ -57,7 +58,7 @@ function assertCompatibleAngularVersion(projectRoot, logger) {
     // of both 8 and 9.
     const supportedAngularSemver = `^${cliMajor}.0.0-next || >=${cliMajor}.0.0 <${cliMajor + 1}.0.0`;
     if (!semver_1.satisfies(angularVersion, supportedAngularSemver, { includePrerelease: true })) {
-        logger.error(core_1.tags.stripIndents `
+        console.error(core_1.tags.stripIndents `
         This version of CLI is only compatible with Angular versions ${supportedAngularSemver},
         but Angular version ${angularVersion} was found instead.