@ic-reactor/react 0.2.0 → 0.2.2

package/dist/hooks.d.ts

@@ -1,16 +1,25 @@
-import { CallMethod, ExtractReActorMethodArgs } from "@ic-reactor/store";
+import { CallMethod, ExtractReActorMethodArgs, ReActorActorStore, ReActorMethodField } from "@ic-reactor/store";
 import { ReActorUseQueryArgs, ReActorUseUpdateArgs } from "./types";
-export declare const getCallHooks: <A extends unknown>(callMethod: CallMethod<A>) => {
+export declare const getCallHooks: <A extends unknown>(callMethod: CallMethod<A>, actorStore: ReActorActorStore<A>) => {
+    useField: (functionName: keyof A & string) => {
+        current: ReActorMethodField<A> | undefined;
+    };
     useQueryCall: <M extends keyof A>({ autoRefresh, refreshInterval, disableInitialCall, ...rest }: ReActorUseQueryArgs<A, M>) => {
         data: import("@ic-reactor/store").ExtractReActorMethodReturnType<A[M]> | undefined;
         error: Error | undefined;
         loading: boolean;
-        recall: (replaceArgs?: ExtractReActorMethodArgs<A[M]> | undefined) => Promise<import("@ic-reactor/store").ExtractReActorMethodReturnType<A[M]> | undefined>;
+        field: {
+            current: ReActorMethodField<A> | undefined;
+        };
+        call: (replaceArgs?: ExtractReActorMethodArgs<A[M]> | undefined) => Promise<import("@ic-reactor/store").ExtractReActorMethodReturnType<A[M]> | undefined>;
     };
     useUpdateCall: <M_1 extends keyof A>(args: ReActorUseUpdateArgs<A, M_1>) => {
         data: import("@ic-reactor/store").ExtractReActorMethodReturnType<A[M_1]> | undefined;
         error: Error | undefined;
         loading: boolean;
         call: (replaceArgs?: ExtractReActorMethodArgs<A[M_1]> | undefined) => Promise<import("@ic-reactor/store").ExtractReActorMethodReturnType<A[M_1]> | undefined>;
+        field: {
+            current: ReActorMethodField<A> | undefined;
+        };
     };
 };

package/dist/hooks.js

@@ -22,7 +22,22 @@ var __rest = (this && this.__rest) || function (s, e) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCallHooks = void 0;
 const react_1 = require("react");
-const getCallHooks = (callMethod) => {
+const getCallHooks = (callMethod, actorStore) => {
+    const useField = (functionName) => {
+        const [field, setField] = (0, react_1.useState)(undefined);
+        (0, react_1.useEffect)(() => {
+            const unsubscribe = actorStore.subscribe((state) => {
+                if (state.methodFields) {
+                    const field = state.methodFields.find((f) => f.functionName === functionName);
+                    setField(field);
+                }
+            });
+            return () => {
+                unsubscribe();
+            };
+        }, [functionName]);
+        return { current: field };
+    };
     const useReActorCall = ({ onError, onSuccess, onLoading, args = [], functionName, }) => {
         const [state, setState] = (0, react_1.useState)({
             data: undefined,
@@ -47,33 +62,35 @@ const getCallHooks = (callMethod) => {
                 setState((prevState) => (Object.assign(Object.assign({}, prevState), { error: error, loading: false })));
             }
         }), [args, functionName, onError, onSuccess, onLoading]);
-        return Object.assign({ call }, state);
+        const field = useField(functionName);
+        return Object.assign({ call, field }, state);
     };
     const useQueryCall = (_a) => {
         var { autoRefresh, refreshInterval = 5000, disableInitialCall } = _a, rest = __rest(_a, ["autoRefresh", "refreshInterval", "disableInitialCall"]);
-        const _b = useReActorCall(rest), { call: recall } = _b, state = __rest(_b, ["call"]);
+        const _b = useReActorCall(rest), { call } = _b, state = __rest(_b, ["call"]);
         let intervalId = (0, react_1.useRef)(undefined);
         (0, react_1.useEffect)(() => {
             // Auto-refresh logic
             if (autoRefresh) {
                 intervalId.current = setInterval(() => {
-                    recall();
+                    call();
                 }, refreshInterval);
             }
             // Initial call logic
             if (!disableInitialCall) {
-                recall();
+                call();
             }
             return () => {
                 clearInterval(intervalId.current);
             };
         }, [disableInitialCall, autoRefresh, refreshInterval]);
-        return Object.assign({ recall }, state);
+        return Object.assign({ call }, state);
     };
     const useUpdateCall = (args) => {
         return useReActorCall(args);
     };
     return {
+        useField,
         useQueryCall,
         useUpdateCall,
     };

package/dist/index.d.ts

@@ -2,6 +2,9 @@ import { AuthClientLoginOptions } from "@dfinity/auth-client";
 import type { ActorSubclass, ReActorAuthStore, ReActorOptions } from "@ic-reactor/store";
 export type ReActorContextType<A = ActorSubclass<any>> = ReActorAuthStore<A>;
 export declare const createReActor: <A extends unknown>(options: ReActorOptions) => {
+    useField: (functionName: keyof A & string) => {
+        current: import("@ic-reactor/store").ReActorMethodField<A> | undefined;
+    };
     useActorStore: () => {
         initialize: (agentOptions?: import("@dfinity/agent").HttpAgentOptions | undefined, identity?: import("@ic-reactor/store").Identity | undefined) => void;
         actor: A | null;
@@ -9,19 +12,26 @@ export declare const createReActor: <A extends unknown>(options: ReActorOptions)
         initializing: boolean;
         error: Error | undefined;
         methodState: import("@ic-reactor/store").ReActorMethodStates<A>;
+        methodFields: import("@ic-reactor/store").ReActorMethodField<A>[];
     };
     useAuthStore: () => import("@ic-reactor/store").ReActorAuthState<A>;
     useQueryCall: <M extends keyof A>({ autoRefresh, refreshInterval, disableInitialCall, ...rest }: import("./types").ReActorUseQueryArgs<A, M>) => {
         data: import("@ic-reactor/store").ExtractReActorMethodReturnType<A[M]> | undefined;
         error: Error | undefined;
         loading: boolean;
-        recall: (replaceArgs?: import("@ic-reactor/store").ExtractReActorMethodArgs<A[M]> | undefined) => Promise<import("@ic-reactor/store").ExtractReActorMethodReturnType<A[M]> | undefined>;
+        field: {
+            current: import("@ic-reactor/store").ReActorMethodField<A> | undefined;
+        };
+        call: (replaceArgs?: import("@ic-reactor/store").ExtractReActorMethodArgs<A[M]> | undefined) => Promise<import("@ic-reactor/store").ExtractReActorMethodReturnType<A[M]> | undefined>;
     };
     useUpdateCall: <M_1 extends keyof A>(args: import("./types").ReActorUseUpdateArgs<A, M_1>) => {
         data: import("@ic-reactor/store").ExtractReActorMethodReturnType<A[M_1]> | undefined;
         error: Error | undefined;
         loading: boolean;
         call: (replaceArgs?: import("@ic-reactor/store").ExtractReActorMethodArgs<A[M_1]> | undefined) => Promise<import("@ic-reactor/store").ExtractReActorMethodReturnType<A[M_1]> | undefined>;
+        field: {
+            current: import("@ic-reactor/store").ReActorMethodField<A> | undefined;
+        };
     };
     useAuthClient: () => {
         authClient: import("@dfinity/auth-client").AuthClient | null;

package/dist/index.js

@@ -14,16 +14,13 @@ const store_1 = require("@ic-reactor/store");
 const react_1 = require("react");
 const zustand_1 = require("zustand");
 const hooks_1 = require("./hooks");
-const isLocal = (process === null || process === void 0 ? void 0 : process.env.NODE_ENV) === "development" ||
-    (process === null || process === void 0 ? void 0 : process.env.DFX_NETWORK) === "local";
 const createReActor = (options) => {
-    const { callMethod, unsubscribe, initialize, authenticate, authStore, actorStore, } = (0, store_1.createReActorStore)(Object.assign(Object.assign({ isLocal }, options), { initializeOnMount: false }));
+    const isLocal = typeof process !== "undefined" &&
+        (process.env.NODE_ENV === "development" ||
+            process.env.DFX_NETWORK === "local");
+    const { callMethod, initialize, authenticate, authStore, actorStore } = (0, store_1.createReActorStore)(Object.assign({ isLocal }, options));
     const useActorStore = () => {
         const actorState = (0, zustand_1.useStore)(actorStore, (state) => state);
-        (0, react_1.useEffect)(() => {
-            initialize();
-            return unsubscribe;
-        }, []);
         return Object.assign(Object.assign({}, actorState), { initialize });
     };
     const useAuthStore = () => {
@@ -76,8 +73,9 @@ const createReActor = (options) => {
             loginError,
         };
     };
-    const { useQueryCall, useUpdateCall } = (0, hooks_1.getCallHooks)(callMethod);
+    const { useQueryCall, useField, useUpdateCall } = (0, hooks_1.getCallHooks)(callMethod, actorStore);
     return {
+        useField,
         useActorStore,
         useAuthStore,
         useQueryCall,

package/dist/types.d.ts

@@ -1,6 +1,6 @@
 import { ExtractReActorMethodArgs, ExtractReActorMethodReturnType } from "@ic-reactor/store";
 export type ReActorCallArgs<A, M extends keyof A> = {
-    functionName: M;
+    functionName: M & string;
     args?: ExtractReActorMethodArgs<A[M]>;
     onLoading?: (loading: boolean) => void;
     onError?: (error: Error | unknown) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ic-reactor/react",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "A React library for interacting with Dfinity actors",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -28,25 +28,25 @@
   "scripts": {
     "test": "npx jest",
     "start": "tsc watch",
-    "build": "npx tsc",
-    "clean": "rimraf dist"
+    "build": "npx rimraf dist && npx tsc",
+    "clean": "npx rimraf dist"
   },
   "engines": {
     "node": ">=10"
   },
   "dependencies": {
+    "@ic-reactor/store": "^0.2.2",
+    "zustand-utils": "^1.3"
+  },
+  "peerDependencies": {
     "@dfinity/agent": "^0.20",
     "@dfinity/auth-client": "^0.20",
     "@dfinity/candid": "0.20",
     "@dfinity/identity": "^0.20",
     "@dfinity/principal": "^0.20",
-    "@ic-reactor/store": "^0.2.0",
-    "zustand": "4.4",
-    "zustand-utils": "^1.3"
-  },
-  "peerDependencies": {
     "@peculiar/webcrypto": "1.4",
-    "react": ">=16.8"
+    "react": ">=16.8",
+    "zustand": "4.4"
   },
-  "gitHead": "8499f295b9e20d1dc12bd4f0a33927bfce54c23a"
+  "gitHead": "97c96f8577f6cf748fca237932c3903638002d1e"
 }