ptech-preset 1.2.4 → 1.2.6

package/dist/index.d.ts

@@ -13,6 +13,10 @@ type MfAutoOptions = {
     stylesExposeKey?: string;
     separateExposes?: boolean;
     separateExposeChunkPrefix?: string;
+    /** tên folder chứa types đã consume; mặc định "@mf-types" */
+    typesFolder?: string;
+    /** env để ép refresh types ở dev (khởi động lại dev) */
+    devTypesRefreshEnvVar?: string;
     mf: Record<string, any>;
 };
 declare function pluginCore(opts: MfAutoOptions): RsbuildPlugin;

package/dist/index.js

@@ -17,10 +17,7 @@ async function collectAutoExposes(opts = {}) {
     absolute: true,
     ignore: ["**/*.d.ts"]
   });
-  const jsdocRe = new RegExp(
-    String.raw`/\*\*[\s\S]*?@${tag}(?:\s+([^\s*]+))?[\s\S]*?\*/`,
-    "m"
-  );
+  const jsdocRe = new RegExp(String.raw`/\*\*[\s\S]*?@${tag}(?:\s+([^\s*]+))?[\s\S]*?\*/`, "m");
   const exposes = {};
   const root = process.cwd();
   for (const abs of files) {
@@ -50,10 +47,7 @@ async function collectAutoExposesWithWrapper(opts = {}) {
     ignore: ["**/*.d.ts"]
   });
   const root = process.cwd();
-  const jsdocRe = new RegExp(
-    String.raw`/\*\*[\s\S]*?@expose(?:\s+([^\s*]+))?[\s\S]*?\*/`,
-    "m"
-  );
+  const jsdocRe = new RegExp(String.raw`/\*\*[\s\S]*?@expose(?:\s+([^\s*]+))?[\s\S]*?\*/`, "m");
   const wrapperRe = /exposeComponent\s*\(\s*[^,]+,\s*['"`]([^'"`]+)['"`]\s*\)/;
   const exposes = {};
   for (const abs of files) {
@@ -74,7 +68,9 @@ async function collectAutoExposesWithWrapper(opts = {}) {
     }
   }
   if (debug) {
-    console.log(`[mf-auto] collectAutoExposesWithWrapper: ${Object.keys(exposes).length} expose(s) found`);
+    console.log(
+      `[mf-auto] collectAutoExposesWithWrapper: ${Object.keys(exposes).length} expose(s) found`
+    );
   }
   return exposes;
 }
@@ -85,10 +81,12 @@ import path2 from "path";
 async function collectAutoRemotes(opts = {}) {
   const remotes = {};
   const prefix = opts.envPrefix ?? "REMOTE_";
-  for (const [k, v] of Object.entries(process.env)) {
-    if (!v) continue;
+  for (const [k, vRaw] of Object.entries(process.env)) {
+    if (!vRaw) continue;
     if (k.startsWith(prefix)) {
       const scope = k.slice(prefix.length).toLowerCase();
+      const v = String(vRaw).trim();
+      if (!v) continue;
       remotes[scope] = `${scope}@${v}`;
     }
   }
@@ -115,9 +113,13 @@ async function collectAutoRemotes(opts = {}) {
         console.warn(`[mf-auto] read manifest error:`, e);
       }
     }
-    for (const [scope, url] of Object.entries(obj)) {
-      if (typeof url === "string" && url.trim()) {
-        remotes[scope] = `${scope}@${url}`;
+    for (const [scopeRaw, urlRaw] of Object.entries(obj)) {
+      const scope = String(scopeRaw).toLowerCase();
+      const url = String(urlRaw || "").trim();
+      if (url) {
+        if (!remotes[scope]) {
+          remotes[scope] = `${scope}@${url}`;
+        }
       }
     }
   }
@@ -154,6 +156,75 @@ var DEFAULT_SHARED = {
   "@azure/msal-browser": { singleton: true, eager: true, requiredVersion: false }
 };
 var CDN_BASE = "https://oneportal.blob.core.windows.net/external/ts/";
+function parseRemoteSpec(key, val) {
+  if (typeof val !== "string") return null;
+  const m = val.match(/^([^@]+)@(.+)$/);
+  if (m) return { scope: m[1], url: m[2] };
+  return { scope: key, url: val };
+}
+function inferTypeUrls(remoteUrl) {
+  if (typeof remoteUrl !== "string") return null;
+  const base = remoteUrl.replace(/\/remoteEntry(\.[cm]?js)?(\?.*)?$/i, "");
+  const b = base && base !== remoteUrl ? base : (() => {
+    const i = remoteUrl.lastIndexOf("/");
+    return i > 7 ? remoteUrl.slice(0, i) : remoteUrl;
+  })();
+  return { base: b, zip: `${b}/@mf-types.zip`, api: `${b}/@mf-types.d.ts` };
+}
+function buildRemoteTypeUrls(remotes) {
+  const out = {};
+  if (!remotes || typeof remotes !== "object") return out;
+  for (const [key, val] of Object.entries(remotes)) {
+    if (typeof val !== "string") continue;
+    const parsed = parseRemoteSpec(key, val);
+    if (!parsed) continue;
+    const t = inferTypeUrls(parsed.url);
+    if (!t) continue;
+    const scope = (parsed.scope || key).toString();
+    out[scope] = { alias: scope, zip: t.zip, api: t.api };
+  }
+  return out;
+}
+function ensureDtsObject(dts) {
+  if (dts === false) return false;
+  if (dts == null || dts === true) return {};
+  if (typeof dts === "object") return { ...dts };
+  return {};
+}
+async function devFetchRemoteTypesOnce(params) {
+  const { root, baseDir, typesFolderRel, urls } = params;
+  if (!urls || Object.keys(urls).length === 0) return;
+  const typesRootAbs = path3.resolve(root, typesFolderRel);
+  const remDir = path3.join(typesRootAbs, "__remotes");
+  fs3.mkdirSync(remDir, { recursive: true });
+  for (const [scope, spec] of Object.entries(urls)) {
+    try {
+      const res = await fetch(spec.api);
+      if (!res.ok) {
+        console.warn(`[mf-auto] fetch types failed for ${scope}: ${res.status} ${res.statusText}`);
+        continue;
+      }
+      const txt = await res.text();
+      fs3.writeFileSync(path3.join(remDir, `${scope}.d.ts`), txt, "utf8");
+    } catch (e) {
+      console.warn(`[mf-auto] fetch types error for ${scope}:`, e);
+    }
+  }
+  const refs = Object.keys(urls).map((s) => `/// <reference path="./__remotes/${s}.d.ts" />`).join(os.EOL);
+  const banner = `// generated by plugin-mf-auto (dev once)
+`;
+  fs3.writeFileSync(path3.join(typesRootAbs, "index.d.ts"), banner + refs + os.EOL, "utf8");
+  const shimDir = path3.join(root, baseDir, ".mf-auto");
+  fs3.mkdirSync(shimDir, { recursive: true });
+  const relToIndex = path3.relative(shimDir, path3.join(typesRootAbs, "index.d.ts")).replace(/\\/g, "/");
+  fs3.writeFileSync(
+    path3.join(shimDir, "mf-types.d.ts"),
+    `/// <reference path="${relToIndex}" />
+// generated by plugin-mf-auto
+`,
+    "utf8"
+  );
+}
 function pluginCore(opts) {
   const {
     baseDir = "src",
@@ -167,6 +238,8 @@ function pluginCore(opts) {
     stylesExposeKey = "./styles",
     separateExposes = true,
     separateExposeChunkPrefix = "mf-expose-",
+    typesFolder = "@mf-types",
+    devTypesRefreshEnvVar = "MF_DTS_REFRESH",
     mf
   } = opts;
   if (!mf || typeof mf !== "object") {
@@ -249,18 +322,60 @@ function pluginCore(opts) {
           mfMerged.exposes = { ...mfMerged.exposes ?? {}, [stylesExposeKey]: `./${relFromRoot}` };
         }
       }
-      const isBuild = api?.context?.command === "build" || process.env.NODE_ENV === "production";
-      if (typeof mfMerged.dts === "undefined") {
-        mfMerged.dts = isBuild;
+      const command = api?.context?.command;
+      const isProd = process.env.NODE_ENV === "production" || command === "build";
+      const isDev = !isProd;
+      const autoTypeUrls = buildRemoteTypeUrls(mfMerged.remotes || {});
+      if (isDev) {
+        const refresh = process.env[devTypesRefreshEnvVar] === "1";
+        const typesRootAbs = path3.resolve(root, typesFolder);
+        const indexFile = path3.join(typesRootAbs, "index.d.ts");
+        const needFetch = refresh || !fs3.existsSync(indexFile) || Object.keys(autoTypeUrls).some(
+          (s) => !fs3.existsSync(path3.join(typesRootAbs, "__remotes", `${s}.d.ts`))
+        );
+        if (Object.keys(autoTypeUrls).length > 0) {
+          if (needFetch) {
+            await devFetchRemoteTypesOnce({
+              root,
+              baseDir,
+              typesFolderRel: typesFolder,
+              urls: autoTypeUrls
+            });
+          }
+          const dtsObj = ensureDtsObject(mfMerged.dts);
+          dtsObj.generateTypes = dtsObj.generateTypes ?? { tsConfigPath: "./tsconfig.json" };
+          mfMerged.dts = dtsObj;
+        } else {
+          const dtsObj = ensureDtsObject(mfMerged.dts);
+          dtsObj.generateTypes = dtsObj.generateTypes ?? { tsConfigPath: "./tsconfig.json" };
+          mfMerged.dts = dtsObj;
+        }
+      } else {
+        if (mfMerged.dts !== false) {
+          const dtsObj = ensureDtsObject(mfMerged.dts);
+          if (Object.keys(autoTypeUrls).length > 0) {
+            const existingConsume = dtsObj.consumeTypes ?? {};
+            const existingRt = existingConsume.remoteTypeUrls ?? {};
+            dtsObj.consumeTypes = {
+              typesFolder: existingConsume.typesFolder ?? typesFolder,
+              maxRetries: existingConsume.maxRetries ?? 3,
+              // ưu tiên config hiện hữu nếu đụng key
+              remoteTypeUrls: { ...autoTypeUrls, ...existingRt }
+            };
+          }
+          dtsObj.generateTypes = dtsObj.generateTypes ?? { tsConfigPath: "./tsconfig.json" };
+          mfMerged.dts = dtsObj;
+        }
       }
       const mfPlugin = pluginModuleFederation(mfMerged);
       await mfPlugin.setup?.(api);
       const pkgSafe = getPackageName(root) || mfMerged.name || path3.basename(root).replace(/\W+/g, "");
       const cdnUrl = `${CDN_BASE}${pkgSafe}/`;
-      const isProd = process.env.NODE_ENV === "production";
       api.modifyRsbuildConfig((config) => {
         config.output ??= {};
-        if (isProd && !config.output.assetPrefix) config.output.assetPrefix = cdnUrl;
+        if (!config.output.assetPrefix && process.env.NODE_ENV === "production") {
+          config.output.assetPrefix = cdnUrl;
+        }
         return config;
       });
       if (separateExposes && mfMerged.exposes) {

package/package.json

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