@ic-reactor/react 1.0.5 → 1.0.7

package/README.md

@@ -36,12 +36,11 @@ import { createReactor } from "@ic-reactor/react"
 
 type Actor = typeof actor
 
-export const { useActorStore, useAuthClient, useQueryCall } =
-  createReactor<Actor>({
-    canisterId,
-    idlFactory,
-    host: "https://localhost:4943",
-  })
+export const { useActorStore, useAuth, useQueryCall } = createReactor<Actor>({
+  canisterId,
+  idlFactory,
+  host: "https://localhost:4943",
+})
 ```
 
 Then, use the `useQueryCall` hook to call your canister method:
@@ -82,7 +81,7 @@ export default Balance
 
 ```jsx
 // Login.tsx
-import { useAuthClient } from "./actor"
+import { useAuth } from "./actor"
 
 const Login = () => {
   const {
@@ -93,7 +92,7 @@ const Login = () => {
     identity,
     authenticating,
     authenticated,
-  } = useAuthClient()
+  } = useAuth()
 
   return (
     <div>

package/dist/context/actor.d.ts

@@ -0,0 +1,64 @@
+import { BaseActor } from "../types";
+import { CreateActorContextParameters, CreateActorContextReturnType } from "./types";
+/**
+ * Creates a React context specifically designed for managing the state and interactions with an actor on the Internet Computer (IC) blockchain.
+ * This context facilitates the dynamic creation and management of IC actors within React applications, leveraging the provided configuration options.
+ *
+ * @param reactorParameters A partial configuration object for the actor context, allowing customization and specification of actor-related settings.
+ * - `canisterId`: The default Canister ID to be used if not overridden in the `ActorProvider` component.
+ * - Other configurations can include properties related to the actor's interaction, such as agent options or authentication requirements.
+ *
+ * @returns An object containing the `ActorProvider` component and various hooks for interacting with the actor.
+ * - `ActorProvider`: A context provider component that allows child components to access and interact with the configured actor.
+ * - Hooks: Custom hooks derived from the actor context, facilitating interactions like querying or updating the actor's state.
+ *
+ * @example
+ * ```jsx
+ * import React from 'react';
+ * import { createActorContext } from '@ic-reactor/react';
+ * import { backend, canisterId, idlFactory } from './declarations/candid'; // Assuming 'declarations/candid' is where your actor interface is defined.
+ *
+ * // Initialize the actor context with configuration options
+ * const { ActorProvider, useActorState, useQueryCall, useUpdateCall } = createActorContext<typeof backend>({
+ *   canisterId,
+ *   idlFactory, // Optional
+ * });
+ *
+ * // A sample component that utilizes the actor context
+ * const App = () => (
+ *   <AgentProvider>
+ *     <ActorProvider>
+ *       <div>
+ *         <h1>IC Actor Interaction Example</h1>
+ *         <ActorComponent />
+ *       </div>
+ *     </ActorProvider>
+ *   </AgentProvider>
+ * );
+ *
+ * export default App;
+ *
+ * // A sample component that uses the actor hooks
+ * const ActorComponent = () => {
+ *   const { data, loading, error } = useQueryCall({
+ *      functionName: 'backendMethodName',
+ *      args: [],
+ *      refetchInterval: 10000,
+ *      refetchOnMount: true,
+ *   });
+  
+ *   return (
+ *     <div>
+ *        {loading && <p>Loading...</p>}
+ *        {error && <p>Error: {error.message}</p>}
+ *        {data && <p>Actor data: {data}</p>}
+ *     </div>
+ *   );
+ * };
+ * ```
+ *
+ * This function streamlines the process of setting up a context for IC actor interactions within a React app, making it easier
+ * to manage actor state and perform actions such as queries or updates. It abstracts away the complexities involved in directly
+ * managing IC agents and actors, providing a simple, declarative API for developers.
+ */
+export declare function createActorContext<A = BaseActor>(config?: CreateActorContextParameters): CreateActorContextReturnType<A>;

package/dist/context/actor.js

@@ -0,0 +1,117 @@
+"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.createActorContext = void 0;
+const react_1 = __importStar(require("react"));
+const useActor_1 = require("../hooks/useActor");
+const extractActorContext_1 = require("../helpers/extractActorContext");
+/**
+ * Creates a React context specifically designed for managing the state and interactions with an actor on the Internet Computer (IC) blockchain.
+ * This context facilitates the dynamic creation and management of IC actors within React applications, leveraging the provided configuration options.
+ *
+ * @param reactorParameters A partial configuration object for the actor context, allowing customization and specification of actor-related settings.
+ * - `canisterId`: The default Canister ID to be used if not overridden in the `ActorProvider` component.
+ * - Other configurations can include properties related to the actor's interaction, such as agent options or authentication requirements.
+ *
+ * @returns An object containing the `ActorProvider` component and various hooks for interacting with the actor.
+ * - `ActorProvider`: A context provider component that allows child components to access and interact with the configured actor.
+ * - Hooks: Custom hooks derived from the actor context, facilitating interactions like querying or updating the actor's state.
+ *
+ * @example
+ * ```jsx
+ * import React from 'react';
+ * import { createActorContext } from '@ic-reactor/react';
+ * import { backend, canisterId, idlFactory } from './declarations/candid'; // Assuming 'declarations/candid' is where your actor interface is defined.
+ *
+ * // Initialize the actor context with configuration options
+ * const { ActorProvider, useActorState, useQueryCall, useUpdateCall } = createActorContext<typeof backend>({
+ *   canisterId,
+ *   idlFactory, // Optional
+ * });
+ *
+ * // A sample component that utilizes the actor context
+ * const App = () => (
+ *   <AgentProvider>
+ *     <ActorProvider>
+ *       <div>
+ *         <h1>IC Actor Interaction Example</h1>
+ *         <ActorComponent />
+ *       </div>
+ *     </ActorProvider>
+ *   </AgentProvider>
+ * );
+ *
+ * export default App;
+ *
+ * // A sample component that uses the actor hooks
+ * const ActorComponent = () => {
+ *   const { data, loading, error } = useQueryCall({
+ *      functionName: 'backendMethodName',
+ *      args: [],
+ *      refetchInterval: 10000,
+ *      refetchOnMount: true,
+ *   });
+  
+ *   return (
+ *     <div>
+ *        {loading && <p>Loading...</p>}
+ *        {error && <p>Error: {error.message}</p>}
+ *        {data && <p>Actor data: {data}</p>}
+ *     </div>
+ *   );
+ * };
+ * ```
+ *
+ * This function streamlines the process of setting up a context for IC actor interactions within a React app, making it easier
+ * to manage actor state and perform actions such as queries or updates. It abstracts away the complexities involved in directly
+ * managing IC agents and actors, providing a simple, declarative API for developers.
+ */
+function createActorContext(config = {}) {
+    const { canisterId: defaultCanisterId } = config, defaultConfig = __rest(config, ["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, useActor_1.useActor)(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 }, (0, extractActorContext_1.extractActorContext)(ActorContext));
+}
+exports.createActorContext = createActorContext;

package/dist/context/agent.d.ts

@@ -0,0 +1,74 @@
+import type { CreateAgentContextReturnType, CreateAgentCotextParameters } from "./types";
+/**
+ * Creates a React context for managing IC agent and authentication states, providing hooks for interacting with the IC blockchain.
+ * This function initializes an `AgentContext` with a set of utilities and hooks based on the provided agent configuration.
+ *
+ * @param config A partial configuration object {@link CreateAgentCotextParameters}, allowing customization of the agent's behavior.
+ *
+ * @returns
+ * An object containing the {@link AgentProvider} component and various hooks for interacting with the agent and authentication state.
+ * The {@link AgentProvider} component is a React context provider that should wrap your app or components needing access to agent functionalities.
+ *
+ * Usage:
+ * - {@link AgentProvider}: React component to provide agent context to your application.
+ * - {@link useAgent}, {@link useAuth}, {@link useAuthState},
+ *   {@link useAgentState}, {@link useAgentManager}, {@link useUserPrincipal}:
+ *  Hooks extracted from the created context for managing agent and authentication state within components.
+ *
+ * @example
+ * agent.ts
+ * ```tsx
+ * import { createAgentContext } from "@ic-reactor/react";
+ * import { CreateAgentCotextParameters } from "@ic-reactor/react/dist/types";
+ *
+ * // Optional: Define custom agent configuration
+ * const agentConfig: CreateAgentCotextParameters = {
+ *   host: "https://localhost:8000",
+ *   // or
+ *   // isLocalEnv: true,
+ *   // port: 8000,
+ * };
+ *
+ * export const {
+ *   AgentProvider,
+ *   useAgent,
+ *   useAuth,
+ *   useAuthState,
+ *   useAgentState,
+ *   useAgentManager,
+ *   useUserPrincipal,
+ * } = createAgentContext(agentConfig);
+ *
+ * // Now you can use the returned hooks in your React components
+ *```
+ * App.tsx
+ * ```tsx
+ * import React from 'react';
+ * import { AgentProvider } from './agent';
+ *
+ * const App = () => (
+ *   <AgentProvider>
+ *     <Login />
+ *     <YourActor />
+ *   </AgentProvider>
+ * );
+ *
+ * const Login = () => {
+ *  const { login } = useAuth()
+ *  const principal = useUserPrincipal()
+ *
+ *  return (
+ *    <div>
+ *      <button onClick={() => login()}>Login</button>
+ *      <p>User: {principal?.toText()}</p>
+ *    </div>
+ *  )
+ * };
+ *
+ * ```
+ *
+ * This setup allows you to use the agent and authentication hooks within
+ * the components wrapped by {@link AgentProvider}, facilitating interaction
+ * with the Internet Computer blockchain.
+ */
+export declare const createAgentContext: (config?: CreateAgentCotextParameters) => CreateAgentContextReturnType;

package/dist/context/agent.js

@@ -0,0 +1,128 @@
+"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.createAgentContext = void 0;
+const react_1 = __importStar(require("react"));
+const core_1 = require("@ic-reactor/core");
+const agentHooks_1 = require("../helpers/agentHooks");
+const authHooks_1 = require("../helpers/authHooks");
+const extractAgentContext_1 = require("../helpers/extractAgentContext");
+/**
+ * Creates a React context for managing IC agent and authentication states, providing hooks for interacting with the IC blockchain.
+ * This function initializes an `AgentContext` with a set of utilities and hooks based on the provided agent configuration.
+ *
+ * @param config A partial configuration object {@link CreateAgentCotextParameters}, allowing customization of the agent's behavior.
+ *
+ * @returns
+ * An object containing the {@link AgentProvider} component and various hooks for interacting with the agent and authentication state.
+ * The {@link AgentProvider} component is a React context provider that should wrap your app or components needing access to agent functionalities.
+ *
+ * Usage:
+ * - {@link AgentProvider}: React component to provide agent context to your application.
+ * - {@link useAgent}, {@link useAuth}, {@link useAuthState},
+ *   {@link useAgentState}, {@link useAgentManager}, {@link useUserPrincipal}:
+ *  Hooks extracted from the created context for managing agent and authentication state within components.
+ *
+ * @example
+ * agent.ts
+ * ```tsx
+ * import { createAgentContext } from "@ic-reactor/react";
+ * import { CreateAgentCotextParameters } from "@ic-reactor/react/dist/types";
+ *
+ * // Optional: Define custom agent configuration
+ * const agentConfig: CreateAgentCotextParameters = {
+ *   host: "https://localhost:8000",
+ *   // or
+ *   // isLocalEnv: true,
+ *   // port: 8000,
+ * };
+ *
+ * export const {
+ *   AgentProvider,
+ *   useAgent,
+ *   useAuth,
+ *   useAuthState,
+ *   useAgentState,
+ *   useAgentManager,
+ *   useUserPrincipal,
+ * } = createAgentContext(agentConfig);
+ *
+ * // Now you can use the returned hooks in your React components
+ *```
+ * App.tsx
+ * ```tsx
+ * import React from 'react';
+ * import { AgentProvider } from './agent';
+ *
+ * const App = () => (
+ *   <AgentProvider>
+ *     <Login />
+ *     <YourActor />
+ *   </AgentProvider>
+ * );
+ *
+ * const Login = () => {
+ *  const { login } = useAuth()
+ *  const principal = useUserPrincipal()
+ *
+ *  return (
+ *    <div>
+ *      <button onClick={() => login()}>Login</button>
+ *      <p>User: {principal?.toText()}</p>
+ *    </div>
+ *  )
+ * };
+ *
+ * ```
+ *
+ * This setup allows you to use the agent and authentication hooks within
+ * the components wrapped by {@link AgentProvider}, facilitating interaction
+ * with the Internet Computer blockchain.
+ */
+const createAgentContext = (config = {}) => {
+    const AgentContext = (0, react_1.createContext)(null);
+    const AgentProvider = (_a) => {
+        var { children, agentManager: mybeAgentManager } = _a, options = __rest(_a, ["children", "agentManager"]);
+        const hooks = (0, react_1.useMemo)(() => {
+            const agentManager = mybeAgentManager !== null && mybeAgentManager !== void 0 ? mybeAgentManager : (0, core_1.createAgentManager)(Object.assign(Object.assign({}, options), config));
+            return Object.assign(Object.assign(Object.assign({}, (0, agentHooks_1.agentHooks)(agentManager)), (0, authHooks_1.authHooks)(agentManager)), { agentManager });
+        }, [options]);
+        return (react_1.default.createElement(AgentContext.Provider, { value: hooks }, children));
+    };
+    AgentProvider.displayName = "AgentProvider";
+    return Object.assign({ AgentProvider }, (0, extractAgentContext_1.extractAgentContext)(AgentContext));
+};
+exports.createAgentContext = createAgentContext;

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

@@ -1,9 +1,10 @@
 import type { IDL, ActorHooksReturnType, AgentHooksReturnType, AuthHooksReturnType, BaseActor, AgentManager, ActorManagerParameters, AgentManagerParameters } from "../types";
 import type { PropsWithChildren } from "react";
-export * from "./hooks/types";
 export interface AgentContext extends AgentHooksReturnType, AuthHooksReturnType {
     agentManager: AgentManager;
 }
+export interface CreateAgentCotextParameters extends AgentManagerParameters {
+}
 export interface CreateAgentContextReturnType extends AgentHooksReturnType, AuthHooksReturnType {
     useAgentManager: (agentContext?: React.Context<AgentContext | null>) => AgentManager;
     AgentProvider: React.FC<AgentProviderProps>;

package/dist/createReactor.d.ts

@@ -0,0 +1,49 @@
+import type { BaseActor, CreateReactorParameters, CreateReactorReturnType } from "./types";
+/**
+ * Initializes and configures the reactor environment for interacting with the Internet Computer (IC) blockchain within a React application.
+ * It encapsulates the creation of actors, authentication, and agent management, offering a streamlined interface for blockchain interactions.
+ *
+ * @param config Configuration {@link CreateReactorParameters} for the reactor, including:
+ *  - `withProcessEnv` (optional): Specifies whether to use process environment variables to determine if the environment is local or development. Defaults to false.
+ *  - `isLocalEnv` (optional): Indicates if the current environment is local or development, influencing the agent and actor behavior. Useful for testing or development.
+ *  - `port` (optional): Port number for the local or development environment.
+ *
+ * @returns An object containing {@link CreateReactorReturnType} hooks and utilities:
+ *  - {@link getAgent} - Returns the current agent instance.
+ *  - {@link getVisitFunction} - Returns the visit function for the actor.
+ *  - {@link useQueryCall} - A hook for querying actor methods.
+ *  - {@link useUpdateCall} - A hook for updating actor methods.
+ *  - {@link useAuth} - A hook for managing authentication and user principal.
+ *  - {@link useActor} - A hook for managing actors and their methods.
+ *  - {@link useActorManager} - A hook for managing actor manager and its methods.
+ *  - {@link useAgentManager} - A hook for managing agent manager and its methods.
+ *  - {@link initialize} - A function to initialize the actor manager if not initialized.
+ *  - {@link useActorState} - A hook for managing actor state.
+ *  - {@link useAgent} - A hook for managing agent and its methods.
+ *  - {@link useAuthState} - A hook for managing authentication state.
+ *  - {@link useAgentState} - A hook for managing agent state.
+ *  - {@link useUserPrincipal} - A hook for managing user principal.
+ *  - {@link useVisitMethod} - A hook for visiting actor methods.
+ *
+ * @example
+ * ```typescript
+ * import { createReactor } from "@ic-reactor/react";
+ * import type { CreateReactorParameters } from "@ic-reactor/react/dist/types";
+ * import { canisterId, idlFactory, yourActor } from "./declaration/yourActor"
+ *
+ * const config: CreateReactorParameters = {
+ *   canisterId,
+ *   idlFactory,
+ *   host: "https://localhost:8000", // IC network host         |
+ *   isLocalEnv: true, // Set true for local network            | one of these
+ *   withProcessEnv: true, // Use process.env to determine host |
+ *   port: 8000, // Port number for local network               |
+ * };
+ *
+ * export type YourActor = typeof yourActor;
+ *
+ * export const { useAuth, useQueryCall, useUpdateCall } = createReactor<YourActor>(config);
+ * // Now you can use the returned hooks in your React components
+ * ```
+ */
+export declare const createReactor: <A = BaseActor>(config: CreateReactorParameters) => CreateReactorReturnType<A>;

package/dist/createReactor.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReactor = void 0;
+const core_1 = require("@ic-reactor/core");
+const helpers_1 = require("./helpers");
+/**
+ * Initializes and configures the reactor environment for interacting with the Internet Computer (IC) blockchain within a React application.
+ * It encapsulates the creation of actors, authentication, and agent management, offering a streamlined interface for blockchain interactions.
+ *
+ * @param config Configuration {@link CreateReactorParameters} for the reactor, including:
+ *  - `withProcessEnv` (optional): Specifies whether to use process environment variables to determine if the environment is local or development. Defaults to false.
+ *  - `isLocalEnv` (optional): Indicates if the current environment is local or development, influencing the agent and actor behavior. Useful for testing or development.
+ *  - `port` (optional): Port number for the local or development environment.
+ *
+ * @returns An object containing {@link CreateReactorReturnType} hooks and utilities:
+ *  - {@link getAgent} - Returns the current agent instance.
+ *  - {@link getVisitFunction} - Returns the visit function for the actor.
+ *  - {@link useQueryCall} - A hook for querying actor methods.
+ *  - {@link useUpdateCall} - A hook for updating actor methods.
+ *  - {@link useAuth} - A hook for managing authentication and user principal.
+ *  - {@link useActor} - A hook for managing actors and their methods.
+ *  - {@link useActorManager} - A hook for managing actor manager and its methods.
+ *  - {@link useAgentManager} - A hook for managing agent manager and its methods.
+ *  - {@link initialize} - A function to initialize the actor manager if not initialized.
+ *  - {@link useActorState} - A hook for managing actor state.
+ *  - {@link useAgent} - A hook for managing agent and its methods.
+ *  - {@link useAuthState} - A hook for managing authentication state.
+ *  - {@link useAgentState} - A hook for managing agent state.
+ *  - {@link useUserPrincipal} - A hook for managing user principal.
+ *  - {@link useVisitMethod} - A hook for visiting actor methods.
+ *
+ * @example
+ * ```typescript
+ * import { createReactor } from "@ic-reactor/react";
+ * import type { CreateReactorParameters } from "@ic-reactor/react/dist/types";
+ * import { canisterId, idlFactory, yourActor } from "./declaration/yourActor"
+ *
+ * const config: CreateReactorParameters = {
+ *   canisterId,
+ *   idlFactory,
+ *   host: "https://localhost:8000", // IC network host         |
+ *   isLocalEnv: true, // Set true for local network            | one of these
+ *   withProcessEnv: true, // Use process.env to determine host |
+ *   port: 8000, // Port number for local network               |
+ * };
+ *
+ * export type YourActor = typeof yourActor;
+ *
+ * export const { useAuth, useQueryCall, useUpdateCall } = createReactor<YourActor>(config);
+ * // Now you can use the returned hooks in your React components
+ * ```
+ */
+const createReactor = (config) => {
+    const actorManager = (0, core_1.createReactorStore)(config);
+    const getVisitFunction = () => {
+        return actorManager.visitFunction;
+    };
+    const getAgent = () => {
+        return actorManager.agentManager.getAgent();
+    };
+    return Object.assign(Object.assign(Object.assign({ getAgent,
+        getVisitFunction }, (0, helpers_1.actorHooks)(actorManager)), (0, helpers_1.authHooks)(actorManager.agentManager)), (0, helpers_1.agentHooks)(actorManager.agentManager));
+};
+exports.createReactor = createReactor;

package/dist/helpers/authHooks.js

@@ -12,17 +12,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.authHooks = void 0;
 const zustand_1 = require("zustand");
 const react_1 = require("react");
-const tools_1 = require("@ic-reactor/core/dist/tools");
+const utils_1 = require("@ic-reactor/core/dist/utils");
 const authHooks = (agentManager) => {
-    const { authenticate: authenticator, authStore, isLocalEnv } = agentManager;
+    const { authenticate: authenticator, getAuth, authStore, isLocalEnv, } = agentManager;
     const useAuthState = () => (0, zustand_1.useStore)(authStore);
     const useUserPrincipal = () => { var _a, _b; return (_b = (_a = useAuthState()) === null || _a === void 0 ? void 0 : _a.identity) === null || _b === void 0 ? void 0 : _b.getPrincipal(); };
-    const useAuthClient = ({ onAuthentication, onAuthenticationSuccess, onAuthenticationFailure, onLogin, onLoginSuccess, onLoginError, onLoggedOut, } = {}) => {
+    const useAuth = ({ onAuthentication, onAuthenticationSuccess, onAuthenticationFailure, onLogin, onLoginSuccess, onLoginError, onLoggedOut, } = {}) => {
         const [loginState, setLoginState] = (0, react_1.useState)({
             loading: false,
             error: null,
         });
-        const { authClient, authenticated, authenticating, error, identity } = useAuthState();
+        const { authenticated, authenticating, error, identity } = useAuthState();
         const authenticate = (0, react_1.useCallback)(() => __awaiter(void 0, void 0, void 0, function* () {
             const authenticatePromise = new Promise((resolve, reject) => {
                 authenticator()
@@ -47,12 +47,13 @@ const authHooks = (agentManager) => {
             setLoginState({ loading: true, error: null });
             const loginPromise = new Promise((resolve, reject) => {
                 try {
+                    const authClient = getAuth();
                     if (!authClient) {
                         throw new Error("Auth client not initialized");
                     }
                     authClient.login(Object.assign(Object.assign({ identityProvider: isLocalEnv
-                            ? tools_1.IC_INTERNET_IDENTITY_PROVIDER
-                            : tools_1.LOCAL_INTERNET_IDENTITY_PROVIDER }, options), { onSuccess: () => {
+                            ? utils_1.LOCAL_INTERNET_IDENTITY_PROVIDER
+                            : utils_1.IC_INTERNET_IDENTITY_PROVIDER }, options), { onSuccess: () => {
                             authenticate()
                                 .then((identity) => {
                                 var _a;
@@ -60,6 +61,7 @@ const authHooks = (agentManager) => {
                                 (_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);
+                                setLoginState({ loading: false, error: null });
                             })
                                 .catch((e) => {
                                 const error = e;
@@ -84,29 +86,23 @@ const authHooks = (agentManager) => {
                 }
             });
             onLogin === null || onLogin === void 0 ? void 0 : onLogin(() => loginPromise);
-        }), [
-            authClient,
-            onLogin,
-            onLoginSuccess,
-            onLoginError,
-            isLocalEnv,
-            authenticate,
-        ]);
+        }), [onLogin, onLoginSuccess, onLoginError, isLocalEnv, authenticate]);
         const logout = (0, react_1.useCallback)((options) => __awaiter(void 0, void 0, void 0, function* () {
+            const authClient = getAuth();
             if (!authClient) {
                 throw new Error("Auth client not initialized");
             }
             yield authClient.logout(options);
             yield authenticate();
             onLoggedOut === null || onLoggedOut === void 0 ? void 0 : onLoggedOut();
-        }), [authClient, onLoggedOut]);
+        }), [onLoggedOut]);
         (0, react_1.useEffect)(() => {
+            const authClient = getAuth();
             if (!authClient && !authenticating) {
                 authenticate();
             }
-        }, [authClient, authenticating]);
+        }, [authenticating]);
         return {
-            authClient,
             authenticated,
             authenticating,
             identity,
@@ -121,7 +117,7 @@ const authHooks = (agentManager) => {
     return {
         useUserPrincipal,
         useAuthState,
-        useAuthClient,
+        useAuth,
     };
 };
 exports.authHooks = authHooks;