@ic-reactor/core 1.0.2 → 1.0.4

package/dist/{actor → classes/actor}/index.d.ts

@@ -1,7 +1,6 @@
-import type { HttpAgent } from "@dfinity/agent";
-import type { CanisterId, ActorMethodArgs, ActorMethodReturnType, ActorStore, ActorManagerOptions, FunctionName, VisitService, BaseActor, ActorMethodState } from "./types";
+import type { CanisterId, ActorMethodParameters, ActorMethodReturnType, ActorStore, ActorManagerParameters, FunctionName, VisitService, BaseActor, ActorMethodState } from "./types";
 import type { AgentManager } from "../agent";
-import type { UpdateAgentOptions } from "../types";
+import type { UpdateAgentParameters } from "../../types";
 export declare class ActorManager<A = BaseActor> {
     private _actor;
     private _idlFactory;
@@ -10,20 +9,18 @@ export declare class ActorManager<A = BaseActor> {
     actorStore: ActorStore<A>;
     visitFunction: VisitService<A>;
     private initialState;
-    unsubscribeActor: () => void;
     private updateState;
     updateMethodState: (method: FunctionName<A>, hash: string, newState: Partial<{
         data: ActorMethodReturnType<A[FunctionName<A>]> | undefined;
         loading: boolean;
         error: Error | undefined;
     }>) => void;
-    constructor(actorConfig: ActorManagerOptions);
-    initialize: (options?: UpdateAgentOptions) => Promise<void>;
+    constructor(actorConfig: ActorManagerParameters);
+    initialize: (options?: UpdateAgentParameters) => Promise<void>;
     extractService(): VisitService<A>;
     private initializeActor;
-    callMethod: <M extends FunctionName<A>>(functionName: M, ...args: ActorMethodArgs<A[M]>) => Promise<ActorMethodReturnType<A[M]>>;
+    callMethod: <M extends FunctionName<A>>(functionName: M, ...args: ActorMethodParameters<A[M]>) => Promise<ActorMethodReturnType<A[M]>>;
     get agentManager(): AgentManager;
-    getAgent: () => HttpAgent;
     getActor: () => A | null;
     getState: ActorStore<A>["getState"];
     subscribeActorState: ActorStore<A>["subscribe"];

package/dist/{actor → classes/actor}/index.js

@@ -12,7 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ActorManager = void 0;
 /* eslint-disable no-console */
 const agent_1 = require("@dfinity/agent");
-const helper_1 = require("../tools/helper");
+const helper_1 = require("../../tools/helper");
 const candid_1 = require("@dfinity/candid");
 class ActorManager {
     constructor(actorConfig) {
@@ -29,11 +29,7 @@ class ActorManager {
         this.updateMethodState = (method, hash, newState) => {
             this.actorStore.setState((state) => {
                 const methodState = state.methodState[method] || {};
-                const currentMethodState = methodState[hash] || {
-                    loading: false,
-                    data: undefined,
-                    error: undefined,
-                };
+                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 }) });
             });
@@ -82,9 +78,6 @@ class ActorManager {
             const data = yield method(...args);
             return data;
         });
-        this.getAgent = () => {
-            return this._agentManager.getAgent();
-        };
         // actor store
         this.getActor = () => {
             return this._actor;
@@ -100,11 +93,11 @@ class ActorManager {
         };
         const { agentManager, canisterId, idlFactory, withVisitor = false, withDevtools = false, initializeOnCreate = true, } = actorConfig;
         this._agentManager = agentManager;
-        this.unsubscribeActor = this._agentManager.subscribeAgent(this.initializeActor);
+        this._agentManager.subscribeAgent(this.initializeActor);
         this.canisterId = canisterId;
         this._idlFactory = idlFactory;
         if (withVisitor) {
-            this.visitFunction = this.extractService();
+            this.visitFunction = withVisitor ? this.extractService() : emptyVisitor;
         }
         else {
             this.visitFunction = emptyVisitor;
@@ -140,3 +133,4 @@ const emptyVisitor = new Proxy({}, {
         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.`);
     },
 });
+const DEFAULT_STATE = { data: undefined, error: undefined, loading: false };

package/dist/{actor → classes/actor}/types.d.ts

@@ -1,7 +1,7 @@
 import type { IDL } from "@dfinity/candid";
 import type { StoreApi } from "zustand";
 import type { AgentManager } from "../agent";
-import type { ActorMethod, ActorSubclass, Principal } from "../types";
+import type { ActorMethod, ActorSubclass, Principal } from "../../types";
 export interface DefaultActorType {
     [key: string]: ActorMethod;
 }
@@ -9,7 +9,7 @@ export type BaseActor<T = DefaultActorType> = ActorSubclass<T>;
 export type FunctionName<A = BaseActor> = keyof A & string;
 export type FunctionType = "query" | "update";
 export type CanisterId = string | Principal;
-export interface ActorManagerOptions {
+export interface ActorManagerParameters {
     agentManager: AgentManager;
     idlFactory: IDL.InterfaceFactory;
     canisterId: CanisterId;
@@ -24,23 +24,23 @@ export type VisitorType<V> = V extends IDL.Visitor<infer D, infer R> ? {
 export type VisitService<A = BaseActor, M extends FunctionName<A> = FunctionName<A>> = {
     [K in M]: <V extends IDL.Visitor<unknown, unknown>>(extractorClass: V, data?: VisitorType<V>["data"]) => ReturnType<V["visitFunc"]>;
 };
-export type ActorMethodArgs<T> = T extends ActorMethod<infer Args, any> ? Args : never;
+export type ActorMethodParameters<T> = T extends ActorMethod<infer Args, any> ? Args : never;
 export type ActorMethodReturnType<T> = T extends ActorMethod<any, infer Ret> ? Ret : never;
-export interface ActorMethodState<A, M extends keyof A> {
+export interface ActorMethodState<A = BaseActor, M extends FunctionName<A> = FunctionName<A>> {
     [key: string]: {
         data: ActorMethodReturnType<A[M]> | undefined;
         loading: boolean;
         error: Error | undefined;
     };
 }
-export type ActorMethodStates<A> = {
-    [M in keyof A]: ActorMethodState<A, M>;
+export type ActorMethodStates<A = BaseActor> = {
+    [M in FunctionName<A>]: ActorMethodState<A, M>;
 };
-export type ActorState<A> = {
+export type ActorState<A = BaseActor> = {
     initialized: boolean;
     initializing: boolean;
     error: Error | undefined;
     methodState: ActorMethodStates<A>;
 };
 export type ActorStore<A = BaseActor> = StoreApi<ActorState<A>>;
-export type CallActorMethod<A = BaseActor> = <M extends keyof A>(functionName: M, ...args: ActorMethodArgs<A[M]>) => Promise<ActorMethodReturnType<A[M]>>;
+export type CallActorMethod<A = BaseActor> = <M extends FunctionName<A> = FunctionName<A>>(functionName: M, ...args: ActorMethodParameters<A[M]>) => Promise<ActorMethodReturnType<A[M]>>;

package/dist/{agent → classes/agent}/index.d.ts

@@ -1,5 +1,5 @@
 import { HttpAgent } from "@dfinity/agent";
-import type { AgentStore, AgentManagerOptions, UpdateAgentOptions, AuthStore } from "./types";
+import type { AgentStore, AgentManagerParameters, UpdateAgentParameters, AuthStore } from "./types";
 export declare class AgentManager {
     private _agent;
     private _subscribers;
@@ -10,12 +10,12 @@ export declare class AgentManager {
     private initialAuthState;
     private updateAgentState;
     private updateAuthState;
-    constructor(options?: AgentManagerOptions);
+    constructor(options?: AgentManagerParameters);
     private initializeAgent;
     subscribeAgent: (callback: (agent: HttpAgent) => void) => () => void;
     unsubscribeAgent: (callback: (agent: HttpAgent) => void) => void;
     private notifySubscribers;
-    updateAgent: (options?: UpdateAgentOptions) => Promise<void>;
+    updateAgent: (options?: UpdateAgentParameters) => Promise<void>;
     authenticate: () => Promise<import("@dfinity/agent").Identity>;
     getAgent: () => HttpAgent;
     getAgentState: AgentStore["getState"];

package/dist/{agent → classes/agent}/index.js

@@ -45,8 +45,8 @@ var __rest = (this && this.__rest) || function (s, e) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentManager = void 0;
 const agent_1 = require("@dfinity/agent");
-const helper_1 = require("../tools/helper");
-const constants_1 = require("../tools/constants");
+const helper_1 = require("../../tools/helper");
+const constants_1 = require("../../tools/constants");
 class AgentManager {
     constructor(options) {
         this._subscribers = [];
@@ -155,7 +155,7 @@ class AgentManager {
             const identity = this.authStore.getState().identity;
             return identity ? identity.getPrincipal() : null;
         };
-        const _a = options || {}, { withDevtools, port = 4943, isLocalEnv, host: optionHost } = _a, agentOptions = __rest(_a, ["withDevtools", "port", "isLocalEnv", "host"]);
+        const _a = options || {}, { withDevtools, port = 4943, isLocalEnv, host: optionHost } = _a, agentParameters = __rest(_a, ["withDevtools", "port", "isLocalEnv", "host"]);
         const host = isLocalEnv
             ? `http://127.0.0.1:${port}`
             : optionHost
@@ -171,7 +171,7 @@ class AgentManager {
             withDevtools,
             store: "auth",
         });
-        this._agent = new agent_1.HttpAgent(Object.assign(Object.assign({}, agentOptions), { host }));
+        this._agent = new agent_1.HttpAgent(Object.assign(Object.assign({}, agentParameters), { host }));
         this.isLocalEnv = this._agent.isLocal();
         this.initializeAgent();
     }

package/dist/{agent → classes/agent}/types.d.ts

@@ -2,7 +2,7 @@ import type { HttpAgent, HttpAgentOptions, Identity } from "@dfinity/agent";
 import type { AuthClient } from "@dfinity/auth-client";
 import type { StoreApi } from "zustand";
 export { HttpAgentOptions, AuthClient, Identity };
-export interface AgentManagerOptions extends HttpAgentOptions {
+export interface AgentManagerParameters extends HttpAgentOptions {
     port?: number;
     isLocalEnv?: boolean;
     withDevtools?: boolean;
@@ -19,7 +19,7 @@ export interface AuthState {
     authenticated: boolean;
     error: Error | undefined;
 }
-export interface UpdateAgentOptions extends HttpAgentOptions {
+export interface UpdateAgentParameters extends HttpAgentOptions {
     agent?: HttpAgent;
 }
 export type AgentStore = StoreApi<AgentState>;

package/dist/{candid → classes/candid}/index.d.ts

@@ -1,9 +1,9 @@
 import { HttpAgent } from "@dfinity/agent";
-import type { CanisterId, CandidAdapterOptions, CandidDefenition } from "../types";
+import type { CanisterId, CandidAdapterParameters, CandidDefenition } from "../../types";
 export declare class CandidAdapter {
     agent: HttpAgent;
     didjsCanisterId: string;
-    constructor({ agentManager, agent, didjsCanisterId }: CandidAdapterOptions);
+    constructor({ agentManager, agent, didjsCanisterId, }: CandidAdapterParameters);
     private getDefaultDidJsId;
     getCandidDefinition(canisterId: CanisterId): Promise<CandidDefenition>;
     getFromMetadata(canisterId: CanisterId): Promise<CandidDefenition | undefined>;

package/dist/{candid → classes/candid}/index.js

@@ -12,9 +12,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CandidAdapter = void 0;
 const agent_1 = require("@dfinity/agent");
 const principal_1 = require("@dfinity/principal");
-const constants_1 = require("../tools/constants");
+const constants_1 = require("../../tools/constants");
 class CandidAdapter {
-    constructor({ agentManager, agent, didjsCanisterId }) {
+    constructor({ agentManager, agent, didjsCanisterId, }) {
         if (agent) {
             this.agent = agent;
         }

package/dist/{candid → classes/candid}/types.d.ts

@@ -1,6 +1,6 @@
 import type { AgentManager } from "../agent";
-import type { IDL, HttpAgent } from "../types";
-export interface CandidAdapterOptions {
+import type { IDL, HttpAgent } from "../../types";
+export interface CandidAdapterParameters {
     agentManager?: AgentManager;
     agent?: HttpAgent;
     didjsCanisterId?: string;

package/dist/classes/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./actor";
+export * from "./agent";
+export * from "./candid";

package/dist/classes/index.js

@@ -0,0 +1,19 @@
+"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 __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 });
+__exportStar(require("./actor"), exports);
+__exportStar(require("./agent"), exports);
+__exportStar(require("./candid"), exports);

package/dist/index.d.ts

@@ -1,56 +1,6 @@
-import { ActorManager } from "./actor";
-import { AgentManager } from "./agent";
-import type { ActorManagerOptions, BaseActor, AgentManagerOptions, ReactorCore, CreateReactorOptions, CreateReactorStoreOptions, CandidAdapterOptions } from "./types";
-import { CandidAdapter } from "./candid";
-/**
- * The Core module is the main entry point for the library.
- * Create a new actor manager with the given options.
- * Its create a new agent manager if not provided.
- *
- * @category Main
- * @includeExample ./packages/core/README.md:26-80
- */
-export declare const createReactorCore: <A = BaseActor>({ isLocalEnv, withProcessEnv, ...options }: CreateReactorOptions) => ReactorCore<A>;
-/**
- * The `CandidAdapter` class is used to interact with a canister and retrieve its Candid interface definition.
- * It provides methods to fetch the Candid definition either from the canister's metadata or by using a temporary hack method.
- * If both methods fail, it throws an error.
- *
- * @category Main
- * @includeExample ./packages/core/README.md:145-186
- */
-export declare const createCandidAdapter: (options: CandidAdapterOptions) => CandidAdapter;
-/**
- * Create a new actor manager with the given options.
- * Its create a new agent manager if not provided.
- * It also creates a new actor manager with the given options.
- *
- * @category Main
- * @includeExample ./packages/core/README.md:194-220
- */
-export declare const createReactorStore: <A = BaseActor>(options: CreateReactorStoreOptions) => ActorManager<A>;
-/**
- * Agent manager handles the lifecycle of the `@dfinity/agent`.
- * It is responsible for creating agent and managing the agent's state.
- * You can use it to subscribe to the agent changes.
- * login and logout to the internet identity.
- *
- * @category Main
- * @includeExample ./packages/core/README.md:226-254
- */
-export declare const createAgentManager: (options?: AgentManagerOptions) => AgentManager;
-/**
- * Actor manager handles the lifecycle of the actors.
- * It is responsible for creating and managing the actors.
- * You can use it to call and visit the actor's methods.
- * It also provides a way to interact with the actor's state.
- *
- * @category Main
- * @includeExample ./packages/core/README.md:262-277
- */
-export declare const createActorManager: <A = BaseActor>(options: ActorManagerOptions) => ActorManager<A>;
-export * from "./actor";
-export * from "./agent";
-export * from "./candid";
+export * from "./main";
+export * from "./store";
+export * from "./other";
+export * as classes from "./classes";
 export * as types from "./types";
 export * as tools from "./tools";

package/dist/index.js

@@ -25,216 +25,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __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) {
-        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;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tools = exports.types = exports.createActorManager = exports.createAgentManager = exports.createReactorStore = exports.createCandidAdapter = exports.createReactorCore = void 0;
-const actor_1 = require("./actor");
-const agent_1 = require("./agent");
-const constants_1 = require("./tools/constants");
-const tools_1 = require("./tools");
-const candid_1 = require("./candid");
-/**
- * The Core module is the main entry point for the library.
- * Create a new actor manager with the given options.
- * Its create a new agent manager if not provided.
- *
- * @category Main
- * @includeExample ./packages/core/README.md:26-80
- */
-const createReactorCore = (_a) => {
-    var { isLocalEnv, withProcessEnv = false } = _a, options = __rest(_a, ["isLocalEnv", "withProcessEnv"]);
-    isLocalEnv = isLocalEnv || (withProcessEnv ? (0, tools_1.isInLocalOrDevelopment)() : false);
-    const _b = (0, exports.createReactorStore)(Object.assign({ isLocalEnv }, options)), { subscribeActorState, updateMethodState, callMethod, getState, agentManager } = _b, rest = __rest(_b, ["subscribeActorState", "updateMethodState", "callMethod", "getState", "agentManager"]);
-    const reActorMethod = (functionName, ...args) => {
-        const requestHash = (0, tools_1.generateRequestHash)(args);
-        const updateState = (newState = {}) => {
-            updateMethodState(functionName, requestHash, newState);
-        };
-        updateState();
-        try {
-            const methodState = ((key) => {
-                const state = getState().methodState[functionName][requestHash];
-                switch (key) {
-                    case "data":
-                        return state.data;
-                    case "loading":
-                        return state.loading;
-                    case "error":
-                        return state.error;
-                    default:
-                        return state;
-                }
-            });
-            const subscribe = (callback) => {
-                const unsubscribe = subscribeActorState((state) => {
-                    const methodState = state.methodState[functionName];
-                    const methodStateHash = methodState[requestHash];
-                    if (methodStateHash) {
-                        callback(methodStateHash);
-                    }
-                });
-                return unsubscribe;
-            };
-            const call = (replaceArgs) => __awaiter(void 0, void 0, void 0, function* () {
-                updateState({
-                    loading: true,
-                    error: undefined,
-                });
-                try {
-                    const data = yield callMethod(functionName, ...(replaceArgs !== null && replaceArgs !== void 0 ? replaceArgs : args));
-                    updateState({ data, loading: false });
-                    return data;
-                }
-                catch (error) {
-                    updateState({
-                        error: error,
-                        loading: false,
-                    });
-                    throw error;
-                }
-            });
-            return {
-                requestHash,
-                subscribe,
-                getState: methodState,
-                call,
-            };
-        }
-        catch (error) {
-            updateState({
-                error: error,
-                loading: false,
-            });
-            throw error;
-        }
-    };
-    const queryCall = ({ functionName, args = [], refetchOnMount = true, refetchInterval = false, }) => {
-        let intervalId = null;
-        const _a = reActorMethod(functionName, ...args), { call } = _a, rest = __rest(_a, ["call"]);
-        if (refetchInterval) {
-            intervalId = setInterval(() => {
-                call();
-            }, refetchInterval);
-        }
-        let dataPromise = Promise.resolve();
-        if (refetchOnMount)
-            dataPromise = call();
-        return Object.assign(Object.assign({}, rest), { call, dataPromise, intervalId });
-    };
-    const updateCall = ({ functionName, args = [] }) => {
-        return reActorMethod(functionName, ...args);
-    };
-    const login = (options) => __awaiter(void 0, void 0, void 0, function* () {
-        const authClient = agentManager.getAuthClient();
-        if (!authClient) {
-            yield agentManager.authenticate();
-        }
-        if (!authClient) {
-            throw new Error("Auth client not initialized");
-        }
-        yield authClient.login(Object.assign({ identityProvider: isLocalEnv
-                ? constants_1.IC_INTERNET_IDENTITY_PROVIDER
-                : constants_1.LOCAL_INTERNET_IDENTITY_PROVIDER }, options));
-    });
-    const logout = (options) => __awaiter(void 0, void 0, void 0, function* () {
-        const authClient = agentManager.getAuthClient();
-        if (!authClient) {
-            throw new Error("Auth client not initialized");
-        }
-        yield authClient.logout(options);
-        yield agentManager.authenticate();
-    });
-    return Object.assign(Object.assign({ queryCall,
-        updateCall,
-        callMethod,
-        getState,
-        login,
-        logout,
-        subscribeActorState }, agentManager), rest);
-};
-exports.createReactorCore = createReactorCore;
-/**
- * The `CandidAdapter` class is used to interact with a canister and retrieve its Candid interface definition.
- * It provides methods to fetch the Candid definition either from the canister's metadata or by using a temporary hack method.
- * If both methods fail, it throws an error.
- *
- * @category Main
- * @includeExample ./packages/core/README.md:145-186
- */
-const createCandidAdapter = (options) => {
-    return new candid_1.CandidAdapter(options);
-};
-exports.createCandidAdapter = createCandidAdapter;
-/**
- * Create a new actor manager with the given options.
- * Its create a new agent manager if not provided.
- * It also creates a new actor manager with the given options.
- *
- * @category Main
- * @includeExample ./packages/core/README.md:194-220
- */
-const createReactorStore = (options) => {
-    const { idlFactory, canisterId, withDevtools = false, initializeOnCreate = true, withVisitor = false, agentManager: maybeAgentManager } = options, agentOptions = __rest(options, ["idlFactory", "canisterId", "withDevtools", "initializeOnCreate", "withVisitor", "agentManager"]);
-    const agentManager = maybeAgentManager ||
-        (0, exports.createAgentManager)(Object.assign({ withDevtools }, agentOptions));
-    const actorManager = (0, exports.createActorManager)({
-        idlFactory,
-        canisterId,
-        agentManager,
-        withVisitor,
-        withDevtools,
-        initializeOnCreate,
-    });
-    return actorManager;
-};
-exports.createReactorStore = createReactorStore;
-/**
- * Agent manager handles the lifecycle of the `@dfinity/agent`.
- * It is responsible for creating agent and managing the agent's state.
- * You can use it to subscribe to the agent changes.
- * login and logout to the internet identity.
- *
- * @category Main
- * @includeExample ./packages/core/README.md:226-254
- */
-const createAgentManager = (options) => {
-    return new agent_1.AgentManager(options);
-};
-exports.createAgentManager = createAgentManager;
-/**
- * Actor manager handles the lifecycle of the actors.
- * It is responsible for creating and managing the actors.
- * You can use it to call and visit the actor's methods.
- * It also provides a way to interact with the actor's state.
- *
- * @category Main
- * @includeExample ./packages/core/README.md:262-277
- */
-const createActorManager = (options) => {
-    return new actor_1.ActorManager(options);
-};
-exports.createActorManager = createActorManager;
-__exportStar(require("./actor"), exports);
-__exportStar(require("./agent"), exports);
-__exportStar(require("./candid"), exports);
+exports.tools = exports.types = exports.classes = void 0;
+__exportStar(require("./main"), exports);
+__exportStar(require("./store"), exports);
+__exportStar(require("./other"), exports);
+exports.classes = __importStar(require("./classes"));
 exports.types = __importStar(require("./types"));
 exports.tools = __importStar(require("./tools"));

package/dist/main.d.ts

@@ -0,0 +1,10 @@
+import type { BaseActor, CreateReactorCoreParameters, CreateReactorCoreReturnType } from "./types";
+/**
+ * The Core module is the main entry point for the library.
+ * Create a new actor manager with the given options.
+ * Its create a new agent manager if not provided.
+ *
+ * @category Main
+ * @includeExample ./packages/core/README.md:26-80
+ */
+export declare const createReactorCore: <A = BaseActor>(config: CreateReactorCoreParameters) => CreateReactorCoreReturnType<A>;

package/dist/main.js

@@ -0,0 +1,144 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReactorCore = void 0;
+const constants_1 = require("./tools/constants");
+const tools_1 = require("./tools");
+const store_1 = require("./store");
+/**
+ * The Core module is the main entry point for the library.
+ * Create a new actor manager with the given options.
+ * Its create a new agent manager if not provided.
+ *
+ * @category Main
+ * @includeExample ./packages/core/README.md:26-80
+ */
+const createReactorCore = (config) => {
+    const _a = (0, store_1.createReactorStore)(config), { subscribeActorState, updateMethodState, callMethod, getState, agentManager } = _a, rest = __rest(_a, ["subscribeActorState", "updateMethodState", "callMethod", "getState", "agentManager"]);
+    const actorMethod = (functionName, ...args) => {
+        const requestHash = (0, tools_1.generateRequestHash)(args);
+        const updateState = (newState = {}) => {
+            updateMethodState(functionName, requestHash, newState);
+        };
+        updateState();
+        try {
+            const methodState = ((key) => {
+                const state = getState().methodState[functionName][requestHash];
+                switch (key) {
+                    case "data":
+                        return state.data;
+                    case "loading":
+                        return state.loading;
+                    case "error":
+                        return state.error;
+                    default:
+                        return state;
+                }
+            });
+            const subscribe = (callback) => {
+                const unsubscribe = subscribeActorState((state) => {
+                    const methodState = state.methodState[functionName];
+                    const methodStateHash = methodState[requestHash];
+                    if (methodStateHash) {
+                        callback(methodStateHash);
+                    }
+                });
+                return unsubscribe;
+            };
+            const call = (replaceArgs) => __awaiter(void 0, void 0, void 0, function* () {
+                updateState({
+                    loading: true,
+                    error: undefined,
+                });
+                try {
+                    const data = yield callMethod(functionName, ...(replaceArgs !== null && replaceArgs !== void 0 ? replaceArgs : args));
+                    updateState({ data, loading: false });
+                    return data;
+                }
+                catch (error) {
+                    updateState({
+                        error: error,
+                        loading: false,
+                    });
+                    throw error;
+                }
+            });
+            return {
+                requestHash,
+                subscribe,
+                getState: methodState,
+                call,
+            };
+        }
+        catch (error) {
+            updateState({
+                error: error,
+                loading: false,
+            });
+            throw error;
+        }
+    };
+    const queryCall = ({ functionName, args = [], refetchOnMount = true, refetchInterval = false, }) => {
+        let intervalId = null;
+        const _a = actorMethod(functionName, ...args), { call } = _a, rest = __rest(_a, ["call"]);
+        if (refetchInterval) {
+            intervalId = setInterval(() => {
+                call();
+            }, refetchInterval);
+        }
+        let dataPromise = Promise.resolve();
+        if (refetchOnMount)
+            dataPromise = call();
+        return Object.assign(Object.assign({}, rest), { call, dataPromise, intervalId });
+    };
+    const updateCall = ({ functionName, args = [] }) => {
+        return actorMethod(functionName, ...args);
+    };
+    const login = (options) => __awaiter(void 0, void 0, void 0, function* () {
+        const authClient = agentManager.getAuthClient();
+        if (!authClient) {
+            yield agentManager.authenticate();
+        }
+        if (!authClient) {
+            throw new Error("Auth client not initialized");
+        }
+        yield authClient.login(Object.assign({ identityProvider: agentManager.isLocalEnv
+                ? constants_1.IC_INTERNET_IDENTITY_PROVIDER
+                : constants_1.LOCAL_INTERNET_IDENTITY_PROVIDER }, options));
+    });
+    const logout = (options) => __awaiter(void 0, void 0, void 0, function* () {
+        const authClient = agentManager.getAuthClient();
+        if (!authClient) {
+            throw new Error("Auth client not initialized");
+        }
+        yield authClient.logout(options);
+        yield agentManager.authenticate();
+    });
+    return Object.assign(Object.assign({ queryCall,
+        updateCall,
+        callMethod,
+        getState,
+        login,
+        logout,
+        subscribeActorState }, agentManager), rest);
+};
+exports.createReactorCore = createReactorCore;

package/dist/other.d.ts

@@ -0,0 +1,33 @@
+import { ActorManager } from "./classes/actor";
+import { AgentManager } from "./classes/agent";
+import { CandidAdapter } from "./classes/candid";
+import { CandidAdapterParameters, ActorManagerParameters, AgentManagerParameters, BaseActor } from "./types";
+/**
+ * The `CandidAdapter` class is used to interact with a canister and retrieve its Candid interface definition.
+ * It provides methods to fetch the Candid definition either from the canister's metadata or by using a temporary hack method.
+ * If both methods fail, it throws an error.
+ *
+ * @category Main
+ * @includeExample ./packages/core/README.md:145-186
+ */
+export declare const createCandidAdapter: (config: CandidAdapterParameters) => CandidAdapter;
+/**
+ * Agent manager handles the lifecycle of the `@dfinity/agent`.
+ * It is responsible for creating agent and managing the agent's state.
+ * You can use it to subscribe to the agent changes.
+ * login and logout to the internet identity.
+ *
+ * @category Main
+ * @includeExample ./packages/core/README.md:226-254
+ */
+export declare const createAgentManager: (config?: AgentManagerParameters) => AgentManager;
+/**
+ * Actor manager handles the lifecycle of the actors.
+ * It is responsible for creating and managing the actors.
+ * You can use it to call and visit the actor's methods.
+ * It also provides a way to interact with the actor's state.
+ *
+ * @category Main
+ * @includeExample ./packages/core/README.md:262-277
+ */
+export declare const createActorManager: <A = BaseActor>(config: ActorManagerParameters) => ActorManager<A>;

package/dist/other.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createActorManager = exports.createAgentManager = exports.createCandidAdapter = void 0;
+const actor_1 = require("./classes/actor");
+const agent_1 = require("./classes/agent");
+const candid_1 = require("./classes/candid");
+/**
+ * The `CandidAdapter` class is used to interact with a canister and retrieve its Candid interface definition.
+ * It provides methods to fetch the Candid definition either from the canister's metadata or by using a temporary hack method.
+ * If both methods fail, it throws an error.
+ *
+ * @category Main
+ * @includeExample ./packages/core/README.md:145-186
+ */
+const createCandidAdapter = (config) => {
+    return new candid_1.CandidAdapter(config);
+};
+exports.createCandidAdapter = createCandidAdapter;
+/**
+ * Agent manager handles the lifecycle of the `@dfinity/agent`.
+ * It is responsible for creating agent and managing the agent's state.
+ * You can use it to subscribe to the agent changes.
+ * login and logout to the internet identity.
+ *
+ * @category Main
+ * @includeExample ./packages/core/README.md:226-254
+ */
+const createAgentManager = (config) => {
+    return new agent_1.AgentManager(config);
+};
+exports.createAgentManager = createAgentManager;
+/**
+ * Actor manager handles the lifecycle of the actors.
+ * It is responsible for creating and managing the actors.
+ * You can use it to call and visit the actor's methods.
+ * It also provides a way to interact with the actor's state.
+ *
+ * @category Main
+ * @includeExample ./packages/core/README.md:262-277
+ */
+const createActorManager = (config) => {
+    return new actor_1.ActorManager(config);
+};
+exports.createActorManager = createActorManager;

package/dist/store.d.ts

@@ -0,0 +1,11 @@
+import { ActorManager } from "./classes/actor";
+import type { BaseActor, CreateReactorStoreParameters } from "./types";
+/**
+ * Create a new actor manager with the given options.
+ * Its create a new agent manager if not provided.
+ * It also creates a new actor manager with the given options.
+ *
+ * @category Main
+ * @includeExample ./packages/core/README.md:194-220
+ */
+export declare const createReactorStore: <A = BaseActor>(config: CreateReactorStoreParameters) => ActorManager<A>;

package/dist/store.js

@@ -0,0 +1,43 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReactorStore = void 0;
+const other_1 = require("./other");
+const tools_1 = require("./tools");
+/**
+ * Create a new actor manager with the given options.
+ * Its create a new agent manager if not provided.
+ * It also creates a new actor manager with the given options.
+ *
+ * @category Main
+ * @includeExample ./packages/core/README.md:194-220
+ */
+const createReactorStore = (config) => {
+    const isLocalEnv = config.withProcessEnv
+        ? (0, tools_1.isInLocalOrDevelopment)()
+        : undefined;
+    const { idlFactory, canisterId, withDevtools = false, initializeOnCreate = true, withVisitor = false, agentManager: maybeAgentManager } = config, agentParameters = __rest(config, ["idlFactory", "canisterId", "withDevtools", "initializeOnCreate", "withVisitor", "agentManager"]);
+    const agentManager = maybeAgentManager ||
+        (0, other_1.createAgentManager)(Object.assign({ withDevtools,
+            isLocalEnv }, agentParameters));
+    const actorManager = (0, other_1.createActorManager)({
+        idlFactory,
+        canisterId,
+        agentManager,
+        withVisitor,
+        withDevtools,
+        initializeOnCreate,
+    });
+    return actorManager;
+};
+exports.createReactorStore = createReactorStore;

package/dist/tools/helper.d.ts

@@ -1,9 +1,9 @@
-import { BaseActor } from "../types";
-interface StoreOptions {
+import type { BaseActor } from "../types";
+interface StoreParameters {
     withDevtools?: boolean;
     store: string;
 }
-export declare function createStoreWithOptionalDevtools<T>(initialState: T, options: StoreOptions): Omit<import("zustand/vanilla").StoreApi<T>, "setState"> & {
+export declare function createStoreWithOptionalDevtools<T>(initialState: T, config: StoreParameters): Omit<import("zustand/vanilla").StoreApi<T>, "setState"> & {
     setState<A extends string | {
         type: string;
     }>(partial: T | Partial<T> | ((state: T) => T | Partial<T>), replace?: boolean | undefined, action?: A | undefined): void;

package/dist/tools/helper.js

@@ -5,11 +5,11 @@ const agent_1 = require("@dfinity/agent");
 const candid_1 = require("@dfinity/candid");
 const middleware_1 = require("zustand/middleware");
 const vanilla_1 = require("zustand/vanilla");
-function createStoreWithOptionalDevtools(initialState, options) {
-    if (options.withDevtools) {
+function createStoreWithOptionalDevtools(initialState, config) {
+    if (config.withDevtools) {
         return (0, vanilla_1.createStore)((0, middleware_1.devtools)(() => initialState, {
             name: "Reactor",
-            store: options.store,
+            store: config.store,
         }));
     }
     else {

package/dist/types.d.ts

@@ -2,17 +2,16 @@
 import type { ActorMethod, ActorSubclass, HttpAgentOptions, HttpAgent, Identity } from "@dfinity/agent";
 import type { Principal } from "@dfinity/principal";
 import type { IDL } from "@dfinity/candid";
-import type { ActorManager } from "./actor";
-import type { ActorManagerOptions, ActorMethodArgs, ActorMethodReturnType, ActorMethodState, BaseActor, FunctionName } from "./actor/types";
-import type { AgentManager } from "./agent";
+import type { ActorManagerParameters, ActorMethodParameters, ActorMethodReturnType, ActorMethodState, BaseActor, FunctionName } from "./classes/actor/types";
+import type { ActorManager } from "./classes/actor";
+import type { AgentManager } from "./classes/agent";
 import type { AuthClientLoginOptions } from "@dfinity/auth-client";
-export * from "./agent/types";
-export * from "./actor/types";
-export * from "./candid/types";
-export type { ActorMethod, HttpAgentOptions, ActorSubclass, Principal, HttpAgent, Identity, IDL, };
-export interface CreateReactorOptions extends CreateReactorStoreOptions {
-}
-export interface CreateReactorStoreOptions extends HttpAgentOptions, Omit<ActorManagerOptions, "agentManager"> {
+export * from "./classes/agent/types";
+export * from "./classes/actor/types";
+export * from "./classes/candid/types";
+export type { ActorManager, AgentManager };
+export type { ActorMethod, AuthClientLoginOptions, HttpAgentOptions, ActorSubclass, Principal, HttpAgent, Identity, IDL, };
+export interface CreateReactorStoreParameters extends HttpAgentOptions, Omit<ActorManagerParameters, "agentManager"> {
     agentManager?: AgentManager;
     withProcessEnv?: boolean;
     isLocalEnv?: boolean;
@@ -25,8 +24,8 @@ export type ActorGetStateFunction<A, M extends FunctionName<A>> = {
     (): ActorMethodState<A, M>[string];
 };
 export type ActorSubscribeFunction<A, M extends FunctionName<A>> = (callback: (state: ActorMethodState<A, M>[string]) => void) => () => void;
-export type ActorCallFunction<A, M extends FunctionName<A>> = (replaceArgs?: ActorMethodArgs<A[M]>) => Promise<ActorMethodReturnType<A[M]>>;
-export type ActorQueryReturn<A, M extends FunctionName<A>> = {
+export type ActorCallFunction<A, M extends FunctionName<A>> = (replaceArgs?: ActorMethodParameters<A[M]>) => Promise<ActorMethodReturnType<A[M]>>;
+export type ActorQueryReturnType<A, M extends FunctionName<A>> = {
     intervalId: NodeJS.Timeout | null;
     requestHash: string;
     getState: ActorGetStateFunction<A, M>;
@@ -34,28 +33,31 @@ export type ActorQueryReturn<A, M extends FunctionName<A>> = {
     call: ActorCallFunction<A, M>;
     dataPromise: Promise<ActorMethodReturnType<A[M]>>;
 };
-export type ActorUpdateReturn<A, M extends FunctionName<A>> = {
+export type ActorUpdateReturnType<A, M extends FunctionName<A>> = {
     requestHash: string;
     getState: ActorGetStateFunction<A, M>;
     subscribe: ActorSubscribeFunction<A, M>;
     call: ActorCallFunction<A, M>;
 };
-export type ActorQueryArgs<A, M extends FunctionName<A>> = {
+export type ActorQueryParameters<A, M extends FunctionName<A>> = {
     functionName: M;
-    args?: ActorMethodArgs<A[M]>;
+    args?: ActorMethodParameters<A[M]>;
     refetchOnMount?: boolean;
     refetchInterval?: number | false;
 };
-export type ActorUpdateArgs<A, M extends FunctionName<A>> = {
+export type ActorUpdateParameters<A, M extends FunctionName<A>> = {
     functionName: M;
-    args?: ActorMethodArgs<A[M]>;
+    args?: ActorMethodParameters<A[M]>;
 };
-export type ActorMethodCall<A = Record<string, ActorMethod>> = <M extends FunctionName<A>>(functionName: M, ...args: ActorMethodArgs<A[M]>) => ActorUpdateReturn<A, M>;
-export type ActorQuery<A = Record<string, ActorMethod>> = <M extends FunctionName<A>>(options: ActorQueryArgs<A, M>) => ActorQueryReturn<A, M>;
-export type ActorUpdate<A = Record<string, ActorMethod>> = <M extends FunctionName<A>>(options: ActorUpdateArgs<A, M>) => ActorUpdateReturn<A, M>;
-export interface ReactorCore<A = BaseActor> extends AgentManager, Omit<ActorManager<A>, "updateMethodState"> {
-    login: (options?: AuthClientLoginOptions) => Promise<void>;
-    logout: (options?: {
+export type ActorMethodCall<A = Record<string, ActorMethod>> = <M extends FunctionName<A>>(functionName: M, ...args: ActorMethodParameters<A[M]>) => ActorUpdateReturnType<A, M>;
+export type ActorQuery<A = Record<string, ActorMethod>> = <M extends FunctionName<A>>(config: ActorQueryParameters<A, M>) => ActorQueryReturnType<A, M>;
+export type ActorUpdate<A = Record<string, ActorMethod>> = <M extends FunctionName<A>>(config: ActorUpdateParameters<A, M>) => ActorUpdateReturnType<A, M>;
+export interface CreateReactorCoreParameters extends CreateReactorStoreParameters {
+    withProcessEnv?: boolean;
+}
+export interface CreateReactorCoreReturnType<A = BaseActor> extends AgentManager, Omit<ActorManager<A>, "updateMethodState"> {
+    login: (config?: AuthClientLoginOptions) => Promise<void>;
+    logout: (config?: {
         returnTo?: string;
     }) => Promise<void>;
     queryCall: ActorQuery<A>;

package/dist/types.js

@@ -14,6 +14,6 @@ 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 });
-__exportStar(require("./agent/types"), exports);
-__exportStar(require("./actor/types"), exports);
-__exportStar(require("./candid/types"), exports);
+__exportStar(require("./classes/agent/types"), exports);
+__exportStar(require("./classes/actor/types"), exports);
+__exportStar(require("./classes/candid/types"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ic-reactor/core",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "A library for intracting with the Internet Computer canisters",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -43,5 +43,5 @@
   "engines": {
     "node": ">=10"
   },
-  "gitHead": "4d19bef671056c8046ec64037f51d85380ff5bae"
+  "gitHead": "6b8947ab2611bf7af4f0fadaa33a1fa231cfc26b"
 }