@ic-reactor/react 1.0.2 → 1.0.3

package/dist/helpers/actor.d.ts

@@ -1,3 +1,4 @@
-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";
+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,67 @@ 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;
-    };
+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, callMethod]);
         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);
-            }
-            return () => {
-                clearInterval(intervalId.current);
-            };
-        }, [refetchInterval]);
+            if (refetchInterval)
+                intervalId.current = setInterval(call, refetchInterval);
+            return () => clearInterval(intervalId.current);
+        }, [refetchInterval, call]);
         (0, react_1.useLayoutEffect)(() => {
-            if (refetchOnMount) {
+            if (refetchOnMount)
                 call();
-            }
-        }, []);
+        }, [call, 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.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,7 @@
-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";
+import type { UseAuthClientArgs, UseAuthClientReturn } 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;
-    };
+    useUserPrincipal: () => import("@dfinity/principal").Principal | undefined;
+    useAuthState: () => import("@ic-reactor/core/dist/agent/types").AuthState;
+    useAuthClient: (events?: UseAuthClientArgs) => UseAuthClientReturn;
 };

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,81 @@
-import { getAgentHooks } from "./agent";
-import { getAuthHooks } from "./auth";
+/// <reference types="react" />
+import type { AuthClientLoginOptions } from "@dfinity/auth-client";
+import type { getAgentHooks } from "./agent";
+import type { getAuthHooks } from "./auth";
+import type { ActorState, CanisterId, ActorMethodArgs, ActorMethodReturnType, Identity, Principal, FunctionName, VisitService, AuthClient } from "@ic-reactor/core/dist/types";
 export type AgentHooks = ReturnType<typeof getAgentHooks>;
 export type AuthHooks = ReturnType<typeof getAuthHooks>;
+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;
+}
+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];
+}

package/dist/hooks/index.d.ts

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

package/dist/hooks/index.js

@@ -14,5 +14,5 @@ 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("./useReactor"), exports);
 __exportStar(require("./useCandid"), exports);

package/dist/hooks/useCandid.js

@@ -12,7 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.useCandid = void 0;
 const react_1 = require("react");
 const core_1 = require("@ic-reactor/core");
-const agent_1 = require("../context/agent");
+const agent_1 = require("../provider/agent");
 const DEFAULT_STATE = {
     candid: { idlFactory: undefined, init: () => [] },
     fetching: false,

package/dist/hooks/{useActor.d.ts → useReactor.d.ts}

@@ -9,10 +9,8 @@ interface DynamicActorArgs extends Omit<ActorManagerOptions, "idlFactory" | "age
 }
 /**
  * A hook to create an actor manager and fetch the actor's candid interface.
- *
- * @category Hooks
  */
-export declare const useActor: <A = BaseActor>({ canisterId, agentContext, idlFactory: maybeIdlFactory, didjsCanisterId, ...config }: DynamicActorArgs) => {
+export declare const useReactor: <A = BaseActor>({ canisterId, agentContext, idlFactory: maybeIdlFactory, didjsCanisterId, ...config }: DynamicActorArgs) => {
     fetchCandid: () => Promise<import("@ic-reactor/core/dist/types").CandidDefenition | undefined>;
     fetching: boolean;
     fetchError: string | null;

package/dist/hooks/{useActor.js → useReactor.js}

@@ -11,17 +11,15 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useActor = void 0;
+exports.useReactor = void 0;
 const core_1 = require("@ic-reactor/core");
 const react_1 = require("react");
-const agent_1 = require("../context/agent");
+const agent_1 = require("../provider/agent");
 const useCandid_1 = require("./useCandid");
 /**
  * A hook to create an actor manager and fetch the actor's candid interface.
- *
- * @category Hooks
  */
-const useActor = (_a) => {
+const useReactor = (_a) => {
     var { canisterId, agentContext, idlFactory: maybeIdlFactory, didjsCanisterId } = _a, config = __rest(_a, ["canisterId", "agentContext", "idlFactory", "didjsCanisterId"]);
     const agentManager = (0, agent_1.useAgentManager)(agentContext);
     const _b = (0, useCandid_1.useCandid)({
@@ -45,4 +43,4 @@ const useActor = (_a) => {
     }, [idlFactory]);
     return Object.assign({ actorManager }, rest);
 };
-exports.useActor = useActor;
+exports.useReactor = useReactor;

package/dist/index.d.ts

@@ -1,32 +1,6 @@
-import { BaseActor, CreateReactorOptions } from "@ic-reactor/core/dist/types";
-export declare const createReactor: <A = BaseActor>({ isLocalEnv, withVisitor, withProcessEnv, ...options }: CreateReactorOptions) => {
-    useUserPrincipal: () => import("@dfinity/principal").Principal | undefined;
-    useAuthState: () => import("@ic-reactor/core/dist/types").AuthState;
-    useAuthClient: ({ onAuthentication, onAuthenticationSuccess, onAuthenticationFailure, onLogin, onLoginSuccess, onLoginError, onLoggedOut, }?: import("./types").AuthArgs) => {
-        authClient: import("@dfinity/auth-client").AuthClient | null;
-        authenticated: boolean;
-        authenticating: boolean;
-        identity: import("@ic-reactor/core/dist/types").Identity | null;
-        login: (options?: import("@dfinity/auth-client").AuthClientLoginOptions | undefined) => Promise<void>;
-        logout: (options?: {
-            returnTo?: string | undefined;
-        } | undefined) => Promise<void>;
-        authenticate: () => Promise<import("@ic-reactor/core/dist/types").Identity>;
-        loginLoading: boolean;
-        loginError: Error | null;
-    };
-    initialize: () => Promise<void>;
-    useActorState: () => import("./types").UseActorStoreReturn<A>;
-    useQueryCall: import("./types").ActorQueryCall<A>;
-    useUpdateCall: import("./types").ActorUpdateCall<A>;
-    useMethodCall: <M extends import("@ic-reactor/core/dist/types").FunctionName<A>>(args: import("./types").ActorUseMethodCallArg<A, M>) => import("./types").ActorUseMethodCallReturn<A, M, true>;
-    useVisitMethod: <M_1 extends import("@ic-reactor/core/dist/types").FunctionName<A>>(functionName: M_1) => import("@ic-reactor/core/dist/types").VisitService<A>[M_1];
-    getAgent: () => import("@ic-reactor/core/dist/types").HttpAgent;
-    getVisitFunction: () => import("@ic-reactor/core/dist/types").VisitService<A>;
-};
-export * from "./context/agent";
-export * from "./context/actor";
+export * from "./main";
+export * from "./hooks";
+export * from "./provider";
 export * as helpers from "./helpers";
-export * as hooks from "./hooks";
 export * as types from "./types";
 export * as core from "./core";

package/dist/index.js

@@ -25,46 +25,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-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;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.core = exports.types = exports.hooks = exports.helpers = exports.createReactor = void 0;
-const core_1 = require("@ic-reactor/core");
-const actor_1 = require("./helpers/actor");
-const auth_1 = require("./helpers/auth");
-const tools_1 = require("@ic-reactor/core/dist/tools");
-const createReactor = (_a) => {
-    var { isLocalEnv, withVisitor, withProcessEnv } = _a, options = __rest(_a, ["isLocalEnv", "withVisitor", "withProcessEnv"]);
-    isLocalEnv = isLocalEnv || (withProcessEnv ? (0, tools_1.isInLocalOrDevelopment)() : false);
-    const actorManager = (0, core_1.createReactorStore)(Object.assign({ isLocalEnv,
-        withVisitor }, options));
-    const getVisitFunction = () => {
-        if (!withVisitor) {
-            throw new Error("Service fields not initialized. Pass `withVisitor` to initialize service fields.");
-        }
-        return actorManager.visitFunction;
-    };
-    const getAgent = () => {
-        return actorManager.agentManager.getAgent();
-    };
-    const actorHooks = (0, actor_1.getActorHooks)(actorManager);
-    const authHooks = (0, auth_1.getAuthHooks)(actorManager.agentManager);
-    return Object.assign(Object.assign({ getAgent,
-        getVisitFunction }, actorHooks), authHooks);
-};
-exports.createReactor = createReactor;
-__exportStar(require("./context/agent"), exports);
-__exportStar(require("./context/actor"), exports);
+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.hooks = __importStar(require("./hooks"));
 exports.types = __importStar(require("./types"));
 exports.core = __importStar(require("./core"));

package/dist/main.d.ts

@@ -0,0 +1,2 @@
+import { BaseActor, CreateReactorReturn, CreateReactorOptions } from "./types";
+export declare const createReactor: <A = BaseActor>(options: CreateReactorOptions) => CreateReactorReturn<A>;

package/dist/main.js

@@ -0,0 +1,35 @@
+"use strict";
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReactor = void 0;
+const core_1 = require("@ic-reactor/core");
+const actor_1 = require("./helpers/actor");
+const auth_1 = require("./helpers/auth");
+const tools_1 = require("@ic-reactor/core/dist/tools");
+const helpers_1 = require("./helpers");
+const createReactor = (options) => {
+    const { isLocalEnv, withVisitor, withProcessEnv } = options, args = __rest(options, ["isLocalEnv", "withVisitor", "withProcessEnv"]);
+    const actorManager = (0, core_1.createReactorStore)(Object.assign({ isLocalEnv: isLocalEnv || (withProcessEnv ? (0, tools_1.isInLocalOrDevelopment)() : false), withVisitor }, args));
+    const getVisitFunction = () => {
+        return actorManager.visitFunction;
+    };
+    const getAgent = () => {
+        return actorManager.agentManager.getAgent();
+    };
+    const actorHooks = (0, actor_1.getActorHooks)(actorManager);
+    const authHooks = (0, auth_1.getAuthHooks)(actorManager.agentManager);
+    const agentHooks = (0, helpers_1.getAgentHooks)(actorManager.agentManager);
+    return Object.assign(Object.assign(Object.assign({ getAgent,
+        getVisitFunction }, agentHooks), actorHooks), authHooks);
+};
+exports.createReactor = createReactor;

package/dist/provider/actor/index.d.ts

@@ -0,0 +1,15 @@
+import React from "react";
+import { BaseActor, FunctionName, UseMethodCallArg, UseQueryCallArgs, UseUpdateCallArgs } from "../../types";
+import { CreateActorOptions, ActorContextType, ActorProviderProps } from "./types";
+export declare const ActorContext: React.Context<ActorContextType<BaseActor> | null>, ActorProvider: React.FC<ActorProviderProps>, useActorContext: () => ActorContextType<BaseActor>, useActorState: () => import("../../types").UseActorState, useQueryCall: <M extends string>(args: UseQueryCallArgs<BaseActor, M>) => import("../../types").ReactorCallReturn<BaseActor, M>, useUpdateCall: <M extends string>(args: UseUpdateCallArgs<BaseActor, M>) => import("../../types").ReactorCallReturn<BaseActor, M>, useMethodCall: <M extends string>(args: UseMethodCallArg<BaseActor, M>) => import("../../types").UseMethodCallReturn<BaseActor, M>, useVisitMethod: (functionName: string) => <V extends import("@dfinity/candid/lib/cjs/idl").Visitor<unknown, unknown>>(extractorClass: V, data?: import("@ic-reactor/core/dist/actor/types").VisitorType<V>["data"] | undefined) => ReturnType<V["visitFunc"]>;
+export declare function createReactorContext<Actor = BaseActor>({ canisterId: defaultCanisterId, ...defaultConfig }?: Partial<CreateActorOptions>): {
+    ActorContext: React.Context<ActorContextType<BaseActor> | null>;
+    ActorProvider: React.FC<ActorProviderProps>;
+    useActorContext: () => ActorContextType<Actor>;
+    useActorState: () => import("../../types").UseActorState;
+    useQueryCall: <M extends FunctionName<Actor>>(args: UseQueryCallArgs<Actor, M>) => import("../../types").ReactorCallReturn<Actor, M>;
+    useUpdateCall: <M_1 extends FunctionName<Actor>>(args: UseUpdateCallArgs<Actor, M_1>) => import("../../types").ReactorCallReturn<Actor, M_1>;
+    useMethodCall: <M_2 extends FunctionName<Actor>>(args: UseMethodCallArg<Actor, M_2>) => import("../../types").UseMethodCallReturn<Actor, M_2>;
+    useVisitMethod: (functionName: FunctionName<Actor>) => import("@ic-reactor/core/dist/actor/types").VisitService<Actor>[FunctionName<Actor>];
+    initialize: () => Promise<void>;
+};

package/dist/{context → provider}/actor/index.js

@@ -36,10 +36,9 @@ var __rest = (this && this.__rest) || function (s, e) {
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createReactorContext = exports.useVisitMethod = exports.useMethodCall = exports.useUpdateCall = exports.useQueryCall = exports.useActorState = exports.useActorContext = exports.ActorProvider = exports.ActorContext = void 0;
-/* eslint-disable @typescript-eslint/no-explicit-any */
 const react_1 = __importStar(require("react"));
 const actor_1 = require("../../helpers/actor");
-const useActor_1 = require("../../hooks/useActor");
+const useReactor_1 = require("../../hooks/useReactor");
 _a = createReactorContext(), exports.ActorContext = _a.ActorContext, exports.ActorProvider = _a.ActorProvider, exports.useActorContext = _a.useActorContext, exports.useActorState = _a.useActorState, exports.useQueryCall = _a.useQueryCall, exports.useUpdateCall = _a.useUpdateCall, exports.useMethodCall = _a.useMethodCall, exports.useVisitMethod = _a.useVisitMethod;
 function createReactorContext(_a = {}) {
     var { canisterId: defaultCanisterId } = _a, defaultConfig = __rest(_a, ["canisterId"]);
@@ -50,7 +49,7 @@ function createReactorContext(_a = {}) {
             throw new Error("canisterId is required");
         }
         const config = (0, react_1.useMemo)(() => (Object.assign(Object.assign({}, defaultConfig), restConfig)), [defaultConfig, restConfig]);
-        const { actorManager, fetchError, fetching } = (0, useActor_1.useActor)(Object.assign({ canisterId }, config));
+        const { actorManager, fetchError, fetching } = (0, useReactor_1.useReactor)(Object.assign({ canisterId }, config));
         const hooks = (0, react_1.useMemo)(() => {
             if (actorManager) {
                 return (0, actor_1.getActorHooks)(actorManager);

package/dist/{context → provider}/actor/types.d.ts

@@ -2,19 +2,12 @@
 import { IDL } from "@dfinity/candid";
 import { ActorManagerOptions, BaseActor } from "@ic-reactor/core/dist/types";
 import { ActorHooks, AgentContextType } from "../../types";
-export type ActorContextType<Actor = BaseActor, F extends boolean = true> = ActorHooks<Actor, F> & {
-    ActorContext: React.Context<ActorContextType<Actor, F> | null>;
+export interface ActorContextType<Actor = BaseActor> extends ActorHooks<Actor> {
+    ActorContext: React.Context<ActorContextType<Actor> | null>;
     useActorContext: <A = Actor>() => ActorContextType<A>;
     ActorProvider: React.FC<ActorProviderProps>;
-};
-export type CreateReactorContext = {
-    <A = BaseActor>(options?: Partial<CreateActorOptions> & {
-        withVisitor: true;
-    }): ActorContextType<A, true>;
-    <A = BaseActor>(options?: Partial<CreateActorOptions> & {
-        withVisitor?: false | undefined;
-    }): ActorContextType<A, false>;
-};
+}
+export type CreateReactorContext = <A = BaseActor>(options?: Partial<CreateActorOptions>) => ActorContextType<A>;
 export interface CreateActorOptions extends Omit<ActorManagerOptions, "idlFactory" | "agentManager" | "canisterId"> {
     didjsId?: string;
     canisterId?: string;

package/dist/{context → provider}/agent/hooks.d.ts

@@ -1,24 +1,12 @@
 import { AgentManager } from "@ic-reactor/core/dist/agent";
 import type { AgentContextType } from "./types";
-import { AuthArgs } from "../../types";
-export declare const useAgentManagerContext: (agentContext?: AgentContextType) => import("./types").AgentContextValue;
+import { UseAuthClientArgs } from "../../types";
+export declare const useAgentContext: (agentContext?: AgentContextType) => import("./types").AgentContextValue;
 export declare const useAgentManager: (agentContext?: AgentContextType) => AgentManager;
 export declare const useAgent: (agentContext?: AgentContextType) => import("@dfinity/agent/lib/cjs/agent/http").HttpAgent | undefined;
 export declare const useAuthState: (agentContext?: AgentContextType) => import("@ic-reactor/core/dist/agent/types").AuthState;
 export declare const useAgentState: (agentContext?: AgentContextType) => import("@ic-reactor/core/dist/agent/types").AgentState;
-export declare const useAuthClient: ({ agentContext, ...args }: AuthArgs & {
+export declare const useAuthClient: ({ agentContext, ...args }: UseAuthClientArgs & {
     agentContext?: AgentContextType | undefined;
-}) => {
-    authClient: import("@dfinity/auth-client").AuthClient | null;
-    authenticated: boolean;
-    authenticating: boolean;
-    identity: import("@dfinity/agent/lib/cjs/auth").Identity | null;
-    login: (options?: import("@dfinity/auth-client").AuthClientLoginOptions | undefined) => Promise<void>;
-    logout: (options?: {
-        returnTo?: string | undefined;
-    } | undefined) => Promise<void>;
-    authenticate: () => Promise<import("@dfinity/agent/lib/cjs/auth").Identity>;
-    loginLoading: boolean;
-    loginError: Error | null;
-};
+}) => import("../../types").UseAuthClientReturn;
 export declare const useUserPrincipal: (agentContext?: AgentContextType) => import("@dfinity/principal").Principal | undefined;

package/dist/{context → provider}/agent/hooks.js

@@ -11,33 +11,33 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useUserPrincipal = exports.useAuthClient = exports.useAgentState = exports.useAuthState = exports.useAgent = exports.useAgentManager = exports.useAgentManagerContext = void 0;
+exports.useUserPrincipal = exports.useAuthClient = exports.useAgentState = exports.useAuthState = exports.useAgent = exports.useAgentManager = exports.useAgentContext = void 0;
 const react_1 = require("react");
 const context_1 = require("./context");
-const useAgentManagerContext = (agentContext) => {
+const useAgentContext = (agentContext) => {
     const context = (0, react_1.useContext)(agentContext || context_1.AgentContext);
     if (!context) {
         throw new Error("Agent context must be used within a AgentProvider");
     }
     return context;
 };
-exports.useAgentManagerContext = useAgentManagerContext;
+exports.useAgentContext = useAgentContext;
 const useAgentManager = (agentContext) => {
-    const context = (0, exports.useAgentManagerContext)(agentContext);
+    const context = (0, exports.useAgentContext)(agentContext);
     return context.agentManager;
 };
 exports.useAgentManager = useAgentManager;
-const useAgent = (agentContext) => (0, exports.useAgentManagerContext)(agentContext).useAgent();
+const useAgent = (agentContext) => (0, exports.useAgentContext)(agentContext).useAgent();
 exports.useAgent = useAgent;
-const useAuthState = (agentContext) => (0, exports.useAgentManagerContext)(agentContext).useAuthState();
+const useAuthState = (agentContext) => (0, exports.useAgentContext)(agentContext).useAuthState();
 exports.useAuthState = useAuthState;
-const useAgentState = (agentContext) => (0, exports.useAgentManagerContext)(agentContext).useAgentState();
+const useAgentState = (agentContext) => (0, exports.useAgentContext)(agentContext).useAgentState();
 exports.useAgentState = useAgentState;
 const useAuthClient = (_a) => {
     var { agentContext } = _a, args = __rest(_a, ["agentContext"]);
-    const context = (0, exports.useAgentManagerContext)(agentContext);
+    const context = (0, exports.useAgentContext)(agentContext);
     return context.useAuthClient(args);
 };
 exports.useAuthClient = useAuthClient;
-const useUserPrincipal = (agentContext) => (0, exports.useAgentManagerContext)(agentContext).useUserPrincipal();
+const useUserPrincipal = (agentContext) => (0, exports.useAgentContext)(agentContext).useUserPrincipal();
 exports.useUserPrincipal = useUserPrincipal;

package/dist/types.d.ts

@@ -1,76 +1,10 @@
-/// <reference types="react" />
-import type { ActorState, CanisterId, CreateReactorOptions, ActorMethodArgs, ActorMethodReturnType, HttpAgent, Identity, Principal, FunctionName, VisitService } from "@ic-reactor/core/dist/types";
-import type { AgentHooks, AuthHooks } from "./helpers/types";
+import type { HttpAgent, VisitService } from "@ic-reactor/core/dist/types";
+import type { ActorHooks, AgentHooks, AuthHooks } from "./helpers/types";
 export * from "@ic-reactor/core/dist/types";
-export * from "./context/agent/types";
-export * from "./context/actor/types";
+export * from "./provider/agent/types";
+export * from "./provider/actor/types";
 export * from "./helpers/types";
-export type AuthArgs = {
-    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 type ActorCallArgs<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 ActorHookState<A, M extends FunctionName<A>> = {
-    data: ActorMethodReturnType<A[M]> | undefined;
-    error: Error | undefined;
-    loading: boolean;
-};
-export interface ActorUseQueryArgs<A, M extends FunctionName<A>> extends ActorCallArgs<A, M> {
-    refetchOnMount?: boolean;
-    refetchInterval?: number | false;
-}
-export interface ActorUseUpdateArgs<A, M extends FunctionName<A>> extends ActorCallArgs<A, M> {
-}
-export type ActorCallReturn<A, M extends FunctionName<A>> = ActorHookState<A, M> & {
-    reset: () => void;
-    call: (eventOrReplaceArgs?: React.MouseEvent | ActorMethodArgs<A[M]>) => Promise<ActorMethodReturnType<A[M]> | undefined>;
-};
-export type ActorCall<A> = <M extends FunctionName<A>>(args: ActorCallArgs<A, M>) => ActorCallReturn<A, M>;
-export type ActorQueryCall<A> = <M extends FunctionName<A>>(args: ActorUseQueryArgs<A, M>) => ActorCallReturn<A, M>;
-export type ActorUpdateCall<A> = <M extends FunctionName<A>>(args: ActorUseUpdateArgs<A, M>) => ActorCallReturn<A, M>;
-export type ActorMethodCall<A, M extends FunctionName<A>> = (args: ActorUseMethodCallArg<A, M>) => ActorUseMethodCallReturn<A, M>;
-export interface ActorUseMethodCallReturn<A, M extends FunctionName<A>, F extends boolean = false> extends ActorCallReturn<A, M> {
-    visit: F extends true ? VisitService<A>[M] : undefined;
-    reset: () => void;
-    error: Error | undefined;
-    loading: boolean;
-}
-export type ActorUseMethodCallArg<A, M extends FunctionName<A>> = ActorCallArgs<A, M>;
-export type ActorHooks<A, F extends boolean = false> = ActorDefaultHooks<A, F> & (F extends true ? ActorFieldHooks<A> : object);
-export interface ActorFieldHooks<A> {
-    useVisitMethod: <M extends FunctionName<A>>(functionName: M) => VisitService<A>[M];
-}
-export type UseActorStoreReturn<A> = ActorState<A> & {
-    canisterId: CanisterId;
-};
-export interface ActorDefaultHooks<A, F extends boolean> {
-    initialize: () => Promise<void>;
-    useActorState: () => UseActorStoreReturn<A>;
-    useQueryCall: ActorQueryCall<A>;
-    useUpdateCall: ActorUpdateCall<A>;
-    useMethodCall: <M extends FunctionName<A>>(args: ActorUseMethodCallArg<A, M>) => ActorUseMethodCallReturn<A, M, F>;
-}
-export type GetFunctions<A> = {
+export interface CreateReactorReturn<A> extends ActorHooks<A>, AuthHooks, AgentHooks {
     getAgent: () => HttpAgent;
     getVisitFunction: () => VisitService<A>;
-};
-export type CreateReactor = {
-    <A>(options: CreateReactorOptions & {
-        withVisitor: true;
-    }): GetFunctions<A> & ActorHooks<A, true> & AuthHooks & AgentHooks;
-    <A>(options: CreateReactorOptions & {
-        withVisitor?: false | undefined;
-    }): GetFunctions<A> & ActorHooks<A, false> & AuthHooks & AgentHooks;
-};
+}

package/dist/types.js

@@ -15,6 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("@ic-reactor/core/dist/types"), exports);
-__exportStar(require("./context/agent/types"), exports);
-__exportStar(require("./context/actor/types"), exports);
+__exportStar(require("./provider/agent/types"), exports);
+__exportStar(require("./provider/actor/types"), exports);
 __exportStar(require("./helpers/types"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ic-reactor/react",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "A React library for interacting with Internet Computer canisters",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -35,7 +35,7 @@
     "node": ">=10"
   },
   "dependencies": {
-    "@ic-reactor/core": "^1.0.2",
+    "@ic-reactor/core": "^1.0.3",
     "zustand-utils": "^1.3"
   },
   "peerDependencies": {
@@ -48,5 +48,5 @@
     "react": ">=16.8",
     "zustand": "4.5"
   },
-  "gitHead": "4d19bef671056c8046ec64037f51d85380ff5bae"
+  "gitHead": "acf8b5da61713482264c9eb5c227dc94a7e43cbc"
 }

package/dist/context/actor/index.d.ts

@@ -1,16 +0,0 @@
-import React from "react";
-import { ActorUseMethodCallArg, ActorUseQueryArgs, ActorUseUpdateArgs } from "../../types";
-import { CreateActorOptions, ActorContextType, ActorProviderProps } from "./types";
-import type { ActorSubclass } from "@dfinity/agent";
-export declare const ActorContext: React.Context<ActorContextType | null>, ActorProvider: React.FC<ActorProviderProps>, useActorContext: <A extends unknown = unknown>() => ActorContextType<A>, useActorState: () => import("../../types").UseActorStoreReturn<unknown>, useQueryCall: <M extends never>(args: ActorUseQueryArgs<unknown, M>) => import("../../types").ActorCallReturn<unknown, M>, useUpdateCall: <M extends never>(args: ActorUseUpdateArgs<unknown, M>) => import("../../types").ActorCallReturn<unknown, M>, useMethodCall: <M extends never>(args: ActorUseMethodCallArg<unknown, M>) => import("../../types").ActorUseMethodCallReturn<unknown, M, true>, useVisitMethod: (functionName: never) => never;
-export declare function createReactorContext<Actor extends ActorSubclass<any>>({ canisterId: defaultCanisterId, ...defaultConfig }?: Partial<CreateActorOptions>): {
-    ActorContext: React.Context<ActorContextType | null>;
-    ActorProvider: React.FC<ActorProviderProps>;
-    useActorContext: <A extends unknown = Actor>() => ActorContextType<A>;
-    useActorState: () => import("../../types").UseActorStoreReturn<Actor>;
-    useQueryCall: <M extends keyof Actor & string>(args: ActorUseQueryArgs<Actor, M>) => import("../../types").ActorCallReturn<Actor, M>;
-    useUpdateCall: <M_1 extends keyof Actor & string>(args: ActorUseUpdateArgs<Actor, M_1>) => import("../../types").ActorCallReturn<Actor, M_1>;
-    useMethodCall: <M_2 extends keyof Actor & string>(args: ActorUseMethodCallArg<Actor, M_2>) => import("../../types").ActorUseMethodCallReturn<Actor, M_2, true>;
-    useVisitMethod: (functionName: keyof Actor & string) => import("@ic-reactor/core/dist/actor/types").VisitService<Actor>[keyof Actor & string];
-    initialize: () => Promise<void>;
-};