@ic-reactor/react 0.0.10 → 0.1.1

package/dist/hooks.d.ts

@@ -1,13 +1,6 @@
-import { CallMethod, ExtractReActorMethodArgs, ReActorState } from "@ic-reactor/store";
-import { StoreApi } from "zustand";
+import { CallMethod, ExtractReActorMethodArgs } from "@ic-reactor/store";
 import { ReActorUseQueryArgs, ReActorUseUpdateArgs } from "./types";
-export declare const getStateHooks: <A extends unknown>(store: StoreApi<ReActorState<A>>, callMethod: CallMethod<A>) => {
-    useReActor: () => ReActorState<A>;
-    useLoading: () => boolean;
-    useError: () => Error | undefined;
-    useInitialized: () => boolean;
-    useInitializing: () => boolean;
-    useActorState: () => import("@ic-reactor/store").ReActorActorState<A>;
+export declare const getCallHooks: <A extends unknown>(callMethod: CallMethod<A>) => {
     useQueryCall: <M extends keyof A>({ autoRefresh, refreshInterval, disableInitialCall, ...rest }: ReActorUseQueryArgs<A, M>) => {
         data: import("@ic-reactor/store").ExtractReActorMethodReturnType<A[M]> | undefined;
         error: Error | undefined;

package/dist/hooks.js

@@ -20,34 +20,9 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getStateHooks = void 0;
+exports.getCallHooks = void 0;
 const react_1 = require("react");
-const zustand_1 = require("zustand");
-const getStateHooks = (store, callMethod) => {
-    const useReActor = () => {
-        const state = (0, zustand_1.useStore)(store);
-        return state;
-    };
-    const useLoading = () => {
-        const loading = (0, zustand_1.useStore)(store, (state) => state.loading);
-        return loading;
-    };
-    const useError = () => {
-        const error = (0, zustand_1.useStore)(store, (state) => state.error);
-        return error;
-    };
-    const useInitialized = () => {
-        const initialized = (0, zustand_1.useStore)(store, (state) => state.initialized);
-        return initialized;
-    };
-    const useInitializing = () => {
-        const initializing = (0, zustand_1.useStore)(store, (state) => state.initializing);
-        return initializing;
-    };
-    const useActorState = () => {
-        const actorState = (0, zustand_1.useStore)(store, (state) => state.actorState);
-        return actorState;
-    };
+const getCallHooks = (callMethod) => {
     const useReActorCall = ({ onError, onSuccess, onLoading, args = [], functionName, }) => {
         const [state, setState] = (0, react_1.useState)({
             data: undefined,
@@ -66,6 +41,7 @@ const getStateHooks = (store, callMethod) => {
                 return data;
             }
             catch (error) {
+                console.error("Error in call:", error);
                 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 })));
@@ -98,14 +74,8 @@ const getStateHooks = (store, callMethod) => {
         return useReActorCall(args);
     };
     return {
-        useReActor,
-        useLoading,
-        useError,
-        useInitialized,
-        useInitializing,
-        useActorState,
         useQueryCall,
         useUpdateCall,
     };
 };
-exports.getStateHooks = getStateHooks;
+exports.getCallHooks = getCallHooks;

package/dist/index.d.ts

@@ -1,16 +1,10 @@
-/// <reference types="react" />
-import type { HttpAgent, HttpAgentOptions } from "@dfinity/agent";
+import type { HttpAgent } from "@dfinity/agent";
 import { AuthClientLoginOptions } from "@dfinity/auth-client";
-import type { ActorSubclass, ReActorStore } from "@ic-reactor/store";
-export type ReActorContextType<A = ActorSubclass<any>> = ReActorStore<A>;
-export interface CreateReActorOptions extends HttpAgentOptions {
-    initializeOnMount?: boolean;
-}
-export declare const createReActor: <A extends unknown>(actorInitializer: (agent: HttpAgent) => A, options?: CreateReActorOptions) => {
-    initializeActor: (agentOptions?: HttpAgentOptions | undefined, identity?: import("@dfinity/agent").Identity | undefined) => void;
-    useReActor: () => import("@ic-reactor/store").ReActorState<A>;
-    useLoading: () => boolean;
-    useError: () => Error | undefined;
+import type { ActorSubclass, ReActorAuthStore, ReActorOptions } from "@ic-reactor/store";
+export type ReActorContextType<A = ActorSubclass<any>> = ReActorAuthStore<A>;
+export declare const createReActor: <A extends unknown>(actorInitializer: (agent: HttpAgent) => A, options?: ReActorOptions) => {
+    useActorStore: () => import("@ic-reactor/store").ReActorActorState<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;
@@ -36,15 +30,4 @@ export declare const createReActor: <A extends unknown>(actorInitializer: (agent
         loginLoading: boolean;
         loginError: unknown;
     };
-    useActorState: () => import("@ic-reactor/store").ReActorActorState<A>;
-    useInitialized: () => boolean;
-    useInitializing: () => boolean;
-    initialize: (identity?: import("@dfinity/agent").Identity | undefined) => void;
-    authenticate: () => Promise<void>;
-    resetState: () => void;
-    updateState: (newState: Partial<import("@ic-reactor/store").ReActorState<A>>) => void;
-    callMethod: import("@ic-reactor/store").CallMethod<A>;
-    ReActorProvider: import("react").FC<{
-        children: React.ReactNode;
-    }>;
 };

package/dist/index.js

@@ -12,6 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createReActor = void 0;
 const store_1 = require("@ic-reactor/store");
 const react_1 = require("react");
+const zustand_1 = require("zustand");
 const hooks_1 = require("./hooks");
 const defaultCreateReActorOptions = {
     initializeOnMount: true,
@@ -21,28 +22,19 @@ const defaultCreateReActorOptions = {
 };
 const createReActor = (actorInitializer, options = {}) => {
     const optionsWithDefaults = Object.assign(Object.assign({}, defaultCreateReActorOptions), options);
-    const Context = (0, react_1.createContext)(undefined);
-    const { actions, initializeActor, store } = (0, store_1.createReActorStore)((agent) => actorInitializer(agent), optionsWithDefaults);
-    if (optionsWithDefaults.initializeOnMount) {
-        try {
-            initializeActor();
-        }
-        catch (e) {
-            console.error(e);
-        }
-    }
-    const ReActorProvider = ({ children, }) => {
-        (0, react_1.useEffect)(() => actions.resetState, [actions.resetState]);
-        return (0, react_1.createElement)(Context.Provider, { value: store }, children);
+    const { callMethod, authenticate, authStore, actorStore } = (0, store_1.createReActorStore)((agent) => actorInitializer(agent), optionsWithDefaults);
+    const useActorStore = () => {
+        const actorState = (0, zustand_1.useStore)(actorStore, (state) => state);
+        return actorState;
+    };
+    const useAuthStore = () => {
+        const authState = (0, zustand_1.useStore)(authStore, (state) => state);
+        return authState;
     };
-    const { useReActor, useLoading, useError, useQueryCall, useUpdateCall, useInitialized, useInitializing, useActorState, } = (0, hooks_1.getStateHooks)(store, actions.callMethod);
     const useAuthClient = () => {
         const [loginLoading, setLoginLoading] = (0, react_1.useState)(false);
         const [loginError, setLoginError] = (0, react_1.useState)(null);
-        const { authClient, authenticated, authenticating, identity } = useReActor();
-        const authenticate = () => __awaiter(void 0, void 0, void 0, function* () {
-            yield actions.authenticate();
-        });
+        const { authClient, authenticated, authenticating, identity } = useAuthStore();
         const login = (options) => __awaiter(void 0, void 0, void 0, function* () {
             setLoginLoading(true);
             setLoginError(null);
@@ -85,15 +77,13 @@ const createReActor = (actorInitializer, options = {}) => {
             loginError,
         };
     };
-    return Object.assign(Object.assign({ ReActorProvider }, actions), { initializeActor,
-        useReActor,
-        useLoading,
-        useError,
+    const { useQueryCall, useUpdateCall } = (0, hooks_1.getCallHooks)(callMethod);
+    return {
+        useActorStore,
+        useAuthStore,
         useQueryCall,
         useUpdateCall,
         useAuthClient,
-        useActorState,
-        useInitialized,
-        useInitializing });
+    };
 };
 exports.createReActor = createReActor;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ic-reactor/react",
-  "version": "0.0.10",
+  "version": "0.1.1",
   "description": "A React library for interacting with Dfinity actors",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -40,12 +40,13 @@
     "@dfinity/candid": "0.20",
     "@dfinity/identity": "^0.20",
     "@dfinity/principal": "^0.20",
-    "@ic-reactor/store": "^0.0.6",
-    "zustand": "4.4"
+    "@ic-reactor/store": "^0.1.1",
+    "zustand": "4.4",
+    "zustand-utils": "^1.3"
   },
   "peerDependencies": {
     "@peculiar/webcrypto": "1.4",
     "react": ">=16.8"
   },
-  "gitHead": "948b40598e08c2aa905da470d1952367ccf223ff"
+  "gitHead": "4e63567f41291e0368febc1e19d9eda570828d67"
 }