@angular/build 18.0.0-next.3

package/src/utils/service-worker.js

@@ -0,0 +1,211 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC 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
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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.augmentAppWithServiceWorkerCore = exports.augmentAppWithServiceWorkerEsbuild = exports.augmentAppWithServiceWorker = void 0;
+const crypto = __importStar(require("crypto"));
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("path"));
+const bundler_context_1 = require("../tools/esbuild/bundler-context");
+const error_1 = require("./error");
+const load_esm_1 = require("./load-esm");
+class CliFilesystem {
+    fs;
+    base;
+    constructor(fs, base) {
+        this.fs = fs;
+        this.base = base;
+    }
+    list(dir) {
+        return this._recursiveList(this._resolve(dir), []);
+    }
+    read(file) {
+        return this.fs.readFile(this._resolve(file), 'utf-8');
+    }
+    async hash(file) {
+        return crypto
+            .createHash('sha1')
+            .update(await this.fs.readFile(this._resolve(file)))
+            .digest('hex');
+    }
+    write(_file, _content) {
+        throw new Error('This should never happen.');
+    }
+    _resolve(file) {
+        return path.join(this.base, file);
+    }
+    async _recursiveList(dir, items) {
+        const subdirectories = [];
+        for (const entry of await this.fs.readdir(dir)) {
+            const entryPath = path.join(dir, entry);
+            const stats = await this.fs.stat(entryPath);
+            if (stats.isFile()) {
+                // Uses posix paths since the service worker expects URLs
+                items.push('/' + path.relative(this.base, entryPath).replace(/\\/g, '/'));
+            }
+            else if (stats.isDirectory()) {
+                subdirectories.push(entryPath);
+            }
+        }
+        for (const subdirectory of subdirectories) {
+            await this._recursiveList(subdirectory, items);
+        }
+        return items;
+    }
+}
+class ResultFilesystem {
+    fileReaders = new Map();
+    constructor(outputFiles, assetFiles) {
+        for (const file of outputFiles) {
+            if (file.type === bundler_context_1.BuildOutputFileType.Media || file.type === bundler_context_1.BuildOutputFileType.Browser) {
+                this.fileReaders.set('/' + file.path.replace(/\\/g, '/'), async () => file.contents);
+            }
+        }
+        for (const file of assetFiles) {
+            this.fileReaders.set('/' + file.destination.replace(/\\/g, '/'), () => node_fs_1.promises.readFile(file.source));
+        }
+    }
+    async list(dir) {
+        if (dir !== '/') {
+            throw new Error('Serviceworker manifest generator should only list files from root.');
+        }
+        return [...this.fileReaders.keys()];
+    }
+    async read(file) {
+        const reader = this.fileReaders.get(file);
+        if (reader === undefined) {
+            throw new Error('File does not exist.');
+        }
+        const contents = await reader();
+        return Buffer.from(contents.buffer, contents.byteOffset, contents.byteLength).toString('utf-8');
+    }
+    async hash(file) {
+        const reader = this.fileReaders.get(file);
+        if (reader === undefined) {
+            throw new Error('File does not exist.');
+        }
+        return crypto
+            .createHash('sha1')
+            .update(await reader())
+            .digest('hex');
+    }
+    write() {
+        throw new Error('Serviceworker manifest generator should not attempted to write.');
+    }
+}
+async function augmentAppWithServiceWorker(appRoot, workspaceRoot, outputPath, baseHref, ngswConfigPath, inputputFileSystem = node_fs_1.promises, outputFileSystem = node_fs_1.promises) {
+    // Determine the configuration file path
+    const configPath = ngswConfigPath
+        ? path.join(workspaceRoot, ngswConfigPath)
+        : path.join(appRoot, 'ngsw-config.json');
+    // Read the configuration file
+    let config;
+    try {
+        const configurationData = await inputputFileSystem.readFile(configPath, 'utf-8');
+        config = JSON.parse(configurationData);
+    }
+    catch (error) {
+        (0, error_1.assertIsError)(error);
+        if (error.code === 'ENOENT') {
+            throw new Error('Error: Expected to find an ngsw-config.json configuration file' +
+                ` in the ${appRoot} folder. Either provide one or` +
+                ' disable Service Worker in the angular.json configuration file.');
+        }
+        else {
+            throw error;
+        }
+    }
+    const result = await augmentAppWithServiceWorkerCore(config, new CliFilesystem(outputFileSystem, outputPath), baseHref);
+    const copy = async (src, dest) => {
+        const resolvedDest = path.join(outputPath, dest);
+        return inputputFileSystem === outputFileSystem
+            ? // Native FS (Builder).
+                inputputFileSystem.copyFile(src, resolvedDest, node_fs_1.constants.COPYFILE_FICLONE)
+            : // memfs (Webpack): Read the file from the input FS (disk) and write it to the output FS (memory).
+                outputFileSystem.writeFile(resolvedDest, await inputputFileSystem.readFile(src));
+    };
+    await outputFileSystem.writeFile(path.join(outputPath, 'ngsw.json'), result.manifest);
+    for (const { source, destination } of result.assetFiles) {
+        await copy(source, destination);
+    }
+}
+exports.augmentAppWithServiceWorker = augmentAppWithServiceWorker;
+// This is currently used by the esbuild-based builder
+async function augmentAppWithServiceWorkerEsbuild(workspaceRoot, configPath, baseHref, indexHtml, outputFiles, assetFiles) {
+    // Read the configuration file
+    let config;
+    try {
+        const configurationData = await node_fs_1.promises.readFile(configPath, 'utf-8');
+        config = JSON.parse(configurationData);
+        if (indexHtml) {
+            config.index = indexHtml;
+        }
+    }
+    catch (error) {
+        (0, error_1.assertIsError)(error);
+        if (error.code === 'ENOENT') {
+            // TODO: Generate an error object that can be consumed by the esbuild-based builder
+            const message = `Service worker configuration file "${path.relative(workspaceRoot, configPath)}" could not be found.`;
+            throw new Error(message);
+        }
+        else {
+            throw error;
+        }
+    }
+    return augmentAppWithServiceWorkerCore(config, new ResultFilesystem(outputFiles, assetFiles), baseHref);
+}
+exports.augmentAppWithServiceWorkerEsbuild = augmentAppWithServiceWorkerEsbuild;
+async function augmentAppWithServiceWorkerCore(config, serviceWorkerFilesystem, baseHref) {
+    // Load ESM `@angular/service-worker/config` using the TypeScript dynamic import workaround.
+    // Once TypeScript provides support for keeping the dynamic import this workaround can be
+    // changed to a direct dynamic import.
+    const GeneratorConstructor = (await (0, load_esm_1.loadEsmModule)('@angular/service-worker/config')).Generator;
+    // Generate the manifest
+    const generator = new GeneratorConstructor(serviceWorkerFilesystem, baseHref);
+    const output = await generator.process(config);
+    // Write the manifest
+    const manifest = JSON.stringify(output, null, 2);
+    // Find the service worker package
+    const workerPath = require.resolve('@angular/service-worker/ngsw-worker.js');
+    const result = {
+        manifest,
+        // Main worker code
+        assetFiles: [{ source: workerPath, destination: 'ngsw-worker.js' }],
+    };
+    // If present, write the safety worker code
+    const safetyPath = path.join(path.dirname(workerPath), 'safety-worker.js');
+    if ((0, node_fs_1.existsSync)(safetyPath)) {
+        result.assetFiles.push({ source: safetyPath, destination: 'worker-basic.min.js' });
+        result.assetFiles.push({ source: safetyPath, destination: 'safety-worker.js' });
+    }
+    return result;
+}
+exports.augmentAppWithServiceWorkerCore = augmentAppWithServiceWorkerCore;

package/src/utils/spinner.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright Google LLC 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
+ */
+export declare class Spinner {
+    #private;
+    private readonly spinner;
+    /** When false, only fail messages will be displayed. */
+    enabled: boolean;
+    constructor(text?: string);
+    set text(text: string);
+    get isSpinning(): boolean;
+    succeed(text?: string): void;
+    fail(text?: string): void;
+    stop(): void;
+    start(text?: string): void;
+}

package/src/utils/spinner.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC 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
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Spinner = void 0;
+const ora_1 = __importDefault(require("ora"));
+const color_1 = require("./color");
+const tty_1 = require("./tty");
+class Spinner {
+    spinner;
+    /** When false, only fail messages will be displayed. */
+    enabled = true;
+    #isTTY = (0, tty_1.isTTY)();
+    constructor(text) {
+        this.spinner = (0, ora_1.default)({
+            text: text === undefined ? undefined : text + '\n',
+            // The below 2 options are needed because otherwise CTRL+C will be delayed
+            // when the underlying process is sync.
+            hideCursor: false,
+            discardStdin: false,
+            isEnabled: this.#isTTY,
+        });
+    }
+    set text(text) {
+        this.spinner.text = text;
+    }
+    get isSpinning() {
+        return this.spinner.isSpinning || !this.#isTTY;
+    }
+    succeed(text) {
+        if (this.enabled) {
+            this.spinner.succeed(text);
+        }
+    }
+    fail(text) {
+        this.spinner.fail(text && color_1.colors.redBright(text));
+    }
+    stop() {
+        this.spinner.stop();
+    }
+    start(text) {
+        if (this.enabled) {
+            this.spinner.start(text);
+        }
+    }
+}
+exports.Spinner = Spinner;

package/src/utils/stats-table.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright Google LLC 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 { BudgetCalculatorResult } from './bundle-calculator';
+export type BundleStatsData = [
+    files: string,
+    names: string,
+    rawSize: number | string,
+    estimatedTransferSize: number | string
+];
+export interface BundleStats {
+    initial: boolean;
+    stats: BundleStatsData;
+}
+export declare function generateEsbuildBuildStatsTable([browserStats, serverStats]: [browserStats: BundleStats[], serverStats: BundleStats[]], colors: boolean, showTotalSize: boolean, showEstimatedTransferSize: boolean, budgetFailures?: BudgetCalculatorResult[], verbose?: boolean): string;
+export declare function generateBuildStatsTable(data: BundleStats[], colors: boolean, showTotalSize: boolean, showEstimatedTransferSize: boolean, budgetFailures?: BudgetCalculatorResult[]): string;

package/src/utils/stats-table.js

@@ -0,0 +1,205 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC 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 });
+exports.generateBuildStatsTable = exports.generateEsbuildBuildStatsTable = void 0;
+const node_util_1 = require("node:util");
+const color_1 = require("./color");
+const format_bytes_1 = require("./format-bytes");
+function generateEsbuildBuildStatsTable([browserStats, serverStats], colors, showTotalSize, showEstimatedTransferSize, budgetFailures, verbose) {
+    const bundleInfo = generateBuildStatsData(browserStats, colors, showTotalSize, showEstimatedTransferSize, budgetFailures, verbose);
+    if (serverStats.length) {
+        const m = (x) => (colors ? color_1.colors.magenta(x) : x);
+        if (browserStats.length) {
+            bundleInfo.unshift([m('Browser bundles')]);
+            // Add seperators between browser and server logs
+            bundleInfo.push([], []);
+        }
+        bundleInfo.push([m('Server bundles')], ...generateBuildStatsData(serverStats, colors, false, false, undefined, verbose));
+    }
+    return generateTableText(bundleInfo, colors);
+}
+exports.generateEsbuildBuildStatsTable = generateEsbuildBuildStatsTable;
+function generateBuildStatsTable(data, colors, showTotalSize, showEstimatedTransferSize, budgetFailures) {
+    const bundleInfo = generateBuildStatsData(data, colors, showTotalSize, showEstimatedTransferSize, budgetFailures, true);
+    return generateTableText(bundleInfo, colors);
+}
+exports.generateBuildStatsTable = generateBuildStatsTable;
+function generateBuildStatsData(data, colors, showTotalSize, showEstimatedTransferSize, budgetFailures, verbose) {
+    if (data.length === 0) {
+        return [];
+    }
+    const g = (x) => (colors ? color_1.colors.green(x) : x);
+    const c = (x) => (colors ? color_1.colors.cyan(x) : x);
+    const r = (x) => (colors ? color_1.colors.redBright(x) : x);
+    const y = (x) => (colors ? color_1.colors.yellowBright(x) : x);
+    const bold = (x) => (colors ? color_1.colors.bold(x) : x);
+    const dim = (x) => (colors ? color_1.colors.dim(x) : x);
+    const getSizeColor = (name, file, defaultColor = c) => {
+        const severity = budgets.get(name) || (file && budgets.get(file));
+        switch (severity) {
+            case 'warning':
+                return y;
+            case 'error':
+                return r;
+            default:
+                return defaultColor;
+        }
+    };
+    const changedEntryChunksStats = [];
+    const changedLazyChunksStats = [];
+    let initialTotalRawSize = 0;
+    let changedLazyChunksCount = 0;
+    let initialTotalEstimatedTransferSize;
+    const maxLazyChunksWithoutBudgetFailures = 15;
+    const budgets = new Map();
+    if (budgetFailures) {
+        for (const { label, severity } of budgetFailures) {
+            // In some cases a file can have multiple budget failures.
+            // Favor error.
+            if (label && (!budgets.has(label) || budgets.get(label) === 'warning')) {
+                budgets.set(label, severity);
+            }
+        }
+    }
+    // Sort descending by raw size
+    data.sort((a, b) => {
+        if (a.stats[2] > b.stats[2]) {
+            return -1;
+        }
+        if (a.stats[2] < b.stats[2]) {
+            return 1;
+        }
+        return 0;
+    });
+    for (const { initial, stats } of data) {
+        const [files, names, rawSize, estimatedTransferSize] = stats;
+        if (!initial &&
+            !verbose &&
+            changedLazyChunksStats.length >= maxLazyChunksWithoutBudgetFailures &&
+            !budgets.has(names) &&
+            !budgets.has(files)) {
+            // Limit the number of lazy chunks displayed in the stats table when there is no budget failure and not in verbose mode.
+            changedLazyChunksCount++;
+            continue;
+        }
+        const getRawSizeColor = getSizeColor(names, files);
+        let data;
+        if (showEstimatedTransferSize) {
+            data = [
+                g(files),
+                dim(names),
+                getRawSizeColor(typeof rawSize === 'number' ? (0, format_bytes_1.formatSize)(rawSize) : rawSize),
+                c(typeof estimatedTransferSize === 'number'
+                    ? (0, format_bytes_1.formatSize)(estimatedTransferSize)
+                    : estimatedTransferSize),
+            ];
+        }
+        else {
+            data = [
+                g(files),
+                dim(names),
+                getRawSizeColor(typeof rawSize === 'number' ? (0, format_bytes_1.formatSize)(rawSize) : rawSize),
+                '',
+            ];
+        }
+        if (initial) {
+            changedEntryChunksStats.push(data);
+            if (typeof rawSize === 'number') {
+                initialTotalRawSize += rawSize;
+            }
+            if (showEstimatedTransferSize && typeof estimatedTransferSize === 'number') {
+                if (initialTotalEstimatedTransferSize === undefined) {
+                    initialTotalEstimatedTransferSize = 0;
+                }
+                initialTotalEstimatedTransferSize += estimatedTransferSize;
+            }
+        }
+        else {
+            changedLazyChunksStats.push(data);
+            changedLazyChunksCount++;
+        }
+    }
+    const bundleInfo = [];
+    const baseTitles = ['Names', 'Raw size'];
+    if (showEstimatedTransferSize) {
+        baseTitles.push('Estimated transfer size');
+    }
+    // Entry chunks
+    if (changedEntryChunksStats.length) {
+        bundleInfo.push(['Initial chunk files', ...baseTitles].map(bold), ...changedEntryChunksStats);
+        if (showTotalSize) {
+            const initialSizeTotalColor = getSizeColor('bundle initial', undefined, (x) => x);
+            const totalSizeElements = [
+                ' ',
+                'Initial total',
+                initialSizeTotalColor((0, format_bytes_1.formatSize)(initialTotalRawSize)),
+            ];
+            if (showEstimatedTransferSize) {
+                totalSizeElements.push(typeof initialTotalEstimatedTransferSize === 'number'
+                    ? (0, format_bytes_1.formatSize)(initialTotalEstimatedTransferSize)
+                    : '-');
+            }
+            bundleInfo.push([], totalSizeElements.map(bold));
+        }
+    }
+    // Seperator
+    if (changedEntryChunksStats.length && changedLazyChunksStats.length) {
+        bundleInfo.push([]);
+    }
+    // Lazy chunks
+    if (changedLazyChunksStats.length) {
+        bundleInfo.push(['Lazy chunk files', ...baseTitles].map(bold), ...changedLazyChunksStats);
+        if (changedLazyChunksCount > changedLazyChunksStats.length) {
+            bundleInfo.push([
+                dim(`...and ${changedLazyChunksCount - changedLazyChunksStats.length} more lazy chunks files. ` +
+                    'Use "--verbose" to show all the files.'),
+            ]);
+        }
+    }
+    return bundleInfo;
+}
+function generateTableText(bundleInfo, colors) {
+    const skipText = (value) => value.includes('...and ');
+    const longest = [];
+    for (const item of bundleInfo) {
+        for (let i = 0; i < item.length; i++) {
+            if (item[i] === undefined) {
+                continue;
+            }
+            const currentItem = item[i].toString();
+            if (skipText(currentItem)) {
+                continue;
+            }
+            const currentLongest = (longest[i] ??= 0);
+            const currentItemLength = (0, node_util_1.stripVTControlCharacters)(currentItem).length;
+            if (currentLongest < currentItemLength) {
+                longest[i] = currentItemLength;
+            }
+        }
+    }
+    const seperator = colors ? color_1.colors.dim(' | ') : ' | ';
+    const outputTable = [];
+    for (const item of bundleInfo) {
+        for (let i = 0; i < longest.length; i++) {
+            if (item[i] === undefined) {
+                continue;
+            }
+            const currentItem = item[i].toString();
+            if (skipText(currentItem)) {
+                continue;
+            }
+            const currentItemLength = (0, node_util_1.stripVTControlCharacters)(currentItem).length;
+            const stringPad = ' '.repeat(longest[i] - currentItemLength);
+            // Values in columns at index 2 and 3 (Raw and Estimated sizes) are always right aligned.
+            item[i] = i >= 2 ? stringPad + currentItem : currentItem + stringPad;
+        }
+        outputTable.push(item.join(seperator));
+    }
+    return outputTable.join('\n');
+}

package/src/utils/supported-browsers.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright Google LLC 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
+ */
+export declare function getSupportedBrowsers(projectRoot: string, logger: {
+    warn(message: string): void;
+}): string[];

package/src/utils/supported-browsers.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC 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
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSupportedBrowsers = void 0;
+const browserslist_1 = __importDefault(require("browserslist"));
+function getSupportedBrowsers(projectRoot, logger) {
+    browserslist_1.default.defaults = [
+        'last 2 Chrome versions',
+        'last 1 Firefox version',
+        'last 2 Edge major versions',
+        'last 2 Safari major versions',
+        'last 2 iOS major versions',
+        'Firefox ESR',
+    ];
+    // Get browsers from config or default.
+    const browsersFromConfigOrDefault = new Set((0, browserslist_1.default)(undefined, { path: projectRoot }));
+    // Get browsers that support ES6 modules.
+    const browsersThatSupportEs6 = new Set((0, browserslist_1.default)('supports es6-module'));
+    const unsupportedBrowsers = [];
+    for (const browser of browsersFromConfigOrDefault) {
+        if (!browsersThatSupportEs6.has(browser)) {
+            browsersFromConfigOrDefault.delete(browser);
+            unsupportedBrowsers.push(browser);
+        }
+    }
+    if (unsupportedBrowsers.length) {
+        logger.warn(`One or more browsers which are configured in the project's Browserslist configuration ` +
+            'will be ignored as ES5 output is not supported by the Angular CLI.\n' +
+            `Ignored browsers: ${unsupportedBrowsers.join(', ')}`);
+    }
+    return Array.from(browsersFromConfigOrDefault);
+}
+exports.getSupportedBrowsers = getSupportedBrowsers;

package/src/utils/tty.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright Google LLC 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
+ */
+export declare function isTTY(): boolean;

package/src/utils/tty.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC 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 });
+exports.isTTY = void 0;
+function _isTruthy(value) {
+    // Returns true if value is a string that is anything but 0 or false.
+    return value !== undefined && value !== '0' && value.toUpperCase() !== 'FALSE';
+}
+function isTTY() {
+    // If we force TTY, we always return true.
+    const force = process.env['NG_FORCE_TTY'];
+    if (force !== undefined) {
+        return _isTruthy(force);
+    }
+    return !!process.stdout.isTTY && !_isTruthy(process.env['CI']);
+}
+exports.isTTY = isTTY;

package/src/utils/url.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright Google LLC 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
+ */
+export declare function urlJoin(...parts: string[]): string;

package/src/utils/url.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC 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 });
+exports.urlJoin = void 0;
+function urlJoin(...parts) {
+    const [p, ...rest] = parts;
+    // Remove trailing slash from first part
+    // Join all parts with `/`
+    // Dedupe double slashes from path names
+    return p.replace(/\/$/, '') + ('/' + rest.join('/')).replace(/\/\/+/g, '/');
+}
+exports.urlJoin = urlJoin;

package/src/utils/version.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright Google LLC 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
+ */
+export declare function assertCompatibleAngularVersion(projectRoot: string): void | never;