@nx/angular-rspack 20.8.2 → 20.9.0

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

@@ -0,0 +1,87 @@
+"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',
+        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' },
+        },
+        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 && !isDevServer
+                ? [new prerender_plugin_1.PrerenderPlugin(normalizedOptions, i18n)]
+                : []),
+        ],
+    };
+}

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

@@ -0,0 +1,7 @@
+import { RspackPluginInstance, RuleSetRule } from '@rspack/core';
+import type { SourceMap } from '../../models';
+export declare function configureSourceMap(sourceMap: SourceMap): {
+    sourceMapRules: RuleSetRule[];
+    sourceMapPlugins: RspackPluginInstance[];
+};
+//# sourceMappingURL=sourcemap-utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sourcemap-utils.d.ts","sourceRoot":"","sources":["../../../../src/lib/config/config-utils/sourcemap-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,WAAW,EAEZ,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAG9C,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,SAAS;;;EAoDtD"}

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureSourceMap = configureSourceMap;
+const core_1 = require("@rspack/core");
+const dev_tools_ignore_plugin_1 = require("../../plugins/tools/dev-tools-ignore-plugin");
+function configureSourceMap(sourceMap) {
+    const { scripts, styles, hidden, vendor } = sourceMap;
+    const sourceMapRules = [];
+    const sourceMapPlugins = [];
+    if (scripts || styles) {
+        const include = [];
+        if (scripts) {
+            include.push(/js$/);
+        }
+        if (styles) {
+            include.push(/css$/);
+        }
+        sourceMapPlugins.push(new dev_tools_ignore_plugin_1.DevToolsIgnorePlugin());
+        sourceMapPlugins.push(new core_1.SourceMapDevToolPlugin({
+            filename: '[file].map',
+            include,
+            // We want to set sourceRoot to  `webpack:///` for non
+            // inline sourcemaps as otherwise paths to sourcemaps will be broken in browser
+            // `webpack:///` is needed for Visual Studio breakpoints to work properly as currently
+            // there is no way to set the 'webRoot'
+            sourceRoot: 'webpack:///',
+            moduleFilenameTemplate: '[resource-path]',
+            append: hidden ? false : undefined,
+        }));
+        sourceMapRules.push({
+            test: /\.[cm]?jsx?$/,
+            enforce: 'pre',
+            loader: require.resolve('source-map-loader'),
+            options: {
+                filterSourceMappingUrl: (_mapUri, resourcePath) => {
+                    if (vendor) {
+                        // Consume all sourcemaps when vendor option is enabled.
+                        return true;
+                    }
+                    // Don't consume sourcemaps in node_modules when vendor is disabled.
+                    // But, do consume local libraries sourcemaps.
+                    return !resourcePath.includes('node_modules');
+                },
+            },
+        });
+    }
+    return { sourceMapRules, sourceMapPlugins };
+}

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

@@ -0,0 +1,7 @@
+import { type Plugins, type RuleSetRules } from '@rspack/core';
+import type { HashFormat, NormalizedAngularRspackPluginOptions } from '../../models';
+export declare function getStylesConfig(buildOptions: NormalizedAngularRspackPluginOptions, hashFormat: HashFormat, platform: 'browser' | 'server'): Promise<{
+    loaderRules: RuleSetRules;
+    plugins: Plugins;
+}>;
+//# sourceMappingURL=style-config-utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"style-config-utils.d.ts","sourceRoot":"","sources":["../../../../src/lib/config/config-utils/style-config-utils.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,OAAO,EACZ,KAAK,YAAY,EAElB,MAAM,cAAc,CAAC;AAKtB,OAAO,KAAK,EACV,UAAU,EACV,oCAAoC,EACrC,MAAM,cAAc,CAAC;AAStB,wBAAsB,eAAe,CACnC,YAAY,EAAE,oCAAoC,EAClD,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,SAAS,GAAG,QAAQ,GAC7B,OAAO,CAAC;IACT,WAAW,EAAE,YAAY,CAAC;IAC1B,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC,CA4PD"}

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

@@ -0,0 +1,353 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStylesConfig = getStylesConfig;
+const tslib_1 = require("tslib");
+const devkit_1 = require("@nx/devkit");
+const core_1 = require("@rspack/core");
+const node_module_1 = require("node:module");
+const node_path_1 = require("node:path");
+const node_url_1 = require("node:url");
+const postcss_cli_resources_1 = tslib_1.__importDefault(require("../../utils/postcss-cli-resources"));
+const postcss_configuration_1 = require("../../utils/postcss-configuration");
+async function getStylesConfig(buildOptions, hashFormat, platform) {
+    const extraPlugins = [];
+    const cssSourceMap = buildOptions.sourceMap.styles;
+    // use includePaths from appConfig
+    const includePaths = buildOptions.stylePreprocessorOptions?.includePaths?.map((p) => (0, node_path_1.resolve)(buildOptions.root, p)) ?? [];
+    const assetNameTemplate = assetNameTemplateFactory(hashFormat);
+    const extraPostcssPlugins = [];
+    // A configuration file can exist in the project or workspace root
+    const searchDirectories = await (0, postcss_configuration_1.generateSearchDirectories)([
+        buildOptions.root,
+        devkit_1.workspaceRoot,
+    ]);
+    const postcssConfiguration = await (0, postcss_configuration_1.loadPostcssConfiguration)(searchDirectories);
+    if (postcssConfiguration) {
+        for (const [pluginName, pluginOptions] of postcssConfiguration.plugins) {
+            const { default: plugin } = await Promise.resolve(`${pluginName}`).then(s => tslib_1.__importStar(require(s)));
+            if (typeof plugin !== 'function' || plugin.postcss !== true) {
+                throw new Error(`Attempted to load invalid Postcss plugin: "${pluginName}"`);
+            }
+            extraPostcssPlugins.push(plugin(pluginOptions));
+        }
+    }
+    else {
+        const tailwindConfig = await getTailwindConfig(searchDirectories, devkit_1.workspaceRoot);
+        if (tailwindConfig) {
+            const tailwind = await Promise.resolve(`${tailwindConfig.package}`).then(s => tslib_1.__importStar(require(s)));
+            extraPostcssPlugins.push(tailwind.default({ config: tailwindConfig.file }));
+        }
+    }
+    const autoprefixer = require('autoprefixer');
+    const postcssOptionsCreator = (inlineSourcemaps, extracted) => {
+        const optionGenerator = (loader) => ({
+            map: inlineSourcemaps
+                ? {
+                    inline: true,
+                    annotation: false,
+                }
+                : undefined,
+            plugins: [
+                (0, postcss_cli_resources_1.default)({
+                    baseHref: buildOptions.baseHref,
+                    deployUrl: buildOptions.deployUrl,
+                    resourcesOutputPath: buildOptions.outputPath.media,
+                    loader,
+                    filename: assetNameTemplate,
+                    emitFile: platform !== 'server',
+                    extracted,
+                }),
+                ...extraPostcssPlugins,
+                autoprefixer({
+                    ignoreUnknownVersions: true,
+                    overrideBrowserslist: buildOptions.supportedBrowsers,
+                }),
+            ],
+        });
+        // postcss-loader fails when trying to determine configuration files for data URIs
+        optionGenerator.config = false;
+        return optionGenerator;
+    };
+    let componentsSourceMap = !!cssSourceMap;
+    if (cssSourceMap) {
+        // TODO: use below once we support optimization granular options
+        // if (buildOptions.optimization.styles.minify) {
+        if (buildOptions.optimization) {
+            // Never use component css sourcemap when style optimizations are on.
+            // It will just increase bundle size without offering good debug experience.
+            console.warn('Components styles sourcemaps are not generated when styles optimization is enabled.');
+            componentsSourceMap = false;
+        }
+        else if (buildOptions.sourceMap.hidden) {
+            // Inline all sourcemap types except hidden ones, which are the same as no sourcemaps
+            // for component css.
+            console.warn('Components styles sourcemaps are not generated when sourcemaps are hidden.');
+            componentsSourceMap = false;
+        }
+    }
+    // extract global css from js files into own css file.
+    extraPlugins.push(new core_1.CssExtractRspackPlugin({ filename: `[name]${hashFormat.extract}.css` }));
+    // TODO: add this once we support hmr
+    // if (!buildOptions.hmr) {
+    //   // don't remove `.js` files for `.css` when we are using HMR these contain HMR accept codes.
+    //   // suppress empty .js files in css only entry points.
+    //   extraPlugins.push(new SuppressExtractedTextChunksWebpackPlugin());
+    // }
+    const postCss = require('postcss');
+    const postCssLoaderPath = require.resolve('postcss-loader');
+    const componentStyleLoaders = [
+        {
+            loader: require.resolve('css-loader'),
+            options: {
+                url: false,
+                sourceMap: componentsSourceMap,
+                importLoaders: 1,
+                exportType: 'string',
+                esModule: false,
+            },
+        },
+        {
+            loader: postCssLoaderPath,
+            options: {
+                implementation: postCss,
+                postcssOptions: postcssOptionsCreator(componentsSourceMap, false),
+            },
+        },
+    ];
+    const globalStyleLoaders = [
+        {
+            loader: core_1.CssExtractRspackPlugin.loader,
+        },
+        {
+            loader: require.resolve('css-loader'),
+            options: {
+                url: false,
+                sourceMap: !!cssSourceMap,
+                importLoaders: 1,
+            },
+        },
+        {
+            loader: postCssLoaderPath,
+            options: {
+                implementation: postCss,
+                postcssOptions: postcssOptionsCreator(false, true),
+                sourceMap: !!cssSourceMap,
+            },
+        },
+    ];
+    const styleLanguages = [
+        {
+            extensions: ['css'],
+            use: [],
+        },
+        {
+            extensions: ['scss'],
+            use: [
+                {
+                    loader: require.resolve('resolve-url-loader'),
+                    options: {
+                        sourceMap: cssSourceMap,
+                    },
+                },
+                {
+                    loader: require.resolve('sass-loader'),
+                    options: getSassLoaderOptions(devkit_1.workspaceRoot, includePaths, false, !!buildOptions.verbose, !!buildOptions.preserveSymlinks),
+                },
+            ],
+        },
+        {
+            extensions: ['sass'],
+            use: [
+                {
+                    loader: require.resolve('resolve-url-loader'),
+                    options: {
+                        sourceMap: cssSourceMap,
+                    },
+                },
+                {
+                    loader: require.resolve('sass-loader'),
+                    options: getSassLoaderOptions(devkit_1.workspaceRoot, includePaths, true, !!buildOptions.verbose, !!buildOptions.preserveSymlinks),
+                },
+            ],
+        },
+        {
+            extensions: ['less'],
+            use: [
+                {
+                    loader: require.resolve('less-loader'),
+                    options: {
+                        sourceMap: cssSourceMap,
+                        lessOptions: {
+                            javascriptEnabled: true,
+                            paths: includePaths,
+                        },
+                    },
+                },
+            ],
+        },
+    ];
+    return {
+        loaderRules: styleLanguages.map(({ extensions, use }) => ({
+            test: new RegExp(`\\.(?:${extensions.join('|')})$`, 'i'),
+            rules: [
+                // Setup processing rules for global and component styles
+                {
+                    oneOf: [
+                        // Global styles are only defined global styles
+                        {
+                            use: globalStyleLoaders,
+                            resourceQuery: /\?ngGlobalStyle/,
+                        },
+                        // Component styles are all styles except defined global styles
+                        {
+                            use: componentStyleLoaders,
+                            resourceQuery: /\?ngResource/,
+                        },
+                    ],
+                },
+                { use },
+            ],
+        })),
+        plugins: extraPlugins,
+    };
+}
+function assetNameTemplateFactory(hashFormat) {
+    const visitedFiles = new Map();
+    return (resourcePath) => {
+        if (hashFormat.file) {
+            // File names are hashed therefore we don't need to handle files with the same file name.
+            return `[name]${hashFormat.file}.[ext]`;
+        }
+        const filename = (0, node_path_1.basename)(resourcePath);
+        // Check if the file with the same name has already been processed.
+        const visited = visitedFiles.get(filename);
+        if (!visited) {
+            // Not visited.
+            visitedFiles.set(filename, resourcePath);
+            return filename;
+        }
+        else if (visited === resourcePath) {
+            // Same file.
+            return filename;
+        }
+        // File has the same name but it's in a different location.
+        return '[path][name].[ext]';
+    };
+}
+function getSassLoaderOptions(root, includePaths, indentedSyntax, verbose, preserveSymlinks) {
+    return {
+        api: 'modern-compiler',
+        sourceMap: true,
+        implementation: require.resolve('sass-embedded'),
+        // Webpack importer is only implemented in the legacy API and we have our own custom Webpack importer.
+        // See: https://github.com/webpack-contrib/sass-loader/blob/997f3eb41d86dd00d5fa49c395a1aeb41573108c/src/utils.js#L642-L651
+        webpackImporter: false,
+        sassOptions: (loaderContext) => ({
+            importers: [
+                getSassResolutionImporter(loaderContext, root, preserveSymlinks),
+            ],
+            loadPaths: includePaths,
+            // Use expanded as otherwise sass will remove comments that are needed for autoprefixer
+            // Ex: /* autoprefixer grid: autoplace */
+            // See: https://github.com/webpack-contrib/sass-loader/blob/45ad0be17264ceada5f0b4fb87e9357abe85c4ff/src/getSassOptions.js#L68-L70
+            style: 'expanded',
+            // Silences compiler warnings from 3rd party stylesheets
+            quietDeps: !verbose,
+            verbose,
+            syntax: indentedSyntax ? 'indented' : 'scss',
+            sourceMapIncludeSources: true,
+        }),
+    };
+}
+function getSassResolutionImporter(loaderContext, root, preserveSymlinks) {
+    const commonResolverOptions = {
+        conditionNames: ['sass', 'style'],
+        mainFields: ['sass', 'style', 'main', '...'],
+        extensions: ['.scss', '.sass', '.css'],
+        restrictions: [/\.((sa|sc|c)ss)$/i],
+        preferRelative: true,
+        symlinks: !preserveSymlinks,
+    };
+    // Sass also supports import-only files. If you name a file <name>.import.scss, it will only be loaded for imports, not for @uses.
+    // See: https://sass-lang.com/documentation/at-rules/import#import-only-files
+    const resolveImport = loaderContext.getResolve({
+        byDependency: {
+            'sass-import': {
+                ...commonResolverOptions,
+                mainFiles: ['_index.import', '_index', 'index.import', 'index', '...'],
+            },
+        },
+    });
+    const resolveModule = loaderContext.getResolve({
+        byDependency: {
+            'sass-module': {
+                ...commonResolverOptions,
+                mainFiles: ['_index', 'index', '...'],
+            },
+        },
+    });
+    return {
+        findFileUrl: async (url, { fromImport, containingUrl }) => {
+            if (url.charAt(0) === '.') {
+                // Let Sass handle relative imports.
+                return null;
+            }
+            let resolveDir = root;
+            if (containingUrl) {
+                resolveDir = (0, node_path_1.dirname)((0, node_url_1.fileURLToPath)(containingUrl));
+            }
+            const resolve = fromImport ? resolveImport : resolveModule;
+            // Try to resolve from root of workspace
+            const result = await tryResolve(resolve, resolveDir, url);
+            return result ? (0, node_url_1.pathToFileURL)(result) : null;
+        },
+    };
+}
+async function tryResolve(resolve, root, url) {
+    const promisifiedResolve = (root, url) => new Promise((res, rej) => {
+        resolve(root, url, (err, result) => {
+            if (err) {
+                rej();
+            }
+            else {
+                res(result);
+            }
+        });
+    });
+    try {
+        return await promisifiedResolve(root, url);
+    }
+    catch {
+        // Try to resolve a partial file
+        // @use '@material/button/button' as mdc-button;
+        // `@material/button/button` -> `@material/button/_button`
+        const lastSlashIndex = url.lastIndexOf('/');
+        const underscoreIndex = lastSlashIndex + 1;
+        if (underscoreIndex > 0 && url.charAt(underscoreIndex) !== '_') {
+            const partialFileUrl = `${url.slice(0, underscoreIndex)}_${url.slice(underscoreIndex)}`;
+            return promisifiedResolve(root, partialFileUrl).catch(() => undefined);
+        }
+    }
+    return undefined;
+}
+async function getTailwindConfig(searchDirectories, workspaceRoot) {
+    const tailwindConfigurationPath = (0, postcss_configuration_1.findTailwindConfiguration)(searchDirectories);
+    if (!tailwindConfigurationPath) {
+        return undefined;
+    }
+    // Create a node resolver from the configuration file
+    const resolver = (0, node_module_1.createRequire)(tailwindConfigurationPath);
+    try {
+        return {
+            file: tailwindConfigurationPath,
+            package: resolver.resolve('tailwindcss'),
+        };
+    }
+    catch {
+        const relativeTailwindConfigPath = (0, node_path_1.relative)(workspaceRoot, tailwindConfigurationPath);
+        console.warn(`Tailwind CSS configuration file found (${relativeTailwindConfigPath})` +
+            ` but the 'tailwindcss' package is not installed.` +
+            ` To enable Tailwind CSS, please install the 'tailwindcss' package.`);
+    }
+    return undefined;
+}

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

@@ -0,0 +1,78 @@
+import type { Configuration } from '@rspack/core';
+import type { AngularRspackPluginOptions } from '../../models';
+export declare function handleConfigurations(defaultOptions: {
+    options: AngularRspackPluginOptions;
+    rspackConfigOverrides?: Partial<Configuration>;
+}, configurations: Record<string, {
+    options: Partial<AngularRspackPluginOptions>;
+    rspackConfigOverrides?: Partial<Configuration>;
+}>, configurationModes: string[]): {
+    mergedConfigurationBuildOptions: {
+        aot?: boolean;
+        assets?: import("../../models").AssetElement[];
+        baseHref?: string;
+        browser?: string;
+        commonChunk?: boolean;
+        crossOrigin?: "none" | "anonymous" | "use-credentials";
+        define?: Record<string, string>;
+        deleteOutputPath?: boolean;
+        deployUrl?: string;
+        devServer?: import("../../models").DevServerOptions;
+        externalDependencies?: string[];
+        extractLicenses?: boolean;
+        fileReplacements?: import("@nx/angular-rspack-compiler").FileReplacement[];
+        index?: import("../../models").IndexElement;
+        inlineStyleLanguage?: import("@nx/angular-rspack-compiler").InlineStyleLanguage;
+        i18nMetadata?: import("../../models").I18nProjectMetadata;
+        i18nMissingTranslation?: "warning" | "error" | "ignore";
+        i18nDuplicateTranslation?: "warning" | "error" | "ignore";
+        localize?: boolean | string[];
+        namedChunks?: boolean;
+        ngswConfigPath?: string;
+        optimization?: boolean | import("../../models").OptimizationOptions;
+        outputHashing?: import("../../models").OutputHashing;
+        outputPath?: string | (Required<Pick<import("../../models").OutputPath, "base">> & Partial<import("../../models").OutputPath>);
+        polyfills?: string[];
+        prerender?: boolean | {
+            routes?: string[];
+            routesFile?: string;
+            discoverRoutes?: boolean;
+        };
+        preserveSymlinks?: boolean;
+        root?: string;
+        scripts?: import("../../models").ScriptOrStyleEntry[];
+        server?: string;
+        serviceWorker?: boolean;
+        skipTypeChecking?: boolean;
+        sourceMap?: boolean | Partial<import("../../models").SourceMap>;
+        ssr?: boolean | {
+            entry: string;
+            experimentalPlatform?: "node" | "neutral";
+        };
+        stylePreprocessorOptions?: import("@nx/angular-rspack-compiler").StylePreprocessorOptions;
+        styles?: import("../../models").ScriptOrStyleEntry[];
+        subresourceIntegrity?: boolean;
+        tsConfig?: string;
+        useTsProjectReferences?: boolean;
+        vendorChunk?: boolean;
+        webWorkerTsConfig?: string;
+        security?: {
+            autoCsp?: boolean | {
+                unsafeEval?: boolean;
+            };
+        };
+        clearScreen?: boolean;
+        verbose?: boolean;
+        progress?: boolean;
+        watch?: boolean;
+        poll?: number;
+        statsJson?: boolean;
+        budgets?: import("../../models/unsupported-options").BudgetEntry[];
+        allowedCommonJsDependencies?: string[];
+        appShell?: boolean;
+        outputMode?: "static" | "server";
+    };
+    mergedRspackConfigOverrides: Partial<import("@rspack/core").RspackOptions>;
+};
+export declare function parseConfigurationMode(configurationMode: string): string[];
+//# sourceMappingURL=user-defined-config-helpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"user-defined-config-helpers.d.ts","sourceRoot":"","sources":["../../../../src/lib/config/config-utils/user-defined-config-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAGlD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,cAAc,CAAC;AAE/D,wBAAgB,oBAAoB,CAClC,cAAc,EAAE;IACd,OAAO,EAAE,0BAA0B,CAAC;IACpC,qBAAqB,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;CAChD,EACD,cAAc,EAAE,MAAM,CACpB,MAAM,EACN;IACE,OAAO,EAAE,OAAO,CAAC,0BAA0B,CAAC,CAAC;IAC7C,qBAAqB,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;CAChD,CACF,EACD,kBAAkB,EAAE,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAwBujH,CAAC;sBAA2O,CAAC;0BAA8L,CAAC;;;;;;;;;;;gCAA4gB,CAAC;;;;;;;;;;mBAtBx+I,CAAC;0BACvB,CAAC;;;;;;;;;;;;;;;EAgBhB;AAED,wBAAgB,sBAAsB,CAAC,iBAAiB,EAAE,MAAM,YAE/D"}

package/dist/lib/config/config-utils/user-defined-config-helpers.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleConfigurations = handleConfigurations;
+exports.parseConfigurationMode = parseConfigurationMode;
+const tslib_1 = require("tslib");
+const webpack_merge_1 = require("webpack-merge");
+const deepmerge_1 = tslib_1.__importDefault(require("deepmerge"));
+function handleConfigurations(defaultOptions, configurations, configurationModes) {
+    let mergedConfigurationBuildOptions = { ...defaultOptions.options };
+    let mergedRspackConfigOverrides = defaultOptions.rspackConfigOverrides ?? {};
+    for (const configurationName of configurationModes) {
+        if (configurationName in configurations) {
+            mergedConfigurationBuildOptions = (0, deepmerge_1.default)(mergedConfigurationBuildOptions, configurations[configurationName].options ?? {});
+            if (configurations[configurationName].rspackConfigOverrides) {
+                mergedRspackConfigOverrides = (0, webpack_merge_1.merge)(mergedRspackConfigOverrides, configurations[configurationName].rspackConfigOverrides);
+            }
+        }
+    }
+    return { mergedConfigurationBuildOptions, mergedRspackConfigOverrides };
+}
+function parseConfigurationMode(configurationMode) {
+    return configurationMode.split(',').map((m) => m.trim());
+}