@ic-reactor/core 0.3.0 → 0.3.1

package/dist/index.d.ts

@@ -1,13 +1,16 @@
-import type { ActorSubclass, ReActorAuthStore, ReActorOptions } from "@ic-reactor/store";
+import type { CreateReActorOptions } from "@ic-reactor/store";
 import { ReActorQuery, ReActorUpdate } from "./types";
-export type ReActorContextType<A = ActorSubclass<any>> = ReActorAuthStore<A>;
-export declare const createReActor: <A extends unknown>(options: ReActorOptions) => {
-    agentStore: import("@ic-reactor/store").ReActorAgentStore;
-    unsubscribeAgent: () => void;
-    initializeAgent: (agentOptions?: import("@dfinity/agent").HttpAgentOptions | undefined, isLocal?: boolean | undefined) => Promise<void>;
+export declare const createReActor: <A extends unknown>(options: CreateReActorOptions) => {
+    methodFields: import("@ic-reactor/store").ActorMethodField<A>[];
+    unsubscribeActor: () => void;
+    updateMethodState: (newState: Partial<import("@ic-reactor/store").ActorMethodStates<A>>) => void;
+    subscribeAgent: (callback: (agent: import("@ic-reactor/store").HttpAgent) => void) => () => void;
+    unsubscribeAgent: (callback: (agent: import("@ic-reactor/store").HttpAgent) => void) => void;
+    updateAgent: (agent: import("@ic-reactor/store").HttpAgent) => void;
     authenticate: () => Promise<void>;
-    actorStore: import("@ic-reactor/store").ReActorActorStore<A>;
-    authStore: ReActorAuthStore<A>;
+    getAgent: () => import("@ic-reactor/store").HttpAgent;
+    actorStore: import("@ic-reactor/store").ActorStore<A>;
+    authStore: import("@ic-reactor/store").AuthenticateStore;
     queryCall: ReActorQuery<A>;
     updateCall: ReActorUpdate<A>;
 };

package/dist/index.js

@@ -23,7 +23,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createReActor = void 0;
 const store_1 = require("@ic-reactor/store");
 const createReActor = (options) => {
-    const _a = (0, store_1.createReActorStore)(options), { callMethod, actorStore, authStore } = _a, rest = __rest(_a, ["callMethod", "actorStore", "authStore"]);
+    const _a = (0, store_1.createReActorStore)(options), { agentManager, callMethod, actorStore } = _a, rest = __rest(_a, ["agentManager", "callMethod", "actorStore"]);
+    const { authStore } = agentManager, agentRest = __rest(agentManager, ["authStore"]);
     const updateMethodState = (method, args = [], newState) => {
         const hash = (0, store_1.generateRequestHash)(args);
         actorStore.setState((state) => {
@@ -114,14 +115,14 @@ const createReActor = (options) => {
         let initialData = Promise.resolve();
         if (!disableInitialCall)
             initialData = call();
-        return Object.assign(Object.assign({}, rest), { recall: call, initialData, intervalId });
+        return Object.assign(Object.assign({}, rest), { call, initialData, intervalId });
     };
     const updateCall = ({ functionName, args = [] }) => {
         return reActorMethod(functionName, ...args);
     };
-    return Object.assign({ actorStore,
+    return Object.assign(Object.assign({ actorStore,
         authStore,
         queryCall,
-        updateCall }, rest);
+        updateCall }, agentRest), rest);
 };
 exports.createReActor = createReActor;

package/dist/types.d.ts

@@ -1,20 +1,20 @@
 /// <reference types="node" />
-import { ActorMethod, ActorSubclass, ExtractReActorMethodArgs, ExtractReActorMethodReturnType, ReActorMethodState } from "@ic-reactor/store";
+import type { ActorMethod, ActorSubclass, ExtractActorMethodArgs, ExtractActorMethodReturnType, ActorMethodState } from "@ic-reactor/store";
 export type ReActorGetStateFunction<A, M extends keyof A> = {
-    (key: "data"): ExtractReActorMethodReturnType<A[M]> | undefined;
+    (key: "data"): ExtractActorMethodReturnType<A[M]> | undefined;
     (key: "loading"): boolean;
     (key: "error"): Error | undefined;
-    (): ReActorMethodState<A, M>[string];
+    (): ActorMethodState<A, M>[string];
 };
-export type ReActorSubscribeFunction<A, M extends keyof A> = (callback: (state: ReActorMethodState<A, M>[string]) => void) => () => void;
-export type ReActorCallFunction<A, M extends keyof A> = (replaceArgs?: ExtractReActorMethodArgs<A[M]>) => Promise<ExtractReActorMethodReturnType<A[M]> | undefined>;
+export type ReActorSubscribeFunction<A, M extends keyof A> = (callback: (state: ActorMethodState<A, M>[string]) => void) => () => void;
+export type ReActorCallFunction<A, M extends keyof A> = (replaceArgs?: ExtractActorMethodArgs<A[M]>) => Promise<ExtractActorMethodReturnType<A[M]> | undefined>;
 export type ReActorQueryReturn<A, M extends keyof A> = {
     intervalId: NodeJS.Timeout | null;
     requestHash: string;
     getState: ReActorGetStateFunction<A, M>;
     subscribe: ReActorSubscribeFunction<A, M>;
-    recall: ReActorCallFunction<A, M>;
-    initialData: Promise<ExtractReActorMethodReturnType<A[M]> | undefined>;
+    call: ReActorCallFunction<A, M>;
+    initialData: Promise<ExtractActorMethodReturnType<A[M]> | undefined>;
 };
 export type ReActorUpdateReturn<A, M extends keyof A> = {
     requestHash: string;
@@ -24,16 +24,16 @@ export type ReActorUpdateReturn<A, M extends keyof A> = {
 };
 export type ReActorQueryArgs<A, M extends keyof A> = {
     functionName: M;
-    args?: ExtractReActorMethodArgs<A[M]>;
+    args?: ExtractActorMethodArgs<A[M]>;
     disableInitialCall?: boolean;
     autoRefresh?: boolean;
     refreshInterval?: number;
 };
 export type ReActorUpdateArgs<A, M extends keyof A> = {
     functionName: M;
-    args?: ExtractReActorMethodArgs<A[M]>;
+    args?: ExtractActorMethodArgs<A[M]>;
 };
-export type ReActorMethod<A = Record<string, ActorMethod>> = <M extends keyof A>(functionName: M, ...args: ExtractReActorMethodArgs<A[M]>) => ReActorUpdateReturn<A, M>;
+export type ReActorMethod<A = Record<string, ActorMethod>> = <M extends keyof A>(functionName: M, ...args: ExtractActorMethodArgs<A[M]>) => ReActorUpdateReturn<A, M>;
 export type ReActorQuery<A = Record<string, ActorMethod>> = <M extends keyof A>(options: ReActorQueryArgs<A, M>) => ReActorQueryReturn<A, M>;
 export type ReActorUpdate<A = Record<string, ActorMethod>> = <M extends keyof A>(options: ReActorUpdateArgs<A, M>) => ReActorUpdateReturn<A, M>;
 export interface ReActorCoreActions<A extends ActorSubclass<any>> {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ic-reactor/core",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "A React library for interacting with Dfinity actors",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -35,7 +35,7 @@
     "node": ">=10"
   },
   "dependencies": {
-    "@ic-reactor/store": "^0.3.0"
+    "@ic-reactor/store": "^0.3.1"
   },
   "peerDependencies": {
     "@dfinity/agent": "^0.20",
@@ -46,5 +46,5 @@
     "@peculiar/webcrypto": "1.4",
     "zustand": "4.4"
   },
-  "gitHead": "00b0d7f282c144151f27d344c47d92b9b446b14a"
+  "gitHead": "c1204b00b5faca2d75911a684fdbc1e341f610a4"
 }