@ic-reactor/react 1.15.0 → 1.15.1

package/dist/context/actor/create.js

@@ -18,6 +18,7 @@ exports.createActorContext = createActorContext;
 const react_1 = __importDefault(require("react"));
 const useActor_1 = require("../../hooks/useActor");
 const extractActorContext_1 = require("../../helpers/extractActorContext");
+const useActorManager_1 = require("../../hooks/useActorManager");
 /**
  * Creates a React context specifically designed for managing the state and interactions with an actor on the Internet Computer (IC) blockchain.
  * This context facilitates the dynamic creation and management of IC actors within React applications, leveraging the provided configuration options.
@@ -109,6 +110,13 @@ function createActorContext(contextConfig = {}) {
     const ActorHookProvider = ({ hooks, children, }) => {
         return (react_1.default.createElement(ActorContext.Provider, { value: hooks }, children));
     };
+    const ActorManagerProvider = ({ actorManager, children, }) => {
+        const { hooks } = (0, useActorManager_1.useActorManager)({
+            actorManager,
+        });
+        return (react_1.default.createElement(ActorContext.Provider, { value: hooks }, children));
+    };
     return Object.assign({ ActorProvider,
-        ActorHookProvider }, (0, extractActorContext_1.extractActorContext)(ActorContext));
+        ActorHookProvider,
+        ActorManagerProvider }, (0, extractActorContext_1.extractActorContext)(ActorContext));
 }

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

@@ -47,3 +47,25 @@ export declare const ActorProvider: import("react").FC<import("./types").ActorPr
  * This setup ensures that `YourComponent` and any of its children can interact with the specified IC actor hooks through the context provided by `ActorHookProvider`.
  */
 export declare const ActorHookProvider: import("react").FC<import("./types").ActorHookProviderProps<import("@ic-reactor/core/dist/types").BaseActor>>;
+/**
+ * `ActorManagerProvider` is a React functional component that serves as a context provider for IC actor managers within a React application.
+ * It wraps child components, providing them access to actor-specific manager functionalities based on the provided actor manager and configuration.
+ *
+ * Props:
+ * - `actorManager`: ActorManager - The actor manager object containing the actor manager functionalities.
+ * - `children`: React Node - The child components that will have access to the actor manager context.
+ *
+ * Behavior:
+ * - Validates the presence of the `actorManager`. Throws an error if it is missing, ensuring that the actor manager is always available for actor operations.
+ * - Utilizes `useMemo` to memoize the `actorManager`, optimizing for performance by avoiding unnecessary recalculations.
+ * - Renders the child components once the `actorManager` is available, effectively providing them access to the actor manager context.
+ *
+ * @example
+ * ```jsx
+ * <ActorManagerProvider actorManager={yourActorManager}>
+ *   <YourComponent />
+ * </ActorManagerProvider>
+ * ```
+ * This setup ensures that `YourComponent` and any of its children can interact with the specified IC actor manager through the context provided by `ActorManagerProvider`.
+ */
+export declare const ActorManagerProvider: import("react").FC<import("./types").ActorManagerProviderProps<import("@ic-reactor/core/dist/types").BaseActor>>;

package/dist/context/actor/provider.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ActorHookProvider = exports.ActorProvider = void 0;
+exports.ActorManagerProvider = exports.ActorHookProvider = exports.ActorProvider = void 0;
 const _1 = require(".");
 /**
  * `ActorProvider` is a React functional component that serves as a context provider for IC actor interactions within a React application.
@@ -51,3 +51,25 @@ exports.ActorProvider = _1.ActorHooks.ActorProvider;
  * This setup ensures that `YourComponent` and any of its children can interact with the specified IC actor hooks through the context provided by `ActorHookProvider`.
  */
 exports.ActorHookProvider = _1.ActorHooks.ActorHookProvider;
+/**
+ * `ActorManagerProvider` is a React functional component that serves as a context provider for IC actor managers within a React application.
+ * It wraps child components, providing them access to actor-specific manager functionalities based on the provided actor manager and configuration.
+ *
+ * Props:
+ * - `actorManager`: ActorManager - The actor manager object containing the actor manager functionalities.
+ * - `children`: React Node - The child components that will have access to the actor manager context.
+ *
+ * Behavior:
+ * - Validates the presence of the `actorManager`. Throws an error if it is missing, ensuring that the actor manager is always available for actor operations.
+ * - Utilizes `useMemo` to memoize the `actorManager`, optimizing for performance by avoiding unnecessary recalculations.
+ * - Renders the child components once the `actorManager` is available, effectively providing them access to the actor manager context.
+ *
+ * @example
+ * ```jsx
+ * <ActorManagerProvider actorManager={yourActorManager}>
+ *   <YourComponent />
+ * </ActorManagerProvider>
+ * ```
+ * This setup ensures that `YourComponent` and any of its children can interact with the specified IC actor manager through the context provided by `ActorManagerProvider`.
+ */
+exports.ActorManagerProvider = _1.ActorHooks.ActorManagerProvider;

package/dist/context/actor/types.d.ts

@@ -1,16 +1,21 @@
-import type { IDL, ActorHooksReturnType, BaseActor, ActorManagerParameters, CanisterId, InitializeActor } from "../../types";
+import type { IDL, ActorHooksReturnType, BaseActor, ActorManagerParameters, CanisterId, InitializeActor, ActorManager } from "../../types";
 export interface CreateActorContextType<A = BaseActor> extends ActorHooksReturnType<A> {
     useInitializeActor?: () => InitializeActor;
 }
 export interface CreateActorContextReturnType<A = BaseActor> extends ActorHooksReturnType<A> {
     ActorProvider: React.FC<ActorProviderProps>;
     ActorHookProvider: React.FC<ActorHookProviderProps<A>>;
+    ActorManagerProvider: React.FC<ActorManagerProviderProps<A>>;
     useInitializeActor: () => InitializeActor;
 }
 export interface ActorHookProviderProps<A> {
     hooks: ActorHooksReturnType<A>;
     children?: React.ReactNode;
 }
+export interface ActorManagerProviderProps<A> {
+    children?: React.ReactNode | undefined;
+    actorManager: ActorManager<A>;
+}
 export interface ActorProviderProps extends CreateActorContextParameters {
     children?: React.ReactNode | undefined;
     candidString?: string;

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/hooks/index.d.ts

@@ -1 +1,2 @@
 export * from "./useActor";
+export * from "./useActorManager";

package/dist/hooks/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./useActor"), exports);
+__exportStar(require("./useActorManager"), exports);

package/dist/hooks/types.d.ts

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

package/dist/hooks/useActorManager.d.ts

@@ -0,0 +1,68 @@
+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

@@ -0,0 +1,75 @@
+"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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ic-reactor/react",
-  "version": "1.15.0",
+  "version": "1.15.1",
   "description": "A React library for interacting with Internet Computer canisters",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -48,7 +48,7 @@
     "react": ">=16.8",
     "zustand": ">=5.0.0"
   },
-  "gitHead": "4c6badf97d6d2845f6bed00bf21274a72dc68134",
+  "gitHead": "7105d3df4b003c1e4232396054cf7b217888ccee",
   "devDependencies": {
     "@dfinity/agent": ">=2.1",
     "@dfinity/auth-client": ">=2.1",