@crimson-education/sdk 0.2.0

package/dist/react/hooks/useOAuth.d.ts

@@ -0,0 +1,94 @@
+import type { OAuthAdapter } from "../../core/auth/oauth-adapter";
+import type { OAuthTokens, AuthorizeOptions, CallbackParams, OAuthError } from "../../core/auth/types";
+/**
+ * OAuth hook return type
+ */
+export interface UseOAuthResult {
+    /** Whether the user is authenticated */
+    isAuthenticated: boolean;
+    /** Whether authentication state is loading */
+    isLoading: boolean;
+    /** Current tokens (if authenticated) */
+    tokens: OAuthTokens | null;
+    /** Last error (if any) */
+    error: Error | OAuthError | null;
+    /** Start OAuth authorization flow */
+    authorize: (options?: AuthorizeOptions) => Promise<void>;
+    /** Get authorization URL without redirecting */
+    getAuthorizeUrl: (options?: AuthorizeOptions) => Promise<string>;
+    /** Handle OAuth callback */
+    handleCallback: (params: CallbackParams) => Promise<OAuthTokens>;
+    /** Logout and revoke tokens */
+    logout: () => Promise<void>;
+    /** Manually refresh token */
+    refreshToken: () => Promise<OAuthTokens | null>;
+}
+/**
+ * React hook for OAuth authentication
+ *
+ * @param adapter - OAuth adapter instance from CrimsonClient
+ * @returns OAuth state and methods
+ *
+ * @example
+ * ```tsx
+ * const client = createCrimsonClient({
+ *   apiUrl: 'https://api.example.com',
+ *   oauth: {
+ *     clientId: 'my-app',
+ *     redirectUri: 'https://myapp.com/callback',
+ *   },
+ * });
+ *
+ * function App() {
+ *   const oauth = useOAuth(client.getOAuthAdapter());
+ *
+ *   if (oauth.isLoading) return <div>Loading...</div>;
+ *
+ *   if (!oauth.isAuthenticated) {
+ *     return <button onClick={() => oauth.authorize()}>Login</button>;
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       <p>Authenticated!</p>
+ *       <button onClick={() => oauth.logout()}>Logout</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useOAuth(adapter: OAuthAdapter | undefined): UseOAuthResult;
+/**
+ * Hook for handling OAuth callback page
+ *
+ * @param adapter - OAuth adapter instance
+ * @param params - URL parameters from OAuth callback
+ * @returns Callback handling state
+ *
+ * @example
+ * ```tsx
+ * function CallbackPage() {
+ *   const params = new URLSearchParams(window.location.search);
+ *   const { isProcessing, error, success } = useOAuthCallback(
+ *     client.getOAuthAdapter(),
+ *     {
+ *       code: params.get('code') ?? undefined,
+ *       state: params.get('state') ?? undefined,
+ *       error: params.get('error') ?? undefined,
+ *       errorDescription: params.get('error_description') ?? undefined,
+ *     }
+ *   );
+ *
+ *   if (isProcessing) return <div>Processing...</div>;
+ *   if (error) return <div>Error: {error.message}</div>;
+ *   if (success) return <Navigate to="/" />;
+ *
+ *   return null;
+ * }
+ * ```
+ */
+export declare function useOAuthCallback(adapter: OAuthAdapter | undefined, params: CallbackParams): {
+    isProcessing: boolean;
+    error: Error | OAuthError | null;
+    success: boolean;
+};

package/dist/react/hooks/useOAuth.js

@@ -0,0 +1,211 @@
+"use strict";
+"use client";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOAuth = useOAuth;
+exports.useOAuthCallback = useOAuthCallback;
+const react_1 = require("react");
+const emptyState = {
+    isAuthenticated: false,
+    isLoading: true,
+    tokens: null,
+    error: null,
+};
+/**
+ * React hook for OAuth authentication
+ *
+ * @param adapter - OAuth adapter instance from CrimsonClient
+ * @returns OAuth state and methods
+ *
+ * @example
+ * ```tsx
+ * const client = createCrimsonClient({
+ *   apiUrl: 'https://api.example.com',
+ *   oauth: {
+ *     clientId: 'my-app',
+ *     redirectUri: 'https://myapp.com/callback',
+ *   },
+ * });
+ *
+ * function App() {
+ *   const oauth = useOAuth(client.getOAuthAdapter());
+ *
+ *   if (oauth.isLoading) return <div>Loading...</div>;
+ *
+ *   if (!oauth.isAuthenticated) {
+ *     return <button onClick={() => oauth.authorize()}>Login</button>;
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       <p>Authenticated!</p>
+ *       <button onClick={() => oauth.logout()}>Logout</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+function useOAuth(adapter) {
+    const [state, setState] = (0, react_1.useState)(emptyState);
+    // Subscribe to auth state changes
+    (0, react_1.useEffect)(() => {
+        if (!adapter) {
+            setState({
+                isAuthenticated: false,
+                isLoading: false,
+                tokens: null,
+                error: new Error("OAuth adapter not provided"),
+            });
+            return;
+        }
+        // Initialize adapter
+        adapter.initialize().catch((error) => {
+            setState((prev) => (Object.assign(Object.assign({}, prev), { isLoading: false, error: error instanceof Error ? error : new Error(String(error)) })));
+        });
+        // Subscribe to state changes
+        const unsubscribe = adapter.subscribe((newState) => {
+            setState(newState);
+        });
+        return () => {
+            unsubscribe();
+        };
+    }, [adapter]);
+    // Memoized methods
+    const authorize = (0, react_1.useCallback)((options) => __awaiter(this, void 0, void 0, function* () {
+        if (!adapter) {
+            throw new Error("OAuth adapter not provided");
+        }
+        yield adapter.authorize(options);
+    }), [adapter]);
+    const getAuthorizeUrl = (0, react_1.useCallback)((options) => __awaiter(this, void 0, void 0, function* () {
+        if (!adapter) {
+            throw new Error("OAuth adapter not provided");
+        }
+        return adapter.getAuthorizeUrl(options);
+    }), [adapter]);
+    const handleCallback = (0, react_1.useCallback)((params) => __awaiter(this, void 0, void 0, function* () {
+        if (!adapter) {
+            throw new Error("OAuth adapter not provided");
+        }
+        return adapter.handleCallback(params);
+    }), [adapter]);
+    const logout = (0, react_1.useCallback)(() => __awaiter(this, void 0, void 0, function* () {
+        if (!adapter) {
+            throw new Error("OAuth adapter not provided");
+        }
+        yield adapter.logout();
+    }), [adapter]);
+    const refreshToken = (0, react_1.useCallback)(() => __awaiter(this, void 0, void 0, function* () {
+        if (!adapter) {
+            throw new Error("OAuth adapter not provided");
+        }
+        return adapter.refreshToken();
+    }), [adapter]);
+    // Return memoized result
+    return (0, react_1.useMemo)(() => ({
+        isAuthenticated: state.isAuthenticated,
+        isLoading: state.isLoading,
+        tokens: state.tokens,
+        error: state.error,
+        authorize,
+        getAuthorizeUrl,
+        handleCallback,
+        logout,
+        refreshToken,
+    }), [
+        state.isAuthenticated,
+        state.isLoading,
+        state.tokens,
+        state.error,
+        authorize,
+        getAuthorizeUrl,
+        handleCallback,
+        logout,
+        refreshToken,
+    ]);
+}
+/**
+ * Hook for handling OAuth callback page
+ *
+ * @param adapter - OAuth adapter instance
+ * @param params - URL parameters from OAuth callback
+ * @returns Callback handling state
+ *
+ * @example
+ * ```tsx
+ * function CallbackPage() {
+ *   const params = new URLSearchParams(window.location.search);
+ *   const { isProcessing, error, success } = useOAuthCallback(
+ *     client.getOAuthAdapter(),
+ *     {
+ *       code: params.get('code') ?? undefined,
+ *       state: params.get('state') ?? undefined,
+ *       error: params.get('error') ?? undefined,
+ *       errorDescription: params.get('error_description') ?? undefined,
+ *     }
+ *   );
+ *
+ *   if (isProcessing) return <div>Processing...</div>;
+ *   if (error) return <div>Error: {error.message}</div>;
+ *   if (success) return <Navigate to="/" />;
+ *
+ *   return null;
+ * }
+ * ```
+ */
+function useOAuthCallback(adapter, params) {
+    const [isProcessing, setIsProcessing] = (0, react_1.useState)(true);
+    const [error, setError] = (0, react_1.useState)(null);
+    const [success, setSuccess] = (0, react_1.useState)(false);
+    (0, react_1.useEffect)(() => {
+        if (!adapter) {
+            setError(new Error("OAuth adapter not provided"));
+            setIsProcessing(false);
+            return;
+        }
+        // Check for error in params
+        if (params.error) {
+            setError({
+                error: params.error,
+                errorDescription: params.errorDescription,
+            });
+            setIsProcessing(false);
+            return;
+        }
+        // Process callback
+        if (params.code && params.state) {
+            adapter
+                .handleCallback(params)
+                .then(() => {
+                setSuccess(true);
+                setIsProcessing(false);
+            })
+                .catch((err) => {
+                setError(err instanceof Error ? err : { error: String(err) });
+                setIsProcessing(false);
+            });
+        }
+        else {
+            setError({
+                error: "invalid_request",
+                errorDescription: "Missing code or state parameter",
+            });
+            setIsProcessing(false);
+        }
+    }, [
+        adapter,
+        params.code,
+        params.state,
+        params.error,
+        params.errorDescription,
+    ]);
+    return { isProcessing, error, success };
+}

package/dist/react/hooks/useRoadmapContext.d.ts

@@ -0,0 +1,2 @@
+import type { RoadmapContext } from "../../core/types";
+export declare function useRoadmapContext(userId: string | null, enabled: boolean): import("@tanstack/react-query").UseQueryResult<RoadmapContext | null, Error>;

package/dist/react/hooks/useRoadmapContext.js

@@ -0,0 +1,29 @@
+"use strict";
+"use client";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRoadmapContext = useRoadmapContext;
+const react_query_1 = require("@tanstack/react-query");
+const provider_1 = require("../provider");
+function useRoadmapContext(userId, enabled) {
+    const client = (0, provider_1.useCrimsonClient)();
+    return (0, react_query_1.useQuery)({
+        queryKey: ["roadmap-context", userId],
+        enabled: !!userId && enabled,
+        queryFn: () => __awaiter(this, void 0, void 0, function* () {
+            if (!userId) {
+                throw new Error("Missing userId");
+            }
+            return client.roadmap.context(userId);
+        }),
+        staleTime: 60 * 1000,
+    });
+}

package/dist/react/hooks/useStudentProfile.d.ts

@@ -0,0 +1,24 @@
+import type { StudentProfile, StudentPrefilledInfo } from "../../core/types";
+export declare const studentProfileKeys: {
+    all: readonly ["studentProfile"];
+    profiles: () => readonly ["studentProfile", "profile"];
+    profile: (studentId: string) => readonly ["studentProfile", "profile", string];
+    prefilledInfos: () => readonly ["studentProfile", "prefilledInfo"];
+    prefilledInfo: (studentId: string) => readonly ["studentProfile", "prefilledInfo", string];
+};
+/**
+ * Hook to fetch student profile by student ID
+ *
+ * @param studentId - The student's user ID
+ * @param enabled - Whether to enable the query (default: true)
+ * @returns Query result with student profile data
+ */
+export declare function useStudentProfile(studentId: string | null, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<StudentProfile | undefined, Error>;
+/**
+ * Hook to fetch student prefilled information (application cycle, grade, school, etc.)
+ *
+ * @param studentId - The student's user ID
+ * @param enabled - Whether to enable the query (default: true)
+ * @returns Query result with prefilled info including applicationCycle, currentGrade, etc.
+ */
+export declare function useStudentPrefilledInfo(studentId: string | null, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<StudentPrefilledInfo | undefined, Error>;

package/dist/react/hooks/useStudentProfile.js

@@ -0,0 +1,65 @@
+"use strict";
+"use client";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.studentProfileKeys = void 0;
+exports.useStudentProfile = useStudentProfile;
+exports.useStudentPrefilledInfo = useStudentPrefilledInfo;
+const react_query_1 = require("@tanstack/react-query");
+const provider_1 = require("../provider");
+// Query keys
+exports.studentProfileKeys = {
+    all: ["studentProfile"],
+    profiles: () => [...exports.studentProfileKeys.all, "profile"],
+    profile: (studentId) => [...exports.studentProfileKeys.profiles(), studentId],
+    prefilledInfos: () => [...exports.studentProfileKeys.all, "prefilledInfo"],
+    prefilledInfo: (studentId) => [...exports.studentProfileKeys.prefilledInfos(), studentId],
+};
+/**
+ * Hook to fetch student profile by student ID
+ *
+ * @param studentId - The student's user ID
+ * @param enabled - Whether to enable the query (default: true)
+ * @returns Query result with student profile data
+ */
+function useStudentProfile(studentId, enabled = true) {
+    const client = (0, provider_1.useCrimsonClient)();
+    return (0, react_query_1.useQuery)({
+        queryKey: exports.studentProfileKeys.profile(studentId || ""),
+        queryFn: () => __awaiter(this, void 0, void 0, function* () {
+            if (!studentId) {
+                return undefined;
+            }
+            return client.studentProfile.getProfile(studentId);
+        }),
+        enabled: enabled && !!studentId,
+    });
+}
+/**
+ * Hook to fetch student prefilled information (application cycle, grade, school, etc.)
+ *
+ * @param studentId - The student's user ID
+ * @param enabled - Whether to enable the query (default: true)
+ * @returns Query result with prefilled info including applicationCycle, currentGrade, etc.
+ */
+function useStudentPrefilledInfo(studentId, enabled = true) {
+    const client = (0, provider_1.useCrimsonClient)();
+    return (0, react_query_1.useQuery)({
+        queryKey: exports.studentProfileKeys.prefilledInfo(studentId || ""),
+        queryFn: () => __awaiter(this, void 0, void 0, function* () {
+            if (!studentId) {
+                return undefined;
+            }
+            return client.studentProfile.getPrefilledInfo(studentId);
+        }),
+        enabled: enabled && !!studentId,
+    });
+}

package/dist/react/hooks/useTasks.d.ts

@@ -0,0 +1,26 @@
+import type { Task, PaginatedResult } from "../../core/types";
+import type { TaskFilters } from "../../core/tasks";
+export declare const taskKeys: {
+    all: readonly ["tasks"];
+    lists: () => readonly ["tasks", "list"];
+    list: (missionId: string) => readonly ["tasks", "list", string];
+    infinite: (roadmapId: string, userId: string, filters?: Omit<TaskFilters, "start" | "limit">) => readonly ["tasks", "infinite", string, string, Omit<TaskFilters, "start" | "limit"> | undefined];
+    details: () => readonly ["tasks", "detail"];
+    detail: (id: string) => readonly ["tasks", "detail", string];
+};
+export declare function useTasks(missionId: string | null, enabled: boolean): import("@tanstack/react-query").UseQueryResult<Task[], Error>;
+export declare function useAllUserTasks(missionLinkIds: string[], enabled: boolean): import("@tanstack/react-query").UseQueryResult<Task[], Error>;
+export declare function useTasksByRoadmapId(roadmapId: string | null, userId: string | null, enabled: boolean): import("@tanstack/react-query").UseQueryResult<Task[], Error>;
+/**
+ * Infinite query hook for paginated task loading (requires roadmapId)
+ */
+export declare function useTasksInfinite(roadmapId: string | null, userId: string | null, filters?: Omit<TaskFilters, "start" | "limit">, options?: {
+    enabled?: boolean;
+    pageSize?: number;
+}): import("@tanstack/react-query").UseInfiniteQueryResult<import("@tanstack/react-query").InfiniteData<PaginatedResult<Task>, unknown>, Error>;
+export declare function useCreateTask(): import("@tanstack/react-query").UseMutationResult<Task, Error, Partial<Task>, unknown>;
+export declare function useUpdateTask(): import("@tanstack/react-query").UseMutationResult<Task, Error, {
+    id: string;
+    data: Partial<Task>;
+}, unknown>;
+export declare function useDeleteTask(): import("@tanstack/react-query").UseMutationResult<void, Error, string, unknown>;

package/dist/react/hooks/useTasks.js

@@ -0,0 +1,137 @@
+"use strict";
+"use client";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskKeys = void 0;
+exports.useTasks = useTasks;
+exports.useAllUserTasks = useAllUserTasks;
+exports.useTasksByRoadmapId = useTasksByRoadmapId;
+exports.useTasksInfinite = useTasksInfinite;
+exports.useCreateTask = useCreateTask;
+exports.useUpdateTask = useUpdateTask;
+exports.useDeleteTask = useDeleteTask;
+const react_query_1 = require("@tanstack/react-query");
+const provider_1 = require("../provider");
+// Query keys
+exports.taskKeys = {
+    all: ["tasks"],
+    lists: () => [...exports.taskKeys.all, "list"],
+    list: (missionId) => [...exports.taskKeys.lists(), missionId],
+    infinite: (roadmapId, userId, filters) => [...exports.taskKeys.all, "infinite", roadmapId, userId, filters],
+    details: () => [...exports.taskKeys.all, "detail"],
+    detail: (id) => [...exports.taskKeys.details(), id],
+};
+function useTasks(missionId, enabled) {
+    const client = (0, provider_1.useCrimsonClient)();
+    return (0, react_query_1.useQuery)({
+        queryKey: exports.taskKeys.list(missionId || ""),
+        queryFn: () => __awaiter(this, void 0, void 0, function* () {
+            if (!missionId) {
+                throw new Error("Missing missionId");
+            }
+            // Without pagination params, list() returns Task[]
+            return (yield client.tasks.list({ missionId }));
+        }),
+        enabled: !!missionId && enabled,
+    });
+}
+function useAllUserTasks(missionLinkIds, enabled) {
+    const client = (0, provider_1.useCrimsonClient)();
+    return (0, react_query_1.useQuery)({
+        queryKey: [
+            ...exports.taskKeys.all,
+            "missionLinks",
+            missionLinkIds.sort().join(","),
+        ],
+        queryFn: () => __awaiter(this, void 0, void 0, function* () {
+            if (!missionLinkIds || missionLinkIds.length === 0) {
+                return [];
+            }
+            // Without pagination params, list() returns Task[]
+            return (yield client.tasks.list({ missionLinkIds }));
+        }),
+        enabled: enabled && missionLinkIds.length > 0,
+    });
+}
+function useTasksByRoadmapId(roadmapId, userId, enabled) {
+    const client = (0, provider_1.useCrimsonClient)();
+    return (0, react_query_1.useQuery)({
+        queryKey: [...exports.taskKeys.all, "roadmap", roadmapId, userId],
+        queryFn: () => __awaiter(this, void 0, void 0, function* () {
+            if (!roadmapId || !userId) {
+                return [];
+            }
+            // Without pagination params, list() returns Task[]
+            return (yield client.tasks.list({ roadmapId, userId }));
+        }),
+        enabled: !!roadmapId && !!userId && enabled,
+    });
+}
+/**
+ * Infinite query hook for paginated task loading (requires roadmapId)
+ */
+function useTasksInfinite(roadmapId, userId, filters, options) {
+    var _a, _b;
+    const client = (0, provider_1.useCrimsonClient)();
+    const enabled = (_a = options === null || options === void 0 ? void 0 : options.enabled) !== null && _a !== void 0 ? _a : true;
+    const pageSize = (_b = options === null || options === void 0 ? void 0 : options.pageSize) !== null && _b !== void 0 ? _b : 20;
+    return (0, react_query_1.useInfiniteQuery)({
+        queryKey: exports.taskKeys.infinite(roadmapId || "", userId || "", filters),
+        queryFn: (_a) => __awaiter(this, [_a], void 0, function* ({ pageParam = 0 }) {
+            if (!roadmapId || !userId) {
+                throw new Error("Missing roadmapId or userId");
+            }
+            return client.tasks.listPaginated(roadmapId, userId, filters, {
+                start: pageParam,
+                limit: pageSize,
+            });
+        }),
+        initialPageParam: 0,
+        getNextPageParam: (lastPage) => {
+            if (!(lastPage === null || lastPage === void 0 ? void 0 : lastPage.pagination))
+                return undefined;
+            return lastPage.pagination.hasMore
+                ? lastPage.pagination.start + lastPage.pagination.limit
+                : undefined;
+        },
+        enabled: !!roadmapId && !!userId && enabled,
+    });
+}
+function useCreateTask() {
+    const client = (0, provider_1.useCrimsonClient)();
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: (data) => client.tasks.create(data),
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: exports.taskKeys.all });
+        },
+    });
+}
+function useUpdateTask() {
+    const client = (0, provider_1.useCrimsonClient)();
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: ({ id, data }) => client.tasks.update(id, data),
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: exports.taskKeys.all });
+        },
+    });
+}
+function useDeleteTask() {
+    const client = (0, provider_1.useCrimsonClient)();
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: (id) => client.tasks.delete(id),
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: exports.taskKeys.all });
+        },
+    });
+}

package/dist/react/hooks/useUsers.d.ts

@@ -0,0 +1,9 @@
+import type { User } from "../../core/types";
+export declare const userKeys: {
+    all: readonly ["users"];
+    details: () => readonly ["users", "detail"];
+    detail: (id: string) => readonly ["users", "detail", string];
+    list: (ids: string[]) => readonly ["users", "list", string];
+};
+export declare function useUsers(userIds: string[], enabled?: boolean): import("@tanstack/react-query").UseQueryResult<User[], Error>;
+export declare function useUser(userId: string | null, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<User | undefined, Error>;

package/dist/react/hooks/useUsers.js

@@ -0,0 +1,50 @@
+"use strict";
+"use client";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.userKeys = void 0;
+exports.useUsers = useUsers;
+exports.useUser = useUser;
+const react_query_1 = require("@tanstack/react-query");
+const provider_1 = require("../provider");
+// Query keys
+exports.userKeys = {
+    all: ["users"],
+    details: () => [...exports.userKeys.all, "detail"],
+    detail: (id) => [...exports.userKeys.details(), id],
+    list: (ids) => [...exports.userKeys.all, "list", ids.sort().join(",")],
+};
+function useUsers(userIds, enabled = true) {
+    const client = (0, provider_1.useCrimsonClient)();
+    return (0, react_query_1.useQuery)({
+        queryKey: exports.userKeys.list(userIds),
+        queryFn: () => __awaiter(this, void 0, void 0, function* () {
+            if (!userIds || userIds.length === 0) {
+                return [];
+            }
+            return client.users.getByIds(userIds);
+        }),
+        enabled: enabled && userIds.length > 0,
+    });
+}
+function useUser(userId, enabled = true) {
+    const client = (0, provider_1.useCrimsonClient)();
+    return (0, react_query_1.useQuery)({
+        queryKey: exports.userKeys.detail(userId || ""),
+        queryFn: () => __awaiter(this, void 0, void 0, function* () {
+            if (!userId) {
+                return undefined;
+            }
+            return client.users.getById(userId);
+        }),
+        enabled: enabled && !!userId,
+    });
+}

package/dist/react/index.d.ts

@@ -0,0 +1,3 @@
+export { CrimsonProvider, useCrimsonClient } from "./provider";
+export type { CrimsonProviderProps } from "./provider";
+export * from "./hooks";