@ic-reactor/react 1.1.5 → 1.1.7

package/dist/context/actor.d.ts

@@ -61,4 +61,4 @@ import { CreateActorContextParameters, CreateActorContextReturnType } from "./ty
  * 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>;
+export declare function createActorContext<A = BaseActor>(contextConfig?: CreateActorContextParameters): CreateActorContextReturnType<A>;

package/dist/context/actor.js

@@ -79,8 +79,8 @@ const extractActorContext_1 = require("../helpers/extractActorContext");
  * 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"]);
+function createActorContext(contextConfig = {}) {
+    const { canisterId: defaultCanisterId } = contextConfig, defaultConfig = __rest(contextConfig, ["canisterId"]);
     const ActorContext = react_1.default.createContext(null);
     const ActorProvider = (_a) => {
         var { children, canisterId = defaultCanisterId, loadingComponent = react_1.default.createElement("div", null, "Fetching canister..."), authenticatingComponent = react_1.default.createElement("div", null, "Authenticating...") } = _a, restConfig = __rest(_a, ["children", "canisterId", "loadingComponent", "authenticatingComponent"]);
@@ -88,7 +88,7 @@ function createActorContext(config = {}) {
             throw new Error("canisterId is required");
         }
         const config = react_1.default.useMemo(() => (Object.assign(Object.assign({}, defaultConfig), restConfig)), [defaultConfig, restConfig]);
-        const { fetchError, authenticating, hooks } = (0, useActor_1.useActor)(Object.assign({ canisterId, fetchOnMount: false }, config));
+        const { fetchError, authenticating, hooks } = (0, useActor_1.useActor)(Object.assign({ canisterId }, config));
         return (react_1.default.createElement(ActorContext.Provider, { value: hooks }, hooks === null
             ? (fetchError !== null && fetchError !== void 0 ? fetchError : authenticating)
                 ? authenticatingComponent

package/dist/helpers/actorHooks.js

@@ -1,27 +1,4 @@
 "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) {
@@ -42,9 +19,12 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.actorHooks = void 0;
-const react_1 = __importStar(require("react"));
+const react_1 = __importDefault(require("react"));
 const zustand_1 = require("zustand");
 const DEFAULT_STATE = {
     data: undefined,
@@ -76,7 +56,12 @@ const actorHooks = (actorManager) => {
         return visitFunction;
     };
     const useVisitMethod = (functionName) => {
-        return react_1.default.useMemo(() => visitFunction[functionName], [functionName]);
+        return react_1.default.useMemo(() => {
+            if (!visitFunction[functionName]) {
+                throw new Error(`Method ${functionName} not found`);
+            }
+            return visitFunction[functionName];
+        }, [functionName]);
     };
     const useSharedCall = (_a) => {
         var { args = [], functionName, throwOnError = false } = _a, events = __rest(_a, ["args", "functionName", "throwOnError"]);
@@ -123,21 +108,10 @@ const actorHooks = (actorManager) => {
     };
     const useUpdateCall = useSharedCall;
     const useMethod = (args) => {
-        const _a = useSharedCall(args), { call, data } = _a, state = __rest(_a, ["call", "data"]);
+        const _a = useSharedCall(args), { call } = _a, state = __rest(_a, ["call"]);
         const visit = useVisitMethod(args.functionName);
-        const transformedData = (0, react_1.useMemo)(() => {
-            if (data === undefined)
-                return data;
-            if (args.transform) {
-                return visit(args.transform, {
-                    value: data,
-                    label: args.functionName,
-                });
-            }
-            return data;
-        }, [data, args.transform, visit]);
         return Object.assign({ call,
-            visit, data: transformedData }, state);
+            visit }, state);
     };
     return {
         initialize,

package/dist/helpers/authHooks.js

@@ -23,7 +23,7 @@ const authHooks = (agentManager) => {
     const useAuth = ({ onAuthentication, onAuthenticationSuccess, onAuthenticationFailure, onLogin, onLoginSuccess, onLoginError, onLoggedOut, } = {}) => {
         const [loginState, setLoginState] = react_1.default.useState({
             loading: false,
-            error: null,
+            error: undefined,
         });
         const { authenticated, authenticating, error, identity } = useAuthState();
         const authenticate = react_1.default.useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
@@ -47,7 +47,7 @@ const authHooks = (agentManager) => {
             onAuthenticationFailure,
         ]);
         const login = react_1.default.useCallback((options) => __awaiter(void 0, void 0, void 0, function* () {
-            setLoginState({ loading: true, error: null });
+            setLoginState({ loading: true, error: undefined });
             const loginPromise = new Promise((resolve, reject) => {
                 try {
                     const authClient = getAuth();
@@ -64,18 +64,16 @@ 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 });
+                                setLoginState({ loading: false, error: undefined });
                             })
-                                .catch((e) => {
-                                const error = e;
+                                .catch((error) => {
                                 setLoginState({ loading: false, error });
                                 onLoginError === null || onLoginError === void 0 ? void 0 : onLoginError(error);
                                 reject(error);
                             });
-                        }, onError: (e) => {
+                        }, onError: (error) => {
                             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);
+                            (_a = options === null || options === void 0 ? void 0 : options.onError) === null || _a === void 0 ? void 0 : _a.call(options, error);
                             setLoginState({ loading: false, error });
                             onLoginError === null || onLoginError === void 0 ? void 0 : onLoginError(error);
                             reject(error);

package/dist/helpers/types.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="react" />
-import type { ServiceClass, Visitor } from "@dfinity/candid/lib/cjs/idl";
+import type { ServiceClass } from "@dfinity/candid/lib/cjs/idl";
 import type { ActorState, CanisterId, AuthClientLoginOptions, ActorMethodParameters, ActorMethodReturnType, Identity, Principal, FunctionName, VisitService, AuthState, HttpAgent, AgentState, BaseActor } from "@ic-reactor/core/dist/types";
 export interface AgentHooksReturnType {
     useAgent: () => HttpAgent | undefined;
@@ -13,9 +13,9 @@ export interface AuthHooksReturnType {
 export interface UseAuthParameters {
     onAuthentication?: (promise: () => Promise<Identity>) => void;
     onAuthenticationSuccess?: (identity: Identity) => void;
-    onAuthenticationFailure?: (error: Error) => void;
+    onAuthenticationFailure?: (error: string | undefined) => void;
     onLoginSuccess?: (principal: Principal) => void;
-    onLoginError?: (error: Error) => void;
+    onLoginError?: (error: string | undefined) => void;
     onLogin?: (promise: () => Promise<Principal>) => void;
     onLoggedOut?: () => void;
 }
@@ -28,11 +28,11 @@ export interface UseAuthReturnType {
     logout: (options?: LogoutParameters) => Promise<void>;
     authenticate: () => Promise<Identity>;
     loginLoading: boolean;
-    loginError: Error | null;
+    loginError: string | undefined;
 }
 export type LoginState = {
     loading: boolean;
-    error: Error | null;
+    error: string | undefined;
 };
 export type LoginParameters = AuthClientLoginOptions;
 export type LogoutParameters = {
@@ -71,29 +71,17 @@ export interface DynamicDataArgs<V = unknown> {
     label: string;
     value: V;
 }
-export interface UseMethodParameters<A, M extends FunctionName<A>, T = unknown> extends UseSharedCallParameters<A, M> {
-    transform?: Visitor<DynamicDataArgs, T>;
+export interface UseMethodParameters<A, M extends FunctionName<A>> extends UseSharedCallParameters<A, M> {
 }
-export interface UseMethodReturnType<A, M extends FunctionName<A> = FunctionName<A>, T = unknown> {
+export interface UseMethodReturnType<A, M extends FunctionName<A> = FunctionName<A>> {
     loading: boolean;
     error: Error | undefined;
-    data: T | ActorMethodReturnType<A[M]> | undefined;
+    data: ActorMethodReturnType<A[M]> | undefined;
     visit: VisitService<A>[M];
     reset: () => void;
     call: (eventOrReplaceArgs?: React.MouseEvent | ActorMethodParameters<A[M]>) => Promise<ActorMethodReturnType<A[M]> | undefined>;
 }
-export type UseMethod<A> = {
-    <M extends FunctionName<A>, T = unknown>({ transform, }: {
-        transform: Visitor<DynamicDataArgs, T>;
-    } & UseMethodParameters<A, M, T>): {
-        data: T | undefined;
-    } & UseMethodReturnType<A, M, T>;
-    <M extends FunctionName<A>, T = unknown>({ transform, }: {
-        transform?: undefined;
-    } & UseMethodParameters<A, M, T>): {
-        data: ActorMethodReturnType<A[M]> | undefined;
-    } & UseMethodReturnType<A, M, T>;
-};
+export type UseMethod<A> = <M extends FunctionName<A>>(args: UseMethodParameters<A, M>) => UseMethodReturnType<A, M>;
 export type UseVisitMethod<A> = <M extends FunctionName<A>>(functionName: M) => VisitService<A>[M];
 export type UseVisitService<A> = () => VisitService<A>;
 export interface ActorHooksReturnType<A = BaseActor> {

package/dist/hooks/types.d.ts

@@ -6,7 +6,6 @@ export interface UseActorParameters extends Omit<ActorManagerParameters, "idlFac
     canisterId: string;
     idlFactory?: IDL.InterfaceFactory;
     agentContext?: React.Context<AgentContext | null>;
-    fetchOnMount?: boolean;
     didjsCanisterId?: string;
 }
 export interface UseActorReturn<A = BaseActor> {

package/dist/hooks/useActor.d.ts

@@ -1,4 +1,4 @@
-import type { BaseActor } from "../types";
+import { type BaseActor } from "../types";
 import type { UseActorParameters, UseActorReturn } from "./types";
 /**
  * A comprehensive hook that manages both the fetching of Candid interfaces

package/dist/hooks/useActor.js

@@ -89,21 +89,25 @@ const agent_1 = require("./agent");
  * ```
  */
 const useActor = (config) => {
-    const { canisterId, idlFactory: maybeIdlFactory, agentContext, fetchOnMount = true, didjsCanisterId } = config, actorConfig = __rest(config, ["canisterId", "idlFactory", "agentContext", "fetchOnMount", "didjsCanisterId"]);
-    const [{ idlFactory, fetching, fetchError }, setState] = (0, react_1.useState)({
-        idlFactory: maybeIdlFactory,
+    const { canisterId, idlFactory: maybeIdlFactory, agentContext, didjsCanisterId } = config, actorConfig = __rest(config, ["canisterId", "idlFactory", "agentContext", "didjsCanisterId"]);
+    if (!canisterId) {
+        throw new Error("canisterId is required");
+    }
+    const [actorManager, setActorManager] = (0, react_1.useState)();
+    const [{ fetching, fetchError }, setState] = (0, react_1.useState)({
         fetching: false,
         fetchError: null,
     });
     const agentManager = (0, useAgentManager_1.useAgentManager)(agentContext);
-    const fetchCandid = (0, react_1.useCallback)((agent) => __awaiter(void 0, void 0, void 0, function* () {
-        if (!canisterId || fetching)
+    const authenticating = (0, agent_1.useAuthState)().authenticating;
+    const fetchCandid = (0, react_1.useCallback)(() => __awaiter(void 0, void 0, void 0, function* () {
+        if (fetching || authenticating)
             return;
         setState({
-            idlFactory: undefined,
             fetching: true,
             fetchError: null,
         });
+        const agent = agentManager.getAgent();
         try {
             const candidManager = (0, core_1.createCandidAdapter)({
                 agent,
@@ -111,7 +115,6 @@ const useActor = (config) => {
             });
             const { idlFactory } = yield candidManager.getCandidDefinition(canisterId);
             setState({
-                idlFactory,
                 fetching: false,
                 fetchError: null,
             });
@@ -121,35 +124,35 @@ const useActor = (config) => {
             // eslint-disable-next-line no-console
             console.error(err);
             setState({
-                idlFactory: undefined,
                 fetchError: `Error fetching canister ${canisterId}`,
                 fetching: false,
             });
         }
-    }), [canisterId, didjsCanisterId]);
+    }), [canisterId, authenticating, didjsCanisterId]);
     (0, react_1.useEffect)(() => {
         if (maybeIdlFactory) {
-            setState(() => ({
-                idlFactory: maybeIdlFactory,
-                fetching: false,
-                fetchError: null,
-            }));
-            return;
+            const actorManager = (0, core_1.createActorManager)(Object.assign({ agentManager, idlFactory: maybeIdlFactory, canisterId }, actorConfig));
+            setActorManager(() => actorManager);
         }
-        const unsubscribe = agentManager.subscribeAgent(fetchCandid, fetchOnMount);
-        return unsubscribe;
-    }, [agentManager, fetchOnMount]);
-    const authenticating = (0, agent_1.useAuthState)().authenticating;
+        else {
+            fetchCandid().then((idlFactory) => {
+                if (!idlFactory)
+                    return;
+                const actorManager = (0, core_1.createActorManager)(Object.assign({ agentManager,
+                    idlFactory,
+                    canisterId }, actorConfig));
+                setActorManager(() => actorManager);
+            });
+        }
+        return actorManager === null || actorManager === void 0 ? void 0 : actorManager.cleanup();
+    }, [fetchCandid, maybeIdlFactory, canisterId, agentManager]);
     const hooks = (0, react_1.useMemo)(() => {
-        if (!idlFactory)
+        if (fetching)
             return null;
-        if (authenticating)
+        if (!actorManager)
             return null;
-        const actorManager = (0, core_1.createActorManager)(Object.assign({ agentManager,
-            idlFactory,
-            canisterId }, actorConfig));
         return (0, helpers_1.actorHooks)(actorManager);
-    }, [canisterId, authenticating, idlFactory]);
+    }, [canisterId, authenticating, actorManager, fetching]);
     return { hooks, authenticating, fetching, fetchError };
 };
 exports.useActor = useActor;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ic-reactor/react",
-  "version": "1.1.5",
+  "version": "1.1.7",
   "description": "A React library for interacting with Internet Computer canisters",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -35,7 +35,7 @@
     "node": ">=10"
   },
   "dependencies": {
-    "@ic-reactor/core": "^1.1.2",
+    "@ic-reactor/core": "^1.1.3",
     "zustand-utils": "^1.3"
   },
   "peerDependencies": {
@@ -47,5 +47,5 @@
     "react": ">=16.8",
     "zustand": "4.5"
   },
-  "gitHead": "5203d7142eda0153581cb3b6de00e12fc128eb33"
+  "gitHead": "f5b239372688a3343ef371369143b733d876158f"
 }