@module-federation/dts-plugin 0.8.11 → 0.8.12

package/dist/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @module-federation/dts-plugin
 
+## 0.8.12
+
+### Patch Changes
+
+- d227303: fix(dts-plugin): only block build process in prod env when generating types
+  - @module-federation/sdk@0.8.12
+  - @module-federation/managers@0.8.12
+  - @module-federation/third-party-dts-extractor@0.8.12
+  - @module-federation/error-codes@0.8.12
+
 ## 0.8.11
 
 ### Patch Changes

package/dist/esm/index.js

@@ -307,11 +307,22 @@ var _ConsumeTypesPlugin = class _ConsumeTypesPlugin {
       displayErrorInTerminal: dtsOptions.displayErrorInTerminal
     };
     validateOptions(finalOptions.host);
-    consumeTypes(finalOptions).then(() => {
+    const promise = consumeTypes(finalOptions).then(() => {
       callback();
     }).catch(() => {
       callback();
     });
+    compiler.hooks.thisCompilation.tap("mf:generateTypes", (compilation) => {
+      compilation.hooks.processAssets.tapPromise({
+        name: "mf:generateTypes",
+        stage: (
+          // @ts-expect-error use runtime variable in case peer dep not installed , it should execute before generate types
+          compilation.constructor.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER - 1
+        )
+      }, () => __async(this, null, function* () {
+        yield promise;
+      }));
+    });
   }
 };
 __name(_ConsumeTypesPlugin, "ConsumeTypesPlugin");
@@ -369,7 +380,84 @@ var _GenerateTypesPlugin = class _GenerateTypesPlugin {
       return fn;
     }, "getGenerateTypesFn");
     const generateTypesFn = getGenerateTypesFn();
-    let compiledOnce = false;
+    const emitTypesFiles = /* @__PURE__ */ __name((compilation) => __async(this, null, function* () {
+      try {
+        const { zipTypesPath, apiTypesPath, zipName, apiFileName } = retrieveTypesAssetsInfo(finalOptions.remote);
+        if (isProd && zipName && compilation.getAsset(zipName)) {
+          callback();
+          return;
+        }
+        yield generateTypesFn(finalOptions);
+        const config = finalOptions.remote.moduleFederationConfig;
+        let zipPrefix = "";
+        if (typeof config.manifest === "object" && config.manifest.filePath) {
+          zipPrefix = config.manifest.filePath;
+        } else if (typeof config.manifest === "object" && config.manifest.fileName) {
+          zipPrefix = path5.dirname(config.manifest.fileName);
+        } else if (config.filename) {
+          zipPrefix = path5.dirname(config.filename);
+        }
+        if (isProd) {
+          const zipAssetName = path5.join(zipPrefix, zipName);
+          const apiAssetName = path5.join(zipPrefix, apiFileName);
+          if (zipTypesPath && !compilation.getAsset(zipAssetName)) {
+            compilation.emitAsset(zipAssetName, new compiler.webpack.sources.RawSource(fs2.readFileSync(zipTypesPath), false));
+          }
+          if (apiTypesPath && !compilation.getAsset(apiAssetName)) {
+            compilation.emitAsset(apiAssetName, new compiler.webpack.sources.RawSource(fs2.readFileSync(apiTypesPath), false));
+          }
+          callback();
+        } else {
+          const isEEXIST = /* @__PURE__ */ __name((err) => {
+            return err.code == "EEXIST";
+          }, "isEEXIST");
+          if (zipTypesPath) {
+            const zipContent = fs2.readFileSync(zipTypesPath);
+            const zipOutputPath = path5.join(compiler.outputPath, zipPrefix, zipName);
+            yield new Promise((resolve2, reject) => {
+              compiler.outputFileSystem.mkdir(path5.dirname(zipOutputPath), (err) => {
+                if (err && !isEEXIST(err)) {
+                  reject(err);
+                } else {
+                  compiler.outputFileSystem.writeFile(zipOutputPath, zipContent, (writeErr) => {
+                    if (writeErr && !isEEXIST(writeErr)) {
+                      reject(writeErr);
+                    } else {
+                      resolve2();
+                    }
+                  });
+                }
+              });
+            });
+          }
+          if (apiTypesPath) {
+            const apiContent = fs2.readFileSync(apiTypesPath);
+            const apiOutputPath = path5.join(compiler.outputPath, zipPrefix, apiFileName);
+            yield new Promise((resolve2, reject) => {
+              compiler.outputFileSystem.mkdir(path5.dirname(apiOutputPath), (err) => {
+                if (err && !isEEXIST(err)) {
+                  reject(err);
+                } else {
+                  compiler.outputFileSystem.writeFile(apiOutputPath, apiContent, (writeErr) => {
+                    if (writeErr && !isEEXIST(writeErr)) {
+                      reject(writeErr);
+                    } else {
+                      resolve2();
+                    }
+                  });
+                }
+              });
+            });
+          }
+          callback();
+        }
+      } catch (err) {
+        callback();
+        if (finalOptions.displayErrorInTerminal) {
+          console.error("Error in mf:generateTypes processAssets hook:", err);
+        }
+      }
+    }), "emitTypesFiles");
     compiler.hooks.thisCompilation.tap("mf:generateTypes", (compilation) => {
       compilation.hooks.processAssets.tapPromise({
         name: "mf:generateTypes",
@@ -379,42 +467,9 @@ var _GenerateTypesPlugin = class _GenerateTypesPlugin {
         )
       }, () => __async(this, null, function* () {
         yield consumeTypesPromise;
-        try {
-          if (pluginOptions.dev === false && compiledOnce) {
-            return;
-          }
-          if (compiledOnce) {
-            return;
-          }
-          const { zipTypesPath, apiTypesPath, zipName, apiFileName } = retrieveTypesAssetsInfo(finalOptions.remote);
-          if (zipName && compilation.getAsset(zipName)) {
-            return;
-          }
-          yield generateTypesFn(finalOptions);
-          const config = finalOptions.remote.moduleFederationConfig;
-          let zipPrefix = "";
-          if (typeof config.manifest === "object" && config.manifest.filePath) {
-            zipPrefix = config.manifest.filePath;
-          } else if (typeof config.manifest === "object" && config.manifest.fileName) {
-            zipPrefix = path5.dirname(config.manifest.fileName);
-          } else if (config.filename) {
-            zipPrefix = path5.dirname(config.filename);
-          }
-          const zipAssetName = path5.join(zipPrefix, zipName);
-          if (zipTypesPath && !compilation.getAsset(zipAssetName)) {
-            compilation.emitAsset(path5.join(zipPrefix, zipName), new compiler.webpack.sources.RawSource(fs2.readFileSync(zipTypesPath), false));
-          }
-          const apiAssetName = path5.join(zipPrefix, apiFileName);
-          if (apiTypesPath && !compilation.getAsset(apiAssetName)) {
-            compilation.emitAsset(path5.join(zipPrefix, apiFileName), new compiler.webpack.sources.RawSource(fs2.readFileSync(apiTypesPath), false));
-          }
-          compiledOnce = true;
-          callback();
-        } catch (err) {
-          callback();
-          if (finalOptions.displayErrorInTerminal) {
-            console.error("Error in mf:generateTypes processAssets hook:", err);
-          }
+        const emitTypesFilesPromise = emitTypesFiles(compilation);
+        if (isProd) {
+          yield emitTypesFilesPromise;
         }
       }));
     });

package/dist/index.js

@@ -2512,11 +2512,22 @@ var _ConsumeTypesPlugin = class _ConsumeTypesPlugin {
       displayErrorInTerminal: dtsOptions.displayErrorInTerminal
     };
     validateOptions(finalOptions.host);
-    consumeTypes(finalOptions).then(() => {
+    const promise = consumeTypes(finalOptions).then(() => {
       callback();
     }).catch(() => {
       callback();
     });
+    compiler.hooks.thisCompilation.tap("mf:generateTypes", (compilation) => {
+      compilation.hooks.processAssets.tapPromise({
+        name: "mf:generateTypes",
+        stage: (
+          // @ts-expect-error use runtime variable in case peer dep not installed , it should execute before generate types
+          compilation.constructor.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER - 1
+        )
+      }, () => __async(this, null, function* () {
+        yield promise;
+      }));
+    });
   }
 };
 __name(_ConsumeTypesPlugin, "ConsumeTypesPlugin");
@@ -2574,7 +2585,84 @@ var _GenerateTypesPlugin = class _GenerateTypesPlugin {
       return fn;
     }, "getGenerateTypesFn");
     const generateTypesFn = getGenerateTypesFn();
-    let compiledOnce = false;
+    const emitTypesFiles = /* @__PURE__ */ __name((compilation) => __async(this, null, function* () {
+      try {
+        const { zipTypesPath, apiTypesPath, zipName, apiFileName } = retrieveTypesAssetsInfo(finalOptions.remote);
+        if (isProd && zipName && compilation.getAsset(zipName)) {
+          callback();
+          return;
+        }
+        yield generateTypesFn(finalOptions);
+        const config = finalOptions.remote.moduleFederationConfig;
+        let zipPrefix = "";
+        if (typeof config.manifest === "object" && config.manifest.filePath) {
+          zipPrefix = config.manifest.filePath;
+        } else if (typeof config.manifest === "object" && config.manifest.fileName) {
+          zipPrefix = import_path10.default.dirname(config.manifest.fileName);
+        } else if (config.filename) {
+          zipPrefix = import_path10.default.dirname(config.filename);
+        }
+        if (isProd) {
+          const zipAssetName = import_path10.default.join(zipPrefix, zipName);
+          const apiAssetName = import_path10.default.join(zipPrefix, apiFileName);
+          if (zipTypesPath && !compilation.getAsset(zipAssetName)) {
+            compilation.emitAsset(zipAssetName, new compiler.webpack.sources.RawSource(import_fs4.default.readFileSync(zipTypesPath), false));
+          }
+          if (apiTypesPath && !compilation.getAsset(apiAssetName)) {
+            compilation.emitAsset(apiAssetName, new compiler.webpack.sources.RawSource(import_fs4.default.readFileSync(apiTypesPath), false));
+          }
+          callback();
+        } else {
+          const isEEXIST = /* @__PURE__ */ __name((err) => {
+            return err.code == "EEXIST";
+          }, "isEEXIST");
+          if (zipTypesPath) {
+            const zipContent = import_fs4.default.readFileSync(zipTypesPath);
+            const zipOutputPath = import_path10.default.join(compiler.outputPath, zipPrefix, zipName);
+            yield new Promise((resolve5, reject) => {
+              compiler.outputFileSystem.mkdir(import_path10.default.dirname(zipOutputPath), (err) => {
+                if (err && !isEEXIST(err)) {
+                  reject(err);
+                } else {
+                  compiler.outputFileSystem.writeFile(zipOutputPath, zipContent, (writeErr) => {
+                    if (writeErr && !isEEXIST(writeErr)) {
+                      reject(writeErr);
+                    } else {
+                      resolve5();
+                    }
+                  });
+                }
+              });
+            });
+          }
+          if (apiTypesPath) {
+            const apiContent = import_fs4.default.readFileSync(apiTypesPath);
+            const apiOutputPath = import_path10.default.join(compiler.outputPath, zipPrefix, apiFileName);
+            yield new Promise((resolve5, reject) => {
+              compiler.outputFileSystem.mkdir(import_path10.default.dirname(apiOutputPath), (err) => {
+                if (err && !isEEXIST(err)) {
+                  reject(err);
+                } else {
+                  compiler.outputFileSystem.writeFile(apiOutputPath, apiContent, (writeErr) => {
+                    if (writeErr && !isEEXIST(writeErr)) {
+                      reject(writeErr);
+                    } else {
+                      resolve5();
+                    }
+                  });
+                }
+              });
+            });
+          }
+          callback();
+        }
+      } catch (err) {
+        callback();
+        if (finalOptions.displayErrorInTerminal) {
+          console.error("Error in mf:generateTypes processAssets hook:", err);
+        }
+      }
+    }), "emitTypesFiles");
     compiler.hooks.thisCompilation.tap("mf:generateTypes", (compilation) => {
       compilation.hooks.processAssets.tapPromise({
         name: "mf:generateTypes",
@@ -2584,42 +2672,9 @@ var _GenerateTypesPlugin = class _GenerateTypesPlugin {
         )
       }, () => __async(this, null, function* () {
         yield consumeTypesPromise;
-        try {
-          if (pluginOptions.dev === false && compiledOnce) {
-            return;
-          }
-          if (compiledOnce) {
-            return;
-          }
-          const { zipTypesPath, apiTypesPath, zipName, apiFileName } = retrieveTypesAssetsInfo(finalOptions.remote);
-          if (zipName && compilation.getAsset(zipName)) {
-            return;
-          }
-          yield generateTypesFn(finalOptions);
-          const config = finalOptions.remote.moduleFederationConfig;
-          let zipPrefix = "";
-          if (typeof config.manifest === "object" && config.manifest.filePath) {
-            zipPrefix = config.manifest.filePath;
-          } else if (typeof config.manifest === "object" && config.manifest.fileName) {
-            zipPrefix = import_path10.default.dirname(config.manifest.fileName);
-          } else if (config.filename) {
-            zipPrefix = import_path10.default.dirname(config.filename);
-          }
-          const zipAssetName = import_path10.default.join(zipPrefix, zipName);
-          if (zipTypesPath && !compilation.getAsset(zipAssetName)) {
-            compilation.emitAsset(import_path10.default.join(zipPrefix, zipName), new compiler.webpack.sources.RawSource(import_fs4.default.readFileSync(zipTypesPath), false));
-          }
-          const apiAssetName = import_path10.default.join(zipPrefix, apiFileName);
-          if (apiTypesPath && !compilation.getAsset(apiAssetName)) {
-            compilation.emitAsset(import_path10.default.join(zipPrefix, apiFileName), new compiler.webpack.sources.RawSource(import_fs4.default.readFileSync(apiTypesPath), false));
-          }
-          compiledOnce = true;
-          callback();
-        } catch (err) {
-          callback();
-          if (finalOptions.displayErrorInTerminal) {
-            console.error("Error in mf:generateTypes processAssets hook:", err);
-          }
+        const emitTypesFilesPromise = emitTypesFiles(compilation);
+        if (isProd) {
+          yield emitTypesFilesPromise;
         }
       }));
     });

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@module-federation/dts-plugin",
-  "version": "0.8.11",
+  "version": "0.8.12",
   "author": "hanric <hanric.zhang@gmail.com>",
   "main": "./dist/index.js",
   "module": "./dist/index.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@module-federation/dts-plugin",
-  "version": "0.8.11",
+  "version": "0.8.12",
   "author": "hanric <hanric.zhang@gmail.com>",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -60,10 +60,10 @@
     "log4js": "6.9.1",
     "node-schedule": "2.1.1",
     "ws": "8.18.0",
-    "@module-federation/sdk": "0.8.11",
-    "@module-federation/managers": "0.8.11",
-    "@module-federation/third-party-dts-extractor": "0.8.11",
-    "@module-federation/error-codes": "0.8.11"
+    "@module-federation/sdk": "0.8.12",
+    "@module-federation/managers": "0.8.12",
+    "@module-federation/third-party-dts-extractor": "0.8.12",
+    "@module-federation/error-codes": "0.8.12"
   },
   "devDependencies": {
     "@types/ws": "8.5.12",
@@ -72,7 +72,7 @@
     "vue": "^3.4.29",
     "@vue/tsconfig": "^0.5.1",
     "vue-tsc": "^2.0.26",
-    "@module-federation/runtime": "0.8.11"
+    "@module-federation/runtime": "0.8.12"
   },
   "peerDependencies": {
     "typescript": "^4.9.0 || ^5.0.0",