@sunbay/checkout-sdk-js 0.0.0-stage → 0.0.2

package/dist/index.global.js

@@ -0,0 +1,1246 @@
+"use strict";
+var SunbayCheckout = (() => {
+  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);
+
+  // src/index.ts
+  var index_exports = {};
+  __export(index_exports, {
+    CheckoutElement: () => CheckoutElement,
+    CheckoutInstance: () => CheckoutInstance,
+    ErrorCode: () => ErrorCode,
+    createCheckout: () => createCheckout,
+    version: () => version
+  });
+
+  // ../protocol/dist/index.mjs
+  var PROTOCOL_NAME = "sunbay-checkout";
+  var PROTOCOL_MAJOR = 1;
+  var ENVELOPE_KINDS = ["request", "response", "event"];
+  var EnvelopeDecodeError = class extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "EnvelopeDecodeError";
+    }
+  };
+  function isRecord(value) {
+    return typeof value === "object" && value !== null;
+  }
+  function assertString(obj, key) {
+    if (typeof obj[key] !== "string") {
+      throw new EnvelopeDecodeError(`Envelope field "${key}" is missing or not a string`);
+    }
+  }
+  function encodeEnvelope(envelope) {
+    return JSON.stringify(envelope);
+  }
+  function decodeEnvelope(wire) {
+    let parsed;
+    try {
+      parsed = JSON.parse(wire);
+    } catch {
+      throw new EnvelopeDecodeError("Envelope is not valid JSON");
+    }
+    if (!isRecord(parsed)) {
+      throw new EnvelopeDecodeError("Envelope must be an object");
+    }
+    if (parsed.protocol !== PROTOCOL_NAME) {
+      throw new EnvelopeDecodeError(
+        `protocol must be "${PROTOCOL_NAME}", received ${JSON.stringify(parsed.protocol)}`
+      );
+    }
+    if (parsed.major !== PROTOCOL_MAJOR) {
+      throw new EnvelopeDecodeError(
+        `major must be ${PROTOCOL_MAJOR}, received ${JSON.stringify(parsed.major)}`
+      );
+    }
+    assertString(parsed, "runtimeId");
+    assertString(parsed, "checkoutId");
+    if (parsed.elementId !== void 0 && typeof parsed.elementId !== "string") {
+      throw new EnvelopeDecodeError("elementId must be a string when present");
+    }
+    const kind = parsed.kind;
+    if (typeof kind !== "string" || !ENVELOPE_KINDS.includes(kind)) {
+      throw new EnvelopeDecodeError(`Invalid kind: ${JSON.stringify(kind)}`);
+    }
+    switch (kind) {
+      case "request": {
+        assertString(parsed, "requestId");
+        assertString(parsed, "name");
+        if (!("payload" in parsed)) {
+          throw new EnvelopeDecodeError("request envelope is missing payload");
+        }
+        break;
+      }
+      case "response": {
+        assertString(parsed, "requestId");
+        if (typeof parsed.ok !== "boolean") {
+          throw new EnvelopeDecodeError("response envelope is missing boolean ok");
+        }
+        if (parsed.ok === true) {
+          if (!("data" in parsed)) {
+            throw new EnvelopeDecodeError("successful response is missing data");
+          }
+        } else if (!isRecord(parsed.error)) {
+          throw new EnvelopeDecodeError("failed response is missing error object");
+        }
+        break;
+      }
+      case "event": {
+        assertString(parsed, "eventId");
+        assertString(parsed, "name");
+        if (!("payload" in parsed)) {
+          throw new EnvelopeDecodeError("event envelope is missing payload");
+        }
+        if ("operationId" in parsed && parsed.operationId !== void 0 && typeof parsed.operationId !== "string") {
+          throw new EnvelopeDecodeError("operationId must be a string when present");
+        }
+        break;
+      }
+    }
+    return parsed;
+  }
+  var ErrorCode = {
+    INVALID_OPTIONS: "INVALID_OPTIONS",
+    ELEMENT_CONFLICT: "ELEMENT_CONFLICT",
+    INSTANCE_DESTROYED: "INSTANCE_DESTROYED",
+    CHECKOUT_BUSY: "CHECKOUT_BUSY",
+    VALIDATION_ERROR: "VALIDATION_ERROR",
+    SESSION_LOAD_FAILED: "SESSION_LOAD_FAILED",
+    RUNTIME_LOAD_FAILED: "RUNTIME_LOAD_FAILED",
+    PROTOCOL_UNSUPPORTED: "PROTOCOL_UNSUPPORTED",
+    REQUEST_TIMEOUT: "REQUEST_TIMEOUT",
+    PAYMENT_FLOW_ERROR: "PAYMENT_FLOW_ERROR",
+    UNSUPPORTED_CAPABILITY: "UNSUPPORTED_CAPABILITY"
+  };
+  var IFRAME_RESIZE_MESSAGE_TYPE = "sunbay:checkout:iframe-resize";
+  function isIframeResizeMessage(data) {
+    if (typeof data !== "object" || data === null) {
+      return false;
+    }
+    const msg = data;
+    return msg.type === IFRAME_RESIZE_MESSAGE_TYPE && typeof msg.elementId === "string" && msg.elementId.length > 0 && typeof msg.height === "number" && Number.isFinite(msg.height) && msg.height >= 0;
+  }
+
+  // src/transport/MainFrameTransport.ts
+  var DEFAULT_REQUEST_TIMEOUTS = {
+    default: 1e4,
+    initialize: 3e4,
+    handshake: 15e3
+  };
+  function genId(prefix) {
+    const rand = Math.random().toString(36).slice(2);
+    return `${prefix}_${Date.now().toString(36)}_${rand}`;
+  }
+  function makeError(code, message) {
+    return {
+      code,
+      message,
+      category: "runtime",
+      errorId: genId("err")
+    };
+  }
+  function isRuntimeHello(value) {
+    if (typeof value !== "object" || value === null) {
+      return false;
+    }
+    const record = value;
+    return record.protocol === PROTOCOL_NAME && record.kind === "hello";
+  }
+  var MainFrameTransport = class {
+    constructor(options, timeouts = DEFAULT_REQUEST_TIMEOUTS) {
+      this.iframe = null;
+      this.pending = /* @__PURE__ */ new Map();
+      this.eventHandlers = /* @__PURE__ */ new Map();
+      this.helloHandler = null;
+      /**
+       * 握手协商出的运行时 id；未注入前为空串。出站 request 信封据此填充，
+       * main 端点仅处理 runtimeId 与自身一致的请求，空串会被静默丢弃。
+       */
+      this.runtimeId = "";
+      this.destroyed = false;
+      this.checkoutId = options.checkoutId;
+      this.hostOrigin = options.hostOrigin;
+      this.timeouts = timeouts;
+      this.messageListener = (event) => {
+        this.handleMessage(event);
+      };
+      window.addEventListener("message", this.messageListener);
+    }
+    /**
+     * 创建隐藏 0 尺寸 main iframe，append 到 document.body。
+     *
+     * @returns 已挂载的 iframe 元素。
+     * @example
+     * const iframe = transport.createHiddenIframe();
+     */
+    createHiddenIframe() {
+      if (this.iframe) {
+        return this.iframe;
+      }
+      const iframe = document.createElement("iframe");
+      iframe.src = `${this.hostOrigin}/sdk/main?checkoutId=${this.checkoutId}`;
+      iframe.setAttribute("aria-hidden", "true");
+      iframe.title = "sunbay-checkout-main";
+      iframe.style.position = "absolute";
+      iframe.style.width = "0";
+      iframe.style.height = "0";
+      iframe.style.border = "0";
+      iframe.style.visibility = "hidden";
+      document.body.appendChild(iframe);
+      this.iframe = iframe;
+      return iframe;
+    }
+    /**
+     * 发送一条 request 信封，按 requestId 配对响应。
+     *
+     * @param name - 命令名。
+     * @param payload - 命令载荷（JSON 可序列化）。
+     * @returns 响应 data；失败（ok:false / 超时 / destroy）reject 一个 CheckoutError。
+     * @example
+     * const session = await transport.request('getSession', {});
+     */
+    request(name, payload) {
+      return new Promise((resolve, reject) => {
+        if (this.destroyed) {
+          reject(makeError(ErrorCode.INSTANCE_DESTROYED, "Checkout instance has been destroyed"));
+          return;
+        }
+        const contentWindow = this.iframe?.contentWindow;
+        if (!contentWindow) {
+          reject(
+            makeError(
+              ErrorCode.RUNTIME_LOAD_FAILED,
+              "main iframe not created or contentWindow unavailable"
+            )
+          );
+          return;
+        }
+        const requestId = genId("req");
+        const envelope = {
+          protocol: PROTOCOL_NAME,
+          major: PROTOCOL_MAJOR,
+          runtimeId: this.runtimeId,
+          checkoutId: this.checkoutId,
+          kind: "request",
+          requestId,
+          name,
+          payload
+        };
+        const timeoutMs = this.resolveTimeout(name);
+        const timer = setTimeout(() => {
+          this.pending.delete(requestId);
+          reject(makeError(ErrorCode.REQUEST_TIMEOUT, `Command ${name} timed out`));
+        }, timeoutMs);
+        this.pending.set(requestId, { resolve, reject, timer });
+        contentWindow.postMessage(encodeEnvelope(envelope), this.hostOrigin);
+      });
+    }
+    /**
+     * 注册事件 handler（分发 kind:'event' 信封的 payload）。
+     *
+     * @param event - 事件名。
+     * @param handler - 回调。
+     */
+    on(event, handler) {
+      let set = this.eventHandlers.get(event);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        this.eventHandlers.set(event, set);
+      }
+      set.add(handler);
+    }
+    /**
+     * 注销事件 handler。
+     *
+     * @param event - 事件名。
+     * @param handler - 先前注册的回调。
+     */
+    off(event, handler) {
+      const set = this.eventHandlers.get(event);
+      if (set) {
+        set.delete(handler);
+        if (set.size === 0) {
+          this.eventHandlers.delete(event);
+        }
+      }
+    }
+    /**
+     * 注册握手（RuntimeHello）回调。hello 阶段尚无 checkoutId，单独处理。
+     *
+     * @param handler - 收到 hello 时调用。
+     */
+    onHello(handler) {
+      this.helloHandler = handler;
+    }
+    /**
+     * 注入握手协商出的运行时 id。必须在发送首个 request（initialize）之前调用，
+     * 否则出站信封 runtimeId 为空串、被 main 端点静默丢弃导致请求超时。
+     *
+     * @param runtimeId - RuntimeHello 中的 runtimeId。
+     */
+    setRuntimeId(runtimeId) {
+      this.runtimeId = runtimeId;
+    }
+    /**
+     * 销毁：移除 iframe、清监听，未决 request 以 INSTANCE_DESTROYED reject。
+     */
+    destroy() {
+      if (this.destroyed) {
+        return;
+      }
+      this.destroyed = true;
+      window.removeEventListener("message", this.messageListener);
+      for (const [, entry] of this.pending) {
+        clearTimeout(entry.timer);
+        entry.reject(makeError(ErrorCode.INSTANCE_DESTROYED, "Checkout instance has been destroyed"));
+      }
+      this.pending.clear();
+      this.eventHandlers.clear();
+      this.helloHandler = null;
+      if (this.iframe && this.iframe.parentNode) {
+        this.iframe.parentNode.removeChild(this.iframe);
+      }
+      this.iframe = null;
+    }
+    /** 按命令名解析超时时长。 */
+    resolveTimeout(name) {
+      if (name === "initialize") {
+        return this.timeouts.initialize;
+      }
+      return this.timeouts.default;
+    }
+    /**
+     * 点对点 port relay（父窗口中继，Stripe controller 模型）。
+     *
+     * 兄弟 iframe（main 与各 Element iframe）之间拿不到彼此 window 引用，无法直接
+     * transfer MessagePort。本层（商户页，唯一同时可达两端且知其 origin 的角色）在
+     * 收到某 Element iframe 的 `element-online` 时：
+     * 1. 建 `MessageChannel`；
+     * 2. `port1` → main iframe（`relay-port`，targetOrigin=hostOrigin）；
+     * 3. `port2` → 发起的 Element iframe（即 `event.source`，targetOrigin=hostOrigin）。
+     *
+     * 两端 origin 均为 hostOrigin，targetOrigin 恒正确（跨域亦不被丢弃）。
+     * 本层只搬运**空 port**，绝不接触卡值（卡值在 port 建立后端到端传输）。
+     *
+     * @param event 入站 message（origin 已校验为 hostOrigin）
+     * @returns 是否作为 element-online 处理（是则调用方应 return）
+     */
+    tryHandleElementOnline(event) {
+      const data = event.data;
+      if (typeof data !== "object" || data === null) {
+        return false;
+      }
+      const msg = data;
+      if (msg.kind !== "element-online") {
+        return false;
+      }
+      if (msg.checkoutId !== this.checkoutId || typeof msg.fieldType !== "string") {
+        return true;
+      }
+      const mainWin = this.iframe?.contentWindow;
+      const elementWin = event.source;
+      if (!mainWin || !elementWin) {
+        return true;
+      }
+      const channel = new MessageChannel();
+      const relayMsg = {
+        kind: "relay-port",
+        checkoutId: this.checkoutId,
+        fieldType: msg.fieldType
+      };
+      mainWin.postMessage(relayMsg, this.hostOrigin, [channel.port1]);
+      elementWin.postMessage(relayMsg, this.hostOrigin, [channel.port2]);
+      return true;
+    }
+    /** 处理入站 message：过滤 origin，识别 relay / hello / Envelope 并分发。 */
+    handleMessage(event) {
+      if (this.destroyed) {
+        return;
+      }
+      if (event.origin !== this.hostOrigin) {
+        return;
+      }
+      if (this.tryHandleElementOnline(event)) {
+        return;
+      }
+      if (typeof event.data !== "string") {
+        return;
+      }
+      let raw;
+      try {
+        raw = JSON.parse(event.data);
+      } catch {
+        return;
+      }
+      if (isRuntimeHello(raw)) {
+        if (this.helloHandler) {
+          this.helloHandler(raw);
+        }
+        return;
+      }
+      let envelope;
+      try {
+        envelope = decodeEnvelope(event.data);
+      } catch {
+        return;
+      }
+      if (envelope.checkoutId !== this.checkoutId) {
+        return;
+      }
+      if (envelope.kind === "response") {
+        this.handleResponse(envelope);
+      } else if (envelope.kind === "event") {
+        this.handleEvent(envelope);
+      }
+    }
+    /** 分发 response 到配对的未决 request。 */
+    handleResponse(envelope) {
+      const entry = this.pending.get(envelope.requestId);
+      if (!entry) {
+        return;
+      }
+      this.pending.delete(envelope.requestId);
+      clearTimeout(entry.timer);
+      if (envelope.ok) {
+        entry.resolve(envelope.data);
+      } else {
+        entry.reject(envelope.error);
+      }
+    }
+    /** 分发 event 到注册的 handler。 */
+    handleEvent(envelope) {
+      const set = this.eventHandlers.get(envelope.name);
+      if (!set) {
+        return;
+      }
+      for (const handler of set) {
+        handler(envelope.payload);
+      }
+    }
+  };
+
+  // src/Element.ts
+  var FIELD_TYPES = ["cardNumber", "cardExpiry", "cardCvc"];
+  var INPUT_TYPES = [
+    "cardNumber",
+    "cardExpiry",
+    "cardCvc",
+    "card",
+    "address"
+  ];
+  function makeError2(code, message, elementId) {
+    const rand = Math.random().toString(36).slice(2);
+    return {
+      code,
+      message,
+      category: "configuration",
+      errorId: `err_${Date.now().toString(36)}_${rand}`,
+      elementId
+    };
+  }
+  function matchesElement(payload, elementId) {
+    if (typeof payload !== "object" || payload === null) {
+      return false;
+    }
+    return payload.elementId === elementId;
+  }
+  var CheckoutElement = class _CheckoutElement {
+    constructor(opts) {
+      this.status = "created";
+      this.container = null;
+      this.iframe = null;
+      /** mount 期间临时订阅的事件 handler（resolve/reject 后解绑）。 */
+      this.readyHandler = null;
+      this.loadErrorHandler = null;
+      /** 仅 expressCheckout：常驻订阅的 expressAvailabilityChange handler（destroy 时解绑）。 */
+      this.availabilityHandler = null;
+      /**
+       * iframe 自适应高度：挂载期间常驻的 window 'message' 监听器（iframe 消失/销毁时解绑）。
+       * 存引用以便 removeEventListener；null 表示未监听。
+       */
+      this.resizeHandler = null;
+      /** 最近一次已应用的 iframe 高度（px），用于去重，避免冗余 style 写入；null 表示尚未设置。 */
+      this.lastHeight = null;
+      this.elementId = opts.elementId;
+      this.type = opts.type;
+      this.hostOrigin = opts.hostOrigin;
+      this.checkoutId = opts.checkoutId;
+      this.transport = opts.transport;
+      this.options = opts.initialOptions;
+      this.colorScheme = opts.colorScheme;
+      this.appearance = opts.appearance;
+      this.mode = opts.initialOptions?.mode;
+      this.onDestroy = opts.onDestroy;
+      this.installInputActions();
+      this.installExpressAvailability();
+    }
+    /** 当前状态（只读快照，供外部/测试观测）。 */
+    getStatus() {
+      return this.status;
+    }
+    /**
+     * 仅 expressCheckout：返回当前各钱包可用性快照（其他类型恒为 undefined）。
+     *
+     * 初值来自 elementReady 的 availableWallets，之后由 expressAvailabilityChange 更新。
+     *
+     * @returns 可用性快照；尚未就绪或非 express 时为 undefined。
+     */
+    getAvailableWallets() {
+      return this.availableWallets;
+    }
+    /**
+     * 挂载到商户 DOM 目标：插入可见 iframe、发 createElement、等 elementReady。
+     *
+     * @param selectorOrEl - CSS 选择器或 HTMLElement 容器；容器须唯一且为空。
+     * @returns elementReady 后 resolve；失败移除节点并 reject（loadError / INVALID_OPTIONS）。
+     * @throws 已销毁时抛 INSTANCE_DESTROYED。
+     * @example
+     * await element.mount('#card-field');
+     */
+    mount(selectorOrEl) {
+      this.assertAlive();
+      if (this.status === "loading" || this.status === "ready") {
+        return Promise.reject(
+          makeError2(
+            ErrorCode.ELEMENT_CONFLICT,
+            "This Element is already mounted; mount cannot be called twice",
+            this.elementId
+          )
+        );
+      }
+      const container = this.resolveContainer(selectorOrEl);
+      if (!container) {
+        return Promise.reject(
+          makeError2(
+            ErrorCode.INVALID_OPTIONS,
+            "Target container not found or not uniquely resolvable",
+            this.elementId
+          )
+        );
+      }
+      if (container.childElementCount > 0) {
+        return Promise.reject(
+          makeError2(ErrorCode.INVALID_OPTIONS, "Target container is not empty", this.elementId)
+        );
+      }
+      this.status = "loading";
+      this.container = container;
+      const iframe = document.createElement("iframe");
+      iframe.src = this.resolveSrc();
+      iframe.title = `sunbay-checkout-${this.type}`;
+      iframe.setAttribute("data-element-id", this.elementId);
+      iframe.style.border = "0";
+      iframe.style.width = "100%";
+      iframe.style.display = "block";
+      container.appendChild(iframe);
+      this.iframe = iframe;
+      this.installResizeListener();
+      return new Promise((resolve, reject) => {
+        const cleanup = () => {
+          if (this.readyHandler) {
+            this.transport.off("elementReady", this.readyHandler);
+            this.readyHandler = null;
+          }
+          if (this.loadErrorHandler) {
+            this.transport.off("loadError", this.loadErrorHandler);
+            this.loadErrorHandler = null;
+          }
+        };
+        const onReady = (payload) => {
+          if (!matchesElement(payload, this.elementId)) {
+            return;
+          }
+          cleanup();
+          const wallets = payload.availableWallets;
+          if (wallets) {
+            this.availableWallets = wallets;
+          }
+          this.status = "ready";
+          resolve();
+        };
+        const onLoadError = (payload) => {
+          if (!matchesElement(payload, this.elementId)) {
+            return;
+          }
+          cleanup();
+          this.status = "loadError";
+          this.removeIframe();
+          const err = payload?.error;
+          reject(
+            err ?? makeError2(
+              ErrorCode.RUNTIME_LOAD_FAILED,
+              "Failed to load Element",
+              this.elementId
+            )
+          );
+        };
+        this.readyHandler = onReady;
+        this.loadErrorHandler = onLoadError;
+        this.transport.on("elementReady", onReady);
+        this.transport.on("loadError", onLoadError);
+        this.transport.request("createElement", {
+          elementId: this.elementId,
+          type: this.type,
+          options: this.options
+        }).catch((cmdErr) => {
+          cleanup();
+          this.status = "loadError";
+          this.removeIframe();
+          reject(cmdErr);
+        });
+      });
+    }
+    /**
+     * 卸载：发 destroyElement、移除 iframe；幂等；保留句柄与配置。
+     *
+     * @returns 完成后 resolve（未挂载时直接 resolve）。
+     * @throws 已销毁时抛 INSTANCE_DESTROYED。
+     */
+    async unmount() {
+      this.assertAlive();
+      if (this.status !== "ready" && this.status !== "loading") {
+        return;
+      }
+      try {
+        await this.transport.request("destroyElement", { elementId: this.elementId });
+      } finally {
+        this.removeIframe();
+        this.container = null;
+        this.status = "created";
+      }
+    }
+    /**
+     * 销毁句柄：幂等；移除 iframe；此后非 destroy/off 调用抛 INSTANCE_DESTROYED。
+     */
+    destroy() {
+      if (this.status === "destroyed") {
+        return;
+      }
+      if (this.readyHandler) {
+        this.transport.off("elementReady", this.readyHandler);
+        this.readyHandler = null;
+      }
+      if (this.loadErrorHandler) {
+        this.transport.off("loadError", this.loadErrorHandler);
+        this.loadErrorHandler = null;
+      }
+      if (this.availabilityHandler) {
+        this.transport.off("expressAvailabilityChange", this.availabilityHandler);
+        this.availabilityHandler = null;
+      }
+      this.removeIframe();
+      this.container = null;
+      this.status = "destroyed";
+      this.onDestroy?.(this.elementId);
+    }
+    /**
+     * 更新 Element 配置：发 updateElement；非法字段由托管侧整次拒绝。
+     *
+     * @param patch - 配置增量。
+     * @returns 成功写回本地 options 后 resolve。
+     * @throws 已销毁时抛 INSTANCE_DESTROYED。
+     */
+    async update(patch) {
+      this.assertAlive();
+      const resp = await this.transport.request("updateElement", {
+        elementId: this.elementId,
+        patch
+      });
+      const next = resp?.options;
+      if (next) {
+        this.options = next;
+      }
+    }
+    /**
+     * 注册事件 handler（透传到 transport，按事件名分发）。
+     *
+     * @param event - 事件名。
+     * @param handler - 回调。
+     * @throws 已销毁时抛 INSTANCE_DESTROYED。
+     */
+    on(event, handler) {
+      this.assertAlive();
+      this.transport.on(event, handler);
+    }
+    /**
+     * 注销事件 handler（销毁后仍可安全调用）。
+     *
+     * @param event - 事件名。
+     * @param handler - 先前注册的回调。
+     */
+    off(event, handler) {
+      this.transport.off(event, handler);
+    }
+    /** 已挂载后安装输入类动作方法（由构造后自动调用）。 */
+    installInputActions() {
+      if (!INPUT_TYPES.includes(this.type)) {
+        return;
+      }
+      this.focus = () => this.sendAction("focus");
+      this.blur = () => this.sendAction("blur");
+      this.clear = () => this.sendAction("clear");
+    }
+    /**
+     * 仅 expressCheckout：常驻订阅 expressAvailabilityChange，更新本地可用性快照。
+     *
+     * 该事件载荷不含 elementId；express 为单例（由 CheckoutInstance 保证），
+     * 故无需按 elementId 过滤。非 express 类型不订阅。
+     */
+    installExpressAvailability() {
+      if (this.type !== "expressCheckout") {
+        return;
+      }
+      const handler = (payload) => {
+        if (typeof payload !== "object" || payload === null) {
+          return;
+        }
+        const wallets = payload.availableWallets;
+        if (wallets) {
+          this.availableWallets = wallets;
+        }
+      };
+      this.availabilityHandler = handler;
+      this.transport.on("expressAvailabilityChange", handler);
+    }
+    /** 发送一条输入类动作命令（销毁后同步抛 INSTANCE_DESTROYED）。 */
+    sendAction(name) {
+      this.assertAlive();
+      return this.transport.request(name, { elementId: this.elementId }).then(() => void 0);
+    }
+    /** 若已销毁则抛 INSTANCE_DESTROYED。 */
+    assertAlive() {
+      if (this.status === "destroyed") {
+        throw makeError2(ErrorCode.INSTANCE_DESTROYED, "Checkout instance has been destroyed", this.elementId);
+      }
+    }
+    /** 解析挂载容器（选择器须唯一命中一个元素）。 */
+    resolveContainer(selectorOrEl) {
+      if (typeof selectorOrEl !== "string") {
+        return selectorOrEl;
+      }
+      const nodes = document.querySelectorAll(selectorOrEl);
+      if (nodes.length !== 1) {
+        return null;
+      }
+      const node = nodes[0];
+      return node instanceof HTMLElement ? node : null;
+    }
+    /**
+     * 解析 iframe src：拆分字段走 /sdk/field/，其余走 /sdk/element/，带 checkoutId 与 elementId；
+     * 若提供了初始 colorScheme，则追加 `&colorScheme=<值>`（首帧无闪）；
+     * 若初始 appearance 含 variables 或 rules，则追加
+     * `&appearance=<encodeURIComponent(JSON.stringify(appearance))>`（首帧即生效，无闪）。
+     * 仅含 colorScheme（无 variables/rules）的 appearance 不拼接，避免空外观串。
+     * 对 expressCheckout，另追加钱包开关 / 每钱包 buttonType / 全局 buttonHeight
+     * （见 {@link resolveExpressQuery}）。
+     *
+     * elementId 随 src 下发，供托管 child 在 iframe-resize 消息中原样回传，父窗口据此在
+     * 同页多个 iframe 间按句柄分发高度。
+     */
+    resolveSrc() {
+      const segment = FIELD_TYPES.includes(this.type) ? "field" : "element";
+      let query = `?checkoutId=${encodeURIComponent(this.checkoutId)}`;
+      query += `&elementId=${encodeURIComponent(this.elementId)}`;
+      if (this.colorScheme) {
+        query += `&colorScheme=${encodeURIComponent(this.colorScheme)}`;
+      }
+      if (this.appearance && (this.appearance.variables || this.appearance.rules)) {
+        query += `&appearance=${encodeURIComponent(JSON.stringify(this.appearance))}`;
+      }
+      if (this.type === "expressCheckout") {
+        query += this.resolveExpressQuery();
+      }
+      return `${this.hostOrigin}/sdk/${segment}/${this.type}${query}`;
+    }
+    /**
+     * 构造 expressCheckout 专属 query 片段（仅 expressCheckout 调用）：
+     * - 钱包显式置为 `false` → `&applePay=false` / `&googlePay=false`（强制隐藏，保持
+     *   既有开关语义；`true` / 缺省 → 自动，不拼开关）；
+     * - 钱包以对象形态配置且含 `buttonType` → `&applePayButtonType=<v>` /
+     *   `&googlePayButtonType=<v>`（布尔开关 / 缺省 → 不拼）；
+     * - 全局 `buttonHeight`（有限数）→ `&buttonHeight=<n>`。
+     *
+     * 仅在有值时拼接；不拼空串。本片段不触碰卡值，仅承载展示配置。
+     *
+     * @returns 以 `&` 起始的 query 片段（无可拼项时返回空串）。
+     */
+    resolveExpressQuery() {
+      const options = this.options;
+      if (!options) {
+        return "";
+      }
+      let query = "";
+      const applePay = options.paymentMethods?.applePay;
+      const googlePay = options.paymentMethods?.googlePay;
+      if (applePay === false) {
+        query += `&applePay=false`;
+      }
+      if (googlePay === false) {
+        query += `&googlePay=false`;
+      }
+      if (typeof applePay === "object" && applePay.buttonType) {
+        query += `&applePayButtonType=${encodeURIComponent(applePay.buttonType)}`;
+      }
+      if (typeof googlePay === "object" && googlePay.buttonType) {
+        query += `&googlePayButtonType=${encodeURIComponent(googlePay.buttonType)}`;
+      }
+      if (typeof options.buttonHeight === "number" && Number.isFinite(options.buttonHeight)) {
+        query += `&buttonHeight=${encodeURIComponent(String(options.buttonHeight))}`;
+      }
+      return query;
+    }
+    /**
+     * 安装 iframe 自适应高度监听：订阅 window 'message'，仅采信来自本 iframe
+     * `contentWindow` 且 origin === hostOrigin 的合法 {@link IframeResizeMessage}，
+     * 且 elementId 与本句柄匹配时，将外层 iframe 高度调整为内容真实高度（宽度保持 100%）。
+     *
+     * 安全：先校验 `event.source === iframe.contentWindow`（关键来源校验），
+     * 再校验 `event.origin === hostOrigin`（更严格的同源校验），防跨源伪造。
+     * 高度去重：与上次相同则跳过，避免冗余 style 写入。
+     */
+    installResizeListener() {
+      const handler = (event) => {
+        if (!this.iframe) {
+          return;
+        }
+        if (event.source !== this.iframe.contentWindow) {
+          return;
+        }
+        if (event.origin !== this.hostOrigin) {
+          return;
+        }
+        if (!isIframeResizeMessage(event.data)) {
+          return;
+        }
+        if (event.data.elementId !== this.elementId) {
+          return;
+        }
+        const { height } = event.data;
+        if (height === this.lastHeight) {
+          return;
+        }
+        this.lastHeight = height;
+        this.iframe.style.height = `${height}px`;
+      };
+      this.resizeHandler = handler;
+      window.addEventListener("message", handler);
+    }
+    /** 解绑 iframe 自适应高度监听并重置去重状态（幂等）。 */
+    teardownResizeListener() {
+      if (this.resizeHandler) {
+        window.removeEventListener("message", this.resizeHandler);
+        this.resizeHandler = null;
+      }
+      this.lastHeight = null;
+    }
+    /** 移除 iframe DOM 节点（若存在），并解绑自适应高度监听。 */
+    removeIframe() {
+      this.teardownResizeListener();
+      if (this.iframe && this.iframe.parentNode) {
+        this.iframe.parentNode.removeChild(this.iframe);
+      }
+      this.iframe = null;
+    }
+    /** 工厂：等价于 `new CheckoutElement(opts)`（供 CheckoutInstance 统一入口）。 */
+    static create(opts) {
+      return new _CheckoutElement(opts);
+    }
+  };
+
+  // src/CheckoutInstance.ts
+  var CARD_FIELD_TYPES = ["cardNumber", "cardExpiry", "cardCvc"];
+  function genId2(prefix) {
+    const rand = Math.random().toString(36).slice(2);
+    return `${prefix}_${Date.now().toString(36)}_${rand}`;
+  }
+  function makeError3(code, message, category = "configuration") {
+    return {
+      code,
+      message,
+      category,
+      errorId: genId2("err")
+    };
+  }
+  var CheckoutInstance = class {
+    constructor(opts) {
+      /** 已创建的 Element（按 elementId 索引）。 */
+      /**
+       * 互斥注册表的**单一数据源**：elementId → 已创建的 CheckoutElement。
+       * 互斥判定由本 Map 实时推导（见 {@link assertNoConflict}），元素 `destroy()` 经
+       * {@link releaseElement} 从本 Map 移除以释放名额（允许销毁后重建同类互斥 Element）。
+       */
+      this.elements = /* @__PURE__ */ new Map();
+      /** 当前未决 confirm（同一时刻至多一个）。 */
+      this.pendingConfirm = null;
+      this.destroyed = false;
+      this.checkoutId = opts.checkoutId;
+      this.runtimeId = opts.runtimeId;
+      this.capabilities = opts.capabilities;
+      this.hostOrigin = opts.hostOrigin;
+      this.transport = opts.transport;
+      this.session = opts.session;
+      this.appearance = opts.appearance;
+      this.paymentResultHandler = (payload) => {
+        this.handlePaymentResult(payload);
+      };
+      this.transport.on("paymentResult", this.paymentResultHandler);
+    }
+    /**
+     * 创建一个 Element 句柄（不自动挂载；互斥冲突抛 ELEMENT_CONFLICT）。
+     *
+     * 互斥规则（spec 6）：
+     * - 聚合 `card` 与任一拆分字段（cardNumber/cardExpiry/cardCvc）互斥。
+     * - 同 `mode`（billing/shipping）的 address 不可重复。
+     * - `expressCheckout` 单例。
+     *
+     * @param type - Element 类型。
+     * @param options - 初始 Element 配置。
+     * @returns 新建的 CheckoutElement。
+     * @throws 已销毁时抛 INSTANCE_DESTROYED；互斥冲突抛 ELEMENT_CONFLICT。
+     */
+    create(type, options) {
+      this.assertAlive();
+      this.assertNoConflict(type, options);
+      const elementId = genId2("el");
+      const elementOpts = {
+        elementId,
+        type,
+        hostOrigin: this.hostOrigin,
+        checkoutId: this.checkoutId,
+        transport: this.transport,
+        initialOptions: options,
+        colorScheme: this.appearance?.colorScheme,
+        appearance: this.appearance,
+        onDestroy: (id) => this.releaseElement(id)
+      };
+      const element = CheckoutElement.create(elementOpts);
+      this.elements.set(elementId, element);
+      return element;
+    }
+    /**
+     * 发起支付确认。生成 operationId，发 confirm 命令拿 accepted，返回的 Promise
+     * 由后续同 operationId 的 paymentResult 事件兑现。进行中再次调用 → CHECKOUT_BUSY。
+     *
+     * @param opts - 账单/配送地址、姓名、邮箱、returnUrl 等可选参数。
+     * @returns 支付终态结果 PaymentOutcome。
+     * @throws 已销毁时 reject INSTANCE_DESTROYED；进行中 reject CHECKOUT_BUSY。
+     */
+    confirm(opts) {
+      if (this.destroyed) {
+        return Promise.reject(
+          makeError3(ErrorCode.INSTANCE_DESTROYED, "Checkout instance has been destroyed", "runtime")
+        );
+      }
+      if (this.pendingConfirm) {
+        return Promise.reject(
+          makeError3(ErrorCode.CHECKOUT_BUSY, "A payment confirmation is already in progress", "runtime")
+        );
+      }
+      const operationId = genId2("op");
+      const payload = { ...opts, operationId };
+      return new Promise((resolve, reject) => {
+        this.pendingConfirm = { operationId, resolve, reject };
+        this.transport.request("confirm", payload).catch((err) => {
+          if (this.pendingConfirm && this.pendingConfirm.operationId === operationId) {
+            this.pendingConfirm = null;
+          }
+          reject(err);
+        });
+      });
+    }
+    /**
+     * 获取最新会话视图（透传 getSession 命令并写回本地快照）。
+     *
+     * @returns 最新 PublicSessionView。
+     * @throws 已销毁时 reject INSTANCE_DESTROYED。
+     */
+    async getSession() {
+      this.assertAlive();
+      const resp = await this.transport.request("getSession", {});
+      this.session = resp;
+      return resp;
+    }
+    /**
+     * 刷新会话（透传 refresh 命令并写回本地快照）。
+     *
+     * @returns 刷新后的 PublicSessionView。
+     * @throws 已销毁时 reject INSTANCE_DESTROYED。
+     */
+    async refresh() {
+      this.assertAlive();
+      const resp = await this.transport.request("refresh", {});
+      this.session = resp;
+      return resp;
+    }
+    /**
+     * 查询支付状态（原样返回 TxnStatus，不转义）。
+     *
+     * @returns txnStatus（可能含 txnId）。
+     * @throws 已销毁时 reject INSTANCE_DESTROYED。
+     */
+    async getPaymentStatus() {
+      this.assertAlive();
+      return await this.transport.request("getPaymentStatus", {});
+    }
+    /**
+     * 更新结账外观/语言（不改会话或金额）。
+     *
+     * @param patch - locale / appearance 增量。
+     * @throws 已销毁时 reject INSTANCE_DESTROYED。
+     */
+    async updateCheckout(patch) {
+      this.assertAlive();
+      const payload = patch;
+      await this.transport.request("updateCheckout", payload);
+    }
+    /**
+     * 注册 Checkout 级事件 handler（透传 transport）。
+     *
+     * @param event - 事件名。
+     * @param handler - 回调。
+     * @throws 已销毁时抛 INSTANCE_DESTROYED。
+     */
+    on(event, handler) {
+      this.assertAlive();
+      this.transport.on(event, handler);
+    }
+    /**
+     * 注销事件 handler（销毁后仍可安全调用）。
+     *
+     * @param event - 事件名。
+     * @param handler - 先前注册的回调。
+     */
+    off(event, handler) {
+      this.transport.off(event, handler);
+    }
+    /**
+     * 销毁实例：幂等。释放全部 Element、解绑 paymentResult 监听、以
+     * INSTANCE_DESTROYED reject 未决 confirm、发 destroy 命令并销毁 transport。
+     * 此后迟到的 paymentResult 一律忽略，不改写已结束的 Promise。
+     */
+    destroy() {
+      if (this.destroyed) {
+        return;
+      }
+      this.destroyed = true;
+      for (const element of this.elements.values()) {
+        element.destroy();
+      }
+      this.elements.clear();
+      this.transport.off("paymentResult", this.paymentResultHandler);
+      if (this.pendingConfirm) {
+        this.pendingConfirm.reject(
+          makeError3(ErrorCode.INSTANCE_DESTROYED, "Checkout instance has been destroyed", "runtime")
+        );
+        this.pendingConfirm = null;
+      }
+      void Promise.resolve(this.transport.request("destroy", {})).catch(() => void 0);
+      this.transport.destroy();
+    }
+    /** 若已销毁则抛 INSTANCE_DESTROYED。 */
+    assertAlive() {
+      if (this.destroyed) {
+        throw makeError3(ErrorCode.INSTANCE_DESTROYED, "Checkout instance has been destroyed", "runtime");
+      }
+    }
+    /** 互斥检查：冲突时抛 ELEMENT_CONFLICT（由 elements Map 实时推导，不改变注册表）。 */
+    assertNoConflict(type, options) {
+      const existing = [...this.elements.values()];
+      const has = (t) => existing.some((e) => e.type === t);
+      const hasCardField = () => existing.some((e) => CARD_FIELD_TYPES.includes(e.type));
+      if (type === "card") {
+        if (has("card")) {
+          throw makeError3(ErrorCode.ELEMENT_CONFLICT, "A combined card Element already exists");
+        }
+        if (hasCardField()) {
+          throw makeError3(
+            ErrorCode.ELEMENT_CONFLICT,
+            "Combined card and split card fields are mutually exclusive; split card fields already exist"
+          );
+        }
+        return;
+      }
+      if (CARD_FIELD_TYPES.includes(type)) {
+        if (has("card")) {
+          throw makeError3(
+            ErrorCode.ELEMENT_CONFLICT,
+            "Split card fields and combined card are mutually exclusive; a combined card already exists"
+          );
+        }
+        if (has(type)) {
+          throw makeError3(
+            ErrorCode.ELEMENT_CONFLICT,
+            `A split card field of type ${type} already exists`
+          );
+        }
+        return;
+      }
+      if (type === "address") {
+        const mode = options?.mode;
+        if (mode && existing.some((e) => e.type === "address" && e.mode === mode)) {
+          throw makeError3(
+            ErrorCode.ELEMENT_CONFLICT,
+            `An address Element with mode=${mode} already exists`
+          );
+        }
+        return;
+      }
+      if (type === "expressCheckout") {
+        if (has("expressCheckout")) {
+          throw makeError3(ErrorCode.ELEMENT_CONFLICT, "An expressCheckout Element already exists");
+        }
+        return;
+      }
+    }
+    /**
+     * 元素 `destroy()` 回调：从互斥注册表（elements Map）移除该 elementId，释放名额。
+     * 幂等；实例整体 destroy 时（已置 destroyed）走统一 `elements.clear()` 路径，此处 no-op，
+     * 避免遍历 elements 调 element.destroy() 时的并发修改。
+     */
+    releaseElement(elementId) {
+      if (this.destroyed) {
+        return;
+      }
+      this.elements.delete(elementId);
+    }
+    /** 处理 paymentResult 事件：按 operationId 兑现未决 confirm；迟到/不匹配忽略。 */
+    handlePaymentResult(payload) {
+      if (this.destroyed) {
+        return;
+      }
+      if (typeof payload !== "object" || payload === null) {
+        return;
+      }
+      const evt = payload;
+      const pending = this.pendingConfirm;
+      if (!pending) {
+        return;
+      }
+      if (evt.operationId !== pending.operationId) {
+        return;
+      }
+      if (!evt.outcome) {
+        return;
+      }
+      this.pendingConfirm = null;
+      pending.resolve(evt.outcome);
+    }
+  };
+
+  // src/config/env.ts
+  var HOST_ORIGINS = {
+    dev: "https://checkout.sunbay-dev.com",
+    prod: "https://checkout.sunbay.us"
+  };
+  function resolveHostOrigin(env = "dev", override) {
+    if (override) {
+      return override;
+    }
+    return HOST_ORIGINS[env];
+  }
+
+  // src/createCheckout.ts
+  var HANDSHAKE_TIMEOUT_MS = 15e3;
+  function genId3(prefix) {
+    const rand = Math.random().toString(36).slice(2);
+    return `${prefix}_${Date.now().toString(36)}_${rand}`;
+  }
+  function makeError4(code, message) {
+    return {
+      code,
+      message,
+      category: "runtime",
+      errorId: genId3("err")
+    };
+  }
+  var defaultTransportFactory = ({ checkoutId, hostOrigin }) => new MainFrameTransport({ checkoutId, hostOrigin });
+  async function createCheckout(opts) {
+    const checkoutId = genId3("co");
+    const hostOrigin = resolveHostOrigin(opts.env, opts.hostOrigin);
+    const factory = opts.__transportFactory ?? defaultTransportFactory;
+    const transport = factory({ checkoutId, hostOrigin });
+    transport.createHiddenIframe();
+    let hello;
+    try {
+      hello = await waitForHello(transport);
+    } catch (err) {
+      transport.destroy();
+      throw err;
+    }
+    if (!hello.supportedMajorVersions.includes(PROTOCOL_MAJOR)) {
+      transport.destroy();
+      throw makeError4(
+        ErrorCode.PROTOCOL_UNSUPPORTED,
+        `No common major protocol version: SDK=${PROTOCOL_MAJOR}, runtime=${JSON.stringify(hello.supportedMajorVersions)}`
+      );
+    }
+    transport.setRuntimeId(hello.runtimeId);
+    const initReq = {
+      sessionId: opts.sessionId,
+      locale: opts.locale,
+      appearance: opts.appearance,
+      paymentMethods: opts.paymentMethods
+    };
+    let initResp;
+    try {
+      initResp = await transport.request("initialize", initReq);
+    } catch (err) {
+      transport.destroy();
+      throw err;
+    }
+    return new CheckoutInstance({
+      checkoutId,
+      runtimeId: hello.runtimeId,
+      hostOrigin,
+      transport,
+      capabilities: initResp.capabilities,
+      session: initResp.session,
+      appearance: opts.appearance
+    });
+  }
+  function waitForHello(transport) {
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const timer = setTimeout(() => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        reject(makeError4(ErrorCode.RUNTIME_LOAD_FAILED, "Timed out waiting for hosted runtime handshake"));
+      }, HANDSHAKE_TIMEOUT_MS);
+      transport.onHello((raw) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        clearTimeout(timer);
+        resolve(raw);
+      });
+    });
+  }
+
+  // src/index.ts
+  if (typeof window !== "undefined") {
+    const w = window;
+    w.SunbayCheckout = { ...w.SunbayCheckout ?? {}, createCheckout };
+  }
+  var version = true ? "0.0.2" : "0.0.0";
+  return __toCommonJS(index_exports);
+})();
+//# sourceMappingURL=index.global.js.map