@ic-reactor/react 1.7.8 → 1.8.0

package/dist/context/actor/create.js

@@ -82,19 +82,24 @@ 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"]);
+        var { children, fetchingComponent, canisterId = defaultCanisterId, errorComponent = (error) => react_1.default.createElement("div", null, error), loadingComponent = react_1.default.createElement("div", null, "Fetching canister..."), authenticatingComponent = react_1.default.createElement("div", null, "Authenticating...") } = _a, restConfig = __rest(_a, ["children", "fetchingComponent", "canisterId", "errorComponent", "loadingComponent", "authenticatingComponent"]);
         if (!canisterId) {
             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 }, config));
-        return (react_1.default.createElement(ActorContext.Provider, { value: hooks }, hooks === null
-            ? fetchError
+        const { fetchError, authenticating, initializeActor, hooks } = (0, useActor_1.useActor)(Object.assign({ canisterId }, config));
+        const useInitializeActor = react_1.default.useCallback(() => {
+            return initializeActor;
+        }, [initializeActor]);
+        return (react_1.default.createElement(ActorContext.Provider, { value: Object.assign(Object.assign({}, hooks), { useInitializeActor }) },
+            fetchingComponent,
+            hooks === null
                 ? fetchError
-                : authenticating
-                    ? authenticatingComponent
-                    : loadingComponent
-            : children));
+                    ? errorComponent(fetchError)
+                    : authenticating
+                        ? authenticatingComponent
+                        : loadingComponent
+                : children));
     };
     ActorProvider.displayName = "ActorProvider";
     const ActorHookProvider = ({ hooks, children, }) => {

package/dist/context/actor/hooks/useInitializeActor.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Initializes an actor with the provided IDL factory and optional actor configuration.
+ * This hook is used when the actor is not initialized by the `ActorProvider` component,
+ * or when the actor needs to be initialized in a specific way.
+ */
+export declare const useInitializeActor: () => import("../../../types").InitializeActor;

package/dist/context/actor/hooks/useInitializeActor.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useInitializeActor = void 0;
+const __1 = require("..");
+/**
+ * Initializes an actor with the provided IDL factory and optional actor configuration.
+ * This hook is used when the actor is not initialized by the `ActorProvider` component,
+ * or when the actor needs to be initialized in a specific way.
+ */
+exports.useInitializeActor = __1.ActorHooks.useInitializeActor;

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

@@ -12,4 +12,5 @@ export * from "./hooks/useActorState";
 export * from "./hooks/useVisitMethod";
 export * from "./hooks/useVisitService";
 export * from "./hooks/useActorInterface";
+export * from "./hooks/useInitializeActor";
 export * from "./hooks/useMethod";

package/dist/context/actor/index.js

@@ -29,4 +29,5 @@ __exportStar(require("./hooks/useActorState"), exports);
 __exportStar(require("./hooks/useVisitMethod"), exports);
 __exportStar(require("./hooks/useVisitService"), exports);
 __exportStar(require("./hooks/useActorInterface"), exports);
+__exportStar(require("./hooks/useInitializeActor"), exports);
 __exportStar(require("./hooks/useMethod"), exports);

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

@@ -1,8 +1,12 @@
 /// <reference types="react" />
-import type { IDL, ActorHooksReturnType, BaseActor, ActorManagerParameters, CanisterId } from "../../types";
+import type { IDL, ActorHooksReturnType, BaseActor, ActorManagerParameters, CanisterId, InitializeActor } from "../../types";
+export interface CreateActorContextType<A = BaseActor> extends ActorHooksReturnType<A> {
+    useInitializeActor?: () => InitializeActor;
+}
 export interface CreateActorContextReturnType<A = BaseActor> extends ActorHooksReturnType<A> {
     ActorProvider: React.FC<ActorProviderProps>;
     ActorHookProvider: React.FC<ActorHookProviderProps<A>>;
+    useInitializeActor: () => InitializeActor;
 }
 export interface ActorHookProviderProps<A> {
     hooks: ActorHooksReturnType<A>;
@@ -11,6 +15,8 @@ export interface ActorHookProviderProps<A> {
 export interface ActorProviderProps extends CreateActorContextParameters {
     children?: React.ReactNode | undefined;
     candidString?: string;
+    fetchingComponent?: React.ReactNode;
+    errorComponent?: (error: string) => React.ReactNode;
     loadingComponent?: React.ReactNode;
     authenticatingComponent?: React.ReactNode;
 }
@@ -18,4 +24,5 @@ export interface CreateActorContextParameters extends Omit<ActorManagerParameter
     didjsId?: string;
     canisterId?: CanisterId;
     idlFactory?: IDL.InterfaceFactory;
+    disableAutoFetch?: boolean;
 }

package/dist/context/adapter/create.js

@@ -1,4 +1,13 @@
 "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)
@@ -22,8 +31,57 @@ function createAdapterContext(config = {}) {
     const { withParser: _withParser, didjsCanisterId: _didjsCanisterId } = config, defaultConfig = __rest(config, ["withParser", "didjsCanisterId"]);
     const CandidAdapterContext = react_1.default.createContext(null);
     const useCandidAdapter = () => {
-        const candidAdapter = react_1.default.useContext(CandidAdapterContext);
-        return candidAdapter;
+        const context = react_1.default.useContext(CandidAdapterContext);
+        if (!context) {
+            throw new Error("Actor hooks must be used within a ActorProvider");
+        }
+        return context;
+    };
+    const useCandidEvaluation = () => {
+        const [state, setState] = react_1.default.useState({
+            fetching: true,
+            fetchError: null,
+        });
+        const candidAdapter = useCandidAdapter();
+        const validateCandid = react_1.default.useCallback((candidString) => {
+            setState({
+                fetchError: null,
+                fetching: false,
+            });
+            try {
+                return candidAdapter.validateIDL(candidString);
+            }
+            catch (err) {
+                // eslint-disable-next-line no-console
+                console.error(err);
+                setState({
+                    fetchError: `Error validating Candid definition, ${err}`,
+                    fetching: false,
+                });
+            }
+        }, []);
+        const evaluateCandid = react_1.default.useCallback((candidString) => __awaiter(this, void 0, void 0, function* () {
+            setState({
+                fetchError: null,
+                fetching: true,
+            });
+            try {
+                const definition = yield candidAdapter.dynamicEvalJs(candidString);
+                if (typeof (definition === null || definition === void 0 ? void 0 : definition.idlFactory) !== "function") {
+                    throw new Error("Error evaluating Candid definition");
+                }
+                return definition.idlFactory;
+            }
+            catch (err) {
+                // eslint-disable-next-line no-console
+                console.error(err);
+                setState({
+                    fetchError: `Error evaluating Candid definition, ${err}`,
+                    fetching: false,
+                });
+            }
+        }), []);
+        return Object.assign({ evaluateCandid, validateCandid }, state);
     };
     const CandidAdapterProvider = (_a) => {
         var { children, withParser = _withParser, loadingComponent = react_1.default.createElement("div", null, "Loading Parser..."), didjsCanisterId = _didjsCanisterId } = _a, restConfig = __rest(_a, ["children", "withParser", "loadingComponent", "didjsCanisterId"]);
@@ -43,8 +101,10 @@ function createAdapterContext(config = {}) {
     };
     CandidAdapterProvider.displayName = "CandidAdapterProvider";
     return {
-        useCandidAdapter,
+        CandidAdapterContext,
         CandidAdapterProvider,
+        useCandidEvaluation,
+        useCandidAdapter,
     };
 }
 exports.createAdapterContext = createAdapterContext;

package/dist/context/adapter/hooks/useCandidEvaluation.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Accesses the `CandidEvaluation` function to evaluate the actor's Candid interface from a string
+ * into an `idlFactory`.
+ */
+export declare const useCandidEvaluation: () => import("../types").UseCandidEvaluationReturnType;

package/dist/context/adapter/hooks/useCandidEvaluation.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCandidEvaluation = void 0;
+const __1 = require("..");
+/**
+ * Accesses the `CandidEvaluation` function to evaluate the actor's Candid interface from a string
+ * into an `idlFactory`.
+ */
+exports.useCandidEvaluation = __1.AdapterHooks.useCandidEvaluation;

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

@@ -1,6 +1,7 @@
-import { createAdapterContext } from "./create";
-export { createAdapterContext };
+/// <reference types="react" />
 /** @ignore */
 export declare const AdapterHooks: import("./types").CreateCandidAdapterContextReturnType;
+export declare const CandidAdapterContext: import("react").Context<import("./types").CandidAdapterContextType | null>;
 export * from "./provider";
 export * from "./hooks/useCandidAdapter";
+export * from "./hooks/useCandidEvaluation";

package/dist/context/adapter/index.js

@@ -14,10 +14,11 @@ 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 });
-exports.AdapterHooks = exports.createAdapterContext = void 0;
+exports.CandidAdapterContext = exports.AdapterHooks = void 0;
 const create_1 = require("./create");
-Object.defineProperty(exports, "createAdapterContext", { enumerable: true, get: function () { return create_1.createAdapterContext; } });
 /** @ignore */
 exports.AdapterHooks = (0, create_1.createAdapterContext)();
+exports.CandidAdapterContext = exports.AdapterHooks.CandidAdapterContext;
 __exportStar(require("./provider"), exports);
 __exportStar(require("./hooks/useCandidAdapter"), exports);
+__exportStar(require("./hooks/useCandidEvaluation"), exports);

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

@@ -1,5 +1,5 @@
 import type { PropsWithChildren } from "react";
-import type { CandidAdapterParameters } from "../../types";
+import type { CandidAdapterParameters, IDL } from "../../types";
 import type { CandidAdapter } from "@ic-reactor/core/dist/classes";
 export type { CandidAdapter };
 export interface CandidAdapterContextType extends CandidAdapter {
@@ -11,7 +11,15 @@ export interface CandidAdapterProviderProps extends PropsWithChildren, CandidAda
 export interface CreateCandidAdapterCotextParameters extends CandidAdapterParameters {
     withParser?: boolean;
 }
+export interface UseCandidEvaluationReturnType {
+    fetchError: string | null;
+    fetching: boolean;
+    validateCandid: (candidString: string) => boolean | undefined;
+    evaluateCandid: (candidString: string) => Promise<IDL.InterfaceFactory | undefined>;
+}
 export interface CreateCandidAdapterContextReturnType {
-    useCandidAdapter: () => CandidAdapter;
+    CandidAdapterContext: React.Context<CandidAdapterContextType | null>;
     CandidAdapterProvider: React.FC<CandidAdapterProviderProps>;
+    useCandidEvaluation: () => UseCandidEvaluationReturnType;
+    useCandidAdapter: () => CandidAdapter;
 }

package/dist/context/agent/create.js

@@ -107,6 +107,6 @@ function createAgentContext(config = {}) {
         return (react_1.default.createElement(AgentContext.Provider, { value: hooks }, children));
     };
     AgentProvider.displayName = "AgentProvider";
-    return Object.assign({ AgentProvider }, (0, extractAgentContext_1.extractAgentContext)(AgentContext));
+    return Object.assign({ AgentContext, AgentProvider }, (0, extractAgentContext_1.extractAgentContext)(AgentContext));
 }
 exports.createAgentContext = createAgentContext;

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

@@ -1,7 +1,7 @@
-import { createAgentContext } from "./create";
-export { createAgentContext };
+/// <reference types="react" />
 /** @ignore */
 export declare const AgentHooks: import("./types").CreateAgentContextReturnType;
+export declare const AgentContext: import("react").Context<import("./types").AgentContext | null>;
 export * from "./provider";
 export * from "./hooks/useAgent";
 export * from "./hooks/useAgentState";

package/dist/context/agent/index.js

@@ -14,11 +14,11 @@ 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 });
-exports.AgentHooks = exports.createAgentContext = void 0;
+exports.AgentContext = exports.AgentHooks = void 0;
 const create_1 = require("./create");
-Object.defineProperty(exports, "createAgentContext", { enumerable: true, get: function () { return create_1.createAgentContext; } });
 /** @ignore */
 exports.AgentHooks = (0, create_1.createAgentContext)();
+exports.AgentContext = exports.AgentHooks.AgentContext;
 __exportStar(require("./provider"), exports);
 __exportStar(require("./hooks/useAgent"), exports);
 __exportStar(require("./hooks/useAgentState"), exports);

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

@@ -10,6 +10,7 @@ export interface CreateAgentCotextParameters extends AgentManagerParameters {
 export interface CreateAgentContextReturnType extends AgentHooksReturnType, AuthHooksReturnType {
     useAgentManager: () => AgentManager;
     AgentProvider: React.FC<AgentProviderProps>;
+    AgentContext: React.Context<AgentContext | null>;
 }
 export interface AgentProviderProps extends PropsWithChildren, CreateAgentCotextParameters {
     agentManager?: AgentManager;

package/dist/helpers/actorHooks.d.ts

@@ -1,5 +1,5 @@
 import type { ActorHooksReturnType } from "../types";
-import type { ActorManager, BaseActor } from "@ic-reactor/core/dist/types";
+import { type ActorManager, type BaseActor } from "@ic-reactor/core/dist/types";
 /**
  * Provides a set of React hooks designed for interacting with actors in an Internet Computer (IC) project using the React framework and Zustand for state management.
  *

package/dist/helpers/actorHooks.js

@@ -90,13 +90,16 @@ const actorHooks = (actorManager) => {
         return [state, setSharedState];
     };
     const useMethodAttributes = () => {
-        return React.useMemo(extractMethodAttributes, []);
+        return React.useMemo(extractMethodAttributes, [
+            actorManager,
+        ]);
     };
     const useMethodNames = () => {
-        return React.useMemo(() => Object.keys(extractMethodAttributes()), []);
+        const methodAttributes = useMethodAttributes();
+        return Object.keys(methodAttributes);
     };
     const useActorInterface = () => {
-        return React.useMemo(() => extractInterface(), []);
+        return extractInterface();
     };
     const useVisitService = () => {
         return visitFunction;

package/dist/helpers/extractActorContext.d.ts

@@ -1,4 +1,4 @@
 import React from "react";
-import type { ActorHooksReturnType, BaseActor } from "../types";
-import type { CreateActorContextReturnType } from "../context/actor/types";
-export declare function extractActorContext<A = BaseActor>(actorContext: React.Context<ActorHooksReturnType<A> | null>): Omit<CreateActorContextReturnType<A>, "ActorProvider" | "ActorHookProvider">;
+import type { BaseActor } from "../types";
+import type { CreateActorContextReturnType, CreateActorContextType } from "../context/actor/types";
+export declare function extractActorContext<A = BaseActor>(actorContext: React.Context<CreateActorContextType<A> | null>): Omit<CreateActorContextReturnType<A>, "ActorProvider" | "ActorHookProvider">;

package/dist/helpers/extractActorContext.js

@@ -26,6 +26,7 @@ function extractActorContext(actorContext) {
     const useVisitMethod = (functionName) => useActorContext().useVisitMethod(functionName);
     const useVisitService = () => useActorContext().useVisitService();
     const useActorInterface = () => useActorContext().useActorInterface();
+    const useInitializeActor = () => { var _a, _b; return (_b = (_a = useActorContext()).useInitializeActor) === null || _b === void 0 ? void 0 : _b.call(_a); };
     return {
         useActorStore,
         useActorState,
@@ -37,6 +38,7 @@ function extractActorContext(actorContext) {
         useVisitMethod,
         useVisitService,
         useActorInterface,
+        useInitializeActor,
         initialize,
     };
 }

package/dist/helpers/extractAgentContext.d.ts

@@ -25,4 +25,4 @@ import type { AgentContext, CreateAgentContextReturnType } from "../types";
  * To use these hooks, ensure your components are wrapped in an `AgentProvider` that you've set up to supply the `AgentContext`.
  * This context provides the necessary agent functionalities and state management capabilities required by the hooks.
  */
-export declare const extractAgentContext: (agentContext: React.Context<AgentContext | null>) => Omit<CreateAgentContextReturnType, "AgentProvider">;
+export declare const extractAgentContext: (agentContext: React.Context<AgentContext | null>) => Omit<CreateAgentContextReturnType, "AgentProvider" | "AgentContext">;

package/dist/hooks/types.d.ts

@@ -3,10 +3,13 @@ export interface UseActorParameters extends Omit<ActorManagerParameters, "idlFac
     candidString?: string;
     canisterId: CanisterId;
     idlFactory?: IDL.InterfaceFactory;
+    disableAutoFetch?: boolean;
 }
 export interface UseActorReturn<A = BaseActor> {
     hooks: ActorHooksReturnType<A> | null;
     fetching: boolean;
     fetchError: string | null;
     authenticating: boolean;
+    initializeActor: InitializeActor;
 }
+export type InitializeActor = (idlFactory: IDL.InterfaceFactory, actorReConfig?: UseActorParameters) => void;

package/dist/hooks/useActor.js

@@ -91,7 +91,7 @@ const agent_1 = require("../context/agent");
  * ```
  */
 const useActor = (config) => {
-    const { canisterId, candidString, idlFactory: maybeIdlFactory } = config, actorConfig = __rest(config, ["canisterId", "candidString", "idlFactory"]);
+    const { canisterId, candidString, idlFactory: maybeIdlFactory, disableAutoFetch } = config, actorConfig = __rest(config, ["canisterId", "candidString", "idlFactory", "disableAutoFetch"]);
     if (!canisterId) {
         throw new Error("canisterId is required");
     }
@@ -106,7 +106,7 @@ const useActor = (config) => {
         fetching: false,
         fetchError: null,
     });
-    const candidAdapter = (0, adapter_1.useCandidAdapter)();
+    const candidAdapter = (0, react_1.useContext)(adapter_1.CandidAdapterContext);
     const authenticating = (0, agent_1.useAuthState)().authenticating;
     const fetchCandid = (0, react_1.useCallback)(() => __awaiter(void 0, void 0, void 0, function* () {
         if (fetching)
@@ -150,19 +150,26 @@ const useActor = (config) => {
         }
     }), [candidString]);
     const agentManager = (0, agent_1.useAgentManager)();
-    const initialActorManager = (0, react_1.useCallback)((idlFactory) => {
+    const initializeActor = (0, react_1.useCallback)((idlFactory, actorReConfig) => {
         if (authenticating || !idlFactory)
             return;
-        const actorManager = (0, core_1.createActorManager)(Object.assign({ agentManager,
+        const newActorManager = (0, core_1.createActorManager)(Object.assign(Object.assign({ agentManager,
             idlFactory,
-            canisterId }, actorConfig));
-        setActorManager(actorManager);
+            canisterId }, actorConfig), actorReConfig));
+        setActorManager(newActorManager);
     }, [canisterId, agentManager, authenticating]);
     const handleActorInitialization = (0, react_1.useCallback)(() => __awaiter(void 0, void 0, void 0, function* () {
         if (authenticating)
             return;
         if (maybeIdlFactory) {
-            initialActorManager(maybeIdlFactory);
+            initializeActor(maybeIdlFactory);
+            return;
+        }
+        if (disableAutoFetch) {
+            setState({
+                fetchError: "Candid interface not fetched!",
+                fetching: false,
+            });
             return;
         }
         if (!candidAdapter) {
@@ -175,8 +182,10 @@ const useActor = (config) => {
         else {
             idlFactory = yield fetchCandid();
         }
-        initialActorManager(idlFactory);
-    }), [fetchCandid, evaluateCandid, maybeIdlFactory, initialActorManager]);
+        if (!idlFactory)
+            return;
+        initializeActor(idlFactory);
+    }), [fetchCandid, evaluateCandid, maybeIdlFactory, initializeActor]);
     (0, react_1.useEffect)(() => {
         handleActorInitialization();
     }, [handleActorInitialization]);
@@ -185,6 +194,6 @@ const useActor = (config) => {
             return null;
         return (0, helpers_1.actorHooks)(actorManager);
     }, [actorManager]);
-    return { hooks, authenticating, fetching, fetchError };
+    return { hooks, authenticating, fetching, fetchError, initializeActor };
 };
 exports.useActor = useActor;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ic-reactor/react",
-  "version": "1.7.8",
+  "version": "1.8.0",
   "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.7.5",
+    "@ic-reactor/core": "^1.8.0",
     "zustand-utils": "^1.3"
   },
   "peerDependencies": {
@@ -47,5 +47,5 @@
     "react": ">=16.8",
     "zustand": "4.5"
   },
-  "gitHead": "926af41a399b6ef28f1c5a7c419c22e3b7baa6db"
+  "gitHead": "35908ed17cea4c78169b00b9c4707393381041e1"
 }