@ic-reactor/react 0.3.2 → 0.3.4

package/dist/actorContext.d.ts

@@ -0,0 +1,14 @@
+import React, { PropsWithChildren } from "react";
+import { type ReActorHooks } from "./index";
+import { IDL } from "@dfinity/candid";
+import { ActorSubclass, CreateReActorOptions } from "@ic-reactor/store";
+export type ActorContextType<A = ActorSubclass<any>> = ReActorHooks<A>;
+export declare const ActorContext: React.Context<ActorContextType<any> | null>;
+type UseReActorType = <A = ActorSubclass<any>>() => ActorContextType<A>;
+export declare const useActor: UseReActorType;
+interface ActorProviderProps extends PropsWithChildren, Omit<CreateReActorOptions, "idlFactory"> {
+    idlFactory?: IDL.InterfaceFactory;
+    loadingComponent?: React.ReactNode;
+}
+export declare const ActorProvider: React.FC<ActorProviderProps>;
+export {};

package/dist/actorContext.js

@@ -0,0 +1,118 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActorProvider = exports.useActor = exports.ActorContext = void 0;
+const react_1 = __importStar(require("react"));
+const index_1 = require("./index");
+const store_1 = require("@ic-reactor/store");
+const agentContext_1 = require("./agentContext");
+exports.ActorContext = (0, react_1.createContext)(null);
+const useActor = () => {
+    const context = (0, react_1.useContext)(exports.ActorContext);
+    if (!context) {
+        throw new Error("useReActor must be used within a ActorProvider");
+    }
+    return context;
+};
+exports.useActor = useActor;
+const ActorProvider = (_a) => {
+    var { children, canisterId, loadingComponent = react_1.default.createElement("div", null, "Loading...") } = _a, config = __rest(_a, ["children", "canisterId", "loadingComponent"]);
+    const agentManager = (0, agentContext_1.useAgentManager)();
+    const [didJs, setDidJS] = (0, react_1.useState)();
+    const fetchDidJs = (0, react_1.useCallback)(() => __awaiter(void 0, void 0, void 0, function* () {
+        if (!canisterId) {
+            throw new Error("canisterId is required");
+        }
+        const agent = agentManager.getAgent();
+        (0, store_1.getDidJsFromMetadata)(agent, canisterId).then((idlFactory) => __awaiter(void 0, void 0, void 0, function* () {
+            if (!idlFactory) {
+                try {
+                    idlFactory = yield (0, store_1.getDidJsFromTmpHack)(agent, canisterId);
+                }
+                catch (err) {
+                    if (/no query method/.test(err)) {
+                        console.warn(err);
+                        idlFactory = undefined;
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+                if (!idlFactory) {
+                    console.warn("No query method found for canister", canisterId);
+                }
+            }
+            setDidJS(idlFactory);
+        }));
+        return didJs;
+    }), [canisterId]);
+    (0, react_1.useEffect)(() => {
+        const { idlFactory } = config;
+        if (idlFactory) {
+            setDidJS({ idlFactory });
+            return;
+        }
+        fetchDidJs();
+    }, [fetchDidJs, config.idlFactory]);
+    const hooks = (0, react_1.useMemo)(() => {
+        if (!didJs) {
+            return null;
+        }
+        try {
+            return (0, index_1.createReActor)({
+                idlFactory: didJs.idlFactory,
+                agentManager,
+                canisterId,
+                withDevtools: config.withDevtools,
+            });
+        }
+        catch (err) {
+            console.error(err);
+            return null;
+        }
+    }, [canisterId, agentManager, didJs]);
+    return (react_1.default.createElement(exports.ActorContext.Provider, { value: hooks }, hooks === null ? loadingComponent : children));
+};
+exports.ActorProvider = ActorProvider;

package/dist/agentContext.d.ts

@@ -0,0 +1,14 @@
+import React, { PropsWithChildren } from "react";
+import { AgentManager, AgentManagerOptions } from "@ic-reactor/store";
+import { getAuthHooks } from "./hooks/auth";
+export type AgentContextType = ReturnType<typeof getAuthHooks> & {
+    agentManager: AgentManager;
+};
+export declare const AgentContext: React.Context<AgentContextType | null>;
+export declare const useAgent: () => AgentContextType;
+export declare const useAgentManager: () => AgentManager;
+interface ReActorProviderProps extends PropsWithChildren, AgentManagerOptions {
+    agentManager?: AgentManager;
+}
+export declare const AgentProvider: React.FC<ReActorProviderProps>;
+export {};

package/dist/agentContext.js

@@ -0,0 +1,67 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __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.AgentProvider = exports.useAgentManager = exports.useAgent = exports.AgentContext = void 0;
+const react_1 = __importStar(require("react"));
+const store_1 = require("@ic-reactor/store");
+const auth_1 = require("./hooks/auth");
+exports.AgentContext = (0, react_1.createContext)(null);
+const useAgent = () => {
+    const context = (0, react_1.useContext)(exports.AgentContext);
+    if (!context) {
+        throw new Error("useAgent must be used within a AgentProvider");
+    }
+    return context;
+};
+exports.useAgent = useAgent;
+const useAgentManager = () => {
+    const context = (0, react_1.useContext)(exports.AgentContext);
+    if (!context) {
+        throw new Error("useAgentManager must be used within a AgentProvider");
+    }
+    return context.agentManager;
+};
+exports.useAgentManager = useAgentManager;
+const AgentProvider = (_a) => {
+    var { children } = _a, config = __rest(_a, ["children"]);
+    const agentManager = (0, react_1.useRef)(config.agentManager || (0, store_1.createAgentManager)(config));
+    const hooks = (0, react_1.useMemo)(() => {
+        const hooks = (0, auth_1.getAuthHooks)(agentManager.current);
+        return Object.assign(Object.assign({}, hooks), { agentManager: agentManager.current });
+    }, []);
+    return react_1.default.createElement(exports.AgentContext.Provider, { value: hooks }, children);
+};
+exports.AgentProvider = AgentProvider;

package/dist/context/actor.d.ts

@@ -0,0 +1,16 @@
+import React, { PropsWithChildren } from "react";
+import { type ActorHooks } from "../index";
+import { IDL } from "@dfinity/candid";
+import { ActorSubclass, ActorManagerOptions } from "@ic-reactor/store";
+import { AgentContextType } from "./agent";
+export type ActorContextType<A = ActorSubclass<any>> = ActorHooks<A>;
+export declare const ActorContext: React.Context<ActorContextType<any> | null>;
+type UseActorType = <A = ActorSubclass<any>>() => ActorContextType<A>;
+export declare const useActor: UseActorType;
+interface ActorProviderProps extends PropsWithChildren, Omit<ActorManagerOptions, "idlFactory" | "agentManager"> {
+    agentContext?: AgentContextType;
+    idlFactory?: IDL.InterfaceFactory;
+    loadingComponent?: React.ReactNode;
+}
+export declare const ActorProvider: React.FC<ActorProviderProps>;
+export {};

package/dist/context/actor.js

@@ -0,0 +1,124 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActorProvider = exports.useActor = exports.ActorContext = void 0;
+const react_1 = __importStar(require("react"));
+const index_1 = require("../index");
+const store_1 = require("@ic-reactor/store");
+const agent_1 = require("./agent");
+exports.ActorContext = (0, react_1.createContext)(null);
+const useActor = () => {
+    const context = (0, react_1.useContext)(exports.ActorContext);
+    if (!context) {
+        throw new Error("useActor must be used within a ActorProvider");
+    }
+    return context;
+};
+exports.useActor = useActor;
+const ActorProvider = (_a) => {
+    var { children, canisterId, agentContext, loadingComponent = react_1.default.createElement("div", null, "Loading...") } = _a, config = __rest(_a, ["children", "canisterId", "agentContext", "loadingComponent"]);
+    const agentManager = (0, agent_1.useAgentManager)(agentContext);
+    const [didJs, setDidJS] = (0, react_1.useState)();
+    const [fetching, setFetching] = (0, react_1.useState)(false);
+    const fetchDidJs = (0, react_1.useCallback)(() => __awaiter(void 0, void 0, void 0, function* () {
+        if (!canisterId) {
+            throw new Error("canisterId is required");
+        }
+        if (fetching) {
+            return;
+        }
+        setFetching(true);
+        const agent = agentManager.getAgent();
+        (0, store_1.getDidJsFromMetadata)(agent, canisterId).then((idlFactory) => __awaiter(void 0, void 0, void 0, function* () {
+            if (!idlFactory) {
+                try {
+                    idlFactory = yield (0, store_1.getDidJsFromTmpHack)(agent, canisterId);
+                }
+                catch (err) {
+                    if (/no query method/.test(err)) {
+                        console.warn(err);
+                        idlFactory = undefined;
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+                if (!idlFactory) {
+                    console.warn("No query method found for canister", canisterId);
+                }
+            }
+            setDidJS(idlFactory);
+            setFetching(false);
+        }));
+    }), [canisterId, agentManager]);
+    (0, react_1.useEffect)(() => {
+        const { idlFactory } = config;
+        if (idlFactory) {
+            setDidJS({ idlFactory });
+            return;
+        }
+        console.log("idlFactory not provided, fetching from canister...");
+        fetchDidJs();
+    }, [fetchDidJs, config.idlFactory]);
+    const hooks = (0, react_1.useMemo)(() => {
+        if (!didJs) {
+            return null;
+        }
+        try {
+            return (0, index_1.createReActor)({
+                idlFactory: didJs.idlFactory,
+                agentManager,
+                canisterId,
+                withDevtools: config.withDevtools,
+            });
+        }
+        catch (err) {
+            console.error(err);
+            return null;
+        }
+    }, [canisterId, agentManager, didJs]);
+    return (react_1.default.createElement(exports.ActorContext.Provider, { value: hooks }, fetching || hooks === null ? loadingComponent : children));
+};
+exports.ActorProvider = ActorProvider;

package/dist/context/agent.d.ts

@@ -0,0 +1,15 @@
+import React, { PropsWithChildren } from "react";
+import { AgentManager, AgentManagerOptions } from "@ic-reactor/store";
+import { getAuthHooks } from "../hooks/auth";
+export type AgentContextValue = ReturnType<typeof getAuthHooks> & {
+    agentManager: AgentManager;
+};
+export type AgentContextType = React.Context<AgentContextValue | null>;
+export declare const AgentContext: React.Context<AgentContextValue | null>;
+export declare const useAgent: (agentContext?: AgentContextType) => AgentContextValue;
+export declare const useAgentManager: (agentContext?: AgentContextType) => AgentManager;
+interface ReActorProviderProps extends PropsWithChildren, AgentManagerOptions {
+    agentManager?: AgentManager;
+}
+export declare const AgentProvider: React.FC<ReActorProviderProps>;
+export {};

package/dist/context/agent.js

@@ -0,0 +1,67 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __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.AgentProvider = exports.useAgentManager = exports.useAgent = exports.AgentContext = void 0;
+const react_1 = __importStar(require("react"));
+const store_1 = require("@ic-reactor/store");
+const auth_1 = require("../hooks/auth");
+exports.AgentContext = (0, react_1.createContext)(null);
+const useAgent = (agentContext) => {
+    const context = (0, react_1.useContext)(agentContext || exports.AgentContext);
+    if (!context) {
+        throw new Error("useAgent must be used within a AgentProvider");
+    }
+    return context;
+};
+exports.useAgent = useAgent;
+const useAgentManager = (agentContext) => {
+    const context = (0, react_1.useContext)(agentContext || exports.AgentContext);
+    if (!context) {
+        throw new Error("useAgentManager must be used within a AgentProvider");
+    }
+    return context.agentManager;
+};
+exports.useAgentManager = useAgentManager;
+const AgentProvider = (_a) => {
+    var { children } = _a, config = __rest(_a, ["children"]);
+    const agentManager = (0, react_1.useRef)(config.agentManager || (0, store_1.createAgentManager)(config));
+    const hooks = (0, react_1.useMemo)(() => {
+        const hooks = (0, auth_1.getAuthHooks)(agentManager.current);
+        return Object.assign(Object.assign({}, hooks), { agentManager: agentManager.current });
+    }, []);
+    return react_1.default.createElement(exports.AgentContext.Provider, { value: hooks }, children);
+};
+exports.AgentProvider = AgentProvider;

package/dist/hooks/actor.d.ts

@@ -1,14 +1,14 @@
 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>) => {
+import type { ActorUseQueryArgs, ActorUseUpdateArgs } from "../types";
+export declare const getActorHooks: <A extends unknown>({ methodFields, canisterId, actorStore, callMethod, }: ActorManager<A>) => {
+    useQueryCall: <M extends keyof A>({ autoRefresh, refreshInterval, disableInitialCall, ...rest }: ActorUseQueryArgs<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>) => {
+    useUpdateCall: <M_1 extends keyof A>(args: ActorUseUpdateArgs<A, M_1>) => {
         data: import("@ic-reactor/store").ExtractActorMethodReturnType<A[M_1]> | undefined;
         error: Error | undefined;
         loading: boolean;
@@ -16,6 +16,7 @@ export declare const getActorHooks: <A extends unknown>({ methodFields, actorSto
         field: ActorMethodField<A> | undefined;
     };
     useActorStore: () => {
+        canisterId: import("@ic-reactor/store").CanisterId;
         initialized: boolean;
         initializing: boolean;
         error: Error | undefined;

package/dist/hooks/actor.js

@@ -23,10 +23,10 @@ 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 getActorHooks = ({ methodFields, canisterId, actorStore, callMethod, }) => {
     const useActorStore = () => {
         const actorState = (0, zustand_1.useStore)(actorStore, (state) => state);
-        return Object.assign({}, actorState);
+        return Object.assign(Object.assign({}, actorState), { canisterId });
     };
     const useMethodFields = () => {
         return methodFields;

package/dist/hooks/auth.d.ts

@@ -1,6 +1,7 @@
 import type { AuthClientLoginOptions } from "@dfinity/auth-client";
 import type { AgentManager } from "@ic-reactor/store";
-export declare const getAuthHooks: ({ authStore, authenticate }: AgentManager) => {
+export declare const getAuthHooks: (agentManager: AgentManager) => {
+    useAgentManager: () => AgentManager;
     useAuthStore: () => import("@ic-reactor/store").ActorAuthState;
     useAuthClient: () => {
         authClient: import("@dfinity/auth-client").AuthClient | null;

package/dist/hooks/auth.js

@@ -12,7 +12,11 @@ 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 getAuthHooks = (agentManager) => {
+    const { authenticate, authStore } = agentManager;
+    const useAgentManager = () => {
+        return agentManager;
+    };
     const useAuthStore = () => {
         const authState = (0, zustand_1.useStore)(authStore, (state) => state);
         return authState;
@@ -64,6 +68,7 @@ const getAuthHooks = ({ authStore, authenticate }) => {
         };
     };
     return {
+        useAgentManager,
         useAuthStore,
         useAuthClient,
     };

package/dist/index.d.ts

@@ -2,7 +2,7 @@ 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 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>;
+export * from "./context/agent";
+export * from "./context/actor";
+export type ActorHooks<A extends ActorSubclass<any>> = ReturnType<typeof getActorHooks<A>> & ReturnType<typeof getAuthHooks>;
+export declare const createReActor: <A extends unknown>({ isLocal, ...options }: CreateReActorOptions) => ActorHooks<A>;

package/dist/index.js

@@ -13,6 +13,17 @@ 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 __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 = exports.createActorManager = exports.createAgentManager = exports.createReActorStore = void 0;
 const store_1 = require("@ic-reactor/store");
@@ -22,15 +33,20 @@ 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");
+__exportStar(require("./context/agent"), exports);
+__exportStar(require("./context/actor"), exports);
+const createReActor = (_a) => {
+    var { isLocal } = _a, options = __rest(_a, ["isLocal"]);
+    isLocal =
+        isLocal ||
+            (typeof process !== "undefined" &&
+                (process.env.NODE_ENV === "development" ||
+                    process.env.DFX_NETWORK === "local"));
     const actorManager = (0, store_1.createReActorStore)(Object.assign({ isLocal }, options));
-    const { useAuthClient, useAuthStore } = (0, auth_1.getAuthHooks)(actorManager.agentManager);
+    const { useAuthClient, useAgentManager, useAuthStore } = (0, auth_1.getAuthHooks)(actorManager.agentManager);
     const { useActorStore, useQueryCall, useMethodField, useMethodFields, useUpdateCall, } = (0, actor_1.getActorHooks)(actorManager);
     return {
+        useAgentManager,
         useMethodFields,
         useMethodField,
         useActorStore,

package/dist/types.d.ts

@@ -1,21 +1,21 @@
 import type { ExtractActorMethodArgs, ExtractActorMethodReturnType } from "@ic-reactor/store";
 export type * from "@ic-reactor/store";
-export type ReActorCallArgs<A, M extends keyof A> = {
+export type ActorCallArgs<A, M extends keyof A> = {
     functionName: M & string;
     args?: ExtractActorMethodArgs<A[M]>;
     onLoading?: (loading: boolean) => void;
     onError?: (error: Error | unknown) => void;
     onSuccess?: (data: ExtractActorMethodReturnType<A[M]> | undefined) => void;
 };
-export type ReActorHookState<A, M extends keyof A> = {
+export type ActorHookState<A, M extends keyof A> = {
     data: ExtractActorMethodReturnType<A[M]> | undefined;
     error: Error | undefined;
     loading: boolean;
 };
-export interface ReActorUseQueryArgs<A, M extends keyof A> extends ReActorCallArgs<A, M> {
+export interface ActorUseQueryArgs<A, M extends keyof A> extends ActorCallArgs<A, M> {
     disableInitialCall?: boolean;
     autoRefresh?: boolean;
     refreshInterval?: number;
 }
-export interface ReActorUseUpdateArgs<A, M extends keyof A> extends ReActorCallArgs<A, M> {
+export interface ActorUseUpdateArgs<A, M extends keyof A> extends ActorCallArgs<A, M> {
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ic-reactor/react",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "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.2",
+    "@ic-reactor/store": "^0.3.3",
     "zustand-utils": "^1.3"
   },
   "peerDependencies": {
@@ -48,5 +48,5 @@
     "react": ">=16.8",
     "zustand": "4.4"
   },
-  "gitHead": "c0f19f81424e7a3df7f422cf4ee127e44a8140f5"
+  "gitHead": "9768339c7383901e042511420867cca3f762e664"
 }