@gravity-ui/app-builder 0.14.1 → 0.14.2-beta.0

package/dist/common/rspack/config.js

@@ -0,0 +1,772 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateManifest = void 0;
+exports.rspackConfigFactory = rspackConfigFactory;
+exports.configureModuleRules = configureModuleRules;
+exports.configureResolve = configureResolve;
+exports.configureOptimization = configureOptimization;
+/* eslint-disable complexity */
+const path = __importStar(require("node:path"));
+const fs = __importStar(require("node:fs"));
+const core_1 = require("@rspack/core");
+const utils_1 = require("../typescript/utils");
+const ts_checker_rspack_plugin_1 = require("ts-checker-rspack-plugin");
+const clean_webpack_plugin_1 = require("clean-webpack-plugin");
+const webpack_bundle_analyzer_1 = require("webpack-bundle-analyzer");
+const circular_dependency_plugin_1 = __importDefault(require("circular-dependency-plugin"));
+const rspack_manifest_plugin_1 = require("rspack-manifest-plugin");
+const plugin_react_refresh_1 = __importDefault(require("@rspack/plugin-react-refresh"));
+const paths_1 = __importDefault(require("../paths"));
+const babel_1 = require("../babel");
+const progress_plugin_1 = require("./progress-plugin");
+const utils_2 = require("../webpack/utils");
+const s3_upload_1 = require("../s3-upload");
+const log_config_1 = require("../logger/log-config");
+const imagesSizeLimit = 2048;
+const fontSizeLimit = 8192;
+const generateManifest = (seed, files, entries) => {
+    const manifestFiles = files.reduce((manifest, file) => {
+        manifest[file.name] = file.path;
+        return manifest;
+    }, seed);
+    const entrypoints = Object.keys(entries).reduce((previous, name) => {
+        return {
+            ...previous,
+            [name]: {
+                assets: {
+                    js: entries[name].filter((file) => file.endsWith('.js')),
+                    css: entries[name].filter((file) => file.endsWith('.css')),
+                },
+            },
+        };
+    }, {});
+    return {
+        files: manifestFiles,
+        entrypoints,
+    };
+};
+exports.generateManifest = generateManifest;
+async function rspackConfigFactory(rspackMode, config, { logger } = {}) {
+    const isEnvDevelopment = rspackMode === "development" /* RspackMode.Dev */;
+    const isEnvProduction = rspackMode === "production" /* RspackMode.Prod */;
+    const helperOptions = {
+        config,
+        logger,
+        isEnvDevelopment,
+        isEnvProduction,
+        configType: rspackMode,
+    };
+    // Cache is required for lazy compilation
+    const cache = Boolean(config.cache) || (isEnvDevelopment && Boolean(config.lazyCompilation));
+    let rspackConfig = {
+        mode: rspackMode,
+        context: paths_1.default.app,
+        bail: isEnvProduction,
+        devtool: configureDevTool(helperOptions),
+        entry: configureEntry(helperOptions),
+        output: configureOutput(helperOptions),
+        resolve: configureResolve(helperOptions),
+        module: {
+            rules: configureModuleRules(helperOptions),
+        },
+        plugins: configurePlugins(helperOptions),
+        optimization: configureOptimization(helperOptions),
+        // TODO
+        // externals: config.externals,
+        node: config.node,
+        watchOptions: configureWatchOptions(helperOptions),
+        ignoreWarnings: [/Failed to parse source map/],
+        infrastructureLogging: config.verbose
+            ? {
+                colors: true,
+                level: 'verbose',
+            }
+            : undefined,
+        experiments: configureExperiments(helperOptions),
+        cache,
+    };
+    rspackConfig = await config.rspack(rspackConfig, { configType: rspackMode });
+    if (config.debugWebpack) {
+        (0, log_config_1.logConfig)('Preview rspack config', rspackConfig);
+    }
+    return rspackConfig;
+}
+function configureModuleRules(helperOptions, additionalRules = []) {
+    const jsLoader = createJavaScriptLoader(helperOptions);
+    return [
+        ...createSourceMapRules(!helperOptions.config.disableSourceMapGeneration),
+        {
+            oneOf: [
+                createWorkerRule(helperOptions),
+                createJavaScriptRule(helperOptions, jsLoader),
+                createStylesRule(helperOptions),
+                createSassStylesRule(helperOptions),
+                createIconsRule(helperOptions), // workaround for https://github.com/webpack/webpack/issues/9309
+                createIconsRule(helperOptions, jsLoader),
+                ...createAssetsRules(helperOptions),
+                ...additionalRules,
+                ...createFallbackRules(helperOptions),
+            ],
+        },
+    ];
+}
+function configureDevTool({ isEnvProduction, config }) {
+    let format = 'cheap-module-source-map';
+    if (isEnvProduction) {
+        format = config.hiddenSourceMap ? 'hidden-source-map' : 'source-map';
+    }
+    return config.disableSourceMapGeneration ? false : format;
+}
+function configureWatchOptions({ config }) {
+    const watchOptions = {
+        ...config.watchOptions,
+        followSymlinks: (config.watchOptions?.followSymlinks ??
+            (!config.symlinks && config.watchOptions?.watchPackages))
+            ? true
+            : undefined,
+    };
+    delete watchOptions.watchPackages;
+    return watchOptions;
+}
+function configureExperiments({ config, isEnvProduction, }) {
+    let lazyCompilation;
+    let port;
+    if (!isEnvProduction && config.lazyCompilation) {
+        if (typeof config.lazyCompilation === 'object') {
+            port = config.lazyCompilation.port;
+        }
+        lazyCompilation = {
+            // Lazy compilation works without problems only with lazy imports
+            // See https://github.com/web-infra-dev/rspack/issues/8503
+            entries: false,
+            imports: true,
+            backend: {
+                client: require.resolve('./lazy-client.js'),
+                ...(port
+                    ? {
+                        listen: {
+                            port,
+                        },
+                    }
+                    : {}),
+            },
+            test(module) {
+                // make sure that lazy-client.js won't be lazy compiled)
+                return !module.nameForCondition().endsWith('lazy-client.js');
+            },
+        };
+    }
+    return {
+        cache: {
+            type: 'persistent',
+            snapshot: {
+                managedPaths: config.watchOptions?.watchPackages ? [] : undefined,
+            },
+            storage: {
+                type: 'filesystem',
+                directory: typeof config.cache === 'object' && 'cacheDirectory' in config.cache
+                    ? config.cache.cacheDirectory
+                    : undefined,
+            },
+        },
+        lazyCompilation,
+    };
+}
+function configureResolve({ isEnvProduction, config }) {
+    const alias = { ...config.alias };
+    for (const [key, value] of Object.entries(alias)) {
+        alias[key] = path.resolve(paths_1.default.app, value);
+    }
+    if (isEnvProduction && config.reactProfiling) {
+        alias['react-dom$'] = 'react-dom/profiling';
+        alias['scheduler/tracing'] = 'scheduler/tracing-profiling';
+    }
+    const { aliases, modules = [] } = (0, utils_2.resolveTsConfigPathsToAlias)(paths_1.default.appClient);
+    return {
+        alias: {
+            ...aliases,
+            ...alias,
+        },
+        modules: ['node_modules', ...modules, ...(config.modules || [])],
+        extensions: ['.mjs', '.cjs', '.js', '.jsx', '.ts', '.tsx', '.json'],
+        symlinks: config.symlinks,
+        fallback: Array.isArray(config.fallback) ? undefined : config.fallback,
+    };
+}
+function createEntryArray(entry) {
+    return [require.resolve('./public-path'), entry];
+}
+function addEntry(entry, file) {
+    const newEntry = path.resolve(paths_1.default.appEntry, file);
+    return {
+        ...entry,
+        [path.parse(file).name]: createEntryArray(newEntry),
+    };
+}
+function configureEntry({ config }) {
+    let entries = fs.readdirSync(paths_1.default.appEntry).filter((file) => /\.[jt]sx?$/.test(file));
+    if (Array.isArray(config.entryFilter) && config.entryFilter.length) {
+        entries = entries.filter((entry) => config.entryFilter?.includes(entry.split('.')[0] ?? ''));
+    }
+    if (!entries.length) {
+        throw new Error('No entries were found after applying UI_CORE_ENTRY_FILTER');
+    }
+    return entries.reduce((entry, file) => addEntry(entry, file), {});
+}
+function getFileNames({ isEnvProduction }) {
+    return {
+        filename: isEnvProduction ? 'js/[name].[contenthash:8].js' : 'js/[name].js',
+        chunkFilename: isEnvProduction
+            ? 'js/[name].[contenthash:8].chunk.js'
+            : 'js/[name].chunk.js',
+    };
+}
+function configureOutput({ isEnvDevelopment, ...rest }) {
+    return {
+        ...getFileNames({ isEnvDevelopment, ...rest }),
+        path: paths_1.default.appBuild,
+        pathinfo: isEnvDevelopment,
+        clean: false,
+    };
+}
+function createJavaScriptLoader({ isEnvProduction, isEnvDevelopment, configType, config, }) {
+    const plugins = [];
+    if (isEnvDevelopment && config.reactRefresh !== false) {
+        plugins.push([
+            require.resolve('react-refresh/babel'),
+            config.devServer?.webSocketPath
+                ? {
+                    overlay: {
+                        sockPath: config.devServer.webSocketPath,
+                    },
+                }
+                : undefined,
+        ]);
+    }
+    if (isEnvProduction) {
+        plugins.push([
+            require.resolve('babel-plugin-import'),
+            { libraryName: 'lodash', libraryDirectory: '', camel2DashComponentName: false },
+        ]);
+    }
+    const transformOptions = config.babel({
+        presets: [
+            (0, babel_1.babelPreset)({
+                newJsxTransform: config.newJsxTransform,
+                isSsr: false,
+            }),
+        ],
+        plugins,
+    }, { configType, isSsr: false });
+    return {
+        loader: require.resolve('babel-loader'),
+        options: {
+            sourceType: 'unambiguous',
+            ...transformOptions,
+            babelrc: false,
+            configFile: false,
+            compact: isEnvProduction,
+            sourceMaps: !config.disableSourceMapGeneration,
+            cacheCompression: isEnvProduction,
+            cacheDirectory: config.babelCacheDirectory ? config.babelCacheDirectory : true,
+        },
+    };
+}
+function createJavaScriptRule({ config, isEnvProduction }, jsLoader) {
+    const include = [
+        paths_1.default.appClient,
+        ...(config.monaco && isEnvProduction
+            ? [path.resolve(paths_1.default.appNodeModules, 'monaco-editor/esm/vs')]
+            : []),
+        ...(config.includes || []),
+    ];
+    return {
+        test: [/\.[jt]sx?$/, /\.[cm]js$/],
+        include,
+        use: jsLoader,
+    };
+}
+function createSourceMapRules(shouldUseSourceMap) {
+    if (shouldUseSourceMap) {
+        return [
+            {
+                test: [/\.jsx?$/, /\.[cm]js$/],
+                enforce: 'pre',
+                include: /node_modules/,
+                use: require.resolve('source-map-loader'),
+            },
+        ];
+    }
+    return [];
+}
+function createWorkerRule(options) {
+    return {
+        test: /\.worker\.[jt]sx?$/,
+        exclude: /node_modules/,
+        use: [
+            options.config.newWebWorkerSyntax
+                ? {
+                    loader: require.resolve('./worker/worker-loader'),
+                }
+                : {
+                    loader: require.resolve('worker-rspack-loader'),
+                    // currently workers located on cdn are not working properly, so we are enforcing loading workers from
+                    // service instead
+                    options: {
+                        inline: 'no-fallback',
+                    },
+                },
+            createJavaScriptLoader(options),
+        ],
+    };
+}
+function createSassStylesRule(options) {
+    const loaders = getCssLoaders(options, [
+        {
+            loader: require.resolve('resolve-url-loader'),
+            options: {
+                sourceMap: !options.config.disableSourceMapGeneration,
+            },
+        },
+        {
+            loader: require.resolve('sass-loader'),
+            options: {
+                sourceMap: true, // must be always true for work with resolve-url-loader
+                sassOptions: {
+                    loadPaths: [paths_1.default.appClient],
+                    silenceDeprecations: ['legacy-js-api', 'mixed-decls'],
+                },
+            },
+        },
+    ]);
+    return {
+        test: /\.scss$/,
+        sideEffects: options.isEnvProduction ? true : undefined,
+        use: loaders,
+    };
+}
+function createStylesRule(options) {
+    const loaders = getCssLoaders(options);
+    return {
+        test: /\.css$/,
+        sideEffects: options.isEnvProduction ? true : undefined,
+        use: loaders,
+    };
+}
+function getCssLoaders({ isEnvDevelopment, isEnvProduction, config }, additionalRules) {
+    const loaders = [];
+    if (!config.transformCssWithLightningCss) {
+        loaders.push({
+            loader: require.resolve('postcss-loader'),
+            options: {
+                sourceMap: !config.disableSourceMapGeneration,
+                postcssOptions: {
+                    config: false,
+                    plugins: [
+                        [require.resolve('postcss-preset-env'), { enableClientSidePolyfills: false }],
+                    ],
+                },
+            },
+        });
+    }
+    if (Array.isArray(additionalRules) && additionalRules.length > 0) {
+        loaders.push(...additionalRules);
+    }
+    const importLoaders = loaders.length;
+    loaders.unshift({
+        loader: require.resolve('css-loader'),
+        options: {
+            url: {
+                filter: (url) => {
+                    // ignore data uri
+                    return !url.startsWith('data:');
+                },
+            },
+            sourceMap: !config.disableSourceMapGeneration,
+            importLoaders,
+            modules: {
+                auto: true,
+                localIdentName: '[name]__[local]--[hash:base64:5]',
+                exportLocalsConvention: 'camelCase',
+                exportOnlyLocals: false,
+            },
+        },
+    });
+    if (isEnvProduction) {
+        loaders.unshift({ loader: core_1.CssExtractRspackPlugin.loader });
+    }
+    if (isEnvDevelopment) {
+        loaders.unshift({
+            loader: require.resolve('style-loader'),
+        });
+    }
+    return loaders;
+}
+function createIconsRule({ isEnvProduction, config }, jsLoader) {
+    const iconIncludes = config.icons || [];
+    return {
+        // eslint-disable-next-line security/detect-unsafe-regex
+        test: /\.svg(\?v=\d+\.\d+\.\d+)?$/,
+        // we can't use one rule with issuer: /\.[jt]sx?$/ cause of https://github.com/webpack/webpack/issues/9309
+        issuer: jsLoader ? undefined : /\.s?css$/,
+        include: [
+            /icons\/.*\.svg$/,
+            // eslint-disable-next-line security/detect-non-literal-regexp
+            ...iconIncludes.map((dir) => new RegExp(dir)),
+        ],
+        ...(jsLoader
+            ? {
+                use: [
+                    jsLoader,
+                    {
+                        loader: require.resolve('@svgr/webpack'),
+                        options: {
+                            babel: false,
+                            dimensions: false,
+                            jsxRuntime: config.newJsxTransform ? 'automatic' : 'classic',
+                            ...config.svgr,
+                        },
+                    },
+                ],
+            }
+            : {
+                type: 'asset',
+                parser: {
+                    dataUrlCondition: {
+                        maxSize: imagesSizeLimit,
+                    },
+                },
+                generator: {
+                    filename: 'assets/images/[name].[contenthash:8][ext]',
+                    publicPath: isEnvProduction ? '../' : undefined,
+                },
+            }),
+    };
+}
+function createAssetsRules({ isEnvProduction, config }) {
+    const imagesRule = {
+        test: /\.(ico|bmp|gif|jpe?g|png|svg)$/,
+        include: [paths_1.default.appClient, ...(config.images || [])],
+        type: 'asset',
+        parser: {
+            dataUrlCondition: {
+                maxSize: imagesSizeLimit,
+            },
+        },
+        generator: {
+            filename: 'assets/images/[name].[contenthash:8][ext]',
+        },
+    };
+    const fontsRule = {
+        test: /\.(ttf|eot|woff2?)$/,
+        include: [paths_1.default.appClient],
+        type: 'asset',
+        parser: {
+            dataUrlCondition: {
+                maxSize: fontSizeLimit,
+            },
+        },
+        generator: {
+            filename: 'assets/fonts/[name].[contenthash:8][ext]',
+        },
+    };
+    const rules = [imagesRule, fontsRule];
+    if (isEnvProduction) {
+        // with dynamic public path, imports from css files will look for assets in 'css/assets' directory
+        // we are enforcing loading them from 'assets'
+        rules.unshift({
+            test: /\.(ico|bmp|gif|jpe?g|png|svg)$/,
+            issuer: /\.s?css$/,
+            include: [paths_1.default.appClient, ...(config.images || [])],
+            type: 'asset',
+            parser: {
+                dataUrlCondition: {
+                    maxSize: imagesSizeLimit,
+                },
+            },
+            generator: {
+                filename: 'assets/images/[name].[contenthash:8][ext]',
+                publicPath: '../',
+            },
+        }, {
+            test: /\.(ttf|eot|woff2?)$/,
+            issuer: /\.s?css$/,
+            include: [paths_1.default.appClient],
+            type: 'asset',
+            parser: {
+                dataUrlCondition: {
+                    maxSize: fontSizeLimit,
+                },
+            },
+            generator: {
+                filename: 'assets/fonts/[name].[contenthash:8][ext]',
+                publicPath: '../',
+            },
+        });
+    }
+    return rules;
+}
+function createFallbackRules({ isEnvProduction }) {
+    const rules = [
+        {
+            type: 'asset/resource',
+            generator: {
+                filename: 'assets/[name].[contenthash:8][ext]',
+            },
+            exclude: [/\.[jt]sx?$/, /\.json$/, /\.[cm]js$/, /\.ejs$/],
+        },
+    ];
+    if (isEnvProduction) {
+        // with dynamic public path, imports from css files will look for assets in 'css/assets' directory
+        // we are enforcing loading them from 'assets'
+        rules.unshift({
+            test: /\.(ttf|eot|woff2?|bmp|gif|jpe?g|png|svg)$/,
+            issuer: /\.s?css$/,
+            type: 'asset/resource',
+            generator: {
+                filename: 'assets/[name].[contenthash:8][ext]',
+                publicPath: '../',
+            },
+        });
+    }
+    return rules;
+}
+/*
+TODO
+function createMomentTimezoneDataPlugin(options: NormalizedClientConfig['momentTz'] = {}) {
+    const currentYear = new Date().getFullYear();
+    // By default get data for current year only
+    // https://momentjs.com/timezone/docs/#/use-it/webpack/
+    const startYear = options.startYear ?? currentYear;
+    const endYear = options.endYear ?? currentYear;
+
+    return new MomentTimezoneDataPlugin({...options, startYear, endYear});
+}
+*/
+function configurePlugins(options) {
+    const { isEnvDevelopment, isEnvProduction, config } = options;
+    const excludeFromClean = config.excludeFromClean || [];
+    const manifestFile = 'assets-manifest.json';
+    const plugins = [
+        new clean_webpack_plugin_1.CleanWebpackPlugin({
+            verbose: config.verbose,
+            cleanOnceBeforeBuildPatterns: [
+                '**/*',
+                ...(isEnvDevelopment ? ['!manifest.json'] : []),
+                ...excludeFromClean,
+            ],
+        }),
+        /*
+        new RspackManifestPlugin({
+            writeToFileEmit: true,
+            publicPath: '',
+        }),
+        */
+        new rspack_manifest_plugin_1.RspackManifestPlugin({
+            fileName: isEnvProduction ? manifestFile : path.resolve(paths_1.default.appBuild, manifestFile),
+            writeToFileEmit: true,
+            useLegacyEmit: true,
+            publicPath: '',
+            generate: exports.generateManifest,
+        }),
+        new core_1.rspack.DefinePlugin({
+            'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV),
+            ...config.definitions,
+        }),
+    ];
+    if (options.logger) {
+        plugins.push(new progress_plugin_1.ProgressPlugin({ logger: options.logger }));
+    }
+    // TODO use rspack tracing
+    // if (process.env.WEBPACK_PROFILE === 'true') {
+    //     plugins.push(new webpack.debug.ProfilingPlugin());
+    // }
+    if (config.forkTsChecker !== false) {
+        plugins.push(new ts_checker_rspack_plugin_1.TsCheckerRspackPlugin({
+            ...config.forkTsChecker,
+            typescript: {
+                typescriptPath: (0, utils_1.resolveTypescript)(),
+                configFile: path.resolve(paths_1.default.appClient, 'tsconfig.json'),
+                diagnosticOptions: {
+                    syntactic: true,
+                },
+                mode: 'write-references',
+                ...config.forkTsChecker?.typescript,
+            },
+        }));
+    }
+    if (config.detectCircularDependencies) {
+        let circularPluginOptions = {
+            exclude: /node_modules/,
+            allowAsyncCycles: true,
+        };
+        if (typeof config.detectCircularDependencies === 'object') {
+            circularPluginOptions = config.detectCircularDependencies;
+        }
+        plugins.push(new circular_dependency_plugin_1.default(circularPluginOptions));
+    }
+    if (isEnvProduction) {
+        if (config.analyzeBundle === 'true') {
+            plugins.push(new webpack_bundle_analyzer_1.BundleAnalyzerPlugin({
+                openAnalyzer: false,
+                analyzerMode: 'static',
+                reportFilename: 'stats.html',
+            }));
+        }
+    }
+    if (config.monaco) {
+        const MonacoEditorWebpackPlugin = require('monaco-editor-webpack-plugin');
+        plugins.push(new MonacoEditorWebpackPlugin({
+            filename: isEnvProduction ? '[name].[hash:8].worker.js' : undefined,
+            ...config.monaco,
+            // currently, workers located on cdn are not working properly, so we are enforcing loading workers from
+            // service instead
+            publicPath: path.normalize(config.publicPathPrefix + '/build/'),
+        }));
+    }
+    const contextReplacement = config.contextReplacement || {};
+    //plugins.push(createMomentTimezoneDataPlugin(config.momentTz));
+    plugins.push(new core_1.ContextReplacementPlugin(/moment[\\/]locale$/, 
+    // eslint-disable-next-line security/detect-non-literal-regexp
+    new RegExp(`^\\./(${(contextReplacement.locale || ['ru']).join('|')})$`)));
+    plugins.push(new core_1.ContextReplacementPlugin(/dayjs[\\/]locale$/, 
+    // eslint-disable-next-line security/detect-non-literal-regexp
+    new RegExp(`^\\./(${(contextReplacement.locale || ['ru']).join('|')})\\.js$`)));
+    if (contextReplacement['highlight.js']) {
+        plugins.push(new core_1.ContextReplacementPlugin(/highlight\.js[\\/]lib[\\/]languages$/, 
+        // eslint-disable-next-line security/detect-non-literal-regexp
+        new RegExp(`^\\./(${contextReplacement['highlight.js'].join('|')})$`)));
+    }
+    if (isEnvDevelopment && config.reactRefresh !== false) {
+        const { webSocketPath = path.normalize(`/${config.publicPathPrefix}/build/sockjs-node`) } = config.devServer || {};
+        const { overlay, ...reactRefreshConfig } = config.reactRefresh({
+            overlay: { sockPath: webSocketPath },
+            exclude: [/node_modules/, /\.worker\.[jt]sx?$/],
+        });
+        plugins.push(new plugin_react_refresh_1.default({
+            ...reactRefreshConfig,
+            overlay: typeof overlay === 'object'
+                ? {
+                    entry: typeof overlay.entry === 'string' ? overlay.entry : undefined,
+                    module: typeof overlay.module === 'string' ? overlay.module : undefined,
+                    sockPath: overlay.sockPath,
+                    sockHost: overlay.sockHost,
+                    sockPort: overlay.sockPort?.toString(),
+                    sockProtocol: overlay.sockProtocol,
+                    sockIntegration: overlay.sockIntegration === 'wds' ? 'wds' : undefined,
+                }
+                : undefined,
+        }));
+    }
+    if (config.polyfill?.process) {
+        plugins.push(new core_1.rspack.ProvidePlugin({ process: 'process/browser.js' }));
+    }
+    if (isEnvProduction) {
+        plugins.push(new core_1.CssExtractRspackPlugin({
+            filename: 'css/[name].[contenthash:8].css',
+            chunkFilename: 'css/[name].[contenthash:8].chunk.css',
+            ignoreOrder: true,
+        }));
+        if (config.sentryConfig) {
+            const sentryPlugin = require('@sentry/webpack-plugin').sentryWebpackPlugin;
+            plugins.push(sentryPlugin({ ...config.sentryConfig }));
+        }
+    }
+    if (config.cdn) {
+        plugins.push(...(0, s3_upload_1.createS3UploadPlugins)(config, options.logger));
+    }
+    return plugins;
+}
+function configureOptimization({ config }) {
+    const configVendors = config.vendors ?? [];
+    let vendorsList = [
+        'react',
+        'react-dom',
+        'prop-types',
+        'redux',
+        'react-redux',
+        '@reduxjs/toolkit',
+        'lodash',
+        'lodash-es',
+        'moment',
+        'bem-cn-lite',
+        'axios',
+    ];
+    if (typeof configVendors === 'function') {
+        vendorsList = configVendors(vendorsList);
+    }
+    else if (Array.isArray(configVendors)) {
+        vendorsList = vendorsList.concat(configVendors);
+    }
+    const useVendorsList = vendorsList.length > 0;
+    const optimization = {
+        splitChunks: {
+            chunks: 'all',
+            cacheGroups: {
+                ...(useVendorsList
+                    ? {
+                        defaultVendors: {
+                            name: 'vendors',
+                            // eslint-disable-next-line security/detect-non-literal-regexp
+                            test: new RegExp(`([\\\\/])node_modules\\1(${vendorsList.join('|')})\\1`),
+                            priority: Infinity,
+                        },
+                    }
+                    : undefined),
+                css: {
+                    type: 'css/mini-extract',
+                    enforce: true,
+                    minChunks: 2,
+                    reuseExistingChunk: true,
+                },
+            },
+        },
+        runtimeChunk: 'single',
+        minimizer: [
+            new core_1.rspack.SwcJsMinimizerRspackPlugin({
+                minimizerOptions: {
+                    mangle: !config.reactProfiling,
+                    compress: {
+                        passes: 2,
+                    },
+                    format: {
+                        safari10: config.safari10,
+                    },
+                },
+            }),
+            new core_1.rspack.LightningCssMinimizerRspackPlugin({
+                minimizerOptions: {
+                    // Plugin will read the browserslist itself and generate targets
+                    targets: [],
+                },
+            }),
+        ],
+    };
+    return optimization;
+}