@atom-circuit/embed-sdk 1.2.1

package/dist/react.cjs

@@ -0,0 +1,744 @@
+'use strict';
+
+var react = require('react');
+var penpal = require('penpal');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/react.tsx
+
+// src/protocol.ts
+var PROTOCOL_VERSION = "1.0.0";
+var WIDGET_ORIGIN = "https://atomcircuit.net";
+var WIDGET_PATH = "/embed/swap";
+var isObject = (value) => typeof value === "object" && value !== null;
+var isString = (value) => typeof value === "string";
+var isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
+function isHandshakeMessage(value) {
+  if (!isObject(value)) return false;
+  if (value["type"] !== "handshake") return false;
+  if (!isString(value["protocolVersion"])) return false;
+  if (!Array.isArray(value["capabilities"])) return false;
+  return value["capabilities"].every(isString);
+}
+function isResizeMessage(value) {
+  if (!isObject(value)) return false;
+  if (value["type"] !== "atomcircuit:resize") return false;
+  return isFiniteNumber(value["height"]) && value["height"] >= 0;
+}
+var WIDGET_EVENT_NAMES = /* @__PURE__ */ new Set([
+  "ready",
+  "swap:submitted",
+  "swap:success",
+  "swap:error"
+]);
+function isWidgetEventMessage(value) {
+  if (!isObject(value)) return false;
+  if (value["type"] !== "atomcircuit:event") return false;
+  if (!isString(value["name"])) return false;
+  return WIDGET_EVENT_NAMES.has(value["name"]);
+}
+function isProtocolMessage(value) {
+  return isHandshakeMessage(value) || isResizeMessage(value) || isWidgetEventMessage(value);
+}
+function isCompatibleProtocol(sdkVersion, remoteVersion) {
+  const sdkMajor = sdkVersion.split(".")[0];
+  const remoteMajor = remoteVersion.split(".")[0];
+  return sdkMajor !== void 0 && sdkMajor === remoteMajor;
+}
+
+// src/iframe-client.ts
+var noopWarn = (_message) => {
+};
+var IframeClient = class {
+  constructor(opts) {
+    this.connection = null;
+    this.rawListener = null;
+    this.destroyed = false;
+    this.handshakeReceived = null;
+    this.handshakeResolvers = [];
+    this.handlers = {
+      ready: /* @__PURE__ */ new Set(),
+      resize: /* @__PURE__ */ new Set(),
+      "swap:submitted": /* @__PURE__ */ new Set(),
+      "swap:success": /* @__PURE__ */ new Set(),
+      "swap:error": /* @__PURE__ */ new Set()
+    };
+    this.iframe = opts.iframe;
+    this.allowedOrigin = opts.allowedOrigin ?? WIDGET_ORIGIN;
+    this.timeoutMs = opts.timeoutMs ?? 15e3;
+    this.warn = opts.warn ?? noopWarn;
+  }
+  /**
+   * Opens the Penpal connection and starts listening for stream events.
+   * Resolves once the remote handshake has been received.
+   */
+  async init() {
+    if (this.destroyed) {
+      throw new Error("IframeClient: cannot init after destroy()");
+    }
+    if (this.connection) {
+      throw new Error("IframeClient: already initialised");
+    }
+    const remoteWindow = this.iframe.contentWindow;
+    if (!remoteWindow) {
+      throw new Error("IframeClient: iframe.contentWindow is null");
+    }
+    this.rawListener = (event) => {
+      this.handleRawMessage(event);
+    };
+    window.addEventListener("message", this.rawListener);
+    const messenger = new penpal.WindowMessenger({
+      remoteWindow,
+      allowedOrigins: [this.allowedOrigin]
+    });
+    const hostMethods = {
+      handshake: (payload) => {
+        this.recordHandshake(payload);
+      }
+    };
+    const typedConnect = penpal.connect;
+    this.connection = typedConnect({
+      messenger,
+      methods: hostMethods,
+      timeout: this.timeoutMs
+    });
+    await this.connection.promise;
+    return this.waitForHandshake();
+  }
+  /**
+   * Subscribe to a named stream event. Returns an unsubscribe function.
+   */
+  on(name, handler) {
+    this.handlers[name].add(handler);
+    return () => this.off(name, handler);
+  }
+  /**
+   * Remove a registered handler.
+   */
+  off(name, handler) {
+    this.handlers[name].delete(handler);
+  }
+  /**
+   * Tears down the Penpal connection, removes the raw listener, and clears
+   * every event subscriber. Safe to call multiple times.
+   */
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    if (this.rawListener) {
+      window.removeEventListener("message", this.rawListener);
+      this.rawListener = null;
+    }
+    if (this.connection) {
+      this.connection.destroy();
+      this.connection = null;
+    }
+    for (const set of Object.values(this.handlers)) {
+      set.clear();
+    }
+    this.handshakeResolvers = [];
+  }
+  /**
+   * Returns the handshake payload received from the iframe, or null if no
+   * handshake has been observed yet.
+   */
+  getHandshake() {
+    return this.handshakeReceived;
+  }
+  /**
+   * Returns true if the iframe advertised the given capability in its
+   * handshake. Returns false when no handshake has been received yet or
+   * when the capability is not present.
+   *
+   * Callers wrapping a method that requires a capability should gate on
+   * `client.has('cap')` before invoking it. Calls to capabilities the
+   * iframe does not advertise are silent no-ops at the call-site (or
+   * resolve to `null`); the iframe is the source of truth for what it
+   * implements.
+   */
+  has(capability) {
+    const list = this.handshakeReceived?.capabilities;
+    if (!list) return false;
+    for (const entry of list) {
+      if (entry === capability) return true;
+    }
+    return false;
+  }
+  /**
+   * Test-only seam. Allows unit tests to invoke the message handler without
+   * dispatching real `MessageEvent`s through the JSDOM bus.
+   */
+  /* v8 ignore next 3 */
+  _handleMessageForTest(event) {
+    this.handleRawMessage(event);
+  }
+  /* --------------------------------------------------------------------- */
+  handleRawMessage(event) {
+    if (event.origin !== this.allowedOrigin) {
+      return;
+    }
+    if (event.source !== this.iframe.contentWindow) {
+      return;
+    }
+    const data = event.data;
+    if (!isProtocolMessage(data)) {
+      return;
+    }
+    if (data.type === "handshake") {
+      this.recordHandshake(data);
+      return;
+    }
+    if (isResizeMessage(data)) {
+      this.emitResize(data.height);
+      return;
+    }
+    if (isWidgetEventMessage(data)) {
+      this.dispatchWidgetEvent(data);
+    }
+  }
+  recordHandshake(payload) {
+    this.handshakeReceived = payload;
+    if (!isCompatibleProtocol(PROTOCOL_VERSION, payload.protocolVersion)) {
+      this.warn(
+        `Atom Circuit embed: protocol mismatch (sdk=${PROTOCOL_VERSION}, iframe=${payload.protocolVersion}). Some features may be unavailable.`
+      );
+    }
+    const resolvers = this.handshakeResolvers;
+    this.handshakeResolvers = [];
+    for (const resolve of resolvers) {
+      resolve(payload);
+    }
+  }
+  waitForHandshake() {
+    if (this.handshakeReceived) {
+      return Promise.resolve(this.handshakeReceived);
+    }
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        const idx = this.handshakeResolvers.indexOf(wrapped);
+        if (idx >= 0) this.handshakeResolvers.splice(idx, 1);
+        reject(new Error("IframeClient: handshake timeout"));
+      }, this.timeoutMs);
+      const wrapped = (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      };
+      this.handshakeResolvers.push(wrapped);
+    });
+  }
+  emitResize(height) {
+    for (const fn of this.handlers.resize) {
+      fn({ height });
+    }
+  }
+  dispatchWidgetEvent(message) {
+    const name = message.name;
+    switch (name) {
+      case "ready":
+        this.emitReady(message.payload ?? {
+          protocolVersion: this.handshakeReceived?.protocolVersion ?? "unknown"
+        });
+        return;
+      case "swap:submitted":
+        this.emitTyped("swap:submitted", message.payload);
+        return;
+      case "swap:success":
+        this.emitTyped("swap:success", message.payload);
+        return;
+      case "swap:error":
+        this.emitTyped("swap:error", message.payload);
+        return;
+      /* v8 ignore next 2 */
+      default:
+        return;
+    }
+  }
+  emitReady(payload) {
+    for (const fn of this.handlers.ready) {
+      fn(payload);
+    }
+  }
+  emitTyped(name, payload) {
+    for (const fn of this.handlers[name]) {
+      fn(payload);
+    }
+  }
+};
+
+// src/resize.ts
+var DEFAULT_MIN_HEIGHT = "480px";
+function parsePixels(value) {
+  const trimmed = value.trim();
+  const match = trimmed.match(/^([0-9]+(?:\.[0-9]+)?)(px)?$/i);
+  if (!match) return 0;
+  const numStr = match[1];
+  if (numStr === void 0) return 0;
+  const num = Number.parseFloat(numStr);
+  return Number.isFinite(num) ? num : 0;
+}
+function attachResize(opts) {
+  const { iframe, client } = opts;
+  const minHeight = opts.minHeight ?? DEFAULT_MIN_HEIGHT;
+  const minPx = parsePixels(minHeight);
+  iframe.style.minHeight = minHeight;
+  if (!iframe.style.height) {
+    iframe.style.height = minHeight;
+  }
+  let pending = null;
+  let lastApplied = -1;
+  let destroyed = false;
+  const apply = (height) => {
+    if (destroyed) return;
+    const clamped = Math.max(height, minPx);
+    if (clamped === lastApplied) return;
+    iframe.style.height = `${clamped}px`;
+    lastApplied = clamped;
+  };
+  const schedule = (height) => {
+    if (destroyed) return;
+    if (pending !== null) {
+      cancelAnimationFrame(pending);
+    }
+    if (typeof window === "undefined" || typeof window.requestAnimationFrame !== "function") {
+      apply(height);
+      return;
+    }
+    pending = window.requestAnimationFrame(() => {
+      pending = null;
+      apply(height);
+    });
+  };
+  const unsubscribe = client.on("resize", ({ height }) => {
+    schedule(height);
+  });
+  return {
+    destroy() {
+      if (destroyed) return;
+      destroyed = true;
+      if (pending !== null && typeof window !== "undefined" && typeof window.cancelAnimationFrame === "function") {
+        window.cancelAnimationFrame(pending);
+      }
+      pending = null;
+      unsubscribe();
+    }
+  };
+}
+
+// src/theme.ts
+var HEX_COLOR_RE = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/;
+var FONT_FAMILY_RE = /^[a-zA-Z0-9 ,'".\-]+$/;
+var FONT_FAMILY_MAX_LEN = 200;
+var MODES = /* @__PURE__ */ new Set([
+  "light",
+  "dark",
+  "auto"
+]);
+var isObject2 = (value) => typeof value === "object" && value !== null;
+var isString2 = (value) => typeof value === "string";
+var isFiniteNumber2 = (value) => typeof value === "number" && Number.isFinite(value);
+function isHexColor(value) {
+  return isString2(value) && HEX_COLOR_RE.test(value);
+}
+function isValidMode(value) {
+  return isString2(value) && MODES.has(value);
+}
+function isValidFontFamily(value) {
+  if (!isString2(value)) return false;
+  if (value.length === 0 || value.length > FONT_FAMILY_MAX_LEN) return false;
+  return FONT_FAMILY_RE.test(value);
+}
+function validateTheme(theme) {
+  if (!isObject2(theme)) return null;
+  const out = {};
+  if (theme["mode"] !== void 0) {
+    if (!isValidMode(theme["mode"])) return null;
+    out.mode = theme["mode"];
+  }
+  if (theme["accentColor"] !== void 0) {
+    if (!isHexColor(theme["accentColor"])) return null;
+    out.accentColor = theme["accentColor"];
+  }
+  if (theme["background"] !== void 0) {
+    if (!isHexColor(theme["background"])) return null;
+    out.background = theme["background"];
+  }
+  if (theme["foreground"] !== void 0) {
+    if (!isHexColor(theme["foreground"])) return null;
+    out.foreground = theme["foreground"];
+  }
+  if (theme["border"] !== void 0) {
+    if (!isHexColor(theme["border"])) return null;
+    out.border = theme["border"];
+  }
+  if (theme["radius"] !== void 0) {
+    const r = theme["radius"];
+    if (!isFiniteNumber2(r) || r < 0 || r > 64) return null;
+    out.radius = r;
+  }
+  if (theme["fontSize"] !== void 0) {
+    const fs = theme["fontSize"];
+    if (!isFiniteNumber2(fs) || fs < 8 || fs > 32) return null;
+    out.fontSize = fs;
+  }
+  if (theme["fontFamily"] !== void 0) {
+    if (!isValidFontFamily(theme["fontFamily"])) return null;
+    out.fontFamily = theme["fontFamily"];
+  }
+  return out;
+}
+var isBoolean = (value) => typeof value === "boolean";
+function validateChrome(chrome) {
+  if (!isObject2(chrome)) return null;
+  const out = {};
+  if (chrome["logo"] !== void 0) {
+    if (!isBoolean(chrome["logo"])) return null;
+    out.logo = chrome["logo"];
+  }
+  if (chrome["wallet"] !== void 0) {
+    if (!isBoolean(chrome["wallet"])) return null;
+    out.wallet = chrome["wallet"];
+  }
+  if (chrome["validator"] !== void 0) {
+    if (!isBoolean(chrome["validator"])) return null;
+    out.validator = chrome["validator"];
+  }
+  if (chrome["footer"] !== void 0) {
+    if (!isBoolean(chrome["footer"])) return null;
+    out.footer = chrome["footer"];
+  }
+  return out;
+}
+function encodeTheme(theme, chrome) {
+  const compact = {};
+  for (const [key, value] of Object.entries(theme)) {
+    if (value === null || value === void 0) continue;
+    compact[key] = value;
+  }
+  if (chrome && Object.keys(chrome).length > 0) {
+    const chromeCompact = {};
+    for (const [key, value] of Object.entries(chrome)) {
+      if (value === null || value === void 0) continue;
+      chromeCompact[key] = value;
+    }
+    if (Object.keys(chromeCompact).length > 0) {
+      compact["chrome"] = chromeCompact;
+    }
+  }
+  const json = JSON.stringify(compact);
+  if (typeof btoa === "function") {
+    return btoa(json);
+  }
+  return Buffer.from(json, "utf-8").toString("base64");
+}
+
+// src/mount.ts
+var HANDSHAKE_TIMEOUT_MS = 15e3;
+var SANDBOX_ATTR = "allow-scripts allow-same-origin allow-popups allow-popups-to-escape-sandbox allow-forms";
+var LOADER_SVG = '<svg width="32" height="32" viewBox="0 0 32 32" fill="none" xmlns="http://www.w3.org/2000/svg" aria-hidden="true"><circle cx="16" cy="16" r="13" stroke="#7B61FF" stroke-width="2.5" stroke-opacity="0.28"/><path d="M29 16a13 13 0 0 0-13-13" stroke="#33D6FF" stroke-width="2.5" stroke-linecap="round"/></svg>';
+function buildSrc(opts) {
+  const origin = (opts.origin ?? WIDGET_ORIGIN).replace(/\/$/, "");
+  const path = opts.path ?? WIDGET_PATH;
+  const params = new URLSearchParams();
+  params.set("ref", opts.referralId);
+  params.set("v", PROTOCOL_VERSION);
+  const validatedTheme = opts.theme !== void 0 ? validateTheme(opts.theme) : null;
+  if (opts.theme !== void 0 && validatedTheme === null && opts.warn) {
+    opts.warn(
+      "Atom Circuit embed: theme validation failed, falling back to defaults"
+    );
+  }
+  const validatedChrome = opts.chrome !== void 0 ? validateChrome(opts.chrome) : null;
+  if (opts.chrome !== void 0 && validatedChrome === null && opts.warn) {
+    opts.warn(
+      "Atom Circuit embed: chrome validation failed, falling back to defaults"
+    );
+  }
+  if (validatedTheme !== null || validatedChrome !== null) {
+    params.set(
+      "theme",
+      encodeTheme(validatedTheme ?? {}, validatedChrome ?? void 0)
+    );
+  }
+  const sep = path.includes("?") ? "&" : "?";
+  return `${origin}${path}${sep}${params.toString()}`;
+}
+function applyStyle(iframe, style) {
+  if (!style) return;
+  for (const key of Object.keys(style)) {
+    if (key === "height" || key === "width") continue;
+    const value = style[key];
+    if (typeof value === "string") {
+      iframe.style[key] = value;
+    }
+  }
+}
+function applySizing(iframe, wrapper, opts) {
+  if (opts.width !== void 0) {
+    iframe.style.width = opts.width;
+  }
+  if (opts.maxWidth !== void 0) {
+    iframe.style.maxWidth = opts.maxWidth;
+  }
+  if (opts.padding !== void 0) {
+    wrapper.style.padding = opts.padding;
+  }
+}
+function mount(container, opts = {}) {
+  if (!container || typeof container.appendChild !== "function") {
+    throw new TypeError("mount: container must be an HTMLElement");
+  }
+  const referralIdRaw = typeof opts.referralId === "string" ? opts.referralId.trim() : "";
+  const resolvedReferralId = referralIdRaw.length > 0 ? referralIdRaw : "general";
+  const warnSink = typeof console !== "undefined" && typeof console.warn === "function" ? (msg) => {
+    console.warn(msg);
+  } : () => {
+  };
+  let dismissLoader = () => {
+  };
+  const reportError = (error) => {
+    dismissLoader();
+    if (opts.onError) {
+      opts.onError(error);
+      return;
+    }
+    warnSink(`Atom Circuit embed: ${error.code}: ${error.message}`);
+  };
+  const wrapper = document.createElement("div");
+  wrapper.setAttribute("data-atom-circuit-embed", "");
+  wrapper.style.position = "relative";
+  wrapper.style.width = "100%";
+  wrapper.style.display = "block";
+  const iframe = document.createElement("iframe");
+  iframe.src = buildSrc({
+    referralId: resolvedReferralId,
+    ...opts.origin !== void 0 ? { origin: opts.origin } : {},
+    ...opts.path !== void 0 ? { path: opts.path } : {},
+    ...opts.theme !== void 0 ? { theme: opts.theme } : {},
+    ...opts.chrome !== void 0 ? { chrome: opts.chrome } : {},
+    warn: warnSink
+  });
+  iframe.setAttribute("sandbox", SANDBOX_ATTR);
+  iframe.setAttribute("allow", "clipboard-write; clipboard-read");
+  iframe.setAttribute("title", "Atom Circuit swap widget");
+  iframe.setAttribute("loading", "lazy");
+  iframe.setAttribute("referrerpolicy", "strict-origin-when-cross-origin");
+  iframe.style.width = "100%";
+  iframe.style.border = "0";
+  iframe.style.display = "block";
+  iframe.style.colorScheme = "normal";
+  iframe.style.position = "relative";
+  iframe.style.zIndex = "1";
+  applyStyle(iframe, opts.style);
+  applySizing(iframe, wrapper, opts);
+  if (opts.className) {
+    iframe.className = opts.className;
+  }
+  const loader = document.createElement("div");
+  loader.setAttribute("data-atom-circuit-loader", "");
+  loader.setAttribute("aria-hidden", "true");
+  loader.style.position = "absolute";
+  loader.style.inset = "0";
+  loader.style.display = "flex";
+  loader.style.alignItems = "center";
+  loader.style.justifyContent = "center";
+  loader.style.pointerEvents = "none";
+  loader.style.color = "#888888";
+  loader.style.transition = "opacity 0.08s ease-out";
+  loader.style.opacity = "1";
+  loader.style.zIndex = "2";
+  loader.innerHTML = LOADER_SVG;
+  const loaderSvg = loader.querySelector("svg");
+  let spinAnimation = null;
+  if (loaderSvg && typeof loaderSvg.animate === "function") {
+    loaderSvg.style.transformOrigin = "center";
+    spinAnimation = loaderSvg.animate(
+      [{ transform: "rotate(0deg)" }, { transform: "rotate(360deg)" }],
+      { duration: 900, iterations: Infinity, easing: "linear" }
+    );
+  }
+  let loaderDismissed = false;
+  dismissLoader = () => {
+    if (loaderDismissed) return;
+    loaderDismissed = true;
+    loader.style.opacity = "0";
+    if (spinAnimation) {
+      try {
+        spinAnimation.cancel();
+      } catch {
+      }
+      spinAnimation = null;
+    }
+    setTimeout(() => {
+      if (loader.parentNode) loader.parentNode.removeChild(loader);
+    }, 100);
+  };
+  const onIframeError = (event) => {
+    reportError({
+      code: "iframe_load_failed",
+      message: "Iframe failed to load the widget URL",
+      cause: event
+    });
+  };
+  iframe.addEventListener("error", onIframeError);
+  const onIframeLoad = () => {
+    dismissLoader();
+  };
+  iframe.addEventListener("load", onIframeLoad);
+  try {
+    wrapper.appendChild(iframe);
+    wrapper.appendChild(loader);
+    container.appendChild(wrapper);
+  } catch (err) {
+    iframe.removeEventListener("error", onIframeError);
+    iframe.removeEventListener("load", onIframeLoad);
+    throw err;
+  }
+  const client = new IframeClient({
+    iframe,
+    allowedOrigin: opts.origin ?? WIDGET_ORIGIN
+  });
+  const resize = attachResize({
+    iframe,
+    client,
+    ...opts.minHeight !== void 0 ? { minHeight: opts.minHeight } : {}
+  });
+  const subscriptions = [];
+  if (opts.onReady) {
+    const fn = opts.onReady;
+    subscriptions.push(client.on("ready", (p) => fn(p)));
+  }
+  if (opts.onResize) {
+    const fn = opts.onResize;
+    subscriptions.push(client.on("resize", (info) => fn(info)));
+  }
+  if (opts.onSwapSubmitted) {
+    const fn = opts.onSwapSubmitted;
+    subscriptions.push(client.on("swap:submitted", (p) => fn(p)));
+  }
+  if (opts.onSwapSuccess) {
+    const fn = opts.onSwapSuccess;
+    subscriptions.push(client.on("swap:success", (p) => fn(p)));
+  }
+  if (opts.onSwapError) {
+    const fn = opts.onSwapError;
+    subscriptions.push(client.on("swap:error", (p) => fn(p)));
+  }
+  let timeoutHandle = null;
+  let bridgeReady = false;
+  const clearTimer = () => {
+    if (timeoutHandle !== null) {
+      clearTimeout(timeoutHandle);
+      timeoutHandle = null;
+    }
+  };
+  const readySuppressUnsub = client.on("ready", () => {
+    bridgeReady = true;
+    clearTimer();
+    dismissLoader();
+    readySuppressUnsub();
+  });
+  const timeoutPromise = new Promise((_resolve, reject) => {
+    timeoutHandle = setTimeout(() => {
+      reject(new Error(`Iframe handshake timed out after ${HANDSHAKE_TIMEOUT_MS}ms`));
+    }, HANDSHAKE_TIMEOUT_MS);
+  });
+  Promise.race([client.init(), timeoutPromise]).then(() => {
+    clearTimer();
+  }).catch((err) => {
+    clearTimer();
+    if (bridgeReady) return;
+    if (destroyed) return;
+    const message = err instanceof Error ? err.message : String(err);
+    const code = classifyInitError(message);
+    reportError({ code, message, cause: err });
+  });
+  let destroyed = false;
+  const destroy = () => {
+    if (destroyed) return;
+    destroyed = true;
+    if (timeoutHandle !== null) {
+      clearTimeout(timeoutHandle);
+      timeoutHandle = null;
+    }
+    iframe.removeEventListener("error", onIframeError);
+    iframe.removeEventListener("load", onIframeLoad);
+    for (const unsub of subscriptions) unsub();
+    resize.destroy();
+    client.destroy();
+    dismissLoader();
+    if (wrapper.parentNode) {
+      wrapper.parentNode.removeChild(wrapper);
+    } else if (iframe.parentNode) {
+      iframe.parentNode.removeChild(iframe);
+    }
+  };
+  return { iframe, wrapper, client, destroy };
+}
+function classifyInitError(message) {
+  const lower = message.toLowerCase();
+  if (lower.includes("handshake") || lower.includes("timed out") || lower.includes("timeout")) {
+    return "handshake_failed";
+  }
+  if (lower.includes("protocol mismatch") || lower.includes("protocolversion")) {
+    return "protocol_incompatible";
+  }
+  if (lower.includes("origin mismatch") || lower.includes("allowed origin")) {
+    return "origin_mismatch";
+  }
+  if (lower.includes("contentwindow") || lower.includes("iframe failed") || lower.includes("load")) {
+    return "iframe_load_failed";
+  }
+  return "unknown";
+}
+var WRAPPER_STYLE = {
+  width: "100%",
+  display: "block"
+};
+function AtomCircuitSwap(props) {
+  const containerRef = react.useRef(null);
+  const propsRef = react.useRef(props);
+  propsRef.current = props;
+  react.useEffect(() => {
+    const container = containerRef.current;
+    if (!container) return;
+    const opts = {
+      referralId: propsRef.current.referralId,
+      ...propsRef.current.origin !== void 0 ? { origin: propsRef.current.origin } : {},
+      ...propsRef.current.path !== void 0 ? { path: propsRef.current.path } : {},
+      ...propsRef.current.minHeight !== void 0 ? { minHeight: propsRef.current.minHeight } : {},
+      ...propsRef.current.theme !== void 0 ? { theme: propsRef.current.theme } : {},
+      ...propsRef.current.chrome !== void 0 ? { chrome: propsRef.current.chrome } : {},
+      ...propsRef.current.width !== void 0 ? { width: propsRef.current.width } : {},
+      ...propsRef.current.maxWidth !== void 0 ? { maxWidth: propsRef.current.maxWidth } : {},
+      ...propsRef.current.padding !== void 0 ? { padding: propsRef.current.padding } : {},
+      onReady: (payload) => propsRef.current.onReady?.(payload),
+      onResize: (info) => propsRef.current.onResize?.(info),
+      onSwapSubmitted: (payload) => propsRef.current.onSwapSubmitted?.(payload),
+      onSwapSuccess: (payload) => propsRef.current.onSwapSuccess?.(payload),
+      onSwapError: (payload) => propsRef.current.onSwapError?.(payload),
+      onError: (error) => propsRef.current.onError?.(error)
+    };
+    let handle = null;
+    try {
+      handle = mount(container, opts);
+    } catch {
+      handle = null;
+    }
+    return () => {
+      handle?.destroy();
+    };
+  }, [props.referralId, props.origin, props.path]);
+  const wrapperStyle = props.style ? { ...WRAPPER_STYLE, ...props.style } : WRAPPER_STYLE;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      ref: containerRef,
+      className: props.className,
+      style: wrapperStyle,
+      "data-atom-circuit-embed": ""
+    }
+  );
+}
+
+exports.AtomCircuitSwap = AtomCircuitSwap;
+//# sourceMappingURL=react.cjs.map