@youidian/sdk 3.1.0 → 3.2.0

package/dist/index.cjs

@@ -36,7 +36,8 @@ __export(src_exports, {
   PaymentClient: () => PaymentClient,
   PaymentUI: () => PaymentUI,
   createLoginUI: () => createLoginUI,
-  createPaymentUI: () => createPaymentUI
+  createPaymentUI: () => createPaymentUI,
+  handleLoginCallbackIfPresent: () => handleLoginCallbackIfPresent
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -237,115 +238,6 @@ var HostedFrameModal = class {
   }
 };
 
-// src/client.ts
-var PaymentUI = class extends HostedFrameModal {
-  /**
-   * Opens the payment checkout page in an iframe modal.
-   * @param urlOrParams - The checkout page URL or payment parameters
-   * @param options - UI options
-   */
-  openPayment(urlOrParams, options) {
-    if (typeof document === "undefined") return;
-    if (this.modal) return;
-    let checkoutUrl;
-    if (typeof urlOrParams === "string") {
-      checkoutUrl = urlOrParams;
-    } else {
-      const {
-        appId,
-        productId,
-        priceId,
-        productCode,
-        userId,
-        checkoutUrl: checkoutUrlParam,
-        baseUrl = "https://pay.imgto.link"
-      } = urlOrParams;
-      const base = (checkoutUrlParam || baseUrl).replace(/\/$/, "");
-      if (productCode) {
-        checkoutUrl = `${base}/checkout/${appId}/code/${productCode}?userId=${encodeURIComponent(userId)}`;
-      } else if (productId && priceId) {
-        checkoutUrl = `${base}/checkout/${appId}/${productId}/${priceId}?userId=${encodeURIComponent(userId)}`;
-      } else {
-        throw new Error(
-          "Either productCode or both productId and priceId are required"
-        );
-      }
-    }
-    const finalUrl = applyLocaleToUrl(checkoutUrl, options?.locale);
-    this.openHostedFrame(finalUrl, {
-      allowedOrigin: options?.allowedOrigin,
-      onCloseButton: () => options?.onCancel?.(),
-      onMessage: (data, container) => {
-        switch (data.type) {
-          case "PAYMENT_SUCCESS":
-            options?.onSuccess?.(data.orderId);
-            break;
-          case "PAYMENT_CANCELLED":
-            options?.onCancel?.(data.orderId);
-            break;
-          case "PAYMENT_RESIZE":
-            if (data.height) {
-              const maxHeight = window.innerHeight * 0.9;
-              const newHeight = Math.min(data.height, maxHeight);
-              container.style.height = `${newHeight}px`;
-            }
-            break;
-          case "PAYMENT_CLOSE":
-            this.close();
-            options?.onClose?.();
-            break;
-        }
-      }
-    });
-  }
-  /**
-   * Poll order status from integrator's API endpoint
-   * @param statusUrl - The integrator's API endpoint to check order status
-   * @param options - Polling options
-   * @returns Promise that resolves when order is paid or rejects on timeout/failure
-   */
-  async pollOrderStatus(statusUrl, options) {
-    const interval = options?.interval || 3e3;
-    const timeout = options?.timeout || 3e5;
-    const startTime = Date.now();
-    return new Promise((resolve, reject) => {
-      const poll = async () => {
-        try {
-          const response = await fetch(statusUrl);
-          if (!response.ok) {
-            throw new Error(`Status check failed: ${response.status}`);
-          }
-          const status = await response.json();
-          options?.onStatusChange?.(status);
-          if (status.status === "PAID") {
-            resolve(status);
-            return;
-          }
-          if (status.status === "CANCELLED" || status.status === "FAILED") {
-            reject(new Error(`Order ${status.status.toLowerCase()}`));
-            return;
-          }
-          if (Date.now() - startTime > timeout) {
-            reject(new Error("Polling timeout"));
-            return;
-          }
-          setTimeout(poll, interval);
-        } catch (error) {
-          if (Date.now() - startTime > timeout) {
-            reject(error);
-            return;
-          }
-          setTimeout(poll, interval);
-        }
-      };
-      poll();
-    });
-  }
-};
-function createPaymentUI() {
-  return new PaymentUI();
-}
-
 // src/login.ts
 function getOrigin(value) {
   if (!value) return null;
@@ -355,10 +247,70 @@ function getOrigin(value) {
     return null;
   }
 }
-function buildLoginUrl(params) {
+function createLoginCallbackState() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID().replace(/-/g, "");
+  }
+  return `${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`;
+}
+function buildLoginCallbackUrl(callbackState, callbackUrl) {
+  const baseUrl = callbackUrl || window.location.href;
+  const url = new URL(baseUrl, window.location.href);
+  const returnHash = url.hash.replace(/^#/, "");
+  url.hash = "";
+  url.searchParams.set(LOGIN_CALLBACK_MARKER, "1");
+  url.searchParams.set(LOGIN_CALLBACK_STATE_PARAM, callbackState);
+  if (returnHash) {
+    url.searchParams.set(LOGIN_CALLBACK_RETURN_HASH_PARAM, returnHash);
+  } else {
+    url.searchParams.delete(LOGIN_CALLBACK_RETURN_HASH_PARAM);
+  }
+  return url.toString();
+}
+function buildLoginLaunchPayload(params, options, callbackState) {
+  const parentOrigin = typeof window !== "undefined" ? window.location.origin : void 0;
+  const callbackUrl = typeof window !== "undefined" && callbackState ? buildLoginCallbackUrl(callbackState, options?.callbackUrl) : void 0;
+  return {
+    autoClose: options?.autoClose ?? true,
+    callbackUrl,
+    callbackState,
+    origin: parentOrigin,
+    preferredChannel: params.preferredChannel
+  };
+}
+function appendLoginLaunchHash(urlValue, payload) {
+  const hashParams = new URLSearchParams();
+  if (payload.autoClose === false) {
+    hashParams.set("ydAutoClose", "false");
+  }
+  if (payload.origin) {
+    hashParams.set("ydOrigin", payload.origin);
+  }
+  if (payload.callbackUrl) {
+    hashParams.set("ydCallbackUrl", payload.callbackUrl);
+  }
+  if (payload.preferredChannel) {
+    hashParams.set("ydPreferredChannel", payload.preferredChannel);
+  }
+  const hash = hashParams.toString();
+  if (!hash) {
+    return urlValue;
+  }
+  try {
+    const url = new URL(urlValue);
+    url.hash = hash;
+    return url.toString();
+  } catch (_error) {
+    return `${urlValue}#${hash}`;
+  }
+}
+function buildLoginPopupName(payload) {
+  return `youidian-login:${JSON.stringify(payload)}`;
+}
+function buildLoginUrl(params, options, launchPayload) {
   const { appId, baseUrl = "https://pay.imgto.link", loginUrl } = params;
   const rawBase = (loginUrl || baseUrl).replace(/\/$/, "");
-  const parentOrigin = typeof window !== "undefined" ? window.location.origin : void 0;
+  const parentOrigin = launchPayload.origin;
   let finalUrl;
   try {
     const url = new URL(rawBase);
@@ -382,24 +334,39 @@ function buildLoginUrl(params) {
     if (params.preferredChannel) {
       url.searchParams.set("preferredChannel", params.preferredChannel);
     }
+    if (options?.autoClose === false) {
+      url.searchParams.set("autoClose", "false");
+    }
     if (parentOrigin) {
       url.searchParams.set("origin", parentOrigin);
     }
-    return url.toString();
+    if (launchPayload.callbackUrl) {
+      url.searchParams.set("callbackUrl", launchPayload.callbackUrl);
+    }
+    return appendLoginLaunchHash(url.toString(), launchPayload);
   } catch (_error) {
     const searchParams = new URLSearchParams();
     if (params.preferredChannel) {
       searchParams.set("preferredChannel", params.preferredChannel);
     }
+    if (options?.autoClose === false) {
+      searchParams.set("autoClose", "false");
+    }
     if (parentOrigin) {
       searchParams.set("origin", parentOrigin);
     }
+    if (launchPayload.callbackUrl) {
+      searchParams.set("callbackUrl", launchPayload.callbackUrl);
+    }
     const query = searchParams.toString();
     if (!query) {
-      return finalUrl;
+      return appendLoginLaunchHash(finalUrl, launchPayload);
     }
     const separator = finalUrl.includes("?") ? "&" : "?";
-    return `${finalUrl}${separator}${query}`;
+    return appendLoginLaunchHash(
+      `${finalUrl}${separator}${query}`,
+      launchPayload
+    );
   }
 }
 function extractLoginResult(data) {
@@ -417,6 +384,102 @@ function extractLoginResult(data) {
   };
 }
 var LOGIN_UI_LOG_PREFIX = "[Youidian LoginUI]";
+var LOGIN_CALLBACK_MARKER = "yd_login_callback";
+var LOGIN_CALLBACK_RESULT_PARAM = "yd_login_result";
+var LOGIN_CALLBACK_RETURN_HASH_PARAM = "yd_login_return_hash";
+var LOGIN_CALLBACK_STATE_PARAM = "yd_login_state";
+var LOGIN_CALLBACK_STORAGE_PREFIX = "yd-login-callback:";
+function decodeCallbackPayload(value) {
+  try {
+    const padded = value.padEnd(
+      value.length + (4 - value.length % 4) % 4,
+      "="
+    );
+    const base64 = padded.replaceAll("-", "+").replaceAll("_", "/");
+    const binary = atob(base64);
+    const json = decodeURIComponent(
+      Array.from(
+        binary,
+        (char) => `%${char.charCodeAt(0).toString(16).padStart(2, "0")}`
+      ).join("")
+    );
+    const parsed = JSON.parse(json);
+    return parsed && typeof parsed === "object" && parsed.type ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function getLoginCallbackChannelName(state) {
+  return `youidian-login:${state}`;
+}
+function getLoginCallbackStorageKey(state) {
+  return `${LOGIN_CALLBACK_STORAGE_PREFIX}${state}`;
+}
+function publishLoginCallback(state, data) {
+  try {
+    const channel = new BroadcastChannel(getLoginCallbackChannelName(state));
+    channel.postMessage(data);
+    channel.close();
+  } catch {
+  }
+  try {
+    const storageKey = getLoginCallbackStorageKey(state);
+    window.localStorage.setItem(storageKey, JSON.stringify(data));
+    window.setTimeout(() => {
+      try {
+        window.localStorage.removeItem(storageKey);
+      } catch {
+      }
+    }, 800);
+  } catch {
+  }
+  try {
+    window.opener?.postMessage(data, window.location.origin);
+  } catch {
+  }
+}
+function cleanLoginCallbackUrl(url) {
+  url.searchParams.delete(LOGIN_CALLBACK_MARKER);
+  url.searchParams.delete(LOGIN_CALLBACK_STATE_PARAM);
+  const returnHash = url.searchParams.get(LOGIN_CALLBACK_RETURN_HASH_PARAM);
+  url.searchParams.delete(LOGIN_CALLBACK_RETURN_HASH_PARAM);
+  url.hash = returnHash ? `#${returnHash}` : "";
+  return url.toString();
+}
+function handleLoginCallbackIfPresent() {
+  if (typeof window === "undefined") {
+    return false;
+  }
+  const url = new URL(window.location.href);
+  if (url.searchParams.get(LOGIN_CALLBACK_MARKER) !== "1") {
+    return false;
+  }
+  const state = url.searchParams.get(LOGIN_CALLBACK_STATE_PARAM) || "";
+  const hashParams = new URLSearchParams(url.hash.replace(/^#/, ""));
+  const rawResult = hashParams.get(LOGIN_CALLBACK_RESULT_PARAM);
+  const data = rawResult && state ? decodeCallbackPayload(rawResult) : {
+    type: "LOGIN_ERROR",
+    message: "Missing login callback result"
+  };
+  try {
+    document.documentElement.style.visibility = "hidden";
+  } catch {
+  }
+  if (state && data) {
+    publishLoginCallback(state, data);
+  }
+  try {
+    window.history.replaceState(null, "", cleanLoginCallbackUrl(url));
+  } catch {
+  }
+  window.setTimeout(() => {
+    try {
+      window.close();
+    } catch {
+    }
+  }, 30);
+  return true;
+}
 function logLoginDebug(message, details) {
   if (typeof console === "undefined") return;
   console.debug(LOGIN_UI_LOG_PREFIX, message, details || {});
@@ -432,14 +495,24 @@ function logLoginWarn(message, details) {
 var LoginUI = class {
   constructor() {
     __publicField(this, "popup", null);
+    __publicField(this, "callbackChannel", null);
+    __publicField(this, "callbackStorageHandler", null);
     __publicField(this, "messageHandler", null);
     __publicField(this, "closeMonitor", null);
     __publicField(this, "completed", false);
   }
   cleanup() {
+    if (this.callbackChannel) {
+      this.callbackChannel.close();
+    }
+    if (typeof window !== "undefined" && this.callbackStorageHandler) {
+      window.removeEventListener("storage", this.callbackStorageHandler);
+    }
     if (typeof window !== "undefined" && this.messageHandler) {
       window.removeEventListener("message", this.messageHandler);
     }
+    this.callbackChannel = null;
+    this.callbackStorageHandler = null;
     if (typeof window !== "undefined" && this.closeMonitor) {
       window.clearInterval(this.closeMonitor);
     }
@@ -448,6 +521,81 @@ var LoginUI = class {
     this.popup = null;
     this.completed = false;
   }
+  handleLoginEvent(data, options) {
+    if (!data || typeof data !== "object" || !data.type) {
+      logLoginDebug("Ignored non-login event payload");
+      return;
+    }
+    logLoginInfo("Received login event", {
+      type: data.type
+    });
+    switch (data.type) {
+      case "LOGIN_SUCCESS":
+        if (this.completed) {
+          break;
+        }
+        this.completed = true;
+        logLoginInfo("Login succeeded", {
+          channel: data.channel || null,
+          userId: data.userId || null
+        });
+        options?.onSuccess?.(extractLoginResult(data));
+        break;
+      case "LOGIN_CANCELLED":
+        logLoginInfo("Login cancelled");
+        options?.onCancel?.();
+        break;
+      case "LOGIN_RESIZE":
+        break;
+      case "LOGIN_ERROR":
+        if (this.completed) {
+          break;
+        }
+        logLoginWarn("Login flow reported an error", {
+          message: data.message || data.error || null
+        });
+        options?.onError?.(data.message || data.error, data);
+        break;
+      case "LOGIN_CLOSE":
+        if (options?.autoClose === false) {
+          logLoginInfo(
+            "Login popup requested close; autoClose disabled, keeping popup open"
+          );
+          options?.onClose?.();
+          break;
+        }
+        logLoginInfo("Login popup requested close; autoClose enabled");
+        this.close();
+        options?.onClose?.();
+        break;
+    }
+  }
+  listenForLoginCallback(callbackState, options) {
+    try {
+      this.callbackChannel = new BroadcastChannel(
+        getLoginCallbackChannelName(callbackState)
+      );
+      this.callbackChannel.onmessage = (event) => {
+        this.handleLoginEvent(event.data, options);
+        this.handleLoginEvent({ type: "LOGIN_CLOSE" }, options);
+      };
+    } catch {
+      logLoginDebug("BroadcastChannel is unavailable for login callback");
+    }
+    this.callbackStorageHandler = (event) => {
+      if (event.key !== getLoginCallbackStorageKey(callbackState) || !event.newValue) {
+        return;
+      }
+      try {
+        const data = JSON.parse(event.newValue);
+        this.handleLoginEvent(data, options);
+        this.handleLoginEvent({ type: "LOGIN_CLOSE" }, options);
+      } catch {
+        logLoginWarn("Failed to parse login callback storage payload");
+      }
+    };
+    window.addEventListener("storage", this.callbackStorageHandler);
+  }
   close() {
     logLoginInfo("close() called", {
       hasPopup: Boolean(this.popup),
@@ -461,7 +609,13 @@ var LoginUI = class {
   openLogin(params, options) {
     if (typeof window === "undefined") return;
     if (this.popup && !this.popup.closed) return;
-    const finalUrl = buildLoginUrl(params);
+    const callbackState = createLoginCallbackState();
+    const launchPayload = buildLoginLaunchPayload(
+      params,
+      options,
+      callbackState
+    );
+    const finalUrl = buildLoginUrl(params, options, launchPayload);
     logLoginInfo("Opening hosted login popup", {
       appId: params.appId,
       loginUrl: finalUrl,
@@ -487,7 +641,8 @@ var LoginUI = class {
       "resizable=yes",
       "scrollbars=yes"
     ].join(",");
-    const popup = window.open(finalUrl, "youidian-login", features);
+    const popupName = buildLoginPopupName(launchPayload);
+    const popup = window.open(finalUrl, popupName, features);
     if (!popup) {
       logLoginWarn("Popup blocked by the browser");
       options?.onError?.("Login popup was blocked");
@@ -495,6 +650,7 @@ var LoginUI = class {
     }
     this.popup = popup;
     this.completed = false;
+    this.listenForLoginCallback(callbackState, options);
     const allowedOrigin = options?.allowedOrigin;
     const popupOrigin = getOrigin(finalUrl);
     this.messageHandler = (event) => {
@@ -521,38 +677,7 @@ var LoginUI = class {
         type: data.type,
         eventOrigin: event.origin
       });
-      switch (data.type) {
-        case "LOGIN_SUCCESS":
-          this.completed = true;
-          logLoginInfo("Login succeeded", {
-            channel: data.channel || null,
-            userId: data.userId || null
-          });
-          options?.onSuccess?.(extractLoginResult(data));
-          break;
-        case "LOGIN_CANCELLED":
-          logLoginInfo("Login cancelled");
-          options?.onCancel?.();
-          break;
-        case "LOGIN_RESIZE":
-          break;
-        case "LOGIN_ERROR":
-          logLoginWarn("Login flow reported an error", {
-            message: data.message || data.error || null
-          });
-          options?.onError?.(data.message || data.error, data);
-          break;
-        case "LOGIN_CLOSE":
-          if (options?.autoClose === false) {
-            logLoginInfo("Login popup requested close; autoClose disabled, keeping popup open");
-            options?.onClose?.();
-            break;
-          }
-          logLoginInfo("Login popup requested close; autoClose enabled");
-          this.close();
-          options?.onClose?.();
-          break;
-      }
+      this.handleLoginEvent(data, options);
     };
     window.addEventListener("message", this.messageHandler);
     this.closeMonitor = window.setInterval(() => {
@@ -573,6 +698,116 @@ var LoginUI = class {
 function createLoginUI() {
   return new LoginUI();
 }
+handleLoginCallbackIfPresent();
+
+// src/client.ts
+var PaymentUI = class extends HostedFrameModal {
+  /**
+   * Opens the payment checkout page in an iframe modal.
+   * @param urlOrParams - The checkout page URL or payment parameters
+   * @param options - UI options
+   */
+  openPayment(urlOrParams, options) {
+    if (typeof document === "undefined") return;
+    if (this.modal) return;
+    let checkoutUrl;
+    if (typeof urlOrParams === "string") {
+      checkoutUrl = urlOrParams;
+    } else {
+      const {
+        appId,
+        productId,
+        priceId,
+        productCode,
+        userId,
+        checkoutUrl: checkoutUrlParam,
+        baseUrl = "https://pay.imgto.link"
+      } = urlOrParams;
+      const base = (checkoutUrlParam || baseUrl).replace(/\/$/, "");
+      if (productCode) {
+        checkoutUrl = `${base}/checkout/${appId}/code/${productCode}?userId=${encodeURIComponent(userId)}`;
+      } else if (productId && priceId) {
+        checkoutUrl = `${base}/checkout/${appId}/${productId}/${priceId}?userId=${encodeURIComponent(userId)}`;
+      } else {
+        throw new Error(
+          "Either productCode or both productId and priceId are required"
+        );
+      }
+    }
+    const finalUrl = applyLocaleToUrl(checkoutUrl, options?.locale);
+    this.openHostedFrame(finalUrl, {
+      allowedOrigin: options?.allowedOrigin,
+      onCloseButton: () => options?.onCancel?.(),
+      onMessage: (data, container) => {
+        switch (data.type) {
+          case "PAYMENT_SUCCESS":
+            options?.onSuccess?.(data.orderId);
+            break;
+          case "PAYMENT_CANCELLED":
+            options?.onCancel?.(data.orderId);
+            break;
+          case "PAYMENT_RESIZE":
+            if (data.height) {
+              const maxHeight = window.innerHeight * 0.9;
+              const newHeight = Math.min(data.height, maxHeight);
+              container.style.height = `${newHeight}px`;
+            }
+            break;
+          case "PAYMENT_CLOSE":
+            this.close();
+            options?.onClose?.();
+            break;
+        }
+      }
+    });
+  }
+  /**
+   * Poll order status from integrator's API endpoint
+   * @param statusUrl - The integrator's API endpoint to check order status
+   * @param options - Polling options
+   * @returns Promise that resolves when order is paid or rejects on timeout/failure
+   */
+  async pollOrderStatus(statusUrl, options) {
+    const interval = options?.interval || 3e3;
+    const timeout = options?.timeout || 3e5;
+    const startTime = Date.now();
+    return new Promise((resolve, reject) => {
+      const poll = async () => {
+        try {
+          const response = await fetch(statusUrl);
+          if (!response.ok) {
+            throw new Error(`Status check failed: ${response.status}`);
+          }
+          const status = await response.json();
+          options?.onStatusChange?.(status);
+          if (status.status === "PAID") {
+            resolve(status);
+            return;
+          }
+          if (status.status === "CANCELLED" || status.status === "FAILED") {
+            reject(new Error(`Order ${status.status.toLowerCase()}`));
+            return;
+          }
+          if (Date.now() - startTime > timeout) {
+            reject(new Error("Polling timeout"));
+            return;
+          }
+          setTimeout(poll, interval);
+        } catch (error) {
+          if (Date.now() - startTime > timeout) {
+            reject(error);
+            return;
+          }
+          setTimeout(poll, interval);
+        }
+      };
+      poll();
+    });
+  }
+};
+function createPaymentUI() {
+  return new PaymentUI();
+}
 
 // src/server.ts
 var import_crypto = __toESM(require("crypto"), 1);
@@ -830,6 +1065,7 @@ var PaymentClient = class {
   PaymentClient,
   PaymentUI,
   createLoginUI,
-  createPaymentUI
+  createPaymentUI,
+  handleLoginCallbackIfPresent
 });
 //# sourceMappingURL=index.cjs.map