@ic-reactor/react 0.4.5 → 0.5.1

package/dist/context/actor.d.ts

@@ -2,8 +2,8 @@ import React, { PropsWithChildren } from "react";
 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>;
+import { ActorHooksWithField } from "../types";
+export type ActorContextType<A = ActorSubclass<any>> = ActorHooksWithField<A>;
 export declare const ActorContext: React.Context<ActorContextType<any> | null>;
 type UseActorType = <A = ActorSubclass<any>>() => ActorContextType<A>;
 export declare const useActor: UseActorType;

package/dist/context/actor.js

@@ -58,7 +58,7 @@ const useActor = () => {
 };
 exports.useActor = useActor;
 const ActorProvider = (_a) => {
-    var { children, canisterId, agentContext, loadingComponent = react_1.default.createElement("div", null, "Loading...") } = _a, config = __rest(_a, ["children", "canisterId", "agentContext", "loadingComponent"]);
+    var { children, canisterId, agentContext, loadingComponent = react_1.default.createElement("div", null, "Loading..."), withServiceField = false } = _a, config = __rest(_a, ["children", "canisterId", "agentContext", "loadingComponent", "withServiceField"]);
     const agentManager = (0, agent_1.useAgentManager)(agentContext);
     const [didJs, setDidJS] = (0, react_1.useState)();
     const [fetching, setFetching] = (0, react_1.useState)(false);
@@ -112,6 +112,7 @@ const ActorProvider = (_a) => {
                 agentManager,
                 canisterId,
                 withDevtools: config.withDevtools,
+                withServiceField: withServiceField,
             });
         }
         catch (err) {

package/dist/hooks/actor.d.ts

@@ -1,41 +1,3 @@
-/// <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: 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: (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;
-        initialized: boolean;
-        initializing: boolean;
-        error: Error | undefined;
-        methodState: import("@ic-reactor/store").ActorMethodStates<A>;
-    };
-    useMethodField: (functionName: keyof A & string) => ExtractedFunction<A>;
-    useMethodFields: () => ExtractedFunction<A>[];
-    useMethodNames: () => ServiceMethodTypeAndName<A>[];
-    useServiceFields: () => ExtractedService<A>;
-};
+import type { ActorManager } from "@ic-reactor/store";
+import type { ActorHooks } from "../types";
+export declare const getActorHooks: <A extends unknown>({ initialize, serviceFields, withServiceField, canisterId, actorStore, callMethod, }: ActorManager<A>) => ActorHooks<A, boolean>;

package/dist/hooks/actor.js

@@ -23,27 +23,34 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getActorHooks = void 0;
 const react_1 = require("react");
 const zustand_1 = require("zustand");
-const getActorHooks = ({ initialize, serviceFields, canisterId, actorStore, callMethod, }) => {
+const getActorHooks = ({ initialize, serviceFields, withServiceField, canisterId, actorStore, callMethod, }) => {
     const useActorStore = () => {
         const actorState = (0, zustand_1.useStore)(actorStore, (state) => state);
         return Object.assign(Object.assign({}, actorState), { canisterId });
     };
     const useServiceFields = () => {
+        if (!withServiceField || !serviceFields) {
+            throw new Error("Service fields not initialized. Pass `withServiceField` to initialize service fields.");
+        }
         return serviceFields;
     };
-    const useMethodNames = () => {
-        const serviceField = useServiceFields();
-        return serviceField.methodNames;
+    const useMethods = () => {
+        const serviceFields = useServiceFields();
+        return (0, react_1.useMemo)(() => {
+            return Object.values(serviceFields.methods);
+        }, [serviceFields]);
     };
     const useMethodFields = () => {
-        const methodFields = useServiceFields();
+        const serviceFields = useServiceFields();
         return (0, react_1.useMemo)(() => {
-            return Object.values(methodFields.methods);
-        }, [methodFields]);
+            return Object.values(serviceFields.methodFields);
+        }, [serviceFields]);
     };
     const useMethodField = (functionName) => {
         const serviceMethod = useServiceFields();
-        return (0, react_1.useMemo)(() => serviceMethod.methods[functionName], [functionName, serviceMethod]);
+        return (0, react_1.useMemo)(() => {
+            return serviceMethod.methodFields[functionName];
+        }, [functionName, serviceMethod]);
     };
     const useReActorCall = ({ onError, onSuccess, onLoading, args = [], functionName, throwOnError = false, }) => {
         const [state, setState] = (0, react_1.useState)({
@@ -76,7 +83,9 @@ const getActorHooks = ({ initialize, serviceFields, canisterId, actorStore, call
                     throw error;
             }
         }), [args, functionName, onError, onSuccess, onLoading]);
-        const field = useMethodField(functionName);
+        const field = (0, react_1.useMemo)(() => {
+            return serviceFields === null || serviceFields === void 0 ? void 0 : serviceFields.methodFields[functionName];
+        }, [functionName]);
         return Object.assign({ call, field }, state);
     };
     const useQueryCall = (_a) => {
@@ -116,13 +125,13 @@ const getActorHooks = ({ initialize, serviceFields, canisterId, actorStore, call
     };
     return {
         initialize,
+        useMethods,
         useQueryCall,
         useUpdateCall,
         useMethodCall,
         useActorStore,
         useMethodField,
         useMethodFields,
-        useMethodNames,
         useServiceFields,
     };
 };

package/dist/hooks/auth.d.ts

@@ -1,8 +1,9 @@
 import type { AuthClientLoginOptions } from "@dfinity/auth-client";
-import type { AgentManager, Identity } from "@ic-reactor/store";
+import type { AgentManager, Identity, Principal } from "@ic-reactor/store";
 import { AuthArgs } from "../types";
 export type AuthHooks = ReturnType<typeof getAuthHooks>;
 export declare const getAuthHooks: (agentManager: AgentManager) => {
+    useUserPrincipal: () => Principal | undefined;
     useAgentManager: () => AgentManager;
     useAuthStore: () => import("@ic-reactor/store").AgentAuthState;
     useAuthClient: ({ onAuthentication, onAuthenticationSuccess, onAuthenticationFailure, onLogin, onLoginSuccess, onLoginError, onLoggedOut, }?: AuthArgs) => {

package/dist/hooks/auth.js

@@ -21,6 +21,10 @@ const getAuthHooks = (agentManager) => {
         const authState = (0, zustand_1.useStore)(authStore, (state) => state);
         return authState;
     };
+    const useUserPrincipal = () => {
+        const { identity } = useAuthStore();
+        return identity === null || identity === void 0 ? void 0 : identity.getPrincipal();
+    };
     const useAuthClient = ({ onAuthentication, onAuthenticationSuccess, onAuthenticationFailure, onLogin, onLoginSuccess, onLoginError, onLoggedOut, } = {}) => {
         const [loginLoading, setLoginLoading] = (0, react_1.useState)(false);
         const [loginError, setLoginError] = (0, react_1.useState)(null);
@@ -115,6 +119,7 @@ const getAuthHooks = (agentManager) => {
         };
     };
     return {
+        useUserPrincipal,
         useAgentManager,
         useAuthStore,
         useAuthClient,

package/dist/index.d.ts

@@ -1,23 +1,5 @@
-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";
+import { CreateReActor } from "./types";
+export * from "@ic-reactor/store";
 export * from "./context/agent";
 export * from "./context/actor";
-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: ({ onAuthentication, onAuthenticationSuccess, onAuthenticationFailure, onLogin, onLoginSuccess, onLoginError, onLoggedOut, }?: import("./types").AuthArgs) => {
-        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<import("@ic-reactor/store").Identity>;
-        loginLoading: boolean;
-        loginError: Error | null;
-    };
-};
+export declare const createReActor: CreateReActor;

package/dist/index.js

@@ -25,39 +25,22 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createReActor = exports.createActorManager = exports.createAgentManager = exports.createReActorStore = void 0;
+exports.createReActor = void 0;
 const store_1 = require("@ic-reactor/store");
 const actor_1 = require("./hooks/actor");
 const auth_1 = require("./hooks/auth");
-var store_2 = require("@ic-reactor/store");
-Object.defineProperty(exports, "createReActorStore", { enumerable: true, get: function () { return store_2.createReActorStore; } });
-Object.defineProperty(exports, "createAgentManager", { enumerable: true, get: function () { return store_2.createAgentManager; } });
-Object.defineProperty(exports, "createActorManager", { enumerable: true, get: function () { return store_2.createActorManager; } });
+__exportStar(require("@ic-reactor/store"), exports);
 __exportStar(require("./context/agent"), exports);
 __exportStar(require("./context/actor"), exports);
 const createReActor = (_a) => {
-    var { isLocalEnv } = _a, options = __rest(_a, ["isLocalEnv"]);
+    var { isLocalEnv, withServiceField } = _a, options = __rest(_a, ["isLocalEnv", "withServiceField"]);
     isLocalEnv =
         isLocalEnv ||
             (typeof process !== "undefined" &&
-                (process.env.NODE_ENV === "development" ||
-                    process.env.DFX_NETWORK === "local"));
-    const actorManager = (0, store_1.createReActorStore)(Object.assign({ isLocalEnv }, options));
-    const { useAuthClient, useAgentManager, useAuthStore } = (0, auth_1.getAuthHooks)(actorManager.agentManager);
-    const { initialize, useActorStore, useQueryCall, useUpdateCall, useMethodCall, useMethodField, useMethodFields, useMethodNames, useServiceFields, } = (0, actor_1.getActorHooks)(actorManager);
-    return {
-        initialize,
-        useAgentManager,
-        useMethodFields,
-        useMethodField,
-        useActorStore,
-        useAuthStore,
-        useQueryCall,
-        useUpdateCall,
-        useMethodCall,
-        useAuthClient,
-        useMethodNames,
-        useServiceFields,
-    };
+                (process.env.DFX_NETWORK === "local" ||
+                    process.env.NODE_ENV === "development"));
+    const actorManager = (0, store_1.createReActorStore)(Object.assign({ isLocalEnv,
+        withServiceField }, options));
+    return Object.assign(Object.assign({}, (0, actor_1.getActorHooks)(actorManager)), (0, auth_1.getAuthHooks)(actorManager.agentManager));
 };
 exports.createReActor = createReActor;

package/dist/types.d.ts

@@ -1,4 +1,6 @@
-import type { ExtractActorMethodArgs, ExtractActorMethodReturnType, Identity, Principal, ServiceMethodType } from "@ic-reactor/store";
+/// <reference types="react" />
+import type { ActorState, ActorSubclass, CanisterId, CreateReActorOptions, ExtractActorMethodArgs, ExtractActorMethodReturnType, ExtractedFunction, ExtractedService, Identity, Principal, ServiceMethodType, ServiceMethodTypeAndName } from "@ic-reactor/store";
+import { AuthHooks } from "./hooks/auth";
 export type * from "@ic-reactor/store";
 export type * from "@ic-reactor/store/dist/actor/types";
 export type AuthArgs = {
@@ -27,6 +29,49 @@ export interface ActorUseQueryArgs<A, M extends keyof A> extends ActorCallArgs<A
     refetchOnMount?: boolean;
     refetchInterval?: number | false;
 }
+export interface ActorUseQueryReturn<A, M extends keyof A, W extends boolean = false> {
+    call: (eventOrReplaceArgs?: React.MouseEvent | ExtractActorMethodArgs<A[M]>) => Promise<unknown>;
+    field: W extends true ? ExtractedFunction<A> : undefined;
+    data: unknown;
+    error: Error | undefined;
+    loading: boolean;
+}
 export interface ActorUseUpdateArgs<A, M extends keyof A> extends ActorCallArgs<A, M> {
 }
+export interface ActorUseUpdateReturn<A, M extends keyof A, W extends boolean = false> {
+    call: (eventOrReplaceArgs?: React.MouseEvent | ExtractActorMethodArgs<A[M]>) => Promise<unknown>;
+    field: W extends true ? ExtractedFunction<A> : undefined;
+    data: unknown;
+    error: Error | undefined;
+    loading: boolean;
+}
 export type ActorUseMethodArg<A, T extends ServiceMethodType> = T extends "query" ? ActorUseQueryArgs<A, keyof A> : ActorUseUpdateArgs<A, keyof A>;
+export type ActorHooksWithField<A> = ActorDefaultHooks<A, true> & ActorFieldHooks<A>;
+export type ActorHooksWithoutField<A> = ActorDefaultHooks<A, false>;
+export type ActorHooks<A, W extends boolean | undefined = undefined> = W extends true ? ActorHooksWithField<A> : W extends false ? ActorHooksWithoutField<A> : ActorHooksWithField<A> | ActorHooksWithoutField<A>;
+export interface ActorFieldHooks<A> {
+    useServiceFields: () => ExtractedService<A>;
+    useMethodFields: () => ExtractedFunction<A>[];
+    useMethodField: (functionName: keyof A & string) => ExtractedFunction<A>;
+}
+export type UseActorStoreReturn<A> = ActorState<A> & {
+    canisterId: CanisterId;
+};
+export interface ActorDefaultHooks<A, W extends boolean = false> {
+    initialize: () => Promise<void>;
+    useMethods: () => ServiceMethodTypeAndName<A>[];
+    useActorStore: () => UseActorStoreReturn<A>;
+    useQueryCall: <M extends keyof A>(args: ActorUseQueryArgs<A, M>) => ActorUseQueryReturn<A, M, W>;
+    useUpdateCall: <M extends keyof A>(args: ActorUseUpdateArgs<A, M>) => ActorUseUpdateReturn<A, M, W>;
+    useMethodCall: <M extends keyof A, T extends ServiceMethodType>(args: ActorUseMethodArg<A, T> & {
+        type: T;
+    }) => T extends "query" ? ActorUseQueryReturn<A, M, W> : ActorUseUpdateReturn<A, M, W>;
+}
+export type CreateReActor = {
+    <A extends ActorSubclass<any>>(options: CreateReActorOptions & {
+        withServiceField: true;
+    }): ActorHooksWithField<A> & AuthHooks;
+    <A extends ActorSubclass<any>>(options: CreateReActorOptions & {
+        withServiceField?: false | undefined;
+    }): ActorHooksWithoutField<A> & AuthHooks;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ic-reactor/react",
-  "version": "0.4.5",
+  "version": "0.5.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.4.3",
+    "@ic-reactor/store": "^0.5.1",
     "zustand-utils": "^1.3"
   },
   "peerDependencies": {
@@ -48,5 +48,5 @@
     "react": ">=16.8",
     "zustand": "4.4"
   },
-  "gitHead": "c28cdf54b97932fbf4b8f5fefecb36499df51eb7"
+  "gitHead": "86103827fe9a74cd8e910879168aa52e14eef4b8"
 }