@ic-reactor/core 2.0.0-alpha.0 → 2.0.1

package/README.md

@@ -19,7 +19,7 @@ yarn add @ic-reactor/core
 or you can use the UMD version:
 
 ```html
-<script src="https://github.com/B3Pay/ic-reactor/releases/download/v1.10.1/ic-reactor-core.min.js"></script>
+<script src="https://github.com/B3Pay/ic-reactor/releases/download/v2.0.0/ic-reactor-core.min.js"></script>
 ```
 
 ### Using `createReactorCore`

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

@@ -14,11 +14,7 @@ export declare class ActorManager<A = BaseActor> {
     visitFunction: VisitService<A>;
     methodAttributes: MethodAttributes<A>;
     private updateState;
-    updateMethodState: (method: FunctionName<A>, hash: string, newState: Partial<{
-        data: ActorMethodReturnType<A[FunctionName<A>]> | undefined;
-        loading: boolean;
-        error: Error | undefined;
-    }>) => void;
+    updateMethodState: (method: FunctionName<A>, hash: string, newState: Partial<ActorMethodState<A, typeof method>[string]>) => void;
     constructor(actorConfig: ActorManagerParameters);
     initialize: (options?: UpdateAgentParameters) => Promise<void>;
     extractInterface: () => IDL.ServiceClass;
@@ -28,6 +24,7 @@ export declare class ActorManager<A = BaseActor> {
     private _getActorMethod;
     callMethod: <M extends FunctionName<A>>(functionName: M, ...args: ActorMethodParameters<A[M]>) => Promise<ActorMethodReturnType<A[M]>>;
     callMethodWithOptions: (options: CallConfig) => <M extends FunctionName<A>>(functionName: M, ...args: ActorMethodParameters<A[M]>) => Promise<ActorMethodReturnType<A[M]>>;
+    call: <M extends FunctionName<A>>(functionName: M, ...args: ActorMethodParameters<A[M]>) => Promise<ActorMethodReturnType<A[M]>>;
     get agentManager(): AgentManager;
     getActor: () => A | null;
     getState: ActorStore<A>["getState"];

package/dist/classes/actor/index.js

@@ -1,161 +1,68 @@
 "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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ActorManager = void 0;
 /* eslint-disable no-console */
 const agent_1 = require("@dfinity/agent");
 const helper_1 = require("../../utils/helper");
 const candid_1 = require("@dfinity/candid");
-const utils_1 = require("../../utils");
+const ACTOR_INITIAL_STATE = {
+    name: "",
+    version: 0,
+    methodState: {},
+    initializing: false,
+    isInitializing: false,
+    initialized: false,
+    isInitialized: false,
+    error: undefined,
+};
 class ActorManager {
-    constructor(actorConfig) {
-        this._actor = null;
-        this._subscribers = [];
-        this.updateState = (newState, action) => {
-            this.actorStore.setState((state) => (Object.assign(Object.assign({}, state), newState)), false, action);
-        };
-        this.updateMethodState = (method, hash, newState) => {
-            this.actorStore.setState((state) => {
-                const methodState = state.methodState[method] || {};
-                const currentMethodState = methodState[hash] || DEFAULT_STATE;
-                const updatedMethodState = Object.assign(Object.assign({}, methodState), { [hash]: Object.assign(Object.assign({}, currentMethodState), newState) });
-                return Object.assign(Object.assign({}, state), { methodState: Object.assign(Object.assign({}, state.methodState), { [method]: updatedMethodState }) });
-            }, false, method);
-        };
-        this.initialize = (options) => __awaiter(this, void 0, void 0, function* () {
-            yield this._agentManager.updateAgent(options);
-        });
-        this.extractInterface = () => {
-            return this._idlFactory({ IDL: candid_1.IDL });
-        };
-        this.extractMethodAttributes = () => {
-            const iface = this.extractInterface();
-            const methodAttributesArray = iface._fields.map(([name, func]) => ({
-                name: name,
-                attributes: {
-                    numberOfArgs: func.argTypes.length,
-                    type: ((0, helper_1.isQuery)(func) ? "query" : "update"),
-                    validate: (arg) => func.argTypes.some((t, i) => t.covariant(arg[i])),
+    _actor = null;
+    _idlFactory;
+    _agentManager;
+    _unsubscribeAgent;
+    _subscribers = [];
+    canisterId;
+    actorStore;
+    visitFunction;
+    methodAttributes;
+    updateState = (newState, action) => {
+        this.actorStore.setState((state) => ({ ...state, ...newState }), false, action);
+    };
+    updateMethodState = (method, hash, newState) => {
+        const actionName = `${method}:${newState.error ? "error" : newState.isLoading ? "loading..." : "loaded"}`;
+        this.actorStore.setState((state) => {
+            const methodState = state.methodState[method] || {};
+            const currentMethodState = methodState[hash] || DEFAULT_STATE;
+            const updatedMethodState = {
+                ...methodState,
+                [hash]: { ...currentMethodState, ...newState },
+            };
+            return {
+                ...state,
+                methodState: {
+                    ...state.methodState,
+                    [method]: updatedMethodState,
                 },
-            }));
-            methodAttributesArray.sort((a, b) => {
-                if (a.attributes.type === b.attributes.type) {
-                    return a.attributes.numberOfArgs - b.attributes.numberOfArgs;
-                }
-                return a.attributes.type === "query" ? -1 : 1;
-            });
-            return methodAttributesArray.reduce((acc, { name, attributes }) => {
-                acc[name] = attributes;
-                return acc;
-            }, {});
-        };
-        this.extractVisitor = () => {
-            const iface = this.extractInterface();
-            return iface._fields.reduce((acc, service) => {
-                const functionName = service[0];
-                const type = service[1];
-                const visit = ((extractorClass, data) => {
-                    return type.accept(extractorClass, data);
-                });
-                acc[functionName] = visit;
-                return acc;
-            }, {});
-        };
-        this.initializeActor = (agent) => {
-            const network = this._agentManager.getNetwork();
-            console.info(`Initializing actor ${this.canisterId} on ${network} network`);
-            const { _idlFactory, canisterId } = this;
-            this.updateState({
-                initializing: true,
-                initialized: false,
-                methodState: {},
-            }, "initializing");
-            try {
-                if (!agent) {
-                    throw new Error("Agent not initialized");
-                }
-                this._actor = agent_1.Actor.createActor(_idlFactory, {
-                    agent,
-                    canisterId,
-                });
-                if (!this._actor) {
-                    throw new Error("Failed to initialize actor");
-                }
-                this.updateState({
-                    initializing: false,
-                    initialized: true,
-                }, "initialized");
-            }
-            catch (error) {
-                console.error("Error in initializeActor:", error);
-                this.updateState({ error: error, initializing: false }, "error");
-            }
-        };
-        this._getActorMethod = (functionName) => {
-            if (!this._actor) {
-                throw new Error("Actor not initialized");
-            }
-            if (!this._actor[functionName] ||
-                typeof this._actor[functionName] !== "function") {
-                throw new Error(`Method ${String(functionName)} not found`);
-            }
-            return this._actor[functionName];
-        };
-        this.callMethod = (functionName, ...args) => __awaiter(this, void 0, void 0, function* () {
-            const method = this._getActorMethod(functionName);
-            const data = yield method(...args);
-            return data;
-        });
-        this.callMethodWithOptions = (options) => {
-            return (functionName, ...args) => __awaiter(this, void 0, void 0, function* () {
-                const method = this._getActorMethod(functionName);
-                const data = yield method.withOptions(options)(...args);
-                return data;
-            });
-        };
-        // actor store
-        this.getActor = () => {
-            return this._actor;
-        };
-        this.getState = () => {
-            return this.actorStore.getState();
-        };
-        this.subscribeActorState = (listener) => {
-            const unsubscribe = this.actorStore.subscribe(listener);
-            this._subscribers.push(unsubscribe);
-            return unsubscribe;
-        };
-        this.setState = (updater) => {
-            return this.actorStore.setState(updater);
-        };
-        this.cleanup = () => {
-            this._unsubscribeAgent();
-            this._subscribers.forEach((unsubscribe) => unsubscribe());
-        };
+            };
+        }, false, actionName);
+    };
+    constructor(actorConfig) {
         const { agentManager, idlFactory, canisterId, name = canisterId.toString(), withVisitor = false, withDevtools = false, initializeOnCreate = true, } = actorConfig;
         if (!canisterId) {
-            throw new Error("CanisterId is required!");
+            throw new agent_1.AgentError(new agent_1.UnexpectedErrorCode("CanisterId is required!"), agent_1.ErrorKindEnum.Unknown);
         }
         this.canisterId = canisterId.toString();
         if (!idlFactory) {
-            throw new Error("IDLFactory is required!");
+            throw new agent_1.AgentError(new agent_1.UnexpectedErrorCode("IDLFactory is required!"), agent_1.ErrorKindEnum.Unknown);
         }
         this._idlFactory = idlFactory;
         this.methodAttributes = this.extractMethodAttributes();
         if (!agentManager) {
-            throw new Error("AgentManager is required!");
+            throw new agent_1.AgentError(new agent_1.UnexpectedErrorCode("AgentManager is required!"), agent_1.ErrorKindEnum.Unknown);
         }
         this._agentManager = agentManager;
         // Initialize stores
-        this.actorStore = (0, helper_1.createStoreWithOptionalDevtools)(Object.assign(Object.assign({}, utils_1.ACTOR_INITIAL_STATE), { name }), {
+        this.actorStore = (0, helper_1.createStoreWithOptionalDevtools)({ ...ACTOR_INITIAL_STATE, name }, {
             withDevtools,
             name: "reactor-actor",
             store: canisterId.toString(),
@@ -168,15 +75,171 @@ class ActorManager {
             this.visitFunction = emptyVisitor;
         }
     }
+    initialize = async (options) => {
+        await this._agentManager.updateAgent(options);
+    };
+    extractInterface = () => {
+        return this._idlFactory({ IDL: candid_1.IDL });
+    };
+    extractMethodAttributes = () => {
+        const iface = this.extractInterface();
+        const methodAttributesArray = iface._fields.map(([name, func]) => ({
+            name: name,
+            attributes: {
+                numberOfArgs: func.argTypes.length,
+                type: ((0, helper_1.isQuery)(func) ? "query" : "update"),
+                validate: (arg) => func.argTypes.some((t, i) => t.covariant(arg[i])),
+            },
+        }));
+        methodAttributesArray.sort((a, b) => {
+            if (a.attributes.type === b.attributes.type) {
+                return a.attributes.numberOfArgs - b.attributes.numberOfArgs;
+            }
+            return a.attributes.type === "query" ? -1 : 1;
+        });
+        return methodAttributesArray.reduce((acc, { name, attributes }) => {
+            acc[name] = attributes;
+            return acc;
+        }, {});
+    };
+    extractVisitor = () => {
+        const iface = this.extractInterface();
+        return iface._fields.reduce((acc, service) => {
+            const functionName = service[0];
+            const type = service[1];
+            const visit = ((extractorClass, data) => {
+                return type.accept(extractorClass, data);
+            });
+            acc[functionName] = visit;
+            return acc;
+        }, {});
+    };
+    initializeActor = (agent) => {
+        const network = this._agentManager.getNetwork();
+        console.info(`Initializing actor ${this.canisterId} on ${network} network`);
+        const { _idlFactory, canisterId } = this;
+        this.updateState({
+            initializing: true,
+            isInitializing: true,
+            initialized: false,
+            isInitialized: false,
+            methodState: {},
+        }, "initializing");
+        try {
+            if (!agent) {
+                throw new agent_1.AgentError(new agent_1.UnexpectedErrorCode("Agent not initialized"), agent_1.ErrorKindEnum.Unknown);
+            }
+            this._actor = agent_1.Actor.createActor(_idlFactory, {
+                agent,
+                canisterId,
+            });
+            if (!this._actor) {
+                throw new agent_1.AgentError(new agent_1.UnexpectedErrorCode("Failed to initialize actor"), agent_1.ErrorKindEnum.Unknown);
+            }
+            this.updateState({
+                initializing: false,
+                isInitializing: false,
+                initialized: true,
+                isInitialized: true,
+            }, "initialized");
+        }
+        catch (error) {
+            console.error("Error in initializeActor:", error);
+            this.updateState({
+                error: error,
+                initializing: false,
+                isInitializing: false,
+            }, "error");
+        }
+    };
+    _getActorMethod = (functionName) => {
+        if (!this._actor) {
+            throw new agent_1.AgentError(new agent_1.UnexpectedErrorCode("Actor not initialized"), agent_1.ErrorKindEnum.Unknown);
+        }
+        if (!this._actor[functionName] ||
+            typeof this._actor[functionName] !== "function") {
+            throw new agent_1.AgentError(new agent_1.UnexpectedErrorCode(`Method ${String(functionName)} not found`), agent_1.ErrorKindEnum.Unknown);
+        }
+        return this._actor[functionName];
+    };
+    callMethod = async (functionName, ...args) => {
+        const method = this._getActorMethod(functionName);
+        const data = await method(...args);
+        return data;
+    };
+    callMethodWithOptions = (options) => {
+        return async (functionName, ...args) => {
+            const method = this._getActorMethod(functionName);
+            const data = await method.withOptions(options)(...args);
+            return data;
+        };
+    };
+    call = async (functionName, ...args) => {
+        const requestHash = (0, helper_1.generateRequestHash)(args);
+        try {
+            this.updateMethodState(functionName, requestHash, {
+                loading: true,
+                isLoading: true,
+                error: undefined,
+            });
+            const data = await this.callMethod(functionName, ...args);
+            this.updateMethodState(functionName, requestHash, {
+                loading: false,
+                isLoading: false,
+                data,
+            });
+            return data;
+        }
+        catch (error) {
+            this.updateMethodState(functionName, requestHash, {
+                loading: false,
+                isLoading: false,
+                error: error,
+                data: undefined,
+            });
+            throw error;
+        }
+    };
     // agent store
     get agentManager() {
         return this._agentManager;
     }
+    // actor store
+    getActor = () => {
+        return this._actor;
+    };
+    getState = () => {
+        return this.actorStore.getState();
+    };
+    // @ts-expect-error: Overrides subscribe method signature
+    subscribeActorState = (selectorOrListener, listener, options) => {
+        let unsubscribe = helper_1.noop;
+        if (listener) {
+            unsubscribe = this.actorStore.subscribe(selectorOrListener, listener, options);
+        }
+        else {
+            unsubscribe = this.actorStore.subscribe(selectorOrListener);
+        }
+        this._subscribers.push(unsubscribe);
+        return unsubscribe;
+    };
+    setState = (updater) => {
+        return this.actorStore.setState(updater);
+    };
+    cleanup = () => {
+        this._unsubscribeAgent();
+        this._subscribers.forEach((unsubscribe) => unsubscribe());
+    };
 }
 exports.ActorManager = ActorManager;
 const emptyVisitor = new Proxy({}, {
     get: function (_, prop) {
-        throw new Error(`Cannot visit function "${String(prop)}" without initializing the actor with the visitor option, please set the withVisitor option to true when creating the actor manager.`);
+        throw new agent_1.AgentError(new agent_1.UnexpectedErrorCode(`Cannot visit function "${String(prop)}" without initializing the actor with the visitor option, please set the withVisitor option to true when creating the actor manager.`), agent_1.ErrorKindEnum.Unknown);
     },
 });
-const DEFAULT_STATE = { data: undefined, error: undefined, loading: false };
+const DEFAULT_STATE = {
+    data: undefined,
+    error: undefined,
+    loading: false,
+    isLoading: false,
+};

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

@@ -1,6 +1,6 @@
 import type { AgentManager } from "../agent";
-import type { IDL, StoreApiWithDevtools, ActorMethod, ActorSubclass, Principal } from "../../types";
-import { CallConfig } from "@dfinity/agent";
+import type { IDL, ActorMethod, ActorSubclass, Principal, StoreWithAllMiddleware } from "../../types";
+import type { AgentError, CallConfig } from "@dfinity/agent";
 export interface DefaultActorType {
     [key: string]: ActorMethod;
 }
@@ -26,11 +26,34 @@ export type VisitService<A = BaseActor, M extends FunctionName<A> = FunctionName
 };
 export type ActorMethodParameters<T> = T extends ActorMethod<infer Args, any> ? Args : never;
 export type ActorMethodReturnType<T> = T extends ActorMethod<any, infer Ret> ? Ret : never;
+/**
+ * Interface representing the state of each actor method.
+ *
+ * @template A - The actor type, defaulting to `BaseActor`.
+ * @template M - A specific method name of the actor.
+ */
 export interface ActorMethodState<A = BaseActor, M extends FunctionName<A> = FunctionName<A>> {
+    /**
+     * The per-method state object, keyed by the method name.
+     */
     [key: string]: {
+        /**
+         * The data returned from the actor method call, if available.
+         */
         data: ActorMethodReturnType<A[M]> | undefined;
+        /**
+         * @deprecated Use `isLoading` instead.
+         * Flag indicating whether the actor method is in progress.
+         */
         loading: boolean;
-        error: Error | undefined;
+        /**
+         * Flag indicating whether the actor method is in progress.
+         */
+        isLoading: boolean;
+        /**
+         * Error thrown during the actor method invocation, if any.
+         */
+        error: AgentError | undefined;
     };
 }
 export type ActorMethodStates<A = BaseActor> = {
@@ -40,15 +63,48 @@ export type ActorMethodType<A, M extends keyof A> = {
     (...args: ActorMethodParameters<A[M]>): Promise<ActorMethodReturnType<A[M]>>;
     withOptions: (options: CallConfig) => (...args: ActorMethodParameters<A[M]>) => Promise<ActorMethodReturnType<A[M]>>;
 };
+/**
+ * Represents the state of an actor.
+ *
+ * @template A - The type of the actor, defaults to `BaseActor`.
+ */
 export type ActorState<A = BaseActor> = {
+    /**
+     * The name of the actor.
+     */
     name: string;
+    /**
+     * The version of the actor.
+     */
     version: number;
+    /**
+     * @deprecated Use `isInitialized` instead.
+     * Indicates whether the actor is initialized.
+     */
     initialized: boolean;
+    /**
+     * Indicates whether the actor is initialized.
+     */
+    isInitialized: boolean;
+    /**
+     * @deprecated Use `isInitializing` instead.
+     * Indicates whether the actor is in the process of initializing.
+     */
     initializing: boolean;
-    error: Error | undefined;
+    /**
+     * Indicates whether the actor is in the process of initializing.
+     */
+    isInitializing: boolean;
+    /**
+     * The error associated with the actor, if any.
+     */
+    error: AgentError | undefined;
+    /**
+     * The state of the actor's methods.
+     */
     methodState: ActorMethodStates<A>;
 };
-export type ActorStore<A = BaseActor> = StoreApiWithDevtools<ActorState<A>>;
+export type ActorStore<A = BaseActor> = StoreWithAllMiddleware<ActorState<A>>;
 export type CallActorMethod<A = BaseActor> = <M extends FunctionName<A> = FunctionName<A>>(functionName: M, ...args: ActorMethodParameters<A[M]>) => Promise<ActorMethodReturnType<A[M]>>;
 export type MethodAttributes<A = BaseActor> = Record<FunctionName<A>, {
     type: FunctionType;

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

@@ -12,7 +12,7 @@ export declare class CandidAdapter {
     getCandidDefinition(canisterId: CanisterId): Promise<CandidDefenition>;
     getFromMetadata(canisterId: CanisterId): Promise<string | undefined>;
     getFromTmpHack(canisterId: CanisterId): Promise<string>;
-    dynamicEvalJs(data: string): Promise<CandidDefenition>;
+    evaluateCandidDefinition(data: string): Promise<CandidDefenition>;
     fetchDidTojs(candidSource: string, didjsCanisterId?: string): Promise<[string]>;
     parseDidToJs(candidSource: string): string;
     validateIDL(candidSource: string): boolean;