@angular/build 18.0.0-next.3

package/src/utils/load-proxy-config.js

@@ -0,0 +1,189 @@
+"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.loadProxyConfiguration = void 0;
+const fast_glob_1 = require("fast-glob");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const node_url_1 = require("node:url");
+const picomatch_1 = require("picomatch");
+const error_1 = require("./error");
+const load_esm_1 = require("./load-esm");
+async function loadProxyConfiguration(root, proxyConfig) {
+    if (!proxyConfig) {
+        return undefined;
+    }
+    const proxyPath = (0, node_path_1.resolve)(root, proxyConfig);
+    if (!(0, node_fs_1.existsSync)(proxyPath)) {
+        throw new Error(`Proxy configuration file ${proxyPath} does not exist.`);
+    }
+    let proxyConfiguration;
+    switch ((0, node_path_1.extname)(proxyPath)) {
+        case '.json': {
+            const content = await (0, promises_1.readFile)(proxyPath, 'utf-8');
+            const { parse, printParseErrorCode } = await Promise.resolve().then(() => __importStar(require('jsonc-parser')));
+            const parseErrors = [];
+            proxyConfiguration = parse(content, parseErrors, { allowTrailingComma: true });
+            if (parseErrors.length > 0) {
+                let errorMessage = `Proxy configuration file ${proxyPath} contains parse errors:`;
+                for (const parseError of parseErrors) {
+                    const { line, column } = getJsonErrorLineColumn(parseError.offset, content);
+                    errorMessage += `\n[${line}, ${column}] ${printParseErrorCode(parseError.error)}`;
+                }
+                throw new Error(errorMessage);
+            }
+            break;
+        }
+        case '.mjs':
+            // Load the ESM configuration file 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.
+            proxyConfiguration = (await (0, load_esm_1.loadEsmModule)((0, node_url_1.pathToFileURL)(proxyPath)))
+                .default;
+            break;
+        case '.cjs':
+            proxyConfiguration = require(proxyPath);
+            break;
+        default:
+            // The file could be either CommonJS or ESM.
+            // CommonJS is tried first then ESM if loading fails.
+            try {
+                proxyConfiguration = require(proxyPath);
+                break;
+            }
+            catch (e) {
+                (0, error_1.assertIsError)(e);
+                if (e.code === 'ERR_REQUIRE_ESM') {
+                    // Load the ESM configuration file 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.
+                    proxyConfiguration = (await (0, load_esm_1.loadEsmModule)((0, node_url_1.pathToFileURL)(proxyPath)))
+                        .default;
+                    break;
+                }
+                throw e;
+            }
+    }
+    return normalizeProxyConfiguration(proxyConfiguration);
+}
+exports.loadProxyConfiguration = loadProxyConfiguration;
+/**
+ * Converts glob patterns to regular expressions to support Vite's proxy option.
+ * Also converts the Webpack supported array form to an object form supported by both.
+ *
+ * @param proxy A proxy configuration object.
+ */
+function normalizeProxyConfiguration(proxy) {
+    let normalizedProxy;
+    if (Array.isArray(proxy)) {
+        // Construct an object-form proxy configuration from the array
+        normalizedProxy = {};
+        for (const proxyEntry of proxy) {
+            if (!('context' in proxyEntry)) {
+                continue;
+            }
+            if (!Array.isArray(proxyEntry.context)) {
+                continue;
+            }
+            // Array-form entries contain a context string array with the path(s)
+            // to use for the configuration entry.
+            const context = proxyEntry.context;
+            delete proxyEntry.context;
+            for (const contextEntry of context) {
+                if (typeof contextEntry !== 'string') {
+                    continue;
+                }
+                normalizedProxy[contextEntry] = proxyEntry;
+            }
+        }
+    }
+    else {
+        normalizedProxy = proxy;
+    }
+    // TODO: Consider upstreaming glob support
+    for (const key of Object.keys(normalizedProxy)) {
+        if (key[0] !== '^' && (0, fast_glob_1.isDynamicPattern)(key)) {
+            const pattern = (0, picomatch_1.makeRe)(key).source;
+            normalizedProxy[pattern] = normalizedProxy[key];
+            delete normalizedProxy[key];
+        }
+    }
+    // Replace `pathRewrite` field with a `rewrite` function
+    for (const proxyEntry of Object.values(normalizedProxy)) {
+        if (typeof proxyEntry === 'object' &&
+            'pathRewrite' in proxyEntry &&
+            proxyEntry.pathRewrite &&
+            typeof proxyEntry.pathRewrite === 'object') {
+            // Preprocess path rewrite entries
+            const pathRewriteEntries = [];
+            for (const [pattern, value] of Object.entries(proxyEntry.pathRewrite)) {
+                pathRewriteEntries.push([new RegExp(pattern), value]);
+            }
+            proxyEntry.rewrite = pathRewriter.bind(undefined, pathRewriteEntries);
+            delete proxyEntry.pathRewrite;
+        }
+    }
+    return normalizedProxy;
+}
+function pathRewriter(pathRewriteEntries, path) {
+    for (const [pattern, value] of pathRewriteEntries) {
+        const updated = path.replace(pattern, value);
+        if (path !== updated) {
+            return updated;
+        }
+    }
+    return path;
+}
+/**
+ * Calculates the line and column for an error offset in the content of a JSON file.
+ * @param location The offset error location from the beginning of the content.
+ * @param content The full content of the file containing the error.
+ * @returns An object containing the line and column
+ */
+function getJsonErrorLineColumn(offset, content) {
+    if (offset === 0) {
+        return { line: 1, column: 1 };
+    }
+    let line = 0;
+    let position = 0;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        ++line;
+        const nextNewline = content.indexOf('\n', position);
+        if (nextNewline === -1 || nextNewline > offset) {
+            break;
+        }
+        position = nextNewline + 1;
+    }
+    return { line, column: offset - position + 1 };
+}

package/src/utils/load-translations.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @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 type { Diagnostics } from '@angular/localize/tools';
+export type TranslationLoader = (path: string) => {
+    translations: Record<string, import('@angular/localize').ɵParsedTranslation>;
+    format: string;
+    locale?: string;
+    diagnostics: Diagnostics;
+    integrity: string;
+};
+export declare function createTranslationLoader(): Promise<TranslationLoader>;

package/src/utils/load-translations.js

@@ -0,0 +1,84 @@
+"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.createTranslationLoader = void 0;
+const crypto_1 = require("crypto");
+const fs = __importStar(require("fs"));
+const load_esm_1 = require("./load-esm");
+async function createTranslationLoader() {
+    const { parsers, diagnostics } = await importParsers();
+    return (path) => {
+        const content = fs.readFileSync(path, 'utf8');
+        const unusedParsers = new Map();
+        for (const [format, parser] of Object.entries(parsers)) {
+            const analysis = parser.analyze(path, content);
+            if (analysis.canParse) {
+                // Types don't overlap here so we need to use any.
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const { locale, translations } = parser.parse(path, content, analysis.hint);
+                const integrity = 'sha256-' + (0, crypto_1.createHash)('sha256').update(content).digest('base64');
+                return { format, locale, translations, diagnostics, integrity };
+            }
+            else {
+                unusedParsers.set(parser, analysis);
+            }
+        }
+        const messages = [];
+        for (const [parser, analysis] of unusedParsers.entries()) {
+            messages.push(analysis.diagnostics.formatDiagnostics(`*** ${parser.constructor.name} ***`));
+        }
+        throw new Error(`Unsupported translation file format in ${path}. The following parsers were tried:\n` +
+            messages.join('\n'));
+    };
+}
+exports.createTranslationLoader = createTranslationLoader;
+async function importParsers() {
+    try {
+        // Load ESM `@angular/localize/tools` 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 { Diagnostics, ArbTranslationParser, SimpleJsonTranslationParser, Xliff1TranslationParser, Xliff2TranslationParser, XtbTranslationParser, } = await (0, load_esm_1.loadEsmModule)('@angular/localize/tools');
+        const diagnostics = new Diagnostics();
+        const parsers = {
+            arb: new ArbTranslationParser(),
+            json: new SimpleJsonTranslationParser(),
+            xlf: new Xliff1TranslationParser(),
+            xlf2: new Xliff2TranslationParser(),
+            // The name ('xmb') needs to match the AOT compiler option
+            xmb: new XtbTranslationParser(),
+        };
+        return { parsers, diagnostics };
+    }
+    catch {
+        throw new Error(`Unable to load translation file parsers. Please ensure '@angular/localize' is installed.`);
+    }
+}

package/src/utils/normalize-asset-patterns.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @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 { AssetPattern, AssetPatternClass } from '../builders/application/schema';
+export declare class MissingAssetSourceRootException extends Error {
+    constructor(path: string);
+}
+export declare function normalizeAssetPatterns(assetPatterns: AssetPattern[], workspaceRoot: string, projectRoot: string, projectSourceRoot: string | undefined): (AssetPatternClass & {
+    output: string;
+})[];

package/src/utils/normalize-asset-patterns.js

@@ -0,0 +1,96 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeAssetPatterns = exports.MissingAssetSourceRootException = void 0;
+const fs_1 = require("fs");
+const node_assert_1 = __importDefault(require("node:assert"));
+const path = __importStar(require("path"));
+class MissingAssetSourceRootException extends Error {
+    constructor(path) {
+        super(`The ${path} asset path must start with the project source root.`);
+    }
+}
+exports.MissingAssetSourceRootException = MissingAssetSourceRootException;
+function normalizeAssetPatterns(assetPatterns, workspaceRoot, projectRoot, projectSourceRoot) {
+    if (assetPatterns.length === 0) {
+        return [];
+    }
+    // When sourceRoot is not available, we default to ${projectRoot}/src.
+    const sourceRoot = projectSourceRoot || path.join(projectRoot, 'src');
+    const resolvedSourceRoot = path.resolve(workspaceRoot, sourceRoot);
+    return assetPatterns.map((assetPattern) => {
+        // Normalize string asset patterns to objects.
+        if (typeof assetPattern === 'string') {
+            const assetPath = path.normalize(assetPattern);
+            const resolvedAssetPath = path.resolve(workspaceRoot, assetPath);
+            // Check if the string asset is within sourceRoot.
+            if (!resolvedAssetPath.startsWith(resolvedSourceRoot)) {
+                throw new MissingAssetSourceRootException(assetPattern);
+            }
+            let glob, input;
+            let isDirectory = false;
+            try {
+                isDirectory = (0, fs_1.statSync)(resolvedAssetPath).isDirectory();
+            }
+            catch {
+                isDirectory = true;
+            }
+            if (isDirectory) {
+                // Folders get a recursive star glob.
+                glob = '**/*';
+                // Input directory is their original path.
+                input = assetPath;
+            }
+            else {
+                // Files are their own glob.
+                glob = path.basename(assetPath);
+                // Input directory is their original dirname.
+                input = path.dirname(assetPath);
+            }
+            // Output directory for both is the relative path from source root to input.
+            const output = path.relative(resolvedSourceRoot, path.resolve(workspaceRoot, input));
+            assetPattern = { glob, input, output };
+        }
+        else {
+            assetPattern.output = path.join('.', assetPattern.output ?? '');
+        }
+        (0, node_assert_1.default)(assetPattern.output !== undefined);
+        if (assetPattern.output.startsWith('..')) {
+            throw new Error('An asset cannot be written to a location outside of the output path.');
+        }
+        return assetPattern;
+    });
+}
+exports.normalizeAssetPatterns = normalizeAssetPatterns;

package/src/utils/normalize-cache.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @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 interface NormalizedCachedOptions {
+    /** Whether disk cache is enabled. */
+    enabled: boolean;
+    /** Disk cache path. Example: `/.angular/cache/v12.0.0`. */
+    path: string;
+    /** Disk cache base path. Example: `/.angular/cache`. */
+    basePath: string;
+}
+export declare function normalizeCacheOptions(projectMetadata: unknown, worspaceRoot: string): NormalizedCachedOptions;

package/src/utils/normalize-cache.js

@@ -0,0 +1,44 @@
+"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.normalizeCacheOptions = void 0;
+const node_path_1 = require("node:path");
+/** Version placeholder is replaced during the build process with actual package version */
+const VERSION = '18.0.0-next.3';
+function hasCacheMetadata(value) {
+    return (!!value &&
+        typeof value === 'object' &&
+        'cli' in value &&
+        !!value['cli'] &&
+        typeof value['cli'] === 'object' &&
+        'cache' in value['cli']);
+}
+function normalizeCacheOptions(projectMetadata, worspaceRoot) {
+    const cacheMetadata = hasCacheMetadata(projectMetadata) ? projectMetadata.cli.cache : {};
+    const { enabled = true, environment = 'local', path = '.angular/cache' } = cacheMetadata;
+    const isCI = process.env['CI'] === '1' || process.env['CI']?.toLowerCase() === 'true';
+    let cacheEnabled = enabled;
+    if (cacheEnabled) {
+        switch (environment) {
+            case 'ci':
+                cacheEnabled = isCI;
+                break;
+            case 'local':
+                cacheEnabled = !isCI;
+                break;
+        }
+    }
+    const cacheBasePath = (0, node_path_1.resolve)(worspaceRoot, path);
+    return {
+        enabled: cacheEnabled,
+        basePath: cacheBasePath,
+        path: (0, node_path_1.join)(cacheBasePath, VERSION),
+    };
+}
+exports.normalizeCacheOptions = normalizeCacheOptions;

package/src/utils/normalize-optimization.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @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 { FontsClass, OptimizationClass, OptimizationUnion, StylesClass } from '../builders/application/schema';
+export type NormalizedOptimizationOptions = Required<Omit<OptimizationClass, 'fonts' | 'styles'>> & {
+    fonts: FontsClass;
+    styles: StylesClass;
+};
+export declare function normalizeOptimization(optimization?: OptimizationUnion): NormalizedOptimizationOptions;

package/src/utils/normalize-optimization.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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeOptimization = void 0;
+function normalizeOptimization(optimization = true) {
+    if (typeof optimization === 'object') {
+        const styleOptimization = !!optimization.styles;
+        return {
+            scripts: !!optimization.scripts,
+            styles: typeof optimization.styles === 'object'
+                ? optimization.styles
+                : {
+                    minify: styleOptimization,
+                    removeSpecialComments: styleOptimization,
+                    inlineCritical: styleOptimization,
+                },
+            fonts: typeof optimization.fonts === 'object'
+                ? optimization.fonts
+                : {
+                    inline: !!optimization.fonts,
+                },
+        };
+    }
+    return {
+        scripts: optimization,
+        styles: {
+            minify: optimization,
+            inlineCritical: optimization,
+            removeSpecialComments: optimization,
+        },
+        fonts: {
+            inline: optimization,
+        },
+    };
+}
+exports.normalizeOptimization = normalizeOptimization;

package/src/utils/normalize-source-maps.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @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 { SourceMapClass, SourceMapUnion } from '../builders/application/schema';
+export declare function normalizeSourceMaps(sourceMap: SourceMapUnion): SourceMapClass;

package/src/utils/normalize-source-maps.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.normalizeSourceMaps = void 0;
+function normalizeSourceMaps(sourceMap) {
+    const scripts = typeof sourceMap === 'object' ? sourceMap.scripts : sourceMap;
+    const styles = typeof sourceMap === 'object' ? sourceMap.styles : sourceMap;
+    const hidden = (typeof sourceMap === 'object' && sourceMap.hidden) || false;
+    const vendor = (typeof sourceMap === 'object' && sourceMap.vendor) || false;
+    return {
+        vendor,
+        hidden,
+        scripts,
+        styles,
+    };
+}
+exports.normalizeSourceMaps = normalizeSourceMaps;

package/src/utils/postcss-configuration.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @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 interface PostcssConfiguration {
+    plugins: [name: string, options?: object | string][];
+}
+export interface SearchDirectory {
+    root: string;
+    files: Set<string>;
+}
+export declare function generateSearchDirectories(roots: string[]): Promise<SearchDirectory[]>;
+export declare function findTailwindConfiguration(searchDirectories: SearchDirectory[]): string | undefined;
+export declare function loadPostcssConfiguration(searchDirectories: SearchDirectory[]): Promise<PostcssConfiguration | undefined>;

package/src/utils/postcss-configuration.js

@@ -0,0 +1,86 @@
+"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.loadPostcssConfiguration = exports.findTailwindConfiguration = exports.generateSearchDirectories = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const postcssConfigurationFiles = ['postcss.config.json', '.postcssrc.json'];
+const tailwindConfigFiles = [
+    'tailwind.config.js',
+    'tailwind.config.cjs',
+    'tailwind.config.mjs',
+    'tailwind.config.ts',
+];
+async function generateSearchDirectories(roots) {
+    return await Promise.all(roots.map((root) => (0, promises_1.readdir)(root, { withFileTypes: true }).then((entries) => ({
+        root,
+        files: new Set(entries.filter((entry) => entry.isFile()).map((entry) => entry.name)),
+    }))));
+}
+exports.generateSearchDirectories = generateSearchDirectories;
+function findFile(searchDirectories, potentialFiles) {
+    for (const { root, files } of searchDirectories) {
+        for (const potential of potentialFiles) {
+            if (files.has(potential)) {
+                return (0, node_path_1.join)(root, potential);
+            }
+        }
+    }
+    return undefined;
+}
+function findTailwindConfiguration(searchDirectories) {
+    return findFile(searchDirectories, tailwindConfigFiles);
+}
+exports.findTailwindConfiguration = findTailwindConfiguration;
+async function readPostcssConfiguration(configurationFile) {
+    const data = await (0, promises_1.readFile)(configurationFile, 'utf-8');
+    const config = JSON.parse(data);
+    return config;
+}
+async function loadPostcssConfiguration(searchDirectories) {
+    const configPath = findFile(searchDirectories, postcssConfigurationFiles);
+    if (!configPath) {
+        return undefined;
+    }
+    const raw = await readPostcssConfiguration(configPath);
+    // If no plugins are defined, consider it equivalent to no configuration
+    if (!raw.plugins || typeof raw.plugins !== 'object') {
+        return undefined;
+    }
+    // Normalize plugin array form
+    if (Array.isArray(raw.plugins)) {
+        if (raw.plugins.length < 1) {
+            return undefined;
+        }
+        const config = { plugins: [] };
+        for (const element of raw.plugins) {
+            if (typeof element === 'string') {
+                config.plugins.push([element]);
+            }
+            else {
+                config.plugins.push(element);
+            }
+        }
+        return config;
+    }
+    // Normalize plugin object map form
+    const entries = Object.entries(raw.plugins);
+    if (entries.length < 1) {
+        return undefined;
+    }
+    const config = { plugins: [] };
+    for (const [name, options] of entries) {
+        if (!options || (typeof options !== 'object' && typeof options !== 'string')) {
+            continue;
+        }
+        config.plugins.push([name, options]);
+    }
+    return config;
+}
+exports.loadPostcssConfiguration = loadPostcssConfiguration;

package/src/utils/purge-cache.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
+ */
+import { BuilderContext } from '@angular-devkit/architect';
+/** Delete stale cache directories used by previous versions of build-angular. */
+export declare function purgeStaleBuildCache(context: BuilderContext): Promise<void>;