ptech-preset 1.1.4 → 1.1.6

package/dist/index.d.ts

@@ -1,12 +1,22 @@
 import { RsbuildPlugin } from '@rsbuild/core';
 
+type CssInjectionMode = "none" | "wrapper" | "styles-expose";
 type MfAutoOptions = {
     baseDir?: string;
     globs?: string[];
     exposesMode?: "jsdoc" | "wrapper" | "both";
     envPrefix?: string;
     manifestPathOrUrl?: string;
+    /** true: chỉ auto khi exposes/remotes trống; false: luôn auto rồi merge */
     autoWhenEmpty?: boolean;
+    /** Tiêm CSS vào exposes */
+    cssInjection?: CssInjectionMode;
+    cssEntry?: string;
+    stylesExposeKey?: string;
+    /** Ép tách chunk cho từng expose */
+    separateExposes?: boolean;
+    separateExposeChunkPrefix?: string;
+    /** options chuyển nguyên vẹn sang @module-federation/rsbuild-plugin */
     mf: Record<string, any>;
 };
 declare function pluginMFAuto(opts: MfAutoOptions): RsbuildPlugin;

package/dist/index.js

@@ -1,6 +1,7 @@
 // src/index.ts
 import path3 from "path";
 import fs3 from "fs";
+import os from "os";
 
 // src/collectAutoExposes.ts
 import path from "path";
@@ -118,6 +119,13 @@ function getPackageName(root) {
   }
   return void 0;
 }
+function normalizeExposePath(root, maybeRel) {
+  const cleaned = maybeRel.replace(/^\.\//, "");
+  const abs = path3.resolve(root, cleaned);
+  const relFromRoot = path3.relative(root, abs).replace(/\\/g, "/");
+  return `./${relFromRoot}`;
+}
+var escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 function pluginMFAuto(opts) {
   const {
     baseDir = "src",
@@ -126,6 +134,11 @@ function pluginMFAuto(opts) {
     envPrefix = "REMOTE_",
     manifestPathOrUrl,
     autoWhenEmpty = true,
+    cssInjection = "none",
+    cssEntry = "src/index.css",
+    stylesExposeKey = "./styles",
+    separateExposes = true,
+    separateExposeChunkPrefix = "mf-expose-",
     mf
   } = opts;
   if (!mf || typeof mf !== "object") {
@@ -139,8 +152,7 @@ function pluginMFAuto(opts) {
     async setup(api) {
       const { pluginModuleFederation } = await import("@module-federation/rsbuild-plugin");
       const getExposes = async () => {
-        if (exposesMode === "jsdoc")
-          return collectAutoExposes({ baseDir, globs });
+        if (exposesMode === "jsdoc") return collectAutoExposes({ baseDir, globs });
         if (exposesMode === "wrapper")
           return collectAutoExposesWithWrapper({ baseDir, globs });
         const a = await collectAutoExposes({ baseDir, globs });
@@ -148,27 +160,98 @@ function pluginMFAuto(opts) {
         return { ...a, ...b };
       };
       const getRemotes = async () => collectAutoRemotes({ envPrefix, manifestPathOrUrl });
-      api.modifyRsbuildConfig(async (config) => {
-        const mfMerged = { ...mf };
-        if (!autoWhenEmpty || mfMerged.exposes == null || Object.keys(mfMerged.exposes).length === 0) {
-          const autoExposes = await getExposes();
-          if (Object.keys(autoExposes).length > 0) {
-            mfMerged.exposes = { ...mfMerged.exposes ?? {}, ...autoExposes };
+      const root = api.context.rootPath;
+      const mfMerged = { ...mf };
+      if (!autoWhenEmpty || mfMerged.exposes == null || Object.keys(mfMerged.exposes).length === 0) {
+        const autoExposes = await getExposes();
+        if (Object.keys(autoExposes).length > 0) {
+          const normalized = {};
+          for (const [k, rel] of Object.entries(autoExposes)) {
+            normalized[k] = normalizeExposePath(root, rel);
           }
+          mfMerged.exposes = { ...mfMerged.exposes ?? {}, ...normalized };
+        }
+      } else if (mfMerged.exposes) {
+        const normalized = {};
+        for (const [k, rel] of Object.entries(mfMerged.exposes)) {
+          normalized[k] = normalizeExposePath(root, String(rel));
         }
-        if (!autoWhenEmpty || mfMerged.remotes == null || Object.keys(mfMerged.remotes).length === 0) {
-          const autoRemotes = await getRemotes();
-          if (Object.keys(autoRemotes).length > 0) {
-            mfMerged.remotes = { ...mfMerged.remotes ?? {}, ...autoRemotes };
+        mfMerged.exposes = normalized;
+      }
+      if (!autoWhenEmpty || mfMerged.remotes == null || Object.keys(mfMerged.remotes).length === 0) {
+        const autoRemotes = await getRemotes();
+        if (Object.keys(autoRemotes).length > 0) {
+          mfMerged.remotes = { ...mfMerged.remotes ?? {}, ...autoRemotes };
+        }
+      }
+      if (!mfMerged.name) {
+        mfMerged.name = getPackageName(root) || path3.basename(root).replace(/\W+/g, "");
+      }
+      if (cssInjection !== "none") {
+        const cssAbs = path3.resolve(root, cssEntry);
+        const hasCss = fs3.existsSync(cssAbs);
+        const tempDir = path3.resolve(root, ".mf-auto");
+        fs3.mkdirSync(tempDir, { recursive: true });
+        if (cssInjection === "wrapper" && mfMerged.exposes) {
+          const wrapped = {};
+          for (const [key, rel] of Object.entries(
+            mfMerged.exposes
+          )) {
+            const targetAbs = path3.resolve(root, String(rel).replace(/^\.\//, ""));
+            const proxyFile = path3.join(
+              tempDir,
+              `expose_${key.replace(/[./]/g, "_")}.ts`
+            );
+            const lines = [];
+            if (hasCss) {
+              lines.push(`import ${JSON.stringify(cssAbs.replace(/\\/g, "/"))};`);
+            } else {
+              lines.push(`/* no css: ${cssEntry} not found */`);
+            }
+            const target = JSON.stringify(targetAbs.replace(/\\/g, "/"));
+            lines.push(`export * from ${target};`);
+            lines.push(`export { default } from ${target};`);
+            lines.push(`// generated by plugin-mf-auto`);
+            fs3.writeFileSync(proxyFile, lines.join(os.EOL), "utf8");
+            const relFromRoot = path3.relative(root, proxyFile).replace(/\\/g, "/");
+            wrapped[key] = `./${relFromRoot}`;
           }
+          mfMerged.exposes = wrapped;
+        }
+        if (cssInjection === "styles-expose" && hasCss) {
+          const stylesFile = path3.join(tempDir, `styles_expose.ts`);
+          fs3.writeFileSync(
+            stylesFile,
+            `import ${JSON.stringify(cssAbs.replace(/\\/g, "/"))};
+// generated by plugin-mf-auto`,
+            "utf8"
+          );
+          const relFromRoot = path3.relative(root, stylesFile).replace(/\\/g, "/");
+          mfMerged.exposes = {
+            ...mfMerged.exposes ?? {},
+            [stylesExposeKey]: `./${relFromRoot}`
+          };
         }
-        if (!mfMerged.name) {
-          mfMerged.name = getPackageName(api.context.rootPath) || path3.basename(api.context.rootPath).replace(/\W+/g, "");
+      }
+      if (typeof mfMerged.dts === "undefined") mfMerged.dts = true;
+      const mfPlugin = pluginModuleFederation(mfMerged);
+      await mfPlugin.setup?.(api);
+      if (separateExposes && mfMerged.exposes) {
+        const force = {};
+        for (const [key, rel] of Object.entries(
+          mfMerged.exposes
+        )) {
+          const abs = path3.resolve(root, String(rel).replace(/^\.\//, "")).replace(/\\/g, "/");
+          const safe = separateExposeChunkPrefix + key.replace(/[^a-zA-Z0-9_]/g, "_");
+          force[safe] = new RegExp(`${escapeRegExp(abs)}$`);
         }
-        config.plugins ||= [];
-        config.plugins.push(pluginModuleFederation(mfMerged));
-        return config;
-      });
+        api.modifyRsbuildConfig((config) => {
+          (config.performance ??= {}).chunkSplit ??= {};
+          const cs = config.performance.chunkSplit;
+          cs.forceSplitting = { ...cs.forceSplitting || {}, ...force };
+          return config;
+        });
+      }
     }
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ptech-preset",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "description": "Auto Module.",
   "type": "module",
   "main": "dist/index.js",