@ic-reactor/react 0.5.4 → 1.0.0

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

@@ -0,0 +1,16 @@
+import React from "react";
+import { ActorUseMethodCallArg, ActorUseQueryArgs, ActorUseUpdateArgs } from "../../types";
+import { CreateActorOptions, ActorContextType, ActorProviderProps } from "./types";
+export * from "./types";
+export declare const createReActorContext: <Actor extends unknown>({ 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").VisitService<Actor>[keyof Actor & string];
+    initialize: () => Promise<void>;
+};
+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;

package/dist/context/actor/index.js

@@ -0,0 +1,92 @@
+"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 __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;
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useVisitMethod = exports.useMethodCall = exports.useUpdateCall = exports.useQueryCall = exports.useActorState = exports.useActorContext = exports.ActorProvider = exports.ActorContext = exports.createReActorContext = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const react_1 = __importStar(require("react"));
+const actor_1 = require("../../hooks/actor");
+const useActor_1 = require("../../hooks/useActor");
+__exportStar(require("./types"), exports);
+const createReActorContext = (_a = {}) => {
+    var { canisterId: defaultCanisterId } = _a, defaultConfig = __rest(_a, ["canisterId"]);
+    const ActorContext = (0, react_1.createContext)(null);
+    const ActorProvider = (_a) => {
+        var { children, canisterId = defaultCanisterId, loadingComponent = react_1.default.createElement("div", null, "Fetching canister...") } = _a, restConfig = __rest(_a, ["children", "canisterId", "loadingComponent"]);
+        if (!canisterId) {
+            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 hooks = (0, react_1.useMemo)(() => {
+            if (actorManager) {
+                return (0, actor_1.getActorHooks)(actorManager);
+            }
+            return null;
+        }, [actorManager === null || actorManager === void 0 ? void 0 : actorManager.canisterId]);
+        return (react_1.default.createElement(ActorContext.Provider, { value: hooks }, fetching || hooks === null ? fetchError !== null && fetchError !== void 0 ? fetchError : loadingComponent : children));
+    };
+    ActorProvider.displayName = "ActorProvider";
+    const useActorContext = () => {
+        const context = (0, react_1.useContext)(ActorContext);
+        if (!context) {
+            throw new Error("useActor must be used within a ActorProvider");
+        }
+        return context;
+    };
+    const initialize = () => useActorContext().initialize();
+    const useActorState = () => useActorContext().useActorState();
+    const useQueryCall = (args) => useActorContext().useQueryCall(args);
+    const useUpdateCall = (args) => useActorContext().useUpdateCall(args);
+    const useMethodCall = (args) => useActorContext().useMethodCall(args);
+    const useVisitMethod = (functionName) => useActorContext().useVisitMethod(functionName);
+    return {
+        ActorContext,
+        ActorProvider,
+        useActorContext,
+        useActorState,
+        useQueryCall,
+        useUpdateCall,
+        useMethodCall,
+        useVisitMethod,
+        initialize,
+    };
+};
+exports.createReActorContext = createReActorContext;
+_a = (0, exports.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;

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

@@ -0,0 +1,29 @@
+/// <reference types="react" />
+import { IDL } from "@dfinity/candid";
+import { ActorManagerOptions, BaseActor } from "@ic-reactor/core";
+import { AgentContextType } from "../agent";
+import { ActorHooks } from "../../types";
+export type ActorContextType<Actor = BaseActor, F extends boolean = true> = ActorHooks<Actor, F> & {
+    ActorContext: React.Context<ActorContextType<Actor, F> | 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 interface CreateActorOptions extends Omit<ActorManagerOptions, "idlFactory" | "agentManager" | "canisterId"> {
+    didjsId?: string;
+    canisterId?: string;
+    agentContext?: AgentContextType;
+    idlFactory?: IDL.InterfaceFactory;
+    loadingComponent?: React.ReactNode;
+}
+export interface ActorProviderProps extends CreateActorOptions {
+    children?: React.ReactNode | undefined;
+    loadingComponent?: React.ReactNode;
+}

package/dist/context/actor/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/context/agent/hooks.d.ts

@@ -0,0 +1,4 @@
+import { AgentManager, HttpAgent } from "@ic-reactor/core";
+import { AgentContextType } from "./types";
+export declare const useAgentManager: (agentContext?: AgentContextType) => AgentManager;
+export declare const useAgentContext: (agentContext?: AgentContextType) => HttpAgent | undefined;

package/dist/context/agent/hooks.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAgentContext = exports.useAgentManager = void 0;
+const react_1 = require("react");
+const _1 = require(".");
+const useAgentManager = (agentContext) => {
+    const context = (0, _1.useAgentManagerContext)(agentContext);
+    return context.agentManager;
+};
+exports.useAgentManager = useAgentManager;
+const useAgentContext = (agentContext) => {
+    const agentManager = (0, exports.useAgentManager)(agentContext);
+    const [agent, setAgent] = (0, react_1.useState)(agentManager.getAgent());
+    (0, react_1.useEffect)(() => agentManager.subscribeAgent(setAgent), []);
+    return agent;
+};
+exports.useAgentContext = useAgentContext;

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

@@ -0,0 +1,10 @@
+import React from "react";
+import { AgentManagerOptions } from "@ic-reactor/core";
+import { AgentContextValue, AgentContextType, AgentProviderProps } from "./types";
+export * from "./types";
+export * from "./hooks";
+export declare const AgentManagerContext: React.Context<AgentContextValue | null>;
+export declare const useAgentManagerContext: (agentContext?: AgentContextType) => AgentContextValue;
+export declare const createAgentContext: (config: AgentManagerOptions) => AgentContextValue;
+declare const AgentProvider: React.FC<AgentProviderProps>;
+export { AgentProvider };

package/dist/context/{agent.js → agent/index.js}

@@ -22,6 +22,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+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)
@@ -34,40 +37,33 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentProvider = exports.createAgentContext = exports.useAgentManager = exports.useAgent = exports.AgentContext = void 0;
+exports.AgentProvider = exports.createAgentContext = exports.useAgentManagerContext = exports.AgentManagerContext = 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);
+const core_1 = require("@ic-reactor/core");
+const agent_1 = require("../../hooks/agent");
+const auth_1 = require("../../hooks/auth");
+__exportStar(require("./types"), exports);
+__exportStar(require("./hooks"), exports);
+exports.AgentManagerContext = (0, react_1.createContext)(null);
+const useAgentManagerContext = (agentContext) => {
+    const context = (0, react_1.useContext)(agentContext || exports.AgentManagerContext);
     if (!context) {
-        throw new Error("useAgent must be used within a AgentProvider");
+        throw new Error("Agent context 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;
+exports.useAgentManagerContext = useAgentManagerContext;
 const createAgentContext = (config) => {
-    const agentManager = (0, store_1.createAgentManager)(config);
-    const hooks = (0, auth_1.getAuthHooks)(agentManager);
-    return Object.assign(Object.assign({}, hooks), { agentManager });
+    const agentManager = (0, core_1.createAgentManager)(config);
+    const agenthooks = (0, agent_1.getAgentHooks)(agentManager);
+    const authHooks = (0, auth_1.getAuthHooks)(agentManager);
+    return Object.assign(Object.assign(Object.assign({}, agenthooks), authHooks), { agentManager });
 };
 exports.createAgentContext = createAgentContext;
 const AgentProvider = (_a) => {
     var { children } = _a, config = __rest(_a, ["children"]);
-    const value = (0, react_1.useMemo)(() => {
-        const agentManager = config.agentManager || (0, store_1.createAgentManager)(config);
-        const hooks = (0, auth_1.getAuthHooks)(agentManager);
-        return Object.assign(Object.assign({}, hooks), { agentManager });
-    }, [config]);
-    return react_1.default.createElement(exports.AgentContext.Provider, { value: value }, children);
+    const value = (0, react_1.useMemo)(() => (0, exports.createAgentContext)(config), [config]);
+    return (react_1.default.createElement(exports.AgentManagerContext.Provider, { value: value }, children));
 };
 exports.AgentProvider = AgentProvider;
+AgentProvider.displayName = "AgentProvider";

package/dist/context/agent/types.d.ts

@@ -0,0 +1,11 @@
+import React, { PropsWithChildren } from "react";
+import { AgentManager, AgentManagerOptions } from "@ic-reactor/core";
+import { getAuthHooks } from "../../hooks/auth";
+import { getAgentHooks } from "../../hooks/agent";
+export type AgentContextValue = ReturnType<typeof getAuthHooks> & ReturnType<typeof getAgentHooks> & {
+    agentManager: AgentManager;
+};
+export type AgentContextType = React.Context<AgentContextValue | null>;
+export interface AgentProviderProps extends PropsWithChildren, AgentManagerOptions {
+    agentManager?: AgentManager;
+}

package/dist/context/agent/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/context/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./actor";
+export * from "./agent";

package/dist/context/index.js

@@ -0,0 +1,18 @@
+"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("./actor"), exports);
+__exportStar(require("./agent"), exports);

package/dist/hooks/actor.d.ts

@@ -1,3 +1,3 @@
-import type { ActorManager } from "@ic-reactor/store";
-import type { ActorHooks } from "../types";
-export declare const getActorHooks: <A extends unknown>({ initialize, serviceFields, withServiceFields, canisterId, actorStore, callMethod, }: ActorManager<A>) => ActorHooks<A, boolean>;
+import { ActorHooks } from "../types";
+import { ActorManager } from "@ic-reactor/core";
+export declare const getActorHooks: <A>({ initialize, canisterId, actorStore, callMethod, visitFunction, }: ActorManager<A>) => ActorHooks<A, true>;

package/dist/hooks/actor.js

@@ -21,43 +21,31 @@ 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 getActorHooks = ({ initialize, serviceFields, withServiceFields, canisterId, actorStore, callMethod, }) => {
-    const useActorStore = () => {
+const DEFAULT_STATE = {
+    data: undefined,
+    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 useServiceFields = () => {
-        if (!withServiceFields || !serviceFields) {
-            throw new Error("Service fields not initialized. Pass `withServiceFields` to initialize service fields.");
-        }
-        return serviceFields;
-    };
-    const useMethods = () => {
-        const serviceFields = useServiceFields();
-        return (0, react_1.useMemo)(() => {
-            return Object.values(serviceFields.methods);
-        }, [serviceFields]);
+    const useVisitFunction = () => {
+        return visitFunction;
     };
-    const useMethodFields = () => {
-        const serviceFields = useServiceFields();
+    const useVisitMethod = (functionName) => {
+        const serviceFields = useVisitFunction();
         return (0, react_1.useMemo)(() => {
-            return Object.values(serviceFields.methodFields);
-        }, [serviceFields]);
-    };
-    const useMethodField = (functionName) => {
-        const serviceMethod = useServiceFields();
-        return (0, react_1.useMemo)(() => {
-            return serviceMethod.methodFields[functionName];
-        }, [functionName, serviceMethod]);
+            return serviceFields[functionName];
+        }, [functionName, serviceFields]);
     };
     const useReActorCall = ({ onError, onSuccess, onLoading, args = [], functionName, throwOnError = false, }) => {
-        const [state, setState] = (0, react_1.useState)({
-            data: undefined,
-            error: undefined,
-            loading: false,
-        });
+        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);
@@ -83,15 +71,12 @@ const getActorHooks = ({ initialize, serviceFields, withServiceFields, canisterI
                     throw error;
             }
         }), [args, functionName, onError, onSuccess, onLoading]);
-        const field = (0, react_1.useMemo)(() => {
-            return serviceFields === null || serviceFields === void 0 ? void 0 : serviceFields.methodFields[functionName];
-        }, [functionName]);
-        return Object.assign({ call, field }, state);
+        return Object.assign({ call, reset }, state);
     };
     const useQueryCall = (_a) => {
-        var { refetchOnMount = false, refetchInterval = false } = _a, rest = __rest(_a, ["refetchOnMount", "refetchInterval"]);
+        var { refetchOnMount = true, refetchInterval = false } = _a, rest = __rest(_a, ["refetchOnMount", "refetchInterval"]);
         const _b = useReActorCall(rest), { call } = _b, state = __rest(_b, ["call"]);
-        let intervalId = (0, react_1.useRef)(undefined);
+        const intervalId = (0, react_1.useRef)(undefined);
         (0, react_1.useEffect)(() => {
             // Auto-refresh logic
             if (refetchInterval) {
@@ -112,27 +97,17 @@ const getActorHooks = ({ initialize, serviceFields, withServiceFields, canisterI
     const useUpdateCall = (args) => {
         return useReActorCall(args);
     };
-    const useMethodCall = (_a) => {
-        var { type } = _a, rest = __rest(_a, ["type"]);
-        switch (type) {
-            case "query":
-                return useQueryCall(rest);
-            case "update":
-                return useUpdateCall(rest);
-            default:
-                throw new Error(`Invalid type: ${type}`);
-        }
+    const useMethodCall = (args) => {
+        const visit = visitFunction[args.functionName];
+        return Object.assign({ visit }, useReActorCall(args));
     };
     return {
         initialize,
         useQueryCall,
         useUpdateCall,
+        useVisitMethod,
+        useActorState,
         useMethodCall,
-        useActorStore,
-        useMethods,
-        useMethodField,
-        useMethodFields,
-        useServiceFields,
     };
 };
 exports.getActorHooks = getActorHooks;

package/dist/hooks/agent.d.ts

@@ -0,0 +1,6 @@
+import type { AgentManager, HttpAgent } from "@ic-reactor/core";
+export type AgentHooks = ReturnType<typeof getAgentHooks>;
+export declare const getAgentHooks: (agentManager: AgentManager) => {
+    useAgent: () => HttpAgent | undefined;
+    useAgentState: () => import("@ic-reactor/core").AgentState;
+};

package/dist/hooks/agent.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 useAgent = () => {
+        const [agent, setAgent] = (0, react_1.useState)(getAgent());
+        (0, react_1.useEffect)(() => agentManager.subscribeAgent(setAgent), []);
+        return agent;
+    };
+    return {
+        useAgent,
+        useAgentState,
+    };
+};
+exports.getAgentHooks = getAgentHooks;

package/dist/hooks/auth.d.ts

@@ -1,11 +1,10 @@
 import type { AuthClientLoginOptions } from "@dfinity/auth-client";
-import type { AgentManager, Identity, Principal } from "@ic-reactor/store";
+import type { AgentManager, Identity, Principal } from "@ic-reactor/core";
 import { AuthArgs } from "../types";
 export type AuthHooks = ReturnType<typeof getAuthHooks>;
 export declare const getAuthHooks: (agentManager: AgentManager) => {
     useUserPrincipal: () => Principal | undefined;
-    useAgentManager: () => AgentManager;
-    useAuthStore: () => import("@ic-reactor/store").AgentAuthState;
+    useAuthStore: () => import("@ic-reactor/core").AuthState;
     useAuthClient: ({ onAuthentication, onAuthenticationSuccess, onAuthenticationFailure, onLogin, onLoginSuccess, onLoginError, onLoggedOut, }?: AuthArgs) => {
         authClient: import("@dfinity/auth-client").AuthClient | null;
         authenticated: boolean;

package/dist/hooks/auth.js

@@ -14,9 +14,6 @@ const react_1 = require("react");
 const zustand_1 = require("zustand");
 const getAuthHooks = (agentManager) => {
     const { authenticate: authenticator, authStore, isLocalEnv } = agentManager;
-    const useAgentManager = () => {
-        return agentManager;
-    };
     const useAuthStore = () => {
         const authState = (0, zustand_1.useStore)(authStore, (state) => state);
         return authState;
@@ -30,17 +27,17 @@ const getAuthHooks = (agentManager) => {
         const [loginError, setLoginError] = (0, react_1.useState)(null);
         const { authClient, authenticated, authenticating, identity } = useAuthStore();
         const authenticate = (0, react_1.useCallback)(() => __awaiter(void 0, void 0, void 0, function* () {
-            const authenticatePromise = new Promise((resolve, reject) => __awaiter(void 0, void 0, void 0, function* () {
-                try {
-                    const identity = yield authenticator();
+            const authenticatePromise = new Promise((resolve, reject) => {
+                authenticator()
+                    .then((identity) => {
                     onAuthenticationSuccess === null || onAuthenticationSuccess === void 0 ? void 0 : onAuthenticationSuccess(identity);
                     resolve(identity);
-                }
-                catch (e) {
+                })
+                    .catch((e) => {
                     onAuthenticationFailure === null || onAuthenticationFailure === void 0 ? void 0 : onAuthenticationFailure(e);
                     reject(e);
-                }
-            }));
+                });
+            });
             onAuthentication === null || onAuthentication === void 0 ? void 0 : onAuthentication(() => authenticatePromise);
             return authenticatePromise;
         }), [
@@ -52,21 +49,28 @@ const getAuthHooks = (agentManager) => {
         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) => __awaiter(void 0, void 0, void 0, function* () {
+            const loginPromise = new Promise((resolve, reject) => {
                 try {
                     if (!authClient) {
                         throw new Error("Auth client not initialized");
                     }
-                    yield authClient.login(Object.assign(Object.assign({ identityProvider: isLocalEnv
+                    authClient.login(Object.assign(Object.assign({ identityProvider: isLocalEnv
                             ? "https://identity.ic0.app/#authorize"
-                            : "http://rdmx6-jaaaa-aaaaa-aaadq-cai.localhost:4943/#authorize" }, options), { onSuccess: () => __awaiter(void 0, void 0, void 0, function* () {
-                            var _a;
-                            const identity = yield authenticate();
-                            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);
-                        }), onError: (e) => {
+                            : "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);
@@ -83,7 +87,7 @@ const getAuthHooks = (agentManager) => {
                 finally {
                     setLoginLoading(false);
                 }
-            }));
+            });
             onLogin === null || onLogin === void 0 ? void 0 : onLogin(() => loginPromise);
         }), [
             authClient,
@@ -120,7 +124,6 @@ const getAuthHooks = (agentManager) => {
     };
     return {
         useUserPrincipal,
-        useAgentManager,
         useAuthStore,
         useAuthClient,
     };

package/dist/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./useActor";
+export * from "./useCandid";
+export * from "./agent";
+export * from "./actor";
+export * from "./auth";

package/dist/hooks/index.js

@@ -0,0 +1,21 @@
+"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("./useActor"), exports);
+__exportStar(require("./useCandid"), exports);
+__exportStar(require("./agent"), exports);
+__exportStar(require("./actor"), exports);
+__exportStar(require("./auth"), exports);

package/dist/hooks/useActor.d.ts

@@ -0,0 +1,15 @@
+import { ActorManagerOptions, BaseActor, IDL } from "@ic-reactor/core";
+import { AgentContextType } from "../context/agent";
+interface DynamicActorArgs extends Omit<ActorManagerOptions, "idlFactory" | "agentManager" | "canisterId"> {
+    canisterId: string;
+    idlFactory?: IDL.InterfaceFactory;
+    agentContext?: AgentContextType;
+    didjsCanisterId?: string;
+}
+export declare const useActor: <A = BaseActor>({ canisterId, agentContext, idlFactory: maybeIdlFactory, didjsCanisterId, ...config }: DynamicActorArgs) => {
+    fetchCandid: () => Promise<import("@ic-reactor/core").CandidDefenition | undefined>;
+    fetching: boolean;
+    fetchError: string | null;
+    actorManager: import("@ic-reactor/core").ActorManager<A> | null;
+};
+export {};

package/dist/hooks/useActor.js

@@ -0,0 +1,43 @@
+"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.useActor = void 0;
+const core_1 = require("@ic-reactor/core");
+const react_1 = require("react");
+const agent_1 = require("../context/agent");
+const useCandid_1 = require("./useCandid");
+const useActor = (_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)({
+        canisterId,
+        didjsCanisterId,
+        idlFactory: maybeIdlFactory,
+    }), { candid: { idlFactory } } = _b, rest = __rest(_b, ["candid"]);
+    const actorManager = (0, react_1.useMemo)(() => {
+        if (!idlFactory) {
+            return null;
+        }
+        else {
+            const manager = (0, core_1.createReActorStore)({
+                agentManager,
+                idlFactory,
+                canisterId,
+                withDevtools: config.withDevtools,
+            });
+            return manager;
+        }
+    }, [idlFactory]);
+    return Object.assign({ actorManager }, rest);
+};
+exports.useActor = useActor;

package/dist/hooks/useCandid.d.ts

@@ -0,0 +1,18 @@
+import type { IDL } from "@dfinity/candid";
+interface UseIDLFactoryArgs {
+    canisterId: string;
+    didjsCanisterId?: string;
+    idlFactory?: IDL.InterfaceFactory;
+}
+export declare const useCandid: ({ canisterId, didjsCanisterId, idlFactory, }: UseIDLFactoryArgs) => {
+    fetchCandid: () => Promise<import("@ic-reactor/core").CandidDefenition | undefined>;
+    candid: {
+        idlFactory?: IDL.InterfaceFactory | undefined;
+        init: ({ idl }: {
+            idl: typeof IDL;
+        }) => never[];
+    };
+    fetching: boolean;
+    fetchError: string | null;
+};
+export {};

package/dist/hooks/useCandid.js

@@ -0,0 +1,54 @@
+"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.useCandid = void 0;
+const react_1 = require("react");
+const core_1 = require("@ic-reactor/core");
+const agent_1 = require("../context/agent");
+const DEFAULT_STATE = {
+    candid: { idlFactory: undefined, init: () => [] },
+    fetching: false,
+    fetchError: null,
+};
+const useCandid = ({ canisterId, didjsCanisterId, idlFactory, }) => {
+    const [{ candid, fetchError, fetching }, setCandid] = (0, react_1.useState)(Object.assign(Object.assign({}, DEFAULT_STATE), { candid: {
+            idlFactory,
+            init: () => [],
+        } }));
+    const agent = (0, agent_1.useAgentContext)();
+    const fetchCandid = (0, react_1.useCallback)(() => __awaiter(void 0, void 0, void 0, function* () {
+        if (!canisterId || !agent)
+            return;
+        setCandid((prevState) => (Object.assign(Object.assign({}, prevState), { candid: DEFAULT_STATE.candid, fetching: true, fetchError: null })));
+        try {
+            const candidManager = (0, core_1.createCandidAdapter)({ agent, didjsCanisterId });
+            const fetchedCandid = yield candidManager.getCandidDefinition(canisterId);
+            setCandid({
+                candid: fetchedCandid,
+                fetching: false,
+                fetchError: null,
+            });
+            return fetchedCandid;
+        }
+        catch (err) {
+            // eslint-disable-next-line no-console
+            console.error(err);
+            setCandid((prevState) => (Object.assign(Object.assign({}, prevState), { fetchError: `Error fetching canister ${canisterId}`, fetching: false })));
+        }
+    }), [canisterId, didjsCanisterId, agent]);
+    (0, react_1.useEffect)(() => {
+        if (!fetching && !idlFactory) {
+            fetchCandid();
+        }
+    }, [fetchCandid]);
+    return { fetchCandid, candid, fetching, fetchError };
+};
+exports.useCandid = useCandid;

package/dist/index.d.ts

@@ -1,5 +1,31 @@
-import { CreateReActor } from "./types";
-export * from "@ic-reactor/store";
+import { CreateReActorOptions, BaseActor } from "@ic-reactor/core";
+export { createReActor as createReActorCore } from "@ic-reactor/core";
+export * from "@ic-reactor/core";
 export * from "./context/agent";
 export * from "./context/actor";
-export declare const createReActor: CreateReActor;
+export * from "./hooks";
+export declare const createReActor: <A = BaseActor>({ isLocalEnv, withVisitor, withProcessEnv, ...options }: CreateReActorOptions) => {
+    useUserPrincipal: () => import("@dfinity/principal").Principal | undefined;
+    useAuthStore: () => import("@ic-reactor/core").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").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").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").FunctionName<A>>(args: import("./types").ActorUseMethodCallArg<A, M>) => import("./types").ActorUseMethodCallReturn<A, M, true>;
+    useVisitMethod: <M_1 extends import("@ic-reactor/core").FunctionName<A>>(functionName: M_1) => import("@ic-reactor/core").VisitService<A>[M_1];
+    getAgent: () => import("@ic-reactor/core").HttpAgent;
+    getVisitFunction: () => import("@ic-reactor/core").VisitService<A>;
+};

package/dist/index.js

@@ -25,32 +25,39 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createReActor = void 0;
-const store_1 = require("@ic-reactor/store");
+exports.createReActor = exports.createReActorCore = void 0;
+const core_1 = require("@ic-reactor/core");
 const actor_1 = require("./hooks/actor");
 const auth_1 = require("./hooks/auth");
-__exportStar(require("@ic-reactor/store"), exports);
+var core_2 = require("@ic-reactor/core");
+Object.defineProperty(exports, "createReActorCore", { enumerable: true, get: function () { return core_2.createReActor; } });
+__exportStar(require("@ic-reactor/core"), exports);
 __exportStar(require("./context/agent"), exports);
 __exportStar(require("./context/actor"), exports);
+__exportStar(require("./hooks"), exports);
 const createReActor = (_a) => {
-    var { isLocalEnv, withServiceFields } = _a, options = __rest(_a, ["isLocalEnv", "withServiceFields"]);
+    var { isLocalEnv, withVisitor, withProcessEnv } = _a, options = __rest(_a, ["isLocalEnv", "withVisitor", "withProcessEnv"]);
     isLocalEnv =
         isLocalEnv ||
-            (typeof process !== "undefined" &&
-                (process.env.DFX_NETWORK === "local" ||
-                    process.env.NODE_ENV === "development"));
-    const actorManager = (0, store_1.createReActorStore)(Object.assign({ isLocalEnv,
-        withServiceFields }, options));
-    const getServiceFields = () => {
-        if (!withServiceFields || !actorManager.serviceFields) {
-            throw new Error("Service fields not initialized. Pass `withServiceFields` to initialize service fields.");
+            (withProcessEnv
+                ? typeof process !== "undefined" &&
+                    (process.env.DFX_NETWORK === "local" ||
+                        process.env.NODE_ENV === "development")
+                : 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.serviceFields;
+        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,
-        getServiceFields }, (0, actor_1.getActorHooks)(actorManager)), (0, auth_1.getAuthHooks)(actorManager.agentManager));
+        getVisitFunction }, actorHooks), authHooks);
 };
 exports.createReActor = createReActor;

package/dist/types.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="react" />
-import type { ActorState, ActorSubclass, CanisterId, CreateReActorOptions, ExtractActorMethodArgs, ExtractActorMethodReturnType, ExtractedFunction, ExtractedService, HttpAgent, Identity, Principal, ServiceMethodType, ServiceMethodTypeAndName } from "@ic-reactor/store";
+import type { ActorState, CanisterId, CreateReActorOptions, ActorMethodArgs, ActorMethodReturnType, HttpAgent, Identity, Principal, FunctionName, VisitService } from "@ic-reactor/core";
 import type { AuthHooks } from "./hooks/auth";
+import { AgentHooks } from "./hooks/agent";
 export type AuthArgs = {
     onAuthentication?: (promise: () => Promise<Identity>) => void;
     onAuthenticationSuccess?: (identity: Identity) => void;
@@ -10,70 +11,63 @@ export type AuthArgs = {
     onLogin?: (promise: () => Promise<Principal>) => void;
     onLoggedOut?: () => void;
 };
-export type ActorCallArgs<A, M extends keyof A> = {
-    functionName: M & string;
-    args?: ExtractActorMethodArgs<A[M]>;
+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: ExtractActorMethodReturnType<A[M]> | undefined) => void;
+    onSuccess?: (data: ActorMethodReturnType<A[M]> | undefined) => void;
     throwOnError?: boolean;
 };
-export type ActorHookState<A, M extends keyof A> = {
-    data: ExtractActorMethodReturnType<A[M]> | undefined;
+export type ActorHookState<A, M extends FunctionName<A>> = {
+    data: ActorMethodReturnType<A[M]> | undefined;
     error: Error | undefined;
     loading: boolean;
 };
-export interface ActorUseQueryArgs<A, M extends keyof A> extends ActorCallArgs<A, M> {
+export interface ActorUseQueryArgs<A, M extends FunctionName<A>> extends ActorCallArgs<A, M> {
     refetchOnMount?: boolean;
     refetchInterval?: number | false;
 }
-export interface ActorUseQueryReturn<A, M extends keyof A, W extends boolean = false> {
-    call: (eventOrReplaceArgs?: React.MouseEvent | ExtractActorMethodArgs<A[M]>) => Promise<unknown>;
-    field: W extends true ? ExtractedFunction<A> : undefined;
-    data: unknown;
-    error: Error | undefined;
-    loading: boolean;
+export interface ActorUseUpdateArgs<A, M extends FunctionName<A>> extends ActorCallArgs<A, M> {
 }
-export interface ActorUseUpdateArgs<A, M extends keyof A> extends ActorCallArgs<A, M> {
-}
-export interface ActorUseUpdateReturn<A, M extends keyof A, W extends boolean = false> {
-    call: (eventOrReplaceArgs?: React.MouseEvent | ExtractActorMethodArgs<A[M]>) => Promise<unknown>;
-    field: W extends true ? ExtractedFunction<A> : undefined;
-    data: unknown;
+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 ActorUseMethodArg<A, T extends ServiceMethodType> = T extends "query" ? ActorUseQueryArgs<A, keyof A> : ActorUseUpdateArgs<A, keyof A>;
-export type ActorHooksWithField<A> = ActorDefaultHooks<A, true> & ActorFieldHooks<A>;
-export type ActorHooksWithoutField<A> = ActorDefaultHooks<A, false>;
-export type ActorHooks<A, W extends boolean | undefined = undefined> = W extends true ? ActorHooksWithField<A> : W extends false ? ActorHooksWithoutField<A> : ActorHooksWithField<A> | ActorHooksWithoutField<A>;
+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> {
-    useServiceFields: () => ExtractedService<A>;
-    useMethodFields: () => ExtractedFunction<A>[];
-    useMethodField: (functionName: keyof A & string) => ExtractedFunction<A>;
-    useMethods: () => ServiceMethodTypeAndName<A>[];
+    useVisitMethod: <M extends FunctionName<A>>(functionName: M) => VisitService<A>[M];
 }
 export type UseActorStoreReturn<A> = ActorState<A> & {
     canisterId: CanisterId;
 };
-export interface ActorDefaultHooks<A, W extends boolean = false> {
+export interface ActorDefaultHooks<A, F extends boolean> {
     initialize: () => Promise<void>;
-    useActorStore: () => UseActorStoreReturn<A>;
-    useQueryCall: <M extends keyof A>(args: ActorUseQueryArgs<A, M>) => ActorUseQueryReturn<A, M, W>;
-    useUpdateCall: <M extends keyof A>(args: ActorUseUpdateArgs<A, M>) => ActorUseUpdateReturn<A, M, W>;
-    useMethodCall: <M extends keyof A, T extends ServiceMethodType>(args: ActorUseMethodArg<A, T> & {
-        type: T;
-    }) => T extends "query" ? ActorUseQueryReturn<A, M, W> : ActorUseUpdateReturn<A, M, W>;
+    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> = {
     getAgent: () => HttpAgent;
-    getServiceFields: () => ExtractedService<A>;
+    getVisitFunction: () => VisitService<A>;
 };
 export type CreateReActor = {
-    <A extends ActorSubclass<any>>(options: CreateReActorOptions & {
-        withServiceFields: true;
-    }): GetFunctions<A> & ActorHooksWithField<A> & AuthHooks;
-    <A extends ActorSubclass<any>>(options: CreateReActorOptions & {
-        withServiceFields?: false | undefined;
-    }): GetFunctions<A> & ActorHooksWithoutField<A> & AuthHooks;
+    <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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ic-reactor/react",
-  "version": "0.5.4",
-  "description": "A React library for interacting with Dfinity actors",
+  "version": "1.0.0",
+  "description": "A React library for interacting with Internet Computer canisters",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -35,18 +35,18 @@
     "node": ">=10"
   },
   "dependencies": {
-    "@ic-reactor/store": "^0.5.2",
+    "@ic-reactor/core": "^1.0.0",
     "zustand-utils": "^1.3"
   },
   "peerDependencies": {
-    "@dfinity/agent": "^0.20",
-    "@dfinity/auth-client": "^0.20",
-    "@dfinity/candid": "0.20",
-    "@dfinity/identity": "^0.20",
-    "@dfinity/principal": "^0.20",
+    "@dfinity/agent": "^1.0",
+    "@dfinity/auth-client": "^1.0",
+    "@dfinity/candid": "1.0",
+    "@dfinity/identity": "^1.0",
+    "@dfinity/principal": "^1.0",
     "@peculiar/webcrypto": "1.4",
     "react": ">=16.8",
-    "zustand": "4.4"
+    "zustand": "4.5"
   },
-  "gitHead": "e2ec7048f2d3517cb5ffb9a9188d508cb50fe924"
+  "gitHead": "ca9e2f3438a4566c26d5ce56b0f0b953aa93df53"
 }

package/dist/context/actor.d.ts

@@ -1,16 +0,0 @@
-import React, { PropsWithChildren } from "react";
-import { IDL } from "@dfinity/candid";
-import { ActorSubclass, ActorManagerOptions } from "@ic-reactor/store";
-import { AgentContextType } from "./agent";
-import { ActorHooksWithField } from "../types";
-export type ActorContextType<A = ActorSubclass<any>> = ActorHooksWithField<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

@@ -1,125 +0,0 @@
-"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..."), withServiceFields = false } = _a, config = __rest(_a, ["children", "canisterId", "agentContext", "loadingComponent", "withServiceFields"]);
-    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,
-                withServiceFields: withServiceFields,
-            });
-        }
-        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

@@ -1,16 +0,0 @@
-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;
-export declare const createAgentContext: (config: AgentManagerOptions) => AgentContextValue;
-interface AgentProviderProps extends PropsWithChildren, AgentManagerOptions {
-    agentManager?: AgentManager;
-}
-export declare const AgentProvider: React.FC<AgentProviderProps>;
-export {};