@ic-reactor/react 2.0.0-alpha.0 → 2.0.0

package/dist/context/actor/create.js

@@ -1,24 +1,13 @@
 "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;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createActorContext = void 0;
+exports.createActorContext = createActorContext;
 const react_1 = __importDefault(require("react"));
 const useActor_1 = require("../../hooks/useActor");
 const extractActorContext_1 = require("../../helpers/extractActorContext");
-const agent_1 = require("../agent");
+const useActorManager_1 = require("../../hooks/useActorManager");
 /**
  * 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.
@@ -80,31 +69,34 @@ const agent_1 = require("../agent");
  * it provides a type-safe and efficient way to manage actor state and interactions.
  */
 function createActorContext(contextConfig = {}) {
-    const { canisterId: defaultCanisterId } = contextConfig, defaultConfig = __rest(contextConfig, ["canisterId"]);
+    const { canisterId: defaultCanisterId, ...defaultConfig } = contextConfig;
     const ActorContext = react_1.default.createContext(null);
-    const ActorProvider = (_a) => {
-        var { children, fetchingComponent, canisterId = defaultCanisterId, errorComponent = (error) => react_1.default.createElement("div", null, error), loadingComponent = react_1.default.createElement("div", null, "Loading canister..."), authenticatingComponent = react_1.default.createElement("div", null, "Authenticating...") } = _a, restConfig = __rest(_a, ["children", "fetchingComponent", "canisterId", "errorComponent", "loadingComponent", "authenticatingComponent"]);
+    const ActorProvider = ({ children, fetchingComponent, canisterId = defaultCanisterId, errorComponent = (error) => react_1.default.createElement("div", null, error), loadingComponent = react_1.default.createElement("div", null, "Loading canister..."), authenticatingComponent = react_1.default.createElement("div", null, "Authenticating..."), ...restConfig }) => {
         if (!canisterId) {
             throw new Error("canisterId is required");
         }
-        const config = react_1.default.useMemo(() => (Object.assign(Object.assign({}, defaultConfig), restConfig)), [defaultConfig, restConfig]);
-        const agentManager = (0, agent_1.useAgentManager)();
-        const { fetchError, authenticating, initializeActor, hooks } = (0, useActor_1.useActor)(Object.assign({ agentManager,
-            canisterId }, config));
+        const config = react_1.default.useMemo(() => ({
+            ...defaultConfig,
+            ...restConfig,
+        }), [defaultConfig, restConfig]);
+        const { fetchError, isAuthenticating: authenticating, initializeActor, hooks, } = (0, useActor_1.useActor)({
+            canisterId,
+            ...config,
+        });
         const useInitializeActor = react_1.default.useCallback(() => {
             return initializeActor;
         }, [initializeActor]);
         const ActorChildren = ({ useActorState }) => {
-            const { initializing, initialized, error } = useActorState();
-            return initializing
+            const { isInitializing, isInitialized, error } = useActorState();
+            return isInitializing
                 ? loadingComponent
-                : initialized
+                : isInitialized
                     ? children
                     : error
                         ? errorComponent(error.message)
                         : null;
         };
-        return (react_1.default.createElement(ActorContext.Provider, { value: Object.assign(Object.assign({}, hooks), { useInitializeActor }) },
+        return (react_1.default.createElement(ActorContext.Provider, { value: { ...hooks, useInitializeActor } },
             fetchingComponent,
             hooks === null ? (fetchError ? (errorComponent(fetchError)) : authenticating ? (authenticatingComponent) : (loadingComponent)) : (react_1.default.createElement(ActorChildren, { useActorState: hooks.useActorState }, children))));
     };
@@ -112,7 +104,16 @@ function createActorContext(contextConfig = {}) {
     const ActorHookProvider = ({ hooks, children, }) => {
         return (react_1.default.createElement(ActorContext.Provider, { value: hooks }, children));
     };
-    return Object.assign({ ActorProvider,
-        ActorHookProvider }, (0, extractActorContext_1.extractActorContext)(ActorContext));
+    const ActorManagerProvider = ({ actorManager, children, }) => {
+        const { hooks } = (0, useActorManager_1.useActorManager)({
+            actorManager,
+        });
+        return (react_1.default.createElement(ActorContext.Provider, { value: hooks }, children));
+    };
+    return {
+        ActorProvider,
+        ActorHookProvider,
+        ActorManagerProvider,
+        ...(0, extractActorContext_1.extractActorContext)(ActorContext),
+    };
 }
-exports.createActorContext = createActorContext;

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

@@ -1,4 +1,4 @@
 /**
  *
  */
-export declare function useActorInterface(): import("@dfinity/candid/lib/cjs/idl").ServiceClass;
+export declare function useActorInterface(): import("@dfinity/candid/lib/esm/idl").ServiceClass;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useActorInterface = void 0;
+exports.useActorInterface = useActorInterface;
 const __1 = require("..");
 /**
  *
@@ -8,4 +8,3 @@ const __1 = require("..");
 function useActorInterface() {
     return __1.ActorHooks.useActorInterface();
 }
-exports.useActorInterface = useActorInterface;

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

@@ -7,15 +7,15 @@ import type { BaseActor, FunctionName, UseMethodParameters, UseMethodReturnType
  * @example
  * ```tsx
  * function MethodCallComponent() {
- *   const { call, data, loading } = useMethod({
+ *   const { call, data, isLoading } = useMethod({
  *      functionName: 'updateUserProfile',
  *      args: ['123', { name: 'John Doe' }],
- *      onLoading: (loading) => console.log('Loading:', loading),
+ *      onLoading: (isLoading) => console.log('Loading:', isLoading),
  *      onError: (error) => console.error('Error:', error),
  *      onSuccess: (data) => console.log('Success:', data),
  *   });
  *
- *  if (loading) return <p>Updating profile...</p>;
+ *  if (isLoading) return <p>Updating profile...</p>;
  *
  *  return (
  *    <div>

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useMethod = void 0;
+exports.useMethod = useMethod;
 const __1 = require("..");
 /**
  * Hook for making dynamically update or query calls to actors, handling loading states, and managing errors. It supports custom event handlers for loading, success, and error events.
@@ -10,15 +10,15 @@ const __1 = require("..");
  * @example
  * ```tsx
  * function MethodCallComponent() {
- *   const { call, data, loading } = useMethod({
+ *   const { call, data, isLoading } = useMethod({
  *      functionName: 'updateUserProfile',
  *      args: ['123', { name: 'John Doe' }],
- *      onLoading: (loading) => console.log('Loading:', loading),
+ *      onLoading: (isLoading) => console.log('Loading:', isLoading),
  *      onError: (error) => console.error('Error:', error),
  *      onSuccess: (data) => console.log('Success:', data),
  *   });
  *
- *  if (loading) return <p>Updating profile...</p>;
+ *  if (isLoading) return <p>Updating profile...</p>;
  *
  *  return (
  *    <div>
@@ -32,4 +32,3 @@ const __1 = require("..");
 function useMethod(args) {
     return __1.ActorHooks.useMethod(args);
 }
-exports.useMethod = useMethod;

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

@@ -1,20 +1,20 @@
-import type { BaseActor, FunctionName, UseQueryCallParameters, UseSharedCallReturnType } from "../../../types";
+import type { BaseActor, FunctionName, UseQueryCallParameters, UseQueryCallReturnType } from "../../../types";
 /**
  * Hook for making query calls to actors. It supports automatic refetching on component mount and at specified intervals.
  *
  * @param args {@link UseQueryCallParameters}.
- * @returns object {@link UseSharedCallReturnType}.
+ * @returns object {@link UseQueryCallReturnType}.
  * @example
  * ```tsx
  * function QueryCallComponent() {
- *    const { call, data, loading } = useQueryCall({
+ *    const { call, data, isLoading } = useQueryCall({
  *      functionName: 'getUserProfile',
  *      args: ['123'],
  *      refetchOnMount: true,
  *      refetchInterval: 5000, // refetch every 5 seconds
  *    });
  *
- *    if (loading) return <p>Loading profile...</p>;
+ *    if (isLoading) return <p>isLoading profile...</p>;
  *
  *    return (
  *      <div>
@@ -25,4 +25,4 @@ import type { BaseActor, FunctionName, UseQueryCallParameters, UseSharedCallRetu
  * }
  * ```
  */
-export declare function useQueryCall<A = BaseActor, M extends FunctionName<A> = FunctionName<A>>(args: UseQueryCallParameters<A, M>): UseSharedCallReturnType<A, M>;
+export declare function useQueryCall<A = BaseActor, M extends FunctionName<A> = FunctionName<A>>(args: UseQueryCallParameters<A, M>): UseQueryCallReturnType<A, M>;

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

@@ -1,23 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useQueryCall = void 0;
+exports.useQueryCall = useQueryCall;
 const __1 = require("..");
 /**
  * Hook for making query calls to actors. It supports automatic refetching on component mount and at specified intervals.
  *
  * @param args {@link UseQueryCallParameters}.
- * @returns object {@link UseSharedCallReturnType}.
+ * @returns object {@link UseQueryCallReturnType}.
  * @example
  * ```tsx
  * function QueryCallComponent() {
- *    const { call, data, loading } = useQueryCall({
+ *    const { call, data, isLoading } = useQueryCall({
  *      functionName: 'getUserProfile',
  *      args: ['123'],
  *      refetchOnMount: true,
  *      refetchInterval: 5000, // refetch every 5 seconds
  *    });
  *
- *    if (loading) return <p>Loading profile...</p>;
+ *    if (isLoading) return <p>isLoading profile...</p>;
  *
  *    return (
  *      <div>
@@ -31,4 +31,3 @@ const __1 = require("..");
 function useQueryCall(args) {
     return __1.ActorHooks.useQueryCall(args);
 }
-exports.useQueryCall = useQueryCall;

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

@@ -1,21 +1,21 @@
-import type { BaseActor, FunctionName, UseUpdateCallParameters, UseSharedCallReturnType } from "../../../types";
+import type { BaseActor, FunctionName, UseUpdateCallParameters, UseUpdateCallReturnType } from "../../../types";
 /**
  * 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 args {@link UseUpdateCallParameters}.
- * @returns object {@link UseSharedCallReturnType}.
+ * @returns object {@link UseUpdateCallReturnType}.
  * @example
  * ```tsx
  * function UpdateCallComponent() {
- *   const { call, data, loading } = useUpdateCall({
+ *   const { call, data, isLoading } = useUpdateCall({
  *      functionName: 'updateUserProfile',
  *      args: ['123', { name: 'John Doe' }],
- *      onLoading: (loading) => console.log('Loading:', loading),
+ *      onLoading: (isLoading) => console.log('Loading:', isLoading),
  *      onError: (error) => console.error('Error:', error),
  *      onSuccess: (data) => console.log('Success:', data),
  *   });
  *
- *  if (loading) return <p>Updating profile...</p>;
+ *  if (isLoading) return <p>Updating profile...</p>;
  *
  *  return (
  *    <div>
@@ -26,4 +26,4 @@ import type { BaseActor, FunctionName, UseUpdateCallParameters, UseSharedCallRet
  * }
  * ```
  */
-export declare function useUpdateCall<A = BaseActor, M extends FunctionName<A> = FunctionName<A>>(args: UseUpdateCallParameters<A, M>): UseSharedCallReturnType<A, M>;
+export declare function useUpdateCall<A = BaseActor, M extends FunctionName<A> = FunctionName<A>>(args: UseUpdateCallParameters<A, M>): UseUpdateCallReturnType<A, M>;

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

@@ -1,24 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useUpdateCall = void 0;
+exports.useUpdateCall = useUpdateCall;
 const __1 = require("..");
 /**
  * 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 args {@link UseUpdateCallParameters}.
- * @returns object {@link UseSharedCallReturnType}.
+ * @returns object {@link UseUpdateCallReturnType}.
  * @example
  * ```tsx
  * function UpdateCallComponent() {
- *   const { call, data, loading } = useUpdateCall({
+ *   const { call, data, isLoading } = useUpdateCall({
  *      functionName: 'updateUserProfile',
  *      args: ['123', { name: 'John Doe' }],
- *      onLoading: (loading) => console.log('Loading:', loading),
+ *      onLoading: (isLoading) => console.log('Loading:', isLoading),
  *      onError: (error) => console.error('Error:', error),
  *      onSuccess: (data) => console.log('Success:', data),
  *   });
  *
- *  if (loading) return <p>Updating profile...</p>;
+ *  if (isLoading) return <p>Updating profile...</p>;
  *
  *  return (
  *    <div>
@@ -32,4 +32,3 @@ const __1 = require("..");
 function useUpdateCall(args) {
     return __1.ActorHooks.useUpdateCall(args);
 }
-exports.useUpdateCall = useUpdateCall;

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

@@ -5,4 +5,4 @@ import type { FunctionName, BaseActor } from "../../../types";
  * @param functionName The name of the actor method to visit.
  * @returns The visit service function for the specified method.
  */
-export declare function useVisitMethod<A = BaseActor>(functionName: FunctionName<A>): <V extends import("@dfinity/candid/lib/cjs/idl").Visitor<unknown, unknown>>(extractorClass: V, data: import("@ic-reactor/core/dist/classes/actor/types").VisitorType<V>["data"]) => ReturnType<V["visitFunc"]>;
+export declare function useVisitMethod<A = BaseActor>(functionName: FunctionName<A>): <V extends import("@dfinity/candid/lib/esm/idl").Visitor<unknown, unknown>>(extractorClass: V, data: import("@ic-reactor/core/dist/classes/actor/types").VisitorType<V>["data"]) => ReturnType<V["visitFunc"]>;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useVisitMethod = void 0;
+exports.useVisitMethod = useVisitMethod;
 const __1 = require("..");
 /**
  * Memoizes and returns a visit service function for a specific actor method.
@@ -11,4 +11,3 @@ const __1 = require("..");
 function useVisitMethod(functionName) {
     return __1.ActorHooks.useVisitMethod(functionName);
 }
-exports.useVisitMethod = useVisitMethod;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useVisitService = void 0;
+exports.useVisitService = useVisitService;
 const __1 = require("..");
 /**
  * Memoizes and returns a visit service function for a specific actor method.
@@ -11,4 +11,3 @@ const __1 = require("..");
 function useVisitService() {
     return __1.ActorHooks.useVisitService();
 }
-exports.useVisitService = useVisitService;

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

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 /**
  * `ActorProvider` is a React functional component that serves as a context provider for IC actor interactions within a React application.
  * It wraps child components, providing them access to actor-specific hooks and functionalities based on the provided canister ID and configuration.
@@ -48,3 +47,25 @@ export declare const ActorProvider: import("react").FC<import("./types").ActorPr
  * This setup ensures that `YourComponent` and any of its children can interact with the specified IC actor hooks through the context provided by `ActorHookProvider`.
  */
 export declare const ActorHookProvider: import("react").FC<import("./types").ActorHookProviderProps<import("@ic-reactor/core/dist/types").BaseActor>>;
+/**
+ * `ActorManagerProvider` is a React functional component that serves as a context provider for IC actor managers within a React application.
+ * It wraps child components, providing them access to actor-specific manager functionalities based on the provided actor manager and configuration.
+ *
+ * Props:
+ * - `actorManager`: ActorManager - The actor manager object containing the actor manager functionalities.
+ * - `children`: React Node - The child components that will have access to the actor manager context.
+ *
+ * Behavior:
+ * - Validates the presence of the `actorManager`. Throws an error if it is missing, ensuring that the actor manager is always available for actor operations.
+ * - Utilizes `useMemo` to memoize the `actorManager`, optimizing for performance by avoiding unnecessary recalculations.
+ * - Renders the child components once the `actorManager` is available, effectively providing them access to the actor manager context.
+ *
+ * @example
+ * ```jsx
+ * <ActorManagerProvider actorManager={yourActorManager}>
+ *   <YourComponent />
+ * </ActorManagerProvider>
+ * ```
+ * This setup ensures that `YourComponent` and any of its children can interact with the specified IC actor manager through the context provided by `ActorManagerProvider`.
+ */
+export declare const ActorManagerProvider: import("react").FC<import("./types").ActorManagerProviderProps<import("@ic-reactor/core/dist/types").BaseActor>>;

package/dist/context/actor/provider.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ActorHookProvider = exports.ActorProvider = void 0;
+exports.ActorManagerProvider = exports.ActorHookProvider = exports.ActorProvider = void 0;
 const _1 = require(".");
 /**
  * `ActorProvider` is a React functional component that serves as a context provider for IC actor interactions within a React application.
@@ -51,3 +51,25 @@ exports.ActorProvider = _1.ActorHooks.ActorProvider;
  * This setup ensures that `YourComponent` and any of its children can interact with the specified IC actor hooks through the context provided by `ActorHookProvider`.
  */
 exports.ActorHookProvider = _1.ActorHooks.ActorHookProvider;
+/**
+ * `ActorManagerProvider` is a React functional component that serves as a context provider for IC actor managers within a React application.
+ * It wraps child components, providing them access to actor-specific manager functionalities based on the provided actor manager and configuration.
+ *
+ * Props:
+ * - `actorManager`: ActorManager - The actor manager object containing the actor manager functionalities.
+ * - `children`: React Node - The child components that will have access to the actor manager context.
+ *
+ * Behavior:
+ * - Validates the presence of the `actorManager`. Throws an error if it is missing, ensuring that the actor manager is always available for actor operations.
+ * - Utilizes `useMemo` to memoize the `actorManager`, optimizing for performance by avoiding unnecessary recalculations.
+ * - Renders the child components once the `actorManager` is available, effectively providing them access to the actor manager context.
+ *
+ * @example
+ * ```jsx
+ * <ActorManagerProvider actorManager={yourActorManager}>
+ *   <YourComponent />
+ * </ActorManagerProvider>
+ * ```
+ * This setup ensures that `YourComponent` and any of its children can interact with the specified IC actor manager through the context provided by `ActorManagerProvider`.
+ */
+exports.ActorManagerProvider = _1.ActorHooks.ActorManagerProvider;

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

@@ -1,17 +1,21 @@
-/// <reference types="react" />
-import type { IDL, ActorHooksReturnType, BaseActor, ActorManagerParameters, CanisterId, InitializeActor } from "../../types";
+import type { IDL, ActorHooksReturnType, BaseActor, ActorManagerParameters, CanisterId, InitializeActor, ActorManager } 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>>;
+    ActorManagerProvider: React.FC<ActorManagerProviderProps<A>>;
     useInitializeActor: () => InitializeActor;
 }
 export interface ActorHookProviderProps<A> {
     hooks: ActorHooksReturnType<A>;
     children?: React.ReactNode;
 }
+export interface ActorManagerProviderProps<A> {
+    children?: React.ReactNode | undefined;
+    actorManager: ActorManager<A>;
+}
 export interface ActorProviderProps extends CreateActorContextParameters {
     children?: React.ReactNode | undefined;
     candidString?: string;

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

@@ -1,2 +1,2 @@
-import type { CreateCandidAdapterCotextParameters, CreateCandidAdapterContextReturnType } from "./types";
-export declare function createAdapterContext(config?: CreateCandidAdapterCotextParameters): CreateCandidAdapterContextReturnType;
+import type { CreateCandidAdapterContextParameters, CreateCandidAdapterContextReturnType } from "./types";
+export declare function createAdapterContext(config?: CreateCandidAdapterContextParameters): CreateCandidAdapterContextReturnType;

package/dist/context/adapter/create.js

@@ -1,34 +1,14 @@
 "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;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAdapterContext = void 0;
+exports.createAdapterContext = createAdapterContext;
 const react_1 = __importDefault(require("react"));
 const agent_1 = require("../agent");
 const core_1 = require("@ic-reactor/core");
 function createAdapterContext(config = {}) {
-    const { withParser: _withParser, didjsCanisterId: _didjsCanisterId } = config, defaultConfig = __rest(config, ["withParser", "didjsCanisterId"]);
+    const { withParser: _withParser, didjsCanisterId: _didjsCanisterId, ...defaultConfig } = config;
     const CandidAdapterContext = react_1.default.createContext(null);
     const useCandidAdapter = () => {
         const context = react_1.default.useContext(CandidAdapterContext);
@@ -40,6 +20,7 @@ function createAdapterContext(config = {}) {
     const useCandidEvaluation = () => {
         const [state, setState] = react_1.default.useState({
             fetching: true,
+            isFetching: true,
             fetchError: null,
         });
         const candidAdapter = useCandidAdapter();
@@ -47,6 +28,7 @@ function createAdapterContext(config = {}) {
             setState({
                 fetchError: null,
                 fetching: false,
+                isFetching: false,
             });
             try {
                 return candidAdapter.validateIDL(candidString);
@@ -55,22 +37,29 @@ function createAdapterContext(config = {}) {
                 setState({
                     fetchError: `Error validating Candid definition, ${err}`,
                     fetching: false,
+                    isFetching: false,
                 });
+                return false;
             }
         }, []);
-        const evaluateCandid = react_1.default.useCallback((candidString) => __awaiter(this, void 0, void 0, function* () {
+        const isCandidValid = react_1.default.useCallback((candidString) => {
+            return validateCandid(candidString) !== false;
+        }, [validateCandid]);
+        const evaluateCandid = react_1.default.useCallback(async (candidString) => {
             setState({
                 fetchError: null,
                 fetching: true,
+                isFetching: true,
             });
             try {
-                const definition = yield candidAdapter.dynamicEvalJs(candidString);
-                if (typeof (definition === null || definition === void 0 ? void 0 : definition.idlFactory) !== "function") {
+                const definition = await candidAdapter.evaluateCandidDefinition(candidString);
+                if (typeof definition?.idlFactory !== "function") {
                     throw new Error("No Function found in Candid definition!");
                 }
                 setState({
                     fetchError: null,
                     fetching: false,
+                    isFetching: false,
                 });
                 return definition.idlFactory;
             }
@@ -78,17 +67,21 @@ function createAdapterContext(config = {}) {
                 setState({
                     fetchError: `Error evaluating Candid definition, ${err}`,
                     fetching: false,
+                    isFetching: false,
                 });
+                return undefined;
             }
-        }), []);
-        return Object.assign({ evaluateCandid, validateCandid }, state);
+        }, []);
+        return { evaluateCandid, isCandidValid, 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"]);
-        const config = react_1.default.useMemo(() => (Object.assign(Object.assign({}, defaultConfig), restConfig)), [defaultConfig, restConfig]);
+    const CandidAdapterProvider = ({ children, withParser = _withParser, loadingComponent = react_1.default.createElement("div", null, "Loading Parser..."), didjsCanisterId = _didjsCanisterId, ...restConfig }) => {
+        const config = react_1.default.useMemo(() => ({
+            ...defaultConfig,
+            ...restConfig,
+        }), [defaultConfig, restConfig]);
         const [initalized, setInitialized] = react_1.default.useState(false);
         const agentManager = (0, agent_1.useAgentManager)();
-        const candidAdapter = react_1.default.useMemo(() => (0, core_1.createCandidAdapter)(Object.assign({ agentManager, didjsCanisterId }, config)), [didjsCanisterId, agentManager]);
+        const candidAdapter = react_1.default.useMemo(() => (0, core_1.createCandidAdapter)({ agentManager, didjsCanisterId, ...config }), [didjsCanisterId, agentManager]);
         react_1.default.useEffect(() => {
             if (withParser) {
                 candidAdapter.initializeParser().then(() => setInitialized(true));
@@ -107,4 +100,3 @@ function createAdapterContext(config = {}) {
         useCandidAdapter,
     };
 }
-exports.createAdapterContext = createAdapterContext;

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

@@ -1,7 +1,6 @@
-/// <reference types="react" />
 /** @ignore */
 export declare const AdapterHooks: import("./types").CreateCandidAdapterContextReturnType;
-export declare const CandidAdapterContext: import("react").Context<import("./types").CandidAdapterContextType | null>;
+export declare const CandidAdapterContext: import("react").Context<import("@ic-reactor/core/dist/classes").CandidAdapter | null>;
 export * from "./provider";
 export * from "./hooks/useCandidAdapter";
 export * from "./hooks/useCandidEvaluation";

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

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 /**
  * `CandidAdapterProvider` is a React component that provides the CandidAdapter to its children.
  * It initializes the CandidAdapter with the provided options and makes it available to all children.

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

@@ -1,20 +1,47 @@
 import type { PropsWithChildren } from "react";
-import type { CandidAdapterParameters, IDL } from "../../types";
-import type { CandidAdapter } from "@ic-reactor/core/dist/classes";
-export type { CandidAdapter };
-export interface CandidAdapterContextType extends CandidAdapter {
-}
+import type { IDL } from "@dfinity/candid";
+import { CandidAdapter } from "@ic-reactor/core/dist/classes";
+import { CandidAdapterParameters } from "../../types";
+export type CandidAdapterContextType = CandidAdapter;
 export interface CandidAdapterProviderProps extends PropsWithChildren, CandidAdapterParameters {
     withParser?: boolean;
     loadingComponent?: React.ReactNode;
 }
-export interface CreateCandidAdapterCotextParameters extends CandidAdapterParameters {
+export interface CreateCandidAdapterContextParameters extends CandidAdapterParameters {
     withParser?: boolean;
 }
 export interface UseCandidEvaluationReturnType {
+    /**
+     * The error message encountered during the fetch operation, or `null` if no error occurred.
+     */
     fetchError: string | null;
+    /**
+     * @deprecated Use `isFetching` instead.
+     * Indicates whether a fetch operation is currently in progress.
+     */
     fetching: boolean;
+    /**
+     * Indicates whether a fetch operation is currently in progress.
+     */
+    isFetching: boolean;
+    /**
+     * @deprecated Use `isCandidValid` instead.
+     * Validates the provided Candid interface definition string.
+     * @param candidString - The Candid definition to validate.
+     * @returns `true` if the string is valid, `false` otherwise.
+     */
     validateCandid: (candidString: string) => boolean | undefined;
+    /**
+     * Validates the provided Candid interface definition string.
+     * @param candidString - The Candid definition to validate.
+     * @returns `true` if valid, `false` otherwise.
+     */
+    isCandidValid: (candidString: string) => boolean | undefined;
+    /**
+     * Evaluates the provided Candid interface definition string.
+     * @param candidString - The Candid definition to evaluate.
+     * @returns A promise resolving to the corresponding InterfaceFactory if the evaluation succeeds, otherwise `undefined`.
+     */
     evaluateCandid: (candidString: string) => Promise<IDL.InterfaceFactory | undefined>;
 }
 export interface CreateCandidAdapterContextReturnType {