@nocobase/build 2.1.0-beta.9 → 2.2.0-alpha.1

package/lib/build.js

@@ -28,12 +28,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var build_exports = {};
 __export(build_exports, {
   build: () => build,
-  buildPackage: () => buildPackage,
   buildPackages: () => buildPackages
 });
 module.exports = __toCommonJS(build_exports);
 var import_chalk = __toESM(require("chalk"));
-var import_execa = __toESM(require("execa"));
 var import_path = __toESM(require("path"));
 var import_buildCjs = require("./buildCjs");
 var import_buildClient = require("./buildClient");
@@ -46,107 +44,313 @@ var import_utils = require("./utils");
 var import_addlicense = require("./utils/addlicense");
 var import_getPackages = require("./utils/getPackages");
 const BUILD_ERROR = "build-error";
+const DEFAULT_LAYER_CONCURRENCY = 2;
+const DEFAULT_PLUGIN_LAYER_CONCURRENCY = 1;
+const ENABLE_BUILD_PROFILE = process.env.BUILD_PROFILE === "true";
 async function build(pkgs) {
+  const profile = ENABLE_BUILD_PROFILE ? (0, import_utils.createBuildProfileCollector)() : null;
+  const buildStart = (0, import_utils.nowMs)();
   const isDev = process.argv.includes("--development");
   process.env.NODE_ENV = isDev ? "development" : "production";
-  let packages = (0, import_getPackages.getPackages)(pkgs);
-  const cachePkg = (0, import_utils.readFromCache)(BUILD_ERROR);
-  if (process.argv.includes("--retry") && cachePkg?.pkg) {
-    packages = packages.slice(packages.findIndex((item) => item.name === cachePkg.pkg));
+  try {
+    let packages = (0, import_getPackages.getPackages)(pkgs);
+    const cachePkg = (0, import_utils.readFromCache)(BUILD_ERROR);
+    if (process.argv.includes("--retry") && cachePkg?.pkg) {
+      packages = packages.slice(packages.findIndex((item) => item.name === cachePkg.pkg));
+    }
+    const cliPackages = packages.find((item) => item.name === "@nocobase/cli");
+    if (cliPackages) {
+      const log = (0, import_utils.getPkgLog)(cliPackages.name);
+      log('running package script "build" (clean + tsc)');
+      await (0, import_utils.runScript)(["build"], cliPackages.location);
+      if (packages.length === 1) {
+        return;
+      }
+    }
+    if (packages.length === 0) {
+      let msg = "";
+      if (pkgs.length) {
+        msg = `'${pkgs.join(", ")}' did not match any packages`;
+      } else {
+        msg = "No package matched";
+      }
+      console.warn(import_chalk.default.yellow(`[@nocobase/build]: ${msg}`));
+      return;
+    }
+    const pluginPackages = (0, import_constant.getPluginPackages)(packages);
+    const cjsPackages = (0, import_constant.getCjsPackages)(packages);
+    const presetsPackages = (0, import_constant.getPresetsPackages)(packages);
+    await buildPackages(cjsPackages, "lib", import_buildCjs.buildCjs, {
+      sourceConcurrency: DEFAULT_LAYER_CONCURRENCY,
+      declarationConcurrency: 1,
+      stageName: "core cjs",
+      profile
+    });
+    const clientCore = packages.find((item) => item.location === import_constant.CORE_CLIENT);
+    const clientV2Core = packages.find((item) => item.location === import_constant.CORE_CLIENT_V2);
+    if (clientV2Core) {
+      await buildSinglePackage(clientV2Core, "es", import_buildClient.buildClient, {
+        stageName: "core client-v2",
+        profile
+      });
+    }
+    if (clientCore) {
+      await buildSinglePackage(clientCore, "es", import_buildClient.buildClient, {
+        stageName: "core client",
+        profile
+      });
+    }
+    const esmPackages = packages.filter((pkg) => import_constant.ESM_PACKAGES.includes(pkg.name));
+    await buildPackages(esmPackages, "lib", import_buildCjs.buildCjs, {
+      sourceConcurrency: DEFAULT_LAYER_CONCURRENCY,
+      declarationConcurrency: 1,
+      stageName: "esm cjs",
+      profile
+    });
+    await buildPackages(esmPackages, "es", import_buildEsm.buildEsm, {
+      sourceConcurrency: DEFAULT_LAYER_CONCURRENCY,
+      declarationConcurrency: 1,
+      stageName: "esm",
+      profile
+    });
+    await buildPackages(pluginPackages, "dist", import_buildPlugin.buildPlugin, {
+      sourceConcurrency: DEFAULT_PLUGIN_LAYER_CONCURRENCY,
+      declarationConcurrency: 1,
+      stageName: "plugins",
+      profile
+    });
+    await buildPackages(presetsPackages, "lib", import_buildCjs.buildCjs, {
+      sourceConcurrency: DEFAULT_LAYER_CONCURRENCY,
+      declarationConcurrency: 1,
+      stageName: "presets",
+      profile
+    });
+    const appClient = packages.find((item) => item.location === import_constant.CORE_APP);
+    if (appClient) {
+      await (0, import_utils.runProfiledStage)(profile, "app client shell", async () => {
+        await (0, import_utils.runScript)(["rsbuild", "build", "--config", import_path.default.join(import_constant.CORE_APP, "client", "rsbuild.config.ts")], import_constant.ROOT_PATH, {
+          APP_ROOT: import_path.default.join(import_constant.CORE_APP, "client"),
+          ANALYZE: process.env.BUILD_ANALYZE === "true" ? "1" : void 0
+        });
+      });
+      await (0, import_utils.runProfiledStage)(profile, "app client-v2 shell", async () => {
+        await (0, import_utils.runScript)(
+          ["rsbuild", "build", "--config", import_path.default.join(import_constant.CORE_APP, "client-v2", "rsbuild.config.ts")],
+          import_constant.ROOT_PATH,
+          {
+            ANALYZE: process.env.BUILD_ANALYZE === "true" ? "1" : void 0
+          }
+        );
+      });
+    }
+    (0, import_utils.writeToCache)(BUILD_ERROR, {});
+  } finally {
+    if (profile) {
+      (0, import_utils.printBuildProfile)(profile, (0, import_utils.nowMs)() - buildStart);
+    }
   }
-  if (packages.length === 0) {
-    let msg = "";
-    if (pkgs.length) {
-      msg = `'${pkgs.join(", ")}' did not match any packages`;
-    } else {
-      msg = "No package matched";
+}
+async function buildPackages(packages, targetDir, doBuildPackage, options = {}) {
+  const {
+    sourceConcurrency = DEFAULT_LAYER_CONCURRENCY,
+    declarationConcurrency = 1,
+    stageName = "packages",
+    profile = null
+  } = options;
+  const layers = (0, import_getPackages.groupPackagesByTopoLevel)(packages);
+  const shouldRunDeclaration = !process.argv.includes("--no-dts") && !process.argv.includes("--only-tar");
+  await (0, import_utils.runProfiledStage)(profile, `${stageName} source`, async () => {
+    for (let index = 0; index < layers.length; index++) {
+      const layer = layers[index];
+      console.log(import_chalk.default.cyan(`[@nocobase/build]: ${stageName} source layer ${index + 1}/${layers.length} (${layer.length} packages)`));
+      const layerStart = (0, import_utils.nowMs)();
+      await (0, import_utils.runWithConcurrency)(layer, sourceConcurrency, async (pkg) => {
+        await buildPackageSourceLifecycle(pkg, targetDir, doBuildPackage, profile);
+      });
+      const layerDurationMs = (0, import_utils.nowMs)() - layerStart;
+      if (profile) {
+        profile.layers.push({
+          stageName: `${stageName} source`,
+          layerIndex: index + 1,
+          layerCount: layers.length,
+          packageCount: layer.length,
+          durationMs: layerDurationMs
+        });
+      }
+      if (ENABLE_BUILD_PROFILE) {
+        console.log(import_chalk.default.gray(`[@nocobase/build]: ${stageName} source layer ${index + 1}/${layers.length} finished in ${(0, import_utils.formatDuration)(layerDurationMs)}`));
+      }
     }
-    console.warn(import_chalk.default.yellow(`[@nocobase/build]: ${msg}`));
+  });
+  if (!shouldRunDeclaration) {
     return;
   }
-  const pluginPackages = (0, import_constant.getPluginPackages)(packages);
-  const cjsPackages = (0, import_constant.getCjsPackages)(packages);
-  const presetsPackages = (0, import_constant.getPresetsPackages)(packages);
-  await buildPackages(cjsPackages, "lib", import_buildCjs.buildCjs);
-  const clientCore = packages.find((item) => item.location === import_constant.CORE_CLIENT);
-  if (clientCore) {
-    await buildPackage(clientCore, "es", import_buildClient.buildClient);
-  }
-  const esmPackages = packages.filter((pkg) => import_constant.ESM_PACKAGES.includes(pkg.name));
-  await buildPackages(esmPackages, "lib", import_buildCjs.buildCjs);
-  await buildPackages(esmPackages, "es", import_buildEsm.buildEsm);
-  await buildPackages(pluginPackages, "dist", import_buildPlugin.buildPlugin);
-  await buildPackages(presetsPackages, "lib", import_buildCjs.buildCjs);
-  const appClient = packages.find((item) => item.location === import_constant.CORE_APP);
-  if (appClient) {
-    await runScript(["umi", "build"], import_constant.ROOT_PATH, {
-      APP_ROOT: import_path.default.join(import_constant.CORE_APP, "client"),
-      ANALYZE: process.env.BUILD_ANALYZE === "true" ? "1" : void 0
-    });
-  }
-  (0, import_utils.writeToCache)(BUILD_ERROR, {});
+  await (0, import_utils.runProfiledStage)(profile, `${stageName} declaration`, async () => {
+    for (let index = 0; index < layers.length; index++) {
+      const layer = layers[index];
+      console.log(import_chalk.default.cyan(`[@nocobase/build]: ${stageName} declaration layer ${index + 1}/${layers.length} (${layer.length} packages)`));
+      const layerStart = (0, import_utils.nowMs)();
+      await (0, import_utils.runWithConcurrency)(layer, declarationConcurrency, async (pkg) => {
+        await buildPackageDeclarationLifecycle(pkg, targetDir, profile);
+      });
+      const layerDurationMs = (0, import_utils.nowMs)() - layerStart;
+      if (profile) {
+        profile.layers.push({
+          stageName: `${stageName} declaration`,
+          layerIndex: index + 1,
+          layerCount: layers.length,
+          packageCount: layer.length,
+          durationMs: layerDurationMs
+        });
+      }
+      if (ENABLE_BUILD_PROFILE) {
+        console.log(import_chalk.default.gray(`[@nocobase/build]: ${stageName} declaration layer ${index + 1}/${layers.length} finished in ${(0, import_utils.formatDuration)(layerDurationMs)}`));
+      }
+    }
+  });
 }
-async function buildPackages(packages, targetDir, doBuildPackage) {
-  for await (const pkg of packages) {
-    (0, import_utils.writeToCache)(BUILD_ERROR, { pkg: pkg.name });
-    await buildPackage(pkg, targetDir, doBuildPackage);
+async function buildSinglePackage(pkg, targetDir, doBuildPackage, options) {
+  const { stageName, profile = null } = options;
+  await (0, import_utils.runProfiledStage)(profile, `${stageName} source`, async () => {
+    await buildPackageSourceLifecycle(pkg, targetDir, doBuildPackage, profile);
+  });
+  if (process.argv.includes("--no-dts") || process.argv.includes("--only-tar")) {
+    return;
   }
+  await (0, import_utils.runProfiledStage)(profile, `${stageName} declaration`, async () => {
+    await buildPackageDeclarationLifecycle(pkg, targetDir, profile);
+  });
 }
-async function buildPackage(pkg, targetDir, doBuildPackage) {
+async function buildPackageSourceLifecycle(pkg, targetDir, doBuildPackage, profile = null) {
   const sourcemap = process.argv.includes("--sourcemap");
-  const noDeclaration = process.argv.includes("--no-dts");
   const hasTar = process.argv.includes("--tar");
   const onlyTar = process.argv.includes("--only-tar");
   const log = (0, import_utils.getPkgLog)(pkg.name);
   const packageJson = (0, import_utils.getPackageJson)(pkg.location);
   if (onlyTar) {
+    const packageStart2 = (0, import_utils.nowMs)();
     await (0, import_tarPlugin.tarPlugin)(pkg.location, log);
+    if (profile) {
+      profile.packages.push({
+        name: pkg.name,
+        targetDir,
+        kind: "source",
+        durationMs: (0, import_utils.nowMs)() - packageStart2,
+        status: "success",
+        phases: { tar: (0, import_utils.nowMs)() - packageStart2 }
+      });
+    }
     return;
   }
   log(`${import_chalk.default.bold((0, import_utils.toUnixPath)(pkg.location.replace(import_constant.PACKAGES_PATH, "").slice(1)))} build start`);
   const userConfig = (0, import_utils.getUserConfig)(pkg.location);
+  const packageStart = (0, import_utils.nowMs)();
+  const phaseDurations = {};
+  let status = "success";
+  const runPhase = async (phaseName, task) => {
+    const phaseStart = (0, import_utils.nowMs)();
+    await task();
+    phaseDurations[phaseName] = (phaseDurations[phaseName] || 0) + ((0, import_utils.nowMs)() - phaseStart);
+  };
   if (packageJson?.scripts?.prebuild) {
     log("prebuild");
-    await runScript(["prebuild"], pkg.location);
-    await packageJson.prebuild(pkg.location);
+    await runPhase("prebuild", async () => {
+      await (0, import_utils.runScript)(["prebuild"], pkg.location);
+      await packageJson.prebuild(pkg.location);
+    });
   }
   if (userConfig.beforeBuild) {
     log("beforeBuild");
-    await userConfig.beforeBuild(log);
-  }
-  await doBuildPackage(pkg.location, userConfig, sourcemap, log);
-  if (!noDeclaration) {
-    log("build declaration");
-    await (0, import_buildDeclaration.buildDeclaration)(pkg.location, targetDir);
-  }
-  if (packageJson?.scripts?.postbuild) {
-    log("postbuild");
-    await runScript(["postbuild"], pkg.location);
-  }
-  if (userConfig.afterBuild) {
-    log("afterBuild");
-    await userConfig.afterBuild(log);
+    await runPhase("beforeBuild", async () => {
+      await userConfig.beforeBuild(log);
+    });
   }
-  await (0, import_addlicense.addLicense)(import_path.default.join(pkg.location, targetDir), log);
-  if (hasTar) {
-    await (0, import_tarPlugin.tarPlugin)(pkg.location, log);
+  try {
+    await runPhase("build", async () => {
+      await doBuildPackage(pkg.location, userConfig, sourcemap, log);
+    });
+    if (packageJson?.scripts?.postbuild) {
+      log("postbuild");
+      await runPhase("postbuild", async () => {
+        await (0, import_utils.runScript)(["postbuild"], pkg.location);
+      });
+    }
+    if (userConfig.afterBuild) {
+      log("afterBuild");
+      await runPhase("afterBuild", async () => {
+        await userConfig.afterBuild(log);
+      });
+    }
+    await runPhase("addLicense", async () => {
+      await (0, import_addlicense.addLicense)(import_path.default.join(pkg.location, targetDir), log);
+    });
+    if (hasTar) {
+      await runPhase("tar", async () => {
+        await (0, import_tarPlugin.tarPlugin)(pkg.location, log);
+      });
+    }
+  } catch (error) {
+    status = "failed";
+    (0, import_utils.writeToCache)(BUILD_ERROR, { pkg: pkg.name });
+    throw error;
+  } finally {
+    if (profile) {
+      profile.packages.push({
+        name: pkg.name,
+        targetDir,
+        kind: "source",
+        durationMs: (0, import_utils.nowMs)() - packageStart,
+        status,
+        phases: phaseDurations
+      });
+      if (ENABLE_BUILD_PROFILE) {
+        const summary = Object.entries(phaseDurations).sort((a, b) => b[1] - a[1]).map(([name, duration]) => `${name}=${(0, import_utils.formatDuration)(duration)}`).join(", ");
+        console.log(
+          import_chalk.default.gray(
+            `[@nocobase/build:profile] ${pkg.name} ${status} in ${(0, import_utils.formatDuration)((0, import_utils.nowMs)() - packageStart)}${summary ? ` (${summary})` : ""}`
+          )
+        );
+      }
+    }
   }
 }
-function runScript(args, cwd, envs = {}) {
-  return (0, import_execa.default)("yarn", args, {
-    cwd,
-    stdio: "inherit",
-    env: {
-      ...process.env,
-      ...envs,
-      sourcemap: process.argv.includes("--sourcemap") ? "sourcemap" : void 0,
-      NODE_ENV: process.env.NODE_ENV || "production"
+async function buildPackageDeclarationLifecycle(pkg, targetDir, profile = null) {
+  const log = (0, import_utils.getPkgLog)(pkg.name);
+  const packageStart = (0, import_utils.nowMs)();
+  const phaseDurations = {};
+  let status = "success";
+  try {
+    log("build declaration");
+    const phaseStart = (0, import_utils.nowMs)();
+    await (0, import_buildDeclaration.buildDeclaration)(pkg.location, targetDir);
+    phaseDurations.declaration = (0, import_utils.nowMs)() - phaseStart;
+  } catch (error) {
+    status = "failed";
+    (0, import_utils.writeToCache)(BUILD_ERROR, { pkg: pkg.name });
+    throw error;
+  } finally {
+    if (profile) {
+      profile.packages.push({
+        name: pkg.name,
+        targetDir,
+        kind: "declaration",
+        durationMs: (0, import_utils.nowMs)() - packageStart,
+        status,
+        phases: phaseDurations
+      });
+      if (ENABLE_BUILD_PROFILE) {
+        const summary = Object.entries(phaseDurations).sort((a, b) => b[1] - a[1]).map(([name, duration]) => `${name}=${(0, import_utils.formatDuration)(duration)}`).join(", ");
+        console.log(
+          import_chalk.default.gray(
+            `[@nocobase/build:profile] ${pkg.name} declaration ${status} in ${(0, import_utils.formatDuration)((0, import_utils.nowMs)() - packageStart)}${summary ? ` (${summary})` : ""}`
+          )
+        );
+      }
     }
-  });
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   build,
-  buildPackage,
   buildPackages
 });

package/lib/buildCjs.js

@@ -39,28 +39,33 @@ function buildCjs(cwd, userConfig, sourcemap = false, log) {
   log("build cjs");
   const entry = import_fast_glob.default.globSync(["src/**", ...import_constant.globExcludeFiles], { cwd, absolute: true });
   const outDir = import_path.default.join(cwd, "lib");
-  const otherExts = Array.from(new Set(entry.map((item) => import_path.default.extname(item)).filter((item) => !import_constant.EsbuildSupportExts.includes(item))));
+  const otherExts = Array.from(
+    new Set(entry.map((item) => import_path.default.extname(item)).filter((item) => !import_constant.EsbuildSupportExts.includes(item)))
+  );
   if (otherExts.length) {
     log("%s will not be processed, only be copied to the lib directory.", import_chalk.default.yellow(otherExts.join(",")));
   }
-  return (0, import_tsup.build)(userConfig.modifyTsupConfig({
-    entry,
-    splitting: false,
-    clean: true,
-    bundle: false,
-    silent: true,
-    sourcemap,
-    treeshake: false,
-    target: "node16",
-    keepNames: true,
-    outDir,
-    loader: {
-      ...otherExts.reduce((prev, cur) => ({ ...prev, [cur]: "copy" }), {}),
-      ".json": "copy"
-    },
-    format: "cjs",
-    skipNodeModulesBundle: true
-  }));
+  return (0, import_tsup.build)(
+    userConfig.modifyTsupConfig({
+      entry,
+      splitting: false,
+      clean: true,
+      bundle: false,
+      silent: true,
+      sourcemap,
+      treeshake: false,
+      target: "node16",
+      keepNames: true,
+      outDir,
+      loader: {
+        ...otherExts.reduce((prev, cur) => ({ ...prev, [cur]: "copy" }), {}),
+        ".json": "copy",
+        ".txt": "copy"
+      },
+      format: "cjs",
+      skipNodeModulesBundle: true
+    })
+  );
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/buildClient.js

@@ -31,13 +31,14 @@ __export(buildClient_exports, {
   buildLocale: () => buildLocale
 });
 module.exports = __toCommonJS(buildClient_exports);
-var import_plugin_react = __toESM(require("@vitejs/plugin-react"));
+var import_core = require("@rsbuild/core");
+var import_plugin_less = require("@rsbuild/plugin-less");
+var import_plugin_react = require("@rsbuild/plugin-react");
+var import_plugin_svgr = require("@rsbuild/plugin-svgr");
 var import_fast_glob = __toESM(require("fast-glob"));
 var import_fs_extra = __toESM(require("fs-extra"));
 var import_path = __toESM(require("path"));
 var import_tsup = require("tsup");
-var import_vite = require("vite");
-var import_vite_plugin_lib_inject_css = require("vite-plugin-lib-inject-css");
 var import_constant = require("./constant");
 var import_utils = require("./utils");
 async function buildClient(cwd, userConfig, sourcemap = false, log) {
@@ -45,7 +46,7 @@ async function buildClient(cwd, userConfig, sourcemap = false, log) {
   const cwdWin = cwd.replaceAll(/\\/g, "/");
   const cwdUnix = cwd.replaceAll(/\//g, "\\");
   const external = function(id) {
-    if (id.startsWith(".") || id.startsWith(cwdUnix) || id.startsWith(cwdWin)) {
+    if (!id || import_path.default.isAbsolute(id) || id.startsWith(".") || id.startsWith(cwdUnix) || id.startsWith(cwdWin)) {
       return false;
     }
     return true;
@@ -54,35 +55,12 @@ async function buildClient(cwd, userConfig, sourcemap = false, log) {
   await buildClientLib(cwd, userConfig, sourcemap, external, log);
   await buildLocale(cwd, userConfig, log);
 }
-function buildClientEsm(cwd, userConfig, sourcemap, external, log) {
+async function buildClientEsm(cwd, userConfig, sourcemap, external, log) {
   log("build client esm");
   const entry = import_path.default.join(cwd, "src/index.ts").replaceAll(/\\/g, "/");
   const outDir = import_path.default.resolve(cwd, "es");
-  return (0, import_vite.build)(
-    userConfig.modifyViteConfig({
-      mode: process.env.NODE_ENV || "production",
-      define: (0, import_utils.getEnvDefine)(),
-      build: {
-        minify: process.env.NODE_ENV === "production",
-        outDir,
-        cssCodeSplit: true,
-        emptyOutDir: true,
-        sourcemap,
-        lib: {
-          entry,
-          formats: ["es"],
-          fileName: "index"
-        },
-        target: ["es2015", "edge88", "firefox78", "chrome87", "safari14"],
-        rollupOptions: {
-          cache: true,
-          treeshake: true,
-          external
-        }
-      },
-      plugins: [(0, import_plugin_react.default)(), (0, import_vite_plugin_lib_inject_css.libInjectCss)()]
-    })
-  );
+  await buildClientWithRsbuild(cwd, userConfig, sourcemap, external, entry, outDir, "esm");
+  await injectEntryStyleReference(import_path.default.join(outDir, "index.mjs"), 'import "./index.css";');
 }
 async function buildClientLib(cwd, userConfig, sourcemap, external, log) {
   log("build client lib");
@@ -91,32 +69,114 @@ async function buildClientLib(cwd, userConfig, sourcemap, external, log) {
   const entry = import_path.default.join(esDir, "index.ts");
   import_fs_extra.default.removeSync(entry);
   import_fs_extra.default.linkSync(import_path.default.join(cwd, "es/index.mjs"), entry);
-  await (0, import_vite.build)(
-    userConfig.modifyViteConfig({
-      mode: process.env.NODE_ENV || "production",
-      esbuild: {
-        format: "cjs"
+  try {
+    await buildClientWithRsbuild(cwd, userConfig, sourcemap, external, entry, outDir, "cjs");
+  } finally {
+    import_fs_extra.default.removeSync(entry);
+  }
+  await injectEntryStyleReference(import_path.default.join(outDir, "index.js"), 'require("./index.css");');
+}
+async function buildClientWithRsbuild(cwd, userConfig, sourcemap, external, entry, outDir, format) {
+  const config = createClientRsbuildConfig(cwd, entry, outDir, sourcemap, external, format);
+  const rsbuild = await (0, import_core.createRsbuild)({
+    cwd,
+    config: userConfig.modifyRsbuildConfig?.(config) ?? config
+  });
+  const result = await rsbuild.build();
+  await result.close();
+}
+function createClientRsbuildConfig(cwd, entry, outDir, sourcemap, external, format) {
+  return {
+    plugins: [(0, import_plugin_react.pluginReact)(), (0, import_plugin_less.pluginLess)(), (0, import_plugin_svgr.pluginSvgr)()],
+    source: {
+      entry: {
+        index: {
+          import: entry,
+          html: false
+        }
+      },
+      tsconfigPath: import_path.default.join(cwd, "tsconfig.json"),
+      define: (0, import_utils.getEnvDefine)(),
+      decorators: {
+        version: "legacy"
+      }
+    },
+    output: {
+      target: "web",
+      distPath: {
+        root: outDir,
+        js: ".",
+        jsAsync: ".",
+        css: ".",
+        cssAsync: ".",
+        svg: ".",
+        font: ".",
+        image: ".",
+        media: ".",
+        assets: "."
       },
-      build: {
-        outDir,
-        minify: process.env.NODE_ENV === "production",
-        sourcemap,
-        lib: {
-          entry: import_path.default.join(cwd, "es/index.ts"),
-          formats: ["cjs"],
-          fileName: "index"
-        },
-        rollupOptions: {
-          external
+      filename: {
+        js: format === "esm" ? "[name].mjs" : "[name].js",
+        css: "[name].css",
+        svg: "[name][ext][query]",
+        font: "[name][ext][query]",
+        image: "[name][ext][query]",
+        media: "[name][ext][query]",
+        assets: "[name][ext][query]"
+      },
+      cleanDistPath: true,
+      sourceMap: sourcemap,
+      minify: process.env.NODE_ENV === "production",
+      emitCss: true,
+      externals: [
+        function({ request }, callback) {
+          if (request && external(request)) {
+            return callback(null, true);
+          }
+          callback();
         }
+      ]
+    },
+    performance: {
+      chunkSplit: {
+        strategy: "all-in-one"
       }
-    })
-  );
-  import_fs_extra.default.removeSync(entry);
-  const css = import_fast_glob.default.sync("*.css", { cwd: esDir, absolute: true });
-  css.forEach((file) => {
-    import_fs_extra.default.copySync(file, import_path.default.join(outDir, import_path.default.basename(file)));
-  });
+    },
+    tools: {
+      rspack(config) {
+        config.output = config.output || {};
+        config.output.asyncChunks = false;
+        if (format === "esm") {
+          config.output.library = { type: "module" };
+          config.output.module = true;
+          config.output.chunkFormat = "module";
+          config.output.chunkLoading = "import";
+          config.output.workerChunkLoading = "import";
+          config.experiments = {
+            ...config.experiments,
+            outputModule: true
+          };
+          config.externalsType = "module-import";
+        } else {
+          config.output.library = { type: "commonjs-static" };
+        }
+        config.performance = false;
+        config.stats = "errors-warnings";
+      }
+    }
+  };
+}
+async function injectEntryStyleReference(entryFile, styleReference) {
+  const cssFile = import_path.default.join(import_path.default.dirname(entryFile), "index.css");
+  if (!import_fs_extra.default.existsSync(entryFile) || !import_fs_extra.default.existsSync(cssFile)) {
+    return;
+  }
+  const content = await import_fs_extra.default.readFile(entryFile, "utf8");
+  if (content.startsWith(styleReference)) {
+    return;
+  }
+  await import_fs_extra.default.writeFile(entryFile, `${styleReference}
+${content}`);
 }
 function buildLocale(cwd, userConfig, log) {
   log("build client locale");