@gravity-ui/app-builder 0.14.0-beta.2 → 0.14.0-beta.4

package/README.md

@@ -192,8 +192,11 @@ With this `{rootDir}/src/ui/tsconfig.json`:
 - `forkTsCheker` (`false | ForkTsCheckerWebpackPluginOptions`) - config for ForkTsCheckerWebpackPlugin [more](https://github.com/TypeStrong/fork-ts-checker-webpack-plugin#options). If `false`, ForkTsCheckerWebpackPlugin will be disabled.
 - `cache` (`boolean | FileCacheOptions | MemoryCacheOptions`) — Cache the generated webpack modules and chunks to improve build speed. [more](https://webpack.js.org/configuration/cache/)
 - `babelCacheDirectory` (`boolean | string`) — Set directory for babel-loader cache (`default: node_modules/.cache/babel-loader``)
-- `babel` (`(config: babel.TransformOptions, options: {configType: 'development' | 'production'}) => babel.TransformOptions | Promise<babel.TransformOptions>`) - Allow override the default babel transform options.
-- `webpack` (`(config: webpack.Configuration, options: {configType: 'development' | 'production'}) => webpack.Configuration | Promise<webpack.Configuration>`) - Allow override the default configuration.
+- `babel` (`(config: babel.TransformOptions, options: {configType: 'development' | 'production'; isSsr: boolean}) => babel.TransformOptions | Promise<babel.TransformOptions>`) - Allow override the default babel transform options.
+- `webpack` (`(config: webpack.Configuration, options: {configType: 'development' | 'production'; isSsr: boolean}) => webpack.Configuration | Promise<webpack.Configuration>`) - Allow override the default configuration.
+- `ssr` - build SSR bundle. The SSR entries should be inside `src/ui/ssr` directory and match the client entries.
+  - `noExternal` (`string | RegExp | (string | RegExp)[] | true`) - prevent listed dependencies from being externalized for SSR. By default, all dependencies are externalized.
+  - `moduleType`: (`'commonjs' | 'esm'`) - library type for the SSR bundle, by default `commonjs`.
 
 ##### Dev build
 

package/dist/commands/dev/client.js

@@ -40,9 +40,6 @@ const config_1 = require("../../common/webpack/config");
 async function watchClientCompilation(config, onManifestReady) {
     const clientCompilation = await buildWebpackServer(config);
     const compiler = clientCompilation.compiler;
-    if ('compilers' in compiler) {
-        throw new Error('Unexpected multi compiler');
-    }
     subscribeToManifestReadyEvent(compiler, onManifestReady);
     return clientCompilation;
 }
@@ -50,7 +47,14 @@ async function buildWebpackServer(config) {
     const logger = new logger_1.Logger('webpack', 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 webpackConfig = await (0, config_1.webpackConfigFactory)("development" /* WebpackMode.Dev */, normalizedConfig, { logger });
+    const webpackConfigs = [
+        await (0, config_1.webpackConfigFactory)("development" /* WebpackMode.Dev */, normalizedConfig, { logger }),
+    ];
+    const isSsr = Boolean(normalizedConfig.ssr);
+    if (isSsr) {
+        const logger = new logger_1.Logger('webpack(SSR)', config.verbose);
+        webpackConfigs.push(await (0, config_1.webpackConfigFactory)("development" /* WebpackMode.Dev */, normalizedConfig, { logger, isSsr }));
+    }
     const publicPath = path.normalize(config.client.publicPathPrefix + '/build/');
     const staticFolder = path.resolve(paths_1.default.appDist, 'public');
     const options = {
@@ -58,7 +62,18 @@ async function buildWebpackServer(config) {
         devMiddleware: {
             publicPath,
             stats: 'errors-warnings',
-            writeToDisk,
+            writeToDisk: (target) => {
+                if (writeToDisk === true) {
+                    return true;
+                }
+                if (isSsr && target.startsWith(paths_1.default.appSsrBuild)) {
+                    return true;
+                }
+                if (typeof writeToDisk === 'function') {
+                    return writeToDisk(target);
+                }
+                return false;
+            },
         },
         liveReload: false,
         hot: true,
@@ -116,7 +131,7 @@ async function buildWebpackServer(config) {
         });
     }
     options.proxy = proxy;
-    const compiler = (0, webpack_1.default)(webpackConfig);
+    const compiler = (0, webpack_1.default)(webpackConfigs);
     const server = new webpack_dev_server_1.default(options, compiler);
     try {
         await server.start();
@@ -129,17 +144,28 @@ async function buildWebpackServer(config) {
     }
     return server;
 }
-function subscribeToManifestReadyEvent(compiler, onManifestReady) {
+function subscribeToManifestReadyEvent(webpackCompiler, onManifestReady) {
     const promises = [];
-    const assetsManifestPlugin = compiler.options.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 options = Array.isArray(webpackCompiler.options)
+        ? webpackCompiler.options
+        : [webpackCompiler.options];
+    const compilers = 'compilers' in webpackCompiler ? webpackCompiler.compilers : [webpackCompiler];
+    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);
+        }
+        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);
     }
-    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);
     Promise.all(promises).then(() => onManifestReady());
 }

package/dist/commands/dev/index.js

@@ -56,7 +56,7 @@ async function default_1(config) {
                 script: `${serverPath}/index.js`,
                 args: ['--dev', config.server.port ? `--port=${config.server.port}` : ''],
                 env: {
-                    ...(config.server.port ? { APP_PORT: config.server.port } : undefined),
+                    ...(config.server.port ? { APP_PORT: `${config.server.port}` } : undefined),
                 },
                 nodeArgs: inspect || inspectBrk
                     ? [`--${inspect ? 'inspect' : 'inspect-brk'}=:::${inspect || inspectBrk}`]

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

@@ -1,9 +1,13 @@
 export declare function babelPreset(config: {
     newJsxTransform?: boolean;
+    isSsr?: boolean;
 }): (string | {
     env: {
         modules: boolean;
         bugfixes: boolean;
+        targets: {
+            node: string;
+        } | undefined;
     };
     runtime: {
         version: string;

package/dist/common/babel/index.js

@@ -5,7 +5,11 @@ function babelPreset(config) {
     return [
         require.resolve('./ui-preset'),
         {
-            env: { modules: false, bugfixes: true },
+            env: {
+                modules: false,
+                bugfixes: true,
+                targets: config.isSsr ? { node: 'current' } : undefined,
+            },
             runtime: { version: '^7.13.10' },
             typescript: true,
             react: {

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

@@ -180,17 +180,23 @@ export interface ClientConfig {
      */
     webpack?: (config: Configuration, options: {
         configType: `${WebpackMode}`;
+        isSsr?: boolean;
     }) => Configuration | Promise<Configuration>;
     /**
      * Modify or return a custom Babel config.
      */
     babel?: (config: Babel.TransformOptions, options: {
         configType: `${WebpackMode}`;
+        isSsr: boolean;
     }) => Babel.TransformOptions | Promise<Babel.TransformOptions>;
     /**
      * Modify or return a custom [Terser options](https://github.com/terser/terser#minify-options).
      */
     terser?: (options: TerserOptions) => TerserOptions;
+    ssr?: {
+        noExternal?: string | RegExp | (string | RegExp)[] | true;
+        moduleType?: 'commonjs' | 'esm';
+    };
 }
 export interface CdnUploadConfig {
     bucket: string;
@@ -230,10 +236,12 @@ export type NormalizedClientConfig = Omit<ClientConfig, 'publicPathPrefix' | 'hi
     verbose?: boolean;
     webpack: (config: Configuration, options: {
         configType: `${WebpackMode}`;
+        isSsr: boolean;
     }) => Configuration | Promise<Configuration>;
     debugWebpack?: boolean;
     babel: (config: Babel.TransformOptions, options: {
         configType: `${WebpackMode}`;
+        isSsr: boolean;
     }) => Babel.TransformOptions | Promise<Babel.TransformOptions>;
     reactRefresh: NonNullable<ClientConfig['reactRefresh']>;
 };

package/dist/common/paths.d.ts

@@ -7,6 +7,8 @@ declare const _default: {
     appDist: string;
     appRun: string;
     appBuild: string;
+    appSsrEntry: string;
+    appSsrBuild: string;
     src: string;
     libBuild: string;
     libBuildEsm: string;

package/dist/common/paths.js

@@ -36,6 +36,8 @@ exports.default = {
     appDist: resolveApp('dist'),
     appRun: resolveApp('dist/run'),
     appBuild: resolveApp('dist/public/build'),
+    appSsrEntry: resolveApp('src/ui/ssr'),
+    appSsrBuild: resolveApp('dist/ssr'),
     src: resolveApp('src'),
     libBuild: resolveApp('build'),
     libBuildEsm: resolveApp('build/esm'),

package/dist/common/typescript/compile.js

@@ -10,24 +10,11 @@ function compile(ts, { projectPath, configFileName = 'tsconfig.json', optionsToE
     logger.message('Start compilation');
     logger.message(`Typescript v${ts.version}`);
     logger.verbose(`Searching for the ${configFileName} in ${projectPath}`);
-    const configPath = (0, utils_1.getProjectConfig)(ts, projectPath, configFileName);
-    const formatHost = {
-        getCanonicalFileName: (path) => path,
-        getCurrentDirectory: ts.sys.getCurrentDirectory,
-        getNewLine: () => ts.sys.newLine,
-    };
-    const parseConfigFileHost = {
-        getCurrentDirectory: ts.sys.getCurrentDirectory,
-        useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames,
-        readDirectory: ts.sys.readDirectory,
-        fileExists: ts.sys.fileExists,
-        readFile: ts.sys.readFile,
-        onUnRecoverableConfigFileDiagnostic: reportDiagnostic,
-    };
-    const parsedConfig = ts.getParsedCommandLineOfConfigFile(configPath, { noEmit: false, noEmitOnError: true, ...optionsToExtend }, parseConfigFileHost);
-    if (!parsedConfig) {
-        throw new Error(`Invalid '${configFileName}'`);
-    }
+    const parsedConfig = (0, utils_1.getTsProjectConfig)(ts, projectPath, configFileName, {
+        noEmit: false,
+        noEmitOnError: true,
+        ...optionsToExtend,
+    });
     logger.verbose('Config found and parsed');
     logger.verbose("We're about to create the program");
     const compilerHost = ts.createCompilerHost(parsedConfig.options);
@@ -57,6 +44,11 @@ function compile(ts, { projectPath, configFileName = 'tsconfig.json', optionsToE
     else {
         logger.success(`Compiled successfully in ${(0, pretty_time_1.elapsedTime)(start)}`);
     }
+    const formatHost = {
+        getCanonicalFileName: (path) => path,
+        getCurrentDirectory: ts.sys.getCurrentDirectory,
+        getNewLine: () => ts.sys.newLine,
+    };
     function reportDiagnostic(diagnostic) {
         if (logger.isVerbose) {
             logger.message(ts.formatDiagnosticsWithColorAndContext([diagnostic], formatHost));

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

@@ -1,6 +1,7 @@
 import type Typescript from 'typescript';
 import type { Logger } from '../logger';
-export declare function getProjectConfig(ts: typeof Typescript, projectPath: string, filename?: string): string;
+export declare function getTsProjectConfigPath(ts: typeof Typescript, projectPath: string, filename?: string): string;
+export declare function getTsProjectConfig(ts: typeof Typescript, projectPath: string, filename?: string, optionsToExtend?: Typescript.CompilerOptions): Typescript.ParsedCommandLine;
 export declare function displayFilename(originalFunc: (path: string, encoding?: string) => string | undefined, operationName: string, logger: Logger): {
     (path: string, encoding?: string | undefined): string | undefined;
     originalFunc: (path: string, encoding?: string) => string | undefined;

package/dist/common/typescript/utils.js

@@ -3,19 +3,37 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getProjectConfig = getProjectConfig;
+exports.getTsProjectConfigPath = getTsProjectConfigPath;
+exports.getTsProjectConfig = getTsProjectConfig;
 exports.displayFilename = displayFilename;
 exports.onHostEvent = onHostEvent;
 exports.resolveTypescript = resolveTypescript;
 const node_path_1 = __importDefault(require("node:path"));
 const paths_1 = __importDefault(require("../paths"));
-function getProjectConfig(ts, projectPath, filename = 'tsconfig.json') {
+function getTsProjectConfigPath(ts, projectPath, filename = 'tsconfig.json') {
     const configPath = ts.findConfigFile(projectPath, ts.sys.fileExists, filename);
     if (!configPath) {
         throw new Error(`Could not find a valid '${filename}'.`);
     }
     return configPath;
 }
+function getTsProjectConfig(ts, projectPath, filename = 'tsconfig.json', optionsToExtend) {
+    const configPath = getTsProjectConfigPath(ts, projectPath, filename);
+    const parseConfigFileHost = {
+        getCurrentDirectory: ts.sys.getCurrentDirectory,
+        useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames,
+        readDirectory: ts.sys.readDirectory,
+        fileExists: ts.sys.fileExists,
+        readFile: ts.sys.readFile,
+        // this is required in types but not used
+        onUnRecoverableConfigFileDiagnostic: () => { },
+    };
+    const parsedConfig = ts.getParsedCommandLineOfConfigFile(configPath, optionsToExtend, parseConfigFileHost);
+    if (!parsedConfig) {
+        throw new Error(`Invalid config file '${configPath}'`);
+    }
+    return parsedConfig;
+}
 function displayFilename(originalFunc, operationName, logger) {
     let displayEnabled = false;
     let count = 0;

package/dist/common/typescript/watch.js

@@ -7,7 +7,7 @@ const diagnostic_1 = require("./diagnostic");
 function watch(ts, projectPath, { logger, onAfterFilesEmitted, enableSourceMap, }) {
     logger.message('Start compilation in watch mode');
     logger.message(`Typescript v${ts.version}`);
-    const configPath = (0, utils_1.getProjectConfig)(ts, projectPath);
+    const configPath = (0, utils_1.getTsProjectConfigPath)(ts, projectPath);
     const createProgram = ts.createEmitAndSemanticDiagnosticsBuilderProgram;
     const formatHost = {
         getCanonicalFileName: (path) => path,

package/dist/common/webpack/compile.js

@@ -10,10 +10,15 @@ const config_1 = require("./config");
 const utils_1 = require("./utils");
 async function webpackCompile(config) {
     const logger = new logger_1.Logger('webpack', config.verbose);
-    const webpackConfig = await (0, config_1.webpackConfigFactory)("production" /* WebpackMode.Prod */, config, { logger });
+    const webpackConfigs = [await (0, config_1.webpackConfigFactory)("production" /* WebpackMode.Prod */, config, { logger })];
+    const isSsr = Boolean(config.ssr);
+    if (isSsr) {
+        const logger = new logger_1.Logger('webpack(SSR)', config.verbose);
+        webpackConfigs.push(await (0, config_1.webpackConfigFactory)("production" /* WebpackMode.Prod */, config, { logger, isSsr }));
+    }
     logger.verbose('Config created');
     return new Promise((resolve) => {
-        const compiler = (0, webpack_1.default)(webpackConfig, (0, utils_1.webpackCompilerHandlerFactory)(logger, async () => {
+        const compiler = (0, webpack_1.default)(webpackConfigs, (0, utils_1.webpackCompilerHandlerFactory)(logger, async () => {
             resolve();
         }));
         process.on('SIGINT', async () => {

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

@@ -7,16 +7,20 @@ export interface HelperOptions {
     isEnvDevelopment: boolean;
     isEnvProduction: boolean;
     configType: `${WebpackMode}`;
+    buildDirectory: string;
+    entriesDirectory: string;
+    isSsr: boolean;
 }
 export declare const enum WebpackMode {
     Prod = "production",
     Dev = "development"
 }
-export declare function webpackConfigFactory(webpackMode: WebpackMode, config: NormalizedClientConfig, { logger }?: {
+export declare function webpackConfigFactory(webpackMode: WebpackMode, config: NormalizedClientConfig, { logger, isSsr }?: {
     logger?: Logger;
+    isSsr?: boolean;
 }): Promise<webpack.Configuration>;
 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 }: HelperOptions): Optimization;
+export declare function configureOptimization({ config, isSsr }: HelperOptions): Optimization;
 export {};

package/dist/common/webpack/config.js

@@ -44,6 +44,7 @@ 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 webpack_node_externals_1 = __importDefault(require("webpack-node-externals"));
 const paths_1 = __importDefault(require("../paths"));
 const babel_1 = require("../babel");
 const progress_plugin_1 = require("./progress-plugin");
@@ -53,7 +54,7 @@ const log_config_1 = require("../logger/log-config");
 const utils_2 = require("../typescript/utils");
 const imagesSizeLimit = 2048;
 const fontSizeLimit = 8192;
-async function webpackConfigFactory(webpackMode, config, { logger } = {}) {
+async function webpackConfigFactory(webpackMode, config, { logger, isSsr = false } = {}) {
     const isEnvDevelopment = webpackMode === "development" /* WebpackMode.Dev */;
     const isEnvProduction = webpackMode === "production" /* WebpackMode.Prod */;
     const helperOptions = {
@@ -62,11 +63,25 @@ async function webpackConfigFactory(webpackMode, config, { logger } = {}) {
         isEnvDevelopment,
         isEnvProduction,
         configType: webpackMode,
+        buildDirectory: isSsr ? paths_1.default.appSsrBuild : paths_1.default.appBuild,
+        entriesDirectory: isSsr ? paths_1.default.appSsrEntry : paths_1.default.appEntry,
+        isSsr,
     };
+    let externals = config.externals;
+    if (isSsr) {
+        externals =
+            config.ssr?.noExternal === true
+                ? undefined
+                : (0, webpack_node_externals_1.default)({
+                    allowlist: config.ssr?.noExternal,
+                    importType: config.ssr?.moduleType === 'esm' ? 'module' : 'commonjs',
+                });
+    }
     let webpackConfig = {
         mode: webpackMode,
         context: paths_1.default.app,
         bail: isEnvProduction,
+        target: isSsr ? 'node' : undefined,
         devtool: configureDevTool(helperOptions),
         entry: configureEntry(helperOptions),
         output: configureOutput(helperOptions),
@@ -76,7 +91,7 @@ async function webpackConfigFactory(webpackMode, config, { logger } = {}) {
         },
         plugins: configurePlugins(helperOptions),
         optimization: configureOptimization(helperOptions),
-        externals: config.externals,
+        externals,
         node: config.node,
         watchOptions: configureWatchOptions(helperOptions),
         ignoreWarnings: [/Failed to parse source map/],
@@ -92,7 +107,7 @@ async function webpackConfigFactory(webpackMode, config, { logger } = {}) {
         },
         cache: config.cache,
     };
-    webpackConfig = await config.webpack(webpackConfig, { configType: webpackMode });
+    webpackConfig = await config.webpack(webpackConfig, { configType: webpackMode, isSsr });
     if (config.debugWebpack) {
         (0, log_config_1.logConfig)('Preview webpack config', webpackConfig);
     }
@@ -135,7 +150,10 @@ function configureWatchOptions({ config }) {
     delete watchOptions.watchPackages;
     return watchOptions;
 }
-function configureExperiments({ config, isEnvProduction, }) {
+function configureExperiments({ config, isEnvProduction, isSsr, }) {
+    if (isSsr) {
+        return config.ssr?.moduleType === 'esm' ? { outputModule: true } : undefined;
+    }
     if (isEnvProduction) {
         return undefined;
     }
@@ -174,7 +192,7 @@ function configureResolve({ isEnvProduction, config }) {
         alias['react-dom$'] = 'react-dom/profiling';
         alias['scheduler/tracing'] = 'scheduler/tracing-profiling';
     }
-    const { aliases, modules = [] } = (0, utils_1.resolveTsconfigPathsToAlias)(path.resolve(paths_1.default.appClient, 'tsconfig.json')) || {};
+    const { aliases, modules = [] } = (0, utils_1.resolveTsConfigPathsToAlias)(paths_1.default.appClient);
     return {
         alias: {
             ...aliases,
@@ -190,61 +208,74 @@ function createEntryArray(entry) {
     return [require.resolve('./public-path'), entry];
 }
 function addEntry(entry, file) {
-    const newEntry = path.resolve(paths_1.default.appEntry, file);
     return {
         ...entry,
-        [path.parse(file).name]: createEntryArray(newEntry),
+        [path.parse(file).name]: createEntryArray(file),
     };
 }
-function configureEntry({ config }) {
-    let entries = fs.readdirSync(paths_1.default.appEntry).filter((file) => /\.[jt]sx?$/.test(file));
+function configureEntry({ config, entriesDirectory }) {
+    let entries = fs.readdirSync(entriesDirectory).filter((file) => /\.[jt]sx?$/.test(file));
     if (Array.isArray(config.entryFilter) && config.entryFilter.length) {
         entries = entries.filter((entry) => config.entryFilter?.includes(entry.split('.')[0] ?? ''));
     }
     if (!entries.length) {
-        throw new Error('No entries were found after applying UI_CORE_ENTRY_FILTER');
+        throw new Error('No entries were found after applying entry filter');
     }
-    return entries.reduce((entry, file) => addEntry(entry, file), {});
+    return entries.reduce((entry, file) => addEntry(entry, path.resolve(entriesDirectory, file)), {});
 }
-function getFileNames({ isEnvProduction }) {
+function getFileNames({ isEnvProduction, isSsr, config }) {
+    let ext = 'js';
+    if (isSsr) {
+        ext = config.ssr?.moduleType === 'esm' ? 'mjs' : 'cjs';
+    }
     return {
-        filename: isEnvProduction ? 'js/[name].[contenthash:8].js' : 'js/[name].js',
+        filename: isEnvProduction ? `js/[name].[contenthash:8].${ext}` : `js/[name].${ext}`,
         chunkFilename: isEnvProduction
             ? 'js/[name].[contenthash:8].chunk.js'
             : 'js/[name].chunk.js',
     };
 }
-function configureOutput({ isEnvDevelopment, ...rest }) {
+function configureOutput(options) {
+    let ssrOptions;
+    if (options.isSsr) {
+        ssrOptions = {
+            library: { type: options.config.ssr?.moduleType === 'esm' ? 'module' : 'commonjs2' },
+            chunkFormat: false,
+        };
+    }
     return {
-        ...getFileNames({ isEnvDevelopment, ...rest }),
-        path: paths_1.default.appBuild,
-        pathinfo: isEnvDevelopment,
+        ...getFileNames(options),
+        path: options.buildDirectory,
+        pathinfo: options.isEnvDevelopment,
+        ...ssrOptions,
     };
 }
-function createJavaScriptLoader({ isEnvProduction, isEnvDevelopment, configType, config, }) {
+function createJavaScriptLoader({ isEnvProduction, isEnvDevelopment, configType, config, isSsr, }) {
     const plugins = [];
-    if (isEnvDevelopment && config.reactRefresh !== false) {
-        plugins.push([
-            require.resolve('react-refresh/babel'),
-            config.devServer?.webSocketPath
-                ? {
-                    overlay: {
-                        sockPath: config.devServer.webSocketPath,
-                    },
-                }
-                : undefined,
-        ]);
-    }
-    if (isEnvProduction) {
-        plugins.push([
-            require.resolve('babel-plugin-import'),
-            { libraryName: 'lodash', libraryDirectory: '', camel2DashComponentName: false },
-        ]);
+    if (!isSsr) {
+        if (isEnvDevelopment && config.reactRefresh !== false) {
+            plugins.push([
+                require.resolve('react-refresh/babel'),
+                config.devServer?.webSocketPath
+                    ? {
+                        overlay: {
+                            sockPath: config.devServer.webSocketPath,
+                        },
+                    }
+                    : undefined,
+            ]);
+        }
+        if (isEnvProduction) {
+            plugins.push([
+                require.resolve('babel-plugin-import'),
+                { libraryName: 'lodash', libraryDirectory: '', camel2DashComponentName: false },
+            ]);
+        }
     }
     const transformOptions = config.babel({
-        presets: [(0, babel_1.babelPreset)(config)],
+        presets: [(0, babel_1.babelPreset)({ newJsxTransform: config.newJsxTransform, isSsr })],
         plugins,
-    }, { configType });
+    }, { configType, isSsr });
     return {
         loader: require.resolve('babel-loader'),
         options: {
@@ -339,7 +370,7 @@ function createStylesRule(options) {
         use: loaders,
     };
 }
-function getCssLoaders({ isEnvDevelopment, isEnvProduction, config }, additionalRules) {
+function getCssLoaders({ isEnvDevelopment, isEnvProduction, config, isSsr }, additionalRules) {
     const loaders = [];
     if (!config.transformCssWithLightningCss) {
         loaders.push({
@@ -362,27 +393,38 @@ function getCssLoaders({ isEnvDevelopment, isEnvProduction, config }, additional
     loaders.unshift({
         loader: require.resolve('css-loader'),
         options: {
-            esModule: false,
+            url: {
+                filter: (url) => {
+                    // ignore data uri
+                    return !url.startsWith('data:');
+                },
+            },
             sourceMap: !config.disableSourceMapGeneration,
             importLoaders,
             modules: {
                 auto: true,
                 localIdentName: '[name]__[local]--[hash:base64:5]',
                 exportLocalsConvention: 'camelCase',
+                exportOnlyLocals: isSsr,
             },
         },
     });
     if (isEnvProduction) {
-        loaders.unshift(mini_css_extract_plugin_1.default.loader);
+        loaders.unshift({ loader: mini_css_extract_plugin_1.default.loader, options: { emit: !isSsr } });
     }
     if (isEnvDevelopment) {
-        loaders.unshift({
-            loader: require.resolve('style-loader'),
-        });
+        if (isSsr || config.ssr) {
+            loaders.unshift({ loader: mini_css_extract_plugin_1.default.loader, options: { emit: !isSsr } });
+        }
+        else {
+            loaders.unshift({
+                loader: require.resolve('style-loader'),
+            });
+        }
     }
     return loaders;
 }
-function createIconsRule({ isEnvProduction, config }, jsLoader) {
+function createIconsRule({ isEnvProduction, config, isSsr }, jsLoader) {
     const iconIncludes = config.icons || [];
     return {
         // eslint-disable-next-line security/detect-unsafe-regex
@@ -419,11 +461,12 @@ function createIconsRule({ isEnvProduction, config }, jsLoader) {
                 generator: {
                     filename: 'assets/images/[name].[contenthash:8][ext]',
                     publicPath: isEnvProduction ? '../' : undefined,
+                    emit: !isSsr,
                 },
             }),
     };
 }
-function createAssetsRules({ isEnvProduction, config }) {
+function createAssetsRules({ isEnvProduction, config, isSsr }) {
     const imagesRule = {
         test: /\.(ico|bmp|gif|jpe?g|png|svg)$/,
         include: [paths_1.default.appClient, ...(config.images || [])],
@@ -435,6 +478,7 @@ function createAssetsRules({ isEnvProduction, config }) {
         },
         generator: {
             filename: 'assets/images/[name].[contenthash:8][ext]',
+            emit: !isSsr,
         },
     };
     const fontsRule = {
@@ -448,6 +492,7 @@ function createAssetsRules({ isEnvProduction, config }) {
         },
         generator: {
             filename: 'assets/fonts/[name].[contenthash:8][ext]',
+            emit: !isSsr,
         },
     };
     const rules = [imagesRule, fontsRule];
@@ -467,6 +512,7 @@ function createAssetsRules({ isEnvProduction, config }) {
             generator: {
                 filename: 'assets/images/[name].[contenthash:8][ext]',
                 publicPath: '../',
+                emit: !isSsr,
             },
         }, {
             test: /\.(ttf|eot|woff2?)$/,
@@ -481,17 +527,19 @@ function createAssetsRules({ isEnvProduction, config }) {
             generator: {
                 filename: 'assets/fonts/[name].[contenthash:8][ext]',
                 publicPath: '../',
+                emit: !isSsr,
             },
         });
     }
     return rules;
 }
-function createFallbackRules({ isEnvProduction }) {
+function createFallbackRules({ isEnvProduction, isSsr }) {
     const rules = [
         {
             type: 'asset/resource',
             generator: {
                 filename: 'assets/[name].[contenthash:8][ext]',
+                emit: !isSsr,
             },
             exclude: [/\.[jt]sx?$/, /\.json$/, /\.[cm]js$/, /\.ejs$/],
         },
@@ -506,6 +554,7 @@ function createFallbackRules({ isEnvProduction }) {
             generator: {
                 filename: 'assets/[name].[contenthash:8][ext]',
                 publicPath: '../',
+                emit: !isSsr,
             },
         });
     }
@@ -520,7 +569,7 @@ function createMomentTimezoneDataPlugin(options = {}) {
     return new moment_timezone_data_webpack_plugin_1.default({ ...options, startYear, endYear });
 }
 function configurePlugins(options) {
-    const { isEnvDevelopment, isEnvProduction, config } = options;
+    const { isEnvDevelopment, isEnvProduction, config, isSsr } = options;
     const excludeFromClean = config.excludeFromClean || [];
     const manifestFile = 'assets-manifest.json';
     const plugins = [
@@ -544,11 +593,11 @@ function configurePlugins(options) {
             : {
                 entrypoints: true,
                 writeToDisk: true,
-                output: path.resolve(paths_1.default.appBuild, manifestFile),
+                output: path.resolve(options.buildDirectory, manifestFile),
             }),
-        createMomentTimezoneDataPlugin(config.momentTz),
         new webpack.DefinePlugin({
             'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV),
+            'process.env.IS_SSR': JSON.stringify(isSsr),
             ...config.definitions,
         }),
     ];
@@ -558,51 +607,12 @@ function configurePlugins(options) {
     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.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 (config.monaco) {
-        const MonacoEditorWebpackPlugin = require('monaco-editor-webpack-plugin');
-        plugins.push(new MonacoEditorWebpackPlugin({
-            filename: isEnvProduction ? '[name].[hash:8].worker.js' : undefined,
-            ...config.monaco,
-            // currently, workers located on cdn are not working properly, so we are enforcing loading workers from
-            // service instead
-            publicPath: path.normalize(config.publicPathPrefix + '/build/'),
-        }));
-    }
-    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({
-            overlay: { sockPath: webSocketPath },
-            exclude: [/node_modules/, /\.worker\.[jt]sx?$/],
-        })));
-    }
-    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.forkTsChecker !== false) {
         plugins.push(new fork_ts_checker_webpack_plugin_1.default({
             ...config.forkTsChecker,
             typescript: {
                 typescriptPath: (0, utils_2.resolveTypescript)(),
-                configFile: path.resolve(paths_1.default.app, 'src/ui/tsconfig.json'),
+                configFile: path.resolve(paths_1.default.appClient, 'tsconfig.json'),
                 diagnosticOptions: {
                     syntactic: true,
                 },
@@ -611,19 +621,17 @@ function configurePlugins(options) {
             },
         }));
     }
-    if (config.polyfill?.process) {
-        plugins.push(new webpack.ProvidePlugin({ process: 'process/browser.js' }));
+    if (config.detectCircularDependencies) {
+        let circularPluginOptions = {
+            exclude: /node_modules/,
+            allowAsyncCycles: true,
+        };
+        if (typeof config.detectCircularDependencies === 'object') {
+            circularPluginOptions = config.detectCircularDependencies;
+        }
+        plugins.push(new circular_dependency_plugin_1.default(circularPluginOptions));
     }
     if (isEnvProduction) {
-        plugins.push(new mini_css_extract_plugin_1.default({
-            filename: 'css/[name].[contenthash:8].css',
-            chunkFilename: 'css/[name].[contenthash:8].chunk.css',
-            ignoreOrder: true,
-        }));
-        if (config.sentryConfig) {
-            const sentryPlugin = require('@sentry/webpack-plugin').sentryWebpackPlugin;
-            plugins.push(sentryPlugin({ ...config.sentryConfig }));
-        }
         if (config.analyzeBundle === 'true') {
             plugins.push(new webpack_bundle_analyzer_1.BundleAnalyzerPlugin({
                 openAnalyzer: false,
@@ -634,8 +642,8 @@ function configurePlugins(options) {
         if (config.analyzeBundle === 'statoscope') {
             const customStatoscopeConfig = config.statoscopeConfig || {};
             plugins.push(new webpack_plugin_1.default({
-                saveReportTo: path.resolve(paths_1.default.appBuild, 'report.html'),
-                saveStatsTo: path.resolve(paths_1.default.appBuild, 'stats.json'),
+                saveReportTo: path.resolve(options.buildDirectory, 'report.html'),
+                saveStatsTo: path.resolve(options.buildDirectory, 'stats.json'),
                 open: false,
                 statsOptions: {
                     all: true,
@@ -644,50 +652,104 @@ 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,
-            };
+    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) {
+            const MonacoEditorWebpackPlugin = require('monaco-editor-webpack-plugin');
+            plugins.push(new MonacoEditorWebpackPlugin({
+                filename: isEnvProduction ? '[name].[hash:8].worker.js' : undefined,
+                ...config.monaco,
+                // currently, workers located on cdn are not working properly, so we are enforcing loading workers from
+                // service instead
+                publicPath: path.normalize(config.publicPathPrefix + '/build/'),
+            }));
+        }
+        const contextReplacement = config.contextReplacement || {};
+        plugins.push(createMomentTimezoneDataPlugin(config.momentTz));
+        plugins.push(new 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('|')})$`)));
         }
-        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;
+        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({
+                overlay: { sockPath: webSocketPath },
+                exclude: [/node_modules/, /\.worker\.[jt]sx?$/],
+            })));
+        }
+        if (config.polyfill?.process) {
+            plugins.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 }));
             }
-            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,
+        }
+        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,
                 };
             }
-            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,
-            }));
+            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,
+                }));
+            }
         }
     }
     return plugins;
 }
-function configureOptimization({ config }) {
+function configureOptimization({ config, isSsr }) {
+    if (isSsr) {
+        return {};
+    }
     const configVendors = config.vendors ?? [];
     let vendorsList = [
         'react',

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

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

package/dist/common/webpack/storybook.js

@@ -35,6 +35,7 @@ const css_minimizer_webpack_plugin_1 = __importDefault(require("css-minimizer-we
 const config_1 = require("./config");
 const config_2 = require("../config");
 const models_1 = require("../models");
+const paths_1 = __importDefault(require("../paths"));
 async function configureServiceWebpackConfig(mode, storybookConfig) {
     const serviceConfig = await (0, config_2.getProjectConfig)(mode === "production" /* WebpackMode.Prod */ ? 'build' : 'dev', {
         storybook: true,
@@ -104,6 +105,9 @@ async function configureWebpackConfigForStorybook(mode, userConfig = {}, storybo
         isEnvProduction,
         config: config.client,
         configType: mode,
+        buildDirectory: paths_1.default.appBuild,
+        entriesDirectory: paths_1.default.appEntry,
+        isSsr: false,
     };
     return {
         module: {

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

@@ -1,7 +1,10 @@
 import type webpack from 'webpack';
 import type { Logger } from '../logger';
-export declare function webpackCompilerHandlerFactory(logger: Logger, onCompilationEnd?: () => void): (err?: Error | null, stats?: webpack.Stats) => Promise<void>;
-export declare function resolveTsconfigPathsToAlias(tsConfigPath: string): {
+export declare function webpackCompilerHandlerFactory(logger: Logger, onCompilationEnd?: () => void): (err?: Error | null, stats?: webpack.MultiStats) => Promise<void>;
+export declare function resolveTsConfigPathsToAlias(projectPath: string, filename?: string): {
+    aliases?: undefined;
+    modules?: undefined;
+} | {
     aliases: Record<string, string[]>;
     modules: string[];
-} | undefined;
+};

package/dist/common/webpack/utils.js

@@ -24,10 +24,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.webpackCompilerHandlerFactory = webpackCompilerHandlerFactory;
-exports.resolveTsconfigPathsToAlias = resolveTsconfigPathsToAlias;
+exports.resolveTsConfigPathsToAlias = resolveTsConfigPathsToAlias;
 const path = __importStar(require("node:path"));
-const fs = __importStar(require("node:fs"));
+const ts = __importStar(require("typescript"));
 const pretty_time_1 = require("../logger/pretty-time");
+const utils_1 = require("../typescript/utils");
 function webpackCompilerHandlerFactory(logger, onCompilationEnd) {
     return async (err, stats) => {
         if (err) {
@@ -50,25 +51,37 @@ function webpackCompilerHandlerFactory(logger, onCompilationEnd) {
         if (onCompilationEnd) {
             await onCompilationEnd();
         }
-        if (stats) {
-            const time = stats.endTime - stats.startTime;
+        const [clientStats, ssrStats] = stats?.stats ?? [];
+        if (clientStats) {
+            const time = clientStats.endTime - clientStats.startTime;
             logger.success(`Client was successfully compiled in ${(0, pretty_time_1.prettyTime)(BigInt(time) * BigInt(1_000_000))}`);
         }
-        else {
+        if (ssrStats) {
+            const time = ssrStats.endTime - ssrStats.startTime;
+            logger.success(`SSR: Client was successfully compiled in ${(0, pretty_time_1.prettyTime)(BigInt(time) * BigInt(1_000_000))}`);
+        }
+        if (!clientStats && !ssrStats) {
             logger.success(`Client was successfully compiled`);
         }
     };
 }
 const endStarRe = /\/?\*$/;
-function resolveTsconfigPathsToAlias(tsConfigPath) {
-    if (!fs.existsSync(tsConfigPath) || !fs.statSync(tsConfigPath).isFile) {
-        return undefined;
+function resolveTsConfigPathsToAlias(projectPath, filename = 'tsconfig.json') {
+    let parsed;
+    try {
+        parsed = (0, utils_1.getTsProjectConfig)(ts, projectPath, filename);
+    }
+    catch {
+        return {};
+    }
+    if (parsed.errors.length > 0) {
+        return {};
     }
-    const { paths = {}, baseUrl } = readJsonConfig(tsConfigPath).compilerOptions || {};
+    const { paths = {}, baseUrl } = parsed.options;
     if (!baseUrl) {
-        return undefined;
+        return {};
     }
-    const basePath = path.resolve(path.dirname(tsConfigPath), baseUrl);
+    const basePath = path.resolve(path.dirname(projectPath), baseUrl);
     const aliases = {};
     const modules = [basePath];
     for (const [key, value] of Object.entries(paths)) {
@@ -84,14 +97,3 @@ function resolveTsconfigPathsToAlias(tsConfigPath) {
     }
     return { aliases, modules };
 }
-function readJsonConfig(pathname) {
-    try {
-        const json = fs.readFileSync(pathname, 'utf-8');
-        return {
-            ...JSON.parse(json),
-        };
-    }
-    catch {
-        throw new Error(`Couldn't read config ${pathname}`);
-    }
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gravity-ui/app-builder",
-  "version": "0.14.0-beta.2",
+  "version": "0.14.0-beta.4",
   "description": "Develop and build your React client-server projects, powered by typescript and webpack",
   "license": "MIT",
   "type": "commonjs",
@@ -129,6 +129,7 @@
     "webpack-bundle-analyzer": "^4.10.2",
     "webpack-dev-server": "^5.1.0",
     "webpack-manifest-plugin": "^5.0.0",
+    "webpack-node-externals": "^3.0.0",
     "worker-loader": "^3.0.8",
     "yargs": "^17.7.2"
   },
@@ -152,6 +153,7 @@
     "@types/webpack-assets-manifest": "^5.1.4",
     "@types/webpack-bundle-analyzer": "^4.7.0",
     "@types/webpack-manifest-plugin": "^3.0.8",
+    "@types/webpack-node-externals": "^3.0.4",
     "@types/yargs": "17.0.11",
     "babel-plugin-tester": "^11.0.4",
     "eslint": "^8.57.0",