rpc-shooter/lib/index.d.ts

A tool library for handling window && iframe && worker communication based on the JSON RPC specification

export interface RPCHandler {
    (...args: any[]): any;
}
export interface RPCError {
    code: number;
    message: string;
    data: any;
}
export interface RPCEvent {
    emit(event: string, ...args: any[]): void;
    on(event: string, fn: RPCHandler): void;
    off(event: string, fn?: RPCHandler): void;
    onerror: null | ((error: RPCError) => void);
    destroy?: () => void;
}
export interface RPCMessageDataFormat {
    event: string;
    args: any[];
}
export interface RPCPostMessageConfig extends WindowPostMessageOptions {
}
export interface AbstractMessageSendEndpoint {
    postMessage(message: any, options?: WindowPostMessageOptions): void;
}
export interface AbstractMessageReceiveEndpoint extends AbstractMessageSendEndpoint {
    onmessage?: ((this: any, ev: MessageEvent) => any) | null;
    onmessageerror?: ((this: any, ev: MessageEvent) => any) | null;
    /** Disconnects the port, so that it is no longer active. */
    close?: () => void;
    /** Begins dispatching messages received on the port. */
    start?: () => void;
    addEventListener<K extends keyof MessagePortEventMap>(type: K, listener: (this: any, ev: MessagePortEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
    removeEventListener<K extends keyof MessagePortEventMap>(type: K, listener: (this: any, ev: MessagePortEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
}
export interface RPCMessageReceiveEndpoint extends AbstractMessageReceiveEndpoint {
}
export interface RPCMessageSendEndpoint extends AbstractMessageSendEndpoint {
}
export interface RPCMessageEventOptions {
    currentEndpoint: RPCMessageReceiveEndpoint;
    targetEndpoint: RPCMessageSendEndpoint;
    config?: ((data: any, context: RPCMessageSendEndpoint) => RPCPostMessageConfig) | RPCPostMessageConfig;
    sendAdapter?: (data: RPCMessageDataFormat | any, context: RPCMessageSendEndpoint) => {
        data: RPCMessageDataFormat;
        transfer?: Transferable[];
    };
    receiveAdapter?: (event: MessageEvent) => RPCMessageDataFormat;
}
export declare const RPCCodes: Record<string, Pick<RPCError, 'code' | 'message'>>;
export declare class RPCMessageEvent implements RPCEvent {
    private _currentEndpoint;
    private _targetEndpoint;
    private _events;
    private _originOnmessage;
    private _receiveMessage;
    onerror: null | ((error: RPCError) => void);
    config?: RPCMessageEventOptions['config'];
    sendAdapter?: RPCMessageEventOptions['sendAdapter'];
    receiveAdapter?: RPCMessageEventOptions['receiveAdapter'];
    constructor(options: RPCMessageEventOptions);
    emit(event: string, ...args: any[]): void;
    on(event: string, fn: RPCHandler): void;
    off(event: string, fn?: RPCHandler): void;
    destroy(): void;
}
export interface RPCInitOptions {
    event: RPCEvent;
    methods?: Record<string, RPCHandler>;
    timeout?: number;
}
export interface RPCSYNEvent {
    jsonrpc: '2.0';
    method: string;
    params: any[];
    id?: string;
}
export interface RPCSACKEvent {
    jsonrpc: '2.0';
    result?: any;
    error?: RPCError;
    id?: string;
}
export interface RPCInvokeOptions {
    isNotify?: boolean;
    timeout?: number;
}
export declare class RPC {
    private _event;
    private _methods;
    private _timeout;
    private _$connect;
    static CODES: Record<string, Pick<RPCError, "message" | "code">>;
    static EVENT: {
        SYN_SIGN: string;
        ACK_SIGN: string;
        CONNECT: string;
        SYNC_METHODS: string;
    };
    static uuid(): string;
    constructor(options: RPCInitOptions);
    _getSynEventName(method: string): string;
    _getAckEventName(method: string): string;
    connect(timeout?: number): Promise<void>;
    registerMethod(method: string, handler: RPCHandler): void;
    removeMethod(method: string): void;
    invoke(method: string, ...args: any[] | [...any[], RPCInvokeOptions]): Promise<any>;
    destroy(): void;
}