@angular/build 18.0.0-next.3

package/src/builders/application/i18n.js

@@ -0,0 +1,128 @@
+"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.loadActiveTranslations = exports.inlineI18n = void 0;
+const node_path_1 = require("node:path");
+const bundler_context_1 = require("../../tools/esbuild/bundler-context");
+const i18n_inliner_1 = require("../../tools/esbuild/i18n-inliner");
+const environment_options_1 = require("../../utils/environment-options");
+const i18n_options_1 = require("../../utils/i18n-options");
+const load_translations_1 = require("../../utils/load-translations");
+const url_1 = require("../../utils/url");
+const execute_post_bundle_1 = require("./execute-post-bundle");
+/**
+ * Inlines all active locales as specified by the application build options into all
+ * application JavaScript files created during the build.
+ * @param options The normalized application builder options used to create the build.
+ * @param executionResult The result of an executed build.
+ * @param initialFiles A map containing initial file information for the executed build.
+ */
+async function inlineI18n(options, executionResult, initialFiles) {
+    // Create the multi-threaded inliner with common options and the files generated from the build.
+    const inliner = new i18n_inliner_1.I18nInliner({
+        missingTranslation: options.i18nOptions.missingTranslationBehavior ?? 'warning',
+        outputFiles: executionResult.outputFiles,
+        shouldOptimize: options.optimizationOptions.scripts,
+    }, environment_options_1.maxWorkers);
+    const inlineResult = {
+        errors: [],
+        warnings: [],
+        prerenderedRoutes: [],
+    };
+    // For each active locale, use the inliner to process the output files of the build.
+    const updatedOutputFiles = [];
+    const updatedAssetFiles = [];
+    try {
+        for (const locale of options.i18nOptions.inlineLocales) {
+            // A locale specific set of files is returned from the inliner.
+            const localeInlineResult = await inliner.inlineForLocale(locale, options.i18nOptions.locales[locale].translation);
+            const localeOutputFiles = localeInlineResult.outputFiles;
+            inlineResult.errors.push(...localeInlineResult.errors);
+            inlineResult.warnings.push(...localeInlineResult.warnings);
+            const baseHref = getLocaleBaseHref(options.baseHref, options.i18nOptions, locale) ?? options.baseHref;
+            const { errors, warnings, additionalAssets, additionalOutputFiles, prerenderedRoutes: generatedRoutes, } = await (0, execute_post_bundle_1.executePostBundleSteps)({
+                ...options,
+                baseHref,
+            }, localeOutputFiles, executionResult.assetFiles, initialFiles, locale);
+            localeOutputFiles.push(...additionalOutputFiles);
+            inlineResult.errors.push(...errors);
+            inlineResult.warnings.push(...warnings);
+            // Update directory with locale base
+            if (options.i18nOptions.flatOutput !== true) {
+                localeOutputFiles.forEach((file) => {
+                    file.path = (0, node_path_1.join)(locale, file.path);
+                });
+                for (const assetFile of [...executionResult.assetFiles, ...additionalAssets]) {
+                    updatedAssetFiles.push({
+                        source: assetFile.source,
+                        destination: (0, node_path_1.join)(locale, assetFile.destination),
+                    });
+                }
+                inlineResult.prerenderedRoutes.push(...generatedRoutes.map((route) => node_path_1.posix.join('/', locale, route)));
+            }
+            else {
+                inlineResult.prerenderedRoutes.push(...generatedRoutes);
+                executionResult.assetFiles.push(...additionalAssets);
+            }
+            updatedOutputFiles.push(...localeOutputFiles);
+        }
+    }
+    finally {
+        await inliner.close();
+    }
+    // Update the result with all localized files.
+    executionResult.outputFiles = [
+        // Root files are not modified.
+        ...executionResult.outputFiles.filter(({ type }) => type === bundler_context_1.BuildOutputFileType.Root),
+        // Updated files for each locale.
+        ...updatedOutputFiles,
+    ];
+    // Assets are only changed if not using the flat output option
+    if (options.i18nOptions.flatOutput !== true) {
+        executionResult.assetFiles = updatedAssetFiles;
+    }
+    return inlineResult;
+}
+exports.inlineI18n = inlineI18n;
+function getLocaleBaseHref(baseHref, i18n, locale) {
+    if (i18n.flatOutput) {
+        return undefined;
+    }
+    if (i18n.locales[locale] && i18n.locales[locale].baseHref !== '') {
+        return (0, url_1.urlJoin)(baseHref || '', i18n.locales[locale].baseHref ?? `/${locale}/`);
+    }
+    return undefined;
+}
+/**
+ * Loads all active translations using the translation loaders from the `@angular/localize` package.
+ * @param context The architect builder context for the current build.
+ * @param i18n The normalized i18n options to use.
+ */
+async function loadActiveTranslations(context, i18n) {
+    // Load locale data and translations (if present)
+    let loader;
+    for (const [locale, desc] of Object.entries(i18n.locales)) {
+        if (!i18n.inlineLocales.has(locale) && locale !== i18n.sourceLocale) {
+            continue;
+        }
+        if (!desc.files.length) {
+            continue;
+        }
+        loader ??= await (0, load_translations_1.createTranslationLoader)();
+        (0, i18n_options_1.loadTranslations)(locale, desc, context.workspaceRoot, loader, {
+            warn(message) {
+                context.logger.warn(message);
+            },
+            error(message) {
+                throw new Error(message);
+            },
+        }, undefined, i18n.duplicateTranslationBehavior);
+    }
+}
+exports.loadActiveTranslations = loadActiveTranslations;

package/src/builders/application/index.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @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, BuilderOutput } from '@angular-devkit/architect';
+import type { Plugin } from 'esbuild';
+import { BuildOutputFile } from '../../tools/esbuild/bundler-context';
+import { ApplicationBuilderExtensions, ApplicationBuilderInternalOptions } from './options';
+import { Schema as ApplicationBuilderOptions } from './schema';
+export { ApplicationBuilderOptions };
+export declare function buildApplicationInternal(options: ApplicationBuilderInternalOptions, context: BuilderContext & {
+    signal?: AbortSignal;
+}, infrastructureSettings?: {
+    write?: boolean;
+}, extensions?: ApplicationBuilderExtensions): AsyncIterable<ApplicationBuilderOutput>;
+export interface ApplicationBuilderOutput extends BuilderOutput {
+    outputFiles?: BuildOutputFile[];
+    assetFiles?: {
+        source: string;
+        destination: string;
+    }[];
+}
+/**
+ * Builds an application using the `application` builder with the provided
+ * options.
+ *
+ * Usage of the `plugins` parameter is NOT supported and may cause unexpected
+ * build output or build failures.
+ *
+ * @experimental Direct usage of this function is considered experimental.
+ *
+ * @param options The options defined by the builder's schema to use.
+ * @param context An Architect builder context instance.
+ * @param plugins An array of plugins to apply to the main code bundling.
+ * @returns The build output results of the build.
+ */
+export declare function buildApplication(options: ApplicationBuilderOptions, context: BuilderContext, plugins?: Plugin[]): AsyncIterable<ApplicationBuilderOutput>;
+/**
+ * Builds an application using the `application` builder with the provided
+ * options.
+ *
+ * Usage of the `extensions` parameter is NOT supported and may cause unexpected
+ * build output or build failures.
+ *
+ * @experimental Direct usage of this function is considered experimental.
+ *
+ * @param options The options defined by the builder's schema to use.
+ * @param context An Architect builder context instance.
+ * @param extensions An object contain extension points for the build.
+ * @returns The build output results of the build.
+ */
+export declare function buildApplication(options: ApplicationBuilderOptions, context: BuilderContext, extensions?: ApplicationBuilderExtensions): AsyncIterable<ApplicationBuilderOutput>;
+declare const _default: import("../../../../../angular_devkit/architect/src/internal").Builder<ApplicationBuilderOptions & import("../../../../../angular_devkit/core/src").JsonObject>;
+export default _default;

package/src/builders/application/index.js

@@ -0,0 +1,121 @@
+"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.buildApplication = exports.buildApplicationInternal = void 0;
+const architect_1 = require("@angular-devkit/architect");
+const bundler_context_1 = require("../../tools/esbuild/bundler-context");
+const utils_1 = require("../../tools/esbuild/utils");
+const color_1 = require("../../utils/color");
+const purge_cache_1 = require("../../utils/purge-cache");
+const version_1 = require("../../utils/version");
+const build_action_1 = require("./build-action");
+const execute_build_1 = require("./execute-build");
+const options_1 = require("./options");
+async function* buildApplicationInternal(options, 
+// TODO: Integrate abort signal support into builder system
+context, infrastructureSettings, extensions) {
+    const { workspaceRoot, logger, target } = context;
+    // Check Angular version.
+    (0, version_1.assertCompatibleAngularVersion)(workspaceRoot);
+    // Purge old build disk cache.
+    await (0, purge_cache_1.purgeStaleBuildCache)(context);
+    // Determine project name from builder context target
+    const projectName = target?.project;
+    if (!projectName) {
+        yield { success: false, error: `The 'application' builder requires a target to be specified.` };
+        return;
+    }
+    const normalizedOptions = await (0, options_1.normalizeOptions)(context, projectName, options, extensions);
+    const writeToFileSystem = infrastructureSettings?.write ?? true;
+    const writeServerBundles = writeToFileSystem && !!(normalizedOptions.ssrOptions && normalizedOptions.serverEntryPoint);
+    if (writeServerBundles) {
+        const { browser, server } = normalizedOptions.outputOptions;
+        if (browser === '') {
+            yield {
+                success: false,
+                error: `'outputPath.browser' cannot be configured to an empty string when SSR is enabled.`,
+            };
+            return;
+        }
+        if (browser === server) {
+            yield {
+                success: false,
+                error: `'outputPath.browser' and 'outputPath.server' cannot be configured to the same value.`,
+            };
+            return;
+        }
+    }
+    // Setup an abort controller with a builder teardown if no signal is present
+    let signal = context.signal;
+    if (!signal) {
+        const controller = new AbortController();
+        signal = controller.signal;
+        context.addTeardown(() => controller.abort('builder-teardown'));
+    }
+    yield* (0, build_action_1.runEsBuildBuildAction)(async (rebuildState) => {
+        const { prerenderOptions, outputOptions, jsonLogs } = normalizedOptions;
+        const startTime = process.hrtime.bigint();
+        const result = await (0, execute_build_1.executeBuild)(normalizedOptions, context, rebuildState);
+        if (jsonLogs) {
+            result.addLog(await (0, utils_1.createJsonBuildManifest)(result, normalizedOptions));
+        }
+        else {
+            if (prerenderOptions) {
+                const prerenderedRoutesLength = result.prerenderedRoutes.length;
+                let prerenderMsg = `Prerendered ${prerenderedRoutesLength} static route`;
+                prerenderMsg += prerenderedRoutesLength !== 1 ? 's.' : '.';
+                result.addLog(color_1.colors.magenta(prerenderMsg));
+            }
+            const buildTime = Number(process.hrtime.bigint() - startTime) / 10 ** 9;
+            const hasError = result.errors.length > 0;
+            if (writeToFileSystem && !hasError) {
+                result.addLog(`Output location: ${outputOptions.base}\n`);
+            }
+            result.addLog(`Application bundle generation ${hasError ? 'failed' : 'complete'}. [${buildTime.toFixed(3)} seconds]\n`);
+        }
+        return result;
+    }, {
+        watch: normalizedOptions.watch,
+        preserveSymlinks: normalizedOptions.preserveSymlinks,
+        poll: normalizedOptions.poll,
+        deleteOutputPath: normalizedOptions.deleteOutputPath,
+        cacheOptions: normalizedOptions.cacheOptions,
+        outputOptions: normalizedOptions.outputOptions,
+        verbose: normalizedOptions.verbose,
+        projectRoot: normalizedOptions.projectRoot,
+        workspaceRoot: normalizedOptions.workspaceRoot,
+        progress: normalizedOptions.progress,
+        clearScreen: normalizedOptions.clearScreen,
+        colors: normalizedOptions.colors,
+        jsonLogs: normalizedOptions.jsonLogs,
+        writeToFileSystem,
+        // For app-shell and SSG server files are not required by users.
+        // Omit these when SSR is not enabled.
+        writeToFileSystemFilter: writeServerBundles
+            ? undefined
+            : (file) => file.type !== bundler_context_1.BuildOutputFileType.Server,
+        logger,
+        signal,
+    });
+}
+exports.buildApplicationInternal = buildApplicationInternal;
+function buildApplication(options, context, pluginsOrExtensions) {
+    let extensions;
+    if (pluginsOrExtensions && Array.isArray(pluginsOrExtensions)) {
+        extensions = {
+            codePlugins: pluginsOrExtensions,
+        };
+    }
+    else {
+        extensions = pluginsOrExtensions;
+    }
+    return buildApplicationInternal(options, context, undefined, extensions);
+}
+exports.buildApplication = buildApplication;
+exports.default = (0, architect_1.createBuilder)(buildApplication);

package/src/builders/application/options.d.ts

@@ -0,0 +1,149 @@
+/**
+ * @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 { BuilderContext } from '@angular-devkit/architect';
+import type { Plugin } from 'esbuild';
+import { I18nOptions } from '../../utils/i18n-options';
+import { IndexHtmlTransform } from '../../utils/index-file/index-html-generator';
+import { Schema as ApplicationBuilderOptions, I18NTranslation, OutputPathClass } from './schema';
+export type NormalizedOutputOptions = Required<OutputPathClass>;
+export type NormalizedApplicationBuildOptions = Awaited<ReturnType<typeof normalizeOptions>>;
+export interface ApplicationBuilderExtensions {
+    codePlugins?: Plugin[];
+    indexHtmlTransformer?: IndexHtmlTransform;
+}
+/** Internal options hidden from builder schema but available when invoked programmatically. */
+interface InternalOptions {
+    /**
+     * Entry points to use for the compilation. Incompatible with `browser`, which must not be provided. May be relative or absolute paths.
+     * If given a relative path, it is resolved relative to the current workspace and will generate an output at the same relative location
+     * in the output directory. If given an absolute path, the output will be generated in the root of the output directory with the same base
+     * name.
+     */
+    entryPoints?: Set<string>;
+    /** File extension to use for the generated output files. */
+    outExtension?: 'js' | 'mjs';
+    /**
+     * Indicates whether all node packages should be marked as external.
+     * Currently used by the dev-server to support prebundling.
+     */
+    externalPackages?: boolean | {
+        exclude: string[];
+    };
+    /**
+     * Forces the output from the localize post-processing to not create nested directories per locale output.
+     * This is only used by the development server which currently only supports a single locale per build.
+     */
+    forceI18nFlatOutput?: boolean;
+}
+/** Full set of options for `application` builder. */
+export type ApplicationBuilderInternalOptions = Omit<ApplicationBuilderOptions & InternalOptions, 'browser'> & {
+    browser?: string;
+};
+/**
+ * Normalize the user provided options by creating full paths for all path based options
+ * and converting multi-form options into a single form that can be directly used
+ * by the build process.
+ *
+ * @param context The context for current builder execution.
+ * @param projectName The name of the project for the current execution.
+ * @param options An object containing the options to use for the build.
+ * @param plugins An optional array of programmatically supplied build plugins.
+ * @returns An object containing normalized options required to perform the build.
+ */
+export declare function normalizeOptions(context: BuilderContext, projectName: string, options: ApplicationBuilderInternalOptions, extensions?: ApplicationBuilderExtensions): Promise<{
+    advancedOptimizations: boolean;
+    allowedCommonJsDependencies: string[] | undefined;
+    baseHref: string | undefined;
+    cacheOptions: import("../../utils/normalize-cache").NormalizedCachedOptions;
+    crossOrigin: import("./schema").CrossOrigin | undefined;
+    deleteOutputPath: boolean | undefined;
+    externalDependencies: string[] | undefined;
+    extractLicenses: boolean | undefined;
+    inlineStyleLanguage: string;
+    jit: boolean;
+    stats: boolean;
+    polyfills: string[] | undefined;
+    poll: number | undefined;
+    progress: boolean;
+    externalPackages: boolean | {
+        exclude: string[];
+    } | undefined;
+    preserveSymlinks: boolean;
+    stylePreprocessorOptions: import("./schema").StylePreprocessorOptions | undefined;
+    subresourceIntegrity: boolean | undefined;
+    serverEntryPoint: string | undefined;
+    prerenderOptions: {
+        discoverRoutes: boolean;
+        routesFile: string | undefined;
+    } | undefined;
+    appShellOptions: {
+        route: string;
+    } | undefined;
+    ssrOptions: {
+        entry?: undefined;
+    } | {
+        entry: string | undefined;
+    } | undefined;
+    verbose: boolean | undefined;
+    watch: boolean | undefined;
+    workspaceRoot: string;
+    entryPoints: Record<string, string>;
+    optimizationOptions: import("../../utils").NormalizedOptimizationOptions;
+    outputOptions: Required<OutputPathClass>;
+    outExtension: "js" | "mjs" | undefined;
+    sourcemapOptions: import("./schema").SourceMapClass;
+    tsconfig: string;
+    projectRoot: string;
+    assets: (import("./schema").AssetPatternClass & {
+        output: string;
+    })[] | undefined;
+    outputNames: {
+        bundles: string;
+        media: string;
+    };
+    fileReplacements: Record<string, string> | undefined;
+    globalStyles: {
+        name: string;
+        files: string[];
+        initial: boolean;
+    }[];
+    globalScripts: {
+        name: string;
+        files: string[];
+        initial: boolean;
+    }[];
+    serviceWorker: string | undefined;
+    indexHtmlOptions: {
+        input: string;
+        output: string;
+        insertionOrder: [string, boolean][];
+        transformer: IndexHtmlTransform | undefined;
+        preloadInitial: boolean;
+    } | undefined;
+    tailwindConfiguration: {
+        file: string;
+        package: string;
+    } | undefined;
+    postcssConfiguration: import("../../utils/postcss-configuration").PostcssConfiguration | undefined;
+    i18nOptions: I18nOptions & {
+        duplicateTranslationBehavior?: I18NTranslation | undefined;
+        missingTranslationBehavior?: I18NTranslation | undefined;
+    };
+    namedChunks: boolean | undefined;
+    budgets: import("./schema").Budget[] | undefined;
+    publicPath: string | undefined;
+    plugins: Plugin[] | undefined;
+    loaderExtensions: Record<string, "file" | "binary" | "text"> | undefined;
+    jsonLogs: boolean;
+    colors: boolean;
+    clearScreen: boolean | undefined;
+    define: {
+        [key: string]: string;
+    } | undefined;
+}>;
+export {};