@module-federation/bridge-react 0.0.0-next-20241113115843 → 0.0.0-next-20241114041727

package/dist/context-CUbFnlO5.js

@@ -0,0 +1,355 @@
+import React__default from "react";
+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 browser_exports = {};
+__export(browser_exports, {
+  createLogger: () => createLogger2,
+  logger: () => logger
+});
+var browser = __toCommonJS(browser_exports);
+var supportsSubstitutions = void 0;
+var supportColor = () => {
+  if (typeof supportsSubstitutions !== "undefined") {
+    return supportsSubstitutions;
+  }
+  try {
+    const testString = "color test";
+    const css = "color: red;";
+    const originalConsoleLog = console.log;
+    console.log = (...args) => {
+      if (args[0] === `%c${testString}` && args[1] === css) {
+        supportsSubstitutions = true;
+      }
+    };
+    console.log(`%c${testString}`, css);
+    console.log = originalConsoleLog;
+  } catch (e) {
+    supportsSubstitutions = false;
+  }
+  return supportsSubstitutions;
+};
+var ansiToCss = {
+  "bold": "font-weight: bold;",
+  "red": "color: red;",
+  "green": "color: green;",
+  "orange": "color: orange;",
+  "dodgerblue": "color: dodgerblue;",
+  "magenta": "color: magenta;",
+  "gray": "color: gray;"
+};
+var formatter = (key) => supportColor() ? (input) => {
+  if (Array.isArray(input)) {
+    const [label, style] = input;
+    return [`%c${label.replace("%c", "")}`, style ? `${ansiToCss[key]}${style}` : `${ansiToCss[key] || ""}`];
+  }
+  return [`%c${String(input).replace("%c", "")}`, ansiToCss[key] || ""];
+} : (input) => [String(input)];
+var bold = formatter("bold");
+var red = formatter("red");
+var green = formatter("green");
+var orange = formatter("orange");
+var dodgerblue = formatter("dodgerblue");
+var magenta = formatter("magenta");
+formatter("gray");
+function getLabel(type, logType, labels) {
+  let label = [""];
+  if ("label" in logType) {
+    label = [labels[type] || logType.label || ""];
+    label = bold(logType.color ? logType.color(label) : label[0]);
+  }
+  label = label.filter(Boolean);
+  return label;
+}
+function finalLog(label, text, args, message) {
+  if (label.length) {
+    if (Array.isArray(message)) {
+      console.log(...label, ...message);
+    } else {
+      console.log(...label, text);
+    }
+  } else {
+    Array.isArray(message) ? console.log(...message) : console.log(text, ...args);
+  }
+}
+var LOG_LEVEL = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  log: 3,
+  verbose: 4
+};
+var errorStackRegExp = /at\s.*:\d+:\d+[\s\)]*$/;
+var anonymousErrorStackRegExp = /at\s.*\(<anonymous>\)$/;
+var isErrorStackMessage = (message) => errorStackRegExp.test(message) || anonymousErrorStackRegExp.test(message);
+var createLogger$1 = (options = {}, { getLabel: getLabel2, handleError, finalLog: finalLog2, greet, LOG_TYPES: LOG_TYPES2 }) => {
+  let maxLevel = options.level || "log";
+  let customLabels = options.labels || {};
+  let log = (type, message, ...args) => {
+    if (LOG_LEVEL[LOG_TYPES2[type].level] > LOG_LEVEL[maxLevel]) {
+      return;
+    }
+    if (message === void 0 || message === null) {
+      return console.log();
+    }
+    let logType = LOG_TYPES2[type];
+    let text = "";
+    const label = getLabel2(type, logType, customLabels);
+    if (message instanceof Error) {
+      if (message.stack) {
+        let [name, ...rest] = message.stack.split("\n");
+        if (name.startsWith("Error: ")) {
+          name = name.slice(7);
+        }
+        text = `${name}
+${handleError(rest.join("\n"))}`;
+      } else {
+        text = message.message;
+      }
+    } else if (logType.level === "error" && typeof message === "string") {
+      let lines = message.split("\n");
+      text = lines.map((line) => isErrorStackMessage(line) ? handleError(line) : line).join("\n");
+    } else {
+      text = `${message}`;
+    }
+    finalLog2(label, text, args, message);
+  };
+  let logger2 = {
+    // greet
+    greet: (message) => log("log", greet(message))
+  };
+  Object.keys(LOG_TYPES2).forEach((key) => {
+    logger2[key] = (...args) => log(key, ...args);
+  });
+  Object.defineProperty(logger2, "level", {
+    get: () => maxLevel,
+    set(val) {
+      maxLevel = val;
+    }
+  });
+  Object.defineProperty(logger2, "labels", {
+    get: () => customLabels,
+    set(val) {
+      customLabels = val;
+    }
+  });
+  logger2.override = (customLogger) => {
+    Object.assign(logger2, customLogger);
+  };
+  return logger2;
+};
+var startColor = [189, 255, 243];
+var endColor = [74, 194, 154];
+var isWord = (char) => !/[\s\n]/.test(char);
+function gradient(message) {
+  if (!supportColor()) {
+    return [message];
+  }
+  const chars = [...message];
+  const words = chars.filter(isWord);
+  const steps = words.length - 1;
+  if (steps === 0) {
+    console.log(`%c${message}`, `color: rgb(${startColor.join(",")}); font-weight: bold;`);
+    return [message];
+  }
+  let output = "";
+  let styles = [];
+  chars.forEach((char) => {
+    if (isWord(char)) {
+      const progress = words.indexOf(char) / steps;
+      const r = Math.round(startColor[0] + (endColor[0] - startColor[0]) * progress);
+      const g = Math.round(startColor[1] + (endColor[1] - startColor[1]) * progress);
+      const b = Math.round(startColor[2] + (endColor[2] - startColor[2]) * progress);
+      output += `%c${char}`;
+      styles.push(`color: rgb(${r},${g},${b}); font-weight: bold;`);
+    } else {
+      output += char;
+    }
+  });
+  return [output, ...styles];
+}
+var LOG_TYPES = {
+  // Level error
+  error: {
+    label: "error",
+    level: "error",
+    color: red
+  },
+  // Level warn
+  warn: {
+    label: "warn",
+    level: "warn",
+    color: orange
+  },
+  // Level info
+  info: {
+    label: "info",
+    level: "info",
+    color: dodgerblue
+  },
+  start: {
+    label: "start",
+    level: "info",
+    color: dodgerblue
+  },
+  ready: {
+    label: "ready",
+    level: "info",
+    color: green
+  },
+  success: {
+    label: "success",
+    level: "info",
+    color: green
+  },
+  // Level log
+  log: {
+    level: "log"
+  },
+  // Level debug
+  debug: {
+    label: "debug",
+    level: "verbose",
+    color: magenta
+  }
+};
+function createLogger2(options = {}) {
+  return createLogger$1(options, {
+    handleError: (msg) => msg,
+    getLabel,
+    gradient,
+    finalLog,
+    LOG_TYPES,
+    greet: (msg) => {
+      return gradient(msg);
+    }
+  });
+}
+var logger = createLogger2();
+const BROWSER_LOG_KEY = "FEDERATION_DEBUG";
+const BROWSER_LOG_VALUE = "1";
+function isBrowserEnv() {
+  return typeof window !== "undefined";
+}
+function isBrowserDebug() {
+  try {
+    if (isBrowserEnv() && window.localStorage) {
+      return localStorage.getItem(BROWSER_LOG_KEY) === BROWSER_LOG_VALUE;
+    }
+  } catch (error) {
+    return false;
+  }
+  return false;
+}
+function isDebugMode() {
+  if (typeof process !== "undefined" && process.env && process.env["FEDERATION_DEBUG"]) {
+    return Boolean(process.env["FEDERATION_DEBUG"]);
+  }
+  if (typeof FEDERATION_DEBUG !== "undefined" && Boolean(FEDERATION_DEBUG)) {
+    return true;
+  }
+  return isBrowserDebug();
+}
+const PREFIX = "[ Module Federation ]";
+function setDebug(loggerInstance) {
+  if (isDebugMode()) {
+    loggerInstance.level = "verbose";
+  }
+}
+function setPrefix(loggerInstance, prefix) {
+  loggerInstance.labels = {
+    warn: `${prefix} Warn`,
+    error: `${prefix} Error`,
+    success: `${prefix} Success`,
+    info: `${prefix} Info`,
+    ready: `${prefix} Ready`,
+    debug: `${prefix} Debug`
+  };
+}
+function createLogger(prefix) {
+  const loggerInstance = browser.createLogger({
+    labels: {
+      warn: `${PREFIX} Warn`,
+      error: `${PREFIX} Error`,
+      success: `${PREFIX} Success`,
+      info: `${PREFIX} Info`,
+      ready: `${PREFIX} Ready`,
+      debug: `${PREFIX} Debug`
+    }
+  });
+  setDebug(loggerInstance);
+  setPrefix(loggerInstance, prefix);
+  return loggerInstance;
+}
+createLogger(PREFIX);
+const LoggerInstance = createLogger(
+  "[ Module Federation Bridge React ]"
+);
+function atLeastReact18(React2) {
+  if (React2 && typeof React2.version === "string" && React2.version.indexOf(".") >= 0) {
+    const majorVersionString = React2.version.split(".")[0];
+    try {
+      return Number(majorVersionString) >= 18;
+    } catch (err) {
+      return false;
+    }
+  } else {
+    return false;
+  }
+}
+function pathJoin(...args) {
+  const res = args.reduce((res2, path) => {
+    let nPath = path;
+    if (!nPath || typeof nPath !== "string") {
+      return res2;
+    }
+    if (nPath[0] !== "/") {
+      nPath = `/${nPath}`;
+    }
+    const lastIndex = nPath.length - 1;
+    if (nPath[lastIndex] === "/") {
+      nPath = nPath.substring(0, lastIndex);
+    }
+    return res2 + nPath;
+  }, "");
+  return res || "/";
+}
+const getModuleName = (id) => {
+  if (!id) {
+    return id;
+  }
+  const idArray = id.split("/");
+  if (idArray.length < 2) {
+    return id;
+  }
+  return idArray[0] + "/" + idArray[1];
+};
+const getRootDomDefaultClassName = (moduleName) => {
+  if (!moduleName) {
+    return "";
+  }
+  const name = getModuleName(moduleName).replace(/\@/, "").replace(/\//, "-");
+  return `bridge-root-component-${name}`;
+};
+const RouterContext = React__default.createContext(null);
+export {
+  LoggerInstance as L,
+  RouterContext as R,
+  atLeastReact18 as a,
+  getRootDomDefaultClassName as g,
+  pathJoin as p
+};