@gravity-ui/app-builder 0.15.0 → 0.15.1-beta.1

package/dist/commands/dev/client.d.ts

@@ -1,3 +1,4 @@
 import WebpackDevServer from 'webpack-dev-server';
+import { RspackDevServer } from '@rspack/dev-server';
 import type { NormalizedServiceConfig } from '../../common/models';
-export declare function watchClientCompilation(config: NormalizedServiceConfig, onManifestReady: () => void): Promise<WebpackDevServer<import("express").Application, import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>>>;
+export declare function watchClientCompilation(config: NormalizedServiceConfig, onManifestReady: () => void): Promise<WebpackDevServer<import("express").Application, import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>> | RspackDevServer>;

package/dist/commands/dev/client.js

@@ -34,9 +34,13 @@ const webpack_dev_server_1 = __importDefault(require("webpack-dev-server"));
 const webpack_manifest_plugin_1 = require("webpack-manifest-plugin");
 const webpack_assets_manifest_1 = __importDefault(require("webpack-assets-manifest"));
 const utils_1 = require("../../common/utils");
+const rspack_manifest_plugin_1 = require("rspack-manifest-plugin");
+const core_1 = require("@rspack/core");
+const dev_server_1 = require("@rspack/dev-server");
 const paths_1 = __importDefault(require("../../common/paths"));
 const logger_1 = require("../../common/logger");
 const config_1 = require("../../common/webpack/config");
+const rspack_1 = require("../../common/webpack/rspack");
 async function watchClientCompilation(config, onManifestReady) {
     const clientCompilation = await buildDevServer(config);
     const compiler = clientCompilation.compiler;
@@ -44,19 +48,42 @@ async function watchClientCompilation(config, onManifestReady) {
     return clientCompilation;
 }
 async function buildDevServer(config) {
+    const bundler = config.client.bundler;
     const logger = new logger_1.Logger('client', config.verbose);
     const { webSocketPath = path.normalize(`/${config.client.publicPathPrefix}/build/sockjs-node`), writeToDisk, ...devServer } = config.client.devServer || {};
     const normalizedConfig = { ...config.client, devServer: { ...devServer, webSocketPath } };
-    const webpackConfigs = [
-        await (0, config_1.webpackConfigFactory)("development" /* WebpackMode.Dev */, normalizedConfig, { logger }),
-    ];
     const isSsr = Boolean(normalizedConfig.ssr);
-    if (isSsr) {
-        const ssrLogger = new logger_1.Logger('client(SSR)', config.verbose);
-        webpackConfigs.push(await (0, config_1.webpackConfigFactory)("development" /* WebpackMode.Dev */, normalizedConfig, {
-            logger: ssrLogger,
-            isSsr,
-        }));
+    let webpackConfigs = [];
+    let rspackConfigs = [];
+    if (bundler === 'webpack') {
+        webpackConfigs = [
+            await (0, config_1.webpackConfigFactory)({
+                webpackMode: "development" /* WebpackMode.Dev */,
+                config: normalizedConfig,
+                logger,
+            }),
+        ];
+        if (isSsr) {
+            const ssrLogger = new logger_1.Logger('webpack(SSR)', config.verbose);
+            webpackConfigs.push(await (0, config_1.webpackConfigFactory)({
+                webpackMode: "development" /* WebpackMode.Dev */,
+                config: normalizedConfig,
+                logger: ssrLogger,
+                isSsr,
+            }));
+        }
+    }
+    else {
+        if (isSsr) {
+            throw new Error(`SSR is not supported in ${bundler}`);
+        }
+        rspackConfigs = [
+            await (0, config_1.rspackConfigFactory)({
+                webpackMode: "development" /* WebpackMode.Dev */,
+                config: normalizedConfig,
+                logger,
+            }),
+        ];
     }
     const publicPath = path.normalize(config.client.publicPathPrefix + '/build/');
     const staticFolder = path.resolve(paths_1.default.appDist, 'public');
@@ -134,41 +161,60 @@ async function buildDevServer(config) {
         });
     }
     options.proxy = proxy;
-    const compiler = (0, webpack_1.default)(webpackConfigs);
-    const server = new webpack_dev_server_1.default(options, compiler);
+    let server;
+    if (bundler === 'rspack') {
+        // Rspack multicompiler dont work with lazy compilation
+        const compiler = (0, core_1.rspack)(rspackConfigs[0]);
+        server = new dev_server_1.RspackDevServer(options, compiler);
+        // Need to clean cache before start. https://github.com/web-infra-dev/rspack/issues/9025
+        (0, rspack_1.clearCacheDirectory)(rspackConfigs[0], logger);
+    }
+    else {
+        const compiler = (0, webpack_1.default)(webpackConfigs);
+        server = new webpack_dev_server_1.default(options, compiler);
+    }
     try {
         await server.start();
     }
     catch (e) {
-        logger.logError('Cannot start webpack dev server', e);
+        logger.logError(`Cannot start ${bundler} dev server`, e);
     }
     if (options.ipc && typeof options.ipc === 'string') {
         fs.chmod(options.ipc, 0o666, (e) => logger.logError('', e));
     }
     return server;
 }
-function subscribeToManifestReadyEvent(webpackCompiler, onManifestReady) {
+function isRspackCompiler(compiler) {
+    return 'rspack' in compiler;
+}
+function subscribeToManifestReadyEvent(compiler, onManifestReady) {
     const promises = [];
-    const options = Array.isArray(webpackCompiler.options)
-        ? webpackCompiler.options
-        : [webpackCompiler.options];
-    const compilers = 'compilers' in webpackCompiler ? webpackCompiler.compilers : [webpackCompiler];
+    const options = Array.isArray(compiler.options) ? compiler.options : [compiler.options];
+    const compilers = 'compilers' in compiler ? compiler.compilers : [compiler];
     for (let i = 0; i < options.length; i++) {
         const config = options[i];
         const compiler = compilers[i];
         if (!config || !compiler) {
             throw new Error('Something goes wrong!');
         }
-        const assetsManifestPlugin = config.plugins.find((plugin) => plugin instanceof webpack_assets_manifest_1.default);
-        if (assetsManifestPlugin) {
-            const assetsManifestReady = (0, utils_1.deferredPromise)();
-            promises.push(assetsManifestReady.promise);
-            assetsManifestPlugin.hooks.done.tap('app-builder', assetsManifestReady.resolve);
+        if (!isRspackCompiler(compiler)) {
+            const assetsManifestPlugin = config.plugins.find((plugin) => plugin instanceof webpack_assets_manifest_1.default);
+            if (assetsManifestPlugin) {
+                const assetsManifestReady = (0, utils_1.deferredPromise)();
+                promises.push(assetsManifestReady.promise);
+                assetsManifestPlugin.hooks.done.tap('app-builder', assetsManifestReady.resolve);
+            }
         }
         const manifestReady = (0, utils_1.deferredPromise)();
         promises.push(manifestReady.promise);
-        const { afterEmit } = (0, webpack_manifest_plugin_1.getCompilerHooks)(compiler);
-        afterEmit.tap('app-builder', manifestReady.resolve);
+        if (isRspackCompiler(compiler)) {
+            const { afterEmit } = (0, rspack_manifest_plugin_1.getCompilerHooks)(compiler);
+            afterEmit.tap('app-builder', manifestReady.resolve);
+        }
+        else {
+            const { afterEmit } = (0, webpack_manifest_plugin_1.getCompilerHooks)(compiler);
+            afterEmit.tap('app-builder', manifestReady.resolve);
+        }
     }
     Promise.all(promises).then(() => onManifestReady());
 }

package/dist/common/config.js

@@ -197,9 +197,11 @@ async function normalizeClientConfig(client, mode) {
         svgr: client.svgr ?? {},
         entryFilter: client.entryFilter && splitPaths(client.entryFilter),
         webpack: typeof client.webpack === 'function' ? client.webpack : (config) => config,
+        rspack: typeof client.rspack === 'function' ? client.rspack : (config) => config,
         babel: typeof client.babel === 'function' ? client.babel : (config) => config,
         devServer: undefined,
         lazyCompilation: undefined,
+        bundler: client.bundler || 'webpack',
     };
     if (mode === 'dev') {
         if (client.lazyCompilation) {

package/dist/common/library/index.js

@@ -129,6 +129,7 @@ function compileStyles(inputDir, outputDir, onFinish, additionalGlobs = []) {
                 const sassTransformed = sass_1.default.compile(scssFile, {
                     sourceMap: true,
                     sourceMapIncludeSources: true,
+                    silenceDeprecations: ['legacy-js-api'],
                     importers: [
                         {
                             findFileUrl(url) {

package/dist/common/models/index.d.ts

@@ -3,6 +3,7 @@ import type { EditorFeature } from 'monaco-editor-webpack-plugin/out/features';
 import type { IFeatureDefinition } from 'monaco-editor-webpack-plugin/out/types';
 import type { Options as MomentTzOptions } from 'moment-timezone-data-webpack-plugin';
 import type { Configuration, DefinePlugin, FileCacheOptions, MemoryCacheOptions, ResolveOptions } from 'webpack';
+import type { Configuration as RspackConfiguration } from '@rspack/core';
 import type * as Babel from '@babel/core';
 import type { ServerConfiguration } from 'webpack-dev-server';
 import type { Options as CircularDependenciesOptions } from 'circular-dependency-plugin';
@@ -14,6 +15,7 @@ import type { WebpackMode } from '../webpack/config';
 import type { UploadOptions } from '../s3-upload/upload';
 import type { TerserOptions } from 'terser-webpack-plugin';
 import type { ReactRefreshPluginOptions } from '@pmmmwh/react-refresh-webpack-plugin/types/lib/types';
+type Bundler = 'webpack' | 'rspack';
 export interface Entities<T> {
     data: Record<string, T>;
     keys: string[];
@@ -182,6 +184,13 @@ export interface ClientConfig {
         configType: `${WebpackMode}`;
         isSsr?: boolean;
     }) => Configuration | Promise<Configuration>;
+    /**
+     * Modify or return a custom Rspack config.
+     */
+    rspack?: (config: RspackConfiguration, options: {
+        configType: `${WebpackMode}`;
+        isSsr?: boolean;
+    }) => RspackConfiguration | Promise<RspackConfiguration>;
     /**
      * Modify or return a custom Babel config.
      */
@@ -197,6 +206,7 @@ export interface ClientConfig {
         noExternal?: string | RegExp | (string | RegExp)[] | true;
         moduleType?: 'commonjs' | 'esm';
     };
+    bundler?: Bundler;
 }
 export interface CdnUploadConfig {
     bucket: string;
@@ -225,6 +235,7 @@ export interface ServiceConfig {
     verbose?: boolean;
 }
 export type NormalizedClientConfig = Omit<ClientConfig, 'publicPathPrefix' | 'hiddenSourceMap' | 'svgr' | 'lazyCompilation' | 'devServer' | 'disableForkTsChecker' | 'disableReactRefresh'> & {
+    bundler: Bundler;
     publicPathPrefix: string;
     hiddenSourceMap: boolean;
     svgr: NonNullable<ClientConfig['svgr']>;
@@ -238,6 +249,9 @@ export type NormalizedClientConfig = Omit<ClientConfig, 'publicPathPrefix' | 'hi
         configType: `${WebpackMode}`;
         isSsr: boolean;
     }) => Configuration | Promise<Configuration>;
+    rspack: (config: RspackConfiguration, options: {
+        configType: `${WebpackMode}`;
+    }) => RspackConfiguration | Promise<RspackConfiguration>;
     debugWebpack?: boolean;
     babel: (config: Babel.TransformOptions, options: {
         configType: `${WebpackMode}`;

package/dist/common/s3-upload/create-plugin.d.ts

@@ -0,0 +1,3 @@
+import { NormalizedClientConfig } from '../models';
+import type { Logger } from '../logger';
+export declare function createS3UploadPlugins(config: NormalizedClientConfig, logger?: Logger): (false | "" | 0 | ((this: import("webpack").Compiler, compiler: import("webpack").Compiler) => void) | import("webpack").WebpackPluginInstance | null)[];

package/dist/common/s3-upload/create-plugin.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createS3UploadPlugins = createS3UploadPlugins;
+const webpack_plugin_1 = require("./webpack-plugin");
+function createS3UploadPlugins(config, logger) {
+    const plugins = [];
+    let credentialsGlobal;
+    if (process.env.FRONTEND_S3_ACCESS_KEY_ID && process.env.FRONTEND_S3_SECRET_ACCESS_KEY) {
+        credentialsGlobal = {
+            accessKeyId: process.env.FRONTEND_S3_ACCESS_KEY_ID,
+            secretAccessKey: process.env.FRONTEND_S3_SECRET_ACCESS_KEY,
+        };
+    }
+    const cdns = Array.isArray(config.cdn) ? config.cdn : [config.cdn];
+    for (let index = 0; index < cdns.length; index++) {
+        const cdn = cdns[index];
+        if (!cdn) {
+            continue;
+        }
+        let credentials = credentialsGlobal;
+        const accessKeyId = process.env[`FRONTEND_S3_ACCESS_KEY_ID_${index}`];
+        const secretAccessKey = process.env[`FRONTEND_S3_SECRET_ACCESS_KEY_${index}`];
+        if (accessKeyId && secretAccessKey) {
+            credentials = {
+                accessKeyId,
+                secretAccessKey,
+            };
+        }
+        plugins.push(new webpack_plugin_1.S3UploadPlugin({
+            exclude: config.hiddenSourceMap ? /\.map$/ : undefined,
+            compress: cdn.compress,
+            s3ClientOptions: {
+                region: cdn.region,
+                endpoint: cdn.endpoint,
+                credentials,
+            },
+            s3UploadOptions: {
+                bucket: cdn.bucket,
+                targetPath: cdn.prefix,
+                cacheControl: cdn.cacheControl,
+            },
+            additionalPattern: cdn.additionalPattern,
+            logger,
+        }));
+    }
+    return plugins;
+}

package/dist/common/s3-upload/index.d.ts

@@ -1,3 +1,4 @@
 export { S3UploadPlugin } from './webpack-plugin';
 export { uploadFiles } from './upload';
+export { createS3UploadPlugins } from './create-plugin';
 export type { UploadFilesOptions } from './upload';

package/dist/common/s3-upload/index.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.uploadFiles = exports.S3UploadPlugin = void 0;
+exports.createS3UploadPlugins = exports.uploadFiles = exports.S3UploadPlugin = void 0;
 var webpack_plugin_1 = require("./webpack-plugin");
 Object.defineProperty(exports, "S3UploadPlugin", { enumerable: true, get: function () { return webpack_plugin_1.S3UploadPlugin; } });
 var upload_1 = require("./upload");
 Object.defineProperty(exports, "uploadFiles", { enumerable: true, get: function () { return upload_1.uploadFiles; } });
+var create_plugin_1 = require("./create-plugin");
+Object.defineProperty(exports, "createS3UploadPlugins", { enumerable: true, get: function () { return create_plugin_1.createS3UploadPlugins; } });

package/dist/common/webpack/compile.js

@@ -5,22 +5,46 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.clientCompile = clientCompile;
 const webpack_1 = __importDefault(require("webpack"));
+const core_1 = require("@rspack/core");
 const logger_1 = require("../logger");
 const config_1 = require("./config");
 const utils_1 = require("./utils");
 async function clientCompile(config) {
     const logger = new logger_1.Logger('client', config.verbose);
-    const webpackConfigs = [await (0, config_1.webpackConfigFactory)("production" /* WebpackMode.Prod */, config, { logger })];
+    const webpackConfigs = [];
+    const rspackConfigs = [];
     const isSsr = Boolean(config.ssr);
-    if (isSsr) {
-        const ssrLogger = new logger_1.Logger('client(SSR)', config.verbose);
-        webpackConfigs.push(await (0, config_1.webpackConfigFactory)("production" /* WebpackMode.Prod */, config, { logger: ssrLogger, isSsr }));
+    if (config.bundler === 'rspack') {
+        rspackConfigs.push(await (0, config_1.rspackConfigFactory)({ webpackMode: "production" /* WebpackMode.Prod */, config, logger }));
+        if (isSsr) {
+            const ssrLogger = new logger_1.Logger('client(SSR)', config.verbose);
+            rspackConfigs.push(await (0, config_1.rspackConfigFactory)({
+                webpackMode: "production" /* WebpackMode.Prod */,
+                config,
+                logger: ssrLogger,
+                isSsr,
+            }));
+        }
+    }
+    else {
+        webpackConfigs.push(await (0, config_1.webpackConfigFactory)({ webpackMode: "production" /* WebpackMode.Prod */, config, logger }));
+        if (isSsr) {
+            const ssrLogger = new logger_1.Logger('client(SSR)', config.verbose);
+            webpackConfigs.push(await (0, config_1.webpackConfigFactory)({
+                webpackMode: "production" /* WebpackMode.Prod */,
+                config,
+                logger: ssrLogger,
+                isSsr,
+            }));
+        }
     }
     logger.verbose('Config created');
     return new Promise((resolve) => {
-        const compiler = (0, webpack_1.default)(webpackConfigs, (0, utils_1.webpackCompilerHandlerFactory)(logger, async () => {
-            resolve();
-        }));
+        const compiler = config.bundler === 'rspack'
+            ? (0, core_1.rspack)(rspackConfigs) // TODO add compiler factory
+            : (0, webpack_1.default)(webpackConfigs, (0, utils_1.webpackCompilerHandlerFactory)(logger, async () => {
+                resolve();
+            }));
         process.on('SIGINT', async () => {
             compiler.close(() => {
                 process.exit(1);

package/dist/common/webpack/config.d.ts

@@ -1,4 +1,5 @@
 import * as webpack from 'webpack';
+import { Configuration as RspackConfiguration } from '@rspack/core';
 import type { NormalizedClientConfig } from '../models';
 import type { Logger } from '../logger';
 export interface HelperOptions {
@@ -15,12 +16,16 @@ export declare const enum WebpackMode {
     Prod = "production",
     Dev = "development"
 }
-export declare function webpackConfigFactory(webpackMode: WebpackMode, config: NormalizedClientConfig, { logger, isSsr }?: {
+type ClientFactoryOptions = {
+    webpackMode: WebpackMode;
+    config: NormalizedClientConfig;
     logger?: Logger;
     isSsr?: boolean;
-}): Promise<webpack.Configuration>;
+};
+export declare function webpackConfigFactory(options: ClientFactoryOptions): Promise<webpack.Configuration>;
+export declare function rspackConfigFactory(options: ClientFactoryOptions): Promise<RspackConfiguration>;
 export declare function configureModuleRules(helperOptions: HelperOptions, additionalRules?: NonNullable<webpack.RuleSetRule['oneOf']>): webpack.RuleSetRule[];
 export declare function configureResolve({ isEnvProduction, config }: HelperOptions): webpack.ResolveOptions;
 type Optimization = NonNullable<webpack.Configuration['optimization']>;
-export declare function configureOptimization({ config, isSsr }: HelperOptions): Optimization;
+export declare function configureOptimization(helperOptions: HelperOptions): Optimization;
 export {};

package/dist/common/webpack/config.js

@@ -27,6 +27,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.webpackConfigFactory = webpackConfigFactory;
+exports.rspackConfigFactory = rspackConfigFactory;
 exports.configureModuleRules = configureModuleRules;
 exports.configureResolve = configureResolve;
 exports.configureOptimization = configureOptimization;
@@ -43,6 +44,11 @@ const react_refresh_webpack_plugin_1 = __importDefault(require("@pmmmwh/react-re
 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 core_1 = require("@rspack/core");
+const rspack_manifest_plugin_1 = require("rspack-manifest-plugin");
+const rspack_1 = require("./rspack");
+const ts_checker_rspack_plugin_1 = require("ts-checker-rspack-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");
@@ -53,10 +59,11 @@ const utils_2 = require("../typescript/utils");
 const node_externals_1 = require("./node-externals");
 const imagesSizeLimit = 2048;
 const fontSizeLimit = 8192;
-async function webpackConfigFactory(webpackMode, config, { logger, isSsr = false } = {}) {
+const assetsManifestFile = 'assets-manifest.json';
+function getHelperOptions({ webpackMode, config, logger, isSsr = false, }) {
     const isEnvDevelopment = webpackMode === "development" /* WebpackMode.Dev */;
     const isEnvProduction = webpackMode === "production" /* WebpackMode.Prod */;
-    const helperOptions = {
+    return {
         config,
         logger,
         isEnvDevelopment,
@@ -66,6 +73,11 @@ async function webpackConfigFactory(webpackMode, config, { logger, isSsr = false
         entriesDirectory: isSsr ? paths_1.default.appSsrEntry : paths_1.default.appEntry,
         isSsr,
     };
+}
+async function webpackConfigFactory(options) {
+    const { config } = options;
+    const helperOptions = getHelperOptions(options);
+    const { isSsr, isEnvProduction } = helperOptions;
     let externals = config.externals;
     if (isSsr) {
         externals =
@@ -77,7 +89,7 @@ async function webpackConfigFactory(webpackMode, config, { logger, isSsr = false
                 });
     }
     let webpackConfig = {
-        mode: webpackMode,
+        mode: isEnvProduction ? 'production' : 'development',
         context: paths_1.default.app,
         bail: isEnvProduction,
         target: isSsr ? 'node' : undefined,
@@ -88,7 +100,7 @@ async function webpackConfigFactory(webpackMode, config, { logger, isSsr = false
         module: {
             rules: configureModuleRules(helperOptions),
         },
-        plugins: configurePlugins(helperOptions),
+        plugins: configureWebpackPlugins(helperOptions),
         optimization: configureOptimization(helperOptions),
         externals,
         node: config.node,
@@ -106,12 +118,57 @@ async function webpackConfigFactory(webpackMode, config, { logger, isSsr = false
         },
         cache: config.cache,
     };
-    webpackConfig = await config.webpack(webpackConfig, { configType: webpackMode, isSsr });
+    webpackConfig = await config.webpack(webpackConfig, {
+        configType: isEnvProduction ? 'production' : 'development',
+        isSsr,
+    });
     if (config.debugWebpack) {
         (0, log_config_1.logConfig)('Preview webpack config', webpackConfig);
     }
     return webpackConfig;
 }
+async function rspackConfigFactory(options) {
+    const { config } = options;
+    const helperOptions = getHelperOptions(options);
+    const { isSsr, isEnvProduction, isEnvDevelopment } = helperOptions;
+    // Cache is required for lazy compilation
+    const cache = Boolean(config.cache) || (isEnvDevelopment && Boolean(config.lazyCompilation));
+    let rspackConfig = {
+        mode: isEnvProduction ? 'production' : 'development',
+        context: paths_1.default.app,
+        bail: isEnvProduction,
+        target: isSsr ? 'node' : undefined,
+        devtool: configureDevTool(helperOptions),
+        entry: configureEntry(helperOptions),
+        output: configureRspackOutput(helperOptions),
+        resolve: configureRspackResolve(helperOptions),
+        module: {
+            rules: (0, rspack_1.prepareRspackRules)(configureModuleRules(helperOptions)),
+        },
+        plugins: configureRspackPlugins(helperOptions),
+        optimization: configureRspackOptimization(helperOptions),
+        // TODO externals,
+        node: config.node,
+        watchOptions: configureWatchOptions(helperOptions),
+        ignoreWarnings: [/Failed to parse source map/],
+        infrastructureLogging: config.verbose
+            ? {
+                colors: true,
+                level: 'verbose',
+            }
+            : undefined,
+        experiments: configureRspackExperiments(helperOptions),
+        cache,
+    };
+    rspackConfig = await config.rspack(rspackConfig, {
+        configType: isEnvProduction ? 'production' : 'development',
+        isSsr,
+    });
+    if (config.debugWebpack) {
+        (0, log_config_1.logConfig)('Preview rspack config', rspackConfig);
+    }
+    return rspackConfig;
+}
 function configureModuleRules(helperOptions, additionalRules = []) {
     const jsLoader = createJavaScriptLoader(helperOptions);
     return [
@@ -182,6 +239,56 @@ function configureExperiments({ config, isEnvProduction, isSsr, }) {
         lazyCompilation,
     };
 }
+function configureRspackExperiments({ config, isEnvProduction, isSsr, }) {
+    if (isSsr) {
+        return config.ssr?.moduleType === 'esm' ? { outputModule: true } : undefined;
+    }
+    if (isEnvProduction) {
+        return undefined;
+    }
+    let lazyCompilation;
+    let port;
+    if (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)) {
@@ -203,6 +310,16 @@ function configureResolve({ isEnvProduction, config }) {
         fallback: config.fallback,
     };
 }
+function configureRspackResolve(helperOptions) {
+    const { alias, modules, extensions, symlinks, fallback } = configureResolve(helperOptions);
+    return {
+        alias: Array.isArray(alias) ? undefined : alias,
+        modules,
+        extensions,
+        symlinks,
+        fallback: Array.isArray(fallback) ? undefined : fallback,
+    };
+}
 function createEntryArray(entry) {
     return [require.resolve('./public-path'), entry];
 }
@@ -249,6 +366,18 @@ function configureOutput(options) {
         ...ssrOptions,
     };
 }
+function configureRspackOutput(options) {
+    const { filename, chunkFilename, library, chunkFormat, path, pathinfo } = configureOutput(options);
+    return {
+        filename: typeof filename === 'string' ? filename : undefined,
+        chunkFilename: typeof chunkFilename === 'string' ? chunkFilename : undefined,
+        library,
+        chunkFormat,
+        path,
+        pathinfo,
+        clean: false,
+    };
+}
 function createJavaScriptLoader({ isEnvProduction, isEnvDevelopment, configType, config, isSsr, }) {
     const plugins = [];
     if (!isSsr) {
@@ -326,7 +455,9 @@ function createWorkerRule(options) {
                     loader: require.resolve('./worker/worker-loader'),
                 }
                 : {
-                    loader: require.resolve('worker-loader'),
+                    loader: require.resolve(options.config.bundler === 'rspack'
+                        ? 'worker-rspack-loader'
+                        : 'worker-loader'),
                     // currently workers located on cdn are not working properly, so we are enforcing loading workers from
                     // service instead
                     options: {
@@ -370,6 +501,7 @@ function createStylesRule(options) {
     };
 }
 function getCssLoaders({ isEnvDevelopment, isEnvProduction, config, isSsr }, additionalRules) {
+    const isRspack = config.bundler === 'rspack';
     const loaders = [];
     if (!config.transformCssWithLightningCss) {
         loaders.push({
@@ -409,11 +541,17 @@ function getCssLoaders({ isEnvDevelopment, isEnvProduction, config, isSsr }, add
         },
     });
     if (isEnvProduction) {
-        loaders.unshift({ loader: mini_css_extract_plugin_1.default.loader, options: { emit: !isSsr } });
+        loaders.unshift({
+            loader: isRspack ? core_1.CssExtractRspackPlugin.loader : mini_css_extract_plugin_1.default.loader,
+            options: { emit: !isSsr },
+        });
     }
     if (isEnvDevelopment) {
         if (isSsr || config.ssr) {
-            loaders.unshift({ loader: mini_css_extract_plugin_1.default.loader, options: { emit: !isSsr } });
+            loaders.unshift({
+                loader: isRspack ? core_1.CssExtractRspackPlugin.loader : mini_css_extract_plugin_1.default.loader,
+                options: { emit: !isSsr },
+            });
         }
         else {
             loaders.unshift({
@@ -567,47 +705,42 @@ function createMomentTimezoneDataPlugin(options = {}) {
     const endYear = options.endYear ?? currentYear;
     return new moment_timezone_data_webpack_plugin_1.default({ ...options, startYear, endYear });
 }
-function configurePlugins(options) {
-    const { isEnvDevelopment, isEnvProduction, config, isSsr } = 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 webpack_manifest_plugin_1.WebpackManifestPlugin({
-            writeToFileEmit: true,
-            publicPath: '',
-        }),
-        new webpack_assets_manifest_1.default(isEnvProduction
-            ? {
-                entrypoints: true,
-                output: manifestFile,
-            }
-            : {
-                entrypoints: true,
-                writeToDisk: true,
-                output: path.resolve(options.buildDirectory, manifestFile),
-            }),
-        new webpack.DefinePlugin({
-            'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV),
-            'process.env.IS_SSR': JSON.stringify(isSsr),
-            ...config.definitions,
-        }),
-    ];
-    if (options.logger) {
-        plugins.push(new progress_plugin_1.ProgressPlugin({ logger: options.logger }));
+function getDefinitions({ config, isSsr }) {
+    return {
+        'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV),
+        'process.env.IS_SSR': JSON.stringify(isSsr),
+        ...config.definitions,
+    };
+}
+function getContextReplacements({ config, isSsr }) {
+    const contextReplacement = config.contextReplacement || {};
+    if (isSsr) {
+        return [];
     }
-    if (process.env.WEBPACK_PROFILE === 'true') {
-        plugins.push(new webpack.debug.ProfilingPlugin());
+    const replacements = [
+        {
+            resourceRegExp: /moment[\\/]locale$/, // eslint-disable-next-line security/detect-non-literal-regexp
+            newResource: new RegExp(`^\\./(${(contextReplacement.locale || ['ru']).join('|')})$`),
+        },
+        {
+            resourceRegExp: /dayjs[\\/]locale$/,
+            // eslint-disable-next-line security/detect-non-literal-regexp
+            newResource: new RegExp(`^\\./(${(contextReplacement.locale || ['ru']).join('|')})\\.js$`),
+        },
+    ];
+    if (contextReplacement['highlight.js']) {
+        replacements.push({
+            resourceRegExp: /highlight\.js[\\/]lib[\\/]languages$/,
+            // eslint-disable-next-line security/detect-non-literal-regexp
+            newResource: new RegExp(`^\\./(${contextReplacement['highlight.js'].join('|')})$`),
+        });
     }
-    if (config.forkTsChecker !== false) {
-        plugins.push(new fork_ts_checker_webpack_plugin_1.default({
+    return replacements;
+}
+function getForkTsCheckerOptions({ config, }) {
+    return config.forkTsChecker === false
+        ? undefined
+        : {
             ...config.forkTsChecker,
             typescript: {
                 typescriptPath: (0, utils_2.resolveTypescript)(),
@@ -618,8 +751,31 @@ function configurePlugins(options) {
                 mode: 'write-references',
                 ...config.forkTsChecker?.typescript,
             },
-        }));
-    }
+        };
+}
+function getCssExtractPluginOptions({ isEnvProduction }) {
+    return {
+        filename: isEnvProduction ? 'css/[name].[contenthash:8].css' : 'css/[name].css',
+        chunkFilename: isEnvProduction
+            ? 'css/[name].[contenthash:8].chunk.css'
+            : 'css/[name].chunk.css',
+        ignoreOrder: true,
+    };
+}
+function configureCommonPlugins(options) {
+    const { isEnvDevelopment, isEnvProduction, config, isSsr } = options;
+    const excludeFromClean = config.excludeFromClean || [];
+    const plugins = [
+        new clean_webpack_plugin_1.CleanWebpackPlugin({
+            verbose: config.verbose,
+            cleanOnceBeforeBuildPatterns: [
+                '**/*',
+                ...(isEnvDevelopment ? ['!manifest.json'] : []),
+                ...excludeFromClean,
+            ],
+        }),
+        ...(options.logger ? [new progress_plugin_1.ProgressPlugin({ logger: options.logger })] : []),
+    ];
     if (config.detectCircularDependencies) {
         let circularPluginOptions = {
             exclude: /node_modules/,
@@ -638,27 +794,6 @@ function configurePlugins(options) {
                 reportFilename: 'stats.html',
             }));
         }
-        if (config.analyzeBundle === 'statoscope') {
-            const customStatoscopeConfig = config.statoscopeConfig || {};
-            plugins.push(new webpack_plugin_1.default({
-                saveReportTo: path.resolve(options.buildDirectory, 'report.html'),
-                saveStatsTo: path.resolve(options.buildDirectory, 'stats.json'),
-                open: false,
-                statsOptions: {
-                    all: true,
-                },
-                ...customStatoscopeConfig,
-            }));
-        }
-    }
-    if (isEnvProduction || isSsr || config.ssr) {
-        plugins.push(new mini_css_extract_plugin_1.default({
-            filename: isEnvProduction ? 'css/[name].[contenthash:8].css' : 'css/[name].css',
-            chunkFilename: isEnvProduction
-                ? 'css/[name].[contenthash:8].chunk.css'
-                : 'css/[name].chunk.css',
-            ignoreOrder: true,
-        }));
     }
     if (!isSsr) {
         if (config.monaco) {
@@ -671,84 +806,130 @@ function configurePlugins(options) {
                 publicPath: path.normalize(config.publicPathPrefix + '/build/'),
             }));
         }
-        const contextReplacement = config.contextReplacement || {};
         plugins.push(createMomentTimezoneDataPlugin(config.momentTz));
-        plugins.push(new webpack.ContextReplacementPlugin(/moment[\\/]locale$/, 
-        // eslint-disable-next-line security/detect-non-literal-regexp
-        new RegExp(`^\\./(${(contextReplacement.locale || ['ru']).join('|')})$`)));
-        plugins.push(new webpack.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 webpack.ContextReplacementPlugin(/highlight\.js[\\/]lib[\\/]languages$/, 
-            // eslint-disable-next-line security/detect-non-literal-regexp
-            new RegExp(`^\\./(${contextReplacement['highlight.js'].join('|')})$`)));
+    }
+    if (isEnvProduction) {
+        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 configureWebpackPlugins(options) {
+    const { isEnvDevelopment, isEnvProduction, config, isSsr } = options;
+    const forkTsCheckerOptions = getForkTsCheckerOptions(options);
+    const webpackPlugins = [
+        ...configureCommonPlugins(options),
+        new webpack.DefinePlugin(getDefinitions(options)),
+        new webpack_manifest_plugin_1.WebpackManifestPlugin({
+            writeToFileEmit: true,
+            publicPath: '',
+        }),
+        new webpack_assets_manifest_1.default(isEnvProduction
+            ? {
+                entrypoints: true,
+                output: assetsManifestFile,
+            }
+            : {
+                entrypoints: true,
+                writeToDisk: true,
+                output: path.resolve(options.buildDirectory, assetsManifestFile),
+            }),
+        ...(process.env.WEBPACK_PROFILE === 'true' ? [new webpack.debug.ProfilingPlugin()] : []),
+        ...(forkTsCheckerOptions ? [new fork_ts_checker_webpack_plugin_1.default(forkTsCheckerOptions)] : []),
+    ];
+    if (isEnvProduction || isSsr || config.ssr) {
+        webpackPlugins.push(new mini_css_extract_plugin_1.default(getCssExtractPluginOptions(options)));
+    }
+    if (isEnvProduction) {
+        if (config.analyzeBundle === 'statoscope') {
+            const customStatoscopeConfig = config.statoscopeConfig || {};
+            webpackPlugins.push(new webpack_plugin_1.default({
+                saveReportTo: path.resolve(options.buildDirectory, 'report.html'),
+                saveStatsTo: path.resolve(options.buildDirectory, 'stats.json'),
+                open: false,
+                statsOptions: {
+                    all: true,
+                },
+                ...customStatoscopeConfig,
+            }));
+        }
+    }
+    if (!isSsr) {
+        const contextReplacements = getContextReplacements(options);
+        contextReplacements.forEach(({ resourceRegExp, newResource }) => webpackPlugins.push(new webpack.ContextReplacementPlugin(resourceRegExp, newResource)));
         if (isEnvDevelopment && config.reactRefresh !== false) {
             const { webSocketPath = path.normalize(`/${config.publicPathPrefix}/build/sockjs-node`), } = config.devServer || {};
-            plugins.push(new react_refresh_webpack_plugin_1.default(config.reactRefresh({
+            const reactRefreshConfig = config.reactRefresh({
                 overlay: { sockPath: webSocketPath },
                 exclude: [/node_modules/, /\.worker\.[jt]sx?$/],
-            })));
+            });
+            webpackPlugins.push(new react_refresh_webpack_plugin_1.default(reactRefreshConfig));
         }
         if (config.polyfill?.process) {
-            plugins.push(new webpack.ProvidePlugin({ process: 'process/browser.js' }));
+            webpackPlugins.push(new webpack.ProvidePlugin({ process: 'process/browser.js' }));
         }
-        if (isEnvProduction) {
-            if (config.sentryConfig) {
-                const sentryPlugin = require('@sentry/webpack-plugin').sentryWebpackPlugin;
-                plugins.push(sentryPlugin({ ...config.sentryConfig }));
-            }
+    }
+    return webpackPlugins;
+}
+function configureRspackPlugins(options) {
+    const { isEnvDevelopment, isEnvProduction, config, isSsr } = options;
+    const forkTsCheckerOptions = getForkTsCheckerOptions(options);
+    const rspackPlugins = [
+        ...configureCommonPlugins(options),
+        new core_1.rspack.DefinePlugin(getDefinitions(options)),
+        new rspack_manifest_plugin_1.RspackManifestPlugin({
+            fileName: isEnvProduction
+                ? assetsManifestFile
+                : path.resolve(paths_1.default.appBuild, assetsManifestFile),
+            writeToFileEmit: true,
+            useLegacyEmit: true,
+            publicPath: '',
+            generate: rspack_1.generateAssetsManifest,
+        }),
+        ...(forkTsCheckerOptions ? [new ts_checker_rspack_plugin_1.TsCheckerRspackPlugin(forkTsCheckerOptions)] : []),
+    ];
+    if (isEnvProduction || isSsr || config.ssr) {
+        rspackPlugins.push(new core_1.CssExtractRspackPlugin(getCssExtractPluginOptions(options)));
+    }
+    // TODO add rsdoctor plugin
+    if (!isSsr) {
+        const contextReplacements = getContextReplacements(options);
+        contextReplacements.forEach(({ resourceRegExp, newResource }) => rspackPlugins.push(new core_1.rspack.ContextReplacementPlugin(resourceRegExp, newResource)));
+        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?$/],
+            });
+            rspackPlugins.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.cdn) {
-            let credentialsGlobal;
-            if (process.env.FRONTEND_S3_ACCESS_KEY_ID &&
-                process.env.FRONTEND_S3_SECRET_ACCESS_KEY) {
-                credentialsGlobal = {
-                    accessKeyId: process.env.FRONTEND_S3_ACCESS_KEY_ID,
-                    secretAccessKey: process.env.FRONTEND_S3_SECRET_ACCESS_KEY,
-                };
-            }
-            const cdns = Array.isArray(config.cdn) ? config.cdn : [config.cdn];
-            for (let index = 0; index < cdns.length; index++) {
-                const cdn = cdns[index];
-                if (!cdn) {
-                    continue;
-                }
-                let credentials = credentialsGlobal;
-                const accessKeyId = process.env[`FRONTEND_S3_ACCESS_KEY_ID_${index}`];
-                const secretAccessKey = process.env[`FRONTEND_S3_SECRET_ACCESS_KEY_${index}`];
-                if (accessKeyId && secretAccessKey) {
-                    credentials = {
-                        accessKeyId,
-                        secretAccessKey,
-                    };
-                }
-                plugins.push(new s3_upload_1.S3UploadPlugin({
-                    exclude: config.hiddenSourceMap ? /\.map$/ : undefined,
-                    compress: cdn.compress,
-                    s3ClientOptions: {
-                        region: cdn.region,
-                        endpoint: cdn.endpoint,
-                        credentials,
-                    },
-                    s3UploadOptions: {
-                        bucket: cdn.bucket,
-                        targetPath: cdn.prefix,
-                        cacheControl: cdn.cacheControl,
-                    },
-                    additionalPattern: cdn.additionalPattern,
-                    logger: options.logger,
-                }));
-            }
+        if (config.polyfill?.process) {
+            rspackPlugins.push(new core_1.rspack.ProvidePlugin({ process: 'process/browser.js' }));
         }
     }
-    return plugins;
+    return rspackPlugins;
 }
-function configureOptimization({ config, isSsr }) {
-    if (isSsr) {
-        return {};
-    }
+function getOptimizationSplitChunks({ config }) {
     const configVendors = config.vendors ?? [];
     let vendorsList = [
         'react',
@@ -770,28 +951,35 @@ function configureOptimization({ config, isSsr }) {
         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,
-                },
+    return {
+        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,
             },
         },
+    };
+}
+function configureOptimization(helperOptions) {
+    const { config, isSsr } = helperOptions;
+    if (isSsr) {
+        return {};
+    }
+    const optimization = {
+        splitChunks: getOptimizationSplitChunks(helperOptions),
         runtimeChunk: 'single',
         minimizer: [
             (compiler) => {
@@ -841,3 +1029,33 @@ function configureOptimization({ config, isSsr }) {
     };
     return optimization;
 }
+function configureRspackOptimization(helperOptions) {
+    const { config, isSsr } = helperOptions;
+    if (isSsr) {
+        return {};
+    }
+    const optimization = {
+        splitChunks: getOptimizationSplitChunks(helperOptions),
+        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;
+}

package/dist/common/webpack/rspack.d.ts

@@ -0,0 +1,7 @@
+import { ManifestPluginOptions } from 'rspack-manifest-plugin';
+import type { RuleSetRule as WebpackRuleSetRule } from 'webpack';
+import type { Configuration, RuleSetRule as RspackRuleSetRule } from '@rspack/core';
+import type { Logger } from '../logger';
+export declare function clearCacheDirectory(config: Configuration, logger: Logger): void;
+export declare const generateAssetsManifest: ManifestPluginOptions['generate'];
+export declare function prepareRspackRules(webpackRules: (undefined | null | false | '' | 0 | WebpackRuleSetRule | '...')[]): (RspackRuleSetRule | '...')[];

package/dist/common/webpack/rspack.js

@@ -0,0 +1,111 @@
+"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.generateAssetsManifest = void 0;
+exports.clearCacheDirectory = clearCacheDirectory;
+exports.prepareRspackRules = prepareRspackRules;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const paths_1 = __importDefault(require("../../common/paths"));
+function clearCacheDirectory(config, logger) {
+    if (!config.cache) {
+        return;
+    }
+    let cacheDirectory = path.join(paths_1.default.appNodeModules, '.cache/rspack');
+    if (typeof config.experiments?.cache === 'object' &&
+        config.experiments.cache.type === 'persistent' &&
+        config.experiments.cache.storage?.directory) {
+        cacheDirectory = config.experiments.cache.storage?.directory;
+    }
+    if (fs.existsSync(cacheDirectory)) {
+        fs.rmdirSync(cacheDirectory, { recursive: true });
+        logger.message(`Rspack cache ${cacheDirectory} successfully cleared`);
+    }
+}
+const generateAssetsManifest = (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.generateAssetsManifest = generateAssetsManifest;
+function prepareRspackUse(webpackUse) {
+    if (typeof webpackUse === 'string') {
+        if (webpackUse === 'swc-loader') {
+            return 'builtin:swc-loader';
+        }
+        return webpackUse;
+    }
+    if (Array.isArray(webpackUse)) {
+        for (const item of webpackUse) {
+            if (item) {
+                prepareRspackUse(item);
+            }
+        }
+    }
+    return webpackUse;
+}
+function prepareRspackRules(webpackRules) {
+    const rspackRules = [];
+    for (const webpackRule of webpackRules) {
+        if (!webpackRule) {
+            continue;
+        }
+        if (typeof webpackRule === 'string') {
+            rspackRules.push(webpackRule);
+            continue;
+        }
+        const rspackRule = webpackRule;
+        if (webpackRule.oneOf) {
+            rspackRule.oneOf = prepareRspackRules(webpackRule.oneOf);
+        }
+        if (webpackRule.rules) {
+            rspackRule.rules = prepareRspackRules(webpackRule.rules);
+        }
+        if (webpackRule.use) {
+            rspackRule.use = prepareRspackUse(webpackRule.use);
+        }
+        rspackRules.push(rspackRule);
+    }
+    return rspackRules;
+}

package/dist/create-cli.d.ts

@@ -5,8 +5,8 @@ export declare function createCli(argv: string[]): {
     cdn: string | undefined;
     env: string[] | undefined;
     target: "client" | "server" | undefined;
-    inspect: number | undefined;
     c: unknown;
+    inspect: number | undefined;
     inspectBrk: number | undefined;
     "inspect-brk": number | undefined;
     entryFilter: string[] | undefined;
@@ -33,8 +33,8 @@ export declare function createCli(argv: string[]): {
     cdn: string | undefined;
     env: string[] | undefined;
     target: "client" | "server" | undefined;
-    inspect: number | undefined;
     c: unknown;
+    inspect: number | undefined;
     inspectBrk: number | undefined;
     "inspect-brk": number | undefined;
     entryFilter: string[] | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gravity-ui/app-builder",
-  "version": "0.15.0",
+  "version": "0.15.1-beta.1",
   "description": "Develop and build your React client-server projects, powered by typescript and webpack",
   "license": "MIT",
   "type": "commonjs",
@@ -70,6 +70,9 @@
     "@babel/runtime": "^7.26.0",
     "@okikio/sharedworker": "^1.0.7",
     "@pmmmwh/react-refresh-webpack-plugin": "^0.5.15",
+    "@rspack/core": "^1.2.2",
+    "@rspack/dev-server": "^1.0.10",
+    "@rspack/plugin-react-refresh": "^1.0.0",
     "@statoscope/webpack-plugin": "^5.28.2",
     "@svgr/core": "^8.1.0",
     "@svgr/plugin-jsx": "^8.1.0",
@@ -110,6 +113,7 @@
     "react-refresh": "^0.14.2",
     "resolve-url-loader": "^5.0.0",
     "rimraf": "^5.0.7",
+    "rspack-manifest-plugin": "^5.0.1",
     "sass": "^1.79.0",
     "sass-loader": "^16.0.0",
     "semver": "^7.6.3",
@@ -119,6 +123,7 @@
     "style-loader": "^4.0.0",
     "svgo": "^3.3.2",
     "terser-webpack-plugin": "5.3.10",
+    "ts-checker-rspack-plugin": "^1.1.1",
     "ts-node": "10.9.2",
     "tslib": "^2.6.2",
     "typescript": "~5.6.0",
@@ -128,6 +133,7 @@
     "webpack-dev-server": "^5.1.0",
     "webpack-manifest-plugin": "^5.0.0",
     "worker-loader": "^3.0.8",
+    "worker-rspack-loader": "^3.1.2",
     "yargs": "^17.7.2"
   },
   "devDependencies": {