@module-federation/dts-plugin 2.0.1 → 2.1.0

package/dist/esm/chunk-MV6M4VFH.js

@@ -1,1642 +0,0 @@
-import {
-  APIKind,
-  Broker,
-  LogKind,
-  fib,
-  fileLog,
-  getFreePort,
-  getIPV4,
-  getIdentifier,
-  logger
-} from "./chunk-WWV5RWOP.js";
-import {
-  AddPublisherAction,
-  AddSubscriberAction,
-  DEFAULT_TAR_NAME,
-  ExitPublisherAction,
-  ExitSubscriberAction,
-  MF_SERVER_IDENTIFIER,
-  NotifyWebClientAction,
-  UpdateKind,
-  UpdateMode,
-  UpdatePublisherAction,
-  __async,
-  __name,
-  __objRest,
-  __publicField,
-  __require,
-  __spreadProps,
-  __spreadValues
-} from "./chunk-647HGGGS.js";
-
-// src/server/DevServer.ts
-import WebSocket from "isomorphic-ws";
-
-// src/server/broker/createBroker.ts
-import { fork } from "child_process";
-import path from "path";
-function createBroker() {
-  const startBrokerPath = path.resolve(__dirname, "./start-broker.js");
-  const sub = fork(startBrokerPath, [], {
-    detached: true,
-    stdio: "ignore",
-    env: process.env
-  });
-  sub.send("start");
-  sub.unref();
-  return sub;
-}
-__name(createBroker, "createBroker");
-
-// src/server/DevServer.ts
-var _ModuleFederationDevServer = class _ModuleFederationDevServer {
-  constructor(ctx) {
-    __publicField(this, "_remotes");
-    __publicField(this, "_ip");
-    __publicField(this, "_name");
-    __publicField(this, "_remoteTypeTarPath");
-    __publicField(this, "_publishWebSocket", null);
-    __publicField(this, "_subscriberWebsocketMap", {});
-    __publicField(this, "_reconnect", true);
-    __publicField(this, "_reconnectTimes", 0);
-    __publicField(this, "_isConnected", false);
-    __publicField(this, "_isReconnecting", false);
-    __publicField(this, "_updateCallback", /* @__PURE__ */ __name(() => Promise.resolve(void 0), "_updateCallback"));
-    const { name, remotes, remoteTypeTarPath, updateCallback } = ctx;
-    this._ip = getIPV4();
-    this._name = name;
-    this._remotes = remotes;
-    this._remoteTypeTarPath = remoteTypeTarPath;
-    this._updateCallback = updateCallback;
-    this._stopWhenSIGTERMOrSIGINT();
-    this._handleUnexpectedExit();
-    this._connectPublishToServer();
-  }
-  _connectPublishToServer() {
-    if (!this._reconnect) {
-      return;
-    }
-    fileLog(`Publisher:${this._name} Trying to connect to ws://${this._ip}:${Broker.DEFAULT_WEB_SOCKET_PORT}...`, MF_SERVER_IDENTIFIER, "info");
-    this._publishWebSocket = new WebSocket(`ws://${this._ip}:${Broker.DEFAULT_WEB_SOCKET_PORT}?WEB_SOCKET_CONNECT_MAGIC_ID=${Broker.WEB_SOCKET_CONNECT_MAGIC_ID}`);
-    this._publishWebSocket.on("open", () => {
-      var _a2;
-      fileLog(`Current pid: ${process.pid}, publisher:${this._name} connected to ws://${this._ip}:${Broker.DEFAULT_WEB_SOCKET_PORT}, starting service...`, MF_SERVER_IDENTIFIER, "info");
-      this._isConnected = true;
-      const addPublisherAction = new AddPublisherAction({
-        name: this._name,
-        ip: this._ip,
-        remoteTypeTarPath: this._remoteTypeTarPath
-      });
-      (_a2 = this._publishWebSocket) == null ? void 0 : _a2.send(JSON.stringify(addPublisherAction));
-      this._connectSubscribers();
-    });
-    this._publishWebSocket.on("message", (message) => __async(this, null, function* () {
-      var _a2, _b;
-      try {
-        const parsedMessage = JSON.parse(message.toString());
-        if (parsedMessage.type === "Log") {
-          if (parsedMessage.kind === LogKind.BrokerExitLog) {
-            fileLog(`Receive broker exit signal, ${this._name} service will exit...`, MF_SERVER_IDENTIFIER, "warn");
-            this._exit();
-          }
-        }
-        if (parsedMessage.type === "API") {
-          if (parsedMessage.kind === APIKind.FETCH_TYPES) {
-            const { payload: { remoteInfo } } = parsedMessage;
-            fileLog(`${this._name} Receive broker FETCH_TYPES, payload as follows: ${JSON.stringify(remoteInfo, null, 2)}.`, MF_SERVER_IDENTIFIER, "info");
-            yield this.fetchDynamicRemoteTypes({
-              remoteInfo
-            });
-          }
-        }
-      } catch (err) {
-        console.error(err);
-        const exitPublisher = new ExitPublisherAction({
-          name: this._name,
-          ip: this._ip
-        });
-        const exitSubscriber = new ExitSubscriberAction({
-          name: this._name,
-          ip: this._ip,
-          publishers: this._remotes.map((remote) => ({
-            name: remote.name,
-            ip: remote.ip
-          }))
-        });
-        (_a2 = this._publishWebSocket) == null ? void 0 : _a2.send(JSON.stringify(exitPublisher));
-        (_b = this._publishWebSocket) == null ? void 0 : _b.send(JSON.stringify(exitSubscriber));
-        fileLog("Parse messages error, ModuleFederationDevServer will exit...", MF_SERVER_IDENTIFIER, "fatal");
-        this._exit();
-      }
-    }));
-    this._publishWebSocket.on("close", (code) => {
-      fileLog(`Connection closed with code ${code}.`, MF_SERVER_IDENTIFIER, "warn");
-      this._publishWebSocket && this._publishWebSocket.close();
-      this._publishWebSocket = null;
-      if (!this._reconnect) {
-        return;
-      }
-      const reconnectTime = fib(++this._reconnectTimes);
-      fileLog(`start reconnecting to server after ${reconnectTime}s.`, MF_SERVER_IDENTIFIER, "info");
-      setTimeout(() => this._connectPublishToServer(), reconnectTime * 1e3);
-    });
-    this._publishWebSocket.on("error", this._tryCreateBackgroundBroker.bind(this));
-  }
-  // Associate the remotes(Subscriber) to the Broker
-  _connectSubscriberToServer(remote) {
-    const { name, ip } = remote;
-    fileLog(`remote module:${name} trying to connect to  ws://${ip}:${Broker.DEFAULT_WEB_SOCKET_PORT}...`, MF_SERVER_IDENTIFIER, "info");
-    const identifier = getIdentifier({
-      name,
-      ip
-    });
-    this._subscriberWebsocketMap[identifier] = new WebSocket(`ws://${ip}:${Broker.DEFAULT_WEB_SOCKET_PORT}?WEB_SOCKET_CONNECT_MAGIC_ID=${Broker.WEB_SOCKET_CONNECT_MAGIC_ID}`);
-    this._subscriberWebsocketMap[identifier].on("open", () => {
-      fileLog(`Current pid: ${process.pid} remote module: ${name} connected to ws://${ip}:${Broker.DEFAULT_WEB_SOCKET_PORT}, starting service...`, MF_SERVER_IDENTIFIER, "info");
-      const addSubscriber = new AddSubscriberAction({
-        name: this._name,
-        ip: this._ip,
-        publishers: [
-          {
-            name,
-            ip
-          }
-        ]
-      });
-      this._subscriberWebsocketMap[identifier].send(JSON.stringify(addSubscriber));
-    });
-    this._subscriberWebsocketMap[identifier].on("message", (message) => __async(this, null, function* () {
-      try {
-        const parsedMessage = JSON.parse(message.toString());
-        if (parsedMessage.type === "Log") {
-          if (parsedMessage.kind === LogKind.BrokerExitLog) {
-            fileLog(`${identifier}'s Server exit, thus ${identifier} will no longer has reload ability.`, MF_SERVER_IDENTIFIER, "warn");
-            this._exit();
-          }
-        }
-        if (parsedMessage.type === "API") {
-          if (parsedMessage.kind === APIKind.UPDATE_SUBSCRIBER) {
-            const { payload: { updateKind, updateSourcePaths, name: subscribeName, remoteTypeTarPath, updateMode } } = parsedMessage;
-            yield this._updateSubscriber({
-              remoteTypeTarPath,
-              name: subscribeName,
-              updateKind,
-              updateMode,
-              updateSourcePaths
-            });
-          }
-        }
-      } catch (err) {
-        console.error(err);
-        const exitSubscriber = new ExitSubscriberAction({
-          name: this._name,
-          ip: this._ip,
-          publishers: [
-            {
-              name,
-              ip
-            }
-          ]
-        });
-        this._subscriberWebsocketMap[identifier].send(JSON.stringify(exitSubscriber));
-        fileLog(`${identifier} exit,
-        error: ${err instanceof Error ? err.toString() : JSON.stringify(err)}
-        `, MF_SERVER_IDENTIFIER, "warn");
-      }
-    }));
-    this._subscriberWebsocketMap[identifier].on("close", (code) => {
-      var _a2;
-      fileLog(`Connection closed with code ${code}.`, MF_SERVER_IDENTIFIER, "warn");
-      (_a2 = this._subscriberWebsocketMap[identifier]) == null ? void 0 : _a2.close();
-      delete this._subscriberWebsocketMap[identifier];
-    });
-    this._subscriberWebsocketMap[identifier].on("error", (err) => {
-      var _a2;
-      if ("code" in err && err.code === "ETIMEDOUT") {
-        fileLog(`Can not connect ${JSON.stringify(remote)}, please make sure this remote is started locally.`, MF_SERVER_IDENTIFIER, "warn");
-      } else {
-        console.error(err);
-      }
-      (_a2 = this._subscriberWebsocketMap[identifier]) == null ? void 0 : _a2.close();
-      delete this._subscriberWebsocketMap[identifier];
-    });
-  }
-  _connectSubscribers() {
-    this._remotes.forEach((remote) => {
-      this._connectSubscriberToServer(remote);
-    });
-  }
-  // app1 consumes provider1. And the function will be triggered when provider1 code change.
-  _updateSubscriber(options) {
-    return __async(this, null, function* () {
-      var _a2;
-      const { updateMode, updateKind, updateSourcePaths, name, remoteTypeTarPath, remoteInfo } = options;
-      fileLog(
-        // eslint-disable-next-line max-len
-        `[_updateSubscriber] run, options: ${JSON.stringify(options, null, 2)}`,
-        MF_SERVER_IDENTIFIER,
-        "warn"
-      );
-      if (updateMode === UpdateMode.PASSIVE && updateSourcePaths.includes(this._name)) {
-        fileLog(
-          // eslint-disable-next-line max-len
-          `[_updateSubscriber] run, updateSourcePaths:${updateSourcePaths} includes ${this._name}, update ignore!`,
-          MF_SERVER_IDENTIFIER,
-          "warn"
-        );
-        return;
-      }
-      if (updateSourcePaths.slice(-1)[0] === this._name) {
-        fileLog(`[_updateSubscriber] run, updateSourcePaths:${updateSourcePaths} ends is ${this._name}, update ignore!`, MF_SERVER_IDENTIFIER, "warn");
-        return;
-      }
-      fileLog(
-        // eslint-disable-next-line max-len
-        `[_updateSubscriber] run, updateSourcePaths:${updateSourcePaths}, current module:${this._name}, update start...`,
-        MF_SERVER_IDENTIFIER,
-        "info"
-      );
-      yield this._updateCallback({
-        name,
-        updateMode,
-        updateKind,
-        updateSourcePaths,
-        remoteTypeTarPath,
-        remoteInfo
-      });
-      const newUpdateSourcePaths = updateSourcePaths.concat(this._name);
-      const updatePublisher = new UpdatePublisherAction({
-        name: this._name,
-        ip: this._ip,
-        updateMode: UpdateMode.PASSIVE,
-        updateKind,
-        updateSourcePaths: newUpdateSourcePaths,
-        remoteTypeTarPath: this._remoteTypeTarPath
-      });
-      fileLog(
-        // eslint-disable-next-line max-len
-        `[_updateSubscriber] run, updateSourcePaths:${newUpdateSourcePaths}, update publisher ${this._name} start...`,
-        MF_SERVER_IDENTIFIER,
-        "info"
-      );
-      (_a2 = this._publishWebSocket) == null ? void 0 : _a2.send(JSON.stringify(updatePublisher));
-    });
-  }
-  _tryCreateBackgroundBroker(err) {
-    if (!(((err == null ? void 0 : err.code) === "ECONNREFUSED" || (err == null ? void 0 : err.code) === "ETIMEDOUT") && err.port === Broker.DEFAULT_WEB_SOCKET_PORT)) {
-      fileLog(`websocket error: ${err.stack}`, MF_SERVER_IDENTIFIER, "fatal");
-      return;
-    }
-    fileLog(`Failed to connect to ws://${this._ip}:${Broker.DEFAULT_WEB_SOCKET_PORT}...`, MF_SERVER_IDENTIFIER, "fatal");
-    this._isReconnecting = true;
-    setTimeout(() => {
-      this._isReconnecting = false;
-      if (this._reconnect === false) {
-        return;
-      }
-      fileLog("Creating new background broker...", MF_SERVER_IDENTIFIER, "warn");
-      const broker = createBroker();
-      broker.on("message", (message) => {
-        if (message === "ready") {
-          fileLog("background broker started.", MF_SERVER_IDENTIFIER, "info");
-          this._reconnectTimes = 1;
-          if (process.send) {
-            process.send("ready");
-          }
-        }
-      });
-    }, Math.ceil(100 * Math.random()));
-  }
-  _stopWhenSIGTERMOrSIGINT() {
-    process.on("SIGTERM", () => {
-      fileLog(`Process(${process.pid}) SIGTERM, ModuleFederationDevServer will exit...`, MF_SERVER_IDENTIFIER, "warn");
-      this._exit();
-    });
-    process.on("SIGINT", () => {
-      fileLog(`Process(${process.pid}) SIGINT, ModuleFederationDevServer will exit...`, MF_SERVER_IDENTIFIER, "warn");
-      this._exit();
-    });
-  }
-  _handleUnexpectedExit() {
-    process.on("unhandledRejection", (error) => {
-      if (this._isReconnecting) {
-        return;
-      }
-      console.error("Unhandled Rejection Error: ", error);
-      fileLog(`Process(${process.pid}) unhandledRejection, garfishModuleServer will exit...`, MF_SERVER_IDENTIFIER, "error");
-      this._exit();
-    });
-    process.on("uncaughtException", (error) => {
-      if (this._isReconnecting) {
-        return;
-      }
-      console.error("Unhandled Exception Error: ", error);
-      fileLog(`Process(${process.pid}) uncaughtException, garfishModuleServer will exit...`, MF_SERVER_IDENTIFIER, "error");
-      this._exit();
-    });
-  }
-  _exit() {
-    this._reconnect = false;
-    if (this._publishWebSocket) {
-      const exitPublisher = new ExitPublisherAction({
-        name: this._name,
-        ip: this._ip
-      });
-      this._publishWebSocket.send(JSON.stringify(exitPublisher));
-      this._publishWebSocket.on("message", (message) => {
-        const parsedMessage = JSON.parse(message.toString());
-        fileLog(`[${parsedMessage.kind}]: ${JSON.stringify(parsedMessage)}`, MF_SERVER_IDENTIFIER, "info");
-      });
-    }
-    if (this._publishWebSocket) {
-      this._publishWebSocket.close();
-      this._publishWebSocket = null;
-    }
-    process.exit(0);
-  }
-  exit() {
-    this._exit();
-  }
-  update(options) {
-    if (!this._publishWebSocket || !this._isConnected) {
-      return;
-    }
-    const { updateKind, updateMode, updateSourcePaths, clientName } = options;
-    fileLog(`update run, ${this._name} module update, updateKind: ${updateKind}, updateMode: ${updateMode}, updateSourcePaths: ${updateSourcePaths}`, MF_SERVER_IDENTIFIER, "info");
-    if (updateKind === UpdateKind.RELOAD_PAGE) {
-      const notifyWebClient = new NotifyWebClientAction({
-        name: clientName || this._name,
-        updateMode
-      });
-      this._publishWebSocket.send(JSON.stringify(notifyWebClient));
-      return;
-    }
-    const updatePublisher = new UpdatePublisherAction({
-      name: this._name,
-      ip: this._ip,
-      updateMode,
-      updateKind,
-      updateSourcePaths: [
-        this._name
-      ],
-      remoteTypeTarPath: this._remoteTypeTarPath
-    });
-    this._publishWebSocket.send(JSON.stringify(updatePublisher));
-  }
-  fetchDynamicRemoteTypes(options) {
-    return __async(this, null, function* () {
-      const { remoteInfo, once } = options;
-      const updateMode = UpdateMode.PASSIVE;
-      const updateKind = UpdateKind.UPDATE_TYPE;
-      fileLog(`fetchDynamicRemoteTypes: remoteInfo: ${JSON.stringify(remoteInfo)}`, MF_SERVER_IDENTIFIER, "info");
-      yield this._updateCallback({
-        name: this._name,
-        updateMode,
-        updateKind,
-        updateSourcePaths: [],
-        remoteTypeTarPath: "",
-        remoteInfo,
-        once
-      });
-      const updatePublisher = new UpdatePublisherAction({
-        name: this._name,
-        ip: this._ip,
-        updateMode,
-        updateKind,
-        updateSourcePaths: [
-          this._name
-        ],
-        remoteTypeTarPath: this._remoteTypeTarPath
-      });
-      this._publishWebSocket.send(JSON.stringify(updatePublisher));
-    });
-  }
-};
-__name(_ModuleFederationDevServer, "ModuleFederationDevServer");
-var ModuleFederationDevServer = _ModuleFederationDevServer;
-
-// src/server/createKoaServer.ts
-import fs from "fs-extra";
-import Koa from "koa";
-function createKoaServer(options) {
-  return __async(this, null, function* () {
-    const { typeTarPath } = options;
-    const freeport = yield getFreePort();
-    const app = new Koa();
-    app.use((ctx, next) => __async(this, null, function* () {
-      if (ctx.path === `/${DEFAULT_TAR_NAME}`) {
-        ctx.status = 200;
-        ctx.body = fs.createReadStream(typeTarPath);
-        ctx.response.type = "application/x-gzip";
-      } else {
-        yield next();
-      }
-    }));
-    app.listen(freeport);
-    return {
-      server: app,
-      serverAddress: `http://${getIPV4()}:${freeport}`
-    };
-  });
-}
-__name(createKoaServer, "createKoaServer");
-
-// src/core/lib/typeScriptCompiler.ts
-import { ensureDirSync, writeFileSync, existsSync } from "fs-extra";
-import crypto from "crypto";
-import { stat, readdir, writeFile, rm, readFile } from "fs/promises";
-import { dirname, join, normalize, relative, resolve, sep, extname, isAbsolute } from "path";
-import { getShortErrorMsg, TYPE_001, typeDescMap } from "@module-federation/error-codes";
-import { ThirdPartyExtractor } from "@module-federation/third-party-dts-extractor";
-import { execFile } from "child_process";
-import util from "util";
-import { TEMP_DIR } from "@module-federation/sdk";
-var STARTS_WITH_SLASH = /^\//;
-var DEFINITION_FILE_EXTENSION = ".d.ts";
-var retrieveMfTypesPath = /* @__PURE__ */ __name((tsConfig, remoteOptions) => normalize(tsConfig.compilerOptions.outDir.replace(remoteOptions.compiledTypesFolder, "")), "retrieveMfTypesPath");
-var retrieveOriginalOutDir = /* @__PURE__ */ __name((tsConfig, remoteOptions) => normalize(tsConfig.compilerOptions.outDir.replace(remoteOptions.compiledTypesFolder, "").replace(remoteOptions.typesFolder, "")), "retrieveOriginalOutDir");
-var retrieveMfAPITypesPath = /* @__PURE__ */ __name((tsConfig, remoteOptions) => join(retrieveOriginalOutDir(tsConfig, remoteOptions), `${remoteOptions.typesFolder}.d.ts`), "retrieveMfAPITypesPath");
-function writeTempTsConfig(tsConfig, context, name, cwd) {
-  const createHash = /* @__PURE__ */ __name((contents) => {
-    return crypto.createHash("md5").update(contents).digest("hex");
-  }, "createHash");
-  const hash = createHash(`${JSON.stringify(tsConfig)}${name}${Date.now()}`);
-  const tempTsConfigJsonPath = resolve(cwd != null ? cwd : context, "node_modules", TEMP_DIR, `tsconfig.${hash}.json`);
-  ensureDirSync(dirname(tempTsConfigJsonPath));
-  writeFileSync(tempTsConfigJsonPath, JSON.stringify(tsConfig, null, 2));
-  return tempTsConfigJsonPath;
-}
-__name(writeTempTsConfig, "writeTempTsConfig");
-var removeExt = /* @__PURE__ */ __name((f) => {
-  const vueExt = ".vue";
-  const ext = extname(f);
-  if (ext === vueExt) {
-    return f;
-  }
-  const regexPattern = new RegExp(`\\${ext}$`);
-  return f.replace(regexPattern, "");
-}, "removeExt");
-function getExposeKey(options) {
-  const { filePath, rootDir, outDir, mapExposeToEntry } = options;
-  const relativeFilePath = relative(outDir, filePath.replace(new RegExp(`\\.d.ts$`), ""));
-  return mapExposeToEntry[relativeFilePath];
-}
-__name(getExposeKey, "getExposeKey");
-var processTypesFile = /* @__PURE__ */ __name((options) => __async(void 0, null, function* () {
-  const { outDir, filePath, rootDir, cb, mapExposeToEntry, mfTypePath } = options;
-  if (!existsSync(filePath)) {
-    return;
-  }
-  const stats = yield stat(filePath);
-  if (stats.isDirectory()) {
-    const files = yield readdir(filePath);
-    yield Promise.all(files.map((file) => processTypesFile(__spreadProps(__spreadValues({}, options), {
-      filePath: join(filePath, file)
-    }))));
-  } else if (filePath.endsWith(".d.ts")) {
-    const exposeKey = getExposeKey({
-      filePath,
-      rootDir,
-      outDir,
-      mapExposeToEntry
-    });
-    if (exposeKey) {
-      const sourceEntry = exposeKey === "." ? "index" : exposeKey;
-      const mfeTypeEntry = join(mfTypePath, `${sourceEntry}${DEFINITION_FILE_EXTENSION}`);
-      const mfeTypeEntryDirectory = dirname(mfeTypeEntry);
-      const relativePathToOutput = relative(mfeTypeEntryDirectory, filePath).replace(DEFINITION_FILE_EXTENSION, "").replace(STARTS_WITH_SLASH, "").split(sep).join("/");
-      ensureDirSync(mfeTypeEntryDirectory);
-      yield writeFile(mfeTypeEntry, `export * from './${relativePathToOutput}';
-export { default } from './${relativePathToOutput}';`);
-    }
-    const content = yield readFile(filePath, "utf8");
-    cb(content);
-  }
-}), "processTypesFile");
-var getPMFromUserAgent = /* @__PURE__ */ __name(() => {
-  const userAgent = process.env["npm_config_user_agent"];
-  if (userAgent == null) {
-    return "null";
-  }
-  const name = userAgent.split("/")[0];
-  return name;
-}, "getPMFromUserAgent");
-var resolvePackageManagerExecutable = /* @__PURE__ */ __name(() => {
-  const pm = getPMFromUserAgent();
-  switch (pm) {
-    case "yarn":
-      return "yarn";
-    case "npm":
-    case "pnpm":
-    default:
-      return "npx";
-  }
-}, "resolvePackageManagerExecutable");
-var splitCommandArgs = /* @__PURE__ */ __name((value) => {
-  const args = [];
-  let current = "";
-  let quote = null;
-  let escaped = false;
-  for (const char of value) {
-    if (escaped) {
-      current += char;
-      escaped = false;
-      continue;
-    }
-    if (char === "\\") {
-      escaped = true;
-      continue;
-    }
-    if (quote) {
-      if (char === quote) {
-        quote = null;
-      } else {
-        current += char;
-      }
-      continue;
-    }
-    if (char === '"' || char === "'") {
-      quote = char;
-      continue;
-    }
-    if (char.trim() === "") {
-      if (current) {
-        args.push(current);
-        current = "";
-      }
-      continue;
-    }
-    current += char;
-  }
-  if (current) {
-    args.push(current);
-  }
-  return args;
-}, "splitCommandArgs");
-var formatCommandForDisplay = /* @__PURE__ */ __name((executable, args) => {
-  const formatArg = /* @__PURE__ */ __name((arg) => {
-    if (/[\s'"]/.test(arg)) {
-      return JSON.stringify(arg);
-    }
-    return arg;
-  }, "formatArg");
-  return [
-    executable,
-    ...args
-  ].map(formatArg).join(" ");
-}, "formatCommandForDisplay");
-var compileTs = /* @__PURE__ */ __name((mapComponentsToExpose, tsConfig, remoteOptions) => __async(void 0, null, function* () {
-  var _a2, _b, _c, _d;
-  if (!Object.keys(mapComponentsToExpose).length) {
-    return;
-  }
-  const { compilerOptions } = tsConfig;
-  const tempTsConfigJsonPath = writeTempTsConfig(tsConfig, remoteOptions.context, remoteOptions.moduleFederationConfig.name || "mf", typeof remoteOptions.moduleFederationConfig.dts !== "boolean" ? (_b = (_a2 = remoteOptions.moduleFederationConfig.dts) == null ? void 0 : _a2.cwd) != null ? _b : void 0 : void 0);
-  logger.debug(`tempTsConfigJsonPath: ${tempTsConfigJsonPath}`);
-  try {
-    const mfTypePath = retrieveMfTypesPath(tsConfig, remoteOptions);
-    const thirdPartyExtractor = new ThirdPartyExtractor({
-      destDir: resolve(mfTypePath, "node_modules"),
-      context: remoteOptions.context,
-      exclude: typeof remoteOptions.extractThirdParty === "object" ? remoteOptions.extractThirdParty.exclude : void 0
-    });
-    const execPromise = util.promisify(execFile);
-    const pmExecutable = resolvePackageManagerExecutable();
-    const compilerArgs = splitCommandArgs(remoteOptions.compilerInstance);
-    const resolvedCompilerArgs = compilerArgs.length > 0 ? compilerArgs : [
-      remoteOptions.compilerInstance
-    ];
-    const cmdArgs = [
-      ...resolvedCompilerArgs,
-      "--project",
-      tempTsConfigJsonPath
-    ];
-    const cmd = formatCommandForDisplay(pmExecutable, cmdArgs);
-    try {
-      yield execPromise(pmExecutable, cmdArgs, {
-        cwd: typeof remoteOptions.moduleFederationConfig.dts !== "boolean" ? (_d = (_c = remoteOptions.moduleFederationConfig.dts) == null ? void 0 : _c.cwd) != null ? _d : void 0 : void 0,
-        shell: process.platform === "win32"
-      });
-    } catch (err) {
-      if (compilerOptions.tsBuildInfoFile) {
-        try {
-          yield rm(compilerOptions.tsBuildInfoFile);
-        } catch (e) {
-        }
-      }
-      throw new Error(getShortErrorMsg(TYPE_001, typeDescMap, {
-        cmd
-      }));
-    }
-    const mapExposeToEntry = Object.fromEntries(Object.entries(mapComponentsToExpose).map(([exposed, filename]) => {
-      const normalizedFileName = normalize(filename);
-      let relativeFileName = "";
-      if (isAbsolute(normalizedFileName)) {
-        relativeFileName = relative(tsConfig.compilerOptions.rootDir, normalizedFileName);
-      } else {
-        relativeFileName = relative(tsConfig.compilerOptions.rootDir, resolve(remoteOptions.context, normalizedFileName));
-      }
-      return [
-        removeExt(relativeFileName),
-        exposed
-      ];
-    }));
-    const cb = remoteOptions.extractThirdParty ? thirdPartyExtractor.collectPkgs.bind(thirdPartyExtractor) : () => void 0;
-    yield processTypesFile({
-      outDir: compilerOptions.outDir,
-      filePath: compilerOptions.outDir,
-      rootDir: compilerOptions.rootDir,
-      mfTypePath,
-      cb,
-      mapExposeToEntry
-    });
-    if (remoteOptions.extractThirdParty) {
-      yield thirdPartyExtractor.copyDts();
-    }
-    if (remoteOptions.deleteTsConfig) {
-      yield rm(tempTsConfigJsonPath);
-    }
-  } catch (err) {
-    throw err;
-  }
-}), "compileTs");
-
-// src/core/lib/archiveHandler.ts
-import AdmZip from "adm-zip";
-import { resolve as resolve3, join as join3 } from "path";
-import { rm as rm3 } from "fs/promises";
-
-// src/core/lib/utils.ts
-import fs3 from "fs";
-import path3 from "path";
-import axios from "axios";
-import http from "http";
-import https from "https";
-import { getProcessEnv } from "@module-federation/sdk";
-import ansiColors from "ansi-colors";
-
-// src/core/configurations/remotePlugin.ts
-import { existsSync as existsSync2 } from "fs";
-import { dirname as dirname2, join as join2, resolve as resolve2, extname as extname2 } from "path";
-import { utils } from "@module-federation/managers";
-import typescript from "typescript";
-var defaultOptions = {
-  tsConfigPath: "./tsconfig.json",
-  typesFolder: "@mf-types",
-  compiledTypesFolder: "compiled-types",
-  hostRemoteTypesFolder: "@mf-types",
-  deleteTypesFolder: true,
-  additionalFilesToCompile: [],
-  compilerInstance: "tsc",
-  compileInChildProcess: false,
-  implementation: "",
-  generateAPITypes: false,
-  context: process.cwd(),
-  abortOnError: true,
-  extractRemoteTypes: false,
-  extractThirdParty: false,
-  outputDir: "",
-  deleteTsConfig: true
-};
-function getEffectiveRootDir(parsedCommandLine) {
-  const compilerOptions = parsedCommandLine.options;
-  if (compilerOptions.rootDir) {
-    return compilerOptions.rootDir;
-  }
-  const files = parsedCommandLine.fileNames;
-  if (files.length > 0) {
-    const commonRoot = files.map((file) => dirname2(file)).reduce((commonPath, fileDir) => {
-      while (!fileDir.startsWith(commonPath)) {
-        commonPath = dirname2(commonPath);
-      }
-      return commonPath;
-    }, files[0]);
-    return commonRoot;
-  }
-  throw new Error("Can not get effective rootDir, please set compilerOptions.rootDir !");
-}
-__name(getEffectiveRootDir, "getEffectiveRootDir");
-var getDependentFiles = /* @__PURE__ */ __name((rootFiles, configContent, rootDir) => {
-  const program = typescript.createProgram(rootFiles, configContent.options);
-  const sourceFiles = program.getSourceFiles();
-  const dependentFiles = sourceFiles.map((file) => file.fileName).filter((file) => !file.endsWith(".d.ts") && file.startsWith(rootDir));
-  return dependentFiles.length ? dependentFiles : rootFiles;
-}, "getDependentFiles");
-var readTsConfig = /* @__PURE__ */ __name(({ tsConfigPath, typesFolder, compiledTypesFolder, context, additionalFilesToCompile, outputDir }, mapComponentsToExpose) => {
-  const resolvedTsConfigPath = resolve2(context, tsConfigPath);
-  const readResult = typescript.readConfigFile(resolvedTsConfigPath, typescript.sys.readFile);
-  if (readResult.error) {
-    throw new Error(readResult.error.messageText.toString());
-  }
-  const rawTsConfigJson = readResult.config;
-  const configContent = typescript.parseJsonConfigFileContent(rawTsConfigJson, typescript.sys, dirname2(resolvedTsConfigPath));
-  const rootDir = getEffectiveRootDir(configContent);
-  const outDir = resolve2(context, outputDir || configContent.options.outDir || "dist", typesFolder, compiledTypesFolder);
-  const defaultCompilerOptions = {
-    rootDir,
-    emitDeclarationOnly: true,
-    noEmit: false,
-    declaration: true,
-    outDir
-  };
-  rawTsConfigJson.compilerOptions = rawTsConfigJson.compilerOptions || {};
-  rawTsConfigJson.compilerOptions = __spreadValues(__spreadValues({
-    incremental: true,
-    tsBuildInfoFile: resolve2(context, "node_modules/.cache/mf-types/.tsbuildinfo")
-  }, rawTsConfigJson.compilerOptions), defaultCompilerOptions);
-  const _a2 = rawTsConfigJson.compilerOptions || {}, { paths, baseUrl } = _a2, restCompilerOptions = __objRest(_a2, ["paths", "baseUrl"]);
-  rawTsConfigJson.compilerOptions = restCompilerOptions;
-  const outDirWithoutTypesFolder = resolve2(context, outputDir || configContent.options.outDir || "dist");
-  const excludeExtensions = [
-    ".mdx",
-    ".md"
-  ];
-  const rootFiles = [
-    ...Object.values(mapComponentsToExpose),
-    ...additionalFilesToCompile
-  ].filter((filename) => !excludeExtensions.some((ext) => filename.endsWith(ext)));
-  const filesToCompile = [
-    ...getDependentFiles(rootFiles, configContent, rootDir),
-    ...configContent.fileNames.filter((filename) => filename.endsWith(".d.ts") && !filename.startsWith(outDirWithoutTypesFolder))
-  ];
-  rawTsConfigJson.include = [];
-  rawTsConfigJson.files = [
-    ...new Set(filesToCompile)
-  ];
-  rawTsConfigJson.exclude = [];
-  "references" in rawTsConfigJson && delete rawTsConfigJson.references;
-  rawTsConfigJson.extends = resolvedTsConfigPath;
-  if (rawTsConfigJson.compilerOptions.declarationDir) {
-    delete rawTsConfigJson.compilerOptions.declarationDir;
-  }
-  return rawTsConfigJson;
-}, "readTsConfig");
-var TS_EXTENSIONS = [
-  "ts",
-  "tsx",
-  "vue",
-  "svelte"
-];
-var resolveWithExtension = /* @__PURE__ */ __name((exposedPath, context) => {
-  if (extname2(exposedPath)) {
-    return resolve2(context, exposedPath);
-  }
-  for (const extension of TS_EXTENSIONS) {
-    const exposedPathWithExtension = resolve2(context, `${exposedPath}.${extension}`);
-    if (existsSync2(exposedPathWithExtension)) {
-      return exposedPathWithExtension;
-    }
-  }
-  return void 0;
-}, "resolveWithExtension");
-var resolveExposes = /* @__PURE__ */ __name((remoteOptions) => {
-  const parsedOptions = utils.parseOptions(remoteOptions.moduleFederationConfig.exposes || {}, (item, key) => ({
-    exposePath: Array.isArray(item) ? item[0] : item,
-    key
-  }), (item, key) => ({
-    exposePath: Array.isArray(item.import) ? item.import[0] : item.import[0],
-    key
-  }));
-  return parsedOptions.reduce((accumulator, item) => {
-    const { exposePath, key } = item[1];
-    accumulator[key] = resolveWithExtension(exposePath, remoteOptions.context) || resolveWithExtension(join2(exposePath, "index"), remoteOptions.context) || exposePath;
-    return accumulator;
-  }, {});
-}, "resolveExposes");
-var retrieveRemoteConfig = /* @__PURE__ */ __name((options) => {
-  validateOptions(options);
-  const remoteOptions = __spreadValues(__spreadValues({}, defaultOptions), options);
-  const mapComponentsToExpose = resolveExposes(remoteOptions);
-  const tsConfig = readTsConfig(remoteOptions, mapComponentsToExpose);
-  if (tsConfig.compilerOptions.incremental && tsConfig.compilerOptions.tsBuildInfoFile && options.deleteTypesFolder !== true) {
-    remoteOptions.deleteTypesFolder = false;
-  }
-  return {
-    tsConfig,
-    mapComponentsToExpose,
-    remoteOptions
-  };
-}, "retrieveRemoteConfig");
-
-// src/core/lib/DTSManager.ts
-import path2 from "path";
-import { rm as rm2 } from "fs/promises";
-import fs2 from "fs";
-import fse from "fs-extra";
-import { MANIFEST_EXT, inferAutoPublicPath } from "@module-federation/sdk";
-import { ThirdPartyExtractor as ThirdPartyExtractor2 } from "@module-federation/third-party-dts-extractor";
-
-// src/core/configurations/hostPlugin.ts
-import { parseEntry, ENCODE_NAME_PREFIX, decodeName } from "@module-federation/sdk";
-import { utils as utils2 } from "@module-federation/managers";
-var defaultOptions2 = {
-  typesFolder: "@mf-types",
-  remoteTypesFolder: "@mf-types",
-  deleteTypesFolder: true,
-  maxRetries: 3,
-  implementation: "",
-  context: process.cwd(),
-  abortOnError: true,
-  consumeAPITypes: false,
-  runtimePkgs: [],
-  remoteTypeUrls: {},
-  timeout: 6e4,
-  typesOnBuild: false,
-  family: 4
-};
-var buildZipUrl = /* @__PURE__ */ __name((hostOptions, url) => {
-  const remoteUrl = new URL(url, "file:");
-  const pathnameWithoutEntry = remoteUrl.pathname.split("/").slice(0, -1).join("/");
-  remoteUrl.pathname = `${pathnameWithoutEntry}/${hostOptions.remoteTypesFolder}.zip`;
-  return remoteUrl.protocol === "file:" ? remoteUrl.pathname : remoteUrl.href;
-}, "buildZipUrl");
-var buildApiTypeUrl = /* @__PURE__ */ __name((zipUrl) => {
-  if (!zipUrl) {
-    return void 0;
-  }
-  return zipUrl.replace(".zip", ".d.ts");
-}, "buildApiTypeUrl");
-var retrieveRemoteInfo = /* @__PURE__ */ __name((options) => {
-  const { hostOptions, remoteAlias, remote } = options;
-  const { remoteTypeUrls } = hostOptions;
-  let decodedRemote = remote;
-  if (decodedRemote.startsWith(ENCODE_NAME_PREFIX)) {
-    decodedRemote = decodeName(decodedRemote, ENCODE_NAME_PREFIX);
-  }
-  const parsedInfo = parseEntry(decodedRemote, void 0, "@");
-  const url = "entry" in parsedInfo ? parsedInfo.entry : parsedInfo.name === decodedRemote ? decodedRemote : "";
-  let zipUrl = "";
-  let apiTypeUrl = "";
-  const name = parsedInfo.name || remoteAlias;
-  if (typeof remoteTypeUrls === "object" && remoteTypeUrls[name]) {
-    zipUrl = remoteTypeUrls[name].zip;
-    apiTypeUrl = remoteTypeUrls[name].api;
-  }
-  if (!zipUrl && url) {
-    zipUrl = buildZipUrl(hostOptions, url);
-  }
-  if (!apiTypeUrl && zipUrl) {
-    apiTypeUrl = buildApiTypeUrl(zipUrl);
-  }
-  return {
-    name,
-    url,
-    zipUrl,
-    apiTypeUrl,
-    alias: remoteAlias
-  };
-}, "retrieveRemoteInfo");
-var resolveRemotes = /* @__PURE__ */ __name((hostOptions) => {
-  var _a2;
-  const parsedOptions = utils2.parseOptions(hostOptions.moduleFederationConfig.remotes || {}, (item, key) => ({
-    remote: Array.isArray(item) ? item[0] : item,
-    key
-  }), (item, key) => ({
-    remote: Array.isArray(item.external) ? item.external[0] : item.external,
-    key
-  }));
-  const remoteTypeUrls = (_a2 = hostOptions.remoteTypeUrls) != null ? _a2 : {};
-  if (typeof remoteTypeUrls !== "object") {
-    throw new Error("remoteTypeUrls must be consumed before resolveRemotes");
-  }
-  const remoteInfos = Object.keys(remoteTypeUrls).reduce((sum, remoteName) => {
-    const { zip, api, alias } = remoteTypeUrls[remoteName];
-    sum[alias] = {
-      name: remoteName,
-      url: "",
-      zipUrl: zip,
-      apiTypeUrl: api,
-      alias: alias || remoteName
-    };
-    return sum;
-  }, {});
-  return parsedOptions.reduce((accumulator, item) => {
-    const { key, remote } = item[1];
-    const res = retrieveRemoteInfo({
-      hostOptions,
-      remoteAlias: key,
-      remote
-    });
-    if (accumulator[key]) {
-      accumulator[key] = __spreadProps(__spreadValues({}, accumulator[key]), {
-        url: res.url,
-        apiTypeUrl: accumulator[key].apiTypeUrl || res.apiTypeUrl
-      });
-      return accumulator;
-    }
-    accumulator[key] = res;
-    return accumulator;
-  }, remoteInfos);
-}, "resolveRemotes");
-var retrieveHostConfig = /* @__PURE__ */ __name((options) => {
-  validateOptions(options);
-  const hostOptions = __spreadValues(__spreadValues({}, defaultOptions2), options);
-  const mapRemotesToDownload = resolveRemotes(hostOptions);
-  return {
-    hostOptions,
-    mapRemotesToDownload
-  };
-}, "retrieveHostConfig");
-
-// src/core/constant.ts
-var REMOTE_ALIAS_IDENTIFIER = "REMOTE_ALIAS_IDENTIFIER";
-var REMOTE_API_TYPES_FILE_NAME = "apis.d.ts";
-var HOST_API_TYPES_FILE_NAME = "index.d.ts";
-
-// src/core/lib/DTSManager.ts
-var _a;
-var DTSManager = (_a = class {
-  constructor(options) {
-    __publicField(this, "options");
-    __publicField(this, "runtimePkgs");
-    __publicField(this, "remoteAliasMap");
-    __publicField(this, "loadedRemoteAPIAlias");
-    __publicField(this, "extraOptions");
-    __publicField(this, "updatedRemoteInfos");
-    this.options = cloneDeepOptions(options);
-    this.runtimePkgs = [
-      "@module-federation/runtime",
-      "@module-federation/enhanced/runtime",
-      "@module-federation/runtime-tools"
-    ];
-    this.loadedRemoteAPIAlias = /* @__PURE__ */ new Set();
-    this.remoteAliasMap = {};
-    this.extraOptions = (options == null ? void 0 : options.extraOptions) || {};
-    this.updatedRemoteInfos = {};
-  }
-  generateAPITypes(mapComponentsToExpose) {
-    const exposePaths = /* @__PURE__ */ new Set();
-    const packageType = Object.keys(mapComponentsToExpose).reduce((sum, exposeKey) => {
-      const exposePath = path2.join(REMOTE_ALIAS_IDENTIFIER, exposeKey).split(path2.sep).join("/");
-      exposePaths.add(`'${exposePath}'`);
-      const curType = `T extends '${exposePath}' ? typeof import('${exposePath}') :`;
-      sum = curType + sum;
-      return sum;
-    }, "any;");
-    const exposePathKeys = [
-      ...exposePaths
-    ].join(" | ");
-    return `
-    export type RemoteKeys = ${exposePathKeys};
-    type PackageType<T> = ${packageType}`;
-  }
-  extractRemoteTypes(options) {
-    return __async(this, null, function* () {
-      var _a2;
-      const { remoteOptions, tsConfig } = options;
-      if (!remoteOptions.extractRemoteTypes) {
-        return;
-      }
-      let hasRemotes = false;
-      const remotes = remoteOptions.moduleFederationConfig.remotes;
-      if (remotes) {
-        if (Array.isArray(remotes)) {
-          hasRemotes = Boolean(remotes.length);
-        } else if (typeof remotes === "object") {
-          hasRemotes = Boolean(Object.keys(remotes).length);
-        }
-      }
-      const mfTypesPath = retrieveMfTypesPath(tsConfig, remoteOptions);
-      if (hasRemotes && this.options.host) {
-        try {
-          const { hostOptions } = retrieveHostConfig(this.options.host);
-          const remoteTypesFolder = path2.resolve(hostOptions.context, hostOptions.typesFolder);
-          const targetDir = path2.join(mfTypesPath, "node_modules");
-          if (fs2.existsSync(remoteTypesFolder)) {
-            const targetFolder = path2.resolve(remoteOptions.context, targetDir);
-            yield fse.ensureDir(targetFolder);
-            yield fse.copy(remoteTypesFolder, targetFolder, {
-              overwrite: true
-            });
-          }
-        } catch (err) {
-          if (((_a2 = this.options.host) == null ? void 0 : _a2.abortOnError) === false) {
-            fileLog(`Unable to copy remote types, ${err}`, "extractRemoteTypes", "error");
-          } else {
-            throw err;
-          }
-        }
-      }
-    });
-  }
-  // it must execute after consumeTypes
-  generateTypes() {
-    return __async(this, null, function* () {
-      var _a2, _b;
-      try {
-        const { options } = this;
-        if (!options.remote) {
-          throw new Error("options.remote is required if you want to generateTypes");
-        }
-        const { remoteOptions, tsConfig, mapComponentsToExpose } = retrieveRemoteConfig(options.remote);
-        if (!Object.keys(mapComponentsToExpose).length) {
-          return;
-        }
-        if (!((_a2 = tsConfig.files) == null ? void 0 : _a2.length)) {
-          logger.info("No type files to compile, skip");
-          return;
-        }
-        if (tsConfig.compilerOptions.tsBuildInfoFile) {
-          try {
-            const tsBuildInfoFile = path2.resolve(remoteOptions.context, tsConfig.compilerOptions.tsBuildInfoFile);
-            const mfTypesPath = retrieveMfTypesPath(tsConfig, remoteOptions);
-            if (!fs2.existsSync(mfTypesPath)) {
-              fs2.rmSync(tsBuildInfoFile, {
-                force: true
-              });
-            }
-          } catch (e) {
-          }
-        }
-        yield this.extractRemoteTypes({
-          remoteOptions,
-          tsConfig,
-          mapComponentsToExpose
-        });
-        yield compileTs(mapComponentsToExpose, tsConfig, remoteOptions);
-        yield createTypesArchive(tsConfig, remoteOptions);
-        let apiTypesPath = "";
-        if (remoteOptions.generateAPITypes) {
-          const apiTypes = this.generateAPITypes(mapComponentsToExpose);
-          apiTypesPath = retrieveMfAPITypesPath(tsConfig, remoteOptions);
-          fs2.writeFileSync(apiTypesPath, apiTypes);
-        }
-        try {
-          if (remoteOptions.deleteTypesFolder) {
-            yield rm2(retrieveMfTypesPath(tsConfig, remoteOptions), {
-              recursive: true,
-              force: true
-            });
-          }
-        } catch (err) {
-          if (isDebugMode()) {
-            console.error(err);
-          }
-        }
-        logger.success("Federated types created correctly");
-      } catch (error) {
-        if (((_b = this.options.remote) == null ? void 0 : _b.abortOnError) === false) {
-          if (this.options.displayErrorInTerminal) {
-            logger.error(error);
-          }
-        } else {
-          throw error;
-        }
-      }
-    });
-  }
-  requestRemoteManifest(remoteInfo, hostOptions) {
-    return __async(this, null, function* () {
-      try {
-        if (!remoteInfo.url.includes(MANIFEST_EXT)) {
-          return remoteInfo;
-        }
-        if (remoteInfo.zipUrl) {
-          return remoteInfo;
-        }
-        const url = remoteInfo.url;
-        const res = yield axiosGet(url, {
-          timeout: hostOptions.timeout,
-          family: hostOptions.family
-        });
-        const manifestJson = res.data;
-        if (!manifestJson.metaData.types.zip) {
-          throw new Error(`Can not get ${remoteInfo.name}'s types archive url!`);
-        }
-        const addProtocol = /* @__PURE__ */ __name((u) => {
-          if (u.startsWith("//")) {
-            return `https:${u}`;
-          }
-          return u;
-        }, "addProtocol");
-        let publicPath;
-        if ("publicPath" in manifestJson.metaData) {
-          publicPath = manifestJson.metaData.publicPath;
-        } else {
-          const getPublicPath = new Function(manifestJson.metaData.getPublicPath);
-          if (manifestJson.metaData.getPublicPath.startsWith("function")) {
-            publicPath = getPublicPath()();
-          } else {
-            publicPath = getPublicPath();
-          }
-        }
-        if (publicPath === "auto") {
-          publicPath = inferAutoPublicPath(remoteInfo.url);
-        }
-        remoteInfo.zipUrl = new URL(path2.join(addProtocol(publicPath), manifestJson.metaData.types.zip)).href;
-        if (!manifestJson.metaData.types.api) {
-          console.warn(`Can not get ${remoteInfo.name}'s api types url!`);
-          remoteInfo.apiTypeUrl = "";
-          return remoteInfo;
-        }
-        remoteInfo.apiTypeUrl = new URL(path2.join(addProtocol(publicPath), manifestJson.metaData.types.api)).href;
-        return remoteInfo;
-      } catch (_err) {
-        fileLog(`fetch manifest failed, ${_err}, ${remoteInfo.name} will be ignored`, "requestRemoteManifest", "error");
-        return remoteInfo;
-      }
-    });
-  }
-  consumeTargetRemotes(hostOptions, remoteInfo) {
-    return __async(this, null, function* () {
-      if (!remoteInfo.zipUrl) {
-        throw new Error(`Can not get ${remoteInfo.name}'s types archive url!`);
-      }
-      const typesDownloader = downloadTypesArchive(hostOptions);
-      return typesDownloader([
-        remoteInfo.alias,
-        remoteInfo.zipUrl
-      ]);
-    });
-  }
-  downloadAPITypes(remoteInfo, destinationPath, hostOptions) {
-    return __async(this, null, function* () {
-      const { apiTypeUrl } = remoteInfo;
-      if (!apiTypeUrl) {
-        return;
-      }
-      try {
-        const url = apiTypeUrl;
-        const res = yield axiosGet(url, {
-          timeout: hostOptions.timeout,
-          family: hostOptions.family
-        });
-        let apiTypeFile = res.data;
-        apiTypeFile = apiTypeFile.replaceAll(REMOTE_ALIAS_IDENTIFIER, remoteInfo.alias);
-        const filePath = path2.join(destinationPath, REMOTE_API_TYPES_FILE_NAME);
-        fs2.writeFileSync(filePath, apiTypeFile);
-        const existed = this.loadedRemoteAPIAlias.has(remoteInfo.alias);
-        this.loadedRemoteAPIAlias.add(remoteInfo.alias);
-        fileLog(`success`, "downloadAPITypes", "info");
-        return existed;
-      } catch (err) {
-        fileLog(`Unable to download "${remoteInfo.name}" api types, ${err}`, "downloadAPITypes", "error");
-      }
-    });
-  }
-  consumeAPITypes(hostOptions) {
-    const apiTypeFileName = path2.join(hostOptions.context, hostOptions.typesFolder, HOST_API_TYPES_FILE_NAME);
-    try {
-      const existedFile = fs2.readFileSync(apiTypeFileName, "utf-8");
-      const existedImports = new ThirdPartyExtractor2({
-        destDir: ""
-      }).collectTypeImports(existedFile);
-      existedImports.forEach((existedImport) => {
-        const alias = existedImport.split("./").slice(1).join("./").replace("/apis.d.ts", "");
-        this.loadedRemoteAPIAlias.add(alias);
-      });
-    } catch (err) {
-    }
-    if (!this.loadedRemoteAPIAlias.size) {
-      return;
-    }
-    const packageTypes = [];
-    const remoteKeys = [];
-    const importTypeStr = [
-      ...this.loadedRemoteAPIAlias
-    ].sort().map((alias, index) => {
-      const remoteKey = `RemoteKeys_${index}`;
-      const packageType = `PackageType_${index}`;
-      packageTypes.push(`T extends ${remoteKey} ? ${packageType}<T>`);
-      remoteKeys.push(remoteKey);
-      return `import type { PackageType as ${packageType},RemoteKeys as ${remoteKey} } from './${alias}/apis.d.ts';`;
-    }).join("\n");
-    const remoteKeysStr = `type RemoteKeys = ${remoteKeys.join(" | ")};`;
-    const packageTypesStr = `type PackageType<T, Y=any> = ${[
-      ...packageTypes,
-      "Y"
-    ].join(" :\n")} ;`;
-    const runtimePkgs = /* @__PURE__ */ new Set();
-    [
-      ...this.runtimePkgs,
-      ...hostOptions.runtimePkgs
-    ].forEach((pkg) => {
-      runtimePkgs.add(pkg);
-    });
-    const pkgsDeclareStr = [
-      ...runtimePkgs
-    ].map((pkg) => {
-      return `declare module "${pkg}" {
-      ${remoteKeysStr}
-      ${packageTypesStr}
-      export function loadRemote<T extends RemoteKeys,Y>(packageName: T): Promise<PackageType<T, Y>>;
-      export function loadRemote<T extends string,Y>(packageName: T): Promise<PackageType<T, Y>>;
-    }`;
-    }).join("\n");
-    const fileStr = `${importTypeStr}
-    ${pkgsDeclareStr}
-    `;
-    fs2.writeFileSync(path2.join(hostOptions.context, hostOptions.typesFolder, HOST_API_TYPES_FILE_NAME), fileStr);
-  }
-  consumeArchiveTypes(options) {
-    return __async(this, null, function* () {
-      const { hostOptions, mapRemotesToDownload } = retrieveHostConfig(options);
-      const downloadPromises = Object.entries(mapRemotesToDownload).map((item) => __async(this, null, function* () {
-        const remoteInfo = item[1];
-        if (!this.remoteAliasMap[remoteInfo.alias]) {
-          const requiredRemoteInfo = yield this.requestRemoteManifest(remoteInfo, hostOptions);
-          this.remoteAliasMap[remoteInfo.alias] = requiredRemoteInfo;
-        }
-        return this.consumeTargetRemotes(hostOptions, this.remoteAliasMap[remoteInfo.alias]);
-      }));
-      const downloadPromisesResult = yield Promise.allSettled(downloadPromises);
-      return {
-        hostOptions,
-        downloadPromisesResult
-      };
-    });
-  }
-  consumeTypes() {
-    return __async(this, null, function* () {
-      var _a2;
-      try {
-        const { options } = this;
-        if (!options.host) {
-          throw new Error("options.host is required if you want to consumeTypes");
-        }
-        const { mapRemotesToDownload } = retrieveHostConfig(options.host);
-        if (!Object.keys(mapRemotesToDownload).length) {
-          return;
-        }
-        const { downloadPromisesResult, hostOptions } = yield this.consumeArchiveTypes(options.host);
-        if (hostOptions.consumeAPITypes) {
-          yield Promise.all(downloadPromisesResult.map((item) => __async(this, null, function* () {
-            if (item.status === "rejected" || !item.value) {
-              return;
-            }
-            const [alias, destinationPath] = item.value;
-            const remoteInfo = this.remoteAliasMap[alias];
-            if (!remoteInfo) {
-              return;
-            }
-            yield this.downloadAPITypes(remoteInfo, destinationPath, hostOptions);
-          })));
-          this.consumeAPITypes(hostOptions);
-        }
-        logger.success("Federated types extraction completed");
-      } catch (err) {
-        if (((_a2 = this.options.host) == null ? void 0 : _a2.abortOnError) === false) {
-          fileLog(`Unable to consume federated types, ${err}`, "consumeTypes", "error");
-        } else {
-          throw err;
-        }
-      }
-    });
-  }
-  updateTypes(options) {
-    return __async(this, null, function* () {
-      var _a2, _b, _c;
-      try {
-        const { remoteName, updateMode, remoteTarPath, remoteInfo: updatedRemoteInfo, once } = options;
-        const hostName = (_c = (_b = (_a2 = this.options) == null ? void 0 : _a2.host) == null ? void 0 : _b.moduleFederationConfig) == null ? void 0 : _c.name;
-        fileLog(`options: ${JSON.stringify(options, null, 2)};
-hostName: ${hostName}`, "updateTypes", "info");
-        if (updateMode === UpdateMode.POSITIVE && remoteName === hostName) {
-          if (!this.options.remote) {
-            return;
-          }
-          yield this.generateTypes();
-        } else {
-          const { remoteAliasMap } = this;
-          if (!this.options.host) {
-            return;
-          }
-          const { hostOptions, mapRemotesToDownload } = retrieveHostConfig(this.options.host);
-          const loadedRemoteInfo = Object.values(remoteAliasMap).find((i) => i.name === remoteName);
-          const consumeTypes = /* @__PURE__ */ __name((requiredRemoteInfo) => __async(this, null, function* () {
-            fileLog(`consumeTypes start`, "updateTypes", "info");
-            if (!requiredRemoteInfo.zipUrl) {
-              throw new Error(`Can not get ${requiredRemoteInfo.name}'s types archive url!`);
-            }
-            const [_alias, destinationPath] = yield this.consumeTargetRemotes(hostOptions, __spreadProps(__spreadValues({}, requiredRemoteInfo), {
-              // use remoteTarPath first
-              zipUrl: remoteTarPath || requiredRemoteInfo.zipUrl
-            }));
-            const addNew = yield this.downloadAPITypes(requiredRemoteInfo, destinationPath, hostOptions);
-            if (addNew) {
-              this.consumeAPITypes(hostOptions);
-            }
-            fileLog(`consumeTypes end`, "updateTypes", "info");
-          }), "consumeTypes");
-          fileLog(`loadedRemoteInfo: ${JSON.stringify(loadedRemoteInfo, null, 2)}`, "updateTypes", "info");
-          if (!loadedRemoteInfo) {
-            const remoteInfo = Object.values(mapRemotesToDownload).find((item) => {
-              return item.name === remoteName;
-            });
-            fileLog(`remoteInfo: ${JSON.stringify(remoteInfo, null, 2)}`, "updateTypes", "info");
-            if (remoteInfo) {
-              if (!this.remoteAliasMap[remoteInfo.alias]) {
-                const requiredRemoteInfo = yield this.requestRemoteManifest(remoteInfo, hostOptions);
-                this.remoteAliasMap[remoteInfo.alias] = requiredRemoteInfo;
-              }
-              yield consumeTypes(this.remoteAliasMap[remoteInfo.alias]);
-            } else if (updatedRemoteInfo) {
-              const consumeDynamicRemoteTypes = /* @__PURE__ */ __name(() => __async(this, null, function* () {
-                yield consumeTypes(this.updatedRemoteInfos[updatedRemoteInfo.name]);
-              }), "consumeDynamicRemoteTypes");
-              if (!this.updatedRemoteInfos[updatedRemoteInfo.name]) {
-                const parsedRemoteInfo = retrieveRemoteInfo({
-                  hostOptions,
-                  remoteAlias: updatedRemoteInfo.alias || updatedRemoteInfo.name,
-                  remote: updatedRemoteInfo.url
-                });
-                fileLog(`start request manifest`, "consumeTypes", "info");
-                this.updatedRemoteInfos[updatedRemoteInfo.name] = yield this.requestRemoteManifest(parsedRemoteInfo, hostOptions);
-                fileLog(`end request manifest, this.updatedRemoteInfos[updatedRemoteInfo.name]: ${JSON.stringify(this.updatedRemoteInfos[updatedRemoteInfo.name], null, 2)}`, "updateTypes", "info");
-                yield consumeDynamicRemoteTypes();
-              }
-              if (!once && this.updatedRemoteInfos[updatedRemoteInfo.name]) {
-                yield consumeDynamicRemoteTypes();
-              }
-            }
-          } else {
-            yield consumeTypes(loadedRemoteInfo);
-          }
-        }
-      } catch (err) {
-        fileLog(`updateTypes fail, ${err}`, "updateTypes", "error");
-      }
-    });
-  }
-}, __name(_a, "DTSManager"), _a);
-
-// src/core/lib/utils.ts
-import cloneDeepWith from "lodash.clonedeepwith";
-function getDTSManagerConstructor(implementation) {
-  if (implementation) {
-    const NewConstructor = __require(implementation);
-    return NewConstructor.default ? NewConstructor.default : NewConstructor;
-  }
-  return DTSManager;
-}
-__name(getDTSManagerConstructor, "getDTSManagerConstructor");
-var validateOptions = /* @__PURE__ */ __name((options) => {
-  if (!options.moduleFederationConfig) {
-    throw new Error("moduleFederationConfig is required");
-  }
-}, "validateOptions");
-function retrieveTypesAssetsInfo(options) {
-  let apiTypesPath = "";
-  let zipTypesPath = "";
-  try {
-    const { tsConfig, remoteOptions, mapComponentsToExpose } = retrieveRemoteConfig(options);
-    if (!Object.keys(mapComponentsToExpose).length || !tsConfig.files.length) {
-      return {
-        apiTypesPath,
-        zipTypesPath,
-        zipName: "",
-        apiFileName: ""
-      };
-    }
-    const mfTypesPath = retrieveMfTypesPath(tsConfig, remoteOptions);
-    zipTypesPath = retrieveTypesZipPath(mfTypesPath, remoteOptions);
-    if (remoteOptions.generateAPITypes) {
-      apiTypesPath = retrieveMfAPITypesPath(tsConfig, remoteOptions);
-    }
-    return {
-      apiTypesPath,
-      zipTypesPath,
-      zipName: path3.basename(zipTypesPath),
-      apiFileName: path3.basename(apiTypesPath)
-    };
-  } catch (err) {
-    console.error(ansiColors.red(`Unable to compile federated types, ${err}`));
-    return {
-      apiTypesPath: "",
-      zipTypesPath: "",
-      zipName: "",
-      apiFileName: ""
-    };
-  }
-}
-__name(retrieveTypesAssetsInfo, "retrieveTypesAssetsInfo");
-function isDebugMode() {
-  return Boolean(process.env["FEDERATION_DEBUG"]) || process.env["NODE_ENV"] === "test";
-}
-__name(isDebugMode, "isDebugMode");
-var isTSProject = /* @__PURE__ */ __name((dtsOptions, context = process.cwd()) => {
-  if (dtsOptions === false) {
-    return false;
-  }
-  try {
-    let filepath = "";
-    if (typeof dtsOptions === "object" && dtsOptions.tsConfigPath) {
-      filepath = dtsOptions.tsConfigPath;
-    } else {
-      filepath = path3.resolve(context, "./tsconfig.json");
-    }
-    if (!path3.isAbsolute(filepath)) {
-      filepath = path3.resolve(context, filepath);
-    }
-    return fs3.existsSync(filepath);
-  } catch (err) {
-    return false;
-  }
-}, "isTSProject");
-function cloneDeepOptions(options) {
-  const excludeKeys = [
-    "manifest",
-    "async"
-  ];
-  return cloneDeepWith(options, (value, key) => {
-    if (typeof key === "string" && excludeKeys.includes(key)) {
-      return false;
-    }
-    if (typeof value === "function") {
-      return false;
-    }
-    if (key === "extractThirdParty" && Array.isArray(value)) {
-      return value.map((item) => {
-        return item.toString();
-      });
-    }
-  });
-}
-__name(cloneDeepOptions, "cloneDeepOptions");
-var getEnvHeaders = /* @__PURE__ */ __name(() => {
-  const headersStr = getProcessEnv()["MF_ENV_HEADERS"] || "{}";
-  return __spreadValues({}, JSON.parse(headersStr));
-}, "getEnvHeaders");
-function axiosGet(url, config) {
-  return __async(this, null, function* () {
-    var _a2, _b;
-    const httpAgent = new http.Agent({
-      family: (_a2 = config == null ? void 0 : config.family) != null ? _a2 : 4
-    });
-    const httpsAgent = new https.Agent({
-      family: (_b = config == null ? void 0 : config.family) != null ? _b : 4
-    });
-    return axios.get(url, __spreadProps(__spreadValues(__spreadValues({
-      httpAgent,
-      httpsAgent
-    }, {
-      headers: getEnvHeaders()
-    }), config), {
-      timeout: (config == null ? void 0 : config.timeout) || 6e4
-    }));
-  });
-}
-__name(axiosGet, "axiosGet");
-
-// src/core/lib/archiveHandler.ts
-var retrieveTypesZipPath = /* @__PURE__ */ __name((mfTypesPath, remoteOptions) => join3(mfTypesPath.replace(remoteOptions.typesFolder, ""), `${remoteOptions.typesFolder}.zip`), "retrieveTypesZipPath");
-var createTypesArchive = /* @__PURE__ */ __name((tsConfig, remoteOptions) => __async(void 0, null, function* () {
-  const mfTypesPath = retrieveMfTypesPath(tsConfig, remoteOptions);
-  const zip = new AdmZip();
-  zip.addLocalFolder(mfTypesPath);
-  return zip.writeZipPromise(retrieveTypesZipPath(mfTypesPath, remoteOptions));
-}), "createTypesArchive");
-var downloadErrorLogger = /* @__PURE__ */ __name((destinationFolder, fileToDownload) => (reason) => {
-  throw __spreadProps(__spreadValues({}, reason), {
-    message: `Network error: Unable to download federated mocks for '${destinationFolder}' from '${fileToDownload}' because '${reason.message}'`
-  });
-}, "downloadErrorLogger");
-var retrieveTypesArchiveDestinationPath = /* @__PURE__ */ __name((hostOptions, destinationFolder) => {
-  return resolve3(hostOptions.context, hostOptions.typesFolder, destinationFolder);
-}, "retrieveTypesArchiveDestinationPath");
-var downloadTypesArchive = /* @__PURE__ */ __name((hostOptions) => {
-  let retries = 0;
-  return (_0) => __async(void 0, [_0], function* ([destinationFolder, fileToDownload]) {
-    var _a2;
-    const destinationPath = retrieveTypesArchiveDestinationPath(hostOptions, destinationFolder);
-    while (retries++ < hostOptions.maxRetries) {
-      try {
-        const url = new URL(fileToDownload).href;
-        const response = yield axiosGet(url, {
-          responseType: "arraybuffer",
-          timeout: hostOptions.timeout,
-          family: hostOptions.family
-        }).catch(downloadErrorLogger(destinationFolder, url));
-        if (typeof ((_a2 = response.headers) == null ? void 0 : _a2["content-type"]) === "string" && response.headers["content-type"].includes("text/html")) {
-          throw new Error(`${url} receives invalid content-type: ${response.headers["content-type"]}`);
-        }
-        try {
-          if (hostOptions.deleteTypesFolder) {
-            yield rm3(destinationPath, {
-              recursive: true,
-              force: true
-            });
-          }
-        } catch (error) {
-          fileLog(`Unable to remove types folder, ${error}`, "downloadTypesArchive", "error");
-        }
-        const zip = new AdmZip(Buffer.from(response.data));
-        zip.extractAllTo(destinationPath, true);
-        fileLog(`zip.extractAllTo success destinationPath: ${destinationPath}; url: ${url}`, "downloadTypesArchive", "info");
-        return [
-          destinationFolder,
-          destinationPath
-        ];
-      } catch (error) {
-        fileLog(`Error during types archive download: ${(error == null ? void 0 : error.message) || "unknown error"}`, "downloadTypesArchive", "error");
-        if (retries >= hostOptions.maxRetries) {
-          logger.error(`Failed to download types archive from "${fileToDownload}". Set FEDERATION_DEBUG=true for details.`);
-          if (hostOptions.abortOnError !== false) {
-            throw error;
-          }
-          return void 0;
-        }
-      }
-    }
-  });
-}, "downloadTypesArchive");
-
-// src/core/lib/generateTypes.ts
-function generateTypes(options) {
-  return __async(this, null, function* () {
-    var _a2;
-    const DTSManagerConstructor = getDTSManagerConstructor((_a2 = options.remote) == null ? void 0 : _a2.implementation);
-    const dtsManager = new DTSManagerConstructor(options);
-    return dtsManager.generateTypes();
-  });
-}
-__name(generateTypes, "generateTypes");
-
-// src/core/rpc/types.ts
-var RpcGMCallTypes;
-(function(RpcGMCallTypes2) {
-  RpcGMCallTypes2["CALL"] = "mf_call";
-  RpcGMCallTypes2["RESOLVE"] = "mf_resolve";
-  RpcGMCallTypes2["REJECT"] = "mf_reject";
-  RpcGMCallTypes2["EXIT"] = "mf_exit";
-})(RpcGMCallTypes || (RpcGMCallTypes = {}));
-
-// src/core/rpc/expose-rpc.ts
-import process2 from "process";
-function exposeRpc(fn) {
-  const sendMessage = /* @__PURE__ */ __name((message) => new Promise((resolve4, reject) => {
-    if (!process2.send) {
-      reject(new Error(`Process ${process2.pid} doesn't have IPC channels`));
-    } else if (!process2.connected) {
-      reject(new Error(`Process ${process2.pid} doesn't have open IPC channels`));
-    } else {
-      process2.send(message, void 0, void 0, (error) => {
-        if (error) {
-          reject(error);
-        } else {
-          resolve4(void 0);
-        }
-      });
-    }
-  }), "sendMessage");
-  const handleMessage = /* @__PURE__ */ __name((message) => __async(this, null, function* () {
-    if (message.type === RpcGMCallTypes.CALL) {
-      if (!process2.send) {
-        return;
-      }
-      let value, error;
-      try {
-        value = yield fn(...message.args);
-      } catch (fnError) {
-        error = fnError;
-      }
-      try {
-        if (error) {
-          yield sendMessage({
-            type: RpcGMCallTypes.REJECT,
-            id: message.id,
-            error
-          });
-        } else {
-          yield sendMessage({
-            type: RpcGMCallTypes.RESOLVE,
-            id: message.id,
-            value
-          });
-        }
-      } catch (sendError) {
-        if (error) {
-          if (error instanceof Error) {
-            console.error(error);
-          }
-        }
-        console.error(sendError);
-      }
-    }
-  }), "handleMessage");
-  process2.on("message", handleMessage);
-}
-__name(exposeRpc, "exposeRpc");
-
-export {
-  ModuleFederationDevServer,
-  createKoaServer,
-  retrieveMfTypesPath,
-  retrieveOriginalOutDir,
-  retrieveTypesZipPath,
-  retrieveHostConfig,
-  REMOTE_ALIAS_IDENTIFIER,
-  REMOTE_API_TYPES_FILE_NAME,
-  HOST_API_TYPES_FILE_NAME,
-  DTSManager,
-  getDTSManagerConstructor,
-  validateOptions,
-  retrieveTypesAssetsInfo,
-  isDebugMode,
-  isTSProject,
-  cloneDeepOptions,
-  retrieveRemoteConfig,
-  generateTypes,
-  RpcGMCallTypes,
-  exposeRpc
-};