@ic-reactor/react 1.16.0 → 2.0.0

package/dist/helpers/actorHooks.js

@@ -15,33 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-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());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.actorHooks = void 0;
 const React = __importStar(require("react"));
@@ -52,6 +42,7 @@ const DEFAULT_STATE = {
     data: undefined,
     error: undefined,
     loading: false,
+    isLoading: false,
 };
 /**
  * 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.
@@ -78,13 +69,15 @@ const actorHooks = (actorManager) => {
             name: state.name,
             error: state.error,
             version: state.version,
-            initialized: state.initialized,
-            initializing: state.initializing,
+            initialized: state.isInitialized,
+            isInitialized: state.isInitialized,
+            initializing: state.isInitializing,
+            isInitializing: state.isInitializing,
             canisterId,
         }));
     };
     const useMethodState = (functionName, requestKey) => {
-        const state = useActorStore((state) => { var _a; return (_a = state.methodState[functionName]) === null || _a === void 0 ? void 0 : _a[requestKey]; });
+        const state = useActorStore((state) => state.methodState[functionName]?.[requestKey]);
         const setSharedState = React.useCallback((newState) => {
             updateMethodState(functionName, requestKey, newState);
         }, [functionName, requestKey]);
@@ -113,31 +106,35 @@ const actorHooks = (actorManager) => {
             return visitFunction[functionName];
         }, [functionName]);
     };
-    const useSharedCall = (_a) => {
-        var { args = [], functionName, throwOnError = false, onError, onLoading, onSuccess, onSuccessResult, onErrorResult } = _a, options = __rest(_a, ["args", "functionName", "throwOnError", "onError", "onLoading", "onSuccess", "onSuccessResult", "onErrorResult"]);
+    const useSharedCall = ({ args = [], functionName, throwOnError = false, onError, onLoading, onSuccess, onSuccessResult, onErrorResult, ...options }) => {
         const requestKey = React.useMemo(() => (0, utils_1.generateRequestHash)(args), [args]);
         const [sharedState, setSharedState] = useMethodState(functionName, requestKey);
-        const latestDataRef = React.useRef();
+        const latestDataRef = React.useRef(null);
         const reset = React.useCallback(() => {
             updateMethodState(functionName, requestKey, DEFAULT_STATE);
-            latestDataRef.current = undefined;
+            latestDataRef.current = null;
         }, [functionName, requestKey]);
-        const call = React.useCallback((eventOrReplaceArgs) => __awaiter(void 0, void 0, void 0, function* () {
-            setSharedState({ error: undefined, loading: true });
-            onLoading === null || onLoading === void 0 ? void 0 : onLoading(true);
+        const call = React.useCallback(async (eventOrReplaceArgs) => {
+            setSharedState({ error: undefined, loading: true, isLoading: true });
+            onLoading?.(true);
             try {
                 const replaceArgs = eventOrReplaceArgs instanceof Array ? eventOrReplaceArgs : args;
-                const data = yield callMethodWithOptions(options)(functionName, ...(replaceArgs !== null && replaceArgs !== void 0 ? replaceArgs : args));
+                const data = await callMethodWithOptions(options)(functionName, ...(replaceArgs ?? args));
                 latestDataRef.current = data;
-                setSharedState({ data, error: undefined, loading: false });
-                onLoading === null || onLoading === void 0 ? void 0 : onLoading(false);
-                onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(data);
+                setSharedState({
+                    data,
+                    error: undefined,
+                    loading: false,
+                    isLoading: false,
+                });
+                onLoading?.(false);
+                onSuccess?.(data);
                 const { isOk, value, error } = (0, utils_1.createCompiledResult)(data);
                 if (isOk) {
-                    onSuccessResult === null || onSuccessResult === void 0 ? void 0 : onSuccessResult(value);
+                    onSuccessResult?.(value);
                 }
                 else {
-                    onErrorResult === null || onErrorResult === void 0 ? void 0 : onErrorResult(error);
+                    onErrorResult?.(error);
                     if (throwOnError) {
                         throw error;
                     }
@@ -147,17 +144,19 @@ const actorHooks = (actorManager) => {
             catch (error) {
                 // eslint-disable-next-line no-console
                 console.error(`Error calling method ${functionName}:`, error);
-                latestDataRef.current = undefined;
+                latestDataRef.current = null;
                 setSharedState({
                     error: error,
                     loading: false,
+                    isLoading: false,
                 });
-                onError === null || onError === void 0 ? void 0 : onError(error);
-                onLoading === null || onLoading === void 0 ? void 0 : onLoading(false);
+                onError?.(error);
+                onLoading?.(false);
                 if (throwOnError)
                     throw error;
+                return undefined;
             }
-        }), [
+        }, [
             args,
             functionName,
             options,
@@ -168,19 +167,20 @@ const actorHooks = (actorManager) => {
             throwOnError,
         ]);
         const compileResult = () => {
-            return (0, utils_1.createCompiledResult)(latestDataRef.current || (sharedState === null || sharedState === void 0 ? void 0 : sharedState.data));
+            return (0, utils_1.createCompiledResult)(latestDataRef.current || sharedState?.data);
         };
-        return Object.assign({ call,
+        return {
+            call,
             reset,
             compileResult,
-            requestKey }, sharedState);
+            requestKey,
+            ...sharedState,
+        };
     };
-    const useQueryCall = (_a) => {
-        var { refetchOnMount = true, refetchInterval = false } = _a, rest = __rest(_a, ["refetchOnMount", "refetchInterval"]);
-        const _b = useSharedCall(rest), { call, requestKey } = _b, state = __rest(_b, ["call", "requestKey"]);
-        const intervalId = React.useRef();
+    const useQueryCall = ({ refetchOnMount = true, refetchInterval = false, ...rest }) => {
+        const { call, requestKey, ...state } = useSharedCall(rest);
+        const intervalId = React.useRef(null);
         React.useEffect(() => {
-            var _a, _b, _c;
             if (refetchInterval) {
                 intervalId.current = setInterval(call, refetchInterval);
             }
@@ -188,21 +188,25 @@ const actorHooks = (actorManager) => {
                 call();
             }
             else if (refetchOnMount && state.data !== undefined) {
-                (_a = rest.onSuccess) === null || _a === void 0 ? void 0 : _a.call(rest, state.data);
+                rest.onSuccess?.(state.data);
                 const { isOk, value, error } = (0, utils_1.createCompiledResult)(state.data);
                 if (isOk) {
-                    (_b = rest.onSuccessResult) === null || _b === void 0 ? void 0 : _b.call(rest, value);
+                    rest.onSuccessResult?.(value);
                 }
                 else {
-                    (_c = rest.onErrorResult) === null || _c === void 0 ? void 0 : _c.call(rest, error);
+                    rest.onErrorResult?.(error);
                 }
             }
-            return () => clearInterval(intervalId.current);
+            return () => {
+                if (intervalId.current) {
+                    clearInterval(intervalId.current);
+                }
+            };
         }, [refetchInterval, refetchOnMount, requestKey]);
         const refetch = () => {
             call();
         };
-        return Object.assign({ call, refetch, intervalId, requestKey }, state);
+        return { call, refetch, intervalId, requestKey, ...state };
     };
     const useUpdateCall = useSharedCall;
     const useMethod = (params) => {
@@ -236,21 +240,28 @@ const actorHooks = (actorManager) => {
         }, [attributes]);
         let refetchOnMount = params.refetchOnMount;
         let refetchInterval = params.refetchInterval;
-        let formRequired = true;
+        let isFormRequired = true;
         switch (attributes.type) {
             case "query":
                 if (validateArgs(params.args)) {
-                    formRequired = params.refetchOnMount === false ? true : false;
+                    isFormRequired = params.refetchOnMount === false ? true : false;
                 }
                 else {
                     refetchOnMount = false;
                     refetchInterval = false;
                 }
-                return Object.assign(Object.assign({ visit,
-                    validateArgs }, useQueryCall(Object.assign(Object.assign({}, params), { refetchOnMount,
-                    refetchInterval }))), { formRequired });
+                return {
+                    visit,
+                    validateArgs,
+                    ...useQueryCall({
+                        ...params,
+                        refetchOnMount,
+                        refetchInterval,
+                    }),
+                    isFormRequired,
+                };
             case "update":
-                return Object.assign(Object.assign({ visit, validateArgs }, useUpdateCall(params)), { formRequired });
+                return { visit, validateArgs, ...useUpdateCall(params), isFormRequired };
             default:
                 throw new Error(`Method type ${attributes.type} not found`);
         }

package/dist/helpers/authHooks.js

@@ -1,13 +1,4 @@
 "use strict";
-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());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -19,93 +10,104 @@ const utils_1 = require("@ic-reactor/core/dist/utils");
 const authHooks = (agentManager) => {
     const { authenticate: authenticator, getIsLocal, getAuth, authStore, } = agentManager;
     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 useUserPrincipal = () => useAuthState()?.identity?.getPrincipal();
     const useAuth = ({ onAuthentication, onAuthenticationSuccess, onAuthenticationFailure, onLogin, onLoginSuccess, onLoginError, onLoggedOut, } = {}) => {
         const [loginState, setLoginState] = react_1.default.useState({
             loading: false,
+            isLoading: false,
             error: undefined,
         });
-        const { authenticated, authenticating, error, identity } = useAuthState();
-        const authenticate = react_1.default.useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
+        const { isAuthenticated, isAuthenticating, error, identity } = useAuthState();
+        const authenticate = react_1.default.useCallback(async () => {
             const authenticatePromise = new Promise((resolve, reject) => {
                 authenticator()
                     .then((identity) => {
-                    onAuthenticationSuccess === null || onAuthenticationSuccess === void 0 ? void 0 : onAuthenticationSuccess(identity);
+                    onAuthenticationSuccess?.(identity);
                     resolve(identity);
                 })
                     .catch((e) => {
-                    onAuthenticationFailure === null || onAuthenticationFailure === void 0 ? void 0 : onAuthenticationFailure(e);
+                    onAuthenticationFailure?.(e);
                     reject(e);
                 });
             });
-            onAuthentication === null || onAuthentication === void 0 ? void 0 : onAuthentication(() => authenticatePromise);
+            onAuthentication?.(() => authenticatePromise);
             return authenticatePromise;
-        }), [
+        }, [
             authenticator,
             onAuthentication,
             onAuthenticationSuccess,
             onAuthenticationFailure,
         ]);
-        const login = react_1.default.useCallback((options) => __awaiter(void 0, void 0, void 0, function* () {
-            setLoginState({ loading: true, error: undefined });
+        const login = react_1.default.useCallback(async (options) => {
+            setLoginState({ loading: true, isLoading: true, error: undefined });
             const loginPromise = new Promise((resolve, reject) => {
                 try {
                     const authClient = getAuth();
                     if (!authClient) {
                         throw new Error("Auth client not initialized");
                     }
-                    authClient.login(Object.assign(Object.assign({ identityProvider: getIsLocal()
+                    authClient.login({
+                        identityProvider: getIsLocal()
                             ? utils_1.LOCAL_INTERNET_IDENTITY_PROVIDER
-                            : utils_1.IC_INTERNET_IDENTITY_PROVIDER }, options), { onSuccess: (msg) => {
+                            : utils_1.IC_INTERNET_IDENTITY_PROVIDER,
+                        ...options,
+                        onSuccess: (msg) => {
                             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, msg);
-                                onLoginSuccess === null || onLoginSuccess === void 0 ? void 0 : onLoginSuccess(principal);
+                                options?.onSuccess?.(msg);
+                                onLoginSuccess?.(principal);
                                 resolve(principal);
-                                setLoginState({ loading: false, error: undefined });
+                                setLoginState({
+                                    loading: false,
+                                    isLoading: false,
+                                    error: undefined,
+                                });
                             })
                                 .catch((error) => {
-                                setLoginState({ loading: false, error });
-                                onLoginError === null || onLoginError === void 0 ? void 0 : onLoginError(error);
+                                setLoginState({ loading: false, isLoading: false, error });
+                                onLoginError?.(error);
                                 reject(error);
                             });
-                        }, onError: (error) => {
-                            var _a;
-                            (_a = options === null || options === void 0 ? void 0 : options.onError) === null || _a === void 0 ? void 0 : _a.call(options, error);
-                            setLoginState({ loading: false, error });
-                            onLoginError === null || onLoginError === void 0 ? void 0 : onLoginError(error);
+                        },
+                        onError: (error) => {
+                            options?.onError?.(error);
+                            setLoginState({ loading: false, isLoading: false, error });
+                            onLoginError?.(error);
                             reject(error);
-                        } }));
+                        },
+                    });
                 }
                 catch (e) {
                     const error = e;
-                    setLoginState({ loading: false, error });
-                    onLoginError === null || onLoginError === void 0 ? void 0 : onLoginError(error);
+                    setLoginState({ loading: false, isLoading: false, error });
+                    onLoginError?.(error);
                     reject(error);
                 }
             });
-            onLogin === null || onLogin === void 0 ? void 0 : onLogin(() => loginPromise);
-        }), [onLogin, onLoginSuccess, onLoginError, authenticate]);
-        const logout = react_1.default.useCallback((options) => __awaiter(void 0, void 0, void 0, function* () {
+            onLogin?.(() => loginPromise);
+        }, [onLogin, onLoginSuccess, onLoginError, authenticate]);
+        const logout = react_1.default.useCallback(async (options) => {
             const authClient = getAuth();
             if (!authClient) {
                 throw new Error("Auth client not initialized");
             }
-            yield authClient.logout(options);
-            yield authenticate();
-            onLoggedOut === null || onLoggedOut === void 0 ? void 0 : onLoggedOut();
-        }), [onLoggedOut]);
+            await authClient.logout(options);
+            await authenticate();
+            onLoggedOut?.();
+        }, [onLoggedOut]);
         return {
-            authenticated,
-            authenticating,
+            isAuthenticated,
+            isAuthenticating,
+            authenticated: isAuthenticated,
+            authenticating: isAuthenticating,
             identity,
             error,
             login,
             logout,
             authenticate,
-            loginLoading: loginState.loading,
+            loginLoading: loginState.isLoading,
+            isLoginLoading: loginState.isLoading,
             loginError: loginState.error,
         };
     };

package/dist/helpers/extractActorContext.js

@@ -26,7 +26,7 @@ function extractActorContext(actorContext) {
     const useVisitMethod = (functionName) => useActorContext().useVisitMethod(functionName);
     const useVisitService = () => useActorContext().useVisitService();
     const useActorInterface = () => useActorContext().useActorInterface();
-    const useInitializeActor = () => { var _a, _b; return (_b = (_a = useActorContext()).useInitializeActor) === null || _b === void 0 ? void 0 : _b.call(_a); };
+    const useInitializeActor = () => useActorContext().useInitializeActor?.();
     return {
         useActorStore,
         useActorState,

package/dist/helpers/types.d.ts

@@ -1,4 +1,4 @@
-import { CallConfig } from "@dfinity/agent";
+import { AgentError, CallConfig } from "@dfinity/agent";
 import type { IDL, ActorState, AuthClientLoginOptions, ActorMethodParameters, ActorMethodReturnType, Identity, Principal, FunctionName, VisitService, AuthState, HttpAgent, AgentState, BaseActor, MethodAttributes, CompiledResult, ExtractOk, ExtractErr } from "../types";
 export interface AgentHooksReturnType {
     useAgent: () => HttpAgent | undefined;
@@ -18,19 +18,80 @@ export interface UseAuthParameters {
     onLogin?: (promise: () => Promise<Principal>) => void;
     onLoggedOut?: () => void;
 }
+/**
+ * The return type for authentication hooks.
+ */
 export interface UseAuthReturnType {
+    /**
+     * Any non-login related error that occurred.
+     */
     error: Error | undefined;
+    /**
+     * @deprecated Use `isAuthenticated` instead.
+     * Indicates whether the user is authenticated.
+     */
     authenticated: boolean;
+    /**
+     * Indicates whether the user is authenticated.
+     */
+    isAuthenticated: boolean;
+    /**
+     * @deprecated Use `isAuthenticating` instead.
+     * Indicates whether an authentication request is in progress.
+     */
     authenticating: boolean;
+    /**
+     * Indicates whether an authentication request is in progress.
+     */
+    isAuthenticating: boolean;
+    /**
+     * The current identity object, or `null` if not authenticated.
+     */
     identity: Identity | null;
+    /**
+     * Initiates the login flow with optional parameters.
+     * @param options Login parameters (e.g. redirect URL).
+     */
     login: (options?: LoginParameters) => Promise<void>;
+    /**
+     * Logs the user out with optional parameters.
+     * @param options Logout parameters (e.g. return URL).
+     */
     logout: (options?: LogoutParameters) => Promise<void>;
+    /**
+     * Triggers the authentication flow and resolves to an `Identity`.
+     */
     authenticate: () => Promise<Identity>;
+    /**
+     * @deprecated Use `isLoginLoading` instead.
+     * Indicates whether the login operation is in progress.
+     */
     loginLoading: boolean;
+    /**
+     * Indicates whether the login operation is in progress.
+     */
+    isLoginLoading: boolean;
+    /**
+     * The error message, if any, occurred during login.
+     */
     loginError: string | undefined;
 }
+/**
+ * Represents the state of a login operation.
+ */
 export type LoginState = {
+    /**
+     * @deprecated Use `isLoading` instead.
+     * Indicates whether the login operation is in progress.
+     */
     loading: boolean;
+    /**
+     * Indicates whether the login operation is in progress.
+     */
+    isLoading: boolean;
+    /**
+     * The error message, if any, occurred during login.
+     */
     error: string | undefined;
 };
 export type LoginParameters = AuthClientLoginOptions;
@@ -41,21 +102,37 @@ export type UseActorStore<A> = <T>(callback?: (state: ActorState<A>) => T) => T;
 export interface UseActorStateReturnType extends Omit<ActorState, "methodState"> {
     canisterId: string;
 }
+/**
+ * State for shared calls, including the result, error, and loading status.
+ */
 export type UseSharedCallState<A, M extends FunctionName<A>> = {
+    /**
+     * The data returned from the call, or `undefined` if not yet available.
+     */
     data: ActorMethodReturnType<A[M]> | undefined;
-    error: Error | undefined;
+    /**
+     * The error that occurred during the call, or `undefined` if none.
+     */
+    error: AgentError | undefined;
+    /**
+     * @deprecated Use `isLoading` instead.
+     * Indicates whether the call is in progress.
+     */
     loading: boolean;
+    /**
+     * Indicates whether the call is in progress.
+     */
+    isLoading: boolean;
 };
 export interface UseSharedCallParameters<A, M extends FunctionName<A>> extends CallConfig {
     functionName: M;
     args?: ActorMethodParameters<A[M]>;
     onLoading?: (loading: boolean) => void;
-    onError?: (error: Error | undefined) => void;
+    onError?: (error: AgentError | undefined) => void;
     onSuccess?: (data: ActorMethodReturnType<A[M]>) => void;
     onSuccessResult?: (value: ExtractOk<ActorMethodReturnType<A[M]>>) => void;
     onErrorResult?: (error: ExtractErr<ActorMethodReturnType<A[M]>>) => void;
     throwOnError?: boolean;
-    compileResult?: boolean;
 }
 export interface UseSharedCallReturnType<A, M extends FunctionName<A> = FunctionName<A>> extends UseSharedCallState<A, M> {
     requestKey: string;
@@ -72,26 +149,59 @@ export interface UseQueryCallReturnType<A, M extends FunctionName<A>> extends Us
     refetch: () => void;
 }
 export type UseQueryCall<A> = <M extends FunctionName<A>>(params: UseQueryCallParameters<A, M>) => UseQueryCallReturnType<A, M>;
-export interface UseUpdateCallParameters<A, M extends FunctionName<A>> extends UseSharedCallParameters<A, M> {
-}
-export interface UseUpdateCallReturnType<A, M extends FunctionName<A>> extends UseSharedCallReturnType<A, M> {
-}
+export type UseUpdateCallParameters<A, M extends FunctionName<A>> = UseSharedCallParameters<A, M>;
+export type UseUpdateCallReturnType<A, M extends FunctionName<A>> = UseSharedCallReturnType<A, M>;
 export type UseUpdateCall<A> = <M extends FunctionName<A>>(params: UseUpdateCallParameters<A, M>) => UseUpdateCallReturnType<A, M>;
 export interface DynamicDataArgs<V = unknown> {
     label: string;
     value: V;
 }
-export interface UseMethodParameters<A, M extends FunctionName<A>> extends UseQueryCallParameters<A, M> {
-}
+export type UseMethodParameters<A, M extends FunctionName<A>> = UseQueryCallParameters<A, M>;
 export interface UseMethodReturnType<A, M extends FunctionName<A> = FunctionName<A>> {
+    /**
+     * @deprecated Use `isLoading` instead.
+     * Indicates whether the method call is in progress.
+     */
     loading: boolean;
-    formRequired: boolean;
+    /**
+     * Indicates whether the method call is in progress.
+     */
+    isLoading: boolean;
+    /**
+     * Indicates whether the argument form is required for the method.
+     */
+    isFormRequired: boolean;
+    /**
+     * A unique key representing the current request instance.
+     */
     requestKey: string;
-    error: Error | undefined;
+    /**
+     * The error that occurred during the method call, if any.
+     */
+    error: AgentError | undefined;
+    /**
+     * The data returned from the method call, or `undefined` if not yet available.
+     */
     data: ActorMethodReturnType<A[M]> | undefined;
-    validateArgs: (args?: ActorMethodParameters<A[M]> | undefined) => boolean;
+    /**
+     * Validates the provided arguments against the method signature.
+     * @param args Optional arguments for the method.
+     * @returns `true` if the arguments match the expected signature, otherwise `false`.
+     */
+    validateArgs: (args?: ActorMethodParameters<A[M]>) => boolean;
+    /**
+     * The visit service function corresponding to this method.
+     */
     visit: VisitService<A>[M];
+    /**
+     * Resets the method state (data, error, loading) to initial values.
+     */
     reset: () => void;
+    /**
+     * Invokes the method.
+     * @param eventOrReplaceArgs Either the arguments for the call or a React mouse event.
+     * @returns A promise resolving to the method's return data or `undefined`.
+     */
     call: (eventOrReplaceArgs?: ActorMethodParameters<A[M]> | React.MouseEvent) => Promise<ActorMethodReturnType<A[M]> | undefined>;
 }
 export type UseMethod<A> = <M extends FunctionName<A>>(args: UseMethodParameters<A, M>) => UseMethodReturnType<A, M>;

package/dist/hooks/types.d.ts

@@ -11,9 +11,9 @@ export interface UseActorManagerParameters<A> extends ActorReConfigParameters {
 }
 export interface UseActorReturn<A = BaseActor> {
     hooks: ActorHooksReturnType<A> | null;
-    fetching: boolean;
+    isFetching: boolean;
     fetchError: string | null;
-    authenticating: boolean;
+    isAuthenticating: boolean;
     initializeActor: InitializeActor;
 }
 export interface UseActorManagerReturn<A = BaseActor> {