@ic-reactor/core 1.0.2 → 1.0.3

package/dist/actor/index.d.ts

@@ -1,4 +1,3 @@
-import type { HttpAgent } from "@dfinity/agent";
 import type { CanisterId, ActorMethodArgs, ActorMethodReturnType, ActorStore, ActorManagerOptions, FunctionName, VisitService, BaseActor, ActorMethodState } from "./types";
 import type { AgentManager } from "../agent";
 import type { UpdateAgentOptions } from "../types";
@@ -10,7 +9,6 @@ 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;
@@ -23,7 +21,6 @@ export declare class ActorManager<A = BaseActor> {
     private initializeActor;
     callMethod: <M extends FunctionName<A>>(functionName: M, ...args: ActorMethodArgs<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/index.js

@@ -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/types.d.ts

@@ -26,21 +26,21 @@ export type VisitService<A = BaseActor, M extends FunctionName<A> = FunctionName
 };
 export type ActorMethodArgs<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: ActorMethodArgs<A[M]>) => Promise<ActorMethodReturnType<A[M]>>;

package/dist/index.d.ts

@@ -1,54 +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 "./main";
+export * from "./store";
+export * from "./other";
 export * from "./actor";
 export * from "./agent";
 export * from "./candid";

package/dist/index.js

@@ -25,214 +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;
+exports.tools = exports.types = void 0;
+__exportStar(require("./main"), exports);
+__exportStar(require("./store"), exports);
+__exportStar(require("./other"), exports);
 __exportStar(require("./actor"), exports);
 __exportStar(require("./agent"), exports);
 __exportStar(require("./candid"), exports);

package/dist/main.d.ts

@@ -0,0 +1,10 @@
+import type { BaseActor, ReactorCore, CreateReactorOptions } 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>({ isLocalEnv, withProcessEnv, ...options }: CreateReactorOptions) => ReactorCore<A>;

package/dist/main.js

@@ -0,0 +1,146 @@
+"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 = (_a) => {
+    var { isLocalEnv, withProcessEnv = false } = _a, options = __rest(_a, ["isLocalEnv", "withProcessEnv"]);
+    isLocalEnv = isLocalEnv || (withProcessEnv ? (0, tools_1.isInLocalOrDevelopment)() : false);
+    const _b = (0, store_1.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;

package/dist/other.d.ts

@@ -0,0 +1,33 @@
+import { ActorManager } from "./actor";
+import { AgentManager } from "./agent";
+import { CandidAdapter } from "./candid";
+import { ActorManagerOptions, AgentManagerOptions, BaseActor, CandidAdapterOptions } 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: (options: CandidAdapterOptions) => 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: (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>;

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("./actor");
+const agent_1 = require("./agent");
+const candid_1 = require("./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 = (options) => {
+    return new candid_1.CandidAdapter(options);
+};
+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 = (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;

package/dist/store.d.ts

@@ -0,0 +1,11 @@
+import { ActorManager } from "./actor";
+import type { BaseActor, CreateReactorStoreOptions } 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>(options: CreateReactorStoreOptions) => ActorManager<A>;

package/dist/store.js

@@ -0,0 +1,38 @@
+"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");
+/**
+ * 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, other_1.createAgentManager)(Object.assign({ withDevtools }, agentOptions));
+    const actorManager = (0, other_1.createActorManager)({
+        idlFactory,
+        canisterId,
+        agentManager,
+        withVisitor,
+        withDevtools,
+        initializeOnCreate,
+    });
+    return actorManager;
+};
+exports.createReactorStore = createReactorStore;

package/dist/types.d.ts

@@ -11,10 +11,10 @@ export * from "./actor/types";
 export * from "./candid/types";
 export type { ActorMethod, HttpAgentOptions, ActorSubclass, Principal, HttpAgent, Identity, IDL, };
 export interface CreateReactorOptions extends CreateReactorStoreOptions {
+    withProcessEnv?: boolean;
 }
 export interface CreateReactorStoreOptions extends HttpAgentOptions, Omit<ActorManagerOptions, "agentManager"> {
     agentManager?: AgentManager;
-    withProcessEnv?: boolean;
     isLocalEnv?: boolean;
     port?: number;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ic-reactor/core",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "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": "acf8b5da61713482264c9eb5c227dc94a7e43cbc"
 }