@ic-reactor/react 0.3.0 → 0.3.2

package/dist/authHooks.d.ts

@@ -0,0 +1,41 @@
+import type { AuthClientLoginOptions } from "@dfinity/auth-client";
+import type { CreateReActorOptions } from "@ic-reactor/store";
+export * from "./context";
+export declare const createReActor: <A extends unknown>(options: Omit<CreateReActorOptions, "isLocal">) => {
+    useMethodFields: () => import("@ic-reactor/store").ActorMethodField<A>[];
+    useMethodField: (functionName: keyof A & string) => import("@ic-reactor/store").ActorMethodField<A> | undefined;
+    useActorStore: () => {
+        initialized: boolean;
+        initializing: boolean;
+        error: Error | undefined;
+        methodState: import("@ic-reactor/store").ActorMethodStates<A>;
+    };
+    useAuthStore: () => import("@ic-reactor/store").ActorAuthState;
+    useQueryCall: <M extends keyof A>({ autoRefresh, refreshInterval, disableInitialCall, ...rest }: import("./types").ReActorUseQueryArgs<A, M>) => {
+        data: import("@ic-reactor/store").ExtractActorMethodReturnType<A[M]> | undefined;
+        error: Error | undefined;
+        loading: boolean;
+        field: import("@ic-reactor/store").ActorMethodField<A> | undefined;
+        call: (replaceArgs?: import("@ic-reactor/store").ExtractActorMethodArgs<A[M]> | undefined) => Promise<import("@ic-reactor/store").ExtractActorMethodReturnType<A[M]> | undefined>;
+    };
+    useUpdateCall: <M_1 extends keyof A>(args: import("./types").ReActorUseUpdateArgs<A, M_1>) => {
+        data: import("@ic-reactor/store").ExtractActorMethodReturnType<A[M_1]> | undefined;
+        error: Error | undefined;
+        loading: boolean;
+        call: (replaceArgs?: import("@ic-reactor/store").ExtractActorMethodArgs<A[M_1]> | undefined) => Promise<import("@ic-reactor/store").ExtractActorMethodReturnType<A[M_1]> | undefined>;
+        field: import("@ic-reactor/store").ActorMethodField<A> | undefined;
+    };
+    useAuthClient: () => {
+        authClient: import("@dfinity/auth-client").AuthClient | null;
+        authenticated: boolean;
+        authenticating: boolean;
+        identity: import("@ic-reactor/store").Identity | null;
+        login: (options?: AuthClientLoginOptions) => Promise<void>;
+        logout: (options?: {
+            returnTo?: string;
+        }) => Promise<void>;
+        authenticate: () => Promise<void>;
+        loginLoading: boolean;
+        loginError: unknown;
+    };
+};

package/dist/authHooks.js

@@ -0,0 +1,102 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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);
+};
+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.createReActor = void 0;
+const store_1 = require("@ic-reactor/store");
+const react_1 = require("react");
+const zustand_1 = require("zustand");
+const hooks_1 = require("./hooks");
+__exportStar(require("./context"), exports);
+const createReActor = (options) => {
+    const isLocal = typeof process !== "undefined" &&
+        (process.env.NODE_ENV === "development" ||
+            process.env.DFX_NETWORK === "local");
+    const { authenticate, authStore, callMethod, actorStore, methodFields } = (0, store_1.createReActorStore)(Object.assign({ isLocal }, options));
+    const useActorStore = () => {
+        const actorState = (0, zustand_1.useStore)(actorStore, (state) => state);
+        return Object.assign({}, actorState);
+    };
+    const useAuthStore = () => {
+        const authState = (0, zustand_1.useStore)(authStore, (state) => state);
+        return authState;
+    };
+    const useAuthClient = () => {
+        const [loginLoading, setLoginLoading] = (0, react_1.useState)(false);
+        const [loginError, setLoginError] = (0, react_1.useState)(null);
+        const { authClient, authenticated, authenticating, identity } = useAuthStore();
+        const login = (options) => __awaiter(void 0, void 0, void 0, function* () {
+            setLoginLoading(true);
+            setLoginError(null);
+            try {
+                yield (authClient === null || authClient === void 0 ? void 0 : authClient.login(Object.assign(Object.assign({}, options), { onSuccess: () => __awaiter(void 0, void 0, void 0, function* () {
+                        var _a;
+                        setLoginLoading(false);
+                        yield authenticate();
+                        (_a = options === null || options === void 0 ? void 0 : options.onSuccess) === null || _a === void 0 ? void 0 : _a.call(options);
+                    }), onError: (e) => {
+                        var _a;
+                        setLoginError(e);
+                        setLoginLoading(false);
+                        (_a = options === null || options === void 0 ? void 0 : options.onError) === null || _a === void 0 ? void 0 : _a.call(options, e);
+                    } })));
+            }
+            catch (e) {
+                setLoginLoading(false);
+                setLoginError(e);
+            }
+        });
+        const logout = (options) => __awaiter(void 0, void 0, void 0, function* () {
+            yield (authClient === null || authClient === void 0 ? void 0 : authClient.logout(options));
+            yield authenticate();
+        });
+        (0, react_1.useEffect)(() => {
+            if (!authClient && !authenticating) {
+                authenticate();
+            }
+        }, [authClient, authenticating]);
+        return {
+            authClient,
+            authenticated,
+            authenticating,
+            identity,
+            login,
+            logout,
+            authenticate,
+            loginLoading,
+            loginError,
+        };
+    };
+    const { useQueryCall, useMethodField, useMethodFields, useUpdateCall } = (0, hooks_1.getActorHooks)(callMethod, methodFields);
+    return {
+        useMethodFields,
+        useMethodField,
+        useActorStore,
+        useAuthStore,
+        useQueryCall,
+        useUpdateCall,
+        useAuthClient,
+    };
+};
+exports.createReActor = createReActor;

package/dist/context.d.ts

@@ -1,14 +1,12 @@
 import React, { PropsWithChildren } from "react";
-import { ActorSubclass } from "@dfinity/agent";
-import { createReActor } from "./index";
+import { type ReActorHooks } from "./index";
 import { IDL } from "@dfinity/candid";
-import { ReActorOptions } from "@ic-reactor/store";
-export type ReActor<A> = ReturnType<typeof createReActor<A>>;
-export interface ReActorContextType<A = ActorSubclass<any>> extends ReActor<A> {
-}
+import { ActorSubclass, AgentManager, CreateReActorOptions } from "@ic-reactor/store";
+export type ReActorContextType<A = ActorSubclass<any>> = ReActorHooks<A>;
 export declare const ReActorContext: React.Context<ReActorContextType<any> | null>;
 export declare const useReActor: <A = any>() => ReActorContextType<A>;
-interface ReActorProviderProps extends PropsWithChildren, Omit<ReActorOptions, "idlFactory"> {
+interface ReActorProviderProps extends PropsWithChildren, Omit<CreateReActorOptions, "idlFactory"> {
+    agentManager?: AgentManager;
     idlFactory?: IDL.InterfaceFactory;
     loadingComponent?: React.ReactNode;
 }

package/dist/context.js

@@ -45,12 +45,11 @@ var __rest = (this && this.__rest) || function (s, e) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReActorProvider = exports.useReActor = exports.ReActorContext = void 0;
 const react_1 = __importStar(require("react"));
-const agent_1 = require("@dfinity/agent");
 const index_1 = require("./index");
 const store_1 = require("@ic-reactor/store");
 exports.ReActorContext = (0, react_1.createContext)(null);
 const useReActor = () => {
-    const context = react_1.default.useContext(exports.ReActorContext);
+    const context = (0, react_1.useContext)(exports.ReActorContext);
     if (!context) {
         throw new Error("useReActor must be used within a ReActorProvider");
     }
@@ -58,14 +57,14 @@ const useReActor = () => {
 };
 exports.useReActor = useReActor;
 const ReActorProvider = (_a) => {
-    var { children, loadingComponent = react_1.default.createElement("div", null, "Loading...") } = _a, config = __rest(_a, ["children", "loadingComponent"]);
+    var { children, canisterId, loadingComponent = react_1.default.createElement("div", null, "Loading...") } = _a, config = __rest(_a, ["children", "canisterId", "loadingComponent"]);
+    const agentManager = (0, react_1.useRef)(config.agentManager || (0, store_1.createAgentManager)(config));
     const [didJs, setDidJS] = (0, react_1.useState)();
     const fetchDidJs = (0, react_1.useCallback)(() => __awaiter(void 0, void 0, void 0, function* () {
-        const { canisterId } = config;
         if (!canisterId) {
             throw new Error("canisterId is required");
         }
-        const agent = new agent_1.HttpAgent(Object.assign({}, config));
+        const agent = agentManager.current.getAgent();
         (0, store_1.getDidJsFromMetadata)(agent, canisterId).then((idlFactory) => __awaiter(void 0, void 0, void 0, function* () {
             if (!idlFactory) {
                 try {
@@ -87,7 +86,7 @@ const ReActorProvider = (_a) => {
             setDidJS(idlFactory);
         }));
         return didJs;
-    }), [config.canisterId]);
+    }), [canisterId]);
     (0, react_1.useEffect)(() => {
         const { idlFactory } = config;
         if (idlFactory) {
@@ -96,19 +95,23 @@ const ReActorProvider = (_a) => {
         }
         fetchDidJs();
     }, [fetchDidJs, config.idlFactory]);
-    const reActorHooks = (0, react_1.useMemo)(() => {
+    const hooks = (0, react_1.useMemo)(() => {
         if (!didJs) {
             return null;
         }
         try {
-            return (0, index_1.createReActor)(Object.assign(Object.assign({}, config), { idlFactory: didJs.idlFactory }));
+            return (0, index_1.createReActor)({
+                idlFactory: didJs.idlFactory,
+                agentManager: agentManager.current,
+                canisterId,
+                withDevtools: config.withDevtools,
+            });
         }
         catch (err) {
             console.error(err);
             return null;
         }
-    }, [config, didJs]);
-    (0, react_1.useEffect)(() => reActorHooks === null || reActorHooks === void 0 ? void 0 : reActorHooks.unsubscribeAgent, [reActorHooks === null || reActorHooks === void 0 ? void 0 : reActorHooks.unsubscribeAgent]);
-    return (react_1.default.createElement(exports.ReActorContext.Provider, { value: reActorHooks }, reActorHooks ? children : loadingComponent));
+    }, [canisterId, didJs]);
+    return (react_1.default.createElement(exports.ReActorContext.Provider, { value: hooks }, hooks === null ? loadingComponent : children));
 };
 exports.ReActorProvider = ReActorProvider;

package/dist/hooks/actor.d.ts

@@ -0,0 +1,26 @@
+import type { ExtractActorMethodArgs, ActorManager, ActorMethodField } from "@ic-reactor/store";
+import type { ReActorUseQueryArgs, ReActorUseUpdateArgs } from "../types";
+export declare const getActorHooks: <A extends unknown>({ methodFields, actorStore, callMethod, }: ActorManager<A>) => {
+    useQueryCall: <M extends keyof A>({ autoRefresh, refreshInterval, disableInitialCall, ...rest }: ReActorUseQueryArgs<A, M>) => {
+        data: import("@ic-reactor/store").ExtractActorMethodReturnType<A[M]> | undefined;
+        error: Error | undefined;
+        loading: boolean;
+        field: ActorMethodField<A> | undefined;
+        call: (replaceArgs?: ExtractActorMethodArgs<A[M]> | undefined) => Promise<import("@ic-reactor/store").ExtractActorMethodReturnType<A[M]> | undefined>;
+    };
+    useUpdateCall: <M_1 extends keyof A>(args: ReActorUseUpdateArgs<A, M_1>) => {
+        data: import("@ic-reactor/store").ExtractActorMethodReturnType<A[M_1]> | undefined;
+        error: Error | undefined;
+        loading: boolean;
+        call: (replaceArgs?: ExtractActorMethodArgs<A[M_1]> | undefined) => Promise<import("@ic-reactor/store").ExtractActorMethodReturnType<A[M_1]> | undefined>;
+        field: ActorMethodField<A> | undefined;
+    };
+    useActorStore: () => {
+        initialized: boolean;
+        initializing: boolean;
+        error: Error | undefined;
+        methodState: import("@ic-reactor/store").ActorMethodStates<A>;
+    };
+    useMethodField: (functionName: keyof A & string) => ActorMethodField<A> | undefined;
+    useMethodFields: () => ActorMethodField<A>[];
+};

package/dist/hooks/actor.js

@@ -0,0 +1,100 @@
+"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 __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.getActorHooks = void 0;
+const react_1 = require("react");
+const zustand_1 = require("zustand");
+const getActorHooks = ({ methodFields, actorStore, callMethod, }) => {
+    const useActorStore = () => {
+        const actorState = (0, zustand_1.useStore)(actorStore, (state) => state);
+        return Object.assign({}, actorState);
+    };
+    const useMethodFields = () => {
+        return methodFields;
+    };
+    const useMethodField = (functionName) => {
+        const methodFields = useMethodFields();
+        const field = (0, react_1.useMemo)(() => {
+            return methodFields.find((f) => f.functionName === functionName);
+        }, [methodFields, functionName]);
+        return field;
+    };
+    const useReActorCall = ({ onError, onSuccess, onLoading, args = [], functionName, }) => {
+        const [state, setState] = (0, react_1.useState)({
+            data: undefined,
+            error: undefined,
+            loading: false,
+        });
+        const call = (0, react_1.useCallback)((replaceArgs) => __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 })));
+            try {
+                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 })));
+                return data;
+            }
+            catch (error) {
+                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 })));
+            }
+        }), [args, functionName, onError, onSuccess, onLoading]);
+        const field = useMethodField(functionName);
+        return Object.assign({ call, field }, state);
+    };
+    const useQueryCall = (_a) => {
+        var { autoRefresh, refreshInterval = 5000, disableInitialCall } = _a, rest = __rest(_a, ["autoRefresh", "refreshInterval", "disableInitialCall"]);
+        const _b = useReActorCall(rest), { call } = _b, state = __rest(_b, ["call"]);
+        let intervalId = (0, react_1.useRef)(undefined);
+        (0, react_1.useEffect)(() => {
+            // Auto-refresh logic
+            if (autoRefresh) {
+                intervalId.current = setInterval(() => {
+                    call();
+                }, refreshInterval);
+            }
+            // Initial call logic
+            if (!disableInitialCall) {
+                call();
+            }
+            return () => {
+                clearInterval(intervalId.current);
+            };
+        }, [disableInitialCall, autoRefresh, refreshInterval]);
+        return Object.assign({ call }, state);
+    };
+    const useUpdateCall = (args) => {
+        return useReActorCall(args);
+    };
+    return {
+        useQueryCall,
+        useUpdateCall,
+        useActorStore,
+        useMethodField,
+        useMethodFields,
+    };
+};
+exports.getActorHooks = getActorHooks;

package/dist/hooks/auth.d.ts

@@ -0,0 +1,18 @@
+import type { AuthClientLoginOptions } from "@dfinity/auth-client";
+import type { AgentManager } from "@ic-reactor/store";
+export declare const getAuthHooks: ({ authStore, authenticate }: AgentManager) => {
+    useAuthStore: () => import("@ic-reactor/store").ActorAuthState;
+    useAuthClient: () => {
+        authClient: import("@dfinity/auth-client").AuthClient | null;
+        authenticated: boolean;
+        authenticating: boolean;
+        identity: import("@ic-reactor/store").Identity | null;
+        login: (options?: AuthClientLoginOptions) => Promise<void>;
+        logout: (options?: {
+            returnTo?: string;
+        }) => Promise<void>;
+        authenticate: () => Promise<void>;
+        loginLoading: boolean;
+        loginError: unknown;
+    };
+};

package/dist/hooks/auth.js

@@ -0,0 +1,71 @@
+"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.getAuthHooks = void 0;
+const react_1 = require("react");
+const zustand_1 = require("zustand");
+const getAuthHooks = ({ authStore, authenticate }) => {
+    const useAuthStore = () => {
+        const authState = (0, zustand_1.useStore)(authStore, (state) => state);
+        return authState;
+    };
+    const useAuthClient = () => {
+        const [loginLoading, setLoginLoading] = (0, react_1.useState)(false);
+        const [loginError, setLoginError] = (0, react_1.useState)(null);
+        const { authClient, authenticated, authenticating, identity } = useAuthStore();
+        const login = (options) => __awaiter(void 0, void 0, void 0, function* () {
+            setLoginLoading(true);
+            setLoginError(null);
+            try {
+                yield (authClient === null || authClient === void 0 ? void 0 : authClient.login(Object.assign(Object.assign({}, options), { onSuccess: () => __awaiter(void 0, void 0, void 0, function* () {
+                        var _a;
+                        setLoginLoading(false);
+                        yield authenticate();
+                        (_a = options === null || options === void 0 ? void 0 : options.onSuccess) === null || _a === void 0 ? void 0 : _a.call(options);
+                    }), onError: (e) => {
+                        var _a;
+                        setLoginError(e);
+                        setLoginLoading(false);
+                        (_a = options === null || options === void 0 ? void 0 : options.onError) === null || _a === void 0 ? void 0 : _a.call(options, e);
+                    } })));
+            }
+            catch (e) {
+                setLoginLoading(false);
+                setLoginError(e);
+            }
+        });
+        const logout = (options) => __awaiter(void 0, void 0, void 0, function* () {
+            yield (authClient === null || authClient === void 0 ? void 0 : authClient.logout(options));
+            yield authenticate();
+        });
+        (0, react_1.useEffect)(() => {
+            if (!authClient && !authenticating) {
+                authenticate();
+            }
+        }, [authClient, authenticating]);
+        return {
+            authClient,
+            authenticated,
+            authenticating,
+            identity,
+            login,
+            logout,
+            authenticate,
+            loginLoading,
+            loginError,
+        };
+    };
+    return {
+        useAuthStore,
+        useAuthClient,
+    };
+};
+exports.getAuthHooks = getAuthHooks;

package/dist/hooks/index.d.ts

@@ -0,0 +1,6 @@
+import type { ActorSubclass } from "@ic-reactor/store";
+import { getAuthHooks } from "./auth";
+import { getActorHooks } from "./actor";
+export type ReActorHooks<A extends ActorSubclass<any>> = ReturnType<typeof getActorHooks<A>> & ReturnType<typeof getAuthHooks>;
+export { getActorHooks } from "./actor";
+export { getAuthHooks } from "./auth";

package/dist/hooks/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAuthHooks = exports.getActorHooks = void 0;
+var actor_1 = require("./actor");
+Object.defineProperty(exports, "getActorHooks", { enumerable: true, get: function () { return actor_1.getActorHooks; } });
+var auth_1 = require("./auth");
+Object.defineProperty(exports, "getAuthHooks", { enumerable: true, get: function () { return auth_1.getAuthHooks; } });

package/dist/hooks.d.ts

@@ -1,20 +1,20 @@
-import type { CallMethod, ExtractReActorMethodArgs, ReActorActorStore } from "@ic-reactor/store";
+import type { CallActorMethod, ExtractActorMethodArgs, ActorMethodField } from "@ic-reactor/store";
 import type { ReActorUseQueryArgs, ReActorUseUpdateArgs } from "./types";
-export declare const getCallHooks: <A extends unknown>(callMethod: CallMethod<A>, actorStore: ReActorActorStore<A>) => {
+export declare const getActorHooks: <A extends unknown>(callMethod: CallActorMethod<A>, methodFields: ActorMethodField<A>[]) => {
     useQueryCall: <M extends keyof A>({ autoRefresh, refreshInterval, disableInitialCall, ...rest }: ReActorUseQueryArgs<A, M>) => {
-        data: import("@ic-reactor/store").ExtractReActorMethodReturnType<A[M]> | undefined;
+        data: import("@ic-reactor/store").ExtractActorMethodReturnType<A[M]> | undefined;
         error: Error | undefined;
         loading: boolean;
-        field: import("@ic-reactor/store").ReActorMethodField<A> | undefined;
-        call: (replaceArgs?: ExtractReActorMethodArgs<A[M]> | undefined) => Promise<import("@ic-reactor/store").ExtractReActorMethodReturnType<A[M]> | undefined>;
+        field: ActorMethodField<A> | undefined;
+        call: (replaceArgs?: ExtractActorMethodArgs<A[M]> | undefined) => Promise<import("@ic-reactor/store").ExtractActorMethodReturnType<A[M]> | undefined>;
     };
     useUpdateCall: <M_1 extends keyof A>(args: ReActorUseUpdateArgs<A, M_1>) => {
-        data: import("@ic-reactor/store").ExtractReActorMethodReturnType<A[M_1]> | undefined;
+        data: import("@ic-reactor/store").ExtractActorMethodReturnType<A[M_1]> | undefined;
         error: Error | undefined;
         loading: boolean;
-        call: (replaceArgs?: ExtractReActorMethodArgs<A[M_1]> | undefined) => Promise<import("@ic-reactor/store").ExtractReActorMethodReturnType<A[M_1]> | undefined>;
-        field: import("@ic-reactor/store").ReActorMethodField<A> | undefined;
+        call: (replaceArgs?: ExtractActorMethodArgs<A[M_1]> | undefined) => Promise<import("@ic-reactor/store").ExtractActorMethodReturnType<A[M_1]> | undefined>;
+        field: ActorMethodField<A> | undefined;
     };
-    useMethodField: (functionName: keyof A & string) => import("@ic-reactor/store").ReActorMethodField<A> | undefined;
-    useMethodFields: () => import("@ic-reactor/store").ReActorMethodField<A>[];
+    useMethodField: (functionName: keyof A & string) => ActorMethodField<A> | undefined;
+    useMethodFields: () => ActorMethodField<A>[];
 };

package/dist/hooks.js

@@ -20,12 +20,11 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCallHooks = void 0;
+exports.getActorHooks = void 0;
 const react_1 = require("react");
-const zustand_1 = require("zustand");
-const getCallHooks = (callMethod, actorStore) => {
+const getActorHooks = (callMethod, methodFields) => {
     const useMethodFields = () => {
-        return (0, zustand_1.useStore)(actorStore, (state) => state.methodFields);
+        return methodFields;
     };
     const useMethodField = (functionName) => {
         const methodFields = useMethodFields();
@@ -92,4 +91,4 @@ const getCallHooks = (callMethod, actorStore) => {
         useMethodFields,
     };
 };
-exports.getCallHooks = getCallHooks;
+exports.getActorHooks = getActorHooks;

package/dist/index.d.ts

@@ -1,49 +1,8 @@
-import type { AuthClientLoginOptions } from "@dfinity/auth-client";
-import type { ReActorOptions } from "@ic-reactor/store";
+import type { ActorSubclass, CreateReActorOptions } from "@ic-reactor/store";
+import { getActorHooks } from "./hooks/actor";
+import { getAuthHooks } from "./hooks/auth";
+export { createReActorStore, createAgentManager, createActorManager, } from "@ic-reactor/store";
 export * from "./context";
-export declare const createReActor: <A extends unknown>(options: ReActorOptions) => {
-    unsubscribeAgent: () => void;
-    useMethodFields: () => import("@ic-reactor/store").ReActorMethodField<A>[];
-    useMethodField: (functionName: keyof A & string) => import("@ic-reactor/store").ReActorMethodField<A> | undefined;
-    useAgentStore: () => {
-        initializeAgent: (agentOptions?: import("@dfinity/agent").HttpAgentOptions | undefined, isLocal?: boolean | undefined) => Promise<void>;
-        agent: import("@ic-reactor/store").HttpAgent | undefined;
-        canisterId: import("@ic-reactor/store").CanisterId;
-    };
-    useActorStore: () => {
-        actor: A | null;
-        initialized: boolean;
-        initializing: boolean;
-        error: Error | undefined;
-        methodState: import("@ic-reactor/store").ReActorMethodStates<A>;
-        methodFields: import("@ic-reactor/store").ReActorMethodField<A>[];
-    };
-    useAuthStore: () => import("@ic-reactor/store").ReActorAuthState<A>;
-    useQueryCall: <M extends keyof A>({ autoRefresh, refreshInterval, disableInitialCall, ...rest }: import("./types").ReActorUseQueryArgs<A, M>) => {
-        data: import("@ic-reactor/store").ExtractReActorMethodReturnType<A[M]> | undefined;
-        error: Error | undefined;
-        loading: boolean;
-        field: import("@ic-reactor/store").ReActorMethodField<A> | undefined;
-        call: (replaceArgs?: import("@ic-reactor/store").ExtractReActorMethodArgs<A[M]> | undefined) => Promise<import("@ic-reactor/store").ExtractReActorMethodReturnType<A[M]> | undefined>;
-    };
-    useUpdateCall: <M_1 extends keyof A>(args: import("./types").ReActorUseUpdateArgs<A, M_1>) => {
-        data: import("@ic-reactor/store").ExtractReActorMethodReturnType<A[M_1]> | undefined;
-        error: Error | undefined;
-        loading: boolean;
-        call: (replaceArgs?: import("@ic-reactor/store").ExtractReActorMethodArgs<A[M_1]> | undefined) => Promise<import("@ic-reactor/store").ExtractReActorMethodReturnType<A[M_1]> | undefined>;
-        field: import("@ic-reactor/store").ReActorMethodField<A> | undefined;
-    };
-    useAuthClient: () => {
-        authClient: import("@dfinity/auth-client").AuthClient | null;
-        authenticated: boolean;
-        authenticating: boolean;
-        identity: import("@ic-reactor/store").Identity | null;
-        login: (options?: AuthClientLoginOptions) => Promise<void>;
-        logout: (options?: {
-            returnTo?: string;
-        }) => Promise<void>;
-        authenticate: () => Promise<void>;
-        loginLoading: boolean;
-        loginError: unknown;
-    };
-};
+export type ReActorHooks<A extends ActorSubclass<any>> = ReturnType<typeof getActorHooks<A>> & ReturnType<typeof getAuthHooks>;
+export type CreateReactorOptions = Omit<CreateReActorOptions, "isLocal">;
+export declare const createReActor: <A extends unknown>(options: Omit<CreateReActorOptions, "isLocal">) => ReActorHooks<A>;

package/dist/index.js

@@ -13,91 +13,26 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 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);
 };
-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.createReActor = void 0;
+exports.createReActor = exports.createActorManager = exports.createAgentManager = exports.createReActorStore = void 0;
 const store_1 = require("@ic-reactor/store");
-const react_1 = require("react");
-const zustand_1 = require("zustand");
-const hooks_1 = require("./hooks");
+const actor_1 = require("./hooks/actor");
+const auth_1 = require("./hooks/auth");
+var store_2 = require("@ic-reactor/store");
+Object.defineProperty(exports, "createReActorStore", { enumerable: true, get: function () { return store_2.createReActorStore; } });
+Object.defineProperty(exports, "createAgentManager", { enumerable: true, get: function () { return store_2.createAgentManager; } });
+Object.defineProperty(exports, "createActorManager", { enumerable: true, get: function () { return store_2.createActorManager; } });
 __exportStar(require("./context"), exports);
 const createReActor = (options) => {
     const isLocal = typeof process !== "undefined" &&
         (process.env.NODE_ENV === "development" ||
             process.env.DFX_NETWORK === "local");
-    const { unsubscribeAgent, initializeAgent, authenticate, callMethod, authStore, agentStore, actorStore, } = (0, store_1.createReActorStore)(Object.assign({ isLocal }, options));
-    const useAgentStore = () => {
-        const agentState = (0, zustand_1.useStore)(agentStore, (state) => state);
-        return Object.assign(Object.assign({}, agentState), { initializeAgent });
-    };
-    const useActorStore = () => {
-        const actorState = (0, zustand_1.useStore)(actorStore, (state) => state);
-        return Object.assign({}, actorState);
-    };
-    const useAuthStore = () => {
-        const authState = (0, zustand_1.useStore)(authStore, (state) => state);
-        return authState;
-    };
-    const useAuthClient = () => {
-        const [loginLoading, setLoginLoading] = (0, react_1.useState)(false);
-        const [loginError, setLoginError] = (0, react_1.useState)(null);
-        const { authClient, authenticated, authenticating, identity } = useAuthStore();
-        const login = (options) => __awaiter(void 0, void 0, void 0, function* () {
-            setLoginLoading(true);
-            setLoginError(null);
-            try {
-                yield (authClient === null || authClient === void 0 ? void 0 : authClient.login(Object.assign(Object.assign({}, options), { onSuccess: () => __awaiter(void 0, void 0, void 0, function* () {
-                        var _a;
-                        setLoginLoading(false);
-                        yield authenticate();
-                        (_a = options === null || options === void 0 ? void 0 : options.onSuccess) === null || _a === void 0 ? void 0 : _a.call(options);
-                    }), onError: (e) => {
-                        var _a;
-                        setLoginError(e);
-                        setLoginLoading(false);
-                        (_a = options === null || options === void 0 ? void 0 : options.onError) === null || _a === void 0 ? void 0 : _a.call(options, e);
-                    } })));
-            }
-            catch (e) {
-                setLoginLoading(false);
-                setLoginError(e);
-            }
-        });
-        const logout = (options) => __awaiter(void 0, void 0, void 0, function* () {
-            yield (authClient === null || authClient === void 0 ? void 0 : authClient.logout(options));
-            yield authenticate();
-        });
-        (0, react_1.useEffect)(() => {
-            if (!authClient && !authenticating) {
-                authenticate();
-            }
-        }, [authClient, authenticating]);
-        return {
-            authClient,
-            authenticated,
-            authenticating,
-            identity,
-            login,
-            logout,
-            authenticate,
-            loginLoading,
-            loginError,
-        };
-    };
-    const { useQueryCall, useMethodField, useMethodFields, useUpdateCall } = (0, hooks_1.getCallHooks)(callMethod, actorStore);
+    const actorManager = (0, store_1.createReActorStore)(Object.assign({ isLocal }, options));
+    const { useAuthClient, useAuthStore } = (0, auth_1.getAuthHooks)(actorManager.agentManager);
+    const { useActorStore, useQueryCall, useMethodField, useMethodFields, useUpdateCall, } = (0, actor_1.getActorHooks)(actorManager);
     return {
-        unsubscribeAgent,
         useMethodFields,
         useMethodField,
-        useAgentStore,
         useActorStore,
         useAuthStore,
         useQueryCall,

package/dist/types.d.ts

@@ -1,14 +1,14 @@
-import { ExtractReActorMethodArgs, ExtractReActorMethodReturnType } from "@ic-reactor/store";
-export * from "@ic-reactor/store";
+import type { ExtractActorMethodArgs, ExtractActorMethodReturnType } from "@ic-reactor/store";
+export type * from "@ic-reactor/store";
 export type ReActorCallArgs<A, M extends keyof A> = {
     functionName: M & string;
-    args?: ExtractReActorMethodArgs<A[M]>;
+    args?: ExtractActorMethodArgs<A[M]>;
     onLoading?: (loading: boolean) => void;
     onError?: (error: Error | unknown) => void;
-    onSuccess?: (data: ExtractReActorMethodReturnType<A[M]> | undefined) => void;
+    onSuccess?: (data: ExtractActorMethodReturnType<A[M]> | undefined) => void;
 };
 export type ReActorHookState<A, M extends keyof A> = {
-    data: ExtractReActorMethodReturnType<A[M]> | undefined;
+    data: ExtractActorMethodReturnType<A[M]> | undefined;
     error: Error | undefined;
     loading: boolean;
 };

package/dist/types.js

@@ -1,17 +1,2 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-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("@ic-reactor/store"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ic-reactor/react",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "A React library for interacting with Dfinity actors",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -35,7 +35,7 @@
     "node": ">=10"
   },
   "dependencies": {
-    "@ic-reactor/store": "^0.3.0",
+    "@ic-reactor/store": "^0.3.2",
     "zustand-utils": "^1.3"
   },
   "peerDependencies": {
@@ -48,5 +48,5 @@
     "react": ">=16.8",
     "zustand": "4.4"
   },
-  "gitHead": "00b0d7f282c144151f27d344c47d92b9b446b14a"
+  "gitHead": "c0f19f81424e7a3df7f422cf4ee127e44a8140f5"
 }