@ic-reactor/react 1.0.2 → 1.0.4

package/dist/hooks/useReactor.js

@@ -0,0 +1,121 @@
+"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.useReactor = void 0;
+const core_1 = require("@ic-reactor/core");
+const react_1 = require("react");
+const agent_1 = require("../provider/agent");
+const helpers_1 = require("../helpers");
+/**
+ * A comprehensive hook that manages both the fetching of Candid interfaces
+ * and the initialization of actor stores for Internet Computer (IC) canisters.
+ * It simplifies the process of interacting with canisters by encapsulating
+ * the logic for Candid retrieval and actor store management.
+ *
+ * @example
+ * ```tsx
+ * import React from 'react';
+ * import { useReactor } from '@ic-reactor/react';
+ * import { IDL } from '@dfinity/candid';
+ *
+ * const App = () => {
+ *   const { actorManager, fetchCandid, candid, fetching, fetchError } = useReactor({
+ *     canisterId: 'ryjl3-tyaaa-aaaaa-aaaba-cai',
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       <h2>IC Canister Interaction</h2>
+ *       {fetching && <p>Loading Candid interface...</p>}
+ *       {fetchError && <p>Error: {fetchError}</p>}
+ *       {candid.idlFactory && (
+ *         <div>
+ *           <p>Candid interface fetched successfully.</p>
+ *           <pre>{JSON.stringify(candid.idlFactory({ IDL }), null, 2)}</pre>
+ *         </div>
+ *       )}
+ *       <button onClick={fetchCandid} disabled={fetching}>
+ *         {fetching ? 'Fetching...' : 'Fetch Candid'}
+ *       </button>
+ *     </div>
+ *   );
+ * };
+ *
+ * export default App;
+ * ```
+ */
+const useReactor = (_a) => {
+    var { canisterId, agentContext, idlFactory: maybeIdlFactory, didjsCanisterId } = _a, config = __rest(_a, ["canisterId", "agentContext", "idlFactory", "didjsCanisterId"]);
+    const [{ idlFactory, fetching, fetchError }, setState] = (0, react_1.useState)({
+        idlFactory: maybeIdlFactory,
+        fetching: false,
+        fetchError: null,
+    });
+    const agentManager = (0, agent_1.useAgentManager)(agentContext);
+    const fetchCandid = (0, react_1.useCallback)(() => __awaiter(void 0, void 0, void 0, function* () {
+        if (!canisterId)
+            return;
+        setState({
+            idlFactory: undefined,
+            fetching: true,
+            fetchError: null,
+        });
+        try {
+            const candidManager = (0, core_1.createCandidAdapter)({
+                agentManager,
+                didjsCanisterId,
+            });
+            const { idlFactory } = yield candidManager.getCandidDefinition(canisterId);
+            setState({
+                idlFactory,
+                fetching: false,
+                fetchError: null,
+            });
+            return idlFactory;
+        }
+        catch (err) {
+            // eslint-disable-next-line no-console
+            console.error(err);
+            setState({
+                idlFactory: undefined,
+                fetchError: `Error fetching canister ${canisterId}`,
+                fetching: false,
+            });
+        }
+    }), [canisterId, didjsCanisterId, agentManager]);
+    // Automatically fetch Candid if not already fetched or provided.
+    (0, react_1.useEffect)(() => {
+        if (!fetching && !idlFactory) {
+            fetchCandid();
+        }
+    }, [fetchCandid]);
+    const hooks = (0, react_1.useMemo)(() => {
+        if (!idlFactory)
+            return null;
+        const actorManager = (0, core_1.createActorManager)(Object.assign({ agentManager,
+            idlFactory,
+            canisterId }, config));
+        return (0, helpers_1.getActorHooks)(actorManager);
+    }, [idlFactory]);
+    return { hooks, fetching, fetchError };
+};
+exports.useReactor = useReactor;

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/main.d.ts

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

package/dist/main.js

@@ -0,0 +1,35 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReactor = void 0;
+const core_1 = require("@ic-reactor/core");
+const actor_1 = require("./helpers/actor");
+const auth_1 = require("./helpers/auth");
+const tools_1 = require("@ic-reactor/core/dist/tools");
+const helpers_1 = require("./helpers");
+const createReactor = (options) => {
+    const { isLocalEnv, withVisitor, withProcessEnv } = options, args = __rest(options, ["isLocalEnv", "withVisitor", "withProcessEnv"]);
+    const actorManager = (0, core_1.createReactorStore)(Object.assign({ isLocalEnv: isLocalEnv || (withProcessEnv ? (0, tools_1.isInLocalOrDevelopment)() : false), withVisitor }, args));
+    const getVisitFunction = () => {
+        return actorManager.visitFunction;
+    };
+    const getAgent = () => {
+        return actorManager.agentManager.getAgent();
+    };
+    const actorHooks = (0, actor_1.getActorHooks)(actorManager);
+    const authHooks = (0, auth_1.getAuthHooks)(actorManager.agentManager);
+    const agentHooks = (0, helpers_1.getAgentHooks)(actorManager.agentManager);
+    return Object.assign(Object.assign(Object.assign({ getAgent,
+        getVisitFunction }, agentHooks), actorHooks), authHooks);
+};
+exports.createReactor = createReactor;

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

@@ -0,0 +1,20 @@
+import React from "react";
+import { BaseActor, FunctionName, UseMethodCallArg, UseQueryCallArgs, UseUpdateCallArgs } from "../../types";
+import { CreateActorOptions, ActorContextType, ActorProviderProps } from "./types";
+export declare function createReactorContext<A = BaseActor>({ canisterId: defaultCanisterId, ...defaultConfig }?: Partial<CreateActorOptions>): {
+    useActorState: () => import("../../types").UseActorState;
+    useQueryCall: <M extends FunctionName<A>>(args: UseQueryCallArgs<A, M>) => import("../../types").ReactorCallReturn<A, M>;
+    useUpdateCall: <M_1 extends FunctionName<A>>(args: UseUpdateCallArgs<A, M_1>) => import("../../types").ReactorCallReturn<A, M_1>;
+    useMethodCall: <M_2 extends FunctionName<A>>(args: UseMethodCallArg<A, M_2>) => import("../../types").UseMethodCallReturn<A, M_2>;
+    useVisitMethod: (functionName: FunctionName<A>) => import("@ic-reactor/core/dist/actor/types").VisitService<A>[FunctionName<A>];
+    initialize: () => Promise<void>;
+    ActorProvider: React.FC<ActorProviderProps>;
+};
+export declare function extractActorHooks<A = BaseActor>(ActorContext: React.Context<ActorContextType<A> | null>): {
+    useActorState: () => import("../../types").UseActorState;
+    useQueryCall: <M extends FunctionName<A>>(args: UseQueryCallArgs<A, M>) => import("../../types").ReactorCallReturn<A, M>;
+    useUpdateCall: <M_1 extends FunctionName<A>>(args: UseUpdateCallArgs<A, M_1>) => import("../../types").ReactorCallReturn<A, M_1>;
+    useMethodCall: <M_2 extends FunctionName<A>>(args: UseMethodCallArg<A, M_2>) => import("../../types").UseMethodCallReturn<A, M_2>;
+    useVisitMethod: (functionName: FunctionName<A>) => import("@ic-reactor/core/dist/actor/types").VisitService<A>[FunctionName<A>];
+    initialize: () => Promise<void>;
+};

package/dist/provider/actor/context.js

@@ -0,0 +1,184 @@
+"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.extractActorHooks = exports.createReactorContext = void 0;
+const react_1 = __importStar(require("react"));
+const useReactor_1 = require("../../hooks/useReactor");
+function 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 { fetchError, fetching, hooks } = (0, useReactor_1.useReactor)(Object.assign({ canisterId }, config));
+        return (react_1.default.createElement(ActorContext.Provider, { value: hooks }, fetching || hooks === null ? fetchError !== null && fetchError !== void 0 ? fetchError : loadingComponent : children));
+    };
+    ActorProvider.displayName = "ActorProvider";
+    return Object.assign({ ActorProvider }, extractActorHooks(ActorContext));
+}
+exports.createReactorContext = createReactorContext;
+function extractActorHooks(ActorContext) {
+    /**
+     * Hook for accessing the actor context, including the actor manager and state.
+     * @returns The actor context, including the actor manager and state.
+     * @example
+     * ```tsx
+     * function ActorComponent() {
+     *  const { initialize, useActorState, useQueryCall, useUpdateCall, useMethodCall, useVisitMethod } = useActorContext();
+     *  const { canisterId } = useActorState();
+     *
+     *  return (
+     *   <div>
+     *     <p>Canister ID: {canisterId}</p>
+     *   </div>
+     *  );
+     * }
+     * ```
+     */
+    const useActorContext = () => {
+        const context = (0, react_1.useContext)(ActorContext);
+        if (!context) {
+            throw new Error("useActor must be used within a ActorProvider");
+        }
+        return context;
+    };
+    /**
+     * Initializes the actor manager, setting up the actor's state.
+     */
+    const initialize = () => useActorContext().initialize();
+    /**
+     * Hook for accessing the current state of the actor, including the canister ID.
+     *
+     * @returns An object containing the current state of the actor from Zustand's store and the canister ID.
+     * @example
+     * ```tsx
+     * function ActorStateComponent() {
+     *   const { canisterId, initializing, error, initialized } = useActorState();
+     *
+     *   return (
+     *    <div>
+     *     <p>Canister ID: {canisterId}</p>
+     *     <p>Initializing: {initializing.toString()}</p>
+     *     <p>Initialized: {initialized.toString()}</p>
+     *     <p>Error: {error?.message}</p>
+     *   </div>
+     *   );
+     * }
+     *```
+     */
+    const useActorState = () => useActorContext().useActorState();
+    /**
+     * Hook for making query calls to actors. It supports automatic refetching on component mount and at specified intervals.
+     *
+     * @param options Configuration object for the query call, including refetching options and other configurations passed to useReactorCall.
+     * @returns An object containing the query call function and the current call state (data, error, loading, call, reset).
+     * @example
+     * ```tsx
+     * function QueryCallComponent() {
+     *    const { call, data, loading } = useQueryCall({
+     *      functionName: 'getUserProfile',
+     *      args: ['123'],
+     *      refetchOnMount: true,
+     *      refetchInterval: 5000, // refetch every 5 seconds
+     *    });
+     *
+     *    if (loading) return <p>Loading profile...</p>;
+     *
+     *    return (
+     *      <div>
+     *        <p>User Profile: {JSON.stringify(data)}</p>
+     *        <button onClick={call}>Refetch</button>
+     *      </div>
+     *    );
+     * }
+     * ```
+     */
+    const useQueryCall = (args) => useActorContext().useQueryCall(args);
+    /**
+     * Hook for making update calls to actors, handling loading states, and managing errors. It supports custom event handlers for loading, success, and error events.
+     *
+     * @param options Configuration object for the actor method call, including the method name, arguments, and event handlers.
+     * @returns An object containing the method call function, a reset function to reset the call state to its default, and the current call state (data, error, loading, call, reset).
+     * @example
+     * ```tsx
+     * function UpdateCallComponent() {
+     *   const { call, data, loading } = useUpdateCall({
+     *      functionName: 'updateUserProfile',
+     *      args: ['123', { name: 'John Doe' }],
+     *      onLoading: (loading) => console.log('Loading:', loading),
+     *      onError: (error) => console.error('Error:', error),
+     *      onSuccess: (data) => console.log('Success:', data),
+     *   });
+     *
+     *  if (loading) return <p>Updating profile...</p>;
+     *
+     *  return (
+     *    <div>
+     *      <p>Updated Profile: {JSON.stringify(data)}</p>
+     *      <button onClick={call}>Update</button>
+     *    </div>
+     *  );
+     * }
+     * ```
+     */
+    const useUpdateCall = (args) => useActorContext().useUpdateCall(args);
+    /**
+     * Hook that combines useVisitMethod and useReactorCall for calling actor methods. It provides both the visit service for the method and the ability to make actor calls with state management.
+     *
+     * @param args Configuration object including the function name and arguments for the actor method call.
+     * @returns An object containing the visit function for the method and the current call state (data, error, loading).
+     */
+    const useMethodCall = (args) => useActorContext().useMethodCall(args);
+    /**
+     * Memoizes and returns a visit service function for a specific actor method.
+     *
+     * @param functionName The name of the actor method to visit.
+     * @returns The visit service function for the specified method.
+     */
+    const useVisitMethod = (functionName) => useActorContext().useVisitMethod(functionName);
+    return {
+        useActorState,
+        useQueryCall,
+        useUpdateCall,
+        useMethodCall,
+        useVisitMethod,
+        initialize,
+    };
+}
+exports.extractActorHooks = extractActorHooks;

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

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+export declare const ActorProvider: import("react").FC<import("./types").ActorProviderProps>, useActorState: () => import("../../types").UseActorState, useQueryCall: <M extends string>(args: import("../../types").UseQueryCallArgs<import("@ic-reactor/core/dist/types").BaseActor, M>) => import("../../types").ReactorCallReturn<import("@ic-reactor/core/dist/types").BaseActor, M>, useUpdateCall: <M extends string>(args: import("../../types").UseUpdateCallArgs<import("@ic-reactor/core/dist/types").BaseActor, M>) => import("../../types").ReactorCallReturn<import("@ic-reactor/core/dist/types").BaseActor, M>, useMethodCall: <M extends string>(args: import("../../types").UseMethodCallArg<import("@ic-reactor/core/dist/types").BaseActor, M>) => import("../../types").UseMethodCallReturn<import("@ic-reactor/core/dist/types").BaseActor, M>, useVisitMethod: (functionName: string) => <V extends import("@dfinity/candid/lib/cjs/idl").Visitor<unknown, unknown>>(extractorClass: V, data?: import("@ic-reactor/core/dist/types").VisitorType<V>["data"] | undefined) => ReturnType<V["visitFunc"]>;
+export { createReactorContext, extractActorHooks } from "./context";

package/dist/provider/actor/index.js

@@ -0,0 +1,9 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractActorHooks = exports.createReactorContext = exports.useVisitMethod = exports.useMethodCall = exports.useUpdateCall = exports.useQueryCall = exports.useActorState = exports.ActorProvider = void 0;
+const context_1 = require("./context");
+_a = (0, context_1.createReactorContext)(), exports.ActorProvider = _a.ActorProvider, exports.useActorState = _a.useActorState, exports.useQueryCall = _a.useQueryCall, exports.useUpdateCall = _a.useUpdateCall, exports.useMethodCall = _a.useMethodCall, exports.useVisitMethod = _a.useVisitMethod;
+var context_2 = require("./context");
+Object.defineProperty(exports, "createReactorContext", { enumerable: true, get: function () { return context_2.createReactorContext; } });
+Object.defineProperty(exports, "extractActorHooks", { enumerable: true, get: function () { return context_2.extractActorHooks; } });

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

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

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

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

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

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

package/dist/provider/agent/types.js

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