@tramvai/cli 5.49.1 → 6.59.0

package/src/api/start/application.experimental.ts

@@ -0,0 +1,305 @@
+import path from 'node:path';
+import type { Container } from '@tinkoff/dippy';
+import { StartParameters, start } from '@tramvai/api/lib/api/start';
+import { ApplicationProject, Configuration } from '@tramvai/api/lib/config';
+import {
+  COMMAND_PARAMETERS_TOKEN,
+  CONFIG_ENTRY_TOKEN,
+  CONFIG_ROOT_DIR_TOKEN,
+} from '../../di/tokens';
+import { getTramvaiConfig } from '../../utils/getTramvaiConfig';
+import { ApplicationConfigEntry } from '../../typings/configEntry/application';
+import type { Params, Result } from './index';
+
+declare global {
+  // eslint-disable-next-line no-var, vars-on-top
+  var __TRAMVAI_EXIT_HANDLERS__: Array<() => Promise<any>>;
+}
+
+export const startApplicationExperimental = async (di: Container): Result => {
+  const configEntry = di.get(CONFIG_ENTRY_TOKEN);
+  const options = di.get(COMMAND_PARAMETERS_TOKEN as Params);
+  const rootDir = di.get(CONFIG_ROOT_DIR_TOKEN);
+
+  const inputParameters: StartParameters = {
+    name: configEntry.name,
+    mode: 'development',
+    buildType: options.buildType,
+    port: options.port,
+    host: options.host,
+    staticPort: options.staticPort,
+    staticHost: options.staticHost,
+    noServerRebuild: options.noServerRebuild,
+    noClientRebuild: options.noClientRebuild,
+    resolveSymlinks: options.resolveSymlinks,
+    fileCache: options.fileCache,
+    showProgress: true,
+    verboseLogging: options.verboseWebpack,
+  };
+
+  const { content, projects } = mapTramvaiJsonToNewTsConfig({ rootDir });
+
+  const hasSwcTranspiler = Object.values(content.projects).some((project) => {
+    if (
+      project.type !== 'application' ||
+      !(project as ApplicationConfigEntry).experiments?.transpilation
+    ) {
+      return false;
+    }
+    const { loader } = (project as ApplicationConfigEntry).experiments.transpilation;
+
+    if (typeof loader === 'string') {
+      // @ts-expect-error
+      return loader === 'swc';
+    }
+    // @ts-expect-error
+    return loader.development === 'swc';
+  });
+  const hasPwa = Object.values(content.projects).some((project) => {
+    if (project.type !== 'application' || !(project as ApplicationConfigEntry).experiments) {
+      return false;
+    }
+    const { pwa } = (project as ApplicationConfigEntry).experiments;
+    return !!pwa;
+  });
+
+  const extraConfiguration: Partial<Configuration> = {
+    projects,
+    plugins: [
+      '@tramvai/plugin-webpack-builder',
+      hasSwcTranspiler ? '@tramvai/plugin-swc-transpiler' : '@tramvai/plugin-babel-transpiler',
+      hasPwa && '@tramvai/plugin-webpack-pwa',
+    ].filter(Boolean),
+  };
+
+  const devServer = await start(inputParameters, extraConfiguration);
+
+  // CLI will wait for this handlers before exiting
+  // @reference `packages/cli/src/cli/runCLI.ts`
+  if (!global.__TRAMVAI_EXIT_HANDLERS__) {
+    global.__TRAMVAI_EXIT_HANDLERS__ = [];
+  }
+
+  global.__TRAMVAI_EXIT_HANDLERS__.push(async () => {
+    await devServer?.close?.();
+  });
+
+  try {
+    await devServer.buildPromise;
+  } catch (e) {
+    // some webpack build errors can be safely ignored
+    // TODO: strictErrorHandle parameter? used in `packages/cli/src/library/swc/__integration__/swc.start.test.ts` for old cli
+  }
+
+  return {
+    server: devServer.httpServer,
+    staticServer: devServer.staticHttpServer,
+    close: async () => {
+      await devServer.close();
+    },
+    invalidate: async () => {
+      await devServer.invalidate();
+    },
+    getBuildStats: () => {
+      return {};
+    },
+    builder: {
+      name: '@tramvai/plugin-webpack-builder',
+      start: async (options) => {
+        return {
+          close: async () => {
+            await devServer.close();
+          },
+          invalidate: async () => {
+            await devServer.invalidate();
+          },
+          getBuildStats: () => {
+            return {};
+          },
+        };
+      },
+      build: async (options) => {
+        return {
+          getBuildStats: () => {
+            return {};
+          },
+        };
+      },
+      analyze: async (options) => {},
+      on: (event, callback) => {
+        // TODO useful events as public new devServer API
+      },
+    },
+  };
+};
+
+/**
+ * Mapping from tramvai.json config format to new tramvai.config.ts,
+ * for seamless migration
+ */
+// eslint-disable-next-line max-statements, complexity
+function mapTramvaiJsonToNewTsConfig({ rootDir }: { rootDir: string }) {
+  const { content } = getTramvaiConfig(rootDir);
+  const projects: Configuration['projects'] = {};
+
+  for (const projectName in content.projects) {
+    const project = content.projects[projectName];
+
+    if (project.type === 'application') {
+      const applicationProject = project as ApplicationConfigEntry;
+
+      const mappedProject: ApplicationProject = {
+        name: projectName,
+        type: 'application',
+        deprecatedLessSupport: true,
+      };
+
+      if (applicationProject.root) {
+        mappedProject.sourceDir = applicationProject.root;
+      }
+      if (applicationProject.output) {
+        mappedProject.output = {};
+
+        if (applicationProject.output.server) {
+          mappedProject.output.server = applicationProject.output.server;
+        }
+        if (applicationProject.output.client) {
+          mappedProject.output.client = applicationProject.output.client;
+        }
+        if (applicationProject.output.static) {
+          mappedProject.output.static = applicationProject.output.static;
+        }
+      }
+      if (applicationProject.fileSystemPages) {
+        mappedProject.fileSystemPages = applicationProject.fileSystemPages;
+      }
+      if (applicationProject.experiments && 'runtimeChunk' in applicationProject.experiments) {
+        mappedProject.runtimeChunk = applicationProject.experiments.runtimeChunk;
+      }
+      if (applicationProject.experiments && 'viewTransitions' in applicationProject.experiments) {
+        mappedProject.experiments.viewTransitions = applicationProject.experiments.viewTransitions;
+      }
+      if (applicationProject.experiments && 'reactTransitions' in applicationProject.experiments) {
+        mappedProject.experiments.reactTransitions =
+          applicationProject.experiments.reactTransitions;
+      }
+      if (
+        applicationProject.experiments &&
+        'enableFillDeclareActionNamePlugin' in applicationProject.experiments
+      ) {
+        mappedProject.enableFillDeclareActionNamePlugin =
+          applicationProject.experiments.enableFillDeclareActionNamePlugin;
+      }
+      if (applicationProject.serverApiDir) {
+        mappedProject.fileSystemPapiDir = path.resolve(applicationProject.serverApiDir);
+      }
+      if (applicationProject.postcss) {
+        mappedProject.postcss = applicationProject.postcss;
+
+        if (mappedProject.postcss.config) {
+          // TODO file outside src dir
+          if (mappedProject.postcss.config.startsWith(applicationProject.root)) {
+            mappedProject.postcss.config = mappedProject.postcss.config.replace(
+              `${applicationProject.root}/`,
+              ''
+            );
+          } else if (mappedProject.postcss.config.startsWith('./')) {
+            mappedProject.postcss.config = path.resolve(mappedProject.postcss.config);
+          }
+        }
+      }
+      if (applicationProject.polyfill) {
+        try {
+          if (require.resolve(mappedProject.polyfill).includes('node_modules')) {
+            mappedProject.polyfill = require.resolve(applicationProject.polyfill);
+          } else {
+            mappedProject.polyfill = path.resolve(applicationProject.polyfill);
+          }
+        } catch (e) {
+          mappedProject.polyfill = path.resolve(applicationProject.polyfill);
+        }
+      }
+      if (applicationProject.modernPolyfill) {
+        try {
+          if (require.resolve(mappedProject.modernPolyfill).includes('node_modules')) {
+            mappedProject.polyfill = require.resolve(applicationProject.modernPolyfill);
+          } else {
+            mappedProject.polyfill = path.resolve(applicationProject.modernPolyfill);
+          }
+        } catch (e) {
+          mappedProject.polyfill = path.resolve(applicationProject.modernPolyfill);
+        }
+      }
+      if (applicationProject.dedupe) {
+        mappedProject.dedupe = applicationProject.dedupe;
+      }
+      if ('integrity' in applicationProject) {
+        if (typeof applicationProject.integrity === 'boolean') {
+          mappedProject.integrity = {
+            enabled: applicationProject.integrity,
+          };
+        } else {
+          // @ts-expect-error inconsistent `hashFuncNames` types
+          mappedProject.integrity = applicationProject.integrity;
+        }
+      }
+      if (
+        applicationProject.splitChunks &&
+        (applicationProject.splitChunks.mode === 'granularChunks' ||
+          applicationProject.splitChunks.mode === false)
+      ) {
+        // @ts-expect-error `commonChunk` is not supported in new cli
+        mappedProject.splitChunks = applicationProject.splitChunks;
+      }
+      if (applicationProject.webpack?.resolveAlias) {
+        if (!mappedProject.webpack) {
+          mappedProject.webpack = {};
+        }
+        mappedProject.webpack.resolveAlias = applicationProject.webpack.resolveAlias;
+      }
+      if (applicationProject.webpack?.provide) {
+        if (!mappedProject.webpack) {
+          mappedProject.webpack = {};
+        }
+        mappedProject.webpack.provide = applicationProject.webpack.provide;
+      }
+      if (applicationProject.webpack?.watchOptions) {
+        if (!mappedProject.webpack) {
+          mappedProject.webpack = {};
+        }
+        mappedProject.webpack.watchOptions = applicationProject.webpack.watchOptions;
+      }
+      if (applicationProject.webpack && 'devtool' in applicationProject.webpack) {
+        if (!mappedProject.webpack) {
+          mappedProject.webpack = {};
+        }
+        mappedProject.webpack.devtool = applicationProject.webpack.devtool;
+      }
+      if (applicationProject.experiments?.pwa) {
+        mappedProject.pwa = {
+          workbox: {
+            ...applicationProject.experiments.pwa.workbox,
+            enabled:
+              typeof applicationProject.experiments.pwa.workbox.enabled === 'boolean'
+                ? applicationProject.experiments.pwa.workbox.enabled
+                : applicationProject.experiments.pwa.workbox.enabled.development,
+          },
+          sw: applicationProject.experiments.pwa.sw,
+          webmanifest: applicationProject.experiments.pwa.webmanifest,
+          icon: applicationProject.experiments.pwa.icon,
+          meta: applicationProject.experiments.pwa.meta,
+        };
+      }
+      if (applicationProject.externals) {
+        if (!mappedProject.webpack) {
+          mappedProject.webpack = {};
+        }
+        mappedProject.webpack.externals = applicationProject.externals;
+      }
+
+      projects[projectName] = mappedProject;
+    }
+  }
+
+  return { content, projects };
+}

package/src/api/start/index.ts

@@ -3,10 +3,7 @@ import type { PromiseType } from 'utility-types';
 import type { Provider } from '@tinkoff/dippy';
 import { createCommand } from '../../commands/createCommand';
 import type { WithConfig } from '../shared/types/withConfig';
-import { startApplication } from './application';
-import { startModule } from './module';
-import { CONFIG_ENTRY_TOKEN, PORT_MANAGER_TOKEN } from '../../di/tokens';
-import { startChildApp } from './child-app';
+import { COMMAND_PARAMETERS_TOKEN, CONFIG_ENTRY_TOKEN, PORT_MANAGER_TOKEN } from '../../di/tokens';
 import type { Builder } from '../../typings/build/Builder';
 
 export type Params = WithConfig<{
@@ -22,7 +19,6 @@ export type Params = WithConfig<{
   trace?: boolean;
   verboseWebpack?: boolean;
   profile?: boolean;
-  modern?: boolean;
   sourceMap?: boolean;
   noServerRebuild?: boolean;
   noClientRebuild?: boolean;
@@ -34,6 +30,7 @@ export type Params = WithConfig<{
   onlyBundles?: string[];
   strictErrorHandle?: boolean;
   fileCache?: boolean;
+  experimentalWebpackWorkerThreads?: boolean;
 }>;
 
 export type Result<T extends string = any> = Promise<
@@ -50,17 +47,35 @@ export type StartCommand = (params: Params, providers?: Provider[]) => Result;
 export default createCommand({
   name: 'start',
   command: async (di): Result => {
+    const options = di.get(COMMAND_PARAMETERS_TOKEN as Params);
     const configEntry = di.get(CONFIG_ENTRY_TOKEN);
     const portManager = di.get(PORT_MANAGER_TOKEN);
 
+    if (options.experimentalWebpackWorkerThreads) {
+      if (configEntry.type !== 'application') {
+        throw new Error(
+          '--experimentalWebpackWorkerThreads option is only available for application project'
+        );
+      }
+
+      const { startApplicationExperimental } = require('./application.experimental');
+      return startApplicationExperimental(di);
+    }
+
     await portManager.computeAvailablePorts();
 
     switch (configEntry.type) {
       case 'application':
+        // eslint-disable-next-line no-case-declarations
+        const { startApplication } = require('./application');
         return startApplication(di);
       case 'module':
+        // eslint-disable-next-line no-case-declarations
+        const { startModule } = require('./module');
         return startModule(di);
       case 'child-app':
+        // eslint-disable-next-line no-case-declarations
+        const { startChildApp } = require('./child-app');
         return startChildApp(di);
     }
   },

package/src/api/start/utils/banner.ts

@@ -25,7 +25,6 @@ export function showBanner(di: Container) {
   if (config.type !== 'application') {
     titleLines.push(`${label('Type')}             ${config.type}`);
   }
-  titleLines.push(`${label('Modern')}           ${config.modern}`);
   titleLines.push(`${label('ReactRefresh')}     ${config.hotRefresh.enabled}`);
 
   if (isApplication(config) && config.fileSystemPages.enabled) {

package/src/api/start/utils/tips/tips.ts

@@ -26,15 +26,6 @@ Consider to test out swc support.`,
       return configManager.experiments?.transpilation?.loader !== 'swc';
     },
   },
-  {
-    text: `Ship modern code to browser`,
-    docLink: 'how-to/how-enable-modern',
-    isApplicable(di) {
-      const configManager = di.get(CONFIG_MANAGER_TOKEN);
-
-      return configManager.modern !== true;
-    },
-  },
   {
     text: `Forget about reloading page with hotRefresh cli option`,
     docLink: 'references/cli/start/#react-hot-refresh',

package/src/builder/webpack/devServer/pool/process/pool.ts

@@ -28,8 +28,6 @@ export const ProcessWorkerBridge: WorkerBridgeFactory<Worker> = (di) => {
           getDebugArg(configManager.debug),
           configManager.trace ? TRACE_ARGV : []
         ),
-        // устанавливаем в качестве дебага дефолтный порт мастера, т.к. у нас и так один процесс может работать
-        inspectPort: process.debugPort,
         silent: true,
         // @ts-ignore
         cwd: di.get(CONFIG_ROOT_DIR_TOKEN),

package/src/builder/webpack/devServer/server.ts

@@ -241,6 +241,11 @@ export const serverRunner = ({
 
     // Проксируем также и веб-сокеты
     server.on('upgrade', (req, socket, head) => {
+      // prevent uncaughtException when WS is not supported in application server
+      socket.on('error', (err) => {
+        console.error('[dev-server-error] websocket proxy error', err.message);
+      });
+
       proxy.ws(req, socket, { target: `http://localhost:${workerPort}` });
     });
 

package/src/builder/webpack/devServer/setup.ts

@@ -84,6 +84,7 @@ export const createDevServer = ({
     if (configManager.hotRefresh.enabled) {
       app.use(
         getHotModulePrefix(configManager),
+        // @ts-ignore - https://github.com/DefinitelyTyped/DefinitelyTyped/pull/73338
         webpackHotMiddleware(compiler, { log: false, statsOptions: { cached: false } })
       );
     }

package/src/builder/webpack/index.ts

@@ -24,7 +24,6 @@ import { resolveDone } from './utils/resolveDone';
 import { registerProviders } from '../../utils/di';
 import { buildClientSharedProviders } from './providers/build/clientShared';
 import { buildClientProviders } from './providers/build/client';
-import { buildClientModernProviders } from './providers/build/clientModern';
 import { buildServerProviders } from './providers/build/server';
 import { CONFIG_MANAGER_TOKEN } from '../../di/tokens';
 import { buildApplicationServerProviders } from './providers/build/application/server';
@@ -38,7 +37,7 @@ export const webpackProviders: Provider[] = [
     useFactory: ({ di }) => {
       return {
         name: BUILDER_NAME,
-        createBuilder({ options: { shouldBuildClient, shouldBuildServer, onlyModern } }) {
+        createBuilder({ options: { shouldBuildClient, shouldBuildServer } }) {
           registerProviders(di, [
             ...sharedProviders,
             ...(shouldBuildClient ? clientProviders : []),
@@ -83,11 +82,10 @@ export const webpackProviders: Provider[] = [
                 getBuildStats,
               };
             },
-            async build({ modern }) {
+            async build() {
               registerProviders(di, [
                 ...(shouldBuildClient ? buildClientSharedProviders : []),
-                ...(shouldBuildClient && !onlyModern ? buildClientProviders : []),
-                ...(shouldBuildClient && modern ? buildClientModernProviders : []),
+                ...(shouldBuildClient ? buildClientProviders : []),
                 ...(shouldBuildServer ? buildServerProviders : []),
               ]);
 

package/src/builder/webpack/providers/analyze/shared.ts

@@ -10,10 +10,6 @@ import {
 } from '../../../../di/tokens';
 import { toWebpackConfig } from '../../../../library/webpack/utils/toWebpackConfig';
 import { npmRequire, npmRequireList } from '../../../../utils/npmRequire';
-import { BundleAnalyzePlugin } from '../../analyzePlugins/bundle';
-import { StatoscopeAnalyzePlugin } from '../../analyzePlugins/statoscope';
-import { WhyBundledAnalyzePlugin } from '../../analyzePlugins/whyBundled';
-import { RsdoctorAnalyzePlugin } from '../../analyzePlugins/rsdoctor';
 import {
   CLIENT_CONFIG_MANAGER_TOKEN,
   INIT_HANDLER_TOKEN,
@@ -31,18 +27,18 @@ interface Type<T> extends Function {
   new (...args: any[]): T;
 }
 
-const pluginMap: Record<string, Type<AnalyzePlugin>> = {
-  bundle: BundleAnalyzePlugin,
-  whybundled: WhyBundledAnalyzePlugin,
-  statoscope: StatoscopeAnalyzePlugin,
-  rsdoctor: RsdoctorAnalyzePlugin,
+const pluginMap: Record<string, () => Type<AnalyzePlugin>> = {
+  bundle: () => require('../../analyzePlugins/bundle').BundleAnalyzePlugin,
+  whybundled: () => require('../../analyzePlugins/whyBundled').WhyBundledAnalyzePlugin,
+  statoscope: () => require('../../analyzePlugins/statoscope').StatoscopeAnalyzePlugin,
+  rsdoctor: () => require('../../analyzePlugins/rsdoctor').RsdoctorAnalyzePlugin,
 };
 
 export const analyzeSharedProviders: Provider[] = [
   provide({
     provide: WEBPACK_ANALYZE_PLUGIN_TOKEN,
     useFactory: ({ pluginName }) => {
-      const PluginClass = pluginMap[pluginName];
+      const PluginClass = pluginMap[pluginName]();
 
       if (!PluginClass) {
         throw new Error('Set correct plugin option');

package/src/builder/webpack/providers/build/client.ts

@@ -19,7 +19,6 @@ export const buildClientProviders: Provider[] = [
     useFactory: ({ configManager }) => {
       return configManager.withSettings({
         buildType: 'client',
-        modern: false,
       });
     },
     deps: {

package/src/builder/webpack/providers/build/clientShared.ts

@@ -4,32 +4,27 @@ import { provide } from '@tinkoff/dippy';
 import rimraf from 'rimraf';
 import { CLI_PACKAGE_MANAGER, CLI_ROOT_DIR_TOKEN } from '../../../../di/tokens';
 import { npmRequire } from '../../../../utils/npmRequire';
-import {
-  CLIENT_CONFIG_MANAGER_TOKEN,
-  CLIENT_MODERN_CONFIG_MANAGER_TOKEN,
-  INIT_HANDLER_TOKEN,
-} from '../../tokens';
+import { CLIENT_CONFIG_MANAGER_TOKEN, INIT_HANDLER_TOKEN } from '../../tokens';
 
 export const buildClientSharedProviders: Provider[] = [
   provide({
     provide: INIT_HANDLER_TOKEN,
     multi: true,
-    useFactory: ({ configManager, modernConfigManager }) => {
+    useFactory: ({ configManager }) => {
       return function clearBuildDir() {
-        return rimraf.sync(`${(configManager || modernConfigManager).buildPath}/**`, {});
+        return rimraf.sync(`${configManager.buildPath}/**`, {});
       };
     },
     deps: {
       configManager: optional(CLIENT_CONFIG_MANAGER_TOKEN),
-      modernConfigManager: optional(CLIENT_MODERN_CONFIG_MANAGER_TOKEN),
     },
   }),
   provide({
     provide: INIT_HANDLER_TOKEN,
     multi: true,
-    useFactory: ({ configManager, modernConfigManager, rootDir, packageManager }) => {
+    useFactory: ({ configManager, rootDir, packageManager }) => {
       return async function prepareImageOptimization() {
-        if ((configManager || modernConfigManager).imageOptimization?.enabled) {
+        if (configManager.imageOptimization?.enabled) {
           await npmRequire({
             cliRootDir: rootDir,
             packageManager,
@@ -41,7 +36,6 @@ export const buildClientSharedProviders: Provider[] = [
     },
     deps: {
       configManager: optional(CLIENT_CONFIG_MANAGER_TOKEN),
-      modernConfigManager: optional(CLIENT_MODERN_CONFIG_MANAGER_TOKEN),
       rootDir: CLI_ROOT_DIR_TOKEN,
       packageManager: CLI_PACKAGE_MANAGER,
     },

package/src/builder/webpack/providers/client.ts

@@ -3,27 +3,25 @@ import { provide } from '@tinkoff/dippy';
 import { UI_SHOW_PROGRESS_TOKEN } from '../../../di/tokens';
 import type { Env } from '../../../typings/Env';
 import type { ProjectType } from '../../../typings/projectType';
-import {
-  CLIENT_CONFIG_MANAGER_TOKEN,
-  CLIENT_MODERN_CONFIG_MANAGER_TOKEN,
-  WEBPACK_CLIENT_CONFIG_TOKEN,
-  WEBPACK_CLIENT_MODERN_CONFIG_TOKEN,
-} from '../tokens';
+import { CLIENT_CONFIG_MANAGER_TOKEN, WEBPACK_CLIENT_CONFIG_TOKEN } from '../tokens';
 import { CONFIG_GENERATOR_STUB } from '../stubs/config';
 import type { ConfigGenerator } from '../types';
 
-const CONFIG_MAP: Record<Env, Record<ProjectType, ConfigGenerator>> = {
+const CONFIG_MAP: Record<Env, Record<ProjectType, () => ConfigGenerator>> = {
   development: {
-    application: require('../../../library/webpack/application/client/dev').webpackClientConfig,
-    module: require('../../../library/webpack/module/client/dev').webpackClientConfig,
-    'child-app': require('../../../library/webpack/child-app/client/dev').webpackClientConfig,
-    package: CONFIG_GENERATOR_STUB,
+    application: () =>
+      require('../../../library/webpack/application/client/dev').webpackClientConfig,
+    module: () => require('../../../library/webpack/module/client/dev').webpackClientConfig,
+    'child-app': () => require('../../../library/webpack/child-app/client/dev').webpackClientConfig,
+    package: () => CONFIG_GENERATOR_STUB,
   },
   production: {
-    application: require('../../../library/webpack/application/client/prod').webpackClientConfig,
-    module: require('../../../library/webpack/module/client/prod').webpackClientConfig,
-    'child-app': require('../../../library/webpack/child-app/client/prod').webpackClientConfig,
-    package: CONFIG_GENERATOR_STUB,
+    application: () =>
+      require('../../../library/webpack/application/client/prod').webpackClientConfig,
+    module: () => require('../../../library/webpack/module/client/prod').webpackClientConfig,
+    'child-app': () =>
+      require('../../../library/webpack/child-app/client/prod').webpackClientConfig,
+    package: () => CONFIG_GENERATOR_STUB,
   },
 };
 
@@ -31,7 +29,9 @@ export const clientProviders: Provider[] = [
   provide({
     provide: WEBPACK_CLIENT_CONFIG_TOKEN,
     useFactory: ({ configManager, showProgress }) => {
-      return CONFIG_MAP[configManager.env][configManager.type]({
+      const webpackConfigFactory = CONFIG_MAP[configManager.env][configManager.type]();
+
+      return webpackConfigFactory({
         configManager,
         showProgress,
       });
@@ -41,17 +41,4 @@ export const clientProviders: Provider[] = [
       showProgress: { token: UI_SHOW_PROGRESS_TOKEN, optional: true },
     },
   }),
-  provide({
-    provide: WEBPACK_CLIENT_MODERN_CONFIG_TOKEN,
-    useFactory: ({ configManager, showProgress }) => {
-      return CONFIG_MAP[configManager.env][configManager.type]({
-        configManager,
-        showProgress,
-      });
-    },
-    deps: {
-      configManager: CLIENT_MODERN_CONFIG_MANAGER_TOKEN,
-      showProgress: { token: UI_SHOW_PROGRESS_TOKEN, optional: true },
-    },
-  }),
 ];

package/src/builder/webpack/providers/server.ts

@@ -7,18 +7,21 @@ import { SERVER_CONFIG_MANAGER_TOKEN, WEBPACK_SERVER_CONFIG_TOKEN } from '../tok
 import { CONFIG_GENERATOR_STUB } from '../stubs/config';
 import type { ConfigGenerator } from '../types';
 
-const CONFIG_MAP: Record<Env, Record<ProjectType, ConfigGenerator>> = {
+const CONFIG_MAP: Record<Env, Record<ProjectType, () => ConfigGenerator>> = {
   development: {
-    application: require('../../../library/webpack/application/server/dev').webpackServerConfig,
-    module: require('../../../library/webpack/module/server/dev').webpackServerConfig,
-    'child-app': require('../../../library/webpack/child-app/server/dev').webpackServerConfig,
-    package: CONFIG_GENERATOR_STUB,
+    application: () =>
+      require('../../../library/webpack/application/server/dev').webpackServerConfig,
+    module: () => require('../../../library/webpack/module/server/dev').webpackServerConfig,
+    'child-app': () => require('../../../library/webpack/child-app/server/dev').webpackServerConfig,
+    package: () => CONFIG_GENERATOR_STUB,
   },
   production: {
-    application: require('../../../library/webpack/application/server/prod').webpackServerConfig,
-    module: require('../../../library/webpack/module/server/prod').webpackServerConfig,
-    'child-app': require('../../../library/webpack/child-app/server/prod').webpackServerConfig,
-    package: CONFIG_GENERATOR_STUB,
+    application: () =>
+      require('../../../library/webpack/application/server/prod').webpackServerConfig,
+    module: () => require('../../../library/webpack/module/server/prod').webpackServerConfig,
+    'child-app': () =>
+      require('../../../library/webpack/child-app/server/prod').webpackServerConfig,
+    package: () => CONFIG_GENERATOR_STUB,
   },
 };
 
@@ -37,7 +40,9 @@ export const serverProviders: Provider[] = [
   provide({
     provide: WEBPACK_SERVER_CONFIG_TOKEN,
     useFactory: ({ configManager, showProgress }) => {
-      return CONFIG_MAP[configManager.env][configManager.type]({
+      const webpackConfigFactory = CONFIG_MAP[configManager.env][configManager.type]();
+
+      return webpackConfigFactory({
         configManager,
         showProgress,
       });