@youidian/sdk 3.1.0 → 3.2.0

package/dist/client.cjs

@@ -22,12 +22,92 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 // src/client.ts
 var client_exports = {};
 __export(client_exports, {
+  LoginUI: () => LoginUI,
   PaymentUI: () => PaymentUI,
-  createPaymentUI: () => createPaymentUI
+  createLoginUI: () => createLoginUI,
+  createPaymentUI: () => createPaymentUI,
+  handleLoginCallbackIfPresent: () => handleLoginCallbackIfPresent
 });
 module.exports = __toCommonJS(client_exports);
 
 // src/hosted-modal.ts
+var SDK_SUPPORTED_LOCALES = [
+  "en",
+  "zh-CN",
+  "zh-Hant",
+  "fr",
+  "de",
+  "ja",
+  "es",
+  "ko",
+  "nl",
+  "it",
+  "pt"
+];
+var SDK_DEFAULT_LOCALE = "zh-CN";
+var SDK_LOCALE_ALIASES = {
+  en: "en",
+  "en-us": "en",
+  "en-gb": "en",
+  zh: "zh-CN",
+  "zh-cn": "zh-CN",
+  "zh-tw": "zh-Hant",
+  "zh-hk": "zh-Hant",
+  "zh-hant": "zh-Hant",
+  "zh-hans": "zh-CN",
+  fr: "fr",
+  de: "de",
+  ja: "ja",
+  es: "es",
+  ko: "ko",
+  nl: "nl",
+  it: "it",
+  pt: "pt"
+};
+function matchSupportedBaseLocale(locale) {
+  const base = locale.toLowerCase().split("-")[0];
+  return SDK_SUPPORTED_LOCALES.find((item) => item.toLowerCase() === base);
+}
+function normalizeSdkLocale(locale) {
+  if (!locale) return;
+  const sanitized = locale.trim().replace(/_/g, "-");
+  if (!sanitized) return;
+  const lower = sanitized.toLowerCase();
+  if (SDK_LOCALE_ALIASES[lower]) {
+    return SDK_LOCALE_ALIASES[lower];
+  }
+  let canonical;
+  try {
+    canonical = Intl.getCanonicalLocales(sanitized)[0];
+  } catch {
+    canonical = void 0;
+  }
+  const candidates = [canonical, sanitized].filter(Boolean);
+  for (const candidate of candidates) {
+    const candidateLower = candidate.toLowerCase();
+    if (SDK_LOCALE_ALIASES[candidateLower]) {
+      return SDK_LOCALE_ALIASES[candidateLower];
+    }
+    if (SDK_SUPPORTED_LOCALES.includes(candidate)) {
+      return candidate;
+    }
+    const baseMatch = matchSupportedBaseLocale(candidate);
+    if (baseMatch) {
+      return baseMatch;
+    }
+  }
+}
+function getBrowserLocale() {
+  if (typeof navigator === "undefined") return;
+  for (const candidate of navigator.languages || []) {
+    const normalized = normalizeSdkLocale(candidate);
+    if (normalized) return normalized;
+  }
+  return normalizeSdkLocale(navigator.language);
+}
+function getAutoResolvedLocale(locale) {
+  return normalizeSdkLocale(locale) || getBrowserLocale() || SDK_DEFAULT_LOCALE;
+}
 function applyLocaleToUrl(urlValue, locale) {
   if (!locale) return urlValue;
   try {
@@ -147,6 +227,468 @@ var HostedFrameModal = class {
   }
 };
 
+// src/login.ts
+function getOrigin(value) {
+  if (!value) return null;
+  try {
+    return new URL(value).origin;
+  } catch {
+    return null;
+  }
+}
+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 = launchPayload.origin;
+  let finalUrl;
+  try {
+    const url = new URL(rawBase);
+    if (!/\/auth\/connect\/[^/]+$/.test(url.pathname)) {
+      url.pathname = `${url.pathname.replace(/\/$/, "")}/auth/connect/${appId}`.replace(
+        /\/{2,}/g,
+        "/"
+      );
+    }
+    finalUrl = url.toString();
+  } catch (_error) {
+    if (/\/auth\/connect\/[^/]+$/.test(rawBase)) {
+      finalUrl = rawBase;
+    } else {
+      finalUrl = `${rawBase}/auth/connect/${appId}`.replace(/\/{2,}/g, "/");
+    }
+  }
+  finalUrl = applyLocaleToUrl(finalUrl, getAutoResolvedLocale(params.locale));
+  try {
+    const url = new URL(finalUrl);
+    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);
+    }
+    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 appendLoginLaunchHash(finalUrl, launchPayload);
+    }
+    const separator = finalUrl.includes("?") ? "&" : "?";
+    return appendLoginLaunchHash(
+      `${finalUrl}${separator}${query}`,
+      launchPayload
+    );
+  }
+}
+function extractLoginResult(data) {
+  return {
+    avatar: data.avatar,
+    channel: data.channel,
+    email: data.email,
+    expiresAt: data.expiresAt,
+    legacyCasdoorId: data.legacyCasdoorId,
+    loginToken: data.loginToken,
+    name: data.name,
+    userId: data.userId,
+    wechatOpenId: data.wechatOpenId,
+    wechatUnionId: data.wechatUnionId
+  };
+}
+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 || {});
+}
+function logLoginInfo(message, details) {
+  if (typeof console === "undefined") return;
+  console.info(LOGIN_UI_LOG_PREFIX, message, details || {});
+}
+function logLoginWarn(message, details) {
+  if (typeof console === "undefined") return;
+  console.warn(LOGIN_UI_LOG_PREFIX, 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);
+    }
+    this.messageHandler = null;
+    this.closeMonitor = null;
+    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),
+      popupClosed: this.popup?.closed ?? true
+    });
+    if (this.popup && !this.popup.closed) {
+      this.popup.close();
+    }
+    this.cleanup();
+  }
+  openLogin(params, options) {
+    if (typeof window === "undefined") return;
+    if (this.popup && !this.popup.closed) return;
+    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,
+      allowedOrigin: options?.allowedOrigin || null,
+      autoClose: options?.autoClose ?? true
+    });
+    const popupWidth = 520;
+    const popupHeight = 720;
+    const left = Math.max(
+      0,
+      Math.round(window.screenX + (window.outerWidth - popupWidth) / 2)
+    );
+    const top = Math.max(
+      0,
+      Math.round(window.screenY + (window.outerHeight - popupHeight) / 2)
+    );
+    const features = [
+      "popup=yes",
+      `width=${popupWidth}`,
+      `height=${popupHeight}`,
+      `left=${left}`,
+      `top=${top}`,
+      "resizable=yes",
+      "scrollbars=yes"
+    ].join(",");
+    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");
+      return;
+    }
+    this.popup = popup;
+    this.completed = false;
+    this.listenForLoginCallback(callbackState, options);
+    const allowedOrigin = options?.allowedOrigin;
+    const popupOrigin = getOrigin(finalUrl);
+    this.messageHandler = (event) => {
+      if (allowedOrigin && allowedOrigin !== "*" && event.origin !== allowedOrigin) {
+        logLoginWarn("Ignored message due to allowedOrigin mismatch", {
+          allowedOrigin,
+          eventOrigin: event.origin
+        });
+        return;
+      }
+      if (!allowedOrigin && popupOrigin && event.origin !== popupOrigin) {
+        logLoginWarn("Ignored message due to popup origin mismatch", {
+          expectedOrigin: popupOrigin,
+          eventOrigin: event.origin
+        });
+        return;
+      }
+      const data = event.data;
+      if (!data || typeof data !== "object" || !data.type) {
+        logLoginDebug("Ignored non-login postMessage payload");
+        return;
+      }
+      logLoginInfo("Received login event", {
+        type: data.type,
+        eventOrigin: event.origin
+      });
+      this.handleLoginEvent(data, options);
+    };
+    window.addEventListener("message", this.messageHandler);
+    this.closeMonitor = window.setInterval(() => {
+      if (!this.popup || this.popup.closed) {
+        const shouldTreatAsCancel = !this.completed;
+        logLoginInfo("Detected popup closed", {
+          shouldTreatAsCancel
+        });
+        this.cleanup();
+        if (shouldTreatAsCancel) {
+          options?.onCancel?.();
+        }
+        options?.onClose?.();
+      }
+    }, 500);
+  }
+};
+function createLoginUI() {
+  return new LoginUI();
+}
+handleLoginCallbackIfPresent();
+
 // src/client.ts
 var PaymentUI = class extends HostedFrameModal {
   /**
@@ -257,7 +799,10 @@ function createPaymentUI() {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  LoginUI,
   PaymentUI,
-  createPaymentUI
+  createLoginUI,
+  createPaymentUI,
+  handleLoginCallbackIfPresent
 });
 //# sourceMappingURL=client.cjs.map