@nx/angular-rspack 20.8.2 → 21.0.0-beta.0

package/dist/lib/config/config-utils/browser-config.d.ts

@@ -0,0 +1,4 @@
+import type { Configuration } from '@rspack/core';
+import type { HashFormat, I18nOptions, NormalizedAngularRspackPluginOptions } from '../../models';
+export declare function getBrowserConfig(normalizedOptions: NormalizedAngularRspackPluginOptions, i18n: I18nOptions, hashFormat: HashFormat, defaultConfig: Configuration): Promise<Configuration>;
+//# sourceMappingURL=browser-config.d.ts.map

package/dist/lib/config/config-utils/browser-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-config.d.ts","sourceRoot":"","sources":["../../../../src/lib/config/config-utils/browser-config.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,KAAK,EACV,UAAU,EACV,WAAW,EACX,oCAAoC,EACrC,MAAM,cAAc,CAAC;AAQtB,wBAAsB,gBAAgB,CACpC,iBAAiB,EAAE,oCAAoC,EACvD,IAAI,EAAE,WAAW,EACjB,UAAU,EAAE,UAAU,EACtB,aAAa,EAAE,aAAa,GAC3B,OAAO,CAAC,aAAa,CAAC,CA4ExB"}

package/dist/lib/config/config-utils/browser-config.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBrowserConfig = getBrowserConfig;
+const angular_rspack_compiler_1 = require("@nx/angular-rspack-compiler");
+const ng_rspack_1 = require("../../plugins/ng-rspack");
+const dev_server_config_utils_1 = require("./dev-server-config-utils");
+const entry_points_1 = require("./entry-points");
+const optimization_config_1 = require("./optimization-config");
+const path_1 = require("path");
+const hmr_accept_loader_1 = require("../../plugins/loaders/hmr-accept-loader");
+async function getBrowserConfig(normalizedOptions, i18n, hashFormat, defaultConfig) {
+    const isProduction = process.env['NODE_ENV'] === 'production';
+    const { root } = normalizedOptions;
+    return {
+        ...defaultConfig,
+        name: 'browser',
+        target: 'web',
+        entry: {
+            main: {
+                import: [
+                    ...(i18n.shouldInline ? ['@angular/localize/init'] : []),
+                    normalizedOptions.browser,
+                ],
+            },
+            ...(0, entry_points_1.getPolyfillsEntry)(normalizedOptions.polyfills, normalizedOptions.aot),
+            ...(0, entry_points_1.toRspackEntries)(normalizedOptions.globalStyles, normalizedOptions.root, 'ngGlobalStyles'),
+            ...(0, entry_points_1.toRspackEntries)(normalizedOptions.globalScripts, normalizedOptions.root),
+        },
+        devServer: await (0, dev_server_config_utils_1.getDevServerConfig)(normalizedOptions, 'browser'),
+        output: {
+            ...defaultConfig.output,
+            hashFunction: isProduction ? 'xxhash64' : undefined,
+            path: normalizedOptions.outputPath.browser,
+            cssFilename: `[name]${hashFormat.file}.css`,
+            filename: `[name]${hashFormat.chunk}.js`,
+            chunkFilename: `[name]${hashFormat.chunk}.js`,
+            scriptType: 'module',
+            module: true,
+        },
+        optimization: (0, optimization_config_1.getOptimization)(normalizedOptions, 'browser'),
+        module: {
+            ...defaultConfig.module,
+            rules: [
+                {
+                    test: angular_rspack_compiler_1.TS_ALL_EXT_REGEX,
+                    use: [
+                        {
+                            loader: 'builtin:swc-loader',
+                            options: {
+                                jsc: {
+                                    parser: {
+                                        syntax: 'typescript',
+                                    },
+                                    target: 'es2022',
+                                },
+                            },
+                        },
+                    ],
+                },
+                ...(normalizedOptions.devServer?.hmr
+                    ? [
+                        {
+                            loader: hmr_accept_loader_1.HmrLoader,
+                            include: [(0, path_1.resolve)(root, normalizedOptions.browser)],
+                        },
+                    ]
+                    : []),
+                ...(defaultConfig.module?.rules ?? []),
+            ],
+        },
+        plugins: [
+            ...(defaultConfig.plugins ?? []),
+            new ng_rspack_1.NgRspackPlugin(normalizedOptions, {
+                i18nOptions: i18n,
+                platform: 'browser',
+            }),
+        ],
+    };
+}

package/dist/lib/config/config-utils/common-config.d.ts

@@ -0,0 +1,3 @@
+import { HashFormat, I18nOptions, NormalizedAngularRspackPluginOptions } from '../../models';
+export declare function getCommonConfig(normalizedOptions: NormalizedAngularRspackPluginOptions, i18n: I18nOptions, i18nHash: string | (() => void), hashFormat: HashFormat): Promise<import("@rspack/core").RspackOptions>;
+//# sourceMappingURL=common-config.d.ts.map

package/dist/lib/config/config-utils/common-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common-config.d.ts","sourceRoot":"","sources":["../../../../src/lib/config/config-utils/common-config.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,UAAU,EACV,WAAW,EACX,oCAAoC,EACrC,MAAM,cAAc,CAAC;AAQtB,wBAAsB,eAAe,CACnC,iBAAiB,EAAE,oCAAoC,EACvD,IAAI,EAAE,WAAW,EACjB,QAAQ,EAAE,MAAM,GAAG,CAAC,MAAM,IAAI,CAAC,EAC/B,UAAU,EAAE,UAAU,iDA2JvB"}

package/dist/lib/config/config-utils/common-config.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCommonConfig = getCommonConfig;
+const core_1 = require("@rspack/core");
+const node_path_1 = require("node:path");
+const angular_rspack_compiler_1 = require("@nx/angular-rspack-compiler");
+const style_config_utils_1 = require("./style-config-utils");
+const helpers_1 = require("./helpers");
+const sourcemap_utils_1 = require("./sourcemap-utils");
+const stats_json_plugin_1 = require("../../plugins/stats-json-plugin");
+const watch_file_logs_plugin_1 = require("../../plugins/watch-file-logs-plugin");
+const get_index_input_file_1 = require("../../utils/index-file/get-index-input-file");
+async function getCommonConfig(normalizedOptions, i18n, i18nHash, hashFormat) {
+    const isProduction = process.env['NODE_ENV'] === 'production';
+    const crossOriginLoading = (0, helpers_1.getCrossOriginLoading)(normalizedOptions);
+    const sourceMapOptions = (0, sourcemap_utils_1.configureSourceMap)(normalizedOptions.sourceMap);
+    const stylesConfig = await (0, style_config_utils_1.getStylesConfig)(normalizedOptions, hashFormat, normalizedOptions.hasServer ? 'server' : 'browser');
+    const indexInputFile = (0, node_path_1.join)(normalizedOptions.root, (0, get_index_input_file_1.getIndexInputFile)(normalizedOptions.index));
+    const indexInputWatchPlugin = {
+        apply: (compiler) => {
+            compiler.hooks.thisCompilation.tap('build-angular', (compilation) => {
+                compilation.fileDependencies.add(indexInputFile);
+            });
+        },
+    };
+    const defaultConfig = {
+        context: normalizedOptions.root,
+        profile: normalizedOptions.statsJson,
+        mode: isProduction ? 'production' : 'development',
+        devtool: normalizedOptions.sourceMap.scripts ? 'source-map' : undefined,
+        infrastructureLogging: {
+            appendOnly: false,
+            debug: normalizedOptions.verbose,
+            level: normalizedOptions.verbose ? 'verbose' : 'none',
+        },
+        performance: {
+            hints: false,
+        },
+        stats: 'none', // This is handled in the AngularRspackPlugin by the rspackStatsLogger
+        output: {
+            uniqueName: normalizedOptions.projectName ?? 'rspack-angular',
+            publicPath: normalizedOptions.deployUrl ?? '',
+            clean: normalizedOptions.deleteOutputPath,
+            crossOriginLoading,
+            trustedTypes: { policyName: 'angular#bundler' },
+            sourceMapFilename: normalizedOptions.sourceMap.scripts
+                ? '[file].map'
+                : undefined,
+            scriptType: 'module',
+        },
+        resolve: {
+            extensions: ['.ts', '.tsx', '.mjs', '.js'],
+            symlinks: !normalizedOptions.preserveSymlinks,
+            modules: ['node_modules'],
+            mainFields: ['es2020', 'es2015', 'browser', 'module', 'main'],
+            conditionNames: ['es2020', 'es2015', '...'],
+            tsConfig: {
+                configFile: normalizedOptions.tsConfig,
+            },
+            ...(i18n.shouldInline && normalizedOptions.aot
+                ? { alias: { '@angular/localize/init': false } }
+                : {}),
+        },
+        resolveLoader: {
+            symlinks: !normalizedOptions.preserveSymlinks,
+        },
+        watch: normalizedOptions.watch,
+        watchOptions: {
+            poll: normalizedOptions.poll,
+            followSymlinks: normalizedOptions.preserveSymlinks,
+            ignored: normalizedOptions.poll === undefined ? undefined : '**/node_modules/**',
+        },
+        ignoreWarnings: [
+            // https://github.com/webpack-contrib/source-map-loader/blob/b2de4249c7431dd8432da607e08f0f65e9d64219/src/index.js#L83
+            /Failed to parse source map from/,
+            // https://github.com/webpack-contrib/postcss-loader/blob/bd261875fdf9c596af4ffb3a1a73fe3c549befda/src/index.js#L153-L158
+            /Add postcss as project dependency/,
+            // esbuild will issue a warning, while still hoists the @charset at the very top.
+            // This is caused by a bug in css-loader https://github.com/webpack-contrib/css-loader/issues/1212
+            /"@charset" must be the first rule in the file/,
+        ],
+        module: {
+            parser: {
+                javascript: {
+                    requireContext: false,
+                    url: false,
+                },
+            },
+            rules: [
+                {
+                    test: /\.?(svg|html)$/,
+                    // Only process HTML and SVG which are known Angular component resources.
+                    resourceQuery: /\?ngResource/,
+                    type: 'asset/source',
+                },
+                ...stylesConfig.loaderRules,
+                ...sourceMapOptions.sourceMapRules,
+                { test: /[/\\]rxjs[/\\]add[/\\].+\.js$/, sideEffects: true },
+                {
+                    test: angular_rspack_compiler_1.TS_ALL_EXT_REGEX,
+                    use: [
+                        {
+                            loader: require.resolve('@nx/angular-rspack/loaders/angular-loader'),
+                        },
+                    ],
+                },
+                {
+                    test: angular_rspack_compiler_1.JS_ALL_EXT_REGEX,
+                    use: [
+                        {
+                            loader: require.resolve('@nx/angular-rspack/loaders/angular-partial-transform-loader'),
+                        },
+                    ],
+                },
+            ],
+        },
+        plugins: [
+            ...sourceMapOptions.sourceMapPlugins,
+            ...(normalizedOptions.verbose ? [new watch_file_logs_plugin_1.WatchFilesLogsPlugin()] : []),
+            ...(normalizedOptions.watch ? [indexInputWatchPlugin] : []),
+            ...(normalizedOptions.statsJson
+                ? [
+                    new stats_json_plugin_1.StatsJsonPlugin((0, node_path_1.resolve)(normalizedOptions.root, normalizedOptions.outputPath.base, 'stats.json')),
+                ]
+                : []),
+            ...(i18n.shouldInline
+                ? [
+                    {
+                        apply(compiler) {
+                            compiler.hooks.compilation.tap('AngularRspackPlugin', (compilation) => {
+                                core_1.javascript.JavascriptModulesPlugin.getCompilationHooks(compilation).chunkHash.tap('AngularRspackPlugin', (_, hash) => {
+                                    hash.update(Buffer.from('$localize' + i18nHash));
+                                });
+                            });
+                        },
+                    },
+                ]
+                : []),
+            ...stylesConfig.plugins,
+        ],
+    };
+    return defaultConfig;
+}

package/dist/lib/config/config-utils/dev-server-config-utils.d.ts

@@ -0,0 +1,4 @@
+import type { DevServer } from '@rspack/core';
+import type { NormalizedAngularRspackPluginOptions } from '../../models';
+export declare function getDevServerConfig(options: NormalizedAngularRspackPluginOptions, platform: 'browser' | 'server'): Promise<DevServer>;
+//# sourceMappingURL=dev-server-config-utils.d.ts.map

package/dist/lib/config/config-utils/dev-server-config-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev-server-config-utils.d.ts","sourceRoot":"","sources":["../../../../src/lib/config/config-utils/dev-server-config-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAK9C,OAAO,KAAK,EAAE,oCAAoC,EAAE,MAAM,cAAc,CAAC;AAIzE,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,oCAAoC,EAC7C,QAAQ,EAAE,SAAS,GAAG,QAAQ,GAC7B,OAAO,CAAC,SAAS,CAAC,CA2DpB"}

package/dist/lib/config/config-utils/dev-server-config-utils.js

@@ -0,0 +1,257 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDevServerConfig = getDevServerConfig;
+const tslib_1 = require("tslib");
+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 node_url_1 = require("node:url");
+const get_index_output_file_1 = require("../../utils/index-file/get-index-output-file");
+const misc_helpers_1 = require("../../utils/misc-helpers");
+async function getDevServerConfig(options, platform) {
+    const { root } = options;
+    const servePath = buildServePath(options);
+    return {
+        host: options.devServer.host,
+        port: options.devServer.port,
+        headers: {
+            'Access-Control-Allow-Origin': '*',
+            ...options.devServer.headers,
+        },
+        historyApiFallback: {
+            index: node_path_1.posix.join(servePath, (0, get_index_output_file_1.getIndexOutputFile)(options.index)),
+            disableDotRule: true,
+            htmlAcceptHeaders: ['text/html', 'application/xhtml+xml'],
+            rewrites: [
+                {
+                    from: new RegExp(`^(?!${servePath})/.*`),
+                    to: (context) => context.parsedUrl.href,
+                },
+            ],
+        },
+        compress: false,
+        static: false,
+        server: getServerConfig(options),
+        allowedHosts: getAllowedHostsConfig(options.devServer.allowedHosts, options.devServer.disableHostCheck),
+        devMiddleware: {
+            publicPath: servePath,
+            writeToDisk: platform === 'browser' && options.hasServer
+                ? (file) => !file.includes('.hot-update.')
+                : undefined,
+        },
+        liveReload: options.devServer.liveReload,
+        hot: options.devServer.hmr && !options.devServer.liveReload
+            ? 'only'
+            : options.devServer.hmr,
+        proxy: await getProxyConfig(root, options.devServer.proxyConfig),
+        ...getWebSocketSettings(options, servePath),
+        watchFiles: ['./src/**/*.*', './public/**/*.*'],
+        onListening: platform === 'browser'
+            ? (devServer) => {
+                if (!devServer) {
+                    throw new Error('@rspack/dev-server is not defined');
+                }
+                const port = devServer.server?.address()?.port ??
+                    options.devServer.port;
+                console.log('Listening on port:', port);
+            }
+            : undefined,
+    };
+}
+/**
+ * Resolve and build a URL _path_ that will be the root of the server. This resolves base href and
+ * deploy URL from the browser options and returns a path from the root.
+ */
+function buildServePath(options) {
+    let servePath = options.devServer.servePath;
+    if (servePath === undefined) {
+        const defaultPath = findDefaultServePath(options.baseHref, options.deployUrl);
+        if (defaultPath == null) {
+            console.warn(`Warning: --deploy-url and/or --base-href contain unsupported values for ng serve. Default serve path of '/' used. Use --serve-path to override.`);
+        }
+        servePath = defaultPath || '';
+    }
+    if (servePath.endsWith('/')) {
+        servePath = servePath.slice(0, -1);
+    }
+    if (!servePath.startsWith('/')) {
+        servePath = `/${servePath}`;
+    }
+    return servePath;
+}
+/**
+ * Find the default server path. We don't want to expose baseHref and deployUrl as arguments, only
+ * the browser options where needed.
+ */
+function findDefaultServePath(baseHref, deployUrl) {
+    if (!baseHref && !deployUrl) {
+        return '';
+    }
+    if (/^(\w+:)?\/\//.test(baseHref || '') ||
+        /^(\w+:)?\/\//.test(deployUrl || '')) {
+        // If baseHref or deployUrl is absolute, unsupported by ng serve
+        return null;
+    }
+    // normalize baseHref
+    // for ng serve the starting base is always `/` so a relative
+    // and root relative value are identical
+    const baseHrefParts = (baseHref || '')
+        .split('/')
+        .filter((part) => part !== '');
+    if (baseHref && !baseHref.endsWith('/')) {
+        baseHrefParts.pop();
+    }
+    const normalizedBaseHref = baseHrefParts.length === 0 ? '/' : `/${baseHrefParts.join('/')}/`;
+    if (deployUrl && deployUrl[0] === '/') {
+        if (baseHref && baseHref[0] === '/' && normalizedBaseHref !== deployUrl) {
+            // If baseHref and deployUrl are root relative and not equivalent, unsupported by ng serve
+            return null;
+        }
+        return deployUrl;
+    }
+    // Join together baseHref and deployUrl
+    return `${normalizedBaseHref}${deployUrl || ''}`;
+}
+function getServerConfig(options) {
+    const { root, devServer: { ssl, sslCert, sslKey }, } = options;
+    if (!ssl) {
+        return 'http';
+    }
+    return {
+        type: 'https',
+        options: sslCert && sslKey
+            ? {
+                key: (0, node_path_1.resolve)(root, sslKey),
+                cert: (0, node_path_1.resolve)(root, sslCert),
+            }
+            : undefined,
+    };
+}
+function getAllowedHostsConfig(allowedHosts, disableHostCheck) {
+    if (disableHostCheck || allowedHosts === true) {
+        return 'all';
+    }
+    if (Array.isArray(allowedHosts) && allowedHosts.length > 0) {
+        return allowedHosts;
+    }
+    return undefined;
+}
+async function getProxyConfig(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 node_fs_1.promises.readFile(proxyPath, 'utf-8');
+            const { parse, printParseErrorCode } = await Promise.resolve().then(() => tslib_1.__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, misc_helpers_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);
+            }
+            catch (e) {
+                assertIsError(e);
+                if (e.code !== 'ERR_REQUIRE_ESM') {
+                    throw e;
+                }
+                // 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, misc_helpers_1.loadEsmModule)((0, node_url_1.pathToFileURL)(proxyPath))).default;
+            }
+    }
+    return normalizeProxyConfiguration(proxyConfiguration);
+}
+function getWebSocketSettings(options, servePath) {
+    const { hmr, liveReload } = options.devServer;
+    if (!hmr && !liveReload) {
+        return { client: undefined, webSocketServer: false };
+    }
+    const webSocketPath = node_path_1.posix.join(servePath, 'ng-cli-ws');
+    return {
+        webSocketServer: {
+            options: { path: webSocketPath },
+        },
+        client: {
+            logging: 'info',
+            webSocketURL: getPublicHostOptions(options, webSocketPath),
+            overlay: {
+                errors: true,
+                warnings: false,
+                runtimeErrors: false,
+            },
+        },
+    };
+}
+function getPublicHostOptions(options, webSocketPath) {
+    let publicHost = options.devServer.publicHost;
+    if (publicHost) {
+        const hostWithProtocol = !/^\w+:\/\//.test(publicHost)
+            ? `https://${publicHost}`
+            : publicHost;
+        publicHost = new URL(hostWithProtocol).host;
+    }
+    return `auto://${publicHost || '0.0.0.0:0'}${webSocketPath}`;
+}
+function getJsonErrorLineColumn(offset, content) {
+    if (offset === 0) {
+        return { line: 1, column: 1 };
+    }
+    let line = 0;
+    let position = 0;
+    while (true) {
+        ++line;
+        const nextNewline = content.indexOf('\n', position);
+        if (nextNewline === -1 || nextNewline > offset) {
+            break;
+        }
+        position = nextNewline + 1;
+    }
+    return { line, column: offset - position + 1 };
+}
+function normalizeProxyConfiguration(proxy) {
+    return Array.isArray(proxy)
+        ? proxy
+        : Object.entries(proxy).map(([context, value]) => ({
+            context: [context],
+            ...value,
+        }));
+}
+function assertIsError(value) {
+    const isError = value instanceof Error ||
+        // The following is needing to identify errors coming from RxJs.
+        (typeof value === 'object' &&
+            value &&
+            'name' in value &&
+            'message' in value);
+    (0, node_assert_1.default)(isError, 'catch clause variable is not an Error instance');
+}

package/dist/lib/config/{entry-points.d.ts → config-utils/entry-points.d.ts}

@@ -1,4 +1,4 @@
-import type { GlobalEntry } from '../models';
+import type { GlobalEntry } from '../../models';
 export declare function getEntryPoints(globalStyles: GlobalEntry[], globalScripts: GlobalEntry[], isHMREnabled?: boolean): [name: string, isModule: boolean][];
 export declare function getPolyfillsEntry(polyfills: string[], aot: boolean): {
     polyfills?: string[];

package/dist/lib/config/config-utils/entry-points.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-points.d.ts","sourceRoot":"","sources":["../../../../src/lib/config/config-utils/entry-points.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD,wBAAgB,cAAc,CAC5B,YAAY,EAAE,WAAW,EAAE,EAC3B,aAAa,EAAE,WAAW,EAAE,EAC5B,YAAY,CAAC,EAAE,OAAO,GACrB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,CAerC;AAED,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,MAAM,EAAE,EACnB,GAAG,EAAE,OAAO,GACX;IAAE,SAAS,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAW1B;AAED,wBAAgB,eAAe,CAC7B,OAAO,EAAE,WAAW,EAAE,EACtB,IAAI,EAAE,MAAM,EACZ,WAAW,CAAC,EAAE,MAAM;YAEmB,MAAM,EAAE;GAahD"}

package/dist/lib/config/config-utils/get-stats-options.d.ts

@@ -0,0 +1,3 @@
+import { type StatsOptions } from '@rspack/core';
+export declare function getStatsOptions(verbose?: boolean): StatsOptions;
+//# sourceMappingURL=get-stats-options.d.ts.map

package/dist/lib/config/config-utils/get-stats-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-stats-options.d.ts","sourceRoot":"","sources":["../../../../src/lib/config/config-utils/get-stats-options.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD,wBAAgB,eAAe,CAAC,OAAO,UAAQ,GAAG,YAAY,CAsC7D"}

package/dist/lib/config/config-utils/get-stats-options.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStatsOptions = getStatsOptions;
+function getStatsOptions(verbose = false) {
+    const rspackStatsOptions = {
+        all: false, // Fallback value for stats options when an option is not defined. It has precedence over local webpack defaults.
+        colors: true,
+        hash: true, // required by custom stat output
+        timings: true, // required by custom stat output
+        chunks: true, // required by custom stat output
+        builtAt: true, // required by custom stat output
+        warnings: true,
+        errors: true,
+        assets: true, // required by custom stat output
+        cachedAssets: true, // required for bundle size calculators
+        // Needed for markAsyncChunksNonInitial.
+        ids: true,
+        entrypoints: true,
+    };
+    const verboseStatsOutputOptions = {
+        // The verbose output will most likely be piped to a file, so colors just mess it up.
+        colors: false,
+        usedExports: true,
+        optimizationBailout: true,
+        reasons: true,
+        children: true,
+        assets: true,
+        version: true,
+        chunkModules: true,
+        errorDetails: true,
+        errorStack: true,
+        moduleTrace: true,
+        logging: 'verbose',
+        modulesSpace: Infinity,
+    };
+    return verbose
+        ? { ...rspackStatsOptions, ...verboseStatsOutputOptions }
+        : rspackStatsOptions;
+}

package/dist/lib/config/config-utils/helpers.d.ts

@@ -0,0 +1,13 @@
+import { AngularRspackPluginOptions, HashFormat, NormalizedAngularRspackPluginOptions, OutputHashing } from '../../models';
+/**
+ * Delete an output directory, but error out if it's the root of the project.
+ */
+export declare function deleteOutputDir(root: string, outputPath: string, emptyOnlyDirectories?: string[]): Promise<void>;
+export declare function getOutputHashFormat(outputHashing?: OutputHashing, length?: number): HashFormat;
+export declare function normalizeOptionWithI18n(options: AngularRspackPluginOptions): Promise<{
+    i18n: import("@angular/build/private").I18nOptions;
+    i18nHash: string | (() => void);
+    normalizedOptions: NormalizedAngularRspackPluginOptions;
+}>;
+export declare function getCrossOriginLoading(normalizedOptions: NormalizedAngularRspackPluginOptions): false | "anonymous" | "use-credentials";
+//# sourceMappingURL=helpers.d.ts.map

package/dist/lib/config/config-utils/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../../src/lib/config/config-utils/helpers.ts"],"names":[],"mappings":"AASA,OAAO,EACL,0BAA0B,EAC1B,UAAU,EACV,oCAAoC,EAEpC,aAAa,EACd,MAAM,cAAc,CAAC;AAItB;;GAEG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,EAClB,oBAAoB,CAAC,EAAE,MAAM,EAAE,GAC9B,OAAO,CAAC,IAAI,CAAC,CAqCf;AAED,wBAAgB,mBAAmB,CACjC,aAAa,GAAE,aAAsB,EACrC,MAAM,SAAI,GACT,UAAU,CAkCZ;AAED,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,0BAA0B;;;;GAmBpC;AAED,wBAAgB,qBAAqB,CACnC,iBAAiB,EAAE,oCAAoC,2CAcxD"}

package/dist/lib/config/{helpers.js → config-utils/helpers.js}

@@ -2,8 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deleteOutputDir = deleteOutputDir;
 exports.getOutputHashFormat = getOutputHashFormat;
+exports.normalizeOptionWithI18n = normalizeOptionWithI18n;
+exports.getCrossOriginLoading = getCrossOriginLoading;
+/**
+ * @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.dev/license
+ */
 const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
+const models_1 = require("../../models");
+const create_i18n_options_1 = require("../i18n/create-i18n-options");
 /**
  * Delete an output directory, but error out if it's the root of the project.
  */
@@ -71,3 +82,25 @@ function getOutputHashFormat(outputHashing = 'none', length = 8) {
             };
     }
 }
+async function normalizeOptionWithI18n(options) {
+    const { options: _options, i18n } = await (0, create_i18n_options_1.configureI18n)(options.root ?? process.cwd(), options);
+    // Update file hashes to include translation file content
+    const i18nHash = i18n.shouldInline
+        ? Object.values(i18n.locales).reduce((data, locale) => data + locale.files.map((file) => file.integrity || '').join('|'), '')
+        : () => {
+            // no-op as i18n is not inlined
+        };
+    const normalizedOptions = await (0, models_1.normalizeOptions)(_options);
+    return { i18n, i18nHash, normalizedOptions };
+}
+function getCrossOriginLoading(normalizedOptions) {
+    let crossOriginLoading = false;
+    if (normalizedOptions.subresourceIntegrity &&
+        normalizedOptions.crossOrigin === 'none') {
+        crossOriginLoading = 'anonymous';
+    }
+    else if (normalizedOptions.crossOrigin !== 'none') {
+        crossOriginLoading = normalizedOptions.crossOrigin;
+    }
+    return crossOriginLoading;
+}

package/dist/lib/config/config-utils/optimization-config.d.ts

@@ -0,0 +1,5 @@
+import { Configuration } from '@rspack/core';
+import { NormalizedAngularRspackPluginOptions } from '../../models';
+export declare const VENDORS_TEST: RegExp;
+export declare function getOptimization(normalizedOptions: NormalizedAngularRspackPluginOptions, platform: 'browser' | 'server'): Configuration['optimization'];
+//# sourceMappingURL=optimization-config.d.ts.map

package/dist/lib/config/config-utils/optimization-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimization-config.d.ts","sourceRoot":"","sources":["../../../../src/lib/config/config-utils/optimization-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,aAAa,EACd,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,oCAAoC,EAAE,MAAM,cAAc,CAAC;AAGpE,eAAO,MAAM,YAAY,QAA2B,CAAC;AAErD,wBAAgB,eAAe,CAC7B,iBAAiB,EAAE,oCAAoC,EACvD,QAAQ,EAAE,SAAS,GAAG,QAAQ,GAC7B,aAAa,CAAC,cAAc,CAAC,CA6D/B"}