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

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

@@ -0,0 +1,258 @@
+"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' &&
+                    e.code !== 'ERR_REQUIRE_ASYNC_MODULE') {
+                    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/config-utils/entry-points.d.ts

@@ -0,0 +1,9 @@
+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[];
+};
+export declare function toRspackEntries(entries: GlobalEntry[], root: string, queryString?: string): Record<string, {
+    import: string[];
+}>;
+//# sourceMappingURL=entry-points.d.ts.map

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/entry-points.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEntryPoints = getEntryPoints;
+exports.getPolyfillsEntry = getPolyfillsEntry;
+exports.toRspackEntries = toRspackEntries;
+const node_path_1 = require("node:path");
+function getEntryPoints(globalStyles, globalScripts, isHMREnabled) {
+    return [
+        ['runtime', !isHMREnabled],
+        ['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],
+    ];
+}
+function getPolyfillsEntry(polyfills, aot) {
+    const normalizedPolyfills = [...polyfills];
+    if (!aot) {
+        normalizedPolyfills.push('@angular/compiler');
+    }
+    if (normalizedPolyfills.length) {
+        return { polyfills: normalizedPolyfills };
+    }
+    return {};
+}
+function toRspackEntries(entries, root, queryString) {
+    const result = {};
+    for (const { files, name } of entries) {
+        result[name] ??= { import: [] };
+        for (const file of files) {
+            result[name].import.push((0, node_path_1.join)(root, `${file}${queryString ? `?${queryString}` : ''}`));
+        }
+    }
+    return result;
+}

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/config-utils/helpers.js

@@ -0,0 +1,106 @@
+"use strict";
+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.
+ */
+async function deleteOutputDir(root, outputPath, emptyOnlyDirectories) {
+    const resolvedOutputPath = (0, node_path_1.resolve)(root, outputPath);
+    if (resolvedOutputPath === root) {
+        throw new Error('Output path MUST not be project root directory!');
+    }
+    const directoriesToEmpty = emptyOnlyDirectories
+        ? new Set(emptyOnlyDirectories.map((directory) => (0, node_path_1.join)(resolvedOutputPath, directory)))
+        : undefined;
+    // Avoid removing the actual directory to avoid errors in cases where the output
+    // directory is mounted or symlinked. Instead the contents are removed.
+    let entries;
+    try {
+        entries = await (0, promises_1.readdir)(resolvedOutputPath);
+    }
+    catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+            return;
+        }
+        throw error;
+    }
+    for (const entry of entries) {
+        const fullEntry = (0, node_path_1.join)(resolvedOutputPath, entry);
+        // Leave requested directories. This allows symlinks to continue to function.
+        if (directoriesToEmpty?.has(fullEntry)) {
+            await deleteOutputDir(resolvedOutputPath, fullEntry);
+            continue;
+        }
+        await (0, promises_1.rm)(fullEntry, { force: true, recursive: true, maxRetries: 3 });
+    }
+}
+function getOutputHashFormat(outputHashing = 'none', length = 8) {
+    const hashTemplate = `.[contenthash:${length}]`;
+    switch (outputHashing) {
+        case 'media':
+            return {
+                chunk: '',
+                extract: '',
+                file: hashTemplate,
+                script: '',
+            };
+        case 'bundles':
+            return {
+                chunk: hashTemplate,
+                extract: hashTemplate,
+                file: '',
+                script: hashTemplate,
+            };
+        case 'all':
+            return {
+                chunk: hashTemplate,
+                extract: hashTemplate,
+                file: hashTemplate,
+                script: hashTemplate,
+            };
+        case 'none':
+        default:
+            return {
+                chunk: '',
+                extract: '',
+                file: '',
+                script: '',
+            };
+    }
+}
+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"}

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

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VENDORS_TEST = void 0;
+exports.getOptimization = getOptimization;
+const core_1 = require("@rspack/core");
+const transfer_size_plugin_1 = require("../../plugins/transfer-size-plugin");
+exports.VENDORS_TEST = /[\\/]node_modules[\\/]/;
+function getOptimization(normalizedOptions, platform) {
+    return {
+        chunkIds: normalizedOptions.namedChunks ? 'named' : 'deterministic',
+        emitOnErrors: false,
+        moduleIds: 'deterministic',
+        runtimeChunk: platform === 'browser' ? 'single' : false,
+        minimizer: normalizedOptions.optimization.scripts
+            ? [
+                new core_1.SwcJsMinimizerRspackPlugin({
+                    minimizerOptions: {
+                        minify: true,
+                        ...(platform === 'server'
+                            ? {
+                                mangle: {
+                                    reserved: [
+                                        'renderApplication',
+                                        'renderModule',
+                                        'ɵSERVER_CONTEXT',
+                                        'ɵgetRoutesFromAngularRouterConfig',
+                                    ],
+                                },
+                            }
+                            : {}),
+                        format: {
+                            comments: false,
+                        },
+                    },
+                }),
+                new core_1.LightningCssMinimizerRspackPlugin(),
+                ...(platform === 'browser' ? [new transfer_size_plugin_1.TransferSizePlugin()] : []),
+            ]
+            : [],
+        splitChunks: {
+            chunks: platform === 'browser' ? 'all' : 'async',
+            minChunks: 1,
+            minSize: 20000,
+            maxAsyncRequests: 30,
+            maxInitialRequests: 30,
+            cacheGroups: {
+                default: normalizedOptions.commonChunk && {
+                    chunks: 'async',
+                    minChunks: 2,
+                    priority: 10,
+                },
+                common: normalizedOptions.commonChunk && {
+                    name: 'common',
+                    chunks: 'async',
+                    minChunks: 2,
+                    enforce: true,
+                    priority: 5,
+                },
+                vendors: false,
+                defaultVendors: normalizedOptions.vendorChunk && {
+                    name: 'vendor',
+                    chunks: (chunk) => chunk.name === 'main',
+                    enforce: true,
+                    test: exports.VENDORS_TEST,
+                },
+            },
+        },
+    };
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"server-config.d.ts","sourceRoot":"","sources":["../../../../src/lib/config/config-utils/server-config.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,aAAa,EAA4B,MAAM,cAAc,CAAC;AAE5E,OAAO,KAAK,EACV,WAAW,EACX,oCAAoC,EACrC,MAAM,cAAc,CAAC;AAOtB,wBAAsB,eAAe,CACnC,iBAAiB,EAAE,oCAAoC,EACvD,IAAI,EAAE,WAAW,EACjB,aAAa,EAAE,aAAa,GAC3B,OAAO,CAAC,aAAa,CAAC,CAmFxB"}

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

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServerConfig = getServerConfig;
+const angular_rspack_compiler_1 = require("@nx/angular-rspack-compiler");
+const core_1 = require("@rspack/core");
+const path_1 = require("path");
+const ng_rspack_1 = require("../../plugins/ng-rspack");
+const prerender_plugin_1 = require("../../plugins/prerender-plugin");
+const misc_helpers_1 = require("../../utils/misc-helpers");
+const dev_server_config_utils_1 = require("./dev-server-config-utils");
+const optimization_config_1 = require("./optimization-config");
+async function getServerConfig(normalizedOptions, i18n, defaultConfig) {
+    const isDevServer = !!process.env['WEBPACK_SERVE'];
+    const { root } = normalizedOptions;
+    return {
+        ...defaultConfig,
+        dependencies: ['browser'],
+        name: 'server',
+        target: ['node', 'es2015'],
+        entry: {
+            server: {
+                import: [
+                    ...((0, misc_helpers_1.isPackageInstalled)(root, '@angular/platform-server')
+                        ? // This import must come before any imports (direct or transitive) that rely on DOM built-ins being
+                            // available, such as `@angular/elements`.
+                            ['@angular/platform-server/init']
+                        : []),
+                    ...(i18n.shouldInline ? ['@angular/localize/init'] : []),
+                    normalizedOptions.ssr.entry,
+                ],
+            },
+        },
+        output: {
+            ...defaultConfig.output,
+            path: normalizedOptions.outputPath.server,
+            filename: '[name].js',
+            chunkFilename: '[name].js',
+            library: { type: 'commonjs' },
+        },
+        resolve: {
+            ...defaultConfig.resolve,
+            mainFields: ['es2020', 'es2015', 'module', 'main'],
+        },
+        devServer: await (0, dev_server_config_utils_1.getDevServerConfig)(normalizedOptions, 'server'),
+        externals: normalizedOptions.externalDependencies,
+        optimization: (0, optimization_config_1.getOptimization)(normalizedOptions, 'server'),
+        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',
+                                },
+                            },
+                        },
+                    ],
+                },
+                {
+                    loader: require.resolve('@nx/angular-rspack/loaders/platform-server-exports-loader'),
+                    include: [
+                        (0, path_1.resolve)(root, normalizedOptions.ssr.entry),
+                    ],
+                    options: {
+                        angularSSRInstalled: (0, misc_helpers_1.isPackageInstalled)(root, '@angular/ssr'),
+                    },
+                },
+                ...(defaultConfig.module?.rules ?? []),
+            ],
+        },
+        plugins: [
+            ...(defaultConfig.plugins ?? []),
+            // Fixes Critical dependency: the request of a dependency is an expression
+            new core_1.ContextReplacementPlugin(/@?hapi|express[\\/]/),
+            new ng_rspack_1.NgRspackPlugin(normalizedOptions, {
+                i18nOptions: i18n,
+                platform: 'server',
+            }),
+            ...(normalizedOptions.prerender ||
+                (normalizedOptions.appShell && !isDevServer)
+                ? [new prerender_plugin_1.PrerenderPlugin(normalizedOptions, i18n)]
+                : []),
+        ],
+    };
+}