@module-federation/devtools 0.0.0-next-20240425091022

package/dist/lib/utils/chrome/storage.js

@@ -0,0 +1,67 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var storage_exports = {};
+__export(storage_exports, {
+  mergeStorage: () => mergeStorage,
+  removeStorage: () => removeStorage,
+  removeStorageKey: () => removeStorageKey,
+  setStorage: () => setStorage
+});
+module.exports = __toCommonJS(storage_exports);
+var import_sdk = require("../sdk");
+var import_index = require("./index");
+const mergeStorage = (...args) => __async(void 0, null, function* () {
+  return (0, import_index.injectScript)(import_sdk.mergeLocalStorage, false, ...args);
+});
+const removeStorageKey = (...args) => __async(void 0, null, function* () {
+  return (0, import_index.injectScript)(import_sdk.removeLocalStorageKey, false, ...args);
+});
+const removeStorage = (...args) => __async(void 0, null, function* () {
+  return (0, import_index.injectScript)(import_sdk.removeLocalStorage, false, ...args);
+});
+const setStorage = (...args) => __async(void 0, null, function* () {
+  return (0, import_index.injectScript)(import_sdk.setLocalStorage, false, ...args);
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mergeStorage,
+  removeStorage,
+  removeStorageKey,
+  setStorage
+});

package/dist/lib/utils/data/index.js

@@ -0,0 +1,106 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var data_exports = {};
+__export(data_exports, {
+  getModuleInfo: () => getModuleInfo,
+  separateType: () => separateType
+});
+module.exports = __toCommonJS(data_exports);
+var import_snapshot = require("./snapshot");
+__reExport(data_exports, require("./snapshot"), module.exports);
+const separateType = (moduleInfo) => {
+  const consumers = {};
+  const producer = [];
+  Object.keys(moduleInfo).forEach((key) => {
+    var _a;
+    const remotesInfo = (_a = moduleInfo[key]) == null ? void 0 : _a.remotesInfo;
+    if (remotesInfo) {
+      const moduleIds = Object.keys(remotesInfo);
+      if (moduleIds.length) {
+        moduleIds.forEach((id) => {
+          let formatId = id;
+          if (id.includes(":")) {
+            formatId = id.split(":").pop();
+          }
+          const hasBeenAdded = producer.includes(formatId);
+          if (!hasBeenAdded) {
+            producer.push(id);
+          }
+        });
+        consumers[key] = moduleInfo[key];
+      }
+    }
+  });
+  return {
+    consumers,
+    producer
+  };
+};
+const getModuleInfo = (proxyRules) => __async(void 0, null, function* () {
+  let freshModuleInfo;
+  const { moduleInfo } = window.__FEDERATION__;
+  const { consumers } = separateType(moduleInfo);
+  const overrides = {};
+  const isMicroMode = Object.keys(consumers).some((moduleId) => {
+    const subApps = consumers[moduleId].consumerList;
+    return Array.isArray(subApps) && subApps.length;
+  });
+  proxyRules.forEach((rule) => {
+    const { key, value } = rule;
+    overrides[key] = value;
+  });
+  if (isMicroMode) {
+    freshModuleInfo = (0, import_snapshot.calculateMicroAppSnapshot)(moduleInfo, overrides);
+  } else {
+    freshModuleInfo = (0, import_snapshot.calculateSnapshot)(moduleInfo, overrides);
+  }
+  console.debug("New Snapshot: ", freshModuleInfo);
+  return {
+    status: "success",
+    moduleInfo: freshModuleInfo,
+    overrides
+  };
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getModuleInfo,
+  separateType,
+  ...require("./snapshot")
+});

package/dist/lib/utils/data/snapshot.js

@@ -0,0 +1,107 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var snapshot_exports = {};
+__export(snapshot_exports, {
+  calculateMicroAppSnapshot: () => calculateMicroAppSnapshot,
+  calculateSnapshot: () => calculateSnapshot
+});
+module.exports = __toCommonJS(snapshot_exports);
+const calculateSnapshot = (originSnapshot, overrides) => {
+  const overridesWithoutType = Object.keys(overrides).reduce(
+    (memo, current) => {
+      if (current.includes(":")) {
+        const [, moduleId] = current.split(":");
+        memo[moduleId] = overrides[current];
+      }
+      return memo;
+    },
+    {}
+  );
+  const newSnapshot = JSON.parse(JSON.stringify(originSnapshot));
+  const moduleIds = Object.keys(originSnapshot);
+  moduleIds.forEach((moduleId) => {
+    const module2 = originSnapshot[moduleId];
+    if ("remotesInfo" in module2) {
+      const remoteIds = Object.keys(module2.remotesInfo);
+      remoteIds.forEach((id) => {
+        const [, splitId] = id.split(":");
+        const entry = overrides[id] || overridesWithoutType[id] || overrides[splitId] || overridesWithoutType[splitId];
+        if (entry) {
+          newSnapshot[moduleId].remotesInfo[id].matchedVersion = entry;
+          const customEntryId = `${id}:${entry}`;
+          newSnapshot[customEntryId] = {
+            remoteEntry: entry,
+            version: entry
+          };
+        }
+      });
+    }
+  });
+  return newSnapshot;
+};
+const calculateMicroAppSnapshot = (originSnapshot, overrides) => {
+  let masterApp = null;
+  const newSnapshot = JSON.parse(JSON.stringify(originSnapshot));
+  const moduleIds = Object.keys(originSnapshot);
+  moduleIds.forEach((moduleId) => {
+    const module2 = newSnapshot[moduleId];
+    if ("consumerList" in module2 && Array.isArray(module2.consumerList) && module2.consumerList.length > 0) {
+      masterApp = module2;
+    }
+  });
+  if (!masterApp) {
+    return newSnapshot;
+  }
+  const microApps = masterApp.consumerList;
+  const microAppsCount = microApps.length;
+  for (let i = 0; i < microAppsCount; i++) {
+    let overrideTarget = "";
+    const microApp = microApps[i];
+    const idWithVersion = Object.keys(overrides).find((id) => {
+      let target = id;
+      if (id.includes(":")) {
+        const [, name] = id.split(":");
+        target = name;
+      }
+      if (microApp.includes(target)) {
+        overrideTarget = id;
+        return true;
+      }
+      return false;
+    });
+    if (idWithVersion) {
+      const entry = overrides[overrideTarget];
+      const idArray = microApp.split(":");
+      idArray[idArray.length - 1] = entry;
+      microApps[i] = idArray.join(":");
+      const customEntryId = `${overrideTarget}:${entry}`;
+      newSnapshot[customEntryId] = {
+        remoteEntry: entry,
+        version: entry
+      };
+    }
+  }
+  const snapshot = calculateSnapshot(newSnapshot, overrides);
+  return snapshot;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  calculateMicroAppSnapshot,
+  calculateSnapshot
+});

package/dist/lib/utils/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+module.exports = __toCommonJS(utils_exports);
+__reExport(utils_exports, require("./chrome"), module.exports);
+__reExport(utils_exports, require("./sdk"), module.exports);
+__reExport(utils_exports, require("./data"), module.exports);
+__reExport(utils_exports, require("./types"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./chrome"),
+  ...require("./sdk"),
+  ...require("./data"),
+  ...require("./types")
+});

package/dist/lib/utils/sdk/graph.js

@@ -0,0 +1,171 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var graph_exports = {};
+__export(graph_exports, {
+  DependencyGraph: () => DependencyGraph,
+  validateSemver: () => validateSemver
+});
+module.exports = __toCommonJS(graph_exports);
+var import_reactflow = require("reactflow");
+const validateSemver = (schema) => {
+  const reg = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(\.(0|[1-9]\d*))?(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/gm;
+  return reg.test(schema);
+};
+const splitModuleId = (target) => {
+  const array = target.split(":");
+  const { length } = array;
+  if (length === 1) {
+    return target;
+  } else if (length >= 3) {
+    if (array[length - 1].endsWith(".json") || array[length - 1].endsWith(".js")) {
+      const idx = array.findIndex((t) => t.startsWith("http"));
+      return array[idx - 1];
+    } else {
+      return array[1];
+    }
+  } else {
+    const nameOrVersion = array[length - 1];
+    if (nameOrVersion === "*" || nameOrVersion === "latest" || validateSemver(nameOrVersion)) {
+      return array[0];
+    } else {
+      return nameOrVersion;
+    }
+  }
+};
+class DependencyGraph {
+  constructor(snapshot, initTarget) {
+    this.snapshot = snapshot;
+    this.initTarget = initTarget;
+    this.node = [];
+    this.edge = [];
+    this.graph = {};
+    this.identifyMap = /* @__PURE__ */ new Map();
+    this.handledModuleMap = /* @__PURE__ */ new Map();
+  }
+  createGraph(target = this.initTarget) {
+    const { snapshot } = this;
+    let remotesInfo;
+    const snapshotWithoutType = snapshot[target];
+    const snapshotWithType = snapshot[target];
+    if (snapshotWithoutType && "remotesInfo" in snapshotWithoutType) {
+      remotesInfo = snapshotWithoutType == null ? void 0 : snapshotWithoutType.remotesInfo;
+    }
+    if (snapshotWithType && "remotesInfo" in snapshotWithType) {
+      remotesInfo = snapshotWithType == null ? void 0 : snapshotWithType.remotesInfo;
+    }
+    if (!remotesInfo) {
+      return;
+    }
+    Object.keys(remotesInfo).forEach((dep) => {
+      const { matchedVersion } = remotesInfo[dep];
+      let childId = dep;
+      if (matchedVersion && matchedVersion !== "") {
+        childId = `${childId}:${matchedVersion}`;
+      }
+      if (!this.graph[target]) {
+        this.graph[target] = {};
+      }
+      this.graph[childId] = {};
+      this.graph[target][childId] = this.graph[childId];
+      const handled = this.handledModuleMap.get(childId);
+      if (!handled) {
+        this.handledModuleMap.set(childId, true);
+        this.createGraph(childId);
+      }
+    });
+  }
+  addNode(id, type, x, y, nodeData) {
+    this.node.push({
+      id,
+      type,
+      position: {
+        x,
+        y
+      },
+      data: __spreadValues({}, nodeData)
+    });
+  }
+  addEdge(id, source, target, type = "default") {
+    this.edge.push({
+      id,
+      source,
+      target,
+      markerEnd: {
+        type: import_reactflow.MarkerType.Arrow,
+        width: 30,
+        height: 30
+      },
+      type
+    });
+  }
+  run(targetGraph, target = this.initTarget, type, id = this.initTarget) {
+    var _a;
+    if (!targetGraph || !((_a = Object.keys(targetGraph)) == null ? void 0 : _a.length)) {
+      return;
+    }
+    const name = splitModuleId(target);
+    const targetWithoutType = name;
+    let info = name;
+    const remote = this.snapshot[target];
+    if (remote && ("version" in remote || "remoteEntry" in remote)) {
+      info += `:${remote.version || remote.remoteEntry}`;
+    }
+    if (!this.identifyMap.has(targetWithoutType)) {
+      this.identifyMap.set(targetWithoutType, this.identify());
+    }
+    this.addNode(id, type, 0, 0, {
+      info,
+      remote,
+      color: this.identifyMap.get(targetWithoutType)
+    });
+    const graphChilden = Object.keys(
+      targetGraph[targetWithoutType] || targetGraph[target] || {}
+    );
+    graphChilden.forEach((dep) => {
+      this.addEdge(id + dep, id, id + dep);
+      this.run(targetGraph[targetWithoutType], dep, type, id + dep);
+    });
+  }
+  identify() {
+    const r = Math.floor(Math.random() * 255);
+    const g = Math.floor(Math.random() * 255);
+    const b = Math.floor(Math.random() * 255);
+    const color = `rgba(${r},${g},${b},0.8)`;
+    return color;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DependencyGraph,
+  validateSemver
+});

package/dist/lib/utils/sdk/index.js

@@ -0,0 +1,89 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sdk_exports = {};
+__export(sdk_exports, {
+  definePropertyGlobalVal: () => definePropertyGlobalVal,
+  getUnpkgUrl: () => getUnpkgUrl,
+  isObject: () => isObject,
+  mergeLocalStorage: () => mergeLocalStorage,
+  reloadPage: () => reloadPage,
+  removeLocalStorage: () => removeLocalStorage,
+  removeLocalStorageKey: () => removeLocalStorageKey,
+  setLocalStorage: () => setLocalStorage,
+  validateCustom: () => validateCustom
+});
+module.exports = __toCommonJS(sdk_exports);
+__reExport(sdk_exports, require("./graph"), module.exports);
+const setLocalStorage = (key, value) => {
+  localStorage.setItem(key, value);
+};
+const removeLocalStorage = (key) => {
+  const data = localStorage.getItem(key);
+  if (data) {
+    localStorage.removeItem(key);
+  }
+};
+const mergeLocalStorage = (target, key, value) => {
+  const str = localStorage.getItem(target);
+  const obj = JSON.parse(str || "{}");
+  obj[key] = value;
+  localStorage.setItem(target, JSON.stringify(obj));
+};
+const removeLocalStorageKey = (target, key) => {
+  const str = localStorage.getItem(target);
+  if (str) {
+    const obj = JSON.parse(str || "{}");
+    delete obj[key];
+    localStorage.setItem(target, JSON.stringify(obj));
+  }
+};
+const isObject = (target) => Object.prototype.toString.call(target) === "[object Object]";
+const reloadPage = () => {
+  var _a;
+  (_a = globalThis == null ? void 0 : globalThis.location) == null ? void 0 : _a.reload();
+};
+const validateCustom = (schema) => schema == null ? void 0 : schema.endsWith(".json");
+const getUnpkgUrl = (pkg, version) => {
+  if (pkg === "react") {
+    return `https://unpkg.com/react@${version}/umd/react.development.js`;
+  } else if (pkg === "react-dom") {
+    return `https://unpkg.com/react-dom@${version}/umd/react-dom.development.js`;
+  }
+};
+const definePropertyGlobalVal = (target, key, val) => {
+  Object.defineProperty(target, key, {
+    value: val,
+    configurable: false,
+    writable: true
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  definePropertyGlobalVal,
+  getUnpkgUrl,
+  isObject,
+  mergeLocalStorage,
+  reloadPage,
+  removeLocalStorage,
+  removeLocalStorageKey,
+  setLocalStorage,
+  validateCustom,
+  ...require("./graph")
+});

package/dist/lib/utils/types/common.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var common_exports = {};
+module.exports = __toCommonJS(common_exports);

package/dist/lib/utils/types/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);
+__reExport(types_exports, require("./common"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./common")
+});

package/dist/lib/worker/index.js

@@ -0,0 +1,2 @@
+"use strict";
+console.log("Module Federation Worker");

package/dist/types/src/App.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import './init';
+import { RootComponentProps } from './utils';
+import '@arco-design/web-react/dist/css/arco.css';
+declare const App: (props: RootComponentProps) => import("react").JSX.Element;
+export default App;

package/dist/types/src/component/Form/index.d.ts

@@ -0,0 +1,18 @@
+import { SetStateAction } from 'react';
+import { FormInstance } from '@arco-design/web-react';
+import { FormItemStatus, RootComponentProps } from '../../utils';
+interface FormProps {
+    form: FormInstance<any, any, string | number | symbol>;
+    condition: {
+        status: string;
+        message: string;
+        color: string;
+    };
+    formStatus: Array<FormItemStatus>;
+    setFormStatus: React.Dispatch<SetStateAction<FormItemStatus[]>>;
+    validateForm: any;
+    enableHMR: string;
+    onHMRChange: (on: boolean) => void;
+}
+declare const FormComponent: (props: FormProps & RootComponentProps) => import("react").JSX.Element;
+export default FormComponent;

package/dist/types/src/component/Graph/index.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { GlobalModuleInfo } from '@module-federation/sdk';
+import 'reactflow/dist/style.css';
+declare const Graph: (props: {
+    snapshot: GlobalModuleInfo;
+}) => import("react").JSX.Element;
+export default Graph;

package/dist/types/src/component/GraphItem/index.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import 'reactflow/dist/style.css';
+declare const GraphItem: (props: {
+    data: {
+        info?: string;
+        color?: string;
+        remote?: any;
+    };
+}) => import("react").JSX.Element;
+export default GraphItem;

package/dist/types/src/component/Layout/index.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { GlobalModuleInfo } from '@module-federation/sdk';
+import { RootComponentProps } from '../../utils';
+declare const Layout: (props: {
+    moduleInfo: GlobalModuleInfo;
+} & RootComponentProps) => import("react").JSX.Element;
+export default Layout;

package/dist/types/src/index.d.ts

@@ -0,0 +1 @@
+export {};