@nx/angular-rspack 0.0.0-pr-32422-a3285be

package/dist/lib/models/normalize-options.js

@@ -0,0 +1,424 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INDEX_HTML_CSR = void 0;
+exports.resolveFileReplacements = resolveFileReplacements;
+exports.getHasServer = getHasServer;
+exports.validateSsr = validateSsr;
+exports.normalizeOptions = normalizeOptions;
+exports.normalizeOptimization = normalizeOptimization;
+const tslib_1 = require("tslib");
+const private_1 = require("@angular/build/private");
+const devkit_1 = require("@nx/devkit");
+const node_assert_1 = tslib_1.__importDefault(require("node:assert"));
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const find_project_for_path_1 = require("../utils/find-project-for-path");
+const graph_1 = require("../utils/graph");
+exports.INDEX_HTML_CSR = 'index.csr.html';
+/**
+ * Resolves file replacement paths to absolute paths based on the provided root directory.
+ *
+ * @param fileReplacements - Array of file replacements with relative paths.
+ * @param root - The root directory to resolve the paths against.
+ * @returns Array of file replacements resolved against the root.
+ */
+function resolveFileReplacements(fileReplacements, root) {
+    return fileReplacements.map((fileReplacement) => ({
+        replace: (0, node_path_1.resolve)(root, fileReplacement.replace),
+        with: (0, node_path_1.resolve)(root, fileReplacement.with),
+    }));
+}
+function getHasServer(root, server, ssr) {
+    return !!(server &&
+        ssr &&
+        ssr.entry &&
+        (0, node_fs_1.existsSync)((0, node_path_1.join)(root, server)) &&
+        (0, node_fs_1.existsSync)((0, node_path_1.join)(root, ssr.entry)));
+}
+function validateSsr(ssr) {
+    if (!ssr) {
+        return;
+    }
+    if (ssr === true) {
+        throw new Error('The "ssr" option should be an object or false. Please check the documentation.');
+    }
+    if (typeof ssr === 'object')
+        if (!ssr.entry) {
+            throw new Error('The "ssr" option should have an "entry" property. Please check the documentation.');
+        }
+        else if (ssr.experimentalPlatform === 'neutral') {
+            console.warn('The "ssr.experimentalPlatform" option is not currently supported. Node will be used as the platform.');
+        }
+}
+async function normalizeOptions(options) {
+    const { fileReplacements = [], server, ssr, optimization } = options;
+    validateSsr(ssr);
+    const normalizedSsr = !ssr
+        ? false
+        : typeof ssr === 'object'
+            ? {
+                entry: ssr.entry,
+                experimentalPlatform: 'node', // @TODO: Add support for neutral platform
+            }
+            : ssr;
+    const normalizedOptimization = normalizeOptimization(optimization);
+    const root = options.root ?? process.cwd();
+    const tsConfig = options.tsConfig
+        ? (0, node_path_1.resolve)(root, options.tsConfig)
+        : (0, node_path_1.join)(root, 'tsconfig.app.json');
+    const aot = options.aot ?? true;
+    const advancedOptimizations = aot && normalizedOptimization.scripts;
+    const project = await getProject(root);
+    const assets = project && options.assets?.length
+        ? normalizeAssetPatterns(options.assets, root, project.data.root, project.data.sourceRoot)
+        : [];
+    const globalStyles = normalizeGlobalEntries(options.styles, 'styles');
+    const globalScripts = normalizeGlobalEntries(options.scripts, 'scripts');
+    if (options.index === false) {
+        console.warn('Disabling the "index" option is not yet supported. Defaulting to "src/index.html".');
+        options.index = (0, node_path_1.join)(root, 'src/index.html');
+    }
+    else if (!options.index) {
+        options.index = (0, node_path_1.join)(root, 'src/index.html');
+    }
+    // index can never have a value of `true` but in the schema it's of type `boolean`.
+    let indexOutput;
+    // The output file will be created within the configured output path
+    if (typeof options.index === 'string') {
+        indexOutput = options.index;
+    }
+    else {
+        if (options.index.preloadInitial) {
+            console.warn(`The "index.preloadInitial" option is not yet supported.`);
+        }
+        if (options.index.output) {
+            console.warn(`The "index.output" option is not yet supported.`);
+        }
+        indexOutput = options.index.output || 'index.html';
+    }
+    /**
+     * If SSR is activated, create a distinct entry file for the `index.html`.
+     * This is necessary because numerous server/cloud providers automatically serve the `index.html` as a static file
+     * if it exists (handling SSG).
+     *
+     * For instance, accessing `foo.com/` would lead to `foo.com/index.html` being served instead of hitting the server.
+     *
+     * This approach can also be applied to service workers, where the `index.csr.html` is served instead of the prerendered `index.html`.
+     */
+    const indexBaseName = (0, node_path_1.basename)(indexOutput);
+    // @TODO: use this once we properly support SSR/SSG options
+    // (normalizedSsr || prerenderOptions) && indexBaseName === 'index.html'
+    //   ? INDEX_HTML_CSR
+    //   : indexBaseName;
+    indexOutput = indexBaseName;
+    const entryPoints = [
+        ['runtime', !options.devServer?.hmr],
+        ['polyfills', true],
+        ...globalStyles.filter((s) => s.initial).map((s) => [s.name, false]),
+        ...globalScripts.filter((s) => s.initial).map((s) => [s.name, false]),
+        ['vendor', true],
+        ['main', true],
+    ];
+    const duplicates = entryPoints.filter(([name]) => entryPoints[0].indexOf(name) !== entryPoints[0].lastIndexOf(name));
+    if (duplicates.length > 0) {
+        throw new Error(`Multiple bundles have been named the same: '${duplicates.join(`', '`)}'.`);
+    }
+    const index = {
+        input: (0, node_path_1.resolve)(root, typeof options.index === 'string' ? options.index : options.index.input),
+        output: indexOutput,
+        transformer: typeof options.index === 'object' ? options.index.transformer : undefined,
+        // Preload initial defaults to true
+        preloadInitial: typeof options.index !== 'object' ||
+            (options.index.preloadInitial ?? true),
+    };
+    const budgets = !options.budgets
+        ? []
+        : options.budgets.map((budget) => ({
+            ...budget,
+            type: budget.type,
+        }));
+    const zoneless = options.polyfills
+        ? !options.polyfills.includes('zone.js')
+        : true;
+    const stylePreprocessorOptions = options.stylePreprocessorOptions ?? {};
+    if (stylePreprocessorOptions.includePaths?.length) {
+        stylePreprocessorOptions.includePaths = [
+            ...stylePreprocessorOptions.includePaths,
+            'node_modules',
+        ];
+    }
+    return {
+        advancedOptimizations,
+        appShell: options.appShell ?? false,
+        assets,
+        aot,
+        baseHref: options.baseHref,
+        browser: options.browser ?? './src/main.ts',
+        budgets,
+        commonChunk: options.commonChunk ?? true,
+        crossOrigin: options.crossOrigin ?? 'none',
+        define: options.define ?? {},
+        deleteOutputPath: options.deleteOutputPath ?? true,
+        deployUrl: options.deployUrl,
+        devServer: normalizeDevServer(options.devServer),
+        externalDependencies: options.externalDependencies ?? [],
+        extractLicenses: options.extractLicenses ?? true,
+        fileReplacements: resolveFileReplacements(fileReplacements, root),
+        globalStyles,
+        globalScripts,
+        hasServer: getHasServer(root, server, normalizedSsr),
+        index,
+        inlineStyleLanguage: options.inlineStyleLanguage ?? 'css',
+        namedChunks: options.namedChunks ?? false,
+        ngswConfigPath: options.ngswConfigPath,
+        optimization: normalizedOptimization,
+        outputHashing: options.outputHashing ?? 'none',
+        outputPath: normalizeOutputPath(root, options.outputPath),
+        poll: options.poll ?? undefined,
+        polyfills: options.polyfills ?? [],
+        prerender: options.prerender ?? false,
+        projectName: project?.name ?? undefined,
+        progress: options.progress ?? true,
+        root,
+        scripts: options.scripts ?? [],
+        serviceWorker: options.serviceWorker,
+        server,
+        skipTypeChecking: options.skipTypeChecking ?? false,
+        sourceMap: normalizeSourceMap(options.sourceMap),
+        ssr: normalizedSsr,
+        statsJson: options.statsJson ?? false,
+        styles: options.styles ?? [],
+        stylePreprocessorOptions,
+        subresourceIntegrity: options.subresourceIntegrity ?? false,
+        supportedBrowsers: (0, private_1.getSupportedBrowsers)(root, { warn: console.warn }),
+        tsConfig,
+        useTsProjectReferences: options.useTsProjectReferences ?? false,
+        vendorChunk: options.vendorChunk ?? false,
+        verbose: options.verbose ?? false,
+        watch: options.watch ?? false,
+        zoneless,
+    };
+}
+function normalizeOptimization(optimization) {
+    if (typeof optimization === 'boolean') {
+        return {
+            fonts: {
+                inline: optimization,
+            },
+            scripts: optimization,
+            styles: {
+                minify: optimization,
+                inlineCritical: optimization,
+            },
+        };
+    }
+    else if (optimization === undefined) {
+        return {
+            fonts: {
+                inline: true,
+            },
+            scripts: true,
+            styles: {
+                minify: true,
+                inlineCritical: true,
+            },
+        };
+    }
+    return {
+        fonts: {
+            inline: optimization.fonts === undefined
+                ? true
+                : typeof optimization.fonts === 'boolean'
+                    ? optimization.fonts
+                    : optimization.fonts.inline ?? true,
+        },
+        scripts: optimization.scripts ?? true,
+        styles: {
+            minify: optimization.styles === undefined
+                ? true
+                : typeof optimization.styles === 'boolean'
+                    ? optimization.styles
+                    : optimization.styles.minify ?? true,
+            inlineCritical: optimization.styles === undefined
+                ? true
+                : typeof optimization.styles === 'boolean'
+                    ? optimization.styles
+                    : optimization.styles.inlineCritical ?? true,
+        },
+    };
+}
+function normalizeSourceMap(sourceMap) {
+    if (sourceMap === undefined) {
+        return {
+            scripts: false,
+            styles: false,
+            hidden: false,
+            vendor: false,
+        };
+    }
+    if (typeof sourceMap === 'boolean') {
+        return {
+            scripts: sourceMap,
+            styles: sourceMap,
+            hidden: sourceMap,
+            vendor: sourceMap,
+        };
+    }
+    return {
+        scripts: sourceMap.scripts ?? true,
+        styles: sourceMap.styles ?? true,
+        hidden: sourceMap.hidden ?? false,
+        vendor: sourceMap.vendor ?? false,
+    };
+}
+function normalizeDevServer(devServer) {
+    const defaultHost = 'localhost';
+    const defaultPort = 4200;
+    if (!devServer) {
+        return {
+            allowedHosts: [],
+            host: defaultHost,
+            liveReload: true,
+            port: defaultPort,
+            open: false,
+        };
+    }
+    return {
+        ...devServer,
+        open: devServer.open ?? false,
+        allowedHosts: devServer.allowedHosts ?? [],
+        host: devServer.host ?? defaultHost,
+        liveReload: devServer.liveReload ?? true,
+        port: devServer.port ?? defaultPort,
+    };
+}
+function normalizeOutputPath(root, outputPath) {
+    let base = typeof outputPath === 'string' ? outputPath : outputPath?.base ?? 'dist';
+    if (!base.startsWith(root)) {
+        base = (0, node_path_1.join)(root, base);
+    }
+    const browser = typeof outputPath === 'string' || !outputPath?.browser
+        ? (0, node_path_1.join)(base, 'browser')
+        : (0, node_path_1.join)(base, outputPath.browser);
+    const server = typeof outputPath === 'string' || !outputPath?.server
+        ? (0, node_path_1.join)(base, 'server')
+        : (0, node_path_1.join)(base, outputPath.server);
+    const media = typeof outputPath === 'string' || !outputPath?.media
+        ? (0, node_path_1.join)(browser, 'media')
+        : (0, node_path_1.join)(browser, outputPath.media);
+    return { base, browser, server, media };
+}
+function normalizeAssetPatterns(assets, root, projectRoot, projectSourceRoot) {
+    if (assets.length === 0) {
+        return [];
+    }
+    // When sourceRoot is not available, we default to ${projectRoot}/src.
+    const resolvedSourceRoot = projectSourceRoot
+        ? (0, node_path_1.join)(devkit_1.workspaceRoot, projectSourceRoot)
+        : (0, node_path_1.join)(devkit_1.workspaceRoot, projectRoot, 'src');
+    return assets.map((assetPattern) => {
+        // Normalize string asset patterns to objects.
+        if (typeof assetPattern === 'string') {
+            const assetPath = (0, node_path_1.normalize)(assetPattern);
+            const resolvedAssetPath = (0, node_path_1.resolve)(root, assetPath);
+            // Check if the string asset is within sourceRoot.
+            if (!resolvedAssetPath.startsWith(resolvedSourceRoot)) {
+                throw new Error(`The ${assetPattern} asset path must start with the project source root.`);
+            }
+            let glob, input;
+            let isDirectory = false;
+            try {
+                isDirectory = (0, node_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 = (0, node_path_1.basename)(assetPath);
+                // Input directory is their original dirname.
+                input = (0, node_path_1.dirname)(assetPath);
+            }
+            // Output directory for both is the relative path from source root to input.
+            const output = (0, node_path_1.relative)(resolvedSourceRoot, (0, node_path_1.resolve)(root, input));
+            assetPattern = { glob, input, output };
+        }
+        else {
+            assetPattern.output = (0, node_path_1.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;
+    });
+}
+function normalizeGlobalEntries(rawEntries, defaultName) {
+    if (!rawEntries?.length) {
+        return [];
+    }
+    const bundles = new Map();
+    for (const rawEntry of rawEntries) {
+        let entry;
+        if (typeof rawEntry === 'string') {
+            // string entries use default bundle name and inject values
+            entry = { input: rawEntry };
+        }
+        else {
+            entry = rawEntry;
+        }
+        const { bundleName, input, inject = true } = entry;
+        // Non-injected entries default to the file name
+        const name = bundleName || (inject ? defaultName : (0, node_path_1.basename)(input, (0, node_path_1.extname)(input)));
+        const existing = bundles.get(name);
+        if (!existing) {
+            bundles.set(name, { name, files: [input], initial: inject });
+            continue;
+        }
+        if (existing.initial !== inject) {
+            throw new Error(`The "${name}" bundle is mixing injected and non-injected entries. ` +
+                'Verify that the project options are correct.');
+        }
+        existing.files.push(input);
+    }
+    return [...bundles.values()];
+}
+async function getProject(root) {
+    if (global.NX_GRAPH_CREATION) {
+        return undefined;
+    }
+    const projectGraph = await (0, graph_1.retrieveOrCreateProjectGraph)();
+    let projectName = process.env.NX_TASK_TARGET_PROJECT;
+    if (projectGraph) {
+        if (!projectName) {
+            const projectRootMappings = createProjectRootMappings(projectGraph.nodes);
+            projectName =
+                (0, find_project_for_path_1.findProjectForPath)(node_path_1.posix.relative(devkit_1.workspaceRoot, root), projectRootMappings) ?? undefined;
+        }
+        if (projectName) {
+            return projectGraph.nodes[projectName];
+        }
+    }
+    return {
+        name: undefined,
+        data: {
+            name: undefined,
+            root: root,
+            sourceRoot: undefined,
+        },
+    };
+}
+function createProjectRootMappings(nodes) {
+    const projectRootMappings = new Map();
+    for (const projectName of Object.keys(nodes)) {
+        const root = nodes[projectName].data.root;
+        projectRootMappings.set((0, find_project_for_path_1.normalizeProjectRoot)(root), projectName);
+    }
+    return projectRootMappings;
+}

package/dist/lib/plugins/angular-rspack-plugin.d.ts

@@ -0,0 +1,9 @@
+import { type Compiler, type RspackPluginInstance } from '@rspack/core';
+import { type I18nOptions, type NormalizedAngularRspackPluginOptions } from '../models';
+export declare class AngularRspackPlugin implements RspackPluginInstance {
+    #private;
+    constructor(options: NormalizedAngularRspackPluginOptions, i18nOptions?: I18nOptions);
+    apply(compiler: Compiler): void;
+    private setupCompilation;
+}
+//# sourceMappingURL=angular-rspack-plugin.d.ts.map

package/dist/lib/plugins/angular-rspack-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"angular-rspack-plugin.d.ts","sourceRoot":"","sources":["../../../src/lib/plugins/angular-rspack-plugin.ts"],"names":[],"mappings":"AAgBA,OAAO,EACL,KAAK,QAAQ,EAEb,KAAK,oBAAoB,EAE1B,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,KAAK,WAAW,EAGhB,KAAK,oCAAoC,EAC1C,MAAM,WAAW,CAAC;AAUnB,qBAAa,mBAAoB,YAAW,oBAAoB;;gBAS5D,OAAO,EAAE,oCAAoC,EAC7C,WAAW,CAAC,EAAE,WAAW;IAuB3B,KAAK,CAAC,QAAQ,EAAE,QAAQ;YA8PV,gBAAgB;CAgC/B"}

package/dist/lib/plugins/angular-rspack-plugin.js

@@ -0,0 +1,234 @@
+"use strict";
+var _AngularRspackPlugin__options, _AngularRspackPlugin_i18n, _AngularRspackPlugin_sourceFileCache, _AngularRspackPlugin_javascriptTransformer, _AngularRspackPlugin_angularCompilation;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AngularRspackPlugin = void 0;
+const tslib_1 = require("tslib");
+const private_1 = require("@angular/build/private");
+const angular_rspack_compiler_1 = require("@nx/angular-rspack-compiler");
+const devkit_1 = require("@nx/devkit");
+const core_1 = require("@rspack/core");
+const node_path_1 = require("node:path");
+const models_1 = require("../models");
+const get_locale_base_href_1 = require("../utils/get-locale-base-href");
+const rspack_diagnostics_1 = require("../utils/rspack-diagnostics");
+const misc_helpers_1 = require("../utils/misc-helpers");
+const stats_1 = require("../utils/stats");
+const get_stats_options_1 = require("../config/config-utils/get-stats-options");
+const PLUGIN_NAME = 'AngularRspackPlugin';
+class AngularRspackPlugin {
+    constructor(options, i18nOptions) {
+        _AngularRspackPlugin__options.set(this, void 0);
+        _AngularRspackPlugin_i18n.set(this, void 0);
+        _AngularRspackPlugin_sourceFileCache.set(this, void 0);
+        _AngularRspackPlugin_javascriptTransformer.set(this, void 0);
+        // This will be defined in the apply method correctly
+        _AngularRspackPlugin_angularCompilation.set(this, void 0);
+        tslib_1.__classPrivateFieldSet(this, _AngularRspackPlugin__options, options, "f");
+        tslib_1.__classPrivateFieldSet(this, _AngularRspackPlugin_i18n, i18nOptions, "f");
+        tslib_1.__classPrivateFieldSet(this, _AngularRspackPlugin_sourceFileCache, new angular_rspack_compiler_1.SourceFileCache(), "f");
+        tslib_1.__classPrivateFieldSet(this, _AngularRspackPlugin_javascriptTransformer, new angular_rspack_compiler_1.JavaScriptTransformer({
+            /**
+             * Matches https://github.com/angular/angular-cli/blob/33ed6e875e509ebbaa0cbdb57be9e932f9915dff/packages/angular/build/src/tools/esbuild/angular/compiler-plugin.ts#L89
+             * where pluginOptions.sourcemap is set https://github.com/angular/angular-cli/blob/61d98fde122468978de9b17bd79761befdbf2fac/packages/angular/build/src/tools/esbuild/compiler-plugin-options.ts#L34
+             */
+            sourcemap: !!(tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin__options, "f").sourceMap.scripts &&
+                (tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin__options, "f").sourceMap.hidden ? 'external' : true)),
+            thirdPartySourcemaps: tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin__options, "f").sourceMap.vendor,
+            advancedOptimizations: tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin__options, "f").advancedOptimizations,
+            jit: !tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin__options, "f").aot,
+        }, (0, angular_rspack_compiler_1.maxWorkers)()), "f");
+    }
+    apply(compiler) {
+        const root = tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin__options, "f").root;
+        // Both of these are exclusive to each other - only one of them can be used at a time
+        // But they will happen before the compiler is created - so we can use them to set up the parallel compilation once
+        compiler.hooks.beforeRun.tapAsync(PLUGIN_NAME, async (compiler, callback) => {
+            await this.setupCompilation(root, compiler.options.resolve.tsConfig);
+            compiler.hooks.beforeCompile.tapAsync(PLUGIN_NAME, async (params, callback) => {
+                await (0, angular_rspack_compiler_1.buildAndAnalyze)(tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin_angularCompilation, "f"), tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin_sourceFileCache, "f").typeScriptFileCache, tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin_javascriptTransformer, "f"));
+                callback();
+            });
+            callback();
+        });
+        compiler.hooks.watchRun.tapAsync(PLUGIN_NAME, async (compiler, callback) => {
+            if (!compiler.hooks.beforeCompile.taps.some((tap) => tap.name === PLUGIN_NAME)) {
+                compiler.hooks.beforeCompile.tapAsync(PLUGIN_NAME, async (params, callback) => {
+                    const watchingModifiedFiles = compiler.watching?.compiler
+                        ?.modifiedFiles
+                        ? new Set(compiler.watching.compiler.modifiedFiles)
+                        : new Set();
+                    if (tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin_angularCompilation, "f")) {
+                        tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin_sourceFileCache, "f").invalidate(watchingModifiedFiles);
+                    }
+                    await this.setupCompilation(root, compiler.options.resolve.tsConfig, watchingModifiedFiles.size > 0
+                        ? watchingModifiedFiles
+                        : undefined);
+                    await (0, angular_rspack_compiler_1.buildAndAnalyze)(tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin_angularCompilation, "f"), tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin_sourceFileCache, "f").typeScriptFileCache, tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin_javascriptTransformer, "f"));
+                    compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+                        watchingModifiedFiles.forEach((file) => {
+                            compilation.fileDependencies.add(file);
+                        });
+                    });
+                    callback();
+                });
+            }
+            callback();
+        });
+        compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
+            compilation.hooks.processAssets.tap({
+                name: PLUGIN_NAME,
+                stage: compiler.rspack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS,
+            }, (assets) => {
+                for (const assetName in assets) {
+                    const asset = compilation.getAsset(assetName);
+                    if (!asset) {
+                        continue;
+                    }
+                    const assetHash = asset.info?.contenthash?.[0] ?? '';
+                    const assetNameWithoutHash = assetName.replace(`.${assetHash}`, '');
+                    if (assetNameWithoutHash !== 'main.js') {
+                        continue;
+                    }
+                    const originalSource = asset.source;
+                    let setLocaleContent = '';
+                    if (tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin_i18n, "f")?.shouldInline) {
+                        // When inlining, a placeholder is used to allow the post-processing step to inject the $localize locale identifier.
+                        setLocaleContent +=
+                            '(globalThis.$localize ??= {}).locale = "___NG_LOCALE_INSERT___";\n';
+                    }
+                    else if (tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin_i18n, "f")?.hasDefinedSourceLocale) {
+                        // If not inlining translations and source locale is defined, inject the locale specifier.
+                        setLocaleContent += `(globalThis.$localize ??= {}).locale = "${tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin_i18n, "f").sourceLocale}";\n`;
+                    }
+                    const concatLocaleSource = new core_1.sources.ConcatSource(setLocaleContent, originalSource);
+                    compilation.updateAsset(assetName, concatLocaleSource, (assetInfo) => assetInfo);
+                }
+            });
+        });
+        compiler.hooks.emit.tapAsync(PLUGIN_NAME, async (compilation, callback) => {
+            if (!tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin__options, "f").skipTypeChecking) {
+                const { errors, warnings } = await tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin_angularCompilation, "f").diagnoseFiles(angular_rspack_compiler_1.DiagnosticModes.All);
+                for (const error of errors ?? []) {
+                    compilation.errors.push({
+                        name: PLUGIN_NAME,
+                        message: error.text || '',
+                        file: error.location?.file,
+                        loc: `${error.location?.line}:${error.location?.column}`,
+                        moduleIdentifier: error.location?.file,
+                        stack: error.text,
+                    });
+                }
+                for (const warning of warnings ?? []) {
+                    compilation.warnings.push({
+                        name: PLUGIN_NAME,
+                        message: warning.text || '',
+                        file: warning.location?.file,
+                        loc: `${warning.location?.line}:${warning.location?.column}`,
+                        stack: warning.text,
+                        moduleIdentifier: warning.location?.file,
+                    });
+                }
+            }
+            await tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin_javascriptTransformer, "f").close();
+            callback();
+        });
+        compiler.hooks.afterEmit.tap(PLUGIN_NAME, (compilation) => {
+            // Check for budget errors and display them to the user.
+            const budgets = tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin__options, "f").budgets;
+            let budgetFailures;
+            compiler.hooks.done.tap(PLUGIN_NAME, (statsValue) => {
+                const stats = statsValue.toJson();
+                if (budgets?.length) {
+                    budgetFailures = [...(0, private_1.checkBudgets)(budgets, stats)];
+                    for (const { severity, message } of budgetFailures) {
+                        switch (severity) {
+                            case private_1.ThresholdSeverity.Warning:
+                                (0, rspack_diagnostics_1.addWarning)(compilation, {
+                                    message,
+                                    name: PLUGIN_NAME,
+                                    hideStack: true,
+                                });
+                                break;
+                            case private_1.ThresholdSeverity.Error:
+                                (0, rspack_diagnostics_1.addError)(compilation, {
+                                    message,
+                                    name: PLUGIN_NAME,
+                                    hideStack: true,
+                                });
+                                break;
+                            default:
+                                (0, misc_helpers_1.assertNever)(severity);
+                        }
+                    }
+                }
+            });
+            compiler.hooks.afterDone.tap(PLUGIN_NAME, (stats) => {
+                (0, stats_1.rspackStatsLogger)(stats, (0, get_stats_options_1.getStatsOptions)(tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin__options, "f").verbose));
+                if (stats.hasErrors()) {
+                    process.exit(1);
+                }
+            });
+        });
+        compiler.hooks.normalModuleFactory.tap(PLUGIN_NAME, (normalModuleFactory) => {
+            normalModuleFactory.hooks.beforeResolve.tap(PLUGIN_NAME, (data) => {
+                if (data.request.startsWith('angular:jit:')) {
+                    const path = data.request.split(';')[1];
+                    data.request = `${(0, node_path_1.normalize)((0, node_path_1.resolve)((0, node_path_1.dirname)(data.contextInfo.issuer), path))}?raw`;
+                }
+            });
+        });
+        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+            compilation[models_1.NG_RSPACK_SYMBOL_NAME] = () => ({
+                javascriptTransformer: tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin_javascriptTransformer, "f"),
+                typescriptFileCache: tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin_sourceFileCache, "f").typeScriptFileCache,
+                i18n: tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin_i18n, "f"),
+            });
+        });
+        if (tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin__options, "f").serviceWorker) {
+            compiler.hooks.done.tapAsync(PLUGIN_NAME, async (compilation, callback) => {
+                let providedLocales = tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin__options, "f").localize;
+                if (!providedLocales) {
+                    await (0, private_1.augmentAppWithServiceWorker)(tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin__options, "f").root, devkit_1.workspaceRoot, tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin__options, "f").outputPath.browser, tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin__options, "f").baseHref ?? '/', tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin__options, "f").ngswConfigPath);
+                }
+                else if (providedLocales && tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin_i18n, "f")) {
+                    if (typeof providedLocales === 'string') {
+                        providedLocales = [providedLocales];
+                    }
+                    else if (typeof providedLocales === 'boolean') {
+                        providedLocales = Array.from(tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin_i18n, "f").inlineLocales);
+                    }
+                    for (const locale of providedLocales) {
+                        await (0, private_1.augmentAppWithServiceWorker)(tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin__options, "f").root, devkit_1.workspaceRoot, (0, node_path_1.join)(tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin__options, "f").outputPath.browser, tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin_i18n, "f").locales[locale]?.subPath ?? locale), (0, get_locale_base_href_1.getLocaleBaseHref)(tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin_i18n, "f"), locale, tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin__options, "f").baseHref) ??
+                            tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin__options, "f").baseHref ??
+                            '/', tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin__options, "f").ngswConfigPath);
+                    }
+                }
+                callback();
+            });
+        }
+    }
+    async setupCompilation(root, tsConfig, modifiedFiles) {
+        const tsconfigPath = tsConfig
+            ? typeof tsConfig === 'string'
+                ? tsConfig
+                : tsConfig.configFile
+            : tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin__options, "f").tsConfig;
+        tslib_1.__classPrivateFieldSet(this, _AngularRspackPlugin_angularCompilation, await (0, angular_rspack_compiler_1.setupCompilationWithAngularCompilation)({
+            source: {
+                tsconfigPath: tsconfigPath,
+            },
+        }, {
+            root,
+            aot: tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin__options, "f").aot,
+            tsConfig: tsconfigPath,
+            inlineStyleLanguage: tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin__options, "f").inlineStyleLanguage,
+            fileReplacements: tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin__options, "f").fileReplacements,
+            useTsProjectReferences: tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin__options, "f").useTsProjectReferences,
+            hasServer: tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin__options, "f").hasServer,
+            includePaths: tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin__options, "f").stylePreprocessorOptions?.includePaths,
+            sass: tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin__options, "f").stylePreprocessorOptions?.sass,
+        }, tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin_sourceFileCache, "f"), tslib_1.__classPrivateFieldGet(this, _AngularRspackPlugin_angularCompilation, "f"), modifiedFiles), "f");
+    }
+}
+exports.AngularRspackPlugin = AngularRspackPlugin;
+_AngularRspackPlugin__options = new WeakMap(), _AngularRspackPlugin_i18n = new WeakMap(), _AngularRspackPlugin_sourceFileCache = new WeakMap(), _AngularRspackPlugin_javascriptTransformer = new WeakMap(), _AngularRspackPlugin_angularCompilation = new WeakMap();