@longzai-intelligence-auth/react 0.0.2

package/dist/components/authenticated.d.ts

@@ -0,0 +1,7 @@
+import { type ReactNode } from "react";
+export type AuthenticatedProps = {
+    children: ReactNode;
+    fallback?: ReactNode;
+    loadingFallback?: ReactNode;
+};
+export declare function Authenticated({ children, fallback, loadingFallback }: AuthenticatedProps): ReactNode;

package/dist/components/authenticated.js

@@ -0,0 +1,11 @@
+import { useSession } from "../hooks/use-session";
+export function Authenticated({ children, fallback = null, loadingFallback = null, }) {
+    const { isAuthenticated, isLoading } = useSession();
+    if (isLoading) {
+        return loadingFallback;
+    }
+    if (!isAuthenticated) {
+        return fallback;
+    }
+    return children;
+}

package/dist/context/auth-provider.d.ts

@@ -0,0 +1,22 @@
+import { type ReactNode } from "react";
+import type { BaseAuthClient, AuthStrategyType, TokenStorage, StorageType, SessionState } from "@longzai-intelligence-auth/sdk";
+import type { LoginRequest, RegisterRequest } from "@longzai-intelligence-auth/core";
+export type AuthProviderProps = {
+    baseUrl: string;
+    apiPrefix?: string;
+    strategy?: AuthStrategyType;
+    storageType?: StorageType;
+    children: ReactNode;
+};
+export type AuthContextValue = {
+    session: SessionState;
+    client: BaseAuthClient;
+    storage: TokenStorage;
+    strategy: AuthStrategyType;
+    login: (data: LoginRequest) => Promise<void>;
+    register: (data: RegisterRequest) => Promise<void>;
+    logout: () => Promise<void>;
+    refreshSession: () => Promise<void>;
+};
+export declare function AuthProvider({ baseUrl, apiPrefix, strategy, storageType, children }: AuthProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useAuthContext(): AuthContextValue;

package/dist/context/auth-provider.js

@@ -0,0 +1,100 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useState, useCallback, useRef } from "react";
+import { createAuthClient, createTokenStorage } from "@longzai-intelligence-auth/sdk";
+const AuthContext = createContext(null);
+export function AuthProvider({ baseUrl, apiPrefix, strategy = "jwt", storageType = "localStorage", children, }) {
+    const clientRef = useRef(createAuthClient({ baseUrl, apiPrefix, strategy }));
+    const storageRef = useRef(createTokenStorage(storageType));
+    const [session, setSession] = useState({
+        user: null,
+        isLoading: true,
+        isAuthenticated: false,
+        error: null,
+    });
+    useEffect(() => {
+        const token = storageRef.current.getToken();
+        if (!token) {
+            setSession({ user: null, isLoading: false, isAuthenticated: false, error: null });
+            return;
+        }
+        clientRef.current.getProfile(token)
+            .then((data) => {
+            setSession({ user: data.user, isLoading: false, isAuthenticated: true, error: null });
+        })
+            .catch(() => {
+            storageRef.current.clear();
+            setSession({ user: null, isLoading: false, isAuthenticated: false, error: null });
+        });
+    }, []);
+    const login = useCallback(async (data) => {
+        setSession((prev) => ({ ...prev, isLoading: true, error: null }));
+        try {
+            const response = await clientRef.current.login(data);
+            storageRef.current.setToken(response.accessToken);
+            storageRef.current.setRefreshToken(response.refreshToken);
+            const profile = await clientRef.current.getProfile(response.accessToken);
+            const user = profile.user ?? null;
+            setSession({ user, isLoading: false, isAuthenticated: true, error: null });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "登录失败";
+            setSession((prev) => ({ ...prev, isLoading: false, error: message }));
+            throw error;
+        }
+    }, []);
+    const register = useCallback(async (data) => {
+        setSession((prev) => ({ ...prev, isLoading: true, error: null }));
+        try {
+            await clientRef.current.register(data);
+            setSession((prev) => ({ ...prev, isLoading: false }));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "注册失败";
+            setSession((prev) => ({ ...prev, isLoading: false, error: message }));
+            throw error;
+        }
+    }, []);
+    const logout = useCallback(async () => {
+        const token = storageRef.current.getToken();
+        if (token) {
+            try {
+                await clientRef.current.logout(token);
+            }
+            catch {
+            }
+        }
+        storageRef.current.clear();
+        setSession({ user: null, isLoading: false, isAuthenticated: false, error: null });
+    }, []);
+    const refreshSession = useCallback(async () => {
+        const token = storageRef.current.getToken();
+        if (!token)
+            return;
+        setSession((prev) => ({ ...prev, isLoading: true }));
+        try {
+            const data = await clientRef.current.getProfile(token);
+            setSession({ user: data.user, isLoading: false, isAuthenticated: true, error: null });
+        }
+        catch {
+            setSession((prev) => ({ ...prev, isLoading: false }));
+        }
+    }, []);
+    const value = {
+        session,
+        client: clientRef.current,
+        storage: storageRef.current,
+        strategy,
+        login,
+        register,
+        logout,
+        refreshSession,
+    };
+    return (_jsx(AuthContext.Provider, { value: value, children: children }));
+}
+export function useAuthContext() {
+    const context = useContext(AuthContext);
+    if (!context) {
+        throw new Error("useAuthContext 必须在 AuthProvider 内使用");
+    }
+    return context;
+}

package/dist/hooks/use-auth.d.ts

@@ -0,0 +1,7 @@
+export declare function useAuth(): {
+    login: (data: import("@longzai-intelligence-auth/core").LoginRequest) => Promise<void>;
+    register: (data: import("@longzai-intelligence-auth/core").RegisterRequest) => Promise<void>;
+    logout: () => Promise<void>;
+    refreshSession: () => Promise<void>;
+    strategy: import("@longzai-intelligence-auth/sdk").AuthStrategyType;
+};

package/dist/hooks/use-auth.js

@@ -0,0 +1,5 @@
+import { useAuthContext } from "../context/auth-provider";
+export function useAuth() {
+    const { login, register, logout, refreshSession, strategy } = useAuthContext();
+    return { login, register, logout, refreshSession, strategy };
+}

package/dist/hooks/use-permission.d.ts

@@ -0,0 +1,4 @@
+export declare function usePermission(): {
+    hasPermission: boolean;
+    isLoading: boolean;
+};

package/dist/hooks/use-permission.js

@@ -0,0 +1,7 @@
+import { useAuthContext } from "../context/auth-provider";
+export function usePermission() {
+    const { session, storage } = useAuthContext();
+    const token = storage.getToken();
+    const hasPermission = session.isAuthenticated && !!token;
+    return { hasPermission, isLoading: session.isLoading };
+}

package/dist/hooks/use-session.d.ts

@@ -0,0 +1 @@
+export declare function useSession(): import("@longzai-intelligence-auth/sdk").SessionState;

package/dist/hooks/use-session.js

@@ -0,0 +1,5 @@
+import { useAuthContext } from "../context/auth-provider";
+export function useSession() {
+    const { session } = useAuthContext();
+    return session;
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { AuthProvider, useAuthContext } from "./context/auth-provider";
+export type { AuthProviderProps, AuthContextValue } from "./context/auth-provider";
+export { useSession } from "./hooks/use-session";
+export { useAuth } from "./hooks/use-auth";
+export { usePermission } from "./hooks/use-permission";
+export { Authenticated } from "./components/authenticated";
+export type { AuthenticatedProps } from "./components/authenticated";
+export { createAuthClient, AuthClientError } from "@longzai-intelligence-auth/sdk";
+export type { AuthClientOptions, AuthStrategyType, BaseAuthClient, JwtAuthClient } from "@longzai-intelligence-auth/sdk";
+export { createTokenStorage } from "@longzai-intelligence-auth/sdk";
+export type { TokenStorage } from "@longzai-intelligence-auth/sdk";
+export { createTokenInterceptor, createRefreshInterceptor } from "@longzai-intelligence-auth/sdk";
+export type { StorageType, AuthUser, SessionState, } from "@longzai-intelligence-auth/sdk";

package/dist/index.js

@@ -0,0 +1,8 @@
+export { AuthProvider, useAuthContext } from "./context/auth-provider";
+export { useSession } from "./hooks/use-session";
+export { useAuth } from "./hooks/use-auth";
+export { usePermission } from "./hooks/use-permission";
+export { Authenticated } from "./components/authenticated";
+export { createAuthClient, AuthClientError } from "@longzai-intelligence-auth/sdk";
+export { createTokenStorage } from "@longzai-intelligence-auth/sdk";
+export { createTokenInterceptor, createRefreshInterceptor } from "@longzai-intelligence-auth/sdk";

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@longzai-intelligence-auth/react",
+  "version": "0.0.2",
+  "license": "UNLICENSED",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "bun build src/index.ts --outdir dist --target bun",
+    "build:declaration": "tsgo --declaration --emitDeclarationOnly --outDir dist -p tsconfig/app.json",
+    "build:prod": "NODE_ENV=production tsdown",
+    "prepublishOnly": "bun run build:prod",
+    "typecheck": "bun run typecheck:app && bun run typecheck:node && bun run typecheck:test",
+    "typecheck:app": "tsgo --noEmit -p tsconfig/app.json",
+    "typecheck:node": "tsgo --noEmit -p tsconfig/node.json",
+    "typecheck:test": "tsgo --noEmit -p tsconfig/test.json",
+    "lint": "oxlint && oxfmt --check",
+    "lint:fix": "oxlint --fix && oxfmt",
+    "test": "bun test",
+    "test:watch": "bun test --watch",
+    "test:coverage": "bun test --coverage",
+    "clean": "rm -rf dist out .cache"
+  },
+  "dependencies": {
+    "@longzai-intelligence-auth/core": "0.0.1",
+    "@longzai-intelligence-auth/sdk": "0.0.1"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0 || ^19.0.0"
+  },
+  "devDependencies": {
+    "@types/react": "^19.1.0"
+  }
+}