@tsingroc/tsingroc-components 5.0.0-alpha.20 → 5.0.0-alpha.22

package/dist/components/auth/CasdoorAuth.js

@@ -0,0 +1,156 @@
+import { c as _c } from "react/compiler-runtime";
+import Sdk from "casdoor-js-sdk";
+import { useEffect, useEffectEvent, useRef, useState, useSyncExternalStore } from "react";
+import { useSessionStoreInternal } from "./AuthProvider";
+import { EmbeddedAuthService } from "./EmbeddedAuth";
+import { fetcherWithBearerToken } from "./Fetcher";
+export class CasdoorAuthService {
+  #sdk;
+  #signinOrigin;
+  #signinPath;
+  constructor(options) {
+    this.#sdk = new Sdk(options.config);
+    this.#signinOrigin = options.signinOrigin || location.origin;
+    this.#signinPath = options.signinPath;
+  }
+  getSession() {
+    location.href = this.#sdk.getSigninUrl();
+    return Promise.reject(new Error("已跳转到登录页面，该错误用于中止登录流程，可以忽略。"));
+  }
+  async validate(token) {
+    // sdk 的类型声明有误
+    const resp = await this.#sdk.getUserInfo(token);
+    if ("status" in resp) {
+      throw new Error("登陆状态无效！");
+    }
+    return resp;
+  }
+
+  /**
+   * CasdoorAuthService 的特有函数。
+   * 使用 CasdoorAuthService 时，需要在项目中设置一个回调页面。
+   * 当用户完成登录，跳转到回调页面时，可调用此函数获取 access token。
+   * 若用户不经过登录流程进入回调页面，或者后端发生错误，则会抛出异常。
+   */
+  async callback() {
+    // sdk 的类型声明有误
+    const resp = await this.#sdk.signin(this.#signinOrigin, this.#signinPath);
+    const token = resp.token;
+    if (!token) {
+      throw new Error("登录 API 返回了异常的结果：" + JSON.stringify(resp));
+    }
+    return token;
+  }
+  fetcherMiddleware = fetcherWithBearerToken;
+  parseUserInfo(info) {
+    return info;
+  }
+}
+export function CasdoorCallback(props) {
+  const $ = _c(8);
+  const {
+    onSuccess,
+    onError,
+    success: t0,
+    error: t1,
+    children: t2
+  } = props;
+  const success = t0 === undefined ? "\u767B\u5F55\u6210\u529F" : t0;
+  const error = t1 === undefined ? "\u767B\u5F55\u8FC7\u7A0B\u53D1\u751F\u9519\u8BEF" : t1;
+  const children = t2 === undefined ? "\u6B63\u5728\u8DF3\u8F6C\u2026\u2026" : t2;
+  const sessionStore = useSessionStoreInternal("CasdoorCallback");
+  const service = sessionStore.service;
+  if (!(service instanceof CasdoorAuthService)) {
+    throw new Error("CasdoorCallback \u5FC5\u987B\u642D\u914D CasdoorAuthService \u4F7F\u7528\uFF01");
+  }
+  const [status, setStatus] = useState("loading");
+  const hasOngoingCallback = useRef(false);
+  let t3;
+  if ($[0] !== onError || $[1] !== onSuccess || $[2] !== service || $[3] !== sessionStore) {
+    t3 = () => {
+      if (hasOngoingCallback.current) {
+        return;
+      }
+      service.callback().then(token => {
+        setStatus("success");
+        sessionStore.load(token);
+        onSuccess?.();
+      }, err => {
+        setStatus("error");
+        onError?.(err);
+      });
+      hasOngoingCallback.current = true;
+    };
+    $[0] = onError;
+    $[1] = onSuccess;
+    $[2] = service;
+    $[3] = sessionStore;
+    $[4] = t3;
+  } else {
+    t3 = $[4];
+  }
+  const callback = useEffectEvent(t3);
+  let t4;
+  if ($[5] !== callback) {
+    t4 = () => {
+      callback();
+    };
+    $[5] = callback;
+    $[6] = t4;
+  } else {
+    t4 = $[6];
+  }
+  let t5;
+  if ($[7] === Symbol.for("react.memo_cache_sentinel")) {
+    t5 = [];
+    $[7] = t5;
+  } else {
+    t5 = $[7];
+  }
+  useEffect(t4, t5);
+  return status === "loading" ? children : status === "error" ? error : success;
+}
+export function CasdoorRoleCheck(props) {
+  const $ = _c(4);
+  const {
+    required,
+    forbidden,
+    error: t0,
+    children
+  } = props;
+  const error = t0 === undefined ? "\u60A8\u65E0\u6743\u8BBF\u95EE\u6B64\u9875\u9762\uFF01" : t0;
+  const sessionStore = useSessionStoreInternal("CasdoorRoleCheck");
+  if (!(sessionStore.service instanceof CasdoorAuthService || sessionStore.service instanceof EmbeddedAuthService)) {
+    throw new Error("CasdoorRoleCheck \u5FC5\u987B\u642D\u914D CasdoorAuthService \u6216 EmbeddedAuthService \u4F7F\u7528\uFF01");
+  }
+  let t1;
+  if ($[0] !== sessionStore) {
+    t1 = onChange => {
+      sessionStore.addEventListener(onChange);
+      return () => sessionStore.addEventListener(onChange);
+    };
+    $[0] = sessionStore;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  let t2;
+  if ($[2] !== sessionStore.session) {
+    t2 = () => sessionStore.session;
+    $[2] = sessionStore.session;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  const session = useSyncExternalStore(t1, t2);
+  if (!session) {
+    return error;
+  }
+  const userInfo = session.rawUserInfo;
+  const hasRequiredRole = required.some(role => userInfo.roles.includes(role));
+  const hasForbiddenRole = forbidden?.some(role_0 => userInfo.roles.includes(role_0));
+  if (!hasRequiredRole || hasForbiddenRole) {
+    return error;
+  }
+  return children;
+}

package/dist/components/auth/EmbeddedAuth.d.ts

@@ -0,0 +1,16 @@
+import type { SdkConfig } from "casdoor-js-sdk/lib/esm/sdk";
+import type { AuthService, UserInfo } from "./AuthService";
+import type { CasdoorUserInfo } from "./CasdoorAuth";
+import { fetcherWithBearerToken } from "./Fetcher";
+export interface EmbeddedAuthServiceOptions {
+    config: SdkConfig;
+    timeout?: number;
+}
+export declare class EmbeddedAuthService implements AuthService<string, CasdoorUserInfo> {
+    #private;
+    constructor(options: EmbeddedAuthServiceOptions);
+    getSession(): Promise<string>;
+    validate(token: string): Promise<CasdoorUserInfo>;
+    fetcherMiddleware: typeof fetcherWithBearerToken;
+    parseUserInfo(info: CasdoorUserInfo): UserInfo;
+}

package/dist/components/auth/EmbeddedAuth.js

@@ -0,0 +1,53 @@
+import Sdk from "casdoor-js-sdk";
+import { fetcherWithBearerToken } from "./Fetcher";
+export class EmbeddedAuthService {
+  #sdk;
+  #timeout;
+  constructor(options) {
+    this.#sdk = new Sdk(options.config);
+    this.#timeout = options.timeout || 5000;
+  }
+  getSession() {
+    if (!(window.parent && window.parent !== window)) {
+      return Promise.reject(new Error("无法在非嵌入式环境中使用 EmbeddedAuthService"));
+    }
+    return new Promise((resolve, reject) => {
+      const handleMessage = event => {
+        window.removeEventListener("message", handleMessage);
+        clearTimeout(timeout);
+        // 通常来说接收来自父页面的消息需要验证 origin，
+        // 但由于我们这里是在接受 access token，而 access token 没法造假，
+        // 因此只要对数据进行小心验证，可以不需要验证 origin
+        if (event.data && typeof event.data === "object") {
+          const data = event.data;
+          if (data.type === "TOKEN_RESPONSE" && typeof data.token === "string") {
+            resolve(data.token);
+            return;
+          }
+        }
+        reject(new Error("从父页面收到无效数据"));
+      };
+      const handleTimeout = () => {
+        window.removeEventListener("message", handleMessage);
+        reject(new Error("等待父页面回复超时"));
+      };
+      window.addEventListener("message", handleMessage);
+      window.parent.postMessage({
+        type: "REQUEST_TOKEN"
+      }, "*");
+      const timeout = setTimeout(handleTimeout, this.#timeout);
+    });
+  }
+  async validate(token) {
+    // sdk 的类型声明有误
+    const resp = await this.#sdk.getUserInfo(token);
+    if ("status" in resp) {
+      throw new Error("登陆状态无效！");
+    }
+    return resp;
+  }
+  fetcherMiddleware = fetcherWithBearerToken;
+  parseUserInfo(info) {
+    return info;
+  }
+}

package/dist/components/auth/Fetcher.d.ts

@@ -0,0 +1,30 @@
+import { type ReactNode } from "react";
+import type { SessionStore } from "./SessionStore";
+/** 一个与 {@linkcode fetch} 兼容的 fetcher 函数 */
+export type Fetcher = (resource: RequestInfo | URL, options?: RequestInit & FetcherExtraOptions) => Promise<Response>;
+/**
+ * Fetcher 类型可接受的额外选项。可以使用 TypeScript 向这个类型中加入额外内容：
+ *
+ * ```ts
+ * declare module "@tsingroc/tsingroc-components" {
+ *   interface FetcherExtraOptions {
+ *     customOption?: object; // 注意必须是可选参数
+ *   }
+ * }
+ * ```
+ */
+export interface FetcherExtraOptions {
+    loginOn401?: boolean;
+}
+export declare function fetcherWithBearerToken(token: string): (fetcher: Fetcher) => Fetcher;
+export declare function fetcherWithLoginOn401(sessionStore: SessionStore): (fetcher: Fetcher) => Fetcher;
+export declare function useFetcher(): Fetcher;
+export interface FetcherMiddlewareProps {
+    middleware: (fetcher: Fetcher) => Fetcher;
+    children: ReactNode;
+}
+export declare function FetcherMiddleware(props: FetcherMiddlewareProps): import("react/jsx-runtime").JSX.Element;
+export interface FetcherWithAuthProps {
+    children: ReactNode;
+}
+export declare function FetcherWithAuth(props: FetcherWithAuthProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/auth/Fetcher.js

@@ -0,0 +1,132 @@
+import { c as _c } from "react/compiler-runtime";
+import { createContext, use, useSyncExternalStore } from "react";
+import { useSessionStoreInternal } from "./AuthProvider";
+
+/** 一个与 {@linkcode fetch} 兼容的 fetcher 函数 */
+
+/**
+ * Fetcher 类型可接受的额外选项。可以使用 TypeScript 向这个类型中加入额外内容：
+ *
+ * ```ts
+ * declare module "@tsingroc/tsingroc-components" {
+ *   interface FetcherExtraOptions {
+ *     customOption?: object; // 注意必须是可选参数
+ *   }
+ * }
+ * ```
+ */
+import { jsx as _jsx } from "react/jsx-runtime";
+export function fetcherWithBearerToken(token) {
+  return fetcher => async (resource, options) => {
+    const headers = new Headers(options?.headers);
+    if (!headers.has("Authorization")) {
+      headers.set("Authorization", `Bearer ${token}`);
+    }
+    const resp = await fetcher(resource, {
+      ...options,
+      headers
+    });
+    return resp;
+  };
+}
+export function fetcherWithLoginOn401(sessionStore) {
+  return fetcher => async (resource, options) => {
+    const loggedIn = !!sessionStore.session;
+    const resp = await fetcher(resource, options);
+    if (resp.status === 401) {
+      await sessionStore.clear();
+      void sessionStore.get();
+      throw new Error(`对 ${resp.url} 的请求需要鉴权，但用户${loggedIn ? "登录状态已失效" : "未登录"}。`);
+    }
+    return resp;
+  };
+}
+const FetcherContext = /*#__PURE__*/createContext(fetch);
+export function useFetcher() {
+  return use(FetcherContext);
+}
+export function FetcherMiddleware(props) {
+  const $ = _c(6);
+  const {
+    middleware,
+    children
+  } = props;
+  const fetcher = use(FetcherContext);
+  let t0;
+  if ($[0] !== fetcher || $[1] !== middleware) {
+    t0 = middleware(fetcher);
+    $[0] = fetcher;
+    $[1] = middleware;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  let t1;
+  if ($[3] !== children || $[4] !== t0) {
+    t1 = /*#__PURE__*/_jsx(FetcherContext, {
+      value: t0,
+      children: children
+    });
+    $[3] = children;
+    $[4] = t0;
+    $[5] = t1;
+  } else {
+    t1 = $[5];
+  }
+  return t1;
+}
+export function FetcherWithAuth(props) {
+  const $ = _c(12);
+  const {
+    children
+  } = props;
+  const prevFetcher = use(FetcherContext);
+  const sessionStore = useSessionStoreInternal("FetcherWithAuth");
+  const service = sessionStore.service;
+  let t0;
+  if ($[0] !== sessionStore) {
+    t0 = onChange => {
+      sessionStore.addEventListener(onChange);
+      return () => sessionStore.addEventListener(onChange);
+    };
+    $[0] = sessionStore;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  let t1;
+  if ($[2] !== sessionStore.session) {
+    t1 = () => sessionStore.session;
+    $[2] = sessionStore.session;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  const session = useSyncExternalStore(t0, t1);
+  let t2;
+  if ($[4] !== prevFetcher || $[5] !== service || $[6] !== session || $[7] !== sessionStore) {
+    const fetcherWithAuth = session ? service.fetcherMiddleware(session.state)(prevFetcher) : prevFetcher;
+    t2 = fetcherWithLoginOn401(sessionStore)(fetcherWithAuth);
+    $[4] = prevFetcher;
+    $[5] = service;
+    $[6] = session;
+    $[7] = sessionStore;
+    $[8] = t2;
+  } else {
+    t2 = $[8];
+  }
+  const fetcher = t2;
+  let t3;
+  if ($[9] !== children || $[10] !== fetcher) {
+    t3 = /*#__PURE__*/_jsx(FetcherContext, {
+      value: fetcher,
+      children: children
+    });
+    $[9] = children;
+    $[10] = fetcher;
+    $[11] = t3;
+  } else {
+    t3 = $[11];
+  }
+  return t3;
+}

package/dist/components/auth/LocalAuth.d.ts

@@ -0,0 +1,70 @@
+import type { JwtPayload } from "jwt-decode";
+import type { AuthService, UserInfo } from "./AuthService";
+import { fetcherWithBearerToken } from "./Fetcher";
+export interface LocalAuthServiceOptions {
+    openLoginPage: () => void;
+    signinOrigin?: string;
+    signinPath?: string;
+}
+export declare class LocalAuthService implements AuthService<string, LocalUserInfo> {
+    #private;
+    constructor(options: LocalAuthServiceOptions);
+    getSession(): Promise<never>;
+    validate(token: string): Promise<LocalUserInfo>;
+    /**
+     * LocalAuthService 的特有函数。
+     * 使用 CasdoorAuthService 时，需要在项目中设置一个登录页面。
+     * 在用户在登录页面输入账号密码之后，调用此函数获取 access token。
+     * 若账号密码错误，或者后端发生错误，则会抛出异常。
+     */
+    login(username: string, password: string): Promise<string>;
+    fetcherMiddleware: typeof fetcherWithBearerToken;
+    parseUserInfo(info: LocalUserInfo): UserInfo;
+}
+export interface LocalTokenPayload extends JwtPayload {
+    /** Token 的过期时间（Unix 时间戳）。*/
+    exp: number;
+    /** Token 的生效时间（Unix 时间戳）。*/
+    nbf: number;
+    /** Token 的签发时间（Unix 时间戳）。*/
+    iat: number;
+    /** 用户信息 */
+    User: {
+        /** 注册时间。*/
+        createTime: string;
+        /** 用户的 UUID。*/
+        id?: string;
+        /** 用户名。*/
+        username?: string;
+        /** 是否已删除。*/
+        deleted?: boolean;
+        /** 用户的角色。*/
+        role: {
+            /** 角色的 UUID。*/
+            id: string;
+            /** 角色名。*/
+            name: string;
+            /** 角色的显示名。*/
+            display_name: string;
+            /** 角色拥有的权限。*/
+            functions: string[];
+            /** 角色的优先级。*/
+            priority: number;
+        };
+        /** 用户的角色的 UUID。*/
+        roleId: string;
+    };
+}
+export interface LocalUserInfo {
+    /** 用户的 UUID。*/
+    id?: string;
+    /** 用户名。*/
+    username?: string;
+    /** 显示名。*/
+    displayName?: string;
+    /** 创建时间。*/
+    createdAt: string;
+    /** 更新时间。*/
+    updatedAt: string;
+}
+export declare function useLocalLogin(): (username: string, password: string) => Promise<import("./SessionStore").Session>;

package/dist/components/auth/LocalAuth.js

@@ -0,0 +1,84 @@
+import { c as _c } from "react/compiler-runtime";
+import { useSessionStoreInternal } from "./AuthProvider";
+import { fetcherWithBearerToken } from "./Fetcher";
+export class LocalAuthService {
+  #openLoginPage;
+  #signinOrigin;
+  #signinPath;
+  constructor(options) {
+    this.#openLoginPage = options.openLoginPage;
+    this.#signinOrigin = options.signinOrigin ?? location.origin;
+    this.#signinPath = options.signinPath ?? "/api/signin";
+  }
+  getSession() {
+    this.#openLoginPage();
+    return Promise.reject(new Error("已跳转到登录页面，该错误用于中止登录流程，可以忽略。"));
+  }
+  async validate(token) {
+    const resp = await fetch(new URL("/api/userInfo", this.#signinOrigin), {
+      headers: {
+        Authorization: `Bearer ${token}`
+      }
+    });
+    if (resp.status !== 200) {
+      throw new Error("登陆状态无效！");
+    }
+    const json = await resp.json();
+    if (!json.data) {
+      throw new Error("登陆状态无效！");
+    }
+    return json.data;
+  }
+
+  /**
+   * LocalAuthService 的特有函数。
+   * 使用 CasdoorAuthService 时，需要在项目中设置一个登录页面。
+   * 在用户在登录页面输入账号密码之后，调用此函数获取 access token。
+   * 若账号密码错误，或者后端发生错误，则会抛出异常。
+   */
+  async login(username, password) {
+    const resp = await fetch(new URL(this.#signinPath, this.#signinOrigin), {
+      method: "post",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        username,
+        password
+      })
+    });
+    if (resp.status !== 200) {
+      throw new Error("账号或密码错误！");
+    }
+    const json = await resp.json();
+    const token = json.token;
+    if (typeof token !== "string") {
+      throw new Error("登录 API 返回了异常的结果：" + JSON.stringify(json));
+    }
+    return token;
+  }
+  fetcherMiddleware = fetcherWithBearerToken;
+  parseUserInfo(info) {
+    return {
+      name: info.displayName ?? info.username ?? "未命名用户"
+    };
+  }
+}
+export function useLocalLogin() {
+  const $ = _c(3);
+  const sessionStore = useSessionStoreInternal("useLocalLogin");
+  const service = sessionStore.service;
+  if (!(service instanceof LocalAuthService)) {
+    throw new Error("useLocalLogin \u5FC5\u987B\u642D\u914D LocalAuthService \u4F7F\u7528\uFF01");
+  }
+  let t0;
+  if ($[0] !== service || $[1] !== sessionStore) {
+    t0 = async (username, password) => sessionStore.load(await service.login(username, password));
+    $[0] = service;
+    $[1] = sessionStore;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  return t0;
+}

package/dist/components/auth/LoginCheck.d.ts

@@ -0,0 +1,13 @@
+import { type ReactNode } from "react";
+import type { Session } from "./SessionStore";
+export interface LoginCheckProps {
+    onValidated?: (session: Session) => void;
+    onRevalidated?: (session: Session) => void;
+    onFailed?: (err: unknown) => void;
+    onInvalidated?: (err: unknown) => void;
+    onBeforeGetSession?: () => void;
+    loading?: ReactNode;
+    failed?: ReactNode;
+    children: ReactNode;
+}
+export declare function LoginCheck(props: LoginCheckProps): ReactNode;

package/dist/components/auth/LoginCheck.js

@@ -0,0 +1,54 @@
+import { useEffect, useEffectEvent, useState, useSyncExternalStore } from "react";
+import { useSessionStoreInternal } from "./AuthProvider";
+export function LoginCheck(props) {
+  const {
+    onValidated,
+    onRevalidated,
+    onFailed,
+    onInvalidated,
+    onBeforeGetSession,
+    loading = "正在登录……",
+    failed = "登录失败",
+    children
+  } = props;
+  const sessionStore = useSessionStoreInternal("LoginCheck");
+  const session = useSyncExternalStore(onChange => {
+    sessionStore.addEventListener(onChange);
+    return () => sessionStore.addEventListener(onChange);
+  }, () => sessionStore.session);
+  const [status, setStatus] = useState(session ? "loaded" : "loading");
+  const onSessionStoreEvent = useEffectEvent(event => {
+    switch (event.type) {
+      case "failed":
+        onFailed?.(event.reason);
+        break;
+      case "validated":
+        onValidated?.(event.session);
+        break;
+      case "revalidated":
+        onRevalidated?.(event.session);
+        break;
+      case "invalidated":
+        onInvalidated?.(event.reason);
+        break;
+    }
+  });
+  useEffect(() => {
+    sessionStore.addEventListener(onSessionStoreEvent);
+    return () => sessionStore.removeEventListener(onSessionStoreEvent);
+  }, [sessionStore]);
+  const startLoading = useEffectEvent(async () => {
+    try {
+      onBeforeGetSession?.();
+      void (await sessionStore.get());
+    } finally {
+      setStatus("loaded");
+    }
+  });
+  useEffect(() => {
+    if (status === "loading") {
+      startLoading();
+    }
+  }, [status]);
+  return status === "loading" ? loading : session ? children : failed;
+}

package/dist/components/auth/SessionStore.d.ts

@@ -0,0 +1,68 @@
+import type { AuthService, UserInfo } from "./AuthService";
+export interface SessionStoreOptions {
+    /**
+     * 是否将状态保存到 localStorage，并在初始化时自动恢复。
+     * 注意该功能只支持状态为字符串的 AuthService 实现。
+     * @default true
+     */
+    persistent?: boolean;
+    /** 将状态保存到 localStorage 时使用的 key。 @default "access_token" */
+    persistentKey?: string;
+    /** 自动检查登录状态是否有效的间隔时间（单位毫秒），若为 0 则不再定期检查。 @default 0 */
+    revalidateInterval?: number;
+    /** 是否在窗口/标签页获得焦点时立即检查登录状态是否有效。 @default false */
+    revalidateOnFocus?: boolean;
+    /** 是否在网络连接恢复时立即检查登录状态是否有效。 @default false */
+    revalidateOnReconnect?: boolean;
+}
+export declare class SessionStore {
+    #private;
+    get service(): AuthService<unknown, unknown>;
+    get session(): Session | null;
+    constructor(service: AuthService<string>, options?: Readonly<SessionStoreOptions>);
+    constructor(service: AuthService, options?: Readonly<SessionStoreOptions & {
+        persistent: false;
+    }>);
+    /**
+     * 获取会话。
+     *
+     * 如果当前已经有会话，那么直接返回会话。
+     * 如果当前没有会话，那么获取一个新的会话（通常是登录），失败时抛出异常。
+     * 返回的 Promise 可能永远不会 resolve，也可能立即 resolve。
+     */
+    get(): Promise<Session>;
+    /** 加载并验证一个外部的会话状态。有效时更新并返回 Session，无效时抛出异常。 */
+    load(state: unknown): Promise<Session>;
+    /** 在线验证当前保存的会话是否有效。有效时返回 Session，无效或无会话时清除状态并抛出异常。 */
+    validate(): Promise<Session>;
+    /** 在线验证当前保存的会话是否有效。无效时清除状态，有效或无会话时不做任何操作。返回会话是否有效。 */
+    revalidate(): Promise<boolean>;
+    /** 立即结束会话并清除状态。如果当前无会话则不做任何操作。 */
+    clear(): Promise<void>;
+    addEventListener(listener: SessionStoreEventListener): void;
+    removeEventListener(listener: SessionStoreEventListener): void;
+}
+/**
+ * SessionStore 发出的事件类型。
+ *
+ * - validated：会话首次验证成功。
+ * - revalidated：会话重新验证成功。
+ * - failed: 会话创建或首次验证失败。
+ * - invalidated：会话失效。
+ */
+export type SessionStoreEvent = {
+    type: "validated" | "revalidated";
+    session: Session;
+} | {
+    type: "failed" | "invalidated";
+    reason: unknown;
+};
+export type SessionStoreEventListener = (event: SessionStoreEvent) => void;
+export interface Session {
+    /** 特定于实现的会话状态。 */
+    state: unknown;
+    /** 特定于实现的用户信息。 */
+    rawUserInfo: unknown;
+    /** 用户的个人信息。*/
+    userInfo: UserInfo;
+}