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

package/dist/classes/actor/index.js

@@ -1,245 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ActorManager = void 0;
-/* eslint-disable no-console */
-const agent_1 = require("@dfinity/agent");
-const helper_1 = require("../../utils/helper");
-const candid_1 = require("@dfinity/candid");
-const ACTOR_INITIAL_STATE = {
-    name: "",
-    version: 0,
-    methodState: {},
-    initializing: false,
-    isInitializing: false,
-    initialized: false,
-    isInitialized: false,
-    error: undefined,
-};
-class ActorManager {
-    _actor = null;
-    _idlFactory;
-    _agentManager;
-    _unsubscribeAgent;
-    _subscribers = [];
-    canisterId;
-    actorStore;
-    visitFunction;
-    methodAttributes;
-    updateState = (newState, action) => {
-        this.actorStore.setState((state) => ({ ...state, ...newState }), false, action);
-    };
-    updateMethodState = (method, hash, newState) => {
-        const actionName = `${method}:${newState.error ? "error" : newState.isLoading ? "loading..." : "loaded"}`;
-        this.actorStore.setState((state) => {
-            const methodState = state.methodState[method] || {};
-            const currentMethodState = methodState[hash] || DEFAULT_STATE;
-            const updatedMethodState = {
-                ...methodState,
-                [hash]: { ...currentMethodState, ...newState },
-            };
-            return {
-                ...state,
-                methodState: {
-                    ...state.methodState,
-                    [method]: updatedMethodState,
-                },
-            };
-        }, false, actionName);
-    };
-    constructor(actorConfig) {
-        const { agentManager, idlFactory, canisterId, name = canisterId.toString(), withVisitor = false, withDevtools = false, initializeOnCreate = true, } = actorConfig;
-        if (!canisterId) {
-            throw new agent_1.AgentError(new agent_1.UnexpectedErrorCode("CanisterId is required!"), agent_1.ErrorKindEnum.Unknown);
-        }
-        this.canisterId = canisterId.toString();
-        if (!idlFactory) {
-            throw new agent_1.AgentError(new agent_1.UnexpectedErrorCode("IDLFactory is required!"), agent_1.ErrorKindEnum.Unknown);
-        }
-        this._idlFactory = idlFactory;
-        this.methodAttributes = this.extractMethodAttributes();
-        if (!agentManager) {
-            throw new agent_1.AgentError(new agent_1.UnexpectedErrorCode("AgentManager is required!"), agent_1.ErrorKindEnum.Unknown);
-        }
-        this._agentManager = agentManager;
-        // Initialize stores
-        this.actorStore = (0, helper_1.createStoreWithOptionalDevtools)({ ...ACTOR_INITIAL_STATE, name }, {
-            withDevtools,
-            name: "reactor-actor",
-            store: canisterId.toString(),
-        });
-        this._unsubscribeAgent = this._agentManager.subscribeAgent(this.initializeActor, initializeOnCreate);
-        if (withVisitor) {
-            this.visitFunction = this.extractVisitor();
-        }
-        else {
-            this.visitFunction = emptyVisitor;
-        }
-    }
-    initialize = async (options) => {
-        await this._agentManager.updateAgent(options);
-    };
-    extractInterface = () => {
-        return this._idlFactory({ IDL: candid_1.IDL });
-    };
-    extractMethodAttributes = () => {
-        const iface = this.extractInterface();
-        const methodAttributesArray = iface._fields.map(([name, func]) => ({
-            name: name,
-            attributes: {
-                numberOfArgs: func.argTypes.length,
-                type: ((0, helper_1.isQuery)(func) ? "query" : "update"),
-                validate: (arg) => func.argTypes.some((t, i) => t.covariant(arg[i])),
-            },
-        }));
-        methodAttributesArray.sort((a, b) => {
-            if (a.attributes.type === b.attributes.type) {
-                return a.attributes.numberOfArgs - b.attributes.numberOfArgs;
-            }
-            return a.attributes.type === "query" ? -1 : 1;
-        });
-        return methodAttributesArray.reduce((acc, { name, attributes }) => {
-            acc[name] = attributes;
-            return acc;
-        }, {});
-    };
-    extractVisitor = () => {
-        const iface = this.extractInterface();
-        return iface._fields.reduce((acc, service) => {
-            const functionName = service[0];
-            const type = service[1];
-            const visit = ((extractorClass, data) => {
-                return type.accept(extractorClass, data);
-            });
-            acc[functionName] = visit;
-            return acc;
-        }, {});
-    };
-    initializeActor = (agent) => {
-        const network = this._agentManager.getNetwork();
-        console.info(`Initializing actor ${this.canisterId} on ${network} network`);
-        const { _idlFactory, canisterId } = this;
-        this.updateState({
-            initializing: true,
-            isInitializing: true,
-            initialized: false,
-            isInitialized: false,
-            methodState: {},
-        }, "initializing");
-        try {
-            if (!agent) {
-                throw new agent_1.AgentError(new agent_1.UnexpectedErrorCode("Agent not initialized"), agent_1.ErrorKindEnum.Unknown);
-            }
-            this._actor = agent_1.Actor.createActor(_idlFactory, {
-                agent,
-                canisterId,
-            });
-            if (!this._actor) {
-                throw new agent_1.AgentError(new agent_1.UnexpectedErrorCode("Failed to initialize actor"), agent_1.ErrorKindEnum.Unknown);
-            }
-            this.updateState({
-                initializing: false,
-                isInitializing: false,
-                initialized: true,
-                isInitialized: true,
-            }, "initialized");
-        }
-        catch (error) {
-            console.error("Error in initializeActor:", error);
-            this.updateState({
-                error: error,
-                initializing: false,
-                isInitializing: false,
-            }, "error");
-        }
-    };
-    _getActorMethod = (functionName) => {
-        if (!this._actor) {
-            throw new agent_1.AgentError(new agent_1.UnexpectedErrorCode("Actor not initialized"), agent_1.ErrorKindEnum.Unknown);
-        }
-        if (!this._actor[functionName] ||
-            typeof this._actor[functionName] !== "function") {
-            throw new agent_1.AgentError(new agent_1.UnexpectedErrorCode(`Method ${String(functionName)} not found`), agent_1.ErrorKindEnum.Unknown);
-        }
-        return this._actor[functionName];
-    };
-    callMethod = async (functionName, ...args) => {
-        const method = this._getActorMethod(functionName);
-        const data = await method(...args);
-        return data;
-    };
-    callMethodWithOptions = (options) => {
-        return async (functionName, ...args) => {
-            const method = this._getActorMethod(functionName);
-            const data = await method.withOptions(options)(...args);
-            return data;
-        };
-    };
-    call = async (functionName, ...args) => {
-        const requestHash = (0, helper_1.generateRequestHash)(args);
-        try {
-            this.updateMethodState(functionName, requestHash, {
-                loading: true,
-                isLoading: true,
-                error: undefined,
-            });
-            const data = await this.callMethod(functionName, ...args);
-            this.updateMethodState(functionName, requestHash, {
-                loading: false,
-                isLoading: false,
-                data,
-            });
-            return data;
-        }
-        catch (error) {
-            this.updateMethodState(functionName, requestHash, {
-                loading: false,
-                isLoading: false,
-                error: error,
-                data: undefined,
-            });
-            throw error;
-        }
-    };
-    // agent store
-    get agentManager() {
-        return this._agentManager;
-    }
-    // actor store
-    getActor = () => {
-        return this._actor;
-    };
-    getState = () => {
-        return this.actorStore.getState();
-    };
-    // @ts-expect-error: Overrides subscribe method signature
-    subscribeActorState = (selectorOrListener, listener, options) => {
-        let unsubscribe = helper_1.noop;
-        if (listener) {
-            unsubscribe = this.actorStore.subscribe(selectorOrListener, listener, options);
-        }
-        else {
-            unsubscribe = this.actorStore.subscribe(selectorOrListener);
-        }
-        this._subscribers.push(unsubscribe);
-        return unsubscribe;
-    };
-    setState = (updater) => {
-        return this.actorStore.setState(updater);
-    };
-    cleanup = () => {
-        this._unsubscribeAgent();
-        this._subscribers.forEach((unsubscribe) => unsubscribe());
-    };
-}
-exports.ActorManager = ActorManager;
-const emptyVisitor = new Proxy({}, {
-    get: function (_, prop) {
-        throw new agent_1.AgentError(new agent_1.UnexpectedErrorCode(`Cannot visit function "${String(prop)}" without initializing the actor with the visitor option, please set the withVisitor option to true when creating the actor manager.`), agent_1.ErrorKindEnum.Unknown);
-    },
-});
-const DEFAULT_STATE = {
-    data: undefined,
-    error: undefined,
-    loading: false,
-    isLoading: false,
-};

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

@@ -1,113 +0,0 @@
-import type { AgentManager } from "../agent";
-import type { IDL, ActorMethod, ActorSubclass, Principal, StoreWithAllMiddleware } from "../../types";
-import type { AgentError, CallConfig } from "@dfinity/agent";
-export interface DefaultActorType {
-    [key: string]: ActorMethod;
-}
-export type BaseActor<T = DefaultActorType> = ActorSubclass<T>;
-export type FunctionName<A = BaseActor> = Extract<keyof A, string>;
-export type FunctionType = "query" | "update";
-export type CanisterId = string | Principal;
-export interface ActorManagerParameters {
-    idlFactory: IDL.InterfaceFactory;
-    agentManager: AgentManager;
-    name?: string;
-    canisterId: CanisterId;
-    withVisitor?: boolean;
-    withDevtools?: boolean;
-    initializeOnCreate?: boolean;
-}
-export type VisitorType<V> = V extends IDL.Visitor<infer D, infer R> ? {
-    data: D;
-    returnType: R;
-} : never;
-export type VisitService<A = BaseActor, M extends FunctionName<A> = FunctionName<A>> = {
-    [K in M]: <V extends IDL.Visitor<unknown, unknown>>(extractorClass: V, data: VisitorType<V>["data"]) => ReturnType<V["visitFunc"]>;
-};
-export type ActorMethodParameters<T> = T extends ActorMethod<infer Args, any> ? Args : never;
-export type ActorMethodReturnType<T> = T extends ActorMethod<any, infer Ret> ? Ret : never;
-/**
- * Interface representing the state of each actor method.
- *
- * @template A - The actor type, defaulting to `BaseActor`.
- * @template M - A specific method name of the actor.
- */
-export interface ActorMethodState<A = BaseActor, M extends FunctionName<A> = FunctionName<A>> {
-    /**
-     * The per-method state object, keyed by the method name.
-     */
-    [key: string]: {
-        /**
-         * The data returned from the actor method call, if available.
-         */
-        data: ActorMethodReturnType<A[M]> | undefined;
-        /**
-         * @deprecated Use `isLoading` instead.
-         * Flag indicating whether the actor method is in progress.
-         */
-        loading: boolean;
-        /**
-         * Flag indicating whether the actor method is in progress.
-         */
-        isLoading: boolean;
-        /**
-         * Error thrown during the actor method invocation, if any.
-         */
-        error: AgentError | undefined;
-    };
-}
-export type ActorMethodStates<A = BaseActor> = {
-    [M in FunctionName<A>]: ActorMethodState<A, M>;
-};
-export type ActorMethodType<A, M extends keyof A> = {
-    (...args: ActorMethodParameters<A[M]>): Promise<ActorMethodReturnType<A[M]>>;
-    withOptions: (options: CallConfig) => (...args: ActorMethodParameters<A[M]>) => Promise<ActorMethodReturnType<A[M]>>;
-};
-/**
- * Represents the state of an actor.
- *
- * @template A - The type of the actor, defaults to `BaseActor`.
- */
-export type ActorState<A = BaseActor> = {
-    /**
-     * The name of the actor.
-     */
-    name: string;
-    /**
-     * The version of the actor.
-     */
-    version: number;
-    /**
-     * @deprecated Use `isInitialized` instead.
-     * Indicates whether the actor is initialized.
-     */
-    initialized: boolean;
-    /**
-     * Indicates whether the actor is initialized.
-     */
-    isInitialized: boolean;
-    /**
-     * @deprecated Use `isInitializing` instead.
-     * Indicates whether the actor is in the process of initializing.
-     */
-    initializing: boolean;
-    /**
-     * Indicates whether the actor is in the process of initializing.
-     */
-    isInitializing: boolean;
-    /**
-     * The error associated with the actor, if any.
-     */
-    error: AgentError | undefined;
-    /**
-     * The state of the actor's methods.
-     */
-    methodState: ActorMethodStates<A>;
-};
-export type ActorStore<A = BaseActor> = StoreWithAllMiddleware<ActorState<A>>;
-export type CallActorMethod<A = BaseActor> = <M extends FunctionName<A> = FunctionName<A>>(functionName: M, ...args: ActorMethodParameters<A[M]>) => Promise<ActorMethodReturnType<A[M]>>;
-export type MethodAttributes<A = BaseActor> = Record<FunctionName<A>, {
-    type: FunctionType;
-    numberOfArgs: number;
-    validate: (arg: never) => boolean;
-}>;

package/dist/classes/actor/types.js

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

package/dist/classes/adapter/index.d.ts

@@ -1,19 +0,0 @@
-import { HttpAgent } from "@dfinity/agent";
-import type { CanisterId, CandidAdapterParameters, CandidDefenition, ReactorParser } from "../../types";
-export declare class CandidAdapter {
-    agent: HttpAgent;
-    didjsCanisterId: string;
-    private parserModule?;
-    unsubscribeAgent: () => void;
-    constructor({ agentManager, agent, didjsCanisterId, }: CandidAdapterParameters);
-    initializeParser(module?: ReactorParser): Promise<void>;
-    private getDefaultDidJsId;
-    fetchCandidDefinition(canisterId: CanisterId): Promise<string>;
-    getCandidDefinition(canisterId: CanisterId): Promise<CandidDefenition>;
-    getFromMetadata(canisterId: CanisterId): Promise<string | undefined>;
-    getFromTmpHack(canisterId: CanisterId): Promise<string>;
-    evaluateCandidDefinition(data: string): Promise<CandidDefenition>;
-    fetchDidTojs(candidSource: string, didjsCanisterId?: string): Promise<[string]>;
-    parseDidToJs(candidSource: string): string;
-    validateIDL(candidSource: string): boolean;
-}

package/dist/classes/adapter/index.js

@@ -1,140 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CandidAdapter = void 0;
-const agent_1 = require("@dfinity/agent");
-const constants_1 = require("../../utils/constants");
-const utils_1 = require("../../utils");
-class CandidAdapter {
-    agent;
-    didjsCanisterId;
-    parserModule;
-    unsubscribeAgent = utils_1.noop;
-    constructor({ agentManager, agent, didjsCanisterId, }) {
-        if (agent) {
-            this.agent = agent;
-        }
-        else if (agentManager) {
-            this.agent = agentManager.getAgent();
-            this.unsubscribeAgent = agentManager.subscribeAgent((agent) => {
-                this.agent = agent;
-                this.didjsCanisterId = didjsCanisterId || this.getDefaultDidJsId();
-            });
-        }
-        else {
-            throw new Error("No agent or agentManager provided");
-        }
-        this.didjsCanisterId = didjsCanisterId || this.getDefaultDidJsId();
-    }
-    async initializeParser(module) {
-        if (module !== undefined) {
-            this.parserModule = module;
-            return;
-        }
-        try {
-            this.parserModule = require("@ic-reactor/parser");
-            if (typeof this.parserModule !== "undefined" &&
-                "default" in this.parserModule) {
-                await this.parserModule.default();
-            }
-        }
-        catch (error) {
-            throw new Error(`Error initializing parser: ${error}`);
-        }
-    }
-    getDefaultDidJsId() {
-        return this.agent.isLocal?.() === true
-            ? constants_1.DEFAULT_LOCAL_DIDJS_ID
-            : constants_1.DEFAULT_IC_DIDJS_ID;
-    }
-    async fetchCandidDefinition(canisterId) {
-        let candidDef = "";
-        // First attempt: Try getting Candid definition from metadata
-        try {
-            candidDef = await this.getFromMetadata(canisterId);
-            if (!candidDef) {
-                throw new Error("Cannot retrieve Candid definition from metadata");
-            }
-        }
-        catch (error) {
-            // Second attempt: Try the temporary hack method
-            candidDef = await this.getFromTmpHack(canisterId).catch(() => {
-                return undefined;
-            });
-        }
-        if (!candidDef) {
-            throw new Error("Failed to retrieve Candid definition by any method.");
-        }
-        return candidDef;
-    }
-    async getCandidDefinition(canisterId) {
-        try {
-            const candidDef = await this.fetchCandidDefinition(canisterId);
-            return this.evaluateCandidDefinition(candidDef);
-        }
-        catch (error) {
-            throw new Error(`Error fetching canister ${canisterId}: ${error}`);
-        }
-    }
-    async getFromMetadata(canisterId) {
-        const status = await agent_1.CanisterStatus.request({
-            agent: this.agent,
-            canisterId: canisterId,
-            paths: ["candid"],
-        });
-        return status.get("candid");
-    }
-    async getFromTmpHack(canisterId) {
-        const commonInterface = ({ IDL }) => IDL.Service({
-            __get_candid_interface_tmp_hack: IDL.Func([], [IDL.Text], ["query"]),
-        });
-        const actor = agent_1.Actor.createActor(commonInterface, {
-            agent: this.agent,
-            canisterId,
-        });
-        return (await actor.__get_candid_interface_tmp_hack());
-    }
-    async evaluateCandidDefinition(data) {
-        try {
-            let candidDef = "";
-            try {
-                candidDef = this.parseDidToJs(data);
-                if (candidDef === "") {
-                    throw new Error("Cannot compile Candid to JavaScript");
-                }
-            }
-            catch (error) {
-                candidDef = (await this.fetchDidTojs(data))[0];
-            }
-            if (JSON.stringify(candidDef) === JSON.stringify([])) {
-                throw new Error("Cannot compile Candid to JavaScript");
-            }
-            return await (0, utils_1.importCandidDefinition)(candidDef);
-        }
-        catch (error) {
-            throw new Error(`Error evaluating Candid definition: ${error}`);
-        }
-    }
-    async fetchDidTojs(candidSource, didjsCanisterId) {
-        const didjsInterface = ({ IDL }) => IDL.Service({
-            did_to_js: IDL.Func([IDL.Text], [IDL.Opt(IDL.Text)], ["query"]),
-        });
-        const didjs = agent_1.Actor.createActor(didjsInterface, {
-            agent: this.agent,
-            canisterId: didjsCanisterId || this.didjsCanisterId,
-        });
-        return didjs.did_to_js(candidSource);
-    }
-    parseDidToJs(candidSource) {
-        if (!this.parserModule) {
-            throw new Error("Parser module not available");
-        }
-        return this.parserModule.didToJs(candidSource);
-    }
-    validateIDL(candidSource) {
-        if (!this.parserModule) {
-            throw new Error("Parser module not available");
-        }
-        return this.parserModule.validateIDL(candidSource);
-    }
-}
-exports.CandidAdapter = CandidAdapter;

package/dist/classes/adapter/types.d.ts

@@ -1,14 +0,0 @@
-import type { AgentManager } from "../agent";
-import type { IDL, HttpAgent } from "../../types";
-export interface CandidAdapterParameters {
-    agentManager?: AgentManager;
-    agent?: HttpAgent;
-    didjsCanisterId?: string;
-}
-export interface CandidDefenition {
-    idlFactory: IDL.InterfaceFactory;
-    init: ({ idl }: {
-        idl: typeof IDL;
-    }) => never[];
-}
-export type ReactorParser = typeof import("@ic-reactor/parser") | typeof import("@ic-reactor/parser/dist/nodejs") | typeof import("@ic-reactor/parser/dist/bundler");

package/dist/classes/adapter/types.js

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

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

@@ -1,36 +0,0 @@
-import { HttpAgent } from "@dfinity/agent";
-import { AuthClient } from "@dfinity/auth-client";
-import type { AuthClientLoginOptions } from "../../types";
-import type { AgentStore, AgentManagerParameters, UpdateAgentParameters, AuthStore } from "./types";
-export declare class AgentManager {
-    private _agent;
-    private _auth;
-    private _subscribers;
-    agentStore: AgentStore;
-    authStore: AuthStore;
-    private updateAgentState;
-    private updateAuthState;
-    constructor(options?: AgentManagerParameters);
-    initializeAgent: () => Promise<void>;
-    subscribeAgent: (callback: (agent: HttpAgent) => void, initialize?: boolean) => () => void;
-    unsubscribeAgent: (callback: (agent: HttpAgent) => void) => void;
-    private notifySubscribers;
-    updateAgent: (options?: UpdateAgentParameters) => Promise<void>;
-    authenticate: () => Promise<import("@dfinity/agent").Identity>;
-    login: (options?: AuthClientLoginOptions) => Promise<void>;
-    logout: (options?: {
-        returnTo?: string;
-    }) => Promise<void>;
-    getAgent: () => HttpAgent;
-    getAgentHost: () => URL | undefined;
-    getAgentHostName: () => string;
-    getIsLocal: () => boolean;
-    getNetwork: () => "local" | "remote" | "ic";
-    getAgentState: AgentStore["getState"];
-    subscribeAgentState: AgentStore["subscribe"];
-    getAuthState: AuthStore["getState"];
-    subscribeAuthState: AuthStore["subscribe"];
-    getAuth: () => AuthClient | null;
-    getIdentity: () => import("@dfinity/agent").Identity | null;
-    getPrincipal: () => import("@dfinity/principal/lib/esm/principal").Principal | null;
-}