@ic-reactor/react 2.0.0-alpha.0 → 2.0.1

package/dist/context/agent/create.js

@@ -1,20 +1,9 @@
 "use strict";
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAgentContext = void 0;
+exports.createAgentContext = createAgentContext;
 const react_1 = __importDefault(require("react"));
 const core_1 = require("@ic-reactor/core");
 const agentHooks_1 = require("../../helpers/agentHooks");
@@ -93,20 +82,23 @@ const extractAgentContext_1 = require("../../helpers/extractAgentContext");
  * with the Internet Computer blockchain.
  */
 function createAgentContext(config = {}) {
-    const { disableAuthenticateOnMount: defaultDisable } = config, contextOptions = __rest(config, ["disableAuthenticateOnMount"]);
+    const { disableAuthenticateOnMount: defaultDisable, ...contextOptions } = config;
     const AgentContext = react_1.default.createContext(null);
-    const AgentProvider = (_a) => {
-        var { children, agentManager: mybeAgentManager, disableAuthenticateOnMount = defaultDisable !== null && defaultDisable !== void 0 ? defaultDisable : false } = _a, options = __rest(_a, ["children", "agentManager", "disableAuthenticateOnMount"]);
+    const AgentProvider = ({ children, agentManager: mybeAgentManager, disableAuthenticateOnMount = defaultDisable ?? false, ...options }) => {
         const hooks = react_1.default.useMemo(() => {
-            const agentManager = mybeAgentManager !== null && mybeAgentManager !== void 0 ? mybeAgentManager : (0, core_1.createAgentManager)(Object.assign(Object.assign({}, options), contextOptions));
+            const agentManager = mybeAgentManager ??
+                (0, core_1.createAgentManager)({ ...options, ...contextOptions });
             if (!disableAuthenticateOnMount) {
                 agentManager.authenticate();
             }
-            return Object.assign(Object.assign(Object.assign({}, (0, agentHooks_1.agentHooks)(agentManager)), (0, authHooks_1.authHooks)(agentManager)), { agentManager });
+            return {
+                ...(0, agentHooks_1.agentHooks)(agentManager),
+                ...(0, authHooks_1.authHooks)(agentManager),
+                agentManager,
+            };
         }, []);
         return (react_1.default.createElement(AgentContext.Provider, { value: hooks }, children));
     };
     AgentProvider.displayName = "AgentProvider";
-    return Object.assign({ AgentContext, AgentProvider }, (0, extractAgentContext_1.extractAgentContext)(AgentContext));
+    return { AgentContext, AgentProvider, ...(0, extractAgentContext_1.extractAgentContext)(AgentContext) };
 }
-exports.createAgentContext = createAgentContext;

package/dist/context/agent/hooks/useAuth.d.ts

@@ -54,4 +54,4 @@
  *
  * This hook simplifies integrating authentication flows into your IC application, providing hooks for various stages of the authentication process.
  */
-export declare const useAuth: (options?: import("../../../types").UseAuthParameters | undefined) => import("../../../types").UseAuthReturnType;
+export declare const useAuth: (options?: import("../../../types").UseAuthParameters) => import("../../../types").UseAuthReturnType;

package/dist/context/agent/index.d.ts

@@ -1,4 +1,5 @@
-/// <reference types="react" />
+import { createAgentContext } from "./create";
+export { createAgentContext };
 /** @ignore */
 export declare const AgentHooks: import("./types").CreateAgentContextReturnType;
 export declare const AgentContext: import("react").Context<import("./types").AgentContext | null>;

package/dist/context/agent/index.js

@@ -14,8 +14,9 @@ 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 });
-exports.AgentContext = exports.AgentHooks = void 0;
+exports.AgentContext = exports.AgentHooks = exports.createAgentContext = void 0;
 const create_1 = require("./create");
+Object.defineProperty(exports, "createAgentContext", { enumerable: true, get: function () { return create_1.createAgentContext; } });
 /** @ignore */
 exports.AgentHooks = (0, create_1.createAgentContext)();
 exports.AgentContext = exports.AgentHooks.AgentContext;

package/dist/context/agent/provider.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 /**
  * `AgentProvider` is a React functional component that serves as a context provider for IC agent and authentication hooks.
  * It enables any child components to access and use the agent and authentication functionalities seamlessly.

package/dist/createReactor.js

@@ -58,7 +58,12 @@ const createReactor = (config) => {
     const getAgent = () => {
         return actorManager.agentManager.getAgent();
     };
-    return Object.assign(Object.assign(Object.assign({ getAgent,
-        getVisitFunction }, (0, helpers_1.actorHooks)(actorManager)), (0, helpers_1.authHooks)(actorManager.agentManager)), (0, helpers_1.agentHooks)(actorManager.agentManager));
+    return {
+        getAgent,
+        getVisitFunction,
+        ...(0, helpers_1.actorHooks)(actorManager),
+        ...(0, helpers_1.authHooks)(actorManager.agentManager),
+        ...(0, helpers_1.agentHooks)(actorManager.agentManager),
+    };
 };
 exports.createReactor = createReactor;

package/dist/helpers/actorHooks.js

@@ -15,33 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
+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"));
@@ -52,6 +42,7 @@ 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.
@@ -78,13 +69,15 @@ const actorHooks = (actorManager) => {
             name: state.name,
             error: state.error,
             version: state.version,
-            initialized: state.initialized,
-            initializing: state.initializing,
+            initialized: state.isInitialized,
+            isInitialized: state.isInitialized,
+            initializing: state.isInitializing,
+            isInitializing: state.isInitializing,
             canisterId,
         }));
     };
     const useMethodState = (functionName, requestKey) => {
-        const state = useActorStore((state) => { var _a; return (_a = state.methodState[functionName]) === null || _a === void 0 ? void 0 : _a[requestKey]; });
+        const state = useActorStore((state) => state.methodState[functionName]?.[requestKey]);
         const setSharedState = React.useCallback((newState) => {
             updateMethodState(functionName, requestKey, newState);
         }, [functionName, requestKey]);
@@ -113,43 +106,81 @@ const actorHooks = (actorManager) => {
             return visitFunction[functionName];
         }, [functionName]);
     };
-    const useSharedCall = (_a) => {
-        var { args = [], functionName, throwOnError = false, onError, onLoading, onSuccess } = _a, options = __rest(_a, ["args", "functionName", "throwOnError", "onError", "onLoading", "onSuccess"]);
+    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 reset = React.useCallback(() => updateMethodState(functionName, requestKey, DEFAULT_STATE), [functionName, requestKey]);
-        const call = React.useCallback((eventOrReplaceArgs) => __awaiter(void 0, void 0, void 0, function* () {
-            setSharedState({ error: undefined, loading: true });
-            onLoading === null || onLoading === void 0 ? void 0 : onLoading(true);
+        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 = yield callMethodWithOptions(options)(functionName, ...(replaceArgs !== null && replaceArgs !== void 0 ? replaceArgs : args));
-                setSharedState({ data, error: undefined, loading: false });
-                onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(data);
-                onLoading === null || onLoading === void 0 ? void 0 : onLoading(false);
+                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 === null || onError === void 0 ? void 0 : onError(error);
-                onLoading === null || onLoading === void 0 ? void 0 : onLoading(false);
+                onError?.(error);
+                onLoading?.(false);
                 if (throwOnError)
                     throw error;
+                return undefined;
             }
-        }), [args, functionName, options, onError, onLoading, onSuccess, throwOnError]);
-        return Object.assign({ call, reset, requestKey }, sharedState);
+        }, [
+            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 = (_a) => {
-        var { refetchOnMount = true, refetchInterval = false } = _a, rest = __rest(_a, ["refetchOnMount", "refetchInterval"]);
-        const _b = useSharedCall(rest), { call } = _b, state = __rest(_b, ["call"]);
-        const intervalId = React.useRef();
+    const useQueryCall = ({ refetchOnMount = true, refetchInterval = false, ...rest }) => {
+        const { call, requestKey, ...state } = useSharedCall(rest);
+        const intervalId = React.useRef(null);
         React.useEffect(() => {
-            var _a;
             if (refetchInterval) {
                 intervalId.current = setInterval(call, refetchInterval);
             }
@@ -157,11 +188,25 @@ const actorHooks = (actorManager) => {
                 call();
             }
             else if (refetchOnMount && state.data !== undefined) {
-                (_a = rest.onSuccess) === null || _a === void 0 ? void 0 : _a.call(rest, state.data);
+                rest.onSuccess?.(state.data);
+                const { isOk, value, error } = (0, utils_1.createCompiledResult)(state.data);
+                if (isOk) {
+                    rest.onSuccessResult?.(value);
+                }
+                else {
+                    rest.onErrorResult?.(error);
+                }
             }
-            return () => clearInterval(intervalId.current);
-        }, [refetchInterval, refetchOnMount]);
-        return Object.assign({ call, intervalId }, state);
+            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) => {
@@ -195,21 +240,28 @@ const actorHooks = (actorManager) => {
         }, [attributes]);
         let refetchOnMount = params.refetchOnMount;
         let refetchInterval = params.refetchInterval;
-        let formRequired = true;
+        let isFormRequired = true;
         switch (attributes.type) {
             case "query":
                 if (validateArgs(params.args)) {
-                    formRequired = params.refetchOnMount === false ? true : false;
+                    isFormRequired = params.refetchOnMount === false ? true : false;
                 }
                 else {
                     refetchOnMount = false;
                     refetchInterval = false;
                 }
-                return Object.assign(Object.assign({ visit,
-                    validateArgs }, useQueryCall(Object.assign(Object.assign({}, params), { refetchOnMount,
-                    refetchInterval }))), { formRequired });
+                return {
+                    visit,
+                    validateArgs,
+                    ...useQueryCall({
+                        ...params,
+                        refetchOnMount,
+                        refetchInterval,
+                    }),
+                    isFormRequired,
+                };
             case "update":
-                return Object.assign(Object.assign({ visit, validateArgs }, useUpdateCall(params)), { formRequired });
+                return { visit, validateArgs, ...useUpdateCall(params), isFormRequired };
             default:
                 throw new Error(`Method type ${attributes.type} not found`);
         }

package/dist/helpers/authHooks.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -19,100 +10,104 @@ 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 = () => { var _a, _b; return (_b = (_a = useAuthState()) === null || _a === void 0 ? void 0 : _a.identity) === null || _b === void 0 ? void 0 : _b.getPrincipal(); };
+    const useUserPrincipal = () => useAuthState()?.identity?.getPrincipal();
     const useAuth = ({ onAuthentication, onAuthenticationSuccess, onAuthenticationFailure, onLogin, onLoginSuccess, onLoginError, onLoggedOut, } = {}) => {
-        const network = react_1.default.useRef("ic");
         const [loginState, setLoginState] = react_1.default.useState({
             loading: false,
+            isLoading: false,
             error: undefined,
         });
-        const { authenticated, authenticating, error, identity } = useAuthState();
-        const authenticate = react_1.default.useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
+        const { isAuthenticated, isAuthenticating, error, identity } = useAuthState();
+        const authenticate = react_1.default.useCallback(async () => {
             const authenticatePromise = new Promise((resolve, reject) => {
                 authenticator()
                     .then((identity) => {
-                    onAuthenticationSuccess === null || onAuthenticationSuccess === void 0 ? void 0 : onAuthenticationSuccess(identity);
+                    onAuthenticationSuccess?.(identity);
                     resolve(identity);
                 })
                     .catch((e) => {
-                    onAuthenticationFailure === null || onAuthenticationFailure === void 0 ? void 0 : onAuthenticationFailure(e);
+                    onAuthenticationFailure?.(e);
                     reject(e);
                 });
             });
-            onAuthentication === null || onAuthentication === void 0 ? void 0 : onAuthentication(() => authenticatePromise);
+            onAuthentication?.(() => authenticatePromise);
             return authenticatePromise;
-        }), [
+        }, [
             authenticator,
             onAuthentication,
             onAuthenticationSuccess,
             onAuthenticationFailure,
         ]);
-        const login = react_1.default.useCallback((options) => __awaiter(void 0, void 0, void 0, function* () {
-            setLoginState({ loading: true, error: undefined });
+        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(Object.assign(Object.assign({ identityProvider: getIsLocal()
+                    authClient.login({
+                        identityProvider: getIsLocal()
                             ? utils_1.LOCAL_INTERNET_IDENTITY_PROVIDER
-                            : utils_1.IC_INTERNET_IDENTITY_PROVIDER }, options), { onSuccess: (msg) => {
+                            : utils_1.IC_INTERNET_IDENTITY_PROVIDER,
+                        ...options,
+                        onSuccess: (msg) => {
                             authenticate()
                                 .then((identity) => {
-                                var _a;
                                 const principal = identity.getPrincipal();
-                                (_a = options === null || options === void 0 ? void 0 : options.onSuccess) === null || _a === void 0 ? void 0 : _a.call(options, msg);
-                                onLoginSuccess === null || onLoginSuccess === void 0 ? void 0 : onLoginSuccess(principal);
+                                options?.onSuccess?.(msg);
+                                onLoginSuccess?.(principal);
                                 resolve(principal);
-                                setLoginState({ loading: false, error: undefined });
+                                setLoginState({
+                                    loading: false,
+                                    isLoading: false,
+                                    error: undefined,
+                                });
                             })
                                 .catch((error) => {
-                                setLoginState({ loading: false, error });
-                                onLoginError === null || onLoginError === void 0 ? void 0 : onLoginError(error);
+                                setLoginState({ loading: false, isLoading: false, error });
+                                onLoginError?.(error);
                                 reject(error);
                             });
-                        }, onError: (error) => {
-                            var _a;
-                            (_a = options === null || options === void 0 ? void 0 : options.onError) === null || _a === void 0 ? void 0 : _a.call(options, error);
-                            setLoginState({ loading: false, error });
-                            onLoginError === null || onLoginError === void 0 ? void 0 : onLoginError(error);
+                        },
+                        onError: (error) => {
+                            options?.onError?.(error);
+                            setLoginState({ loading: false, isLoading: false, error });
+                            onLoginError?.(error);
                             reject(error);
-                        } }));
+                        },
+                    });
                 }
                 catch (e) {
                     const error = e;
-                    setLoginState({ loading: false, error });
-                    onLoginError === null || onLoginError === void 0 ? void 0 : onLoginError(error);
+                    setLoginState({ loading: false, isLoading: false, error });
+                    onLoginError?.(error);
                     reject(error);
                 }
             });
-            onLogin === null || onLogin === void 0 ? void 0 : onLogin(() => loginPromise);
-        }), [onLogin, onLoginSuccess, onLoginError, authenticate]);
-        const logout = react_1.default.useCallback((options) => __awaiter(void 0, void 0, void 0, function* () {
+            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");
             }
-            yield authClient.logout(options);
-            yield authenticate();
-            onLoggedOut === null || onLoggedOut === void 0 ? void 0 : onLoggedOut();
-        }), [onLoggedOut]);
-        react_1.default.useEffect(() => agentManager.subscribeAgentState((state) => {
-            if (network.current !== state.network) {
-                network.current = state.network;
-                authenticate();
-            }
-        }), []);
+            await authClient.logout(options);
+            await authenticate();
+            onLoggedOut?.();
+        }, [onLoggedOut]);
         return {
-            authenticated,
-            authenticating,
+            isAuthenticated,
+            isAuthenticating,
+            authenticated: isAuthenticated,
+            authenticating: isAuthenticating,
             identity,
             error,
             login,
             logout,
             authenticate,
-            loginLoading: loginState.loading,
+            loginLoading: loginState.isLoading,
+            isLoginLoading: loginState.isLoading,
             loginError: loginState.error,
         };
     };

package/dist/helpers/extractActorContext.d.ts

@@ -1,4 +1,4 @@
 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">;
+export declare function extractActorContext<A = BaseActor>(actorContext: React.Context<CreateActorContextType<A> | null>): Omit<CreateActorContextReturnType<A>, "ActorProvider" | "ActorHookProvider" | "ActorManagerProvider">;

package/dist/helpers/extractActorContext.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractActorContext = void 0;
+exports.extractActorContext = extractActorContext;
 const react_1 = __importDefault(require("react"));
 function extractActorContext(actorContext) {
     const useActorContext = () => {
@@ -26,7 +26,7 @@ function extractActorContext(actorContext) {
     const useVisitMethod = (functionName) => useActorContext().useVisitMethod(functionName);
     const useVisitService = () => useActorContext().useVisitService();
     const useActorInterface = () => useActorContext().useActorInterface();
-    const useInitializeActor = () => { var _a, _b; return (_b = (_a = useActorContext()).useInitializeActor) === null || _b === void 0 ? void 0 : _b.call(_a); };
+    const useInitializeActor = () => useActorContext().useInitializeActor?.();
     return {
         useActorStore,
         useActorState,
@@ -42,4 +42,3 @@ function extractActorContext(actorContext) {
         initialize,
     };
 }
-exports.extractActorContext = extractActorContext;