@ic-reactor/react 1.0.2 → 1.0.4

package/dist/helpers/actor.d.ts

@@ -1,3 +1,21 @@
-import { ActorHooks } from "../types";
-import type { ActorManager } from "@ic-reactor/core/dist/actor";
-export declare const getActorHooks: <A>({ initialize, canisterId, actorStore, callMethod, visitFunction, }: ActorManager<A>) => ActorHooks<A, true>;
+import type { ActorHooks } from "../types";
+import type { BaseActor } from "@ic-reactor/core/dist/types";
+import { ActorManager } from "@ic-reactor/core";
+/**
+ * Provides a set of React hooks designed for interacting with actors in an Internet Computer (IC) project using the React framework and Zustand for state management.
+ *
+ * @param actorManager An instance of ActorManager containing methods and properties to manage actors, including the actorStore, canisterId, visitFunction, callMethod, and initialize function.
+ * @returns An object containing several hooks and utility functions for interacting with actors, managing state, and invoking actor methods.
+ *
+ * Hooks included:
+ * - initialize: Function to initialize actor management.
+ * - useActorState: Hook for accessing the actor's state including the canister ID.
+ * - useVisitMethod: Hook for memoizing a method visit service for a given actor method name.
+ * - useReactorCall: Hook for making calls to actor methods with support for loading states, errors, and custom event handlers.
+ * - useQueryCall: Hook specifically designed for query calls to actors with features such as automatic refetching on mount and at specified intervals.
+ * - useUpdateCall: Alias for useReactorCall, tailored for update calls to actors.
+ * - useMethodCall: Combines useVisitMethod and useReactorCall for a streamlined experience when calling actor methods, including visitation and state management.
+ *
+ * Each hook is designed to simplify the process of interacting with actors in IC projects by abstracting away the complexity of state management, error handling, and method invocation.
+ */
+export declare const getActorHooks: <A = BaseActor>(actorManager: ActorManager<A>) => ActorHooks<A>;

package/dist/helpers/actor.js

@@ -21,7 +21,6 @@ var __rest = (this && this.__rest) || function (s, e) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getActorHooks = void 0;
-/* eslint-disable no-console */
 const react_1 = require("react");
 const zustand_1 = require("zustand");
 const DEFAULT_STATE = {
@@ -29,86 +28,84 @@ const DEFAULT_STATE = {
     error: undefined,
     loading: false,
 };
-const getActorHooks = ({ initialize, canisterId, actorStore, callMethod, visitFunction, }) => {
-    const useActorState = () => {
-        const actorState = (0, zustand_1.useStore)(actorStore, (state) => state);
-        return Object.assign(Object.assign({}, actorState), { canisterId });
-    };
-    const useVisitFunction = () => {
-        return visitFunction;
-    };
+/**
+ * Provides a set of React hooks designed for interacting with actors in an Internet Computer (IC) project using the React framework and Zustand for state management.
+ *
+ * @param actorManager An instance of ActorManager containing methods and properties to manage actors, including the actorStore, canisterId, visitFunction, callMethod, and initialize function.
+ * @returns An object containing several hooks and utility functions for interacting with actors, managing state, and invoking actor methods.
+ *
+ * Hooks included:
+ * - initialize: Function to initialize actor management.
+ * - useActorState: Hook for accessing the actor's state including the canister ID.
+ * - useVisitMethod: Hook for memoizing a method visit service for a given actor method name.
+ * - useReactorCall: Hook for making calls to actor methods with support for loading states, errors, and custom event handlers.
+ * - useQueryCall: Hook specifically designed for query calls to actors with features such as automatic refetching on mount and at specified intervals.
+ * - useUpdateCall: Alias for useReactorCall, tailored for update calls to actors.
+ * - useMethodCall: Combines useVisitMethod and useReactorCall for a streamlined experience when calling actor methods, including visitation and state management.
+ *
+ * Each hook is designed to simplify the process of interacting with actors in IC projects by abstracting away the complexity of state management, error handling, and method invocation.
+ */
+const getActorHooks = (actorManager) => {
+    const { actorStore, canisterId, visitFunction, callMethod, initialize } = actorManager;
+    const useActorState = () => (Object.assign(Object.assign({}, (0, zustand_1.useStore)(actorStore)), { canisterId }));
     const useVisitMethod = (functionName) => {
-        const serviceFields = useVisitFunction();
-        return (0, react_1.useMemo)(() => {
-            return serviceFields[functionName];
-        }, [functionName, serviceFields]);
+        return (0, react_1.useMemo)(() => visitFunction[functionName], [functionName]);
     };
-    const useReactorCall = ({ onError, onSuccess, onLoading, args = [], functionName, throwOnError = false, }) => {
+    const useReactorCall = (_a) => {
+        var { args = [], functionName, throwOnError = false } = _a, events = __rest(_a, ["args", "functionName", "throwOnError"]);
         const [state, setState] = (0, react_1.useState)(DEFAULT_STATE);
         const reset = (0, react_1.useCallback)(() => setState(DEFAULT_STATE), []);
         const call = (0, react_1.useCallback)((eventOrReplaceArgs) => __awaiter(void 0, void 0, void 0, function* () {
-            onLoading === null || onLoading === void 0 ? void 0 : onLoading(true);
-            onError === null || onError === void 0 ? void 0 : onError(undefined);
-            setState((prevState) => (Object.assign(Object.assign({}, prevState), { loading: true, error: undefined })));
+            var _b, _c, _d, _e, _f;
+            setState({ data: undefined, error: undefined, loading: true });
+            (_b = events === null || events === void 0 ? void 0 : events.onLoading) === null || _b === void 0 ? void 0 : _b.call(events, true);
             try {
-                const replaceArgs = eventOrReplaceArgs !== undefined
-                    ? eventOrReplaceArgs.length > 0
-                        ? eventOrReplaceArgs
-                        : undefined
-                    : undefined;
-                const data = yield callMethod(functionName, ...(replaceArgs !== null && replaceArgs !== void 0 ? replaceArgs : args));
-                onLoading === null || onLoading === void 0 ? void 0 : onLoading(false);
-                onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(data);
-                setState((prevState) => (Object.assign(Object.assign({}, prevState), { data, loading: false })));
+                const replaceArgs = eventOrReplaceArgs instanceof Array ? eventOrReplaceArgs : args;
+                const data = yield callMethod(functionName, ...replaceArgs);
+                setState({ data, error: undefined, loading: false });
+                (_c = events === null || events === void 0 ? void 0 : events.onSuccess) === null || _c === void 0 ? void 0 : _c.call(events, data);
+                (_d = events === null || events === void 0 ? void 0 : events.onLoading) === null || _d === void 0 ? void 0 : _d.call(events, false);
                 return data;
             }
             catch (error) {
+                // eslint-disable-next-line no-console
                 console.error("Error in call:", error);
-                onError === null || onError === void 0 ? void 0 : onError(error);
-                onLoading === null || onLoading === void 0 ? void 0 : onLoading(false);
                 setState((prevState) => (Object.assign(Object.assign({}, prevState), { error: error, loading: false })));
+                (_e = events === null || events === void 0 ? void 0 : events.onError) === null || _e === void 0 ? void 0 : _e.call(events, error);
+                (_f = events === null || events === void 0 ? void 0 : events.onLoading) === null || _f === void 0 ? void 0 : _f.call(events, false);
                 if (throwOnError)
                     throw error;
             }
-        }), [args, functionName, onError, onSuccess, onLoading]);
+        }), [args, functionName, events]);
         return Object.assign({ call, reset }, state);
     };
     const useQueryCall = (_a) => {
         var { refetchOnMount = true, refetchInterval = false } = _a, rest = __rest(_a, ["refetchOnMount", "refetchInterval"]);
         const _b = useReactorCall(rest), { call } = _b, state = __rest(_b, ["call"]);
-        const intervalId = (0, react_1.useRef)(undefined);
+        const intervalId = (0, react_1.useRef)();
         (0, react_1.useEffect)(() => {
-            // Auto-refresh logic
             if (refetchInterval) {
-                intervalId.current = setInterval(() => {
-                    call();
-                }, refetchInterval);
+                intervalId.current = setInterval(call, refetchInterval);
             }
-            return () => {
-                clearInterval(intervalId.current);
-            };
-        }, [refetchInterval]);
-        (0, react_1.useLayoutEffect)(() => {
             if (refetchOnMount) {
                 call();
             }
-        }, []);
+            return () => clearInterval(intervalId.current);
+        }, [refetchInterval, refetchOnMount]);
         return Object.assign({ call }, state);
     };
-    const useUpdateCall = (args) => {
-        return useReactorCall(args);
-    };
+    const useUpdateCall = useReactorCall;
     const useMethodCall = (args) => {
-        const visit = visitFunction[args.functionName];
+        const visit = useVisitMethod(args.functionName);
         return Object.assign({ visit }, useReactorCall(args));
     };
     return {
         initialize,
         useQueryCall,
         useUpdateCall,
-        useVisitMethod,
         useActorState,
         useMethodCall,
+        useVisitMethod,
     };
 };
 exports.getActorHooks = getActorHooks;

package/dist/helpers/agent.d.ts

@@ -1,6 +1,3 @@
 import type { AgentManager } from "@ic-reactor/core/dist/agent";
-import type { HttpAgent } from "@ic-reactor/core/dist/types";
-export declare const getAgentHooks: (agentManager: AgentManager) => {
-    useAgent: () => HttpAgent | undefined;
-    useAgentState: () => import("@ic-reactor/core/dist/types").AgentState;
-};
+import type { AgentHooks } from "./types";
+export declare const getAgentHooks: (agentManager: AgentManager) => AgentHooks;

package/dist/helpers/agent.js

@@ -4,13 +4,11 @@ exports.getAgentHooks = void 0;
 const react_1 = require("react");
 const zustand_1 = require("zustand");
 const getAgentHooks = (agentManager) => {
-    const { agentStore, getAgent } = agentManager;
-    const useAgentState = () => {
-        return (0, zustand_1.useStore)(agentStore, (state) => state);
-    };
+    const { agentStore, getAgent, subscribeAgent } = agentManager;
+    const useAgentState = () => (0, zustand_1.useStore)(agentStore);
     const useAgent = () => {
-        const [agent, setAgent] = (0, react_1.useState)(getAgent());
-        (0, react_1.useEffect)(() => agentManager.subscribeAgent(setAgent), []);
+        const [agent, setAgent] = (0, react_1.useState)(getAgent);
+        (0, react_1.useEffect)(() => subscribeAgent(setAgent), [subscribeAgent]);
         return agent;
     };
     return {

package/dist/helpers/auth.d.ts

@@ -1,21 +1,3 @@
-import type { AuthClientLoginOptions } from "@dfinity/auth-client";
-import type { Identity, Principal } from "@ic-reactor/core/dist/types";
 import type { AgentManager } from "@ic-reactor/core/dist/agent";
-import { AuthArgs } from "../types";
-export declare const getAuthHooks: (agentManager: AgentManager) => {
-    useUserPrincipal: () => Principal | undefined;
-    useAuthState: () => import("@ic-reactor/core/dist/types").AuthState;
-    useAuthClient: ({ onAuthentication, onAuthenticationSuccess, onAuthenticationFailure, onLogin, onLoginSuccess, onLoginError, onLoggedOut, }?: AuthArgs) => {
-        authClient: import("@dfinity/auth-client").AuthClient | null;
-        authenticated: boolean;
-        authenticating: boolean;
-        identity: Identity | null;
-        login: (options?: AuthClientLoginOptions) => Promise<void>;
-        logout: (options?: {
-            returnTo?: string;
-        }) => Promise<void>;
-        authenticate: () => Promise<Identity>;
-        loginLoading: boolean;
-        loginError: Error | null;
-    };
-};
+import type { AuthHooks } from "../types";
+export declare const getAuthHooks: (agentManager: AgentManager) => AuthHooks;

package/dist/helpers/auth.js

@@ -10,106 +10,84 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAuthHooks = void 0;
-const react_1 = require("react");
 const zustand_1 = require("zustand");
+const react_1 = require("react");
+const tools_1 = require("@ic-reactor/core/dist/tools");
 const getAuthHooks = (agentManager) => {
     const { authenticate: authenticator, authStore, isLocalEnv } = agentManager;
-    const useAuthState = () => {
-        return (0, zustand_1.useStore)(authStore, (state) => state);
-    };
-    const useUserPrincipal = () => {
-        const { identity } = useAuthState();
-        return identity === null || identity === void 0 ? void 0 : identity.getPrincipal();
-    };
-    const useAuthClient = ({ onAuthentication, onAuthenticationSuccess, onAuthenticationFailure, onLogin, onLoginSuccess, onLoginError, onLoggedOut, } = {}) => {
-        const [loginLoading, setLoginLoading] = (0, react_1.useState)(false);
-        const [loginError, setLoginError] = (0, react_1.useState)(null);
-        const { authClient, authenticated, authenticating, identity } = useAuthState();
+    const useAuthState = () => (0, zustand_1.useStore)(authStore);
+    const useUserPrincipal = () => { var _a, _b; return (_b = (_a = useAuthState()) === null || _a === void 0 ? void 0 : _a.identity) === null || _b === void 0 ? void 0 : _b.getPrincipal(); };
+    const useAuthClient = (events) => {
+        const [loginState, setLoginState] = (0, react_1.useState)({
+            loading: false,
+            error: null,
+        });
+        const { authClient, authenticated, authenticating, identity, error } = useAuthState();
         const authenticate = (0, react_1.useCallback)(() => __awaiter(void 0, void 0, void 0, function* () {
-            const authenticatePromise = new Promise((resolve, reject) => {
-                authenticator()
-                    .then((identity) => {
-                    onAuthenticationSuccess === null || onAuthenticationSuccess === void 0 ? void 0 : onAuthenticationSuccess(identity);
-                    resolve(identity);
-                })
-                    .catch((e) => {
-                    onAuthenticationFailure === null || onAuthenticationFailure === void 0 ? void 0 : onAuthenticationFailure(e);
-                    reject(e);
-                });
-            });
-            onAuthentication === null || onAuthentication === void 0 ? void 0 : onAuthentication(() => authenticatePromise);
-            return authenticatePromise;
-        }), [
-            authenticator,
-            onAuthentication,
-            onAuthenticationSuccess,
-            onAuthenticationFailure,
-        ]);
+            var _a, _b;
+            try {
+                const identity = yield authenticator();
+                (_a = events === null || events === void 0 ? void 0 : events.onAuthenticationSuccess) === null || _a === void 0 ? void 0 : _a.call(events, identity);
+                return identity;
+            }
+            catch (e) {
+                (_b = events === null || events === void 0 ? void 0 : events.onAuthenticationFailure) === null || _b === void 0 ? void 0 : _b.call(events, e);
+                throw e;
+            }
+        }), [authenticator, events]);
         const login = (0, react_1.useCallback)((options) => __awaiter(void 0, void 0, void 0, function* () {
-            setLoginLoading(true);
-            setLoginError(null);
-            const loginPromise = new Promise((resolve, reject) => {
-                try {
-                    if (!authClient) {
-                        throw new Error("Auth client not initialized");
-                    }
-                    authClient.login(Object.assign(Object.assign({ identityProvider: isLocalEnv
-                            ? "https://identity.ic0.app/#authorize"
-                            : "http://rdmx6-jaaaa-aaaaa-aaadq-cai.localhost:4943/#authorize" }, options), { onSuccess: () => {
-                            authenticate()
-                                .then((identity) => {
-                                var _a;
-                                const principal = identity.getPrincipal();
-                                (_a = options === null || options === void 0 ? void 0 : options.onSuccess) === null || _a === void 0 ? void 0 : _a.call(options);
-                                onLoginSuccess === null || onLoginSuccess === void 0 ? void 0 : onLoginSuccess(principal);
-                                resolve(principal);
-                            })
-                                .catch((e) => {
-                                setLoginError(e);
-                                onLoginError === null || onLoginError === void 0 ? void 0 : onLoginError(e);
-                                reject(e);
-                            });
-                        }, onError: (e) => {
-                            var _a;
-                            (_a = options === null || options === void 0 ? void 0 : options.onError) === null || _a === void 0 ? void 0 : _a.call(options, e);
-                            const error = new Error("Login failed: " + e);
-                            setLoginError(error);
-                            onLoginError === null || onLoginError === void 0 ? void 0 : onLoginError(error);
-                            reject(error);
-                        } }));
-                }
-                catch (e) {
-                    setLoginError(e);
-                    onLoginError === null || onLoginError === void 0 ? void 0 : onLoginError(e);
-                    reject(e);
-                }
-                finally {
-                    setLoginLoading(false);
-                }
-            });
-            onLogin === null || onLogin === void 0 ? void 0 : onLogin(() => loginPromise);
-        }), [
-            authClient,
-            onLogin,
-            onLoginSuccess,
-            onLoginError,
-            isLocalEnv,
-            authenticate,
-        ]);
+            var _c;
+            if (!authClient) {
+                throw new Error("Auth client not initialized");
+            }
+            try {
+                setLoginState({ loading: true, error: null });
+                yield authClient.login(Object.assign(Object.assign({ identityProvider: isLocalEnv
+                        ? tools_1.LOCAL_INTERNET_IDENTITY_PROVIDER
+                        : tools_1.IC_INTERNET_IDENTITY_PROVIDER }, options), { onSuccess: () => __awaiter(void 0, void 0, void 0, function* () {
+                        var _d, _e, _f;
+                        try {
+                            const identity = yield authenticate();
+                            const principal = identity.getPrincipal();
+                            (_d = options === null || options === void 0 ? void 0 : options.onSuccess) === null || _d === void 0 ? void 0 : _d.call(options);
+                            (_e = events === null || events === void 0 ? void 0 : events.onLoginSuccess) === null || _e === void 0 ? void 0 : _e.call(events, principal);
+                            setLoginState({ loading: false, error: null });
+                        }
+                        catch (e) {
+                            const error = e;
+                            setLoginState({ loading: false, error });
+                            (_f = events === null || events === void 0 ? void 0 : events.onLoginError) === null || _f === void 0 ? void 0 : _f.call(events, error);
+                        }
+                    }), onError: (e) => {
+                        var _a;
+                        const error = new Error(`Login failed: ${e}`);
+                        setLoginState({ loading: false, error });
+                        (_a = events === null || events === void 0 ? void 0 : events.onLoginError) === null || _a === void 0 ? void 0 : _a.call(events, error);
+                    } }));
+            }
+            catch (e) {
+                const error = e;
+                setLoginState({ loading: false, error });
+                (_c = events === null || events === void 0 ? void 0 : events.onLoginError) === null || _c === void 0 ? void 0 : _c.call(events, error);
+            }
+        }), [authClient, authenticate, isLocalEnv, events]);
         const logout = (0, react_1.useCallback)((options) => __awaiter(void 0, void 0, void 0, function* () {
+            var _g;
             if (!authClient) {
                 throw new Error("Auth client not initialized");
             }
             yield authClient.logout(options);
             yield authenticate();
-            onLoggedOut === null || onLoggedOut === void 0 ? void 0 : onLoggedOut();
-        }), [authClient, onLoggedOut]);
+            (_g = events === null || events === void 0 ? void 0 : events.onLoggedOut) === null || _g === void 0 ? void 0 : _g.call(events);
+        }), [authClient, authenticate, events]);
         (0, react_1.useEffect)(() => {
             if (!authClient && !authenticating) {
-                authenticate();
+                // eslint-disable-next-line no-console
+                authenticate().catch(console.error);
             }
-        }, [authClient, authenticating]);
+        }, [authClient, authenticating, authenticate]);
         return {
+            error,
             authClient,
             authenticated,
             authenticating,
@@ -117,8 +95,8 @@ const getAuthHooks = (agentManager) => {
             login,
             logout,
             authenticate,
-            loginLoading,
-            loginError,
+            loginLoading: loginState.loading,
+            loginError: loginState.error,
         };
     };
     return {

package/dist/helpers/types.d.ts

@@ -1,4 +1,86 @@
-import { getAgentHooks } from "./agent";
-import { getAuthHooks } from "./auth";
-export type AgentHooks = ReturnType<typeof getAgentHooks>;
-export type AuthHooks = ReturnType<typeof getAuthHooks>;
+/// <reference types="react" />
+import type { AuthClientLoginOptions } from "@dfinity/auth-client";
+import type { ActorState, CanisterId, ActorMethodArgs, ActorMethodReturnType, Identity, Principal, FunctionName, VisitService, AuthClient, AuthState, HttpAgent, AgentState } from "@ic-reactor/core/dist/types";
+export interface AgentHooks {
+    useAgent: () => HttpAgent | undefined;
+    useAgentState: () => AgentState;
+}
+export interface AuthHooks {
+    useUserPrincipal: () => Principal | undefined;
+    useAuthState: () => AuthState;
+    useAuthClient: (events?: UseAuthClientArgs) => UseAuthClientReturn;
+}
+export interface ActorHooks<A> {
+    initialize: () => Promise<void>;
+    useActorState: () => UseActorState;
+    useQueryCall: UseQueryCall<A>;
+    useUpdateCall: UseUpdateCall<A>;
+    useMethodCall: UseMethodCall<A>;
+    useVisitMethod: <M extends FunctionName<A>>(functionName: M) => VisitService<A>[M];
+}
+export interface UseAuthClientArgs {
+    onAuthentication?: (promise: () => Promise<Identity>) => void;
+    onAuthenticationSuccess?: (identity: Identity) => void;
+    onAuthenticationFailure?: (error: Error) => void;
+    onLoginSuccess?: (principal: Principal) => void;
+    onLoginError?: (error: Error) => void;
+    onLogin?: (promise: () => Promise<Principal>) => void;
+    onLoggedOut?: () => void;
+}
+export interface UseAuthClientReturn {
+    error: Error | undefined;
+    authClient: AuthClient | null;
+    authenticated: boolean;
+    authenticating: boolean;
+    identity: Identity | null;
+    login: (options?: LoginOptions) => Promise<void>;
+    logout: (options?: LogoutOptions) => Promise<void>;
+    authenticate: () => Promise<Identity>;
+    loginLoading: boolean;
+    loginError: Error | null;
+}
+export type LoginState = {
+    loading: boolean;
+    error: Error | null;
+};
+export type LoginOptions = AuthClientLoginOptions;
+export type LogoutOptions = {
+    returnTo?: string;
+};
+export type ReactorCallArgs<A, M extends FunctionName<A>> = {
+    functionName: M;
+    args?: ActorMethodArgs<A[M]>;
+    onLoading?: (loading: boolean) => void;
+    onError?: (error: Error | undefined) => void;
+    onSuccess?: (data: ActorMethodReturnType<A[M]> | undefined) => void;
+    throwOnError?: boolean;
+};
+export type ActorCallState<A, M extends FunctionName<A>> = {
+    data: ActorMethodReturnType<A[M]> | undefined;
+    error: Error | undefined;
+    loading: boolean;
+};
+export interface UseQueryCallArgs<A, M extends FunctionName<A>> extends ReactorCallArgs<A, M> {
+    refetchOnMount?: boolean;
+    refetchInterval?: number | false;
+}
+export interface UseUpdateCallArgs<A, M extends FunctionName<A>> extends ReactorCallArgs<A, M> {
+}
+export interface ReactorCallReturn<A, M extends FunctionName<A> = FunctionName<A>> extends ActorCallState<A, M> {
+    reset: () => void;
+    call: (eventOrReplaceArgs?: React.MouseEvent | ActorMethodArgs<A[M]>) => Promise<ActorMethodReturnType<A[M]> | undefined>;
+}
+export type ReactorCall<A> = <M extends FunctionName<A>>(args: ReactorCallArgs<A, M>) => ReactorCallReturn<A, M>;
+export type UseQueryCall<A> = <M extends FunctionName<A>>(args: UseQueryCallArgs<A, M>) => ReactorCallReturn<A, M>;
+export type UseUpdateCall<A> = <M extends FunctionName<A>>(args: UseUpdateCallArgs<A, M>) => ReactorCallReturn<A, M>;
+export type UseMethodCall<A> = <M extends FunctionName<A>>(args: UseMethodCallArg<A, M>) => UseMethodCallReturn<A, M>;
+export interface UseMethodCallReturn<A, M extends FunctionName<A> = FunctionName<A>> extends ReactorCallReturn<A, M> {
+    visit: VisitService<A>[M];
+    reset: () => void;
+    error: Error | undefined;
+    loading: boolean;
+}
+export type UseMethodCallArg<A, M extends FunctionName<A>> = ReactorCallArgs<A, M>;
+export interface UseActorState extends Omit<ActorState, "methodState"> {
+    canisterId: CanisterId;
+}

package/dist/hooks/index.d.ts

@@ -1,2 +1 @@
-export * from "./useActor";
-export * from "./useCandid";
+export * from "./useReactor";

package/dist/hooks/index.js

@@ -14,5 +14,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./useActor"), exports);
-__exportStar(require("./useCandid"), exports);
+__exportStar(require("./useReactor"), exports);

package/dist/hooks/types.d.ts

@@ -0,0 +1,19 @@
+import { IDL } from "@dfinity/candid";
+import { ActorManagerOptions, BaseActor } from "@ic-reactor/core/dist/types";
+import { ActorHooks, AgentContextType } from "../types";
+export interface UseReactorOptions extends Omit<ActorManagerOptions, "idlFactory" | "agentManager" | "canisterId"> {
+    canisterId: string;
+    idlFactory?: IDL.InterfaceFactory;
+    agentContext?: AgentContextType;
+    didjsCanisterId?: string;
+}
+export interface UseReactorState {
+    idlFactory?: IDL.InterfaceFactory;
+    fetching: boolean;
+    fetchError: string | null;
+}
+export interface UseReactorReturn<A = BaseActor> {
+    hooks: ActorHooks<A> | null;
+    fetching: boolean;
+    fetchError: string | null;
+}

package/dist/hooks/useReactor.d.ts

@@ -0,0 +1,41 @@
+import { BaseActor } from "../types";
+import { UseReactorOptions, UseReactorReturn } from "./types";
+/**
+ * A comprehensive hook that manages both the fetching of Candid interfaces
+ * and the initialization of actor stores for Internet Computer (IC) canisters.
+ * It simplifies the process of interacting with canisters by encapsulating
+ * the logic for Candid retrieval and actor store management.
+ *
+ * @example
+ * ```tsx
+ * import React from 'react';
+ * import { useReactor } from '@ic-reactor/react';
+ * import { IDL } from '@dfinity/candid';
+ *
+ * const App = () => {
+ *   const { actorManager, fetchCandid, candid, fetching, fetchError } = useReactor({
+ *     canisterId: 'ryjl3-tyaaa-aaaaa-aaaba-cai',
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       <h2>IC Canister Interaction</h2>
+ *       {fetching && <p>Loading Candid interface...</p>}
+ *       {fetchError && <p>Error: {fetchError}</p>}
+ *       {candid.idlFactory && (
+ *         <div>
+ *           <p>Candid interface fetched successfully.</p>
+ *           <pre>{JSON.stringify(candid.idlFactory({ IDL }), null, 2)}</pre>
+ *         </div>
+ *       )}
+ *       <button onClick={fetchCandid} disabled={fetching}>
+ *         {fetching ? 'Fetching...' : 'Fetch Candid'}
+ *       </button>
+ *     </div>
+ *   );
+ * };
+ *
+ * export default App;
+ * ```
+ */
+export declare const useReactor: <A = BaseActor>({ canisterId, agentContext, idlFactory: maybeIdlFactory, didjsCanisterId, ...config }: UseReactorOptions) => UseReactorReturn<A>;