@gravity-ui/app-builder 0.0.1

package/dist/common/webpack/config.js

@@ -0,0 +1,662 @@
+"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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureResolve = exports.configureModuleRules = exports.webpackConfigFactory = void 0;
+/* eslint-disable complexity */
+const path_1 = __importStar(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const webpack = __importStar(require("webpack"));
+const lodash_1 = __importDefault(require("lodash"));
+const clean_webpack_plugin_1 = require("clean-webpack-plugin");
+const webpack_manifest_plugin_1 = require("webpack-manifest-plugin");
+const fork_ts_checker_webpack_plugin_1 = __importDefault(require("fork-ts-checker-webpack-plugin"));
+const mini_css_extract_plugin_1 = __importDefault(require("mini-css-extract-plugin"));
+const css_minimizer_webpack_plugin_1 = __importDefault(require("css-minimizer-webpack-plugin"));
+const webpack_bundle_analyzer_1 = require("webpack-bundle-analyzer");
+const postcss_preset_env_1 = __importDefault(require("postcss-preset-env"));
+const webpack_assets_manifest_1 = __importDefault(require("webpack-assets-manifest"));
+const react_refresh_webpack_plugin_1 = __importDefault(require("@pmmmwh/react-refresh-webpack-plugin"));
+const moment_timezone_data_webpack_plugin_1 = __importDefault(require("moment-timezone-data-webpack-plugin"));
+const webpack_plugin_1 = __importDefault(require("@statoscope/webpack-plugin"));
+const circular_dependency_plugin_1 = __importDefault(require("circular-dependency-plugin"));
+const paths_1 = __importDefault(require("../paths"));
+const tempData_1 = __importDefault(require("../tempData"));
+const babel_1 = require("../babel");
+const progress_plugin_1 = require("./progress-plugin");
+const utils_1 = require("./utils");
+const s3_upload_1 = require("../s3-upload");
+const imagesSizeLimit = 2048;
+const fontSizeLimit = 8192;
+function webpackConfigFactory(webpackMode, config, { logger } = {}) {
+    const isEnvDevelopment = webpackMode === "development" /* WebpackMode.Dev */;
+    const isEnvProduction = webpackMode === "production" /* WebpackMode.Prod */;
+    const { updateIncludes, tsLinkedPackages } = updateIncludesFactory();
+    const helperOptions = {
+        config,
+        logger,
+        isEnvDevelopment,
+        isEnvProduction,
+        updateIncludes,
+        tsLinkedPackages,
+    };
+    return {
+        mode: webpackMode,
+        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),
+        externals: config.externals,
+        node: config.node,
+        watchOptions: config.watchOptions,
+        ignoreWarnings: [/Failed to parse source map/],
+        infrastructureLogging: config.verbose
+            ? {
+                colors: true,
+                level: 'verbose',
+            }
+            : undefined,
+        experiments: isEnvDevelopment
+            ? {
+                lazyCompilation: config.lazyCompilation
+                    ? {
+                        backend: {
+                            client: require.resolve('./lazy-client.js'),
+                            listen: config.lazyCompilation,
+                        },
+                    }
+                    : undefined,
+            }
+            : undefined,
+    };
+}
+exports.webpackConfigFactory = webpackConfigFactory;
+function configureModuleRules(helperOptions) {
+    const jsLoader = createJavaScriptLoader(helperOptions);
+    return [
+        ...createSourceMapRules(!helperOptions.config.disableSourceMapGeneration),
+        {
+            oneOf: [
+                createWorkerRule(helperOptions),
+                createJavaScriptRule(helperOptions, jsLoader),
+                createStylesRule(helperOptions),
+                createIconsRule(helperOptions),
+                createIconsRule(helperOptions, jsLoader),
+                ...createAssetsRules(helperOptions),
+                ...createFallbackRules(helperOptions),
+            ],
+        },
+    ];
+}
+exports.configureModuleRules = configureModuleRules;
+function updateIncludesFactory() {
+    const { linkedPackages } = tempData_1.default.getSettings();
+    const linkedPackagesArr = linkedPackages
+        ? linkedPackages.keys.map((key) => linkedPackages.data[key])
+        : [];
+    if (linkedPackagesArr.length === 0) {
+        return {};
+    }
+    const tsLinkedPackages = linkedPackagesArr.filter(({ typescript }) => typescript);
+    const linkedPackagesJsIncludes = linkedPackagesArr.map((data) => `${data.package}/src`);
+    const linkedPackagesRootAssetsIncludes = linkedPackagesArr.map((data) => `${data.package}/assets`);
+    const linkedPackagesRootStylesIncludes = linkedPackagesArr.map((data) => `${data.package}/styles`);
+    return {
+        updateIncludes: (includes, options) => {
+            let result = includes.filter((pathname) => lodash_1.default.every(linkedPackagesArr, (linkedPackage) => 
+            // eslint-disable-next-line security/detect-non-literal-regexp
+            !new RegExp(linkedPackage.name).test(pathname)));
+            result = [...result, ...linkedPackagesJsIncludes];
+            if (options === null || options === void 0 ? void 0 : options.includeRootAssets) {
+                result = [...result, ...linkedPackagesRootAssetsIncludes];
+            }
+            if (options === null || options === void 0 ? void 0 : options.includeRootStyles) {
+                result = [...result, ...linkedPackagesRootStylesIncludes];
+            }
+            return result;
+        },
+        tsLinkedPackages,
+    };
+}
+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 configureResolve({ isEnvProduction, config, tsLinkedPackages, }) {
+    let alias = config.alias || {};
+    alias = Object.entries(alias).reduce((result, [key, value]) => {
+        result[key] = path_1.default.resolve(paths_1.default.app, value);
+        return result;
+    }, {});
+    if (isEnvProduction && config.reactProfiling) {
+        alias['react-dom$'] = 'react-dom/profiling';
+        alias['scheduler/tracing'] = 'scheduler/tracing-profiling';
+    }
+    if (tsLinkedPackages) {
+        tsLinkedPackages.forEach(({ name }) => {
+            alias[`${name}$`] = `${name}/src`;
+        });
+    }
+    const { aliases, modules = [] } = (0, utils_1.resolveTsconfigPathsToAlias)(path_1.default.resolve(paths_1.default.appClient, 'tsconfig.json')) || {};
+    return {
+        alias: Object.assign(Object.assign({}, aliases), alias),
+        modules: ['node_modules', ...modules, ...(config.modules || [])],
+        extensions: ['.mjs', '.cjs', '.js', '.jsx', '.ts', '.tsx', '.json'],
+        symlinks: config.symlinks || false,
+        fallback: config.fallback,
+    };
+}
+exports.configureResolve = configureResolve;
+function createEntryArray(entry) {
+    return [require.resolve('./public-path'), entry];
+}
+function addEntry(entry, file) {
+    const newEntry = path_1.default.resolve(paths_1.default.appEntry, file);
+    return Object.assign(Object.assign({}, entry), { [path_1.default.parse(file).name]: createEntryArray(newEntry) });
+}
+function configureEntry({ config }) {
+    let entries = fs_1.default.readdirSync(paths_1.default.appEntry).filter((file) => /\.[jt]sx?$/.test(file));
+    if (Array.isArray(config.entryFilter) && config.entryFilter.length) {
+        entries = entries.filter((entry) => { var _a, _b; return (_a = config.entryFilter) === null || _a === void 0 ? void 0 : _a.includes((_b = entry.split('.')[0]) !== null && _b !== void 0 ? _b : ''); });
+    }
+    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(_a) {
+    var { isEnvDevelopment } = _a, rest = __rest(_a, ["isEnvDevelopment"]);
+    return Object.assign(Object.assign({}, getFileNames(Object.assign({ isEnvDevelopment }, rest))), { path: paths_1.default.appBuild, pathinfo: isEnvDevelopment });
+}
+function createJavaScriptLoader({ isEnvProduction, isEnvDevelopment, config, }) {
+    var _a;
+    return {
+        loader: require.resolve('babel-loader'),
+        options: {
+            babelrc: false,
+            configFile: false,
+            presets: [(0, babel_1.babelPreset)(config)],
+            plugins: [
+                isEnvDevelopment &&
+                    !config.disableReactRefresh && [
+                    require.resolve('react-refresh/babel'),
+                    ((_a = config.devServer) === null || _a === void 0 ? void 0 : _a.webSocketPath)
+                        ? {
+                            overlay: {
+                                sockPath: config.devServer.webSocketPath,
+                            },
+                        }
+                        : undefined,
+                ],
+                isEnvProduction && require.resolve('babel-plugin-lodash'),
+            ].filter(Boolean),
+            sourceType: 'unambiguous',
+            cacheDirectory: true,
+            cacheCompression: isEnvProduction,
+            compact: isEnvProduction,
+            sourceMap: !config.disableSourceMapGeneration,
+        },
+    };
+}
+function createJavaScriptRule({ updateIncludes = lodash_1.default.identity, config, isEnvProduction }, jsLoader) {
+    const include = updateIncludes([
+        paths_1.default.appClient,
+        ...(config.monaco && isEnvProduction
+            ? [path_1.default.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: [
+            {
+                loader: require.resolve('worker-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 createStylesRule({ isEnvDevelopment, isEnvProduction, config, }) {
+    const loaders = [];
+    if (isEnvProduction) {
+        loaders.push(mini_css_extract_plugin_1.default.loader);
+    }
+    if (isEnvDevelopment) {
+        loaders.push({
+            loader: require.resolve('style-loader'),
+        });
+    }
+    loaders.push({
+        loader: require.resolve('css-loader'),
+        options: {
+            esModule: false,
+            sourceMap: !config.disableSourceMapGeneration,
+            importLoaders: 2,
+        },
+    });
+    loaders.push({
+        loader: require.resolve('postcss-loader'),
+        options: {
+            sourceMap: !config.disableSourceMapGeneration,
+            postcssOptions: {
+                config: false,
+                plugins: [(0, postcss_preset_env_1.default)()],
+            },
+        },
+    });
+    loaders.push({
+        loader: require.resolve('resolve-url-loader'),
+        options: {
+            sourceMap: !config.disableSourceMapGeneration,
+        },
+    });
+    loaders.push({
+        loader: require.resolve('sass-loader'),
+        options: {
+            sourceMap: true,
+            sassOptions: {
+                includePaths: [paths_1.default.appClient],
+            },
+        },
+    });
+    return {
+        test: /\.s?css$/,
+        sideEffects: isEnvProduction ? true : undefined,
+        use: loaders,
+    };
+}
+function createIconsRule({ isEnvProduction, config }, jsLoader) {
+    const iconIncludes = config.icons || [];
+    return Object.assign({ 
+        // 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: Object.assign({ babel: false, dimensions: false }, config.svgr),
+                },
+            ],
+        }
+        : {
+            type: 'asset',
+            parser: {
+                dataUrlCondition: {
+                    maxSize: imagesSizeLimit,
+                },
+            },
+            generator: {
+                filename: 'assets/images/[name].[contenthash:8][ext]',
+                publicPath: isEnvProduction ? '../' : undefined,
+            },
+        }));
+}
+function createAssetsRules({ updateIncludes = lodash_1.default.identity, isEnvProduction, config, }) {
+    const imagesRule = {
+        test: /\.(ico|bmp|gif|jpe?g|png|svg)$/,
+        include: updateIncludes([paths_1.default.appClient, ...(config.images || [])], {
+            includeRootAssets: true,
+        }),
+        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: updateIncludes([paths_1.default.appClient, ...(config.images || [])], {
+                includeRootAssets: true,
+            }),
+            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;
+}
+function createMomentTimezoneDataPlugin(options = {}) {
+    var _a, _b;
+    const currentYear = new Date().getFullYear();
+    // By default get data for current year only
+    // https://momentjs.com/timezone/docs/#/use-it/webpack/
+    const startYear = (_a = options.startYear) !== null && _a !== void 0 ? _a : currentYear;
+    const endYear = (_b = options.endYear) !== null && _b !== void 0 ? _b : currentYear;
+    return new moment_timezone_data_webpack_plugin_1.default(Object.assign(Object.assign({}, options), { startYear, endYear }));
+}
+function configurePlugins(options) {
+    var _a;
+    const { isEnvDevelopment, isEnvProduction, config } = options;
+    const excludeFromClean = config.excludeFromClean || [];
+    const plugins = [
+        new clean_webpack_plugin_1.CleanWebpackPlugin({
+            cleanOnceBeforeBuildPatterns: [
+                '**/*',
+                ...(isEnvDevelopment ? ['!manifest.json'] : []),
+                ...excludeFromClean,
+            ],
+        }),
+        new webpack_manifest_plugin_1.WebpackManifestPlugin({
+            writeToFileEmit: true,
+            publicPath: '',
+        }),
+        createMomentTimezoneDataPlugin(config.momentTz),
+        new webpack.DefinePlugin(Object.assign({ '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 }));
+    }
+    if (process.env.WEBPACK_PROFILE === 'true') {
+        plugins.push(new webpack.debug.ProfilingPlugin());
+    }
+    const contextReplacement = config.contextReplacement || {};
+    plugins.push(new webpack.ContextReplacementPlugin(/moment[\\/]locale$/, 
+    // eslint-disable-next-line security/detect-non-literal-regexp
+    new RegExp(`^\\./(${(contextReplacement.moment || ['ru']).join('|')})$`)));
+    if (contextReplacement['highlight.js']) {
+        plugins.push(new webpack.ContextReplacementPlugin(/highlight\.js[\\/]lib[\\/]languages$/, 
+        // eslint-disable-next-line security/detect-non-literal-regexp
+        new RegExp(`^\\./(${contextReplacement['highlight.js'].join('|')})$`)));
+    }
+    if (config.monaco) {
+        const MonacoEditorWebpackPlugin = require('monaco-editor-webpack-plugin');
+        plugins.push(new MonacoEditorWebpackPlugin(Object.assign(Object.assign({}, config.monaco), { 
+            // currently, workers located on cdn are not working properly, so we are enforcing loading workers from
+            // service instead
+            publicPath: path_1.default.normalize(config.publicPathPrefix + '/build/') })));
+    }
+    if (isEnvDevelopment && !config.disableReactRefresh) {
+        plugins.push(new react_refresh_webpack_plugin_1.default());
+    }
+    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 (!config.disableForkTsChecker) {
+        plugins.push(new fork_ts_checker_webpack_plugin_1.default({
+            typescript: {
+                typescriptPath: require.resolve((0, path_1.resolve)(paths_1.default.appNodeModules, 'typescript')),
+                configFile: (0, path_1.resolve)(paths_1.default.app, 'src/ui/tsconfig.json'),
+                diagnosticOptions: {
+                    syntactic: true,
+                },
+                mode: 'write-references',
+            },
+        }));
+    }
+    if ((_a = config.polyfill) === null || _a === void 0 ? void 0 : _a.process) {
+        plugins.push(new webpack.ProvidePlugin({ process: 'process/browser.js' }));
+    }
+    if (isEnvProduction) {
+        plugins.push(new mini_css_extract_plugin_1.default({
+            filename: 'css/[name].[contenthash:8].css',
+            chunkFilename: 'css/[name].[contenthash:8].chunk.css',
+            ignoreOrder: true,
+        }));
+        plugins.push(new css_minimizer_webpack_plugin_1.default({
+            minimizerOptions: {
+                preset: [
+                    'default',
+                    {
+                        svgo: false,
+                    },
+                ],
+            },
+        }));
+        if (config.analyzeBundle === 'true') {
+            plugins.push(new webpack_bundle_analyzer_1.BundleAnalyzerPlugin({
+                openAnalyzer: false,
+                analyzerMode: 'static',
+                reportFilename: 'stats.html',
+            }));
+        }
+        if (config.analyzeBundle === 'statoscope') {
+            plugins.push(new webpack_plugin_1.default({
+                saveReportTo: path_1.default.resolve(paths_1.default.appBuild, 'report.html'),
+                saveStatsTo: path_1.default.resolve(paths_1.default.appBuild, 'stats.json'),
+                open: false,
+                statsOptions: {
+                    all: true,
+                },
+            }));
+        }
+    }
+    const manifestFile = 'assets-manifest.json';
+    plugins.push(new webpack_assets_manifest_1.default(isEnvProduction
+        ? {
+            entrypoints: true,
+            output: manifestFile,
+        }
+        : {
+            entrypoints: true,
+            writeToDisk: true,
+            output: path_1.default.resolve(paths_1.default.appBuild, manifestFile),
+        }));
+    if (config.cdn) {
+        let credentials;
+        if (process.env.FRONTEND_S3_ACCESS_KEY_ID && process.env.FRONTEND_S3_SECRET_ACCESS_KEY) {
+            credentials = {
+                accessKeyId: process.env.FRONTEND_S3_ACCESS_KEY_ID,
+                secretAccessKey: process.env.FRONTEND_S3_SECRET_ACCESS_KEY,
+            };
+        }
+        plugins.push(new s3_upload_1.S3UploadPlugin({
+            exclude: config.hiddenSourceMap ? /\.map$/ : undefined,
+            compress: config.cdn.compress,
+            s3ClientOptions: {
+                region: config.cdn.region,
+                endpoint: config.cdn.endpoint,
+                credentials,
+            },
+            s3UploadOptions: {
+                bucket: config.cdn.bucket,
+                targetPath: config.cdn.prefix,
+            },
+        }));
+    }
+    return plugins;
+}
+function configureOptimization({ isEnvProduction, config, }) {
+    var _a;
+    const configVendors = (_a = config.vendors) !== null && _a !== void 0 ? _a : [];
+    const vendorsList = [
+        'react',
+        'react-dom',
+        'prop-types',
+        'redux',
+        'react-redux',
+        '@reduxjs/toolkit',
+        'lodash',
+        'lodash-es',
+        'moment',
+        'bem-cn-lite',
+        'axios',
+        ...configVendors,
+    ];
+    const optimization = {
+        minimize: isEnvProduction && !config.reactProfiling,
+        splitChunks: {
+            chunks: 'all',
+            cacheGroups: {
+                defaultVendors: {
+                    name: 'vendors',
+                    // eslint-disable-next-line security/detect-non-literal-regexp
+                    test: new RegExp(`([\\\\/])node_modules\\1(${vendorsList.join('|')})\\1`),
+                    priority: Infinity,
+                },
+            },
+        },
+        runtimeChunk: 'single',
+    };
+    if (config.safari10) {
+        const TerserPlugin = require('terser-webpack-plugin');
+        optimization.minimizer = [
+            new TerserPlugin({
+                terserOptions: {
+                    safari10: true,
+                },
+            }),
+        ];
+    }
+    return optimization;
+}

package/dist/common/webpack/progress-plugin.d.ts

@@ -0,0 +1,11 @@
+import * as webpack from 'webpack';
+import type { Logger } from '../logger';
+export declare class ProgressPlugin extends webpack.ProgressPlugin {
+    private _logger;
+    private _state;
+    constructor({ logger }: {
+        logger: Logger;
+    });
+    handler: (percent: number, message: string, ...details: string[]) => void;
+    apply(compiler: webpack.Compiler): void;
+}