node-jet/lib/2_jsonrpc/index.d.ts

Jet Realtime Message Bus for the Web. Daemon and Peer implementation.

import { type JsonRPCError } from '../3_jet/errors.js';
import type { JsonParams } from '../3_jet/peer/index.js';
import { type ErrorMessage, type Message, type MessageParams, type MethodRequest, type ResultMessage } from '../3_jet/messages.js';
import type { logger, Logger } from '../3_jet/log.js';
import { Socket } from '../1_socket/socket.js';
import { EventEmitter } from '../1_socket/index.js';
import type { ValueType } from '../3_jet/types.js';
export type resultCallback = ((_success: boolean, _result?: object) => void) | undefined;
export interface JsonRpcConfig {
    batches?: boolean;
    url?: string;
    port?: number;
    ip?: string;
    log?: logger;
}
/**
 * JsonRPC Instance
 * class used to interpret jsonrpc messages. This class can parse incoming socket messages to jsonrpc messages and fires events
 */
export declare class JsonRPC extends EventEmitter {
    sock: Socket;
    config: JsonRpcConfig;
    messages: Message[];
    messageId: number;
    user: string;
    _isOpen: boolean;
    openRequests: Record<string, {
        resolve: (value: ValueType | PromiseLike<ValueType>) => void;
        reject: (value: JsonRPCError | PromiseLike<JsonRPCError>) => void;
    }>;
    requestId: string;
    resolveDisconnect: (value: void | PromiseLike<void>) => void;
    rejectDisconnect: (reason?: any) => void;
    disconnectPromise: Promise<void>;
    resolveConnect: (value: void | PromiseLike<void>) => void;
    rejectConnect: (reason?: any) => void;
    connectPromise: Promise<void>;
    logger: Logger;
    abortController: AbortController;
    constructor(logger: Logger, config?: JsonRpcConfig, sock?: Socket);
    /**
     * Method called before disconnecting from the device to initialize Promise, that is only resolved when disconnected
     */
    createDisconnectPromise: () => void;
    /**
     * Method called before connecting to the device to initialize Promise, that is only resolved when a connection is established
     */
    createConnectPromise: () => void;
    /**
     * Method called to subscribe to all relevant socket events
     */
    subscribeToSocketEvents: () => void;
    /**
     * Method to connect to a Server instance. Either TCP Server or Webserver
     * @params controller: an AbortController that can be used to abort the connection
     */
    connect: (controller?: AbortController) => Promise<void>;
    /**
     * Close.
     */
    close: () => Promise<void>;
    _handleError: (err: Event) => void;
    _convertMessage: (message: Blob | string) => Promise<string>;
    /**
     * _dispatchMessage
     *
     * @api private
     */
    _handleMessage: (event: MessageEvent) => void;
    /**
     * _dispatchSingleMessage
     *
     * @api private
     */
    _dispatchSingleMessage: (message: MethodRequest | ResultMessage | ErrorMessage) => void;
    /**
     * _dispatchResponse
     *
     * @api private
     */
    _dispatchResponse: (message: ResultMessage | ErrorMessage) => void;
    /**
     * _dispatchRequest.
     * Handles both method calls and fetchers (notifications)
     *
     * @api private
     */
    _dispatchRequest: (message: MethodRequest) => void;
    /**
     * Queue.
     */
    queue: <T extends MessageParams | Message>(message: T, id?: string) => Promise<undefined>;
    /**
     * Send.
     */
    send: () => void;
    /**
     * Responding a request
     * @param id the request id to respond to
     * @param params the result of the request
     * @param success if the request was fulfilled
     */
    respond: (id: string, params: ValueType, success: boolean) => void;
    successCb: (id: string, result: ValueType) => void;
    errorCb: (id: string, error: JsonRPCError) => void;
    /**
     * Method to send a request to a JSONRPC Server.
     */
    sendRequest: <T extends ValueType>(method: string, params: JsonParams, sendImmediate?: boolean) => Promise<T>;
}
export default JsonRPC;