refactor: optimize environment handling with environmentList (#6560)

Author: chenjiahan

packages/core/src/createContext.ts

@@ -115,7 +115,7 @@ export async function updateEnvironmentContext(
     };
 
     // EnvironmentContext is readonly.
-    context.environments[name] = new Proxy(environmentContext, {
+    const readonlyEnvironmentContext = new Proxy(environmentContext, {
       get(target, prop: keyof EnvironmentContext) {
         return target[prop];
       },
@@ -130,16 +130,17 @@ export async function updateEnvironmentContext(
         return true;
       },
     });
+
+    context.environmentList[index] = readonlyEnvironmentContext;
+    context.environments[name] = readonlyEnvironmentContext;
   }
 }
 
 export function updateContextByNormalizedConfig(
   context: InternalContext,
 ): void {
   // Try to get the parent dist path from all environments
-  const distPaths = Object.values(context.environments).map(
-    (item) => item.distPath,
-  );
+  const distPaths = context.environmentList.map((item) => item.distPath);
   context.distPath = getCommonParentPath(distPaths);
 }
 
@@ -204,6 +205,7 @@ export async function createContext(
     callerName: options.callerName,
     bundlerType,
     environments: {},
+    environmentList: [],
     publicPathnames: [],
     hooks: initHooks(),
     config: { ...rsbuildConfig },

packages/core/src/hooks.ts

@@ -3,7 +3,6 @@ import { isMultiCompiler } from './helpers/compiler';
 import type {
   AsyncHook,
   EnvironmentAsyncHook,
-  EnvironmentContext,
   HookDescriptor,
   InternalContext,
   ModifyBundlerChainFn,
@@ -377,12 +376,7 @@ export const registerBuildHook = ({
 }): void => {
   let isFirstCompile = true;
 
-  const environmentList = Object.values(context.environments).reduce<
-    EnvironmentContext[]
-  >((prev, curr) => {
-    prev[curr.index] = curr;
-    return prev;
-  }, []);
+  const { environmentList } = context;
 
   const beforeCompile = async () =>
     context.hooks.onBeforeBuild.callBatch({
@@ -459,12 +453,7 @@ export const registerDevHook = ({
 }): void => {
   let isFirstCompile = true;
 
-  const environmentList = Object.values(context.environments).reduce<
-    EnvironmentContext[]
-  >((prev, curr) => {
-    prev[curr.index] = curr;
-    return prev;
-  }, []);
+  const { environmentList } = context;
 
   const beforeCompile = async () =>
     context.hooks.onBeforeDevCompile.callBatch({

packages/core/src/plugins/nonce.ts

@@ -8,11 +8,9 @@ export const pluginNonce = (): RsbuildPlugin => ({
   setup(api) {
     api.onAfterCreateCompiler(({ compiler, environments }) => {
       const environmentList = Object.values(environments);
-      const nonces = environmentList.map((environment) => {
-        const { nonce } = environment.config.security;
-
-        return nonce;
-      });
+      const nonces = Object.values(environments).map(
+        (environment) => environment.config.security.nonce,
+      );
 
       if (!nonces.some((nonce) => !!nonce)) {
         return;

packages/core/src/provider/createCompiler.ts

@@ -207,8 +207,8 @@ export async function createCompiler(options: InitConfigsOptions): Promise<{
       if (!hasErrors) {
         // only print children compiler time when multi compiler
         if (isMultiCompiler && stats.children?.length) {
-          stats.children.forEach((c, index) => {
-            printTime(c, index);
+          stats.children.forEach((item, index) => {
+            printTime(item, index);
           });
         } else {
           printTime(stats, 0);

packages/core/src/server/assets-middleware/getFileFromUrl.ts

@@ -51,8 +51,8 @@ export async function getFileFromUrl(
     });
   };
 
-  const { environments, publicPathnames } = context;
-  const distPaths = Object.values(environments).map((env) => env.distPath);
+  const { environmentList, publicPathnames } = context;
+  const distPaths = environmentList.map((env) => env.distPath);
   const possibleFilenames = new Set<string>();
 
   // First, add paths that match the public prefix for more accurate resolution

packages/core/src/server/assets-middleware/index.ts

@@ -211,12 +211,10 @@ export const assetsMiddleware = async ({
   resolvedPort: number;
 }): Promise<AssetsMiddleware> => {
   const resolvedHost = await resolveHostname(config.server.host);
-  const { environments } = context;
+  const { environments, environmentList } = context;
 
   const setupCompiler = (compiler: Compiler, index: number) => {
-    const environment = Object.values(environments).find(
-      (env) => env.index === index,
-    );
+    const environment = environmentList[index];
     if (!environment) {
       return;
     }
@@ -261,7 +259,11 @@ export const assetsMiddleware = async ({
     });
   });
 
-  const writeToDisk = resolveWriteToDiskConfig(config.dev, environments);
+  const writeToDisk = resolveWriteToDiskConfig(
+    config.dev,
+    environments,
+    environmentList,
+  );
   if (writeToDisk) {
     setupWriteToDisk(compilers, writeToDisk);
   }

packages/core/src/server/assets-middleware/setupWriteToDisk.ts

@@ -22,8 +22,9 @@ export type ResolvedWriteToDisk =
 export const resolveWriteToDiskConfig = (
   config: NormalizedDevConfig,
   environments: Record<string, EnvironmentContext>,
+  environmentList: EnvironmentContext[],
 ): ResolvedWriteToDisk => {
-  const writeToDiskValues = Object.values(environments).map(
+  const writeToDiskValues = environmentList.map(
     (env) => env.config.dev.writeToDisk,
   );
   if (new Set(writeToDiskValues).size === 1) {

packages/core/src/server/devServer.ts

@@ -303,63 +303,45 @@ export async function createDevServer<
     (_stats, entryName, utils) => getTransformedHtml(entryName, utils),
   );
 
-  const environmentAPI = Object.fromEntries(
-    Object.entries(context.environments).map(([name, environment]) => {
-      return [
-        name,
-        {
-          getStats: async () => {
-            if (!buildManager) {
-              throw new Error(
-                `${color.dim('[rsbuild:server]')} Can not call ` +
-                  `${color.yellow('getStats')} when ` +
-                  `${color.yellow('runCompile')} is false`,
-              );
-            }
-            await waitLastCompileDone;
-            return lastStats[environment.index];
-          },
-          context: environment,
-          loadBundle: async <T>(entryName: string) => {
-            if (!buildManager) {
-              throw new Error(
-                `${color.dim('[rsbuild:server]')} Can not call ` +
-                  `${color.yellow('loadBundle')} when ` +
-                  `${color.yellow('runCompile')} is false`,
-              );
-            }
-            await waitLastCompileDone;
-            return cacheableLoadBundle(
-              lastStats[environment.index],
-              entryName,
-              {
-                readFileSync: buildManager.readFileSync,
-                environment,
-              },
-            ) as T;
-          },
-          getTransformedHtml: async (entryName: string) => {
-            if (!buildManager) {
-              throw new Error(
-                `${color.dim('[rsbuild:server]')} Can not call ` +
-                  `${color.yellow('getTransformedHtml')} when ` +
-                  `${color.yellow('runCompile')} is false`,
-              );
-            }
-            await waitLastCompileDone;
-            return cacheableTransformedHtml(
-              lastStats[environment.index],
-              entryName,
-              {
-                readFileSync: buildManager.readFileSync,
-                environment,
-              },
-            );
-          },
-        },
-      ];
-    }),
-  );
+  const environmentAPI: EnvironmentAPI = {};
+
+  const getErrorMsg = (method: string) =>
+    `${color.dim('[rsbuild:server]')} Can not call ` +
+    `${color.yellow(method)} when ` +
+    `${color.yellow('runCompile')} is false`;
+
+  context.environmentList.forEach((environment, index) => {
+    environmentAPI[environment.name] = {
+      context: environment,
+      getStats: async () => {
+        if (!buildManager) {
+          throw new Error(getErrorMsg('getStats'));
+        }
+        await waitLastCompileDone;
+        return lastStats[index];
+      },
+      loadBundle: async <T>(entryName: string) => {
+        if (!buildManager) {
+          throw new Error(getErrorMsg('loadBundle'));
+        }
+        await waitLastCompileDone;
+        return cacheableLoadBundle(lastStats[index], entryName, {
+          readFileSync: buildManager.readFileSync,
+          environment,
+        }) as T;
+      },
+      getTransformedHtml: async (entryName: string) => {
+        if (!buildManager) {
+          throw new Error(getErrorMsg('getTransformedHtml'));
+        }
+        await waitLastCompileDone;
+        return cacheableTransformedHtml(lastStats[index], entryName, {
+          readFileSync: buildManager.readFileSync,
+          environment,
+        });
+      },
+    };
+  });
 
   const connect = requireCompiledPackage('connect');
   const middlewares = connect();

packages/core/src/server/helper.ts

@@ -88,7 +88,7 @@ export const stripBase = (path: string, base: string): string => {
 };
 
 export const getRoutes = (context: InternalContext): Routes => {
-  const environmentWithHtml = Object.values(context.environments).filter(
+  const environmentWithHtml = context.environmentList.filter(
     (item) => Object.keys(item.htmlPaths).length > 0,
   );
   if (environmentWithHtml.length === 0) {

packages/core/src/server/prodServer.ts

@@ -190,7 +190,7 @@ export async function startProdServer(
       pwd: context.rootPath,
       output: {
         path: context.distPath,
-        assetPrefixes: Object.values(context.environments).map((e) =>
+        assetPrefixes: context.environmentList.map((e) =>
           getPathnameFromUrl(e.config.output.assetPrefix),
         ),
       },