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

package/dist/common/rspack/lazy-client.d.ts

@@ -0,0 +1 @@
+export function keepAlive(options: any): () => void;

package/dist/common/rspack/lazy-client.js

@@ -0,0 +1,63 @@
+/* eslint-env browser */
+/* global __resourceQuery */
+'use strict';
+if (typeof EventSource !== 'function') {
+    throw new Error("Environment doesn't support lazy compilation (requires EventSource)");
+}
+const urlBase = new URL(decodeURIComponent(__resourceQuery.slice(1))).pathname;
+let activeEventSource;
+const activeKeys = new Map();
+const errorHandlers = new Set();
+const updateEventSource = function updateEventSource() {
+    if (activeEventSource)
+        activeEventSource.close();
+    if (activeKeys.size) {
+        activeEventSource = new EventSource('/build/lazy' + urlBase + Array.from(activeKeys.keys()).join('@'));
+        activeEventSource.onerror = function (event) {
+            errorHandlers.forEach(function (onError) {
+                onError(new Error('Problem communicating active modules to the server: ' +
+                    event.message +
+                    ' ' +
+                    event.filename +
+                    ':' +
+                    event.lineno +
+                    ':' +
+                    event.colno +
+                    ' ' +
+                    event.error));
+            });
+        };
+    }
+    else {
+        activeEventSource = undefined;
+    }
+};
+exports.keepAlive = function (options) {
+    const data = options.data;
+    const onError = options.onError;
+    const active = options.active;
+    const module = options.module;
+    errorHandlers.add(onError);
+    const value = activeKeys.get(data) || 0;
+    activeKeys.set(data, value + 1);
+    if (value === 0) {
+        updateEventSource();
+    }
+    if (!active && !module.hot) {
+        // eslint-disable-next-line no-console
+        console.log('Hot Module Replacement is not enabled. Waiting for process restart...');
+    }
+    return function () {
+        errorHandlers.delete(onError);
+        setTimeout(function () {
+            const valueToReduce = activeKeys.get(data);
+            if (valueToReduce === 1) {
+                activeKeys.delete(data);
+                updateEventSource();
+            }
+            else {
+                activeKeys.set(data, valueToReduce - 1);
+            }
+        }, 1000);
+    };
+};

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

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

package/dist/common/rspack/progress-plugin.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProgressPlugin = void 0;
+const core_1 = require("@rspack/core");
+const pretty_time_1 = require("../logger/pretty-time");
+class ProgressPlugin extends core_1.rspack.ProgressPlugin {
+    _logger;
+    _state = {};
+    constructor({ logger }) {
+        super();
+        this._logger = logger;
+    }
+    handler = (percent, message, ...details) => {
+        const progress = Math.floor(percent * 100);
+        this._logger.status(`${this._logger.colors.green(`${progress}%`)} - ${this._logger.colors.yellow(message)}${details.length > 0 ? `: ${this._logger.colors.dim(...details)}` : ''}`);
+    };
+    apply(compiler) {
+        super.apply(compiler);
+        hook(compiler, 'compile', () => {
+            this._logger.message('Start compilation');
+            this._logger.message(`rspack v${compiler.rspack.rspackVersion}`);
+            this._state.start = process.hrtime.bigint();
+        });
+        hook(compiler, 'invalid', (fileName, changeTime) => {
+            this._logger.verbose(`Invalidate file: ${fileName} at ${changeTime}`);
+        });
+        hook(compiler, 'done', (stats) => {
+            const time = this._state.start ? ' in ' + (0, pretty_time_1.elapsedTime)(this._state.start) : '';
+            const hasErrors = stats.hasErrors();
+            if (hasErrors) {
+                this._logger.error('Compiled with some errors' + time);
+            }
+            else {
+                this._logger.success('Compiled successfully' + time);
+            }
+        });
+    }
+}
+exports.ProgressPlugin = ProgressPlugin;
+function hook(compiler, hookName, callback) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    compiler.hooks[hookName].tap(`app-builder: ${hookName}`, callback);
+}

package/dist/common/rspack/public-path.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/common/rspack/public-path.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-expect-error
+__webpack_public_path__ = globalThis.__PUBLIC_PATH__ ?? '/build/';

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

@@ -0,0 +1,4 @@
+import type { Configuration, MultiStats } from '@rspack/core';
+import type { Logger } from '../logger';
+export declare function clearCacheDirectory(config: Configuration, logger: Logger): void;
+export declare function rspackCompilerHandlerFactory(logger: Logger, onCompilationEnd?: () => void): (err?: Error | null, stats?: MultiStats) => Promise<void>;

package/dist/common/rspack/utils.js

@@ -0,0 +1,81 @@
+"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.clearCacheDirectory = clearCacheDirectory;
+exports.rspackCompilerHandlerFactory = rspackCompilerHandlerFactory;
+const pretty_time_1 = require("../logger/pretty-time");
+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`);
+    }
+}
+function rspackCompilerHandlerFactory(logger, onCompilationEnd) {
+    return async (err, stats) => {
+        if (err) {
+            logger.panic(err.message, err);
+        }
+        if (stats) {
+            logger.message('Stats:\n' +
+                stats.toString({
+                    preset: 'errors-warnings',
+                    colors: process.stdout.isTTY,
+                    assets: logger.isVerbose,
+                    modules: logger.isVerbose,
+                    entrypoints: logger.isVerbose,
+                    timings: logger.isVerbose,
+                }));
+            if (stats.hasErrors()) {
+                process.exit(1);
+            }
+        }
+        if (onCompilationEnd) {
+            await onCompilationEnd();
+        }
+        const [clientStats] = stats?.stats ?? [];
+        if (clientStats) {
+            const time = (clientStats.endTime || 0) - (clientStats.startTime || 0);
+            logger.success(`Client was successfully compiled in ${(0, pretty_time_1.prettyTime)(BigInt(time) * BigInt(1_000_000))}`);
+        }
+        if (!clientStats) {
+            logger.success(`Client was successfully compiled`);
+        }
+    };
+}

package/dist/common/rspack/worker/public-path.worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/common/rspack/worker/public-path.worker.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+__webpack_public_path__ = self.__PUBLIC_PATH__;

package/dist/common/rspack/worker/web-worker.d.mts

@@ -0,0 +1,8 @@
+import { SharedWorkerPolyfill } from '@okikio/sharedworker';
+declare class WebWorker extends Worker {
+    constructor(url: string | URL, options?: WorkerOptions);
+}
+declare class SharedWebWorker extends SharedWorkerPolyfill {
+    constructor(url: string | URL, options?: WorkerOptions);
+}
+export { WebWorker as Worker, SharedWebWorker as SharedWorker };

package/dist/common/rspack/worker/web-worker.mjs

@@ -0,0 +1,32 @@
+import { SharedWorkerPolyfill } from '@okikio/sharedworker';
+class WebWorker extends Worker {
+    constructor(url, options) {
+        const objectURL = generateWorkerLoader(url);
+        super(objectURL, options);
+        URL.revokeObjectURL(objectURL);
+    }
+}
+class SharedWebWorker extends SharedWorkerPolyfill {
+    constructor(url, options) {
+        const objectURL = generateWorkerLoader(url);
+        super(objectURL, options);
+        URL.revokeObjectURL(objectURL);
+    }
+}
+export { WebWorker as Worker, SharedWebWorker as SharedWorker };
+function generateWorkerLoader(url) {
+    // eslint-disable-next-line camelcase
+    const publicPath = __webpack_public_path__;
+    const workerPublicPath = publicPath.match(/^https?:\/\//)
+        ? publicPath
+        : new URL(publicPath, window.location.origin).toString();
+    const objectURL = URL.createObjectURL(new Blob([
+        [
+            `self.__PUBLIC_PATH__ = ${JSON.stringify(workerPublicPath)}`,
+            `importScripts(${JSON.stringify(url.toString())});`,
+        ].join('\n'),
+    ], {
+        type: 'application/javascript',
+    }));
+    return objectURL;
+}

package/dist/common/rspack/worker/worker-loader.d.ts

@@ -0,0 +1,4 @@
+import type { LoaderDefinition } from '@rspack/core';
+type PitchLoaderDefinitionFunction = Exclude<LoaderDefinition['pitch'], undefined>;
+export declare const pitch: PitchLoaderDefinitionFunction;
+export {};

package/dist/common/rspack/worker/worker-loader.js

@@ -0,0 +1,177 @@
+"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.pitch = void 0;
+const path = __importStar(require("node:path"));
+const paths_1 = __importDefault(require("../../paths"));
+const core_1 = require("@rspack/core");
+const pluginId = 'APP_BUILDER_WORKER_LOADER';
+const publicPath = path.resolve(__dirname, 'public-path.worker.js');
+const pitch = function (request) {
+    this.cacheable(false);
+    if (!this._compiler || !this._compilation) {
+        throw new Error('Something went wrong');
+    }
+    const compilerOptions = this._compiler.options;
+    const logger = this.getLogger(pluginId);
+    if (compilerOptions.output.globalObject === 'window') {
+        logger.warn('Warning (app-builder-worker-loader): output.globalObject is set to "window". It should be set to "self" or "this" to support HMR in Workers.');
+    }
+    const isEnvProduction = compilerOptions.mode === 'production';
+    const filename = 'worker.js';
+    const chunkFilename = isEnvProduction
+        ? 'js/[name].[contenthash:8].worker.js'
+        : 'js/[name].worker.js';
+    const workerOptions = {
+        filename,
+        chunkFilename,
+        publicPath: compilerOptions.output.publicPath,
+        globalObject: 'self',
+        devtoolNamespace: path.resolve('/', path.relative(paths_1.default.app, this.resource)),
+    };
+    const workerCompiler = this._compilation.createChildCompiler(`worker ${request}`, workerOptions, []);
+    new core_1.webworker.WebWorkerTemplatePlugin().apply(workerCompiler);
+    if (this.target !== 'webworker' && this.target !== 'web') {
+        new core_1.node.NodeTargetPlugin().apply(workerCompiler);
+    }
+    /* TODO Unsupported
+    new web.FetchCompileWasmPlugin({
+        mangleImports: this._compiler.options.optimization.mangleWasmImports,
+    }).apply(workerCompiler);
+    */
+    new core_1.web.FetchCompileAsyncWasmPlugin().apply(workerCompiler);
+    const bundleName = path.parse(this.resourcePath).name;
+    new core_1.EntryPlugin(this.context, `!!${publicPath}`, bundleName).apply(workerCompiler);
+    new core_1.EntryPlugin(this.context, `!!${request}`, bundleName).apply(workerCompiler);
+    configureSourceMap(workerCompiler);
+    const cb = this.async();
+    workerCompiler.compile((err, compilation) => {
+        if (compilation) {
+            workerCompiler.parentCompilation?.children.push(compilation);
+        }
+        if (err) {
+            return cb(err);
+        }
+        if (!compilation) {
+            return cb(new Error('Child compilation failed'));
+        }
+        if (compilation.errors && compilation.errors.length) {
+            const errorDetails = compilation.errors
+                .map((error) => {
+                if (error instanceof Error) {
+                    return error.stack;
+                }
+                return error;
+            })
+                .join('\n');
+            return cb(new Error('Child compilation failed:\n' + errorDetails));
+        }
+        const cache = workerCompiler.getCache(pluginId);
+        const cacheIdent = request;
+        const objectToHash = compilation.assets[filename];
+        if (!objectToHash) {
+            return cb(new Error(`Asset ${filename} not found in compilation`));
+        }
+        const cacheETag = cache.getLazyHashedEtag(objectToHash);
+        return cache.get(cacheIdent, cacheETag, (getCacheError, cacheContent) => {
+            if (getCacheError) {
+                return cb(getCacheError);
+            }
+            if (cacheContent) {
+                return cb(null, cacheContent.content, cacheContent.map);
+            }
+            let content = compilation.assets[filename]?.source().toString();
+            const mapFile = `${filename}.map`;
+            let map = compilation.assets[mapFile]?.source();
+            if (map) {
+                const sourceMap = JSON.parse(map.toString());
+                if (Array.isArray(sourceMap.sources)) {
+                    sourceMap.sources = sourceMap.sources.map((pathname) => pathname.replace(/webpack:\/\/[^/]+\//, 'webpack://'));
+                }
+                map = JSON.stringify(sourceMap);
+            }
+            const licenseFile = `${filename}.LICENSE.txt`;
+            const license = compilation.assets[licenseFile]?.source().toString();
+            if (license && content) {
+                if (content.startsWith('/*')) {
+                    content = content.replace(/^\/\*.*?\*\//, license);
+                }
+            }
+            const parentCompilation = workerCompiler.parentCompilation;
+            if (parentCompilation) {
+                for (const [assetName, asset] of Object.entries(compilation.assets)) {
+                    if ([filename, mapFile, licenseFile].includes(assetName)) {
+                        continue;
+                    }
+                    if (parentCompilation.getAsset(assetName)) {
+                        continue;
+                    }
+                    parentCompilation.emitAsset(assetName, asset, compilation.getAsset(assetName)?.info);
+                }
+            }
+            return cache.store(cacheIdent, cacheETag, { content, map: map?.toString() }, (storeCacheError) => {
+                if (storeCacheError) {
+                    return cb(storeCacheError);
+                }
+                return cb(null, content, map?.toString());
+            });
+        });
+    });
+};
+exports.pitch = pitch;
+function configureSourceMap(compiler) {
+    const devtool = compiler.options.devtool;
+    if (devtool) {
+        if (devtool.includes('source-map')) {
+            // remove parent SourceMapDevToolPlugin from compilation
+            for (const hook of Object.values(compiler.hooks)) {
+                for (let i = hook.taps.length - 1; i >= 0; i--) {
+                    const tap = hook.taps[i];
+                    if (tap?.name === 'SourceMapDevToolPlugin') {
+                        hook.taps.splice(i, 1);
+                    }
+                }
+            }
+            const hidden = devtool.includes('hidden');
+            const inline = devtool.includes('inline');
+            const cheap = devtool.includes('cheap');
+            const moduleMaps = devtool.includes('module');
+            new core_1.rspack.SourceMapDevToolPlugin({
+                filename: inline ? null : compiler.options.output.sourceMapFilename,
+                moduleFilenameTemplate: compiler.options.output.devtoolModuleFilenameTemplate,
+                fallbackModuleFilenameTemplate: compiler.options.output.devtoolFallbackModuleFilenameTemplate,
+                append: hidden ? false : undefined,
+                module: moduleMaps ? true : !cheap,
+                columns: !cheap,
+                noSources: false,
+                namespace: (compiler.parentCompilation?.outputOptions.devtoolNamespace ?? '') +
+                    compiler.options.output.devtoolNamespace,
+            }).apply(compiler);
+        }
+    }
+}

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

@@ -702,46 +702,7 @@ function configurePlugins(options) {
             }
         }
         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,
-                }));
-            }
+            plugins.push(...(0, s3_upload_1.createS3UploadPlugins)(config, options.logger));
         }
     }
     return plugins;

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

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

package/dist/common/webpack/progress-plugin.js

@@ -28,10 +28,12 @@ const webpack = __importStar(require("webpack"));
 const pretty_time_1 = require("../logger/pretty-time");
 class ProgressPlugin extends webpack.ProgressPlugin {
     _logger;
+    _bundler;
     _state = {};
-    constructor({ logger }) {
+    constructor({ logger, bundler = 'webpack' }) {
         super();
         this._logger = logger;
+        this._bundler = bundler;
     }
     handler = (percent, message, ...details) => {
         const progress = Math.floor(percent * 100);
@@ -41,7 +43,12 @@ class ProgressPlugin extends webpack.ProgressPlugin {
         super.apply(compiler);
         hook(compiler, 'compile', () => {
             this._logger.message('Start compilation');
-            this._logger.message(`Webpack v${compiler.webpack.version}`);
+            // @ts-ignore
+            const compilerVersipn = this._bundler === 'webpack'
+                ? compiler.webpack.version
+                : // @ts-ignore
+                    compiler.webpack.rspackVersion;
+            this._logger.message(`${this._bundler} v${compilerVersipn}`);
             this._state.start = process.hrtime.bigint();
         });
         hook(compiler, 'invalid', (fileName, changeTime) => {

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

@@ -11,7 +11,7 @@ export declare function configureWebpackConfigForStorybook(mode: Mode, userConfi
     resolve: Webpack.ResolveOptions;
     plugins: (false | "" | 0 | ((this: Webpack.Compiler, compiler: Webpack.Compiler) => void) | Webpack.WebpackPluginInstance | null | undefined)[];
     optimization: {
-        minimizer: (false | "" | 0 | "..." | Webpack.WebpackPluginInstance | ((this: Webpack.Compiler, compiler: Webpack.Compiler) => void) | null | undefined)[] | undefined;
+        minimizer: (false | "" | 0 | Webpack.WebpackPluginInstance | "..." | ((this: Webpack.Compiler, compiler: Webpack.Compiler) => void) | null | undefined)[] | undefined;
     };
 }>;
 export {};