xtj-login-kit 0.3.1

package/dist/react.js

@@ -0,0 +1,297 @@
+import { forwardRef, useRef, useState, useMemo, useEffect, useImperativeHandle, createElement } from "react";
+import { L as LOGIN_STATUS, c as createLoginSession, t as toLoginError } from "./chunks/index-Cuix-7nW.js";
+import { g as getLoginRootStyle, L as LOGIN_MOTION_STYLES, i as isMiniProgramMethod, M as MINI_PROGRAM_LAUNCH_RECOVERY_MS, a as getMiniProgramPresentation, b as getMiniProgramIconStyle, c as getMiniProgramButtonStyle, d as getQrPresentation, e as getQrImageStyle, q as qrIconStyle, f as getQrLabelStyle, h as qrActionStyle, j as qrOverlayStyle, k as qrContentStyle } from "./chunks/ui-C58EkuFV.js";
+const QrLoginView = ({ status, onRetry, active }) => {
+  const children = [];
+  const presentation = getQrPresentation(status, active);
+  if (status.loginImg) {
+    children.push(createElement("img", {
+      key: "qr",
+      className: "xtj-login__qr",
+      src: status.loginImg,
+      alt: "登录二维码",
+      style: getQrImageStyle(Boolean(presentation))
+    }));
+  }
+  if (presentation) {
+    const stateContent = [];
+    if (presentation.icon) {
+      const iconClassName = [
+        "xtj-login__state-icon",
+        presentation.iconState ? `xtj-login__state-icon--${presentation.iconState}` : ""
+      ].filter(Boolean).join(" ");
+      stateContent.push(createElement("img", {
+        key: "icon",
+        className: iconClassName,
+        src: presentation.icon,
+        alt: "",
+        style: qrIconStyle,
+        "aria-hidden": "true"
+      }));
+    }
+    stateContent.push(createElement("span", {
+      key: "label",
+      className: "xtj-login__state-label",
+      style: getQrLabelStyle(Boolean(presentation.icon)),
+      role: "status",
+      "aria-live": "polite"
+    }, presentation.label));
+    if (presentation.action === "retry") {
+      children.push(createElement("button", {
+        key: "state",
+        type: "button",
+        className: "xtj-login__state xtj-login__state--action",
+        style: qrActionStyle,
+        onClick: onRetry,
+        "aria-label": presentation.label === "二维码已过期" ? "二维码已过期，点击重新获取" : presentation.label
+      }, stateContent));
+    } else {
+      children.push(createElement("div", {
+        key: "state",
+        className: "xtj-login__state",
+        style: qrOverlayStyle
+      }, stateContent));
+    }
+  }
+  return createElement("div", { className: "xtj-login__content", style: qrContentStyle }, children);
+};
+const MiniProgramLoginView = ({ status, onRetry, onMiniProgram, miniProgramPhase, active }) => {
+  const presentation = getMiniProgramPresentation(status, miniProgramPhase, active);
+  const onClick = presentation.action === "retry" ? onRetry : presentation.action === "open" ? onMiniProgram : void 0;
+  const children = [
+    createElement("img", {
+      key: "icon",
+      className: [
+        "xtj-login__mini-icon",
+        presentation.iconState ? `xtj-login__mini-icon--${presentation.iconState}` : ""
+      ].filter(Boolean).join(" "),
+      src: presentation.icon,
+      alt: "",
+      style: getMiniProgramIconStyle(presentation),
+      "aria-hidden": "true"
+    }),
+    createElement("span", { key: "label" }, presentation.label)
+  ];
+  return createElement("button", {
+    type: "button",
+    className: `xtj-login__mini-button xtj-login__mini-button--${presentation.tone}`,
+    style: getMiniProgramButtonStyle(presentation),
+    onClick,
+    disabled: presentation.disabled,
+    "aria-live": "polite"
+  }, children);
+};
+const LoginView = (props) => {
+  if (isMiniProgramMethod(props.loginMethod)) return createElement(MiniProgramLoginView, props);
+  return createElement(QrLoginView, props);
+};
+const Login = forwardRef(function Login2(props, forwardedRef) {
+  const active = props.active !== false;
+  const hostRef = useRef(null);
+  const sessionRef = useRef(null);
+  const successRef = useRef(props.onSuccess);
+  const errorRef = useRef(props.onError);
+  const statusRef = useRef(props.onStatus);
+  const miniProgramPhaseRef = useRef("idle");
+  const miniProgramRecoveryTimerRef = useRef(null);
+  const miniProgramRecoveryAtRef = useRef(0);
+  const initializationErrorRef = useRef(null);
+  const [status, setStatus] = useState({ kind: LOGIN_STATUS.IDLE, platform: props.platform || "web" });
+  const [miniProgramPhase, setMiniProgramPhase] = useState("idle");
+  const gatewayOptions = useMemo(() => {
+    if (!props.gatewayOptions) return void 0;
+    const paths = props.gatewayOptions.paths;
+    return {
+      baseUrl: props.gatewayOptions.baseUrl,
+      codeType: props.gatewayOptions.codeType,
+      schemeTarget: props.gatewayOptions.schemeTarget,
+      schemeMiniPath: props.gatewayOptions.schemeMiniPath,
+      requestTimeoutMs: props.gatewayOptions.requestTimeoutMs,
+      fetchImpl: props.gatewayOptions.fetchImpl,
+      paths: paths ? {
+        genLoginId: paths.genLoginId,
+        checkLogin: paths.checkLogin,
+        miniProgramScheme: paths.miniProgramScheme
+      } : void 0
+    };
+  }, [
+    Boolean(props.gatewayOptions),
+    props.gatewayOptions?.baseUrl,
+    props.gatewayOptions?.codeType,
+    props.gatewayOptions?.schemeTarget,
+    props.gatewayOptions?.schemeMiniPath,
+    props.gatewayOptions?.requestTimeoutMs,
+    props.gatewayOptions?.fetchImpl,
+    props.gatewayOptions?.paths?.genLoginId,
+    props.gatewayOptions?.paths?.checkLogin,
+    props.gatewayOptions?.paths?.miniProgramScheme
+  ]);
+  useEffect(() => {
+    successRef.current = props.onSuccess;
+    errorRef.current = props.onError;
+    statusRef.current = props.onStatus;
+  }, [props.onSuccess, props.onError, props.onStatus]);
+  useEffect(() => {
+    miniProgramPhaseRef.current = "idle";
+    miniProgramRecoveryAtRef.current = 0;
+    setMiniProgramPhase("idle");
+    if (!active) {
+      initializationErrorRef.current = null;
+      sessionRef.current = null;
+      setStatus({ kind: LOGIN_STATUS.IDLE, platform: props.platform || "web" });
+      return void 0;
+    }
+    let session;
+    try {
+      session = createLoginSession({
+        gatewayOptions,
+        appCode: props.appCode,
+        platform: props.platform,
+        loginMethod: props.loginMethod,
+        pollIntervalMs: props.pollIntervalMs,
+        requestTimeoutMs: props.requestTimeoutMs,
+        timeoutMs: props.timeoutMs,
+        debug: props.debug,
+        windowRef: props.windowRef,
+        documentRef: props.documentRef,
+        onStatus: (next) => {
+          setStatus(next);
+          if (next.kind === LOGIN_STATUS.QR_READY) {
+            if (miniProgramPhaseRef.current === "awaiting" && Date.now() >= miniProgramRecoveryAtRef.current && session.canRetryMiniProgramLaunch()) {
+              miniProgramPhaseRef.current = "retry-launch";
+              setMiniProgramPhase("retry-launch");
+            } else if (miniProgramPhaseRef.current === "retry-launch" && session.canRetryMiniProgramLaunch() === false) {
+              miniProgramPhaseRef.current = "awaiting";
+              setMiniProgramPhase("awaiting");
+            }
+          }
+          statusRef.current?.(next);
+        },
+        onSuccess: (result) => successRef.current?.(result),
+        onError: (error) => errorRef.current?.(error)
+      });
+      sessionRef.current = session;
+      session.mount(hostRef.current);
+      initializationErrorRef.current = null;
+    } catch (error) {
+      try {
+        session?.unmount();
+      } catch {
+      }
+      const result = toLoginError(error, "init", false);
+      const next = { kind: LOGIN_STATUS.ERROR, platform: props.platform || "web", ...result };
+      const signature = `${result.code}:${result.message}`;
+      sessionRef.current = null;
+      setStatus(next);
+      if (initializationErrorRef.current !== signature) {
+        initializationErrorRef.current = signature;
+        try {
+          statusRef.current?.(next);
+        } catch {
+        }
+        try {
+          errorRef.current?.(result);
+        } catch {
+        }
+      }
+      return void 0;
+    }
+    return () => {
+      if (miniProgramRecoveryTimerRef.current !== null) {
+        clearTimeout(miniProgramRecoveryTimerRef.current);
+        miniProgramRecoveryTimerRef.current = null;
+      }
+      session.unmount();
+      if (sessionRef.current === session) sessionRef.current = null;
+    };
+  }, [
+    active,
+    gatewayOptions,
+    props.appCode,
+    props.platform,
+    props.loginMethod,
+    props.pollIntervalMs,
+    props.requestTimeoutMs,
+    props.timeoutMs,
+    props.debug,
+    props.windowRef,
+    props.documentRef
+  ]);
+  const updateMiniProgramPhase = (next) => {
+    miniProgramPhaseRef.current = next;
+    setMiniProgramPhase(next);
+  };
+  const resetMiniProgramPhase = () => {
+    if (miniProgramRecoveryTimerRef.current !== null) clearTimeout(miniProgramRecoveryTimerRef.current);
+    miniProgramRecoveryTimerRef.current = null;
+    miniProgramRecoveryAtRef.current = 0;
+    updateMiniProgramPhase("idle");
+  };
+  const retry = () => {
+    resetMiniProgramPhase();
+    if (!active) return Promise.resolve(null);
+    return sessionRef.current?.retry() ?? Promise.resolve(null);
+  };
+  const cancel = (reason) => {
+    resetMiniProgramPhase();
+    sessionRef.current?.cancel(reason);
+  };
+  const openMiniProgram = async () => {
+    if (!["idle", "retry-launch"].includes(miniProgramPhaseRef.current)) return;
+    const session = sessionRef.current;
+    if (!session) return;
+    updateMiniProgramPhase("launching");
+    try {
+      await session.openMiniProgram();
+      if (sessionRef.current === session) {
+        updateMiniProgramPhase("awaiting");
+        miniProgramRecoveryAtRef.current = Date.now() + MINI_PROGRAM_LAUNCH_RECOVERY_MS;
+        if (miniProgramRecoveryTimerRef.current !== null) clearTimeout(miniProgramRecoveryTimerRef.current);
+        miniProgramRecoveryTimerRef.current = setTimeout(() => {
+          miniProgramRecoveryTimerRef.current = null;
+          const documentRef = props.documentRef || (typeof document === "undefined" ? null : document);
+          if (sessionRef.current === session && miniProgramPhaseRef.current === "awaiting" && session.canRetryMiniProgramLaunch() && documentRef?.visibilityState !== "hidden") {
+            updateMiniProgramPhase("retry-launch");
+          }
+        }, MINI_PROGRAM_LAUNCH_RECOVERY_MS);
+      }
+    } catch {
+      if (sessionRef.current === session) updateMiniProgramPhase("idle");
+    }
+  };
+  useImperativeHandle(forwardedRef, () => ({
+    get element() {
+      return hostRef.current;
+    },
+    retry,
+    cancel
+  }));
+  const loginMethod = props.loginMethod || "qr";
+  const className = ["xtj-login", `xtj-login--${loginMethod}`, props.className].filter(Boolean).join(" ");
+  return createElement("div", {
+    ref: hostRef,
+    className,
+    style: { ...getLoginRootStyle(loginMethod), ...props.style },
+    "data-state": status.kind,
+    "data-login-method": loginMethod,
+    "data-active": active ? "true" : "false"
+  }, [
+    createElement("style", {
+      key: "motion-styles",
+      "data-xtj-login-styles": "motion"
+    }, LOGIN_MOTION_STYLES),
+    createElement(LoginView, {
+      key: "view",
+      status,
+      active,
+      loginMethod,
+      onRetry: retry,
+      onMiniProgram: openMiniProgram,
+      miniProgramPhase
+    })
+  ]);
+});
+Login.displayName = "XTJLogin";
+export {
+  Login
+};

package/dist/session.js

@@ -0,0 +1,9 @@
+import { D, a, b, L, d, c } from "./chunks/index-Cuix-7nW.js";
+export {
+  D as DEFAULT_POLL_INTERVAL_MS,
+  a as DEFAULT_REQUEST_TIMEOUT_MS,
+  b as DEFAULT_TRANSACTION_TIMEOUT_MS,
+  L as LOGIN_STATUS,
+  d as LoginSession,
+  c as createLoginSession
+};

package/dist/vue.d.ts

@@ -0,0 +1,26 @@
+import type { LoginError, LoginGatewayOptions, LoginHandle, LoginResult, LoginStatus } from './index.js'
+
+export type { LoginHandle } from './index.js'
+
+export type LoginProps = {
+  appCode: string | number
+  active?: boolean
+  className?: string
+  class?: string
+  style?: string | Record<string, string> | Array<string | Record<string, string>>
+  platform?: 'web' | 'mobile-web' | string
+  loginMethod?: 'qr' | 'mini-program' | string
+  pollIntervalMs?: number
+  requestTimeoutMs?: number
+  timeoutMs?: number
+  debug?: boolean
+  gatewayOptions: LoginGatewayOptions
+  windowRef?: Window
+  documentRef?: Document
+}
+
+export const Login: import('vue').DefineComponent<LoginProps, LoginHandle, {}, {}, {}, {}, {}, {
+  success: (result: LoginResult) => void
+  error: (error: LoginError) => void
+  status: (status: LoginStatus) => void
+}>

package/dist/vue.js

@@ -0,0 +1,261 @@
+import { defineComponent, ref, onMounted, watch, onUnmounted, h } from "vue";
+import { L as LOGIN_STATUS, c as createLoginSession, t as toLoginError } from "./chunks/index-Cuix-7nW.js";
+import { g as getLoginRootStyle, L as LOGIN_MOTION_STYLES, i as isMiniProgramMethod, M as MINI_PROGRAM_LAUNCH_RECOVERY_MS, a as getMiniProgramPresentation, c as getMiniProgramButtonStyle, b as getMiniProgramIconStyle, d as getQrPresentation, e as getQrImageStyle, q as qrIconStyle, f as getQrLabelStyle, h as qrActionStyle, j as qrOverlayStyle, k as qrContentStyle } from "./chunks/ui-C58EkuFV.js";
+const QrLoginView = (status, retry, active) => {
+  const children = [];
+  const presentation = getQrPresentation(status, active);
+  if (status.loginImg) {
+    children.push(h("img", {
+      class: "xtj-login__qr",
+      src: status.loginImg,
+      alt: "登录二维码",
+      style: getQrImageStyle(Boolean(presentation))
+    }));
+  }
+  if (presentation) {
+    const stateContent = [];
+    if (presentation.icon) {
+      stateContent.push(h("img", {
+        class: [
+          "xtj-login__state-icon",
+          presentation.iconState ? `xtj-login__state-icon--${presentation.iconState}` : ""
+        ],
+        src: presentation.icon,
+        alt: "",
+        style: qrIconStyle,
+        "aria-hidden": "true"
+      }));
+    }
+    stateContent.push(h("span", {
+      class: "xtj-login__state-label",
+      style: getQrLabelStyle(Boolean(presentation.icon)),
+      role: "status",
+      "aria-live": "polite"
+    }, presentation.label));
+    if (presentation.action === "retry") {
+      children.push(h("button", {
+        class: "xtj-login__state xtj-login__state--action",
+        type: "button",
+        style: qrActionStyle,
+        onClick: retry,
+        "aria-label": presentation.label === "二维码已过期" ? "二维码已过期，点击重新获取" : presentation.label
+      }, stateContent));
+    } else {
+      children.push(h("div", {
+        class: "xtj-login__state",
+        style: qrOverlayStyle
+      }, stateContent));
+    }
+  }
+  return h("div", { class: "xtj-login__content", style: qrContentStyle }, children);
+};
+const MiniProgramLoginView = (status, retry, openMiniProgram, miniProgramPhase, active) => {
+  const presentation = getMiniProgramPresentation(status, miniProgramPhase, active);
+  const onClick = presentation.action === "retry" ? retry : presentation.action === "open" ? openMiniProgram : void 0;
+  return h("button", {
+    class: [`xtj-login__mini-button`, `xtj-login__mini-button--${presentation.tone}`],
+    type: "button",
+    style: getMiniProgramButtonStyle(presentation),
+    onClick,
+    disabled: presentation.disabled,
+    "aria-live": "polite"
+  }, [
+    h("img", {
+      class: [
+        "xtj-login__mini-icon",
+        presentation.iconState ? `xtj-login__mini-icon--${presentation.iconState}` : ""
+      ],
+      src: presentation.icon,
+      alt: "",
+      style: getMiniProgramIconStyle(presentation),
+      "aria-hidden": "true"
+    }),
+    h("span", presentation.label)
+  ]);
+};
+const LoginView = (status, loginMethod, retry, openMiniProgram, miniProgramPhase, active) => {
+  if (isMiniProgramMethod(loginMethod)) {
+    return MiniProgramLoginView(status, retry, openMiniProgram, miniProgramPhase, active);
+  }
+  return QrLoginView(status, retry, active);
+};
+const Login = defineComponent({
+  name: "XTJLogin",
+  props: {
+    appCode: { type: [String, Number], required: true },
+    active: { type: Boolean, default: true },
+    className: { type: String, default: "" },
+    class: { type: String, default: "" },
+    style: { type: [String, Object, Array], default: void 0 },
+    platform: { type: String, default: "web" },
+    loginMethod: { type: String, default: "qr" },
+    pollIntervalMs: { type: Number, default: void 0 },
+    requestTimeoutMs: { type: Number, default: void 0 },
+    timeoutMs: { type: Number, default: void 0 },
+    debug: { type: Boolean, default: false },
+    gatewayOptions: { type: Object, required: true },
+    windowRef: { type: Object, default: void 0 },
+    documentRef: { type: Object, default: void 0 }
+  },
+  emits: ["success", "error", "status"],
+  setup(props, { emit, expose }) {
+    const hostRef = ref(null);
+    const status = ref({ kind: LOGIN_STATUS.IDLE, platform: props.platform });
+    const miniProgramPhase = ref("idle");
+    let miniProgramRecoveryTimer = null;
+    let miniProgramRecoveryAt = 0;
+    let session = null;
+    const createSession = () => {
+      if (!props.active) {
+        session = null;
+        status.value = { kind: LOGIN_STATUS.IDLE, platform: props.platform };
+        return;
+      }
+      try {
+        session = createLoginSession({
+          gatewayOptions: props.gatewayOptions,
+          appCode: props.appCode,
+          platform: props.platform,
+          loginMethod: props.loginMethod,
+          pollIntervalMs: props.pollIntervalMs,
+          requestTimeoutMs: props.requestTimeoutMs,
+          timeoutMs: props.timeoutMs,
+          debug: props.debug,
+          windowRef: props.windowRef,
+          documentRef: props.documentRef,
+          onStatus: (next) => {
+            status.value = next;
+            if (next.kind === LOGIN_STATUS.QR_READY) {
+              if (miniProgramPhase.value === "awaiting" && Date.now() >= miniProgramRecoveryAt && session.canRetryMiniProgramLaunch()) {
+                miniProgramPhase.value = "retry-launch";
+              } else if (miniProgramPhase.value === "retry-launch" && session.canRetryMiniProgramLaunch() === false) {
+                miniProgramPhase.value = "awaiting";
+              }
+            }
+            emit("status", next);
+          },
+          onSuccess: (result) => emit("success", result),
+          onError: (error) => emit("error", error)
+        });
+        session.mount(hostRef.value);
+      } catch (error) {
+        try {
+          session?.unmount();
+        } catch {
+        }
+        const result = toLoginError(error, "init", false);
+        const next = { kind: LOGIN_STATUS.ERROR, platform: props.platform, ...result };
+        session = null;
+        status.value = next;
+        emit("status", next);
+        emit("error", result);
+        return;
+      }
+    };
+    const openMiniProgram = async () => {
+      if (!["idle", "retry-launch"].includes(miniProgramPhase.value)) return;
+      const activeSession = session;
+      if (!activeSession) return;
+      miniProgramPhase.value = "launching";
+      try {
+        await activeSession.openMiniProgram();
+        if (session === activeSession) {
+          miniProgramPhase.value = "awaiting";
+          miniProgramRecoveryAt = Date.now() + MINI_PROGRAM_LAUNCH_RECOVERY_MS;
+          if (miniProgramRecoveryTimer !== null) clearTimeout(miniProgramRecoveryTimer);
+          miniProgramRecoveryTimer = setTimeout(() => {
+            miniProgramRecoveryTimer = null;
+            const documentRef = props.documentRef || (typeof document === "undefined" ? null : document);
+            if (session === activeSession && miniProgramPhase.value === "awaiting" && activeSession.canRetryMiniProgramLaunch() && documentRef?.visibilityState !== "hidden") {
+              miniProgramPhase.value = "retry-launch";
+            }
+          }, MINI_PROGRAM_LAUNCH_RECOVERY_MS);
+        }
+      } catch {
+        if (session === activeSession) miniProgramPhase.value = "idle";
+      }
+    };
+    const resetMiniProgramPhase = () => {
+      if (miniProgramRecoveryTimer !== null) clearTimeout(miniProgramRecoveryTimer);
+      miniProgramRecoveryTimer = null;
+      miniProgramRecoveryAt = 0;
+      miniProgramPhase.value = "idle";
+    };
+    const retry = () => {
+      resetMiniProgramPhase();
+      if (!props.active) return Promise.resolve(null);
+      return session?.retry() ?? Promise.resolve(null);
+    };
+    const cancel = (reason) => {
+      resetMiniProgramPhase();
+      session?.cancel(reason);
+    };
+    expose({
+      get element() {
+        return hostRef.value;
+      },
+      retry,
+      cancel
+    });
+    onMounted(() => {
+      createSession();
+    });
+    watch(
+      [
+        () => props.active,
+        () => props.appCode,
+        () => props.platform,
+        () => props.loginMethod,
+        () => props.pollIntervalMs,
+        () => props.requestTimeoutMs,
+        () => props.timeoutMs,
+        () => props.debug,
+        () => props.windowRef,
+        () => props.documentRef,
+        () => Boolean(props.gatewayOptions),
+        () => props.gatewayOptions?.baseUrl,
+        () => props.gatewayOptions?.codeType,
+        () => props.gatewayOptions?.schemeTarget,
+        () => props.gatewayOptions?.schemeMiniPath,
+        () => props.gatewayOptions?.requestTimeoutMs,
+        () => props.gatewayOptions?.fetchImpl,
+        () => props.gatewayOptions?.paths?.genLoginId,
+        () => props.gatewayOptions?.paths?.checkLogin,
+        () => props.gatewayOptions?.paths?.miniProgramScheme
+      ],
+      () => {
+        session?.unmount();
+        session = null;
+        if (miniProgramRecoveryTimer !== null) clearTimeout(miniProgramRecoveryTimer);
+        miniProgramRecoveryTimer = null;
+        miniProgramRecoveryAt = 0;
+        miniProgramPhase.value = "idle";
+        createSession();
+      }
+    );
+    onUnmounted(() => {
+      if (miniProgramRecoveryTimer !== null) clearTimeout(miniProgramRecoveryTimer);
+      miniProgramRecoveryTimer = null;
+      miniProgramRecoveryAt = 0;
+      session?.unmount();
+      session = null;
+    });
+    return () => {
+      const loginMethod = props.loginMethod || "qr";
+      return h("div", {
+        ref: hostRef,
+        class: ["xtj-login", `xtj-login--${loginMethod}`, props.className || props.class].filter(Boolean),
+        style: [getLoginRootStyle(loginMethod), props.style],
+        "data-state": status.value.kind,
+        "data-login-method": loginMethod,
+        "data-active": props.active ? "true" : "false"
+      }, [
+        h("style", { "data-xtj-login-styles": "motion" }, LOGIN_MOTION_STYLES),
+        LoginView(status.value, loginMethod, retry, openMiniProgram, miniProgramPhase.value, props.active)
+      ]);
+    };
+  }
+});
+export {
+  Login
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "xtj-login-kit",
+  "version": "0.3.1",
+  "description": "可嵌入业务页面的星途径 Web 统一登录组件库",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "import": "./dist/react.js",
+      "default": "./dist/react.js"
+    },
+    "./vue": {
+      "types": "./dist/vue.d.ts",
+      "import": "./dist/vue.js",
+      "default": "./dist/vue.js"
+    },
+    "./session": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/session.js",
+      "default": "./dist/session.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  },
+  "peerDependencies": {
+    "react": ">=18",
+    "vue": ">=3"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "vue": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}