@ic-reactor/react 1.0.4 → 1.0.6

package/README.md

@@ -3,6 +3,7 @@
 ## Features
 
 - **React Hooks Integration**: Custom hooks for managing blockchain actor states and authentication within React applications.
+- **Type-Safe Actor Interactions**: Type-safe interaction with IC actors using the provided actor declaration file.
 - **Efficient State Management**: Utilize the power of Zustand for global state management in React components.
 - **Asynchronous Data Handling**: Easy handling of asynchronous operations related to IC actors.
 - **Authentication Support**: Integrated hooks for managing authentication with the IC blockchain.
@@ -29,25 +30,24 @@ Here's a simple example to get you started:
 First, create an actor declaration file:
 
 ```ts
-// store.ts
+// actor.ts
 import { canisterId, idlFactory, actor } from "declaration/actor"
 import { createReactor } from "@ic-reactor/react"
 
 type Actor = typeof actor
 
-export const { useActorStore, useAuthClient, useQueryCall } =
-  createReactor<Actor>({
-    canisterId: "rrkah-fqaaa-aaaaa-aaaaq-cai",
-    idlFactory,
-    host: "https://localhost:4943",
-  })
+export const { useActorStore, useAuth, useQueryCall } = createReactor<Actor>({
+  canisterId,
+  idlFactory,
+  host: "https://localhost:4943",
+})
 ```
 
 Then, use the `useQueryCall` hook to call your canister method:
 
 ```jsx
 // Balance.tsx
-import { useQueryCall } from "./store"
+import { useQueryCall } from "./actor"
 
 const Balance = ({ principal }) => {
   const { call, data, loading, error } = useQueryCall({
@@ -62,7 +62,7 @@ const Balance = ({ principal }) => {
 
   return (
     <div>
-      <button onClick={() => call()} disabled={loading}>
+      <button onClick={call} disabled={loading}>
         {loading ? "Loading..." : "Refresh"}
       </button>
       {loading && <p>Loading...</p>}
@@ -81,7 +81,7 @@ export default Balance
 
 ```jsx
 // Login.tsx
-import { useAuthClient } from "./store"
+import { useAuth } from "./actor"
 
 const Login = () => {
   const {
@@ -92,7 +92,7 @@ const Login = () => {
     identity,
     authenticating,
     authenticated,
-  } = useAuthClient()
+  } = useAuth()
 
   return (
     <div>
@@ -104,21 +104,11 @@ const Login = () => {
       </div>
       {authenticated ? (
         <div>
-          <button onClick={() => logout()}>Logout</button>
+          <button onClick={logout}>Logout</button>
         </div>
       ) : (
         <div>
-          <button
-            onClick={() =>
-              login({
-                identityProvider:
-                  process.env.DFX_NETWORK === "ic"
-                    ? "https://identity.ic0.app/#authorize"
-                    : "http://rdmx6-jaaaa-aaaaa-aaadq-cai.localhost:4943/#authorize",
-              })
-            }
-            disabled={authenticating}
-          >
+          <button onClick={login} disabled={authenticating}>
             Login
           </button>
         </div>

package/dist/helpers/{actor.d.ts → actorHooks.d.ts}

@@ -1,6 +1,5 @@
-import type { ActorHooks } from "../types";
-import type { BaseActor } from "@ic-reactor/core/dist/types";
-import { ActorManager } from "@ic-reactor/core";
+import type { ActorHooksReturnType } from "../types";
+import type { ActorManager, BaseActor } from "@ic-reactor/core/dist/types";
 /**
  * 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.
  *
@@ -11,11 +10,9 @@ import { ActorManager } from "@ic-reactor/core";
  * - 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.
+ * - useUpdateCall: Hook specifically designed for update calls to actors with features such as error handling and loading 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>;
+export declare const actorHooks: <A = BaseActor>(actorManager: ActorManager<A>) => ActorHooksReturnType<A>;

package/dist/helpers/{actor.js → actorHooks.js}

@@ -20,7 +20,7 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getActorHooks = void 0;
+exports.actorHooks = void 0;
 const react_1 = require("react");
 const zustand_1 = require("zustand");
 const DEFAULT_STATE = {
@@ -38,26 +38,24 @@ const DEFAULT_STATE = {
  * - 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.
+ * - useUpdateCall: Hook specifically designed for update calls to actors with features such as error handling and loading 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 actorHooks = (actorManager) => {
     const { actorStore, canisterId, visitFunction, callMethod, initialize } = actorManager;
     const useActorState = () => (Object.assign(Object.assign({}, (0, zustand_1.useStore)(actorStore)), { canisterId }));
     const useVisitMethod = (functionName) => {
         return (0, react_1.useMemo)(() => visitFunction[functionName], [functionName]);
     };
-    const useReactorCall = (_a) => {
+    const useMethodCall = (_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* () {
             var _b, _c, _d, _e, _f;
-            setState({ data: undefined, error: undefined, loading: true });
+            setState((prev) => (Object.assign(Object.assign({}, prev), { 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 instanceof Array ? eventOrReplaceArgs : args;
@@ -81,7 +79,7 @@ const getActorHooks = (actorManager) => {
     };
     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 _b = useMethodCall(rest), { call } = _b, state = __rest(_b, ["call"]);
         const intervalId = (0, react_1.useRef)();
         (0, react_1.useEffect)(() => {
             if (refetchInterval) {
@@ -94,18 +92,13 @@ const getActorHooks = (actorManager) => {
         }, [refetchInterval, refetchOnMount]);
         return Object.assign({ call }, state);
     };
-    const useUpdateCall = useReactorCall;
-    const useMethodCall = (args) => {
-        const visit = useVisitMethod(args.functionName);
-        return Object.assign({ visit }, useReactorCall(args));
-    };
+    const useUpdateCall = useMethodCall;
     return {
         initialize,
         useQueryCall,
         useUpdateCall,
         useActorState,
-        useMethodCall,
         useVisitMethod,
     };
 };
-exports.getActorHooks = getActorHooks;
+exports.actorHooks = actorHooks;

package/dist/helpers/agentHooks.d.ts

@@ -0,0 +1,3 @@
+import type { AgentManager } from "@ic-reactor/core/dist/types";
+import type { AgentHooksReturnType } from "./types";
+export declare const agentHooks: (agentManager: AgentManager) => AgentHooksReturnType;

package/dist/helpers/{agent.js → agentHooks.js}

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAgentHooks = void 0;
+exports.agentHooks = void 0;
 const react_1 = require("react");
 const zustand_1 = require("zustand");
-const getAgentHooks = (agentManager) => {
+const agentHooks = (agentManager) => {
     const { agentStore, getAgent, subscribeAgent } = agentManager;
     const useAgentState = () => (0, zustand_1.useStore)(agentStore);
     const useAgent = () => {
@@ -16,4 +16,4 @@ const getAgentHooks = (agentManager) => {
         useAgentState,
     };
 };
-exports.getAgentHooks = getAgentHooks;
+exports.agentHooks = agentHooks;

package/dist/helpers/authHooks.d.ts

@@ -0,0 +1,2 @@
+import type { AgentManager, AuthHooksReturnType } from "../types";
+export declare const authHooks: (agentManager: AgentManager) => AuthHooksReturnType;

package/dist/helpers/authHooks.js

@@ -0,0 +1,123 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authHooks = void 0;
+const zustand_1 = require("zustand");
+const react_1 = require("react");
+const tools_1 = require("@ic-reactor/core/dist/tools");
+const authHooks = (agentManager) => {
+    const { authenticate: authenticator, getAuth, authStore, isLocalEnv, } = 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 useAuth = ({ onAuthentication, onAuthenticationSuccess, onAuthenticationFailure, onLogin, onLoginSuccess, onLoginError, onLoggedOut, } = {}) => {
+        const [loginState, setLoginState] = (0, react_1.useState)({
+            loading: false,
+            error: null,
+        });
+        const { authenticated, authenticating, error, identity } = 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,
+        ]);
+        const login = (0, react_1.useCallback)((options) => __awaiter(void 0, void 0, void 0, function* () {
+            setLoginState({ loading: true, error: null });
+            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: isLocalEnv
+                            ? tools_1.IC_INTERNET_IDENTITY_PROVIDER
+                            : tools_1.LOCAL_INTERNET_IDENTITY_PROVIDER }, 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);
+                                setLoginState({ loading: false, error: null });
+                            })
+                                .catch((e) => {
+                                const error = e;
+                                setLoginState({ loading: false, error });
+                                onLoginError === null || onLoginError === void 0 ? void 0 : onLoginError(error);
+                                reject(error);
+                            });
+                        }, 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);
+                            setLoginState({ loading: false, error });
+                            onLoginError === null || onLoginError === void 0 ? void 0 : onLoginError(error);
+                            reject(error);
+                        } }));
+                }
+                catch (e) {
+                    const error = e;
+                    setLoginState({ loading: false, error });
+                    onLoginError === null || onLoginError === void 0 ? void 0 : onLoginError(error);
+                    reject(error);
+                }
+            });
+            onLogin === null || onLogin === void 0 ? void 0 : onLogin(() => loginPromise);
+        }), [onLogin, onLoginSuccess, onLoginError, isLocalEnv, authenticate]);
+        const logout = (0, react_1.useCallback)((options) => __awaiter(void 0, void 0, void 0, function* () {
+            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]);
+        (0, react_1.useEffect)(() => {
+            const authClient = getAuth();
+            if (!authClient && !authenticating) {
+                authenticate();
+            }
+        }, [authenticating]);
+        return {
+            authenticated,
+            authenticating,
+            identity,
+            error,
+            login,
+            logout,
+            authenticate,
+            loginLoading: loginState.loading,
+            loginError: loginState.error,
+        };
+    };
+    return {
+        useUserPrincipal,
+        useAuthState,
+        useAuth,
+    };
+};
+exports.authHooks = authHooks;

package/dist/helpers/extractActorContext.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import type { ActorHooksReturnType, BaseActor, CreateActorContextReturnType } from "../types";
+export declare function extractActorContext<A = BaseActor>(actorContext: React.Context<ActorHooksReturnType<A> | null>): Omit<CreateActorContextReturnType<A>, "ActorProvider">;

package/dist/helpers/extractActorContext.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractActorContext = void 0;
+const react_1 = require("react");
+function extractActorContext(actorContext) {
+    /**
+     * Hook for accessing the actor context, including the actor manager and state.
+     * @returns The actor context, including the actor manager and state.
+     * @example
+     * ```tsx
+     * function ActorComponent() {
+     *  const { initialize, useActorState, useQueryCall, useUpdateCall, useMethodCall, useVisitMethod } = useActorContext();
+     *  const { canisterId } = useActorState();
+     *
+     *  return (
+     *   <div>
+     *     <p>Canister ID: {canisterId}</p>
+     *   </div>
+     *  );
+     * }
+     *
+     * function App() {
+     *  return (
+     *   <ActorProvider canisterId="rrkah-fqaaa-aaaaa-aaaaq-cai">
+     *     <ActorComponent />
+     *   </ActorProvider>
+     *  );
+     * }
+     * ```
+     */
+    const useActorContext = () => {
+        const context = (0, react_1.useContext)(actorContext);
+        if (!context) {
+            throw new Error("Actor hooks must be used within a ActorProvider");
+        }
+        return context;
+    };
+    const initialize = () => useActorContext().initialize();
+    const useActorState = () => useActorContext().useActorState();
+    const useQueryCall = (args) => useActorContext().useQueryCall(args);
+    const useUpdateCall = (args) => useActorContext().useUpdateCall(args);
+    const useVisitMethod = (functionName) => useActorContext().useVisitMethod(functionName);
+    return {
+        useActorState,
+        useQueryCall,
+        useUpdateCall,
+        useVisitMethod,
+        initialize,
+    };
+}
+exports.extractActorContext = extractActorContext;

package/dist/helpers/extractAgentContext.d.ts

@@ -0,0 +1,27 @@
+import type { AgentContext, CreateAgentContextReturnType } from "../types";
+/**
+ * This function facilitates the use of contextually provided agent functionalities,
+ * such as managing the agent's state, authentication state, and user principal.
+ *
+ * @param agentContext A React context object of type AgentContext or null,
+ * typically provided by an AgentProvider at a higher level in the component tree.
+ * @returns An object containing the following hooks:
+ *  - useAgent: Hook for accessing the current agent instance.
+ *  - useAuthState: Hook for accessing the current authentication state.
+ *  - useAgentState: Hook for accessing the current state of the agent.
+ *  - useAuth: Hook for accessing the authentication client, optionally accepting arguments for configuration.
+ *  - useAgentManager: Hook for accessing the AgentManager instance.
+ *  - useUserPrincipal: Hook for accessing the user's principal.
+ *
+ * Each hook is designed to be used within components that are descendants of an AgentProvider,
+ * ensuring access to the necessary agent-related context.
+ *
+ * Throws:
+ *  - Error if used outside of an AgentProvider context.
+ *
+ * ### Integration
+ *
+ * To use these hooks, ensure your components are wrapped in an `AgentProvider` that you've set up to supply the `AgentContext`.
+ * This context provides the necessary agent functionalities and state management capabilities required by the hooks.
+ */
+export declare const extractAgentContext: (agentContext: React.Context<AgentContext | null>) => Omit<CreateAgentContextReturnType, "AgentProvider">;

package/dist/helpers/extractAgentContext.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractAgentContext = void 0;
+const react_1 = require("react");
+/**
+ * This function facilitates the use of contextually provided agent functionalities,
+ * such as managing the agent's state, authentication state, and user principal.
+ *
+ * @param agentContext A React context object of type AgentContext or null,
+ * typically provided by an AgentProvider at a higher level in the component tree.
+ * @returns An object containing the following hooks:
+ *  - useAgent: Hook for accessing the current agent instance.
+ *  - useAuthState: Hook for accessing the current authentication state.
+ *  - useAgentState: Hook for accessing the current state of the agent.
+ *  - useAuth: Hook for accessing the authentication client, optionally accepting arguments for configuration.
+ *  - useAgentManager: Hook for accessing the AgentManager instance.
+ *  - useUserPrincipal: Hook for accessing the user's principal.
+ *
+ * Each hook is designed to be used within components that are descendants of an AgentProvider,
+ * ensuring access to the necessary agent-related context.
+ *
+ * Throws:
+ *  - Error if used outside of an AgentProvider context.
+ *
+ * ### Integration
+ *
+ * To use these hooks, ensure your components are wrapped in an `AgentProvider` that you've set up to supply the `AgentContext`.
+ * This context provides the necessary agent functionalities and state management capabilities required by the hooks.
+ */
+const extractAgentContext = (agentContext) => {
+    const useAgentContext = (mybeAgentContext) => {
+        const context = (0, react_1.useContext)(mybeAgentContext || agentContext);
+        if (!context) {
+            throw new Error("Agent hooks must be used within a AgentProvider");
+        }
+        return context;
+    };
+    const useAgentManager = (agentContext) => {
+        const context = useAgentContext(agentContext);
+        return context.agentManager;
+    };
+    const useAgent = () => useAgentContext().useAgent();
+    const useAuthState = () => useAgentContext().useAuthState();
+    const useAgentState = () => useAgentContext().useAgentState();
+    const useAuth = (args) => useAgentContext().useAuth(args);
+    const useUserPrincipal = () => useAgentContext().useUserPrincipal();
+    return {
+        useAgent,
+        useAuthState,
+        useAgentState,
+        useAuth: useAuth,
+        useAgentManager,
+        useUserPrincipal,
+    };
+};
+exports.extractAgentContext = extractAgentContext;

package/dist/helpers/index.d.ts

@@ -1,3 +1,5 @@
-export * from "./agent";
-export * from "./actor";
-export * from "./auth";
+export * from "./agentHooks";
+export * from "./actorHooks";
+export * from "./authHooks";
+export * from "./extractActorContext";
+export * from "./extractAgentContext";

package/dist/helpers/index.js

@@ -14,6 +14,8 @@ 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("./agent"), exports);
-__exportStar(require("./actor"), exports);
-__exportStar(require("./auth"), exports);
+__exportStar(require("./agentHooks"), exports);
+__exportStar(require("./actorHooks"), exports);
+__exportStar(require("./authHooks"), exports);
+__exportStar(require("./extractActorContext"), exports);
+__exportStar(require("./extractAgentContext"), exports);

package/dist/helpers/types.d.ts

@@ -1,24 +1,15 @@
 /// <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 {
+import type { ActorState, CanisterId, AuthClientLoginOptions, ActorMethodParameters, ActorMethodReturnType, Identity, Principal, FunctionName, VisitService, AuthState, HttpAgent, AgentState, BaseActor } from "@ic-reactor/core/dist/types";
+export interface AgentHooksReturnType {
     useAgent: () => HttpAgent | undefined;
     useAgentState: () => AgentState;
 }
-export interface AuthHooks {
-    useUserPrincipal: () => Principal | undefined;
+export interface AuthHooksReturnType {
+    useAuth: (options?: UseAuthParameters) => UseAuthReturnType;
     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];
+    useUserPrincipal: () => Principal | undefined;
 }
-export interface UseAuthClientArgs {
+export interface UseAuthParameters {
     onAuthentication?: (promise: () => Promise<Identity>) => void;
     onAuthenticationSuccess?: (identity: Identity) => void;
     onAuthenticationFailure?: (error: Error) => void;
@@ -27,14 +18,13 @@ export interface UseAuthClientArgs {
     onLogin?: (promise: () => Promise<Principal>) => void;
     onLoggedOut?: () => void;
 }
-export interface UseAuthClientReturn {
+export interface UseAuthReturnType {
     error: Error | undefined;
-    authClient: AuthClient | null;
     authenticated: boolean;
     authenticating: boolean;
     identity: Identity | null;
-    login: (options?: LoginOptions) => Promise<void>;
-    logout: (options?: LogoutOptions) => Promise<void>;
+    login: (options?: LoginParameters) => Promise<void>;
+    logout: (options?: LogoutParameters) => Promise<void>;
     authenticate: () => Promise<Identity>;
     loginLoading: boolean;
     loginError: Error | null;
@@ -43,13 +33,16 @@ export type LoginState = {
     loading: boolean;
     error: Error | null;
 };
-export type LoginOptions = AuthClientLoginOptions;
-export type LogoutOptions = {
+export type LoginParameters = AuthClientLoginOptions;
+export type LogoutParameters = {
     returnTo?: string;
 };
-export type ReactorCallArgs<A, M extends FunctionName<A>> = {
+export interface UseActorState extends Omit<ActorState, "methodState"> {
+    canisterId: CanisterId;
+}
+export type UseMethodCallParameters<A, M extends FunctionName<A>> = {
     functionName: M;
-    args?: ActorMethodArgs<A[M]>;
+    args?: ActorMethodParameters<A[M]>;
     onLoading?: (loading: boolean) => void;
     onError?: (error: Error | undefined) => void;
     onSuccess?: (data: ActorMethodReturnType<A[M]> | undefined) => void;
@@ -60,27 +53,24 @@ export type ActorCallState<A, M extends FunctionName<A>> = {
     error: Error | undefined;
     loading: boolean;
 };
-export interface UseQueryCallArgs<A, M extends FunctionName<A>> extends ReactorCallArgs<A, M> {
+export interface UseQueryCallParameters<A, M extends FunctionName<A>> extends UseMethodCallParameters<A, M> {
     refetchOnMount?: boolean;
     refetchInterval?: number | false;
 }
-export interface UseUpdateCallArgs<A, M extends FunctionName<A>> extends ReactorCallArgs<A, M> {
+export interface UseUpdateCallParameters<A, M extends FunctionName<A>> extends UseMethodCallParameters<A, M> {
 }
-export interface ReactorCallReturn<A, M extends FunctionName<A> = FunctionName<A>> extends ActorCallState<A, M> {
+export interface UseMethodCallReturnType<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>;
+    call: (eventOrReplaceArgs?: React.MouseEvent | ActorMethodParameters<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;
+export type UseMethodCall<A> = <M extends FunctionName<A>>(args: UseMethodCallParameters<A, M>) => UseMethodCallReturnType<A, M>;
+export type UseQueryCall<A> = <M extends FunctionName<A>>(args: UseQueryCallParameters<A, M>) => UseMethodCallReturnType<A, M>;
+export type UseUpdateCall<A> = <M extends FunctionName<A>>(args: UseUpdateCallParameters<A, M>) => UseMethodCallReturnType<A, M>;
+export type UseVisitMethod<A> = <M extends FunctionName<A>>(functionName: M) => VisitService<A>[M];
+export interface ActorHooksReturnType<A = BaseActor> {
+    initialize: () => Promise<void>;
+    useActorState: () => UseActorState;
+    useQueryCall: UseQueryCall<A>;
+    useUpdateCall: UseUpdateCall<A>;
+    useVisitMethod: UseVisitMethod<A>;
 }

package/dist/index.d.ts

@@ -1,5 +1,4 @@
 export * from "./main";
-export * from "./hooks";
 export * from "./provider";
 export * as helpers from "./helpers";
 export * as types from "./types";

package/dist/index.js

@@ -28,7 +28,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.core = exports.types = exports.helpers = void 0;
 __exportStar(require("./main"), exports);
-__exportStar(require("./hooks"), exports);
 __exportStar(require("./provider"), exports);
 exports.helpers = __importStar(require("./helpers"));
 exports.types = __importStar(require("./types"));