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

package/dist/helpers/types.d.ts

@@ -1,222 +0,0 @@
-import { AgentError, CallConfig } from "@dfinity/agent";
-import type { IDL, ActorState, AuthClientLoginOptions, ActorMethodParameters, ActorMethodReturnType, Identity, Principal, FunctionName, VisitService, AuthState, HttpAgent, AgentState, BaseActor, MethodAttributes, CompiledResult, ExtractOk, ExtractErr } from "../types";
-export interface AgentHooksReturnType {
-    useAgent: () => HttpAgent | undefined;
-    useAgentState: () => AgentState;
-}
-export interface AuthHooksReturnType {
-    useAuth: (options?: UseAuthParameters) => UseAuthReturnType;
-    useAuthState: () => AuthState;
-    useUserPrincipal: () => Principal | undefined;
-}
-export interface UseAuthParameters {
-    onAuthentication?: (promise: () => Promise<Identity>) => void;
-    onAuthenticationSuccess?: (identity: Identity) => void;
-    onAuthenticationFailure?: (error: string | undefined) => void;
-    onLoginSuccess?: (principal: Principal) => void;
-    onLoginError?: (error: string | undefined) => void;
-    onLogin?: (promise: () => Promise<Principal>) => void;
-    onLoggedOut?: () => void;
-}
-/**
- * The return type for authentication hooks.
- */
-export interface UseAuthReturnType {
-    /**
-     * Any non-login related error that occurred.
-     */
-    error: Error | undefined;
-    /**
-     * @deprecated Use `isAuthenticated` instead.
-     * Indicates whether the user is authenticated.
-     */
-    authenticated: boolean;
-    /**
-     * Indicates whether the user is authenticated.
-     */
-    isAuthenticated: boolean;
-    /**
-     * @deprecated Use `isAuthenticating` instead.
-     * Indicates whether an authentication request is in progress.
-     */
-    authenticating: boolean;
-    /**
-     * Indicates whether an authentication request is in progress.
-     */
-    isAuthenticating: boolean;
-    /**
-     * The current identity object, or `null` if not authenticated.
-     */
-    identity: Identity | null;
-    /**
-     * Initiates the login flow with optional parameters.
-     * @param options Login parameters (e.g. redirect URL).
-     */
-    login: (options?: LoginParameters) => Promise<void>;
-    /**
-     * Logs the user out with optional parameters.
-     * @param options Logout parameters (e.g. return URL).
-     */
-    logout: (options?: LogoutParameters) => Promise<void>;
-    /**
-     * Triggers the authentication flow and resolves to an `Identity`.
-     */
-    authenticate: () => Promise<Identity>;
-    /**
-     * @deprecated Use `isLoginLoading` instead.
-     * Indicates whether the login operation is in progress.
-     */
-    loginLoading: boolean;
-    /**
-     * Indicates whether the login operation is in progress.
-     */
-    isLoginLoading: boolean;
-    /**
-     * The error message, if any, occurred during login.
-     */
-    loginError: string | undefined;
-}
-/**
- * Represents the state of a login operation.
- */
-export type LoginState = {
-    /**
-     * @deprecated Use `isLoading` instead.
-     * Indicates whether the login operation is in progress.
-     */
-    loading: boolean;
-    /**
-     * Indicates whether the login operation is in progress.
-     */
-    isLoading: boolean;
-    /**
-     * The error message, if any, occurred during login.
-     */
-    error: string | undefined;
-};
-export type LoginParameters = AuthClientLoginOptions;
-export type LogoutParameters = {
-    returnTo?: string;
-};
-export type UseActorStore<A> = <T>(callback?: (state: ActorState<A>) => T) => T;
-export interface UseActorStateReturnType extends Omit<ActorState, "methodState"> {
-    canisterId: string;
-}
-/**
- * State for shared calls, including the result, error, and loading status.
- */
-export type UseSharedCallState<A, M extends FunctionName<A>> = {
-    /**
-     * The data returned from the call, or `undefined` if not yet available.
-     */
-    data: ActorMethodReturnType<A[M]> | undefined;
-    /**
-     * The error that occurred during the call, or `undefined` if none.
-     */
-    error: AgentError | undefined;
-    /**
-     * @deprecated Use `isLoading` instead.
-     * Indicates whether the call is in progress.
-     */
-    loading: boolean;
-    /**
-     * Indicates whether the call is in progress.
-     */
-    isLoading: boolean;
-};
-export interface UseSharedCallParameters<A, M extends FunctionName<A>> extends CallConfig {
-    functionName: M;
-    args?: ActorMethodParameters<A[M]>;
-    onLoading?: (loading: boolean) => void;
-    onError?: (error: AgentError | undefined) => void;
-    onSuccess?: (data: ActorMethodReturnType<A[M]>) => void;
-    onSuccessResult?: (value: ExtractOk<ActorMethodReturnType<A[M]>>) => void;
-    onErrorResult?: (error: ExtractErr<ActorMethodReturnType<A[M]>>) => void;
-    throwOnError?: boolean;
-}
-export interface UseSharedCallReturnType<A, M extends FunctionName<A> = FunctionName<A>> extends UseSharedCallState<A, M> {
-    requestKey: string;
-    reset: () => void;
-    compileResult: () => CompiledResult<ActorMethodReturnType<A[M]>>;
-    call: (eventOrReplaceArgs?: ActorMethodParameters<A[M]> | React.MouseEvent) => Promise<ActorMethodReturnType<A[M]> | undefined>;
-}
-export type UseSharedCall<A> = <M extends FunctionName<A>>(params: UseSharedCallParameters<A, M>) => UseSharedCallReturnType<A, M>;
-export interface UseQueryCallParameters<A, M extends FunctionName<A>> extends UseSharedCallParameters<A, M> {
-    refetchOnMount?: boolean;
-    refetchInterval?: number | false;
-}
-export interface UseQueryCallReturnType<A, M extends FunctionName<A>> extends UseSharedCallReturnType<A, M> {
-    refetch: () => void;
-}
-export type UseQueryCall<A> = <M extends FunctionName<A>>(params: UseQueryCallParameters<A, M>) => UseQueryCallReturnType<A, M>;
-export type UseUpdateCallParameters<A, M extends FunctionName<A>> = UseSharedCallParameters<A, M>;
-export type UseUpdateCallReturnType<A, M extends FunctionName<A>> = UseSharedCallReturnType<A, M>;
-export type UseUpdateCall<A> = <M extends FunctionName<A>>(params: UseUpdateCallParameters<A, M>) => UseUpdateCallReturnType<A, M>;
-export interface DynamicDataArgs<V = unknown> {
-    label: string;
-    value: V;
-}
-export type UseMethodParameters<A, M extends FunctionName<A>> = UseQueryCallParameters<A, M>;
-export interface UseMethodReturnType<A, M extends FunctionName<A> = FunctionName<A>> {
-    /**
-     * @deprecated Use `isLoading` instead.
-     * Indicates whether the method call is in progress.
-     */
-    loading: boolean;
-    /**
-     * Indicates whether the method call is in progress.
-     */
-    isLoading: boolean;
-    /**
-     * Indicates whether the argument form is required for the method.
-     */
-    isFormRequired: boolean;
-    /**
-     * A unique key representing the current request instance.
-     */
-    requestKey: string;
-    /**
-     * The error that occurred during the method call, if any.
-     */
-    error: AgentError | undefined;
-    /**
-     * The data returned from the method call, or `undefined` if not yet available.
-     */
-    data: ActorMethodReturnType<A[M]> | undefined;
-    /**
-     * Validates the provided arguments against the method signature.
-     * @param args Optional arguments for the method.
-     * @returns `true` if the arguments match the expected signature, otherwise `false`.
-     */
-    validateArgs: (args?: ActorMethodParameters<A[M]>) => boolean;
-    /**
-     * The visit service function corresponding to this method.
-     */
-    visit: VisitService<A>[M];
-    /**
-     * Resets the method state (data, error, loading) to initial values.
-     */
-    reset: () => void;
-    /**
-     * Invokes the method.
-     * @param eventOrReplaceArgs Either the arguments for the call or a React mouse event.
-     * @returns A promise resolving to the method's return data or `undefined`.
-     */
-    call: (eventOrReplaceArgs?: ActorMethodParameters<A[M]> | React.MouseEvent) => Promise<ActorMethodReturnType<A[M]> | undefined>;
-}
-export type UseMethod<A> = <M extends FunctionName<A>>(args: UseMethodParameters<A, M>) => UseMethodReturnType<A, M>;
-export type UseVisitMethod<A> = <M extends FunctionName<A>>(functionName: M) => VisitService<A>[M];
-export type UseVisitService<A> = () => VisitService<A>;
-export interface ActorHooksReturnType<A = BaseActor> {
-    initialize: () => Promise<void>;
-    useActorStore: UseActorStore<A>;
-    useActorState: () => UseActorStateReturnType;
-    useActorInterface: () => IDL.ServiceClass;
-    useMethodNames: <Actor = A>() => FunctionName<Actor>[];
-    useMethodAttributes: <Actor = A>() => MethodAttributes<Actor>;
-    useMethod: UseMethod<A>;
-    useQueryCall: UseQueryCall<A>;
-    useUpdateCall: UseUpdateCall<A>;
-    useVisitMethod: UseVisitMethod<A>;
-    useVisitService: UseVisitService<A>;
-}

package/dist/helpers/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/hooks/types.d.ts

@@ -1,22 +0,0 @@
-import { IDL, ActorHooksReturnType, ActorManagerParameters, BaseActor, CanisterId, ActorManager } from "../types";
-export type ActorReConfigParameters = Omit<ActorManagerParameters, "idlFactory" | "canisterId" | "agentManager">;
-export interface UseActorParameters extends ActorReConfigParameters {
-    candidString?: string;
-    canisterId: CanisterId;
-    idlFactory?: IDL.InterfaceFactory;
-    disableAutoFetch?: boolean;
-}
-export interface UseActorManagerParameters<A> extends ActorReConfigParameters {
-    actorManager: ActorManager<A>;
-}
-export interface UseActorReturn<A = BaseActor> {
-    hooks: ActorHooksReturnType<A> | null;
-    isFetching: boolean;
-    fetchError: string | null;
-    isAuthenticating: boolean;
-    initializeActor: InitializeActor;
-}
-export interface UseActorManagerReturn<A = BaseActor> {
-    hooks: ActorHooksReturnType<A>;
-}
-export type InitializeActor = (idlFactory: IDL.InterfaceFactory, actorReConfig?: ActorReConfigParameters) => void;

package/dist/hooks/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/hooks/useActor.d.ts

@@ -1,67 +0,0 @@
-import type { BaseActor } from "../types";
-import type { UseActorParameters, UseActorReturn } from "./types";
-/**
- * A comprehensive hook that manages both the fetching of Candid interfaces
- * and the initialization of actor stores for Internet Computer (IC) canisters.
- * It simplifies the process of interacting with canisters by encapsulating
- * the logic for Candid retrieval and actor store management.
- *
- * You can use react context to share the actor hooks across your application.
- *
- * @example
- * ```tsx
- * import { AgentProvider, extractActorHooks, useActor } from "@ic-reactor/react"
- * import { createContext } from "react"
- * import type { ActorHooks } from "@ic-reactor/react/dist/types"
- * // With this import, you can have type safety for the actor's interface.
- * // You can get it from the `.did.d.ts` file generated by the DFX tool.
- * // or from dashboard https://dashboard.internetcomputer.org/canisters/<canister-id>
- * import type { Ledger } from "../declarations/ledger"
- *
- * const ActorContext = createContext<ActorHooks<Ledger> | null>(null)
- *
- * export const { useQueryCall, useUpdateCall } = extractActorHooks(ActorContext)
- *
- * const LedgerActor = ({ children }) => {
- *   const { hooks, fetching, fetchError } = useActor<Ledger>({
- *     canisterId: "ryjl3-tyaaa-aaaaa-aaaba-cai", // ICP Ledger canister
- *     idlFactory // optional: it will be fetched using CandidAdapter
- *   })
- *
- *   return (
- *     <ActorContext.Provider value={hooks}>
- *       <h2>IC Canister Interaction</h2>
- *       {fetching && <p>Loading Candid interface...</p>}
- *       {fetchError && <p>Error: {fetchError}</p>}
- *       {hooks && children}
- *     </ActorContext.Provider>
- *   )
- * }
- * // later in the code
- * const CanisterName = () => {
- *   const { data } = useQueryCall({
- *     functionName: "name",
- *   })
- *
- *   return (
- *     <div>
- *       <h3>Query Call</h3>
- *       <p>Result: {JSON.stringify(data)}</p>
- *     </div>
- *   )
- * }
- *
- * const App = () => (
- *   <AgentProvider withDevtools>
- *     <CandidAdapterProvider>
- *      <LedgerActor>
- *       <CanisterName />
- *      </LedgerActor>
- *    </CandidAdapterProvider>
- *   </AgentProvider>
- * )
- *
- * export default App
- * ```
- */
-export declare const useActor: <A = BaseActor>(config: UseActorParameters) => UseActorReturn<A>;

package/dist/hooks/useActor.js

@@ -1,197 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useActor = void 0;
-const core_1 = require("@ic-reactor/core");
-const react_1 = require("react");
-const helpers_1 = require("../helpers");
-const adapter_1 = require("../context/adapter");
-const agent_1 = require("../context/agent");
-/**
- * A comprehensive hook that manages both the fetching of Candid interfaces
- * and the initialization of actor stores for Internet Computer (IC) canisters.
- * It simplifies the process of interacting with canisters by encapsulating
- * the logic for Candid retrieval and actor store management.
- *
- * You can use react context to share the actor hooks across your application.
- *
- * @example
- * ```tsx
- * import { AgentProvider, extractActorHooks, useActor } from "@ic-reactor/react"
- * import { createContext } from "react"
- * import type { ActorHooks } from "@ic-reactor/react/dist/types"
- * // With this import, you can have type safety for the actor's interface.
- * // You can get it from the `.did.d.ts` file generated by the DFX tool.
- * // or from dashboard https://dashboard.internetcomputer.org/canisters/<canister-id>
- * import type { Ledger } from "../declarations/ledger"
- *
- * const ActorContext = createContext<ActorHooks<Ledger> | null>(null)
- *
- * export const { useQueryCall, useUpdateCall } = extractActorHooks(ActorContext)
- *
- * const LedgerActor = ({ children }) => {
- *   const { hooks, fetching, fetchError } = useActor<Ledger>({
- *     canisterId: "ryjl3-tyaaa-aaaaa-aaaba-cai", // ICP Ledger canister
- *     idlFactory // optional: it will be fetched using CandidAdapter
- *   })
- *
- *   return (
- *     <ActorContext.Provider value={hooks}>
- *       <h2>IC Canister Interaction</h2>
- *       {fetching && <p>Loading Candid interface...</p>}
- *       {fetchError && <p>Error: {fetchError}</p>}
- *       {hooks && children}
- *     </ActorContext.Provider>
- *   )
- * }
- * // later in the code
- * const CanisterName = () => {
- *   const { data } = useQueryCall({
- *     functionName: "name",
- *   })
- *
- *   return (
- *     <div>
- *       <h3>Query Call</h3>
- *       <p>Result: {JSON.stringify(data)}</p>
- *     </div>
- *   )
- * }
- *
- * const App = () => (
- *   <AgentProvider withDevtools>
- *     <CandidAdapterProvider>
- *      <LedgerActor>
- *       <CanisterName />
- *      </LedgerActor>
- *    </CandidAdapterProvider>
- *   </AgentProvider>
- * )
- *
- * export default App
- * ```
- */
-const useActor = (config) => {
-    const { canisterId, candidString, idlFactory: maybeIdlFactory, disableAutoFetch, ...actorConfig } = config;
-    if (!canisterId) {
-        throw new Error("canisterId is required");
-    }
-    const [actorManager, setActorManager] = (0, react_1.useState)(null);
-    (0, react_1.useEffect)(() => {
-        if (actorManager?.canisterId !== canisterId.toString()) {
-            setActorManager(null);
-        }
-        return actorManager?.cleanup();
-    }, [canisterId, actorManager]);
-    const [{ fetching, fetchError }, setState] = (0, react_1.useState)({
-        fetching: false,
-        fetchError: null,
-    });
-    const candidAdapter = (0, react_1.useContext)(adapter_1.CandidAdapterContext);
-    const authenticating = (0, agent_1.useAuthState)().isAuthenticating;
-    const fetchCandid = (0, react_1.useCallback)(async () => {
-        if (fetching)
-            return;
-        setState({
-            fetching: true,
-            fetchError: null,
-        });
-        try {
-            if (!candidAdapter) {
-                throw new Error("CandidAdapter is necessary to fetch the Candid interface. Please ensure your application is wrapped with the CandidAdapterProvider, or provide the idlFactory directly.");
-            }
-            const { idlFactory } = await candidAdapter.getCandidDefinition(canisterId);
-            setState({
-                fetching: false,
-                fetchError: null,
-            });
-            return idlFactory;
-        }
-        catch (err) {
-            // eslint-disable-next-line no-console
-            console.error(err);
-            setState({
-                fetchError: `Error fetching canister ${canisterId}`,
-                fetching: false,
-            });
-            return undefined;
-        }
-    }, [canisterId]);
-    const evaluateCandid = (0, react_1.useCallback)(async () => {
-        try {
-            if (!candidString) {
-                throw new Error("Candid string is required to evaluate the Candid definition");
-            }
-            const definition = await candidAdapter?.evaluateCandidDefinition(candidString);
-            if (typeof definition?.idlFactory !== "function") {
-                throw new Error("Error evaluating Candid definition");
-            }
-            return definition.idlFactory;
-        }
-        catch (err) {
-            // eslint-disable-next-line no-console
-            console.error(err);
-            setState({
-                fetchError: `Error evaluating Candid definition, ${err}`,
-                fetching: false,
-            });
-            return undefined;
-        }
-    }, [candidString]);
-    const agentManager = (0, agent_1.useAgentManager)();
-    const initializeActor = (0, react_1.useCallback)((idlFactory, actorReConfig) => {
-        if (authenticating || !idlFactory)
-            return;
-        const newActorManager = (0, core_1.createActorManager)({
-            agentManager,
-            idlFactory,
-            canisterId,
-            ...actorConfig,
-            ...actorReConfig,
-        });
-        setActorManager(newActorManager);
-    }, [canisterId, agentManager, authenticating]);
-    const handleActorInitialization = (0, react_1.useCallback)(async () => {
-        if (authenticating)
-            return;
-        if (maybeIdlFactory) {
-            initializeActor(maybeIdlFactory);
-            return;
-        }
-        if (disableAutoFetch) {
-            setState({
-                fetchError: "Candid interface not fetched!",
-                fetching: false,
-            });
-            return;
-        }
-        if (!candidAdapter) {
-            throw new Error("CandidAdapter is necessary to fetch the Candid interface. Please ensure your application is wrapped with the CandidAdapterProvider, or provide the idlFactory directly.");
-        }
-        let idlFactory;
-        if (candidString) {
-            idlFactory = await evaluateCandid();
-        }
-        else {
-            idlFactory = await fetchCandid();
-        }
-        if (!idlFactory)
-            return;
-        initializeActor(idlFactory);
-    }, [fetchCandid, evaluateCandid, maybeIdlFactory, initializeActor]);
-    (0, react_1.useEffect)(() => {
-        handleActorInitialization();
-    }, [handleActorInitialization]);
-    const hooks = (0, react_1.useMemo)(() => {
-        if (!actorManager)
-            return null;
-        return (0, helpers_1.actorHooks)(actorManager);
-    }, [actorManager]);
-    return {
-        hooks,
-        isAuthenticating: authenticating,
-        isFetching: fetching,
-        fetchError,
-        initializeActor,
-    };
-};
-exports.useActor = useActor;

package/dist/hooks/useActorManager.d.ts

@@ -1,68 +0,0 @@
-import type { BaseActor } from "../types";
-import type { UseActorManagerParameters, UseActorManagerReturn } from "./types";
-/**
- * A comprehensive hook that manages both the fetching of Candid interfaces
- * and the initialization of actor stores for Internet Computer (IC) canisters.
- * It simplifies the process of interacting with canisters by encapsulating
- * the logic for Candid retrieval and actor store management.
- *
- * You can use react context to share the actor hooks across your application.
- *
- * @example
- * ```tsx
- * import { AgentProvider, extractActorHooks, useActorManager } from "@ic-reactor/react"
- * import { createContext } from "react"
- * import type { ActorHooks } from "@ic-reactor/react/dist/types"
- * // With this import, you can have type safety for the actor's interface.
- * // You can get it from the `.did.d.ts` file generated by the DFX tool.
- * // or from dashboard https://dashboard.internetcomputer.org/canisters/<canister-id>
- * import type { Ledger } from "../declarations/ledger"
- *
- * const ActorContext = createContext<ActorHooks<Ledger> | null>(null)
- *
- * export const { useQueryCall, useUpdateCall } = extractActorHooks(ActorContext)
- *
- * const actorManager = createActorManager<Ledger>({
- *  canisterId: "ryjl3-tyaaa-aaaaa-aaaba-cai",
- *  idlFactory: idlFactory
- * })
- *
- * const LedgerActor = ({ children }) => {
- *   const { hooks } = useActorManager<Ledger>({
- *     actorManager
- *   })
- *
- *   return (
- *     <ActorContext.Provider value={hooks}>
- *       <h2>IC Canister Interaction</h2>
- *     </ActorContext.Provider>
- *   )
- * }
- * // later in the code
- * const CanisterName = () => {
- *   const { data } = useQueryCall({
- *     functionName: "name",
- *   })
- *
- *   return (
- *     <div>
- *       <h3>Query Call</h3>
- *       <p>Result: {JSON.stringify(data)}</p>
- *     </div>
- *   )
- * }
- *
- * const App = () => (
- *   <AgentProvider withDevtools>
- *     <CandidAdapterProvider>
- *      <LedgerActor>
- *       <CanisterName />
- *      </LedgerActor>
- *    </CandidAdapterProvider>
- *   </AgentProvider>
- * )
- *
- * export default App
- * ```
- */
-export declare const useActorManager: <A = BaseActor>(config: UseActorManagerParameters<A>) => UseActorManagerReturn<A>;

package/dist/hooks/useActorManager.js

@@ -1,75 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useActorManager = void 0;
-const helpers_1 = require("../helpers");
-/**
- * A comprehensive hook that manages both the fetching of Candid interfaces
- * and the initialization of actor stores for Internet Computer (IC) canisters.
- * It simplifies the process of interacting with canisters by encapsulating
- * the logic for Candid retrieval and actor store management.
- *
- * You can use react context to share the actor hooks across your application.
- *
- * @example
- * ```tsx
- * import { AgentProvider, extractActorHooks, useActorManager } from "@ic-reactor/react"
- * import { createContext } from "react"
- * import type { ActorHooks } from "@ic-reactor/react/dist/types"
- * // With this import, you can have type safety for the actor's interface.
- * // You can get it from the `.did.d.ts` file generated by the DFX tool.
- * // or from dashboard https://dashboard.internetcomputer.org/canisters/<canister-id>
- * import type { Ledger } from "../declarations/ledger"
- *
- * const ActorContext = createContext<ActorHooks<Ledger> | null>(null)
- *
- * export const { useQueryCall, useUpdateCall } = extractActorHooks(ActorContext)
- *
- * const actorManager = createActorManager<Ledger>({
- *  canisterId: "ryjl3-tyaaa-aaaaa-aaaba-cai",
- *  idlFactory: idlFactory
- * })
- *
- * const LedgerActor = ({ children }) => {
- *   const { hooks } = useActorManager<Ledger>({
- *     actorManager
- *   })
- *
- *   return (
- *     <ActorContext.Provider value={hooks}>
- *       <h2>IC Canister Interaction</h2>
- *     </ActorContext.Provider>
- *   )
- * }
- * // later in the code
- * const CanisterName = () => {
- *   const { data } = useQueryCall({
- *     functionName: "name",
- *   })
- *
- *   return (
- *     <div>
- *       <h3>Query Call</h3>
- *       <p>Result: {JSON.stringify(data)}</p>
- *     </div>
- *   )
- * }
- *
- * const App = () => (
- *   <AgentProvider withDevtools>
- *     <CandidAdapterProvider>
- *      <LedgerActor>
- *       <CanisterName />
- *      </LedgerActor>
- *    </CandidAdapterProvider>
- *   </AgentProvider>
- * )
- *
- * export default App
- * ```
- */
-const useActorManager = (config) => {
-    const { actorManager } = config;
-    const hooks = (0, helpers_1.actorHooks)(actorManager);
-    return { hooks };
-};
-exports.useActorManager = useActorManager;

package/dist/utils.d.ts

@@ -1 +0,0 @@
-export * from "@ic-reactor/core/dist/utils";

package/dist/utils.js

@@ -1,17 +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("@ic-reactor/core/dist/utils"), exports);