@tsingroc/tsingroc-components 5.0.0-alpha.21 → 5.0.0-alpha.23

package/dist/components/auth/CasdoorAuth.js

@@ -0,0 +1,180 @@
+import { c as _c } from "react/compiler-runtime";
+import Sdk from "casdoor-js-sdk";
+import { jwtDecode } from "jwt-decode";
+import { useEffect, useEffectEvent, useRef, useState, useSyncExternalStore } from "react";
+import { useSessionStoreInternal } from "./AuthProvider"; // oxlint-disable-line no-unused-vars
+
+import { EmbeddedAuthService } from "./EmbeddedAuth";
+import { fetcherWithBearerToken } from "./Fetcher";
+// oxlint-disable-line no-unused-vars
+
+/**
+ * 基于 Casdoor 的鉴权服务。该鉴权服务的登录流程如下：
+ *
+ * 1. 调用 {@linkcode CasdoorAuthService.getSession | getSession()} 跳转到 SSO 登录页面。
+ * 2. 用户在登录页面完成登录，跳转到回调页面。
+ * 3. 回调页面调用 {@linkcode CasdoorAuthService.callback | callback()} 获取 token。
+ *
+ * 当使用 {@linkcode AuthProvider} 时，第 1 步由 {@linkcode LoginCheck} 完成，
+ * 第 3 步由 {@linkcode CasdoorCallback} 完成。
+ */
+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;
+  }
+
+  /**
+   * 解析 token 中的内容。
+   * Token 可以通过 `useSession().state` 获取。
+   */
+  decodeToken(token) {
+    return jwtDecode(token);
+  }
+}
+/** Casdoor 回调组件。请将该组件放置在 {@linkcode CasdoorAuthService} 中设定的回调路径上。 */
+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;
+}
+/** 检查 Casdoor 用户的角色（role），限制只有特定角色的用户才能访问内部的组件。 */
+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,38 @@
+import type { SdkConfig } from "casdoor-js-sdk/lib/esm/sdk";
+import { type IframeHTMLAttributes, type ReactNode, type RefAttributes } from "react";
+import type { AuthService, UserInfo } from "./AuthService";
+import { type CasdoorTokenPayload, type CasdoorUserInfo } from "./CasdoorAuth";
+import { fetcherWithBearerToken } from "./Fetcher";
+export interface EmbeddedAuthServiceOptions {
+    config: SdkConfig;
+    timeout?: number;
+}
+/**
+ * 嵌入式鉴权服务，只能在 iframe 内使用。该鉴权服务的登录流程如下：
+ *
+ * 1. 调用 {@linkcode EmbeddedAuthService.getSession | getSession()} 向父页面获取 token。
+ * 2. 父页面响应请求，提供 token。
+ * 3. {@linkcode EmbeddedAuthService.getSession | getSession()} 返回 token。
+ *
+ * 当使用 {@linkcode AuthProvider} 时，第 1、3 步由 {@linkcode LoginCheck} 完成，
+ * 第 2 步由父页面中的 {@linkcode Embed} 完成。
+ */
+export declare class EmbeddedAuthService implements AuthService<string, CasdoorUserInfo> {
+    #private;
+    constructor(options: EmbeddedAuthServiceOptions);
+    getSession(): Promise<string>;
+    validate(token: string): Promise<CasdoorUserInfo>;
+    readonly fetcherMiddleware: typeof fetcherWithBearerToken;
+    parseUserInfo(info: CasdoorUserInfo): UserInfo;
+    /**
+     * 解析 token 中的内容。
+     * Token 可以通过 `useSession().state` 获取。
+     */
+    decodeToken(token: string): CasdoorTokenPayload;
+}
+/**
+ * 嵌入一个使用了 {@linkcode EmbeddedAuthService} 的页面。
+ * 该组件必须搭配 {@linkcode CasdoorAuthService} 或 {@linkcode EmbeddedAuthService}，并且在 {@linkcode LoginCheck} 内部使用。
+ * 该组件只负责向子页面提供 token，其它方面的用法和 `<iframe>` 完全相同。
+ */
+export declare function Embed(props: IframeHTMLAttributes<HTMLIFrameElement> & RefAttributes<HTMLIFrameElement>): ReactNode;

package/dist/components/auth/EmbeddedAuth.js

@@ -0,0 +1,205 @@
+import { c as _c } from "react/compiler-runtime";
+import Sdk from "casdoor-js-sdk";
+import { jwtDecode } from "jwt-decode";
+import { useEffectEvent, useSyncExternalStore } from "react";
+import { useSessionStoreInternal } from "./AuthProvider"; // oxlint-disable-line no-unused-vars
+
+import { CasdoorAuthService } from "./CasdoorAuth";
+import { fetcherWithBearerToken } from "./Fetcher";
+// oxlint-disable-line no-unused-vars
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * 嵌入式鉴权服务，只能在 iframe 内使用。该鉴权服务的登录流程如下：
+ *
+ * 1. 调用 {@linkcode EmbeddedAuthService.getSession | getSession()} 向父页面获取 token。
+ * 2. 父页面响应请求，提供 token。
+ * 3. {@linkcode EmbeddedAuthService.getSession | getSession()} 返回 token。
+ *
+ * 当使用 {@linkcode AuthProvider} 时，第 1、3 步由 {@linkcode LoginCheck} 完成，
+ * 第 2 步由父页面中的 {@linkcode Embed} 完成。
+ */
+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;
+  }
+
+  /**
+   * 解析 token 中的内容。
+   * Token 可以通过 `useSession().state` 获取。
+   */
+  decodeToken(token) {
+    return jwtDecode(token);
+  }
+}
+
+/**
+ * 嵌入一个使用了 {@linkcode EmbeddedAuthService} 的页面。
+ * 该组件必须搭配 {@linkcode CasdoorAuthService} 或 {@linkcode EmbeddedAuthService}，并且在 {@linkcode LoginCheck} 内部使用。
+ * 该组件只负责向子页面提供 token，其它方面的用法和 `<iframe>` 完全相同。
+ */
+export function Embed(props) {
+  const $ = _c(16);
+  const sessionStore = useSessionStoreInternal("useSession");
+  if (!(sessionStore.service instanceof CasdoorAuthService || sessionStore.service instanceof EmbeddedAuthService)) {
+    throw new Error("CasdoorRoleCheck \u5FC5\u987B\u642D\u914D CasdoorAuthService \u6216 EmbeddedAuthService \u4F7F\u7528\uFF01");
+  }
+  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);
+  if (!session) {
+    throw new Error("\u5F53\u524D\u7528\u6237\u672A\u767B\u5F55\uFF0C\u65E0\u6CD5\u83B7\u53D6\u4F1A\u8BDD\u3002\u8BF7\u786E\u4FDD\u53EA\u5728 LoginCheck \u5185\u90E8\u4F7F\u7528 Embed\u3002");
+  }
+  const {
+    state: token
+  } = session;
+  let t2;
+  if ($[4] !== props.src || $[5] !== token) {
+    t2 = (event, elem) => {
+      if (!props.src) {
+        return;
+      }
+      if (event.source !== elem.contentWindow) {
+        return;
+      }
+      const data = event.data;
+      if (typeof data !== "object" || !data || !("type" in data) || typeof data.type !== "string") {
+        return;
+      }
+      if (data.type === "REQUEST_TOKEN") {
+        elem.contentWindow?.postMessage({
+          type: "TOKEN_RESPONSE",
+          token
+        }, new URL(props.src).origin);
+      }
+    };
+    $[4] = props.src;
+    $[5] = token;
+    $[6] = t2;
+  } else {
+    t2 = $[6];
+  }
+  const onMessage = useEffectEvent(t2);
+  let ref;
+  let rest;
+  if ($[7] !== props) {
+    ({
+      ref,
+      ...rest
+    } = props);
+    $[7] = props;
+    $[8] = ref;
+    $[9] = rest;
+  } else {
+    ref = $[8];
+    rest = $[9];
+  }
+  let t3;
+  if ($[10] !== onMessage || $[11] !== ref) {
+    t3 = elem_0 => {
+      if (!elem_0) {
+        return;
+      }
+      const listener = event_0 => onMessage(event_0, elem_0);
+      window.addEventListener("message", listener);
+      let cleanup = undefined;
+      if (typeof ref === "function") {
+        const cleanupOrUndefined = ref(elem_0);
+        if (typeof cleanupOrUndefined === "function") {
+          cleanup = cleanupOrUndefined;
+        } else {
+          cleanup = () => ref(null);
+        }
+      } else {
+        if (ref) {
+          ref.current = elem_0;
+          cleanup = () => ref.current = null;
+        }
+      }
+      return () => {
+        cleanup?.();
+        window.removeEventListener("message", listener);
+      };
+    };
+    $[10] = onMessage;
+    $[11] = ref;
+    $[12] = t3;
+  } else {
+    t3 = $[12];
+  }
+  let t4;
+  if ($[13] !== rest || $[14] !== t3) {
+    t4 = /*#__PURE__*/_jsx("iframe", {
+      ref: t3,
+      ...rest
+    });
+    $[13] = rest;
+    $[14] = t3;
+    $[15] = t4;
+  } else {
+    t4 = $[15];
+  }
+  return t4;
+}

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

@@ -0,0 +1,38 @@
+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;
+}
+/** 在请求中添加 Authorization 头的 fetcher 中间件。 */
+export declare function fetcherWithBearerToken(token: string): (fetcher: Fetcher) => Fetcher;
+/** 在请求返回 401 错误时自动尝试登录的 fetcher 中间件。 */
+export declare function fetcherWithLoginOn401(sessionStore: SessionStore): (fetcher: Fetcher) => Fetcher;
+/** 获取当前上下文的 fetcher。 */
+export declare function useFetcher(): Fetcher;
+export interface FetcherMiddlewareProps {
+    middleware: (fetcher: Fetcher) => Fetcher;
+    children: ReactNode;
+}
+/** 为内部的组件添加额外的 fetcher 中间件，例如在发生错误时弹出警告。 */
+export declare function FetcherMiddleware(props: FetcherMiddlewareProps): ReactNode;
+export interface FetcherWithAuthProps {
+    children: ReactNode;
+}
+/**
+ * 为内部的组件的 fetcher 添加 Authorization 头。
+ * 默认设置下，{@linkcode AuthProvider} 已经提供了这个中间件，不需要另外添加。
+ */
+export declare function FetcherWithAuth(props: FetcherWithAuthProps): ReactNode;

package/dist/components/auth/Fetcher.js

@@ -0,0 +1,142 @@
+import { c as _c } from "react/compiler-runtime";
+import { createContext, use, useSyncExternalStore } from "react";
+import { useSessionStoreInternal } from "./AuthProvider"; // oxlint-disable-line no-unused-vars
+
+/** 一个与 {@linkcode fetch} 兼容的 fetcher 函数 */
+
+/**
+ * Fetcher 类型可接受的额外选项。可以使用 TypeScript 向这个类型中加入额外内容：
+ *
+ * ```ts
+ * declare module "@tsingroc/tsingroc-components" {
+ *   interface FetcherExtraOptions {
+ *     customOption?: object; // 注意必须是可选参数
+ *   }
+ * }
+ * ```
+ */
+import { jsx as _jsx } from "react/jsx-runtime";
+/** 在请求中添加 Authorization 头的 fetcher 中间件。 */
+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;
+  };
+}
+
+/** 在请求返回 401 错误时自动尝试登录的 fetcher 中间件。 */
+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);
+
+/** 获取当前上下文的 fetcher。 */
+export function useFetcher() {
+  return use(FetcherContext);
+}
+/** 为内部的组件添加额外的 fetcher 中间件，例如在发生错误时弹出警告。 */
+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;
+}
+/**
+ * 为内部的组件的 fetcher 添加 Authorization 头。
+ * 默认设置下，{@linkcode AuthProvider} 已经提供了这个中间件，不需要另外添加。
+ */
+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,90 @@
+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;
+}
+/**
+ * 用于内网使用的鉴权服务，目前只有风功率预测系统在使用这个鉴权服务。该鉴权服务的登录流程如下：
+ *
+ * 1. 调用 {@linkcode LocalAuthService.getSession | getSession()} 跳转到登录页面。
+ *    这个操作的具体实现由初始化时的设置项 {@linkcode LocalAuthServiceOptions.openLoginPage | openLoginPage} 提供。
+ *    用户需要自行实现跳转操作，可以直接修改 {@linkcode window.location}，也可以使用 router 提供的导航功能。
+ * 2. 用户在登录页面输入账号密码，调用 {@linkcode LocalAuthService.login | login()} 得到 token。
+ *
+ * 当使用 {@linkcode AuthProvider} 时，第 1 步会由 {@linkcode LoginCheck} 自动调用，
+ * 第 2 步可以通过 {@linkcode useLocalLogin} 获取到登录函数。
+ */
+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>;
+    readonly fetcherMiddleware: typeof fetcherWithBearerToken;
+    parseUserInfo(info: LocalUserInfo): UserInfo;
+    /**
+     * 解析 token 中的内容。
+     * Token 可以通过 `useSession().state` 获取。
+     */
+    decodeToken(token: string): LocalTokenPayload;
+}
+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;
+}
+/**
+ * 获取 {@linkcode LocalAuthService} 的登录函数。
+ * 返回的函数只负责使用账号密码登录并将得到的 token 存入 session store，用户需要自行实现登录完成后的跳转。
+ */
+export declare function useLocalLogin(): (username: string, password: string) => Promise<import("./SessionStore").Session>;