xtj-login-kit 0.3.1

package/dist/chunks/index-Cuix-7nW.js

@@ -0,0 +1,949 @@
+class AuthError extends Error {
+  constructor(code, message, details = void 0) {
+    super(message);
+    this.name = "AuthError";
+    this.code = code;
+    this.details = details;
+  }
+}
+const publicCode = (error) => {
+  if (error?.code === "INVALID_APP_CODE") return "INVALID_APP_CODE";
+  if (error?.code === "INVALID_GATEWAY_CONFIG") return "INVALID_GATEWAY_CONFIG";
+  if (error?.code === "TIMEOUT") return "TIMEOUT";
+  if (error?.code === "DUPLICATE_INSTANCE") return "DUPLICATE_INSTANCE";
+  if (error?.code === "UNSUPPORTED_ENVIRONMENT") return "UNSUPPORTED_ENVIRONMENT";
+  if (error?.code === "NETWORK_ERROR") return "NETWORK_ERROR";
+  if (error?.code?.startsWith?.("GATEWAY")) return "GATEWAY_ERROR";
+  return "GENERIC_ERROR";
+};
+const toLoginError = (error, stage, retryable = true) => ({
+  code: publicCode(error),
+  stage,
+  message: error?.message || "登录失败，请重试",
+  retryable
+});
+const DEFAULT_POLL_INTERVAL_MS = 2e3;
+const DEFAULT_REQUEST_TIMEOUT_MS = 1e4;
+const DEFAULT_TRANSACTION_TIMEOUT_MS = 5 * 60 * 1e3;
+const MIN_POLL_INTERVAL_MS = 1e3;
+const MAX_POLL_INTERVAL_MS = 6e4;
+const MIN_REQUEST_TIMEOUT_MS = 1e3;
+const MAX_REQUEST_TIMEOUT_MS = 6e4;
+const MIN_TRANSACTION_TIMEOUT_MS = 1e4;
+const MAX_TRANSACTION_TIMEOUT_MS = 15 * 60 * 1e3;
+const MAX_POLL_RETRY_DELAY_MS = 15e3;
+const normalizeDuration = (value, fallback, minimum, maximum) => {
+  if (value === void 0 || value === null) return fallback;
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  return Math.min(maximum, Math.max(minimum, Math.round(value)));
+};
+const normalizePollInterval = (value) => normalizeDuration(value, DEFAULT_POLL_INTERVAL_MS, MIN_POLL_INTERVAL_MS, MAX_POLL_INTERVAL_MS);
+const normalizeRequestTimeout = (value) => normalizeDuration(value, DEFAULT_REQUEST_TIMEOUT_MS, MIN_REQUEST_TIMEOUT_MS, MAX_REQUEST_TIMEOUT_MS);
+const normalizeTransactionTimeout = (value) => normalizeDuration(value, DEFAULT_TRANSACTION_TIMEOUT_MS, MIN_TRANSACTION_TIMEOUT_MS, MAX_TRANSACTION_TIMEOUT_MS);
+const getCode = (value) => String(value?.code ?? "");
+const isAbortError$1 = (error) => error?.name === "AbortError";
+const isRecord$1 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const requireConfigString = (value, field) => {
+  const normalized = typeof value === "string" ? value.trim() : "";
+  if (!normalized) {
+    throw new AuthError("INVALID_GATEWAY_CONFIG", `必须配置 ${field}`);
+  }
+  return normalized;
+};
+const resolveBaseUrl = (value) => {
+  const baseUrl = requireConfigString(value, "gatewayOptions.baseUrl");
+  try {
+    const url = new URL(baseUrl);
+    if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error("unsupported protocol");
+  } catch {
+    throw new AuthError("INVALID_GATEWAY_CONFIG", "gatewayOptions.baseUrl 必须是有效的 HTTP(S) 地址");
+  }
+  return baseUrl;
+};
+const resolvePaths = (value, requireMiniProgramScheme) => {
+  if (!isRecord$1(value)) {
+    throw new AuthError("INVALID_GATEWAY_CONFIG", "必须配置 gatewayOptions.paths");
+  }
+  const paths = {
+    genLoginId: requireConfigString(value.genLoginId, "gatewayOptions.paths.genLoginId"),
+    checkLogin: requireConfigString(value.checkLogin, "gatewayOptions.paths.checkLogin"),
+    miniProgramScheme: typeof value.miniProgramScheme === "string" ? value.miniProgramScheme.trim() : ""
+  };
+  if (requireMiniProgramScheme && !paths.miniProgramScheme) {
+    throw new AuthError("INVALID_GATEWAY_CONFIG", "小程序登录必须配置 gatewayOptions.paths.miniProgramScheme");
+  }
+  return paths;
+};
+const toUrl = (baseUrl, path, params) => {
+  const url = new URL(path, `${baseUrl.replace(/\/$/, "")}/`);
+  for (const [key, value] of Object.entries(params || {})) {
+    if (value !== void 0 && value !== null && value !== "") {
+      url.searchParams.set(key, String(value));
+    }
+  }
+  return url;
+};
+const readJson = async (response, label) => {
+  let data;
+  try {
+    data = await response.json();
+  } catch {
+    throw new AuthError("GATEWAY_ERROR", `${label} 返回了无效响应`);
+  }
+  if (!response.ok) {
+    throw new AuthError("GATEWAY_ERROR", `${label} 请求失败（HTTP ${response.status}）`, {
+      status: response.status,
+      response: data
+    });
+  }
+  return data;
+};
+const fetchWithTimeout = async ({ fetchImpl, url, init, timeoutMs, signal, label }) => {
+  const controller = typeof AbortController === "function" ? new AbortController() : null;
+  let timeoutId = null;
+  let onAbort = null;
+  if (controller) {
+    onAbort = () => controller.abort();
+    if (signal) {
+      if (signal.aborted) controller.abort();
+      else signal.addEventListener("abort", onAbort, { once: true });
+    }
+  }
+  try {
+    const request = fetchImpl(url, {
+      ...init,
+      signal: controller?.signal || signal
+    }).then((response) => readJson(response, label));
+    const timeout = new Promise((_, reject) => {
+      const timeoutForRace = setTimeout(() => {
+        controller?.abort();
+        reject(new AuthError("NETWORK_ERROR", `${label} 请求超时`));
+      }, timeoutMs);
+      timeoutId = timeoutForRace;
+    });
+    return await Promise.race([request, timeout]);
+  } catch (error) {
+    if (isAbortError$1(error) || controller?.signal.aborted) {
+      if (signal?.aborted) throw error;
+      throw new AuthError("NETWORK_ERROR", `${label} 请求超时`);
+    }
+    if (error instanceof AuthError) throw error;
+    throw new AuthError("NETWORK_ERROR", error instanceof Error ? error.message : `${label} 请求失败`);
+  } finally {
+    if (timeoutId !== null) clearTimeout(timeoutId);
+    if (signal && onAbort) signal.removeEventListener("abort", onAbort);
+  }
+};
+const ensureFetch = (fetchImpl) => {
+  if (typeof fetchImpl !== "function") {
+    throw new AuthError("UNSUPPORTED_ENVIRONMENT", "当前环境不支持 fetch");
+  }
+  return fetchImpl;
+};
+const resolveMiniProgramDestination = (options) => {
+  const target = requireConfigString(options.schemeTarget, "gatewayOptions.schemeTarget");
+  const path = requireConfigString(options.schemeMiniPath, "gatewayOptions.schemeMiniPath").replace(/^\/+/, "");
+  if (!path) {
+    throw new AuthError("INVALID_GATEWAY_CONFIG", "gatewayOptions.schemeMiniPath 不能只包含斜杠");
+  }
+  return { target, path };
+};
+const createLoginGateway = (options = {}) => {
+  const fetchImpl = ensureFetch(options.fetchImpl || globalThis.fetch?.bind(globalThis));
+  const usesMiniProgram = options.loginMethod === "mini-program";
+  const baseUrl = resolveBaseUrl(options.baseUrl);
+  const paths = resolvePaths(options.paths, usesMiniProgram);
+  if (usesMiniProgram) resolveMiniProgramDestination(options);
+  const requestTimeoutMs = normalizeRequestTimeout(options.requestTimeoutMs);
+  const codeType = options.codeType || void 0;
+  const get = (path, params, init, label, signal, timeoutMs) => fetchWithTimeout({
+    fetchImpl,
+    url: toUrl(baseUrl, path, params),
+    init: { method: "GET", ...init, cache: "no-store" },
+    timeoutMs: normalizeRequestTimeout(timeoutMs ?? requestTimeoutMs),
+    signal,
+    label
+  });
+  return {
+    async genLoginId({ appCode, signal, timeoutMs } = {}) {
+      if (appCode === void 0 || appCode === null || appCode === "") {
+        throw new AuthError("INVALID_APP_CODE", "必须提供登录网关发放的 appCode");
+      }
+      const data = await get(
+        paths.genLoginId,
+        { app_code: appCode, code_img: 1, ...codeType ? { code_type: codeType } : {} },
+        void 0,
+        "生成登录二维码",
+        signal,
+        timeoutMs
+      );
+      const loginId = data?.data?.login_id;
+      const loginImg = data?.data?.login_img;
+      if (!loginId || !loginImg) {
+        throw new AuthError("GATEWAY_ERROR", data?.msg || "登录网关未返回二维码");
+      }
+      return { loginId: String(loginId), loginImg: String(loginImg) };
+    },
+    async checkLogin({ loginId, signal, timeoutMs } = {}) {
+      if (!loginId) throw new AuthError("GATEWAY_ERROR", "登录事务缺少 loginId");
+      const data = await get(paths.checkLogin, { login_id: loginId }, void 0, "检查登录状态", signal, timeoutMs);
+      const code = getCode(data);
+      if (code === "200" || code === "201") return { status: "unscanned", code, data: data.data };
+      if (code === "202") return { status: "scanned", code, data: data.data };
+      if (code === "203") {
+        if (!data?.data?.token) {
+          throw new AuthError("GATEWAY_ERROR", "登录网关返回成功状态但缺少 token");
+        }
+        return { status: "confirmed", code, data: { ...data.data } };
+      }
+      if (code === "204") return { status: "expired", code, data: data.data };
+      if (code === "400") {
+        return { status: "failed", code, data: data.data, message: data.msg || "登录失败" };
+      }
+      throw new AuthError("GATEWAY_ERROR", data?.msg || `未知登录状态 ${code || "empty"}`, {
+        code,
+        response: data
+      });
+    },
+    async getMiniProgramScheme({ loginId, signal, timeoutMs } = {}) {
+      if (!loginId) throw new AuthError("GATEWAY_ERROR", "登录事务缺少 loginId");
+      if (!paths.miniProgramScheme) {
+        throw new AuthError("INVALID_GATEWAY_CONFIG", "小程序登录必须配置 gatewayOptions.paths.miniProgramScheme");
+      }
+      const destination = resolveMiniProgramDestination(options);
+      const data = await get(
+        paths.miniProgramScheme,
+        {
+          to: destination.target,
+          path: destination.path,
+          query: `scene=${loginId}`,
+          env_version: codeType || "release"
+        },
+        void 0,
+        "生成微信小程序跳转链接",
+        signal,
+        timeoutMs
+      );
+      if (!data?.data || typeof data.data !== "string") {
+        throw new AuthError("GATEWAY_ERROR", data?.msg || "登录网关未返回微信跳转链接");
+      }
+      return data.data;
+    }
+  };
+};
+const LOGIN_STATUS = Object.freeze({
+  IDLE: "idle",
+  LOADING: "loading",
+  QR_READY: "qr-ready",
+  SCANNED: "scanned",
+  AUTHENTICATED: "authenticated",
+  EXPIRED: "expired",
+  CANCELLED: "cancelled",
+  ERROR: "error"
+});
+const HIDDEN_GRACE_MS = 180;
+const MAX_CONSECUTIVE_POLL_ERRORS = 5;
+const ACTIVE_STATUS_KINDS = Object.freeze([
+  LOGIN_STATUS.LOADING,
+  LOGIN_STATUS.QR_READY,
+  LOGIN_STATUS.SCANNED
+]);
+const VALID_POLL_RESULTS = /* @__PURE__ */ new Set(["unscanned", "scanned", "confirmed", "expired", "failed"]);
+const getDocument = (value) => value || (typeof document === "undefined" ? null : document);
+const getWindow = (value) => value || (typeof window === "undefined" ? null : window);
+const isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const isAbortError = (error) => error?.name === "AbortError";
+const abortError = () => Object.assign(new Error("Aborted"), { name: "AbortError" });
+const wait = (ms, signal) => new Promise((resolve, reject) => {
+  if (signal?.aborted) {
+    reject(abortError());
+    return;
+  }
+  const onAbort = () => {
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", onAbort);
+    reject(abortError());
+  };
+  const done = () => {
+    signal?.removeEventListener("abort", onAbort);
+    resolve();
+  };
+  const timer = setTimeout(done, ms);
+  signal?.addEventListener("abort", onAbort, { once: true });
+});
+const isStronglyHidden = (root) => {
+  if (!root) return false;
+  if (root.isConnected === false) return true;
+  let node = root;
+  while (node && node.nodeType === 1) {
+    if (node.hidden || node.getAttribute?.("aria-hidden") === "true") return true;
+    const style = node.ownerDocument?.defaultView?.getComputedStyle?.(node);
+    if (style && (style.display === "none" || style.visibility === "hidden")) return true;
+    node = node.parentElement;
+  }
+  const rect = root.getBoundingClientRect?.();
+  return Boolean(rect && rect.width === 0 && rect.height === 0);
+};
+const getScope = (windowRef, documentRef) => windowRef || documentRef || null;
+const activeScopes = /* @__PURE__ */ new WeakMap();
+class LoginSession {
+  constructor(options = {}) {
+    if (options.appCode === void 0 || options.appCode === null || options.appCode === "") {
+      throw new AuthError("INVALID_APP_CODE", "必须提供登录网关发放的 appCode");
+    }
+    this.pollIntervalMs = normalizePollInterval(options.pollIntervalMs);
+    this.requestTimeoutMs = normalizeRequestTimeout(
+      options.requestTimeoutMs ?? options.gatewayOptions?.requestTimeoutMs
+    );
+    this.timeoutMs = normalizeTransactionTimeout(options.timeoutMs);
+    this.appCode = options.appCode;
+    this.platform = options.platform || "web";
+    this.loginMethod = options.loginMethod || "qr";
+    this.gateway = createLoginGateway({
+      ...options.gatewayOptions,
+      loginMethod: this.loginMethod,
+      requestTimeoutMs: this.requestTimeoutMs
+    });
+    this.windowRef = getWindow(options.windowRef);
+    this.documentRef = getDocument(options.documentRef);
+    this.scope = getScope(this.windowRef, this.documentRef);
+    this.onStatus = options.onStatus || (() => {
+    });
+    this.onSuccess = options.onSuccess || (() => {
+    });
+    this.onError = options.onError || (() => {
+    });
+    this.debug = options.debug === true;
+    this.status = { kind: LOGIN_STATUS.IDLE, platform: this.platform };
+    this.loginId = "";
+    this.loginImg = "";
+    this.startedAt = 0;
+    this.controller = null;
+    this.pendingPromise = null;
+    this.generation = 0;
+    this.errorNotified = false;
+    this.claimed = false;
+    this.cancelled = false;
+    this.destroyed = false;
+    this.mounted = false;
+    this.result = null;
+    this.root = null;
+    this.hiddenTimer = null;
+    this.containerHidden = false;
+    this.pageHidden = false;
+    this.awaitingExternalReturn = false;
+    this.miniProgramScheme = "";
+    this.miniProgramSchemePromise = null;
+    this.miniProgramLaunchPromise = null;
+    this.miniProgramNavigationObserved = false;
+    this.suspendedForPagehide = false;
+    this.checkImmediately = false;
+    this.deadlineTimer = null;
+    this.visibilityCheckScheduled = false;
+    this.visibilityFrame = null;
+    this.visibilityTimer = null;
+    this.visibilityObserverTargets = [];
+    this.observingDisconnectedRoot = false;
+    this.mutationObserver = null;
+    this.resizeObserver = null;
+    this.visibilityHandler = () => {
+      const hidden = this.documentRef?.visibilityState === "hidden";
+      if (hidden && this.awaitingExternalReturn) this.miniProgramNavigationObserved = true;
+      this.debugLog("visibilitychange", { hidden });
+      if (!hidden && (this.awaitingExternalReturn || this.miniProgramNavigationObserved)) {
+        this.completeExternalReturn("visibilitychange");
+      }
+      if (!hidden && this.pageHidden && this.suspendedForPagehide && this.mounted && !this.destroyed) {
+        this.pageHidden = false;
+        this.suspendedForPagehide = false;
+        this.scheduleVisibilityCheck();
+        if (this.loginId) void this.resumePolling();
+        else void this.start();
+        return;
+      }
+      if (!hidden) this.checkImmediately = true;
+      this.scheduleVisibilityCheck();
+    };
+    this.pageHideHandler = (event) => {
+      if (!ACTIVE_STATUS_KINDS.includes(this.status.kind)) return;
+      this.pageHidden = true;
+      if (this.awaitingExternalReturn) this.miniProgramNavigationObserved = true;
+      this.debugLog("pagehide", {
+        persisted: event?.persisted === true,
+        externalReturn: this.awaitingExternalReturn
+      });
+      this.suspendForPagehide(this.awaitingExternalReturn ? "external-return" : "pagehide");
+    };
+    this.pageShowHandler = (event) => {
+      this.debugLog("pageshow", {
+        persisted: event?.persisted === true,
+        suspended: this.suspendedForPagehide
+      });
+      if (this.mounted && !this.destroyed && this.suspendedForPagehide) {
+        this.pageHidden = false;
+        this.completeExternalReturn("pageshow");
+        this.suspendedForPagehide = false;
+        this.scheduleVisibilityCheck();
+        if (this.loginId) void this.resumePolling();
+        else void this.start();
+        return;
+      }
+      if (this.mounted && !this.destroyed) {
+        this.checkImmediately = true;
+        this.scheduleVisibilityCheck();
+      }
+    };
+  }
+  snapshot() {
+    return {
+      ...this.status,
+      loginImg: this.loginImg || void 0
+    };
+  }
+  emit(kind, extra = {}) {
+    const previous = this.status.kind;
+    this.status = { kind, platform: this.platform, ...extra };
+    this.debugLog("status", { from: previous, to: kind, stage: extra.stage });
+    if ([LOGIN_STATUS.AUTHENTICATED, LOGIN_STATUS.EXPIRED, LOGIN_STATUS.ERROR, LOGIN_STATUS.CANCELLED].includes(kind)) {
+      this.clearDeadline();
+      this.release();
+    }
+    try {
+      this.onStatus(this.snapshot());
+    } catch {
+    }
+  }
+  mount(root) {
+    if (this.mounted) return this;
+    this.mounted = true;
+    this.root = root || null;
+    this.destroyed = false;
+    this.debugLog("mount", { hasRoot: Boolean(this.root) });
+    this.setupObservers();
+    void this.start();
+    return this;
+  }
+  unmount() {
+    if (this.destroyed) return;
+    this.debugLog("unmount", { reason: "component-unmount" });
+    this.destroyed = true;
+    this.mounted = false;
+    this.cancel("组件已卸载", { silent: true });
+    this.cleanupObservers();
+    this.root = null;
+  }
+  claim() {
+    if (!this.scope) return true;
+    const owner = activeScopes.get(this.scope);
+    if (owner && owner !== this) return false;
+    activeScopes.set(this.scope, this);
+    this.claimed = true;
+    return true;
+  }
+  release() {
+    if (this.scope && activeScopes.get(this.scope) === this) activeScopes.delete(this.scope);
+    this.claimed = false;
+  }
+  start() {
+    if (this.destroyed) return Promise.resolve(null);
+    if (this.pendingPromise) return this.pendingPromise;
+    if (this.status.kind === LOGIN_STATUS.AUTHENTICATED) return Promise.resolve(null);
+    this.errorNotified = false;
+    if (!this.claim()) {
+      const error = new AuthError("DUPLICATE_INSTANCE", "当前页面已经存在活跃的登录组件");
+      this.notifyError(error, "init", false);
+      return Promise.resolve(null);
+    }
+    this.cancelled = false;
+    this.awaitingExternalReturn = false;
+    this.suspendedForPagehide = false;
+    this.pageHidden = false;
+    this.result = null;
+    this.loginId = "";
+    this.loginImg = "";
+    this.miniProgramScheme = "";
+    this.miniProgramSchemePromise = null;
+    this.miniProgramLaunchPromise = null;
+    this.miniProgramNavigationObserved = false;
+    this.checkImmediately = false;
+    this.startedAt = Date.now();
+    this.controller = typeof AbortController === "function" ? new AbortController() : null;
+    const generation = ++this.generation;
+    this.armDeadline(generation);
+    this.debugLog("start", { generation });
+    const promise = this.run(generation);
+    this.pendingPromise = promise;
+    promise.then(
+      () => {
+        if (this.pendingPromise === promise) this.pendingPromise = null;
+      },
+      () => {
+        if (this.pendingPromise === promise) this.pendingPromise = null;
+      }
+    );
+    return promise;
+  }
+  isCurrent(generation) {
+    return generation === this.generation && !this.cancelled && !this.destroyed;
+  }
+  async run(generation) {
+    this.debugLog("request-gen-login-id", { generation });
+    this.emit(LOGIN_STATUS.LOADING, { message: "正在生成安全二维码", stage: "init" });
+    try {
+      const generated = await this.gateway.genLoginId({
+        appCode: this.appCode,
+        platform: this.platform,
+        loginMethod: this.loginMethod,
+        signal: this.controller?.signal,
+        timeoutMs: this.requestTimeoutMs
+      });
+      if (!this.isCurrent(generation)) return null;
+      if (!generated?.loginId || !generated?.loginImg) {
+        throw new AuthError("GATEWAY_ERROR", "登录网关未返回二维码");
+      }
+      this.loginId = String(generated.loginId);
+      this.loginImg = String(generated.loginImg);
+      this.debugLog("login-id-ready", { generation, loginId: this.loginId });
+      if (this.loginMethod === "mini-program") {
+        this.emit(LOGIN_STATUS.LOADING, { message: "正在准备微信登录", stage: "mini-program" });
+        try {
+          await this.prepareMiniProgramScheme(generation);
+        } catch (error) {
+          if (!this.isCurrent(generation) || isAbortError(error)) return null;
+          this.notifyError(error, "mini-program", true);
+          return null;
+        }
+      }
+      if (!this.isCurrent(generation)) return null;
+      this.emit(LOGIN_STATUS.QR_READY, { message: "请使用微信扫码登录", stage: "poll" });
+      return await this.poll(generation);
+    } catch (error) {
+      if (!this.isCurrent(generation) || isAbortError(error)) return null;
+      this.notifyError(error, "init", true);
+      return null;
+    }
+  }
+  async poll(generation) {
+    let consecutiveErrors = 0;
+    let nextDelayMs = this.pollIntervalMs;
+    while (this.isCurrent(generation)) {
+      const remaining = this.timeoutMs - (Date.now() - this.startedAt);
+      if (remaining <= 0) {
+        this.notifyError(new AuthError("TIMEOUT", "登录事务已超时，请重新发起登录"), "poll", true);
+        return;
+      }
+      if (this.documentRef?.visibilityState === "hidden" || this.pageHidden || this.containerHidden) {
+        try {
+          await wait(Math.min(this.pollIntervalMs, remaining), this.controller?.signal);
+        } catch (error) {
+          if (!this.isCurrent(generation) || isAbortError(error)) return;
+          throw error;
+        }
+        continue;
+      }
+      if (!this.checkImmediately) {
+        try {
+          await wait(Math.min(nextDelayMs, remaining), this.controller?.signal);
+        } catch (error) {
+          if (!this.isCurrent(generation) || isAbortError(error)) return;
+          throw error;
+        }
+      }
+      this.checkImmediately = false;
+      if (!this.isCurrent(generation)) return;
+      try {
+        const result = await this.gateway.checkLogin({
+          loginId: this.loginId,
+          platform: this.platform,
+          signal: this.controller?.signal,
+          timeoutMs: this.requestTimeoutMs
+        });
+        if (!this.isCurrent(generation)) return;
+        if (Date.now() - this.startedAt >= this.timeoutMs) {
+          this.notifyError(new AuthError("TIMEOUT", "登录事务已超时，请重新发起登录"), "poll", true);
+          return;
+        }
+        if (!VALID_POLL_RESULTS.has(result?.status)) {
+          throw new AuthError("GATEWAY_ERROR", "登录网关返回了未知状态");
+        }
+        consecutiveErrors = 0;
+        nextDelayMs = this.pollIntervalMs;
+        if (result?.status === "unscanned") {
+          this.emit(LOGIN_STATUS.QR_READY, { message: "请使用微信扫码登录", stage: "poll" });
+        } else if (result?.status === "scanned") {
+          this.emit(LOGIN_STATUS.SCANNED, { message: "扫码成功，请在手机上确认", stage: "poll" });
+        } else if (result?.status === "expired") {
+          this.emit(LOGIN_STATUS.EXPIRED, { message: "二维码已过期，请点击刷新", stage: "poll" });
+          return;
+        } else if (result?.status === "failed") {
+          this.notifyError(new AuthError("GATEWAY_ERROR", result.message || "登录失败，请重试"), "poll", true);
+          return;
+        } else if (result?.status === "confirmed") {
+          return this.complete(result.data, generation);
+        }
+      } catch (error) {
+        if (!this.isCurrent(generation) || isAbortError(error)) return;
+        const remainingAfterError = this.timeoutMs - (Date.now() - this.startedAt);
+        if (remainingAfterError <= 0) {
+          this.notifyError(new AuthError("TIMEOUT", "登录事务已超时，请重新发起登录"), "poll", true);
+          return;
+        }
+        consecutiveErrors += 1;
+        if (consecutiveErrors >= MAX_CONSECUTIVE_POLL_ERRORS) {
+          this.notifyError(error, "poll", true);
+          return;
+        }
+        nextDelayMs = Math.min(
+          MAX_POLL_RETRY_DELAY_MS,
+          this.pollIntervalMs * 2 ** Math.min(consecutiveErrors, 4)
+        );
+        this.debugLog("poll-retry", { consecutiveErrors, nextDelayMs });
+        this.emit(this.status.kind === LOGIN_STATUS.SCANNED ? LOGIN_STATUS.SCANNED : LOGIN_STATUS.QR_READY, {
+          message: "登录服务暂时不可用，正在重试",
+          stage: "poll",
+          recovering: true
+        });
+      }
+    }
+  }
+  complete(loginData, generation) {
+    if (!isRecord(loginData) || typeof loginData.token !== "string" || !loginData.token) {
+      this.notifyError(new AuthError("GATEWAY_ERROR", "登录结果缺少 token"), "poll", false);
+      return;
+    }
+    if (!this.isCurrent(generation)) return;
+    const result = {
+      login: Object.freeze({ ...loginData })
+    };
+    this.result = Object.freeze(result);
+    this.emit(LOGIN_STATUS.AUTHENTICATED, { message: "登录成功", stage: "poll" });
+    const callbackResult = this.result;
+    this.result = null;
+    try {
+      this.onSuccess(callbackResult);
+    } catch {
+    }
+    return callbackResult;
+  }
+  notifyError(error, stage, retryable = true) {
+    if (this.errorNotified) return;
+    this.errorNotified = true;
+    this.cancelled = true;
+    this.generation += 1;
+    this.controller?.abort();
+    this.pendingPromise = null;
+    this.awaitingExternalReturn = false;
+    this.suspendedForPagehide = false;
+    const result = toLoginError(error, stage, retryable);
+    this.emit(LOGIN_STATUS.ERROR, result);
+    try {
+      this.onError(result);
+    } catch {
+    }
+  }
+  retry() {
+    if (this.destroyed) return Promise.resolve(null);
+    this.cancelled = true;
+    this.generation += 1;
+    this.controller?.abort();
+    this.pendingPromise = null;
+    this.release();
+    this.containerHidden = false;
+    this.pageHidden = false;
+    this.suspendedForPagehide = false;
+    this.awaitingExternalReturn = false;
+    this.status = { kind: LOGIN_STATUS.IDLE, platform: this.platform };
+    this.debugLog("retry");
+    return this.start();
+  }
+  suspendForPagehide(reason = "pagehide") {
+    this.suspendedForPagehide = true;
+    this.cancelled = true;
+    this.generation += 1;
+    this.controller?.abort();
+    this.pendingPromise = null;
+    this.clearDeadline();
+    this.debugLog("suspend", { reason, hasLoginId: Boolean(this.loginId) });
+  }
+  completeExternalReturn(reason) {
+    if (!this.awaitingExternalReturn && !this.miniProgramNavigationObserved) return false;
+    this.awaitingExternalReturn = false;
+    this.miniProgramNavigationObserved = false;
+    this.debugLog("external-return-complete", { reason });
+    return true;
+  }
+  resumePolling() {
+    if (this.destroyed || !this.mounted || !this.loginId || this.pendingPromise || !ACTIVE_STATUS_KINDS.includes(this.status.kind)) return Promise.resolve(null);
+    const remaining = this.timeoutMs - (Date.now() - this.startedAt);
+    if (remaining <= 0) {
+      this.cancelled = false;
+      this.notifyError(new AuthError("TIMEOUT", "登录事务已超时，请重新发起登录"), "poll", true);
+      return Promise.resolve(null);
+    }
+    this.cancelled = false;
+    this.controller = typeof AbortController === "function" ? new AbortController() : null;
+    this.checkImmediately = true;
+    const generation = ++this.generation;
+    this.armDeadline(generation, remaining);
+    this.debugLog("resume", { generation, loginId: this.loginId });
+    const promise = this.resume(generation);
+    this.pendingPromise = promise;
+    promise.then(
+      () => {
+        if (this.pendingPromise === promise) this.pendingPromise = null;
+      },
+      () => {
+        if (this.pendingPromise === promise) this.pendingPromise = null;
+      }
+    );
+    return promise;
+  }
+  async resume(generation) {
+    if (this.loginMethod === "mini-program" && !this.miniProgramScheme) {
+      this.emit(LOGIN_STATUS.LOADING, { message: "正在准备微信登录", stage: "mini-program" });
+      try {
+        await this.prepareMiniProgramScheme(generation);
+      } catch (error) {
+        if (!this.isCurrent(generation) || isAbortError(error)) return null;
+        this.notifyError(error, "mini-program", true);
+        return null;
+      }
+      if (!this.isCurrent(generation)) return null;
+      this.emit(LOGIN_STATUS.QR_READY, { message: "请使用微信扫码登录", stage: "poll" });
+    }
+    return this.poll(generation);
+  }
+  prepareMiniProgramScheme(generation = this.generation) {
+    if (this.miniProgramScheme) return Promise.resolve(this.miniProgramScheme);
+    if (this.miniProgramSchemePromise) return this.miniProgramSchemePromise;
+    if (!this.loginId) return Promise.reject(new AuthError("GATEWAY_ERROR", "登录事务尚未准备好"));
+    const loginId = this.loginId;
+    const operation = (async () => {
+      const scheme = await this.gateway.getMiniProgramScheme({
+        loginId,
+        platform: this.platform,
+        signal: this.controller?.signal,
+        timeoutMs: this.requestTimeoutMs
+      });
+      if (!this.isCurrent(generation) || loginId !== this.loginId) throw abortError();
+      if (typeof scheme !== "string" || !scheme.trim()) {
+        throw new AuthError("GATEWAY_ERROR", "登录网关未返回微信小程序跳转链接");
+      }
+      this.miniProgramScheme = scheme;
+      this.debugLog("mini-program-scheme-ready", { hasLoginId: true });
+      return scheme;
+    })();
+    this.miniProgramSchemePromise = operation;
+    operation.then(
+      () => {
+        if (this.miniProgramSchemePromise === operation) this.miniProgramSchemePromise = null;
+      },
+      () => {
+        if (this.miniProgramSchemePromise === operation) this.miniProgramSchemePromise = null;
+      }
+    );
+    return operation;
+  }
+  openMiniProgram() {
+    if (this.miniProgramLaunchPromise) return this.miniProgramLaunchPromise;
+    let operation;
+    try {
+      if (!ACTIVE_STATUS_KINDS.includes(this.status.kind) || this.cancelled || this.destroyed) {
+        throw new AuthError("GATEWAY_ERROR", "当前登录事务不可用，请重新发起登录");
+      }
+      if (!this.loginId) throw new AuthError("GATEWAY_ERROR", "登录事务尚未准备好");
+      const launch = (scheme) => {
+        if (!this.windowRef?.location?.assign) {
+          throw new AuthError("UNSUPPORTED_ENVIRONMENT", "当前环境无法拉起微信小程序");
+        }
+        this.miniProgramNavigationObserved = false;
+        this.awaitingExternalReturn = true;
+        this.debugLog("external-return-start", { hasLoginId: true, cachedScheme: true });
+        this.windowRef.location.assign(scheme);
+        return scheme;
+      };
+      operation = this.miniProgramScheme ? Promise.resolve(launch(this.miniProgramScheme)) : this.prepareMiniProgramScheme().then(launch);
+    } catch (error) {
+      operation = Promise.reject(error);
+    }
+    const guardedOperation = operation.catch((error) => {
+      this.awaitingExternalReturn = false;
+      if (!this.cancelled) this.notifyError(error, "mini-program", true);
+      throw error;
+    });
+    this.miniProgramLaunchPromise = guardedOperation;
+    guardedOperation.then(
+      () => {
+        if (this.miniProgramLaunchPromise === guardedOperation) this.miniProgramLaunchPromise = null;
+      },
+      () => {
+        if (this.miniProgramLaunchPromise === guardedOperation) this.miniProgramLaunchPromise = null;
+      }
+    );
+    return guardedOperation;
+  }
+  canRetryMiniProgramLaunch() {
+    return Boolean(
+      this.miniProgramScheme && !this.miniProgramNavigationObserved && ACTIVE_STATUS_KINDS.includes(this.status.kind)
+    );
+  }
+  armDeadline(generation, delayMs = this.timeoutMs) {
+    this.clearDeadline();
+    this.deadlineTimer = setTimeout(() => {
+      this.deadlineTimer = null;
+      if (!this.isCurrent(generation)) return;
+      this.debugLog("transaction-deadline", { timeoutMs: this.timeoutMs });
+      this.notifyError(
+        new AuthError("TIMEOUT", "登录事务已超时，请重新发起登录"),
+        this.status.stage || "poll",
+        true
+      );
+    }, Math.max(0, delayMs));
+  }
+  clearDeadline() {
+    if (this.deadlineTimer !== null) clearTimeout(this.deadlineTimer);
+    this.deadlineTimer = null;
+  }
+  setupObservers() {
+    const doc = this.documentRef;
+    const win = this.windowRef;
+    doc?.addEventListener?.("visibilitychange", this.visibilityHandler);
+    win?.addEventListener?.("pagehide", this.pageHideHandler);
+    win?.addEventListener?.("pageshow", this.pageShowHandler);
+    const MutationObserverImpl = win?.MutationObserver || globalThis.MutationObserver;
+    if (typeof MutationObserverImpl === "function" && this.root) {
+      this.mutationObserver = new MutationObserverImpl(() => this.scheduleVisibilityCheck());
+      this.observeVisibilityTargets();
+    }
+    const ResizeObserverImpl = win?.ResizeObserver || globalThis.ResizeObserver;
+    if (typeof ResizeObserverImpl === "function" && this.root) {
+      this.resizeObserver = new ResizeObserverImpl(() => this.scheduleVisibilityCheck());
+      this.resizeObserver.observe(this.root);
+    }
+    this.checkVisibility();
+  }
+  cleanupObservers() {
+    this.documentRef?.removeEventListener?.("visibilitychange", this.visibilityHandler);
+    this.windowRef?.removeEventListener?.("pagehide", this.pageHideHandler);
+    this.windowRef?.removeEventListener?.("pageshow", this.pageShowHandler);
+    this.mutationObserver?.disconnect();
+    this.resizeObserver?.disconnect();
+    this.mutationObserver = null;
+    this.resizeObserver = null;
+    this.visibilityObserverTargets = [];
+    this.observingDisconnectedRoot = false;
+    if (this.visibilityFrame !== null) {
+      this.windowRef?.cancelAnimationFrame?.(this.visibilityFrame);
+      this.visibilityFrame = null;
+    }
+    if (this.visibilityTimer !== null) {
+      clearTimeout(this.visibilityTimer);
+      this.visibilityTimer = null;
+    }
+    this.visibilityCheckScheduled = false;
+    if (this.hiddenTimer !== null) clearTimeout(this.hiddenTimer);
+    this.hiddenTimer = null;
+  }
+  observeVisibilityTargets() {
+    if (!this.mutationObserver || !this.root) return;
+    const targets = [];
+    let node = this.root;
+    while (node && node.nodeType === 1) {
+      targets.push(node);
+      node = node.parentElement;
+    }
+    const disconnected = this.root.isConnected === false;
+    const recoveryTarget = disconnected ? this.documentRef?.body : null;
+    if (recoveryTarget && !targets.includes(recoveryTarget)) targets.push(recoveryTarget);
+    if (disconnected === this.observingDisconnectedRoot && targets.length === this.visibilityObserverTargets.length && targets.every((target, index) => target === this.visibilityObserverTargets[index])) return;
+    this.mutationObserver.disconnect();
+    for (const target of targets) {
+      if (disconnected && target === recoveryTarget && target !== this.root) {
+        this.mutationObserver.observe(target, { childList: true, subtree: true });
+      } else {
+        this.mutationObserver.observe(target, {
+          childList: true,
+          attributes: true,
+          attributeFilter: ["hidden", "aria-hidden", "style", "class"]
+        });
+      }
+    }
+    this.visibilityObserverTargets = targets;
+    this.observingDisconnectedRoot = disconnected;
+  }
+  scheduleVisibilityCheck() {
+    if (!this.mounted || this.destroyed || !this.root || this.visibilityCheckScheduled) return;
+    this.visibilityCheckScheduled = true;
+    const run = () => {
+      this.visibilityCheckScheduled = false;
+      this.visibilityFrame = null;
+      this.visibilityTimer = null;
+      this.checkVisibility();
+    };
+    if (typeof this.windowRef?.requestAnimationFrame === "function") {
+      const frame = this.windowRef.requestAnimationFrame(run);
+      if (this.visibilityCheckScheduled) this.visibilityFrame = frame;
+      return;
+    }
+    this.visibilityTimer = setTimeout(run, 16);
+  }
+  checkVisibility() {
+    if (!this.mounted || this.destroyed || !this.root) return;
+    this.observeVisibilityTargets();
+    if (!isStronglyHidden(this.root)) {
+      if (this.hiddenTimer !== null) clearTimeout(this.hiddenTimer);
+      this.hiddenTimer = null;
+      if (this.containerHidden) {
+        this.containerHidden = false;
+        this.checkImmediately = true;
+        this.debugLog("container-visible");
+      }
+      return;
+    }
+    if (this.containerHidden || this.hiddenTimer !== null) return;
+    this.hiddenTimer = setTimeout(() => {
+      this.hiddenTimer = null;
+      if (!isStronglyHidden(this.root) || this.destroyed) return;
+      this.containerHidden = true;
+      this.debugLog("container-hidden", { hasLoginId: Boolean(this.loginId) });
+    }, HIDDEN_GRACE_MS);
+  }
+  cancel(reason = "登录已取消", { silent = false } = {}) {
+    if (this.cancelled && this.status.kind === LOGIN_STATUS.CANCELLED) return;
+    this.debugLog("cancel", { reason, silent });
+    this.cancelled = true;
+    this.generation += 1;
+    this.controller?.abort();
+    this.pendingPromise = null;
+    this.clearDeadline();
+    this.release();
+    this.suspendedForPagehide = false;
+    this.awaitingExternalReturn = false;
+    this.miniProgramScheme = "";
+    this.miniProgramSchemePromise = null;
+    this.miniProgramLaunchPromise = null;
+    this.miniProgramNavigationObserved = false;
+    this.pageHidden = false;
+    if (!silent && !this.destroyed) this.emit(LOGIN_STATUS.CANCELLED, { message: reason });
+  }
+  debugLog(event, details = {}) {
+    if (!this.debug) return;
+    const logger = this.windowRef?.console || (typeof console === "undefined" ? null : console);
+    logger?.info?.("[XTJ LoginKit]", event, {
+      status: this.status.kind,
+      generation: this.generation,
+      ...details
+    });
+  }
+}
+const createLoginSession = (options) => new LoginSession(options);
+export {
+  AuthError as A,
+  DEFAULT_POLL_INTERVAL_MS as D,
+  LOGIN_STATUS as L,
+  DEFAULT_REQUEST_TIMEOUT_MS as a,
+  DEFAULT_TRANSACTION_TIMEOUT_MS as b,
+  createLoginSession as c,
+  LoginSession as d,
+  toLoginError as t
+};