@ic-reactor/react 0.3.7 → 0.4.0

package/README.md

@@ -54,6 +54,7 @@ const Balance = ({ principal }) => {
   const { call, data, loading, error } = useQueryCall({
     functionName: "get_balance",
     args: [principal],
+    callOnMount: true,
   })
 
   return (

package/dist/context/actor.d.ts

@@ -1,8 +1,8 @@
 import React, { PropsWithChildren } from "react";
-import { type ActorHooks } from "../index";
 import { IDL } from "@dfinity/candid";
 import { ActorSubclass, ActorManagerOptions } from "@ic-reactor/store";
 import { AgentContextType } from "./agent";
+import type { ActorHooks } from "../hooks/actor";
 export type ActorContextType<A = ActorSubclass<any>> = ActorHooks<A>;
 export declare const ActorContext: React.Context<ActorContextType<any> | null>;
 type UseActorType = <A = ActorSubclass<any>>() => ActorContextType<A>;

package/dist/hooks/actor.d.ts

@@ -1,19 +1,31 @@
-import type { ExtractActorMethodArgs, ActorManager, ActorMethodField } from "@ic-reactor/store";
-import type { ActorUseQueryArgs, ActorUseUpdateArgs } from "../types";
-export declare const getActorHooks: <A extends unknown>({ methodFields, canisterId, actorStore, callMethod, }: ActorManager<A>) => {
-    useQueryCall: <M extends keyof A>({ autoRefresh, refreshInterval, disableInitialCall, ...rest }: ActorUseQueryArgs<A, M>) => {
+/// <reference types="react" />
+import type { ActorSubclass, ExtractActorMethodArgs, ActorManager, ExtractedService, ExtractedFunction, ServiceMethodType, ServiceMethodTypeAndName } from "@ic-reactor/store";
+import type { ActorUseMethodArg, ActorUseQueryArgs, ActorUseUpdateArgs } from "../types";
+export type ActorHooks<A extends ActorSubclass<any>> = ReturnType<typeof getActorHooks<A>>;
+export declare const getActorHooks: <A extends unknown>({ initialize, serviceFields, canisterId, actorStore, callMethod, }: ActorManager<A>) => {
+    initialize: (options?: import("@ic-reactor/store").UpdateAgentOptions | undefined) => Promise<void>;
+    useQueryCall: <M extends keyof A>({ refetchOnMount, refetchInterval, ...rest }: ActorUseQueryArgs<A, M>) => {
         data: import("@ic-reactor/store").ExtractActorMethodReturnType<A[M]> | undefined;
         error: Error | undefined;
         loading: boolean;
-        field: ActorMethodField<A> | undefined;
-        call: (replaceArgs?: ExtractActorMethodArgs<A[M]> | undefined) => Promise<import("@ic-reactor/store").ExtractActorMethodReturnType<A[M]> | undefined>;
+        field: ExtractedFunction<A>;
+        call: (eventOrReplaceArgs?: import("react").MouseEvent<Element, MouseEvent> | ExtractActorMethodArgs<A[M]> | undefined) => Promise<import("@ic-reactor/store").ExtractActorMethodReturnType<A[M]> | undefined>;
     };
     useUpdateCall: <M_1 extends keyof A>(args: ActorUseUpdateArgs<A, M_1>) => {
         data: import("@ic-reactor/store").ExtractActorMethodReturnType<A[M_1]> | undefined;
         error: Error | undefined;
         loading: boolean;
-        call: (replaceArgs?: ExtractActorMethodArgs<A[M_1]> | undefined) => Promise<import("@ic-reactor/store").ExtractActorMethodReturnType<A[M_1]> | undefined>;
-        field: ActorMethodField<A> | undefined;
+        call: (eventOrReplaceArgs?: import("react").MouseEvent<Element, MouseEvent> | ExtractActorMethodArgs<A[M_1]> | undefined) => Promise<import("@ic-reactor/store").ExtractActorMethodReturnType<A[M_1]> | undefined>;
+        field: ExtractedFunction<A>;
+    };
+    useMethodCall: <M_2 extends keyof A, T extends ServiceMethodType>({ type, ...rest }: ActorUseMethodArg<A, T> & {
+        type: T;
+    }) => {
+        data: import("@ic-reactor/store").ExtractActorMethodReturnType<A[M_2]> | undefined;
+        error: Error | undefined;
+        loading: boolean;
+        field: ExtractedFunction<A>;
+        call: (eventOrReplaceArgs?: import("react").MouseEvent<Element, MouseEvent> | ExtractActorMethodArgs<A[M_2]> | undefined) => Promise<import("@ic-reactor/store").ExtractActorMethodReturnType<A[M_2]> | undefined>;
     };
     useActorStore: () => {
         canisterId: import("@ic-reactor/store").CanisterId;
@@ -22,6 +34,8 @@ export declare const getActorHooks: <A extends unknown>({ methodFields, canister
         error: Error | undefined;
         methodState: import("@ic-reactor/store").ActorMethodStates<A>;
     };
-    useMethodField: (functionName: keyof A & string) => ActorMethodField<A> | undefined;
-    useMethodFields: () => ActorMethodField<A>[];
+    useMethodField: (functionName: keyof A & string) => ExtractedFunction<A>;
+    useMethodFields: () => ExtractedFunction<A>[];
+    useMethodNames: () => ServiceMethodTypeAndName<A>[];
+    useServiceFields: () => ExtractedService<A>;
 };

package/dist/hooks/actor.js

@@ -23,32 +23,44 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getActorHooks = void 0;
 const react_1 = require("react");
 const zustand_1 = require("zustand");
-const getActorHooks = ({ methodFields, canisterId, actorStore, callMethod, }) => {
+const getActorHooks = ({ initialize, serviceFields, canisterId, actorStore, callMethod, }) => {
     const useActorStore = () => {
         const actorState = (0, zustand_1.useStore)(actorStore, (state) => state);
         return Object.assign(Object.assign({}, actorState), { canisterId });
     };
+    const useServiceFields = () => {
+        return serviceFields;
+    };
+    const useMethodNames = () => {
+        const serviceField = useServiceFields();
+        return serviceField.methodNames;
+    };
     const useMethodFields = () => {
-        return methodFields;
+        const methodFields = useServiceFields();
+        return (0, react_1.useMemo)(() => {
+            return Object.values(methodFields.methods);
+        }, [methodFields]);
     };
     const useMethodField = (functionName) => {
-        const methodFields = useMethodFields();
-        const field = (0, react_1.useMemo)(() => {
-            return methodFields.find((f) => f.functionName === functionName);
-        }, [methodFields, functionName]);
-        return field;
+        const serviceMethod = useServiceFields();
+        return (0, react_1.useMemo)(() => serviceMethod.methods[functionName], [functionName, serviceMethod]);
     };
-    const useReActorCall = ({ onError, onSuccess, onLoading, args = [], functionName, }) => {
+    const useReActorCall = ({ onError, onSuccess, onLoading, args = [], functionName, throwOnError = false, }) => {
         const [state, setState] = (0, react_1.useState)({
             data: undefined,
             error: undefined,
             loading: false,
         });
-        const call = (0, react_1.useCallback)((replaceArgs) => __awaiter(void 0, void 0, void 0, function* () {
+        const call = (0, react_1.useCallback)((eventOrReplaceArgs) => __awaiter(void 0, void 0, void 0, function* () {
             onLoading === null || onLoading === void 0 ? void 0 : onLoading(true);
             onError === null || onError === void 0 ? void 0 : onError(undefined);
             setState((prevState) => (Object.assign(Object.assign({}, prevState), { loading: true, error: undefined })));
             try {
+                const replaceArgs = eventOrReplaceArgs !== undefined
+                    ? eventOrReplaceArgs.length > 0
+                        ? eventOrReplaceArgs
+                        : undefined
+                    : undefined;
                 const data = yield callMethod(functionName, ...(replaceArgs !== null && replaceArgs !== void 0 ? replaceArgs : args));
                 onLoading === null || onLoading === void 0 ? void 0 : onLoading(false);
                 onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(data);
@@ -60,41 +72,58 @@ const getActorHooks = ({ methodFields, canisterId, actorStore, callMethod, }) =>
                 onError === null || onError === void 0 ? void 0 : onError(error);
                 onLoading === null || onLoading === void 0 ? void 0 : onLoading(false);
                 setState((prevState) => (Object.assign(Object.assign({}, prevState), { error: error, loading: false })));
+                if (throwOnError)
+                    throw error;
             }
         }), [args, functionName, onError, onSuccess, onLoading]);
         const field = useMethodField(functionName);
         return Object.assign({ call, field }, state);
     };
     const useQueryCall = (_a) => {
-        var { autoRefresh, refreshInterval = 5000, disableInitialCall } = _a, rest = __rest(_a, ["autoRefresh", "refreshInterval", "disableInitialCall"]);
+        var { refetchOnMount = false, refetchInterval = false } = _a, rest = __rest(_a, ["refetchOnMount", "refetchInterval"]);
         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) {
+            if (refetchInterval) {
                 intervalId.current = setInterval(() => {
                     call();
-                }, refreshInterval);
+                }, refetchInterval);
             }
             // Initial call logic
-            if (!disableInitialCall) {
+            if (refetchOnMount) {
                 call();
             }
             return () => {
                 clearInterval(intervalId.current);
             };
-        }, [disableInitialCall, autoRefresh, refreshInterval]);
+        }, [refetchOnMount, refetchInterval]);
         return Object.assign({ call }, state);
     };
     const useUpdateCall = (args) => {
         return useReActorCall(args);
     };
+    const useMethodCall = (_a) => {
+        var { type } = _a, rest = __rest(_a, ["type"]);
+        switch (type) {
+            case "query":
+                return useQueryCall(rest);
+            case "update":
+                return useUpdateCall(rest);
+            default:
+                throw new Error(`Invalid type: ${type}`);
+        }
+    };
     return {
+        initialize,
         useQueryCall,
         useUpdateCall,
+        useMethodCall,
         useActorStore,
         useMethodField,
         useMethodFields,
+        useMethodNames,
+        useServiceFields,
     };
 };
 exports.getActorHooks = getActorHooks;

package/dist/hooks/auth.d.ts

@@ -1,8 +1,9 @@
 import type { AuthClientLoginOptions } from "@dfinity/auth-client";
 import type { AgentManager } from "@ic-reactor/store";
+export type AuthHooks = ReturnType<typeof getAuthHooks>;
 export declare const getAuthHooks: (agentManager: AgentManager) => {
     useAgentManager: () => AgentManager;
-    useAuthStore: () => import("@ic-reactor/store").ActorAuthState;
+    useAuthStore: () => import("@ic-reactor/store").AgentAuthState;
     useAuthClient: () => {
         authClient: import("@dfinity/auth-client").AuthClient | null;
         authenticated: boolean;

package/dist/index.d.ts

@@ -1,8 +1,23 @@
-import type { ActorSubclass, CreateReActorOptions } from "@ic-reactor/store";
-import { getActorHooks } from "./hooks/actor";
-import { getAuthHooks } from "./hooks/auth";
+import type { CreateReActorOptions } from "@ic-reactor/store";
+import { ActorHooks } from "./hooks/actor";
+import { AuthHooks } from "./hooks/auth";
 export { createReActorStore, createAgentManager, createActorManager, } from "@ic-reactor/store";
 export * from "./context/agent";
 export * from "./context/actor";
-export type ActorHooks<A extends ActorSubclass<any>> = ReturnType<typeof getActorHooks<A>> & ReturnType<typeof getAuthHooks>;
-export declare const createReActor: <A extends unknown>({ isLocal, ...options }: CreateReActorOptions) => ActorHooks<A>;
+export declare const createReActor: <A extends unknown>({ isLocalEnv, ...options }: CreateReActorOptions) => ActorHooks<A> & {
+    useAgentManager: () => import("@ic-reactor/store").AgentManager;
+    useAuthStore: () => import("@ic-reactor/store").AgentAuthState;
+    useAuthClient: () => {
+        authClient: import("@dfinity/auth-client").AuthClient | null;
+        authenticated: boolean;
+        authenticating: boolean;
+        identity: import("@ic-reactor/store").Identity | null;
+        login: (options?: import("@dfinity/auth-client").AuthClientLoginOptions | undefined) => Promise<void>;
+        logout: (options?: {
+            returnTo?: string | undefined;
+        } | undefined) => Promise<void>;
+        authenticate: () => Promise<void>;
+        loginLoading: boolean;
+        loginError: unknown;
+    };
+};

package/dist/index.js

@@ -36,16 +36,17 @@ Object.defineProperty(exports, "createActorManager", { enumerable: true, get: fu
 __exportStar(require("./context/agent"), exports);
 __exportStar(require("./context/actor"), exports);
 const createReActor = (_a) => {
-    var { isLocal } = _a, options = __rest(_a, ["isLocal"]);
-    isLocal =
-        isLocal ||
+    var { isLocalEnv } = _a, options = __rest(_a, ["isLocalEnv"]);
+    isLocalEnv =
+        isLocalEnv ||
             (typeof process !== "undefined" &&
                 (process.env.NODE_ENV === "development" ||
                     process.env.DFX_NETWORK === "local"));
-    const actorManager = (0, store_1.createReActorStore)(Object.assign({ isLocal }, options));
+    const actorManager = (0, store_1.createReActorStore)(Object.assign({ isLocalEnv }, options));
     const { useAuthClient, useAgentManager, useAuthStore } = (0, auth_1.getAuthHooks)(actorManager.agentManager);
-    const { useActorStore, useQueryCall, useMethodField, useMethodFields, useUpdateCall, } = (0, actor_1.getActorHooks)(actorManager);
+    const { initialize, useActorStore, useQueryCall, useUpdateCall, useMethodCall, useMethodField, useMethodFields, useMethodNames, useServiceFields, } = (0, actor_1.getActorHooks)(actorManager);
     return {
+        initialize,
         useAgentManager,
         useMethodFields,
         useMethodField,
@@ -53,7 +54,10 @@ const createReActor = (_a) => {
         useAuthStore,
         useQueryCall,
         useUpdateCall,
+        useMethodCall,
         useAuthClient,
+        useMethodNames,
+        useServiceFields,
     };
 };
 exports.createReActor = createReActor;

package/dist/types.d.ts

@@ -1,11 +1,13 @@
-import type { ExtractActorMethodArgs, ExtractActorMethodReturnType } from "@ic-reactor/store";
+import type { ExtractActorMethodArgs, ExtractActorMethodReturnType, ServiceMethodType } from "@ic-reactor/store";
 export type * from "@ic-reactor/store";
+export type * from "@ic-reactor/store/dist/actor/types";
 export type ActorCallArgs<A, M extends keyof A> = {
     functionName: M & string;
     args?: ExtractActorMethodArgs<A[M]>;
     onLoading?: (loading: boolean) => void;
-    onError?: (error: Error | unknown) => void;
+    onError?: (error: Error | undefined) => void;
     onSuccess?: (data: ExtractActorMethodReturnType<A[M]> | undefined) => void;
+    throwOnError?: boolean;
 };
 export type ActorHookState<A, M extends keyof A> = {
     data: ExtractActorMethodReturnType<A[M]> | undefined;
@@ -13,9 +15,9 @@ export type ActorHookState<A, M extends keyof A> = {
     loading: boolean;
 };
 export interface ActorUseQueryArgs<A, M extends keyof A> extends ActorCallArgs<A, M> {
-    disableInitialCall?: boolean;
-    autoRefresh?: boolean;
-    refreshInterval?: number;
+    refetchOnMount?: boolean;
+    refetchInterval?: number | false;
 }
 export interface ActorUseUpdateArgs<A, M extends keyof A> extends ActorCallArgs<A, M> {
 }
+export type ActorUseMethodArg<A, T extends ServiceMethodType> = T extends "query" ? ActorUseQueryArgs<A, keyof A> : ActorUseUpdateArgs<A, keyof A>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ic-reactor/react",
-  "version": "0.3.7",
+  "version": "0.4.0",
   "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.5",
+    "@ic-reactor/store": "^0.4.0",
     "zustand-utils": "^1.3"
   },
   "peerDependencies": {
@@ -48,5 +48,5 @@
     "react": ">=16.8",
     "zustand": "4.4"
   },
-  "gitHead": "2e01a26ea775885343887081ddff152944b6e9b2"
+  "gitHead": "b91b8bec6e0329d0a7cde22014d9222814311f23"
 }