@ic-reactor/core 1.0.3 → 1.0.5

package/README.md

@@ -203,7 +203,7 @@ const { agentManager, callMethod } = createReactorStore<Candid>({
 
 // Usage example
 await agentManager.authenticate()
-const authClient = agentManager.getAuthClient()
+const authClient = agentManager.getAuth()
 
 authClient?.login({
   onSuccess: () => {

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

@@ -1,6 +1,6 @@
-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;
@@ -15,11 +15,11 @@ export declare class ActorManager<A = BaseActor> {
         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;
     getActor: () => A | null;
     getState: ActorStore<A>["getState"];

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) {

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

@@ -1,15 +1,15 @@
 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;
 }
 export type BaseActor<T = DefaultActorType> = ActorSubclass<T>;
-export type FunctionName<A = BaseActor> = keyof A & string;
+export type FunctionName<A = BaseActor> = Extract<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,7 +24,7 @@ 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 = BaseActor, M extends FunctionName<A> = FunctionName<A>> {
     [key: string]: {
@@ -43,4 +43,4 @@ export type ActorState<A = BaseActor> = {
     methodState: ActorMethodStates<A>;
 };
 export type ActorStore<A = BaseActor> = StoreApi<ActorState<A>>;
-export type CallActorMethod<A = BaseActor> = <M extends FunctionName<A> = FunctionName<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,7 +1,8 @@
 import { HttpAgent } from "@dfinity/agent";
-import type { AgentStore, AgentManagerOptions, UpdateAgentOptions, AuthStore } from "./types";
+import type { AgentStore, AgentManagerParameters, UpdateAgentParameters, AuthStore, AuthClient } from "./types";
 export declare class AgentManager {
     private _agent;
+    private _auth;
     private _subscribers;
     agentStore: AgentStore;
     authStore: AuthStore;
@@ -10,19 +11,19 @@ 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"];
     subscribeAgentState: AgentStore["subscribe"];
     getAuthState: AuthStore["getState"];
     subscribeAuthState: AuthStore["subscribe"];
-    getAuthClient: () => import("@dfinity/auth-client").AuthClient | null;
+    getAuth: () => AuthClient | null;
     getIdentity: () => import("@dfinity/agent").Identity | null;
     getPrincipal: () => import("@dfinity/principal").Principal | null;
 }

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

@@ -45,10 +45,11 @@ 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._auth = null;
         this._subscribers = [];
         this.initialAgentState = {
             initialized: false,
@@ -57,7 +58,6 @@ class AgentManager {
         };
         this.initialAuthState = {
             identity: null,
-            authClient: null,
             authenticating: false,
             authenticated: false,
             error: undefined,
@@ -110,13 +110,12 @@ class AgentManager {
                     console.error("Failed to import @dfinity/auth-client:", error);
                     throw new Error("Authentication failed: @dfinity/auth-client package is missing.");
                 });
-                const authClient = yield AuthClient.create();
-                const authenticated = yield authClient.isAuthenticated();
-                const identity = authClient.getIdentity();
+                this._auth = yield AuthClient.create();
+                const authenticated = yield this._auth.isAuthenticated();
+                const identity = this._auth.getIdentity();
                 this._agent.replaceIdentity(identity);
                 this.notifySubscribers();
                 this.updateAuthState({
-                    authClient,
                     authenticated,
                     identity,
                     authenticating: false,
@@ -145,8 +144,8 @@ class AgentManager {
         this.subscribeAuthState = (listener) => {
             return this.authStore.subscribe(listener);
         };
-        this.getAuthClient = () => {
-            return this.authStore.getState().authClient;
+        this.getAuth = () => {
+            return this._auth;
         };
         this.getIdentity = () => {
             return this.authStore.getState().identity;
@@ -155,7 +154,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 +170,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;
@@ -14,12 +14,11 @@ export interface AgentState {
 }
 export interface AuthState {
     identity: Identity | null;
-    authClient: AuthClient | null;
     authenticating: boolean;
     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,8 +1,6 @@
 export * from "./main";
 export * from "./store";
 export * from "./other";
-export * from "./actor";
-export * from "./agent";
-export * from "./candid";
+export * as classes from "./classes";
 export * as types from "./types";
 export * as tools from "./tools";

package/dist/index.js

@@ -26,12 +26,10 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tools = exports.types = void 0;
+exports.tools = exports.types = exports.classes = 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);
+exports.classes = __importStar(require("./classes"));
 exports.types = __importStar(require("./types"));
 exports.tools = __importStar(require("./tools"));

package/dist/main.d.ts

@@ -1,4 +1,4 @@
-import type { BaseActor, ReactorCore, CreateReactorOptions } from "./types";
+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.
@@ -7,4 +7,4 @@ import type { BaseActor, ReactorCore, CreateReactorOptions } from "./types";
  * @category Main
  * @includeExample ./packages/core/README.md:26-80
  */
-export declare const createReactorCore: <A = BaseActor>({ isLocalEnv, withProcessEnv, ...options }: CreateReactorOptions) => ReactorCore<A>;
+export declare const createReactorCore: <A = BaseActor>(config: CreateReactorCoreParameters) => CreateReactorCoreReturnType<A>;

package/dist/main.js

@@ -32,11 +32,9 @@ const store_1 = require("./store");
  * @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 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);
@@ -101,7 +99,7 @@ const createReactorCore = (_a) => {
     };
     const queryCall = ({ functionName, args = [], refetchOnMount = true, refetchInterval = false, }) => {
         let intervalId = null;
-        const _a = reActorMethod(functionName, ...args), { call } = _a, rest = __rest(_a, ["call"]);
+        const _a = actorMethod(functionName, ...args), { call } = _a, rest = __rest(_a, ["call"]);
         if (refetchInterval) {
             intervalId = setInterval(() => {
                 call();
@@ -113,22 +111,22 @@ const createReactorCore = (_a) => {
         return Object.assign(Object.assign({}, rest), { call, dataPromise, intervalId });
     };
     const updateCall = ({ functionName, args = [] }) => {
-        return reActorMethod(functionName, ...args);
+        return actorMethod(functionName, ...args);
     };
     const login = (options) => __awaiter(void 0, void 0, void 0, function* () {
-        const authClient = agentManager.getAuthClient();
+        const authClient = agentManager.getAuth();
         if (!authClient) {
             yield agentManager.authenticate();
         }
         if (!authClient) {
             throw new Error("Auth client not initialized");
         }
-        yield authClient.login(Object.assign({ identityProvider: isLocalEnv
+        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();
+        const authClient = agentManager.getAuth();
         if (!authClient) {
             throw new Error("Auth client not initialized");
         }

package/dist/other.d.ts

@@ -1,7 +1,7 @@
-import { ActorManager } from "./actor";
-import { AgentManager } from "./agent";
-import { CandidAdapter } from "./candid";
-import { ActorManagerOptions, AgentManagerOptions, BaseActor, CandidAdapterOptions } from "./types";
+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.
@@ -10,7 +10,7 @@ import { ActorManagerOptions, AgentManagerOptions, BaseActor, CandidAdapterOptio
  * @category Main
  * @includeExample ./packages/core/README.md:145-186
  */
-export declare const createCandidAdapter: (options: CandidAdapterOptions) => CandidAdapter;
+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.
@@ -20,7 +20,7 @@ export declare const createCandidAdapter: (options: CandidAdapterOptions) => Can
  * @category Main
  * @includeExample ./packages/core/README.md:226-254
  */
-export declare const createAgentManager: (options?: AgentManagerOptions) => AgentManager;
+export declare const createAgentManager: (config?: AgentManagerParameters) => AgentManager;
 /**
  * Actor manager handles the lifecycle of the actors.
  * It is responsible for creating and managing the actors.
@@ -30,4 +30,4 @@ export declare const createAgentManager: (options?: AgentManagerOptions) => Agen
  * @category Main
  * @includeExample ./packages/core/README.md:262-277
  */
-export declare const createActorManager: <A = BaseActor>(options: ActorManagerOptions) => ActorManager<A>;
+export declare const createActorManager: <A = BaseActor>(config: ActorManagerParameters) => ActorManager<A>;

package/dist/other.js

@@ -1,9 +1,9 @@
 "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");
+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.
@@ -12,8 +12,8 @@ const candid_1 = require("./candid");
  * @category Main
  * @includeExample ./packages/core/README.md:145-186
  */
-const createCandidAdapter = (options) => {
-    return new candid_1.CandidAdapter(options);
+const createCandidAdapter = (config) => {
+    return new candid_1.CandidAdapter(config);
 };
 exports.createCandidAdapter = createCandidAdapter;
 /**
@@ -25,8 +25,8 @@ exports.createCandidAdapter = createCandidAdapter;
  * @category Main
  * @includeExample ./packages/core/README.md:226-254
  */
-const createAgentManager = (options) => {
-    return new agent_1.AgentManager(options);
+const createAgentManager = (config) => {
+    return new agent_1.AgentManager(config);
 };
 exports.createAgentManager = createAgentManager;
 /**
@@ -38,7 +38,7 @@ exports.createAgentManager = createAgentManager;
  * @category Main
  * @includeExample ./packages/core/README.md:262-277
  */
-const createActorManager = (options) => {
-    return new actor_1.ActorManager(options);
+const createActorManager = (config) => {
+    return new actor_1.ActorManager(config);
 };
 exports.createActorManager = createActorManager;

package/dist/store.d.ts

@@ -1,5 +1,5 @@
-import { ActorManager } from "./actor";
-import type { BaseActor, CreateReactorStoreOptions } from "./types";
+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.
@@ -8,4 +8,4 @@ import type { BaseActor, CreateReactorStoreOptions } from "./types";
  * @category Main
  * @includeExample ./packages/core/README.md:194-220
  */
-export declare const createReactorStore: <A = BaseActor>(options: CreateReactorStoreOptions) => ActorManager<A>;
+export declare const createReactorStore: <A = BaseActor>(config: CreateReactorStoreParameters) => ActorManager<A>;

package/dist/store.js

@@ -13,6 +13,7 @@ var __rest = (this && this.__rest) || function (s, e) {
 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.
@@ -21,10 +22,14 @@ const other_1 = require("./other");
  * @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 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 }, agentOptions));
+        (0, other_1.createAgentManager)(Object.assign({ withDevtools,
+            isLocalEnv }, agentParameters));
     const actorManager = (0, other_1.createActorManager)({
         idlFactory,
         canisterId,

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,19 +2,18 @@
 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 {
-    withProcessEnv?: boolean;
-}
-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;
     port?: number;
 }
@@ -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.3",
+  "version": "1.0.5",
   "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": "acf8b5da61713482264c9eb5c227dc94a7e43cbc"
+  "gitHead": "c52ec12bc91d5a0e2c5fc7c6e163530a1aa5e47f"
 }