@ic-reactor/react 0.2.7 → 0.2.9

package/dist/context.d.ts

@@ -0,0 +1,15 @@
+import React, { PropsWithChildren } from "react";
+import { ActorSubclass } from "@dfinity/agent";
+import { createReActor } from "./index";
+import { IDL } from "@dfinity/candid";
+import { ReActorOptions } from "@ic-reactor/store";
+export type ReActor<A> = ReturnType<typeof createReActor<A>>;
+export interface ReActorContextType<A = ActorSubclass<any>> extends ReActor<A> {
+}
+export declare const useReActor: <A = any>() => ReActorContextType<A>;
+interface ReActorProviderProps extends PropsWithChildren, Omit<ReActorOptions, "idlFactory"> {
+    idlFactory?: IDL.InterfaceFactory;
+    loadingComponent?: React.ReactNode;
+}
+export declare const ReActorProvider: React.FC<ReActorProviderProps>;
+export {};

package/dist/context.js

@@ -0,0 +1,113 @@
+"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 (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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReActorProvider = exports.useReActor = void 0;
+const react_1 = __importStar(require("react"));
+const agent_1 = require("@dfinity/agent");
+const index_1 = require("./index");
+const store_1 = require("@ic-reactor/store");
+const ReActorContext = (0, react_1.createContext)(null);
+const useReActor = () => {
+    const context = react_1.default.useContext(ReActorContext);
+    if (!context) {
+        throw new Error("useReActor must be used within a ReActorProvider");
+    }
+    return context;
+};
+exports.useReActor = useReActor;
+const ReActorProvider = (_a) => {
+    var { children, loadingComponent = react_1.default.createElement("div", null, "Loading...") } = _a, config = __rest(_a, ["children", "loadingComponent"]);
+    const [didJs, setDidJS] = (0, react_1.useState)();
+    const fetchDidJs = (0, react_1.useCallback)(() => __awaiter(void 0, void 0, void 0, function* () {
+        const { canisterId } = config;
+        if (!canisterId) {
+            throw new Error("canisterId is required");
+        }
+        const agent = new agent_1.HttpAgent(Object.assign({}, config));
+        (0, store_1.getDidJsFromMetadata)(agent, canisterId).then((idlFactory) => __awaiter(void 0, void 0, void 0, function* () {
+            if (!idlFactory) {
+                try {
+                    idlFactory = yield (0, store_1.getDidJsFromTmpHack)(agent, canisterId);
+                }
+                catch (err) {
+                    if (/no query method/.test(err)) {
+                        console.warn(err);
+                        idlFactory = undefined;
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+                if (!idlFactory) {
+                    console.warn("No query method found for canister", canisterId);
+                }
+            }
+            setDidJS(idlFactory);
+        }));
+        return didJs;
+    }), [config.canisterId]);
+    (0, react_1.useEffect)(() => {
+        const { idlFactory } = config;
+        if (idlFactory) {
+            setDidJS({ idlFactory });
+            return;
+        }
+        fetchDidJs();
+    }, [fetchDidJs, config.idlFactory]);
+    const reActorHooks = (0, react_1.useMemo)(() => {
+        if (!didJs) {
+            return null;
+        }
+        try {
+            return (0, index_1.createReActor)(Object.assign(Object.assign({}, config), { idlFactory: didJs.idlFactory }));
+        }
+        catch (err) {
+            console.error(err);
+            return null;
+        }
+    }, [config, didJs]);
+    return (react_1.default.createElement(ReActorContext.Provider, { value: reActorHooks }, reActorHooks ? children : loadingComponent));
+};
+exports.ReActorProvider = ReActorProvider;

package/dist/hooks.d.ts

@@ -1,11 +1,11 @@
-import { CallMethod, ExtractReActorMethodArgs, ReActorActorStore, ReActorMethodField } from "@ic-reactor/store";
+import { CallMethod, ExtractReActorMethodArgs, ReActorActorStore } from "@ic-reactor/store";
 import { ReActorUseQueryArgs, ReActorUseUpdateArgs } from "./types";
 export declare const getCallHooks: <A extends unknown>(callMethod: CallMethod<A>, actorStore: ReActorActorStore<A>) => {
     useQueryCall: <M extends keyof A>({ autoRefresh, refreshInterval, disableInitialCall, ...rest }: ReActorUseQueryArgs<A, M>) => {
         data: import("@ic-reactor/store").ExtractReActorMethodReturnType<A[M]> | undefined;
         error: Error | undefined;
         loading: boolean;
-        field: ReActorMethodField<A> | undefined;
+        field: import("@ic-reactor/store").ReActorMethodField<A> | undefined;
         call: (replaceArgs?: ExtractReActorMethodArgs<A[M]> | undefined) => Promise<import("@ic-reactor/store").ExtractReActorMethodReturnType<A[M]> | undefined>;
     };
     useUpdateCall: <M_1 extends keyof A>(args: ReActorUseUpdateArgs<A, M_1>) => {
@@ -13,8 +13,8 @@ export declare const getCallHooks: <A extends unknown>(callMethod: CallMethod<A>
         error: Error | undefined;
         loading: boolean;
         call: (replaceArgs?: ExtractReActorMethodArgs<A[M_1]> | undefined) => Promise<import("@ic-reactor/store").ExtractReActorMethodReturnType<A[M_1]> | undefined>;
-        field: ReActorMethodField<A> | undefined;
+        field: import("@ic-reactor/store").ReActorMethodField<A> | undefined;
     };
-    useMethodField: (functionName: keyof A & string) => ReActorMethodField<A> | undefined;
-    useMethodFields: () => ReActorMethodField<A>[];
+    useMethodField: (functionName: keyof A & string) => import("@ic-reactor/store").ReActorMethodField<A> | undefined;
+    useMethodFields: () => import("@ic-reactor/store").ReActorMethodField<A>[];
 };

package/dist/index.d.ts

@@ -1,11 +1,11 @@
-import { AuthClientLoginOptions } from "@dfinity/auth-client";
-import type { ActorSubclass, ReActorAuthStore, ReActorOptions } from "@ic-reactor/store";
-export type ReActorContextType<A = ActorSubclass<any>> = ReActorAuthStore<A>;
+import type { AuthClientLoginOptions } from "@dfinity/auth-client";
+import type { ReActorOptions } from "@ic-reactor/store";
+export * from "./context";
 export declare const createReActor: <A extends unknown>(options: ReActorOptions) => {
     useMethodFields: () => import("@ic-reactor/store").ReActorMethodField<A>[];
     useMethodField: (functionName: keyof A & string) => import("@ic-reactor/store").ReActorMethodField<A> | undefined;
     useActorStore: () => {
-        initialize: (agentOptions?: import("@dfinity/agent").HttpAgentOptions | undefined, isLocal?: boolean | undefined) => Promise<void>;
+        initialize: (agentOptions?: import("@dfinity/agent").HttpAgentOptions | undefined, isLocal?: boolean | undefined) => void;
         actor: A | null;
         initialized: boolean;
         initializing: boolean;

package/dist/index.js

@@ -1,4 +1,18 @@
 "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);
+};
 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) {
@@ -14,6 +28,7 @@ const store_1 = require("@ic-reactor/store");
 const react_1 = require("react");
 const zustand_1 = require("zustand");
 const hooks_1 = require("./hooks");
+__exportStar(require("./context"), exports);
 const createReActor = (options) => {
     const isLocal = typeof process !== "undefined" &&
         (process.env.NODE_ENV === "development" ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ic-reactor/react",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "A React library for interacting with Dfinity actors",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -35,7 +35,7 @@
     "node": ">=10"
   },
   "dependencies": {
-    "@ic-reactor/store": "^0.2.6",
+    "@ic-reactor/store": "^0.2.8",
     "zustand-utils": "^1.3"
   },
   "peerDependencies": {
@@ -48,5 +48,5 @@
     "react": ">=16.8",
     "zustand": "4.4"
   },
-  "gitHead": "2705615cdbfac8e433d890a0ee52fba1bfbc290d"
+  "gitHead": "e967ca5fbc0d4b2fe76dc0af7c801fad49b2bb88"
 }