ptech-preset 1.1.3 → 1.1.5

package/dist/index.d.ts

@@ -1,14 +1,24 @@
 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;
+    /** options chuyển nguyên vẹn sang @module-federation/rsbuild-plugin */
     mf: Record<string, any>;
 };
+/**
+ * Plugin bọc (wrapper) để tự động hoá exposes/remotes rồi compose MF plugin.
+ */
 declare function pluginMFAuto(opts: MfAutoOptions): RsbuildPlugin;
 
 export { type MfAutoOptions, pluginMFAuto as default, pluginMFAuto };

package/dist/index.js

@@ -1,5 +1,7 @@
 // src/index.ts
 import path3 from "path";
+import fs3 from "fs";
+import os from "os";
 
 // src/collectAutoExposes.ts
 import path from "path";
@@ -103,6 +105,26 @@ async function collectAutoRemotes(opts = {}) {
 }
 
 // src/index.ts
+function getPackageName(root) {
+  try {
+    const pkgPath = path3.resolve(root, "package.json");
+    if (fs3.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs3.readFileSync(pkgPath, "utf8"));
+      if (pkg.name && typeof pkg.name === "string") {
+        return pkg.name.replace(/\W+/g, "");
+      }
+    }
+  } catch (err) {
+    console.warn("[plugin-mf-auto] Cannot read package.json:", err);
+  }
+  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}`;
+}
 function pluginMFAuto(opts) {
   const {
     baseDir = "src",
@@ -111,6 +133,9 @@ function pluginMFAuto(opts) {
     envPrefix = "REMOTE_",
     manifestPathOrUrl,
     autoWhenEmpty = true,
+    cssInjection = "none",
+    cssEntry = "src/index.css",
+    stylesExposeKey = "./styles",
     mf
   } = opts;
   if (!mf || typeof mf !== "object") {
@@ -133,27 +158,84 @@ 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 (!mfMerged.name) {
-          mfMerged.name = path3.basename(api.context.rootPath).replace(/\W+/g, "");
+        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}`
+          };
         }
-        config.plugins ||= [];
-        config.plugins.push(pluginModuleFederation(mfMerged));
-        return config;
-      });
+      }
+      if (typeof mfMerged.dts === "undefined") {
+        mfMerged.dts = true;
+      }
+      const mfPlugin = pluginModuleFederation(mfMerged);
+      await mfPlugin.setup?.(api);
     }
   };
 }

package/package.json

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