feat: normalize environment config

packages/core/src/config.ts

@@ -176,6 +176,7 @@ const createDefaultConfig = (): RsbuildConfig => ({
   tools: getDefaultToolsConfig(),
   security: getDefaultSecurityConfig(),
   performance: getDefaultPerformanceConfig(),
+  environments: {},
 });
 
 function getDefaultEntry(root: string): RsbuildEntry {
@@ -230,7 +231,10 @@ export const withDefaultConfig = async (
  * 3. Meaningful and can be filled by constant value.
  */
 export const normalizeConfig = (config: RsbuildConfig): NormalizedConfig =>
-  mergeRsbuildConfig(createDefaultConfig(), config) as NormalizedConfig;
+  mergeRsbuildConfig(
+    createDefaultConfig(),
+    config,
+  ) as unknown as NormalizedConfig;
 
 export type ConfigParams = {
   env: string;

packages/core/src/createContext.ts

@@ -1,6 +1,7 @@
 import { isAbsolute, join } from 'node:path';
 import type {
   BundlerType,
+  NormalizedEnvironmentConfig,
   RsbuildContext,
   RsbuildTarget,
 } from '@rsbuild/shared';
@@ -22,7 +23,7 @@ function getAbsolutePath(root: string, filepath: string) {
 
 function getAbsoluteDistPath(
   cwd: string,
-  config: RsbuildConfig | NormalizedConfig,
+  config: RsbuildConfig | NormalizedConfig | NormalizedEnvironmentConfig,
 ) {
   const dirRoot = config.output?.distPath?.root ?? ROOT_DIST_DIR;
   return getAbsolutePath(cwd, dirRoot);
@@ -46,6 +47,7 @@ async function createContextByConfig(
     entry: getEntryObject(config, 'web'),
     targets: config.output?.targets || [],
     version: RSBUILD_VERSION,
+    environments: {},
     rootPath,
     distPath,
     cachePath,
@@ -56,6 +58,26 @@ async function createContextByConfig(
   };
 }
 
+export function updateEnvironmentContext(
+  context: RsbuildContext,
+  configs: Record<string, NormalizedEnvironmentConfig>,
+) {
+  context.environments = Object.fromEntries(
+    Object.entries(configs).map(([name, config]) => [
+      name,
+      {
+        // TODO: replace output.targets with output.target
+        target: config.output.targets[0],
+        distPath: getAbsoluteDistPath(context.rootPath, config),
+        entry: getEntryObject(config, config.output.targets[0]),
+        tsconfigPath: config.source.tsconfigPath
+          ? getAbsolutePath(context.rootPath, config.source.tsconfigPath)
+          : undefined,
+      },
+    ]),
+  );
+}
+
 export function updateContextByNormalizedConfig(
   context: RsbuildContext,
   config: NormalizedConfig,

packages/core/src/helpers.ts

@@ -523,6 +523,9 @@ export function pick<T, U extends keyof T>(obj: T, keys: ReadonlyArray<U>) {
   );
 }
 
+export const camelCase = (input: string): string =>
+  input.replace(/[-_](\w)/g, (_, c) => c.toUpperCase());
+
 export const prettyTime = (seconds: number) => {
   const format = (time: string) => color.bold(time);
 

packages/core/src/initPlugins.ts

@@ -1,6 +1,7 @@
 import { join } from 'node:path';
 import type {
   GetRsbuildConfig,
+  NormalizedEnvironmentConfig,
   PluginManager,
   RsbuildPluginAPI,
   RspackChain,
@@ -60,14 +61,29 @@ export function getPluginAPI({
   const { hooks } = context;
   const publicContext = createPublicContext(context);
 
-  const getNormalizedConfig = () => {
+  function getNormalizedConfig(): NormalizedConfig;
+  function getNormalizedConfig(options: {
+    environment: string;
+  }): NormalizedEnvironmentConfig;
+  function getNormalizedConfig(options?: { environment: string }) {
     if (context.normalizedConfig) {
+      if (options?.environment) {
+        const config =
+          context.normalizedConfig.environments[options.environment];
+
+        if (!config) {
+          throw new Error(
+            `Cannot find normalized config by environment: ${options.environment}.`,
+          );
+        }
+        return config;
+      }
       return context.normalizedConfig;
     }
     throw new Error(
       'Cannot access normalized config until modifyRsbuildConfig is called.',
     );
-  };
+  }
 
   const getRsbuildConfig = ((type = 'current') => {
     switch (type) {

packages/core/src/mergeConfig.ts

@@ -64,19 +64,17 @@ const merge = (x: unknown, y: unknown, path = '') => {
   return merged;
 };
 
-export const mergeRsbuildConfig = (
-  ...configs: RsbuildConfig[]
-): RsbuildConfig => {
+export const mergeRsbuildConfig = <T = RsbuildConfig>(...configs: T[]): T => {
   if (configs.length === 2) {
-    return merge(configs[0], configs[1]) as RsbuildConfig;
+    return merge(configs[0], configs[1]) as T;
   }
 
   if (configs.length < 2) {
     return configs[0];
   }
 
   return configs.reduce(
-    (result, config) => merge(result, config) as RsbuildConfig,
-    {},
+    (result, config) => merge(result, config) as T,
+    {} as T,
   );
 };

packages/core/src/plugins/entry.ts

@@ -1,4 +1,5 @@
 import {
+  type NormalizedEnvironmentConfig,
   type RsbuildEntry,
   type RsbuildTarget,
   castArray,
@@ -10,7 +11,7 @@ import { reduceConfigsMergeContext } from '../reduceConfigs';
 import type { NormalizedConfig, RsbuildConfig, RsbuildPlugin } from '../types';
 
 export function getEntryObject(
-  config: RsbuildConfig | NormalizedConfig,
+  config: RsbuildConfig | NormalizedConfig | NormalizedEnvironmentConfig,
   target: RsbuildTarget,
 ): RsbuildEntry {
   if (!config.source?.entry) {

packages/core/src/provider/initConfigs.ts

@@ -1,10 +1,15 @@
 import type {
   InspectConfigOptions,
+  NormalizedEnvironmentConfig,
   PluginManager,
   RspackConfig,
 } from '@rsbuild/shared';
 import { normalizeConfig } from '../config';
-import { updateContextByNormalizedConfig } from '../createContext';
+import {
+  updateContextByNormalizedConfig,
+  updateEnvironmentContext,
+} from '../createContext';
+import { camelCase } from '../helpers';
 import { isDebug, logger } from '../logger';
 import { mergeRsbuildConfig } from '../mergeConfig';
 import { initPlugins } from '../pluginManager';
@@ -33,6 +38,37 @@ export type InitConfigsOptions = {
   rsbuildOptions: Required<CreateRsbuildOptions>;
 };
 
+const normalizeEnvironmentsConfigs = (
+  normalizedConfig: NormalizedConfig,
+): Record<string, NormalizedEnvironmentConfig> => {
+  const { environments, dev, server, provider, ...rsbuildSharedConfig } =
+    normalizedConfig;
+  if (environments) {
+    return Object.fromEntries(
+      Object.entries(environments).map(([name, config]) => [
+        name,
+        {
+          ...mergeRsbuildConfig(
+            rsbuildSharedConfig,
+            config as unknown as NormalizedEnvironmentConfig,
+          ),
+          dev,
+          server,
+        },
+      ]),
+    );
+  }
+
+  return {
+    // TODO: replace output.targets with output.target
+    [camelCase(rsbuildSharedConfig.output.targets[0])]: {
+      ...rsbuildSharedConfig,
+      dev,
+      server,
+    },
+  };
+};
+
 export async function initRsbuildConfig({
   context,
   pluginManager,
@@ -51,9 +87,19 @@ export async function initRsbuildConfig({
   });
 
   await modifyRsbuildConfig(context);
-  context.normalizedConfig = normalizeConfig(context.config);
+  const normalizeBaseConfig = normalizeConfig(context.config);
+
+  const environments = normalizeEnvironmentsConfigs(normalizeBaseConfig);
+
+  context.normalizedConfig = {
+    ...normalizeBaseConfig,
+    environments,
+  };
+
   updateContextByNormalizedConfig(context, context.normalizedConfig);
 
+  updateEnvironmentContext(context, environments);
+
   return context.normalizedConfig;
 }