@ic-reactor/react 2.0.0 → 3.0.0-beta.1

package/dist/helpers/actorHooks.js

@@ -1,283 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.actorHooks = void 0;
-const React = __importStar(require("react"));
-const zustand_1 = require("zustand");
-const shallow_1 = require("zustand/react/shallow");
-const utils_1 = require("../utils");
-const DEFAULT_STATE = {
-    data: undefined,
-    error: undefined,
-    loading: false,
-    isLoading: false,
-};
-/**
- * Provides a set of React hooks designed for interacting with actors in an Internet Computer (IC) project using the React framework and Zustand for state management.
- *
- * @param actorManager An instance of ActorManager containing methods and properties to manage actors, including the actorStore, canisterId, visitFunction, callMethod, and initialize function.
- * @returns An object containing several hooks and utility functions for interacting with actors, managing state, and invoking actor methods.
- *
- * Hooks included:
- * - initialize: Function to initialize actor management.
- * - useActorState: Hook for accessing the actor's state including the canister ID.
- * - useVisitMethod: Hook for memoizing a method visit service for a given actor method name.
- * - useQueryCall: Hook specifically designed for query calls to actors with features such as automatic refetching on mount and at specified intervals.
- * - useUpdateCall: Hook specifically designed for update calls to actors with features such as error handling and loading state management.
- *
- * Each hook is designed to simplify the process of interacting with actors in IC projects by abstracting away the complexity of state management, error handling, and method invocation.
- */
-const actorHooks = (actorManager) => {
-    const { actorStore, canisterId, visitFunction, methodAttributes, updateMethodState, extractMethodAttributes, extractInterface, callMethodWithOptions, initialize, } = actorManager;
-    const useActorStore = (selector = (s) => s) => {
-        return (0, zustand_1.useStore)(actorStore, (0, shallow_1.useShallow)(selector));
-    };
-    const useActorState = () => {
-        return useActorStore((state) => ({
-            name: state.name,
-            error: state.error,
-            version: state.version,
-            initialized: state.isInitialized,
-            isInitialized: state.isInitialized,
-            initializing: state.isInitializing,
-            isInitializing: state.isInitializing,
-            canisterId,
-        }));
-    };
-    const useMethodState = (functionName, requestKey) => {
-        const state = useActorStore((state) => state.methodState[functionName]?.[requestKey]);
-        const setSharedState = React.useCallback((newState) => {
-            updateMethodState(functionName, requestKey, newState);
-        }, [functionName, requestKey]);
-        return [state, setSharedState];
-    };
-    const useMethodAttributes = () => {
-        return React.useMemo(extractMethodAttributes, [
-            actorManager,
-        ]);
-    };
-    const useMethodNames = () => {
-        const methodAttributes = useMethodAttributes();
-        return Object.keys(methodAttributes);
-    };
-    const useActorInterface = () => {
-        return extractInterface();
-    };
-    const useVisitService = () => {
-        return visitFunction;
-    };
-    const useVisitMethod = (functionName) => {
-        return React.useMemo(() => {
-            if (!visitFunction[functionName]) {
-                throw new Error(`Method ${functionName} not found`);
-            }
-            return visitFunction[functionName];
-        }, [functionName]);
-    };
-    const useSharedCall = ({ args = [], functionName, throwOnError = false, onError, onLoading, onSuccess, onSuccessResult, onErrorResult, ...options }) => {
-        const requestKey = React.useMemo(() => (0, utils_1.generateRequestHash)(args), [args]);
-        const [sharedState, setSharedState] = useMethodState(functionName, requestKey);
-        const latestDataRef = React.useRef(null);
-        const reset = React.useCallback(() => {
-            updateMethodState(functionName, requestKey, DEFAULT_STATE);
-            latestDataRef.current = null;
-        }, [functionName, requestKey]);
-        const call = React.useCallback(async (eventOrReplaceArgs) => {
-            setSharedState({ error: undefined, loading: true, isLoading: true });
-            onLoading?.(true);
-            try {
-                const replaceArgs = eventOrReplaceArgs instanceof Array ? eventOrReplaceArgs : args;
-                const data = await callMethodWithOptions(options)(functionName, ...(replaceArgs ?? args));
-                latestDataRef.current = data;
-                setSharedState({
-                    data,
-                    error: undefined,
-                    loading: false,
-                    isLoading: false,
-                });
-                onLoading?.(false);
-                onSuccess?.(data);
-                const { isOk, value, error } = (0, utils_1.createCompiledResult)(data);
-                if (isOk) {
-                    onSuccessResult?.(value);
-                }
-                else {
-                    onErrorResult?.(error);
-                    if (throwOnError) {
-                        throw error;
-                    }
-                }
-                return data;
-            }
-            catch (error) {
-                // eslint-disable-next-line no-console
-                console.error(`Error calling method ${functionName}:`, error);
-                latestDataRef.current = null;
-                setSharedState({
-                    error: error,
-                    loading: false,
-                    isLoading: false,
-                });
-                onError?.(error);
-                onLoading?.(false);
-                if (throwOnError)
-                    throw error;
-                return undefined;
-            }
-        }, [
-            args,
-            functionName,
-            options,
-            onError,
-            onLoading,
-            onSuccess,
-            onSuccessResult,
-            throwOnError,
-        ]);
-        const compileResult = () => {
-            return (0, utils_1.createCompiledResult)(latestDataRef.current || sharedState?.data);
-        };
-        return {
-            call,
-            reset,
-            compileResult,
-            requestKey,
-            ...sharedState,
-        };
-    };
-    const useQueryCall = ({ refetchOnMount = true, refetchInterval = false, ...rest }) => {
-        const { call, requestKey, ...state } = useSharedCall(rest);
-        const intervalId = React.useRef(null);
-        React.useEffect(() => {
-            if (refetchInterval) {
-                intervalId.current = setInterval(call, refetchInterval);
-            }
-            if (refetchOnMount && state.data === undefined) {
-                call();
-            }
-            else if (refetchOnMount && state.data !== undefined) {
-                rest.onSuccess?.(state.data);
-                const { isOk, value, error } = (0, utils_1.createCompiledResult)(state.data);
-                if (isOk) {
-                    rest.onSuccessResult?.(value);
-                }
-                else {
-                    rest.onErrorResult?.(error);
-                }
-            }
-            return () => {
-                if (intervalId.current) {
-                    clearInterval(intervalId.current);
-                }
-            };
-        }, [refetchInterval, refetchOnMount, requestKey]);
-        const refetch = () => {
-            call();
-        };
-        return { call, refetch, intervalId, requestKey, ...state };
-    };
-    const useUpdateCall = useSharedCall;
-    const useMethod = (params) => {
-        const attributes = React.useMemo(() => {
-            if (!methodAttributes[params.functionName]) {
-                throw new Error(`Method ${params.functionName} not found`);
-            }
-            return methodAttributes[params.functionName];
-        }, [params.functionName]);
-        const visit = React.useCallback((extractorClass, data) => visitFunction[params.functionName](extractorClass, data), [params.functionName]);
-        const validateArgs = React.useCallback((args, throwOnError = false) => {
-            if (attributes.numberOfArgs > 0) {
-                if (args === undefined || args.length === 0) {
-                    if (throwOnError) {
-                        throw new Error(`Method ${params.functionName} requires ${attributes.numberOfArgs} arguments, but none were provided.`);
-                    }
-                    return false;
-                }
-                try {
-                    attributes.validate(args);
-                    return true;
-                }
-                catch (error) {
-                    if (throwOnError) {
-                        throw error;
-                    }
-                    return false;
-                }
-            }
-            return true;
-        }, [attributes]);
-        let refetchOnMount = params.refetchOnMount;
-        let refetchInterval = params.refetchInterval;
-        let isFormRequired = true;
-        switch (attributes.type) {
-            case "query":
-                if (validateArgs(params.args)) {
-                    isFormRequired = params.refetchOnMount === false ? true : false;
-                }
-                else {
-                    refetchOnMount = false;
-                    refetchInterval = false;
-                }
-                return {
-                    visit,
-                    validateArgs,
-                    ...useQueryCall({
-                        ...params,
-                        refetchOnMount,
-                        refetchInterval,
-                    }),
-                    isFormRequired,
-                };
-            case "update":
-                return { visit, validateArgs, ...useUpdateCall(params), isFormRequired };
-            default:
-                throw new Error(`Method type ${attributes.type} not found`);
-        }
-    };
-    return {
-        initialize,
-        useActorStore,
-        useMethodAttributes,
-        useMethodNames,
-        useMethod,
-        useQueryCall,
-        useUpdateCall,
-        useActorState,
-        useVisitMethod,
-        useVisitService,
-        useActorInterface,
-    };
-};
-exports.actorHooks = actorHooks;

package/dist/helpers/agentHooks.d.ts

@@ -1,3 +0,0 @@
-import type { AgentManager } from "@ic-reactor/core/dist/types";
-import type { AgentHooksReturnType } from "./types";
-export declare const agentHooks: (agentManager: AgentManager) => AgentHooksReturnType;

package/dist/helpers/agentHooks.js

@@ -1,22 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.agentHooks = void 0;
-const react_1 = __importDefault(require("react"));
-const zustand_1 = require("zustand");
-const agentHooks = (agentManager) => {
-    const { agentStore, getAgent, subscribeAgent } = agentManager;
-    const useAgentState = () => (0, zustand_1.useStore)(agentStore);
-    const useAgent = () => {
-        const [agent, setAgent] = react_1.default.useState(getAgent);
-        react_1.default.useEffect(() => subscribeAgent(setAgent), [subscribeAgent]);
-        return agent;
-    };
-    return {
-        useAgent,
-        useAgentState,
-    };
-};
-exports.agentHooks = agentHooks;

package/dist/helpers/authHooks.d.ts

@@ -1,2 +0,0 @@
-import type { AgentManager, AuthHooksReturnType } from "../types";
-export declare const authHooks: (agentManager: AgentManager) => AuthHooksReturnType;

package/dist/helpers/authHooks.js

@@ -1,120 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.authHooks = void 0;
-const react_1 = __importDefault(require("react"));
-const zustand_1 = require("zustand");
-const utils_1 = require("@ic-reactor/core/dist/utils");
-const authHooks = (agentManager) => {
-    const { authenticate: authenticator, getIsLocal, getAuth, authStore, } = agentManager;
-    const useAuthState = () => (0, zustand_1.useStore)(authStore);
-    const useUserPrincipal = () => useAuthState()?.identity?.getPrincipal();
-    const useAuth = ({ onAuthentication, onAuthenticationSuccess, onAuthenticationFailure, onLogin, onLoginSuccess, onLoginError, onLoggedOut, } = {}) => {
-        const [loginState, setLoginState] = react_1.default.useState({
-            loading: false,
-            isLoading: false,
-            error: undefined,
-        });
-        const { isAuthenticated, isAuthenticating, error, identity } = useAuthState();
-        const authenticate = react_1.default.useCallback(async () => {
-            const authenticatePromise = new Promise((resolve, reject) => {
-                authenticator()
-                    .then((identity) => {
-                    onAuthenticationSuccess?.(identity);
-                    resolve(identity);
-                })
-                    .catch((e) => {
-                    onAuthenticationFailure?.(e);
-                    reject(e);
-                });
-            });
-            onAuthentication?.(() => authenticatePromise);
-            return authenticatePromise;
-        }, [
-            authenticator,
-            onAuthentication,
-            onAuthenticationSuccess,
-            onAuthenticationFailure,
-        ]);
-        const login = react_1.default.useCallback(async (options) => {
-            setLoginState({ loading: true, isLoading: true, error: undefined });
-            const loginPromise = new Promise((resolve, reject) => {
-                try {
-                    const authClient = getAuth();
-                    if (!authClient) {
-                        throw new Error("Auth client not initialized");
-                    }
-                    authClient.login({
-                        identityProvider: getIsLocal()
-                            ? utils_1.LOCAL_INTERNET_IDENTITY_PROVIDER
-                            : utils_1.IC_INTERNET_IDENTITY_PROVIDER,
-                        ...options,
-                        onSuccess: (msg) => {
-                            authenticate()
-                                .then((identity) => {
-                                const principal = identity.getPrincipal();
-                                options?.onSuccess?.(msg);
-                                onLoginSuccess?.(principal);
-                                resolve(principal);
-                                setLoginState({
-                                    loading: false,
-                                    isLoading: false,
-                                    error: undefined,
-                                });
-                            })
-                                .catch((error) => {
-                                setLoginState({ loading: false, isLoading: false, error });
-                                onLoginError?.(error);
-                                reject(error);
-                            });
-                        },
-                        onError: (error) => {
-                            options?.onError?.(error);
-                            setLoginState({ loading: false, isLoading: false, error });
-                            onLoginError?.(error);
-                            reject(error);
-                        },
-                    });
-                }
-                catch (e) {
-                    const error = e;
-                    setLoginState({ loading: false, isLoading: false, error });
-                    onLoginError?.(error);
-                    reject(error);
-                }
-            });
-            onLogin?.(() => loginPromise);
-        }, [onLogin, onLoginSuccess, onLoginError, authenticate]);
-        const logout = react_1.default.useCallback(async (options) => {
-            const authClient = getAuth();
-            if (!authClient) {
-                throw new Error("Auth client not initialized");
-            }
-            await authClient.logout(options);
-            await authenticate();
-            onLoggedOut?.();
-        }, [onLoggedOut]);
-        return {
-            isAuthenticated,
-            isAuthenticating,
-            authenticated: isAuthenticated,
-            authenticating: isAuthenticating,
-            identity,
-            error,
-            login,
-            logout,
-            authenticate,
-            loginLoading: loginState.isLoading,
-            isLoginLoading: loginState.isLoading,
-            loginError: loginState.error,
-        };
-    };
-    return {
-        useUserPrincipal,
-        useAuthState,
-        useAuth,
-    };
-};
-exports.authHooks = authHooks;

package/dist/helpers/extractActorContext.d.ts

@@ -1,4 +0,0 @@
-import React from "react";
-import type { BaseActor } from "../types";
-import type { CreateActorContextReturnType, CreateActorContextType } from "../context/actor/types";
-export declare function extractActorContext<A = BaseActor>(actorContext: React.Context<CreateActorContextType<A> | null>): Omit<CreateActorContextReturnType<A>, "ActorProvider" | "ActorHookProvider" | "ActorManagerProvider">;

package/dist/helpers/extractActorContext.js

@@ -1,44 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractActorContext = extractActorContext;
-const react_1 = __importDefault(require("react"));
-function extractActorContext(actorContext) {
-    const useActorContext = () => {
-        const context = react_1.default.useContext(actorContext);
-        if (!context) {
-            throw new Error("Actor hooks must be used within a ActorProvider");
-        }
-        return context;
-    };
-    const initialize = () => useActorContext().initialize();
-    const useMethodNames = () => useActorContext().useMethodNames();
-    const useMethodAttributes = () => useActorContext().useMethodAttributes();
-    const useActorStore = (selector = (s) => s) => {
-        return useActorContext().useActorStore(selector);
-    };
-    const useActorState = () => useActorContext().useActorState();
-    const useMethod = (args) => useActorContext().useMethod(args);
-    const useQueryCall = (args) => useActorContext().useQueryCall(args);
-    const useUpdateCall = (args) => useActorContext().useUpdateCall(args);
-    const useVisitMethod = (functionName) => useActorContext().useVisitMethod(functionName);
-    const useVisitService = () => useActorContext().useVisitService();
-    const useActorInterface = () => useActorContext().useActorInterface();
-    const useInitializeActor = () => useActorContext().useInitializeActor?.();
-    return {
-        useActorStore,
-        useActorState,
-        useMethod,
-        useMethodNames,
-        useMethodAttributes,
-        useQueryCall,
-        useUpdateCall,
-        useVisitMethod,
-        useVisitService,
-        useActorInterface,
-        useInitializeActor,
-        initialize,
-    };
-}

package/dist/helpers/extractAgentContext.d.ts

@@ -1,28 +0,0 @@
-import React from "react";
-import type { AgentContext, CreateAgentContextReturnType } from "../types";
-/**
- * This function facilitates the use of contextually provided agent functionalities,
- * such as managing the agent's state, authentication state, and user principal.
- *
- * @param agentContext A React context object of type AgentContext or null,
- * typically provided by an AgentProvider at a higher level in the component tree.
- * @returns An object containing the following hooks:
- *  - useAgent: Hook for accessing the current agent instance.
- *  - useAuthState: Hook for accessing the current authentication state.
- *  - useAgentState: Hook for accessing the current state of the agent.
- *  - useAuth: Hook for accessing the authentication client, optionally accepting arguments for configuration.
- *  - useAgentManager: Hook for accessing the AgentManager instance.
- *  - useUserPrincipal: Hook for accessing the user's principal.
- *
- * Each hook is designed to be used within components that are descendants of an AgentProvider,
- * ensuring access to the necessary agent-related context.
- *
- * Throws:
- *  - Error if used outside of an AgentProvider context.
- *
- * ### Integration
- *
- * To use these hooks, ensure your components are wrapped in an `AgentProvider` that you've set up to supply the `AgentContext`.
- * This context provides the necessary agent functionalities and state management capabilities required by the hooks.
- */
-export declare const extractAgentContext: (agentContext: React.Context<AgentContext | null>) => Omit<CreateAgentContextReturnType, "AgentProvider" | "AgentContext">;

package/dist/helpers/extractAgentContext.js

@@ -1,59 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractAgentContext = void 0;
-const react_1 = __importDefault(require("react"));
-/**
- * This function facilitates the use of contextually provided agent functionalities,
- * such as managing the agent's state, authentication state, and user principal.
- *
- * @param agentContext A React context object of type AgentContext or null,
- * typically provided by an AgentProvider at a higher level in the component tree.
- * @returns An object containing the following hooks:
- *  - useAgent: Hook for accessing the current agent instance.
- *  - useAuthState: Hook for accessing the current authentication state.
- *  - useAgentState: Hook for accessing the current state of the agent.
- *  - useAuth: Hook for accessing the authentication client, optionally accepting arguments for configuration.
- *  - useAgentManager: Hook for accessing the AgentManager instance.
- *  - useUserPrincipal: Hook for accessing the user's principal.
- *
- * Each hook is designed to be used within components that are descendants of an AgentProvider,
- * ensuring access to the necessary agent-related context.
- *
- * Throws:
- *  - Error if used outside of an AgentProvider context.
- *
- * ### Integration
- *
- * To use these hooks, ensure your components are wrapped in an `AgentProvider` that you've set up to supply the `AgentContext`.
- * This context provides the necessary agent functionalities and state management capabilities required by the hooks.
- */
-const extractAgentContext = (agentContext) => {
-    const useAgentContext = () => {
-        const context = react_1.default.useContext(agentContext);
-        if (!context) {
-            throw new Error("Agent hooks must be used within a AgentProvider");
-        }
-        return context;
-    };
-    const useAgentManager = () => {
-        const context = useAgentContext();
-        return context.agentManager;
-    };
-    const useAgent = () => useAgentContext().useAgent();
-    const useAuthState = () => useAgentContext().useAuthState();
-    const useAgentState = () => useAgentContext().useAgentState();
-    const useAuth = (args) => useAgentContext().useAuth(args);
-    const useUserPrincipal = () => useAgentContext().useUserPrincipal();
-    return {
-        useAgent,
-        useAuthState,
-        useAgentState,
-        useAuth,
-        useAgentManager,
-        useUserPrincipal,
-    };
-};
-exports.extractAgentContext = extractAgentContext;

package/dist/helpers/index.d.ts

@@ -1,5 +0,0 @@
-export * from "./agentHooks";
-export * from "./actorHooks";
-export * from "./authHooks";
-export * from "./extractActorContext";
-export * from "./extractAgentContext";

package/dist/helpers/index.js

@@ -1,21 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./agentHooks"), exports);
-__exportStar(require("./actorHooks"), exports);
-__exportStar(require("./authHooks"), exports);
-__exportStar(require("./extractActorContext"), exports);
-__exportStar(require("./extractAgentContext"), exports);