universal-message/dist/index.d.mts

A universal message communication library for JavaScript/TypeScript that works across different environments including Worker threads, WebSocket, and other communication channels

declare class MessageBase {
    option: MessageOptions;
    private ons;
    private fns;
    protected plugins: Map<string, MessagePlugin>;
    private paramListeners;
    constructor(option: MessageOptions);
    private init;
    addParamListener(messageId: string, paramListenerId: string): void;
    private cleanupParamListeners;
    addPlugin(plugin: MessagePlugin): void;
    removePlugin(name: string): void;
    private emitPlugin;
    private listenCallback;
    protected callback<T>(msg: MessageInfo, result: any, error?: any): Promise<void>;
    protected send<T>(key: string, data?: any, id?: string, other?: Record<string, any>): Promise<T>;
    on(key: string, callback: (data: any, msg: MessageInfo) => void): void;
    hasOn(key: string): boolean;
    remove(key: string): void;
    removeAll(key: string): void;
    emit<T>(key: string, data?: any, id?: string): Promise<T>;
    $class: Map<string, any>;
    /**
     * 添加代理类
     * @param target 未初始化的类
     */
    addClass<T = Object>(target: T): void;
    getActiveConnectionsCount(): number;
    cleanup(): void;
}

type MessageListen = {
    callback?: Function;
    resolve?: (result: any) => void;
    reject?: (error: any) => void;
    once: boolean;
};
type MessageOptions = {
    on: (callback: Function) => void;
    send: (data: any) => void;
    heartbeat?: HeartbeatConfig;
};
type MessageInfo = {
    id: string;
    key: string;
    data?: string | any;
    error?: any;
    [key: string]: any;
};
type MessageListenArgs = {
    key: string;
    data?: any;
};
type MessageTools = {
    sendUpdate: (data: any) => void;
    remove: () => void;
};
type MessageEcoder<T extends Object | any> = {
    target: (data: T, client: MessageBase) => boolean;
    key: string;
    encode: (data: T, tool: MessageTools, client: MessageBase) => any;
    decode: (data: MessageListenArgs, tool: MessageTools, client: MessageBase) => T;
    update?: (newValue: any, target: T, tool: MessageTools, client: MessageBase) => any;
};
type MessageEcoderInfo = {
    id: string;
    key: string;
    data?: any;
};
type MessageClass = {
    key: string;
    data?: Array<any> | any;
    id?: string;
    className?: string;
};
type MessageVarInfo = {
    key: string;
    attr?: string;
    data?: Array<any> | any;
};
declare abstract class MessagePlugin {
    client: MessageBase;
    constructor(client: MessageBase);
    abstract name: string;
    abstract onMessage?: (data: MessageInfo) => Promise<MessageInfo> | MessageInfo;
    abstract onSend?: (data: MessageInfo) => Promise<MessageInfo> | MessageInfo;
}
type MessageEventName = "onMessage" | "onSend";
type MessageProxyMethods = {
    get: <T extends any>(key: string) => Promise<T>;
    set: <T extends any>(key: string, data?: any) => Promise<T>;
    call: <T extends any>(key: string, ...data: any[]) => Promise<T>;
    close: <T extends any>() => Promise<T>;
};
type MessageProxyClass = MessageProxyMethods & {
    static: MessageProxyMethods;
};
type MessageProxyShared = {
    value: <T extends any>() => Promise<T>;
    del: <T extends any>(attr?: string) => Promise<T>;
    set: <T extends any>(attr?: string, data?: any) => Promise<T>;
    call: <T extends any>(attr?: string, ...data: any[]) => Promise<T>;
    get: <T extends any>(attr: string) => Promise<T>;
    close: <T extends any>() => Promise<T>;
};
type HeartbeatStats = {
    activeListeners: number;
    pendingHeartbeats: number;
    failureCount: number;
    failures: [string, number][];
};
type HeartbeatConfig = {
    interval?: number;
    maxFailures?: number;
    enabled?: boolean;
};

declare class MessageShared extends MessageBase {
    private shareds;
    constructor(option: MessageOptions);
    private checkVar;
    addShared(key: string, target: any): void;
    delShared(key: string): void;
    loadShared(key: string): MessageProxyShared;
}

declare class MessageServer extends MessageShared {
    constructor(option: MessageOptions);
    /**
     * [发送] 初始化类
     * @param target 对象或类名
     * @param data
     * @returns
     */
    newClass(target: string | Object, ...data: any[]): Promise<MessageProxyClass>;
    /**
     * [发送] 获取类静态方法
     * @param target 对象或类名
     * @returns
     */
    staticClass(target: string | Object): MessageProxyMethods;
}

declare class MessageClient extends MessageShared {
    constructor(option: MessageOptions);
    private clsNews;
    private initClass;
}

declare class MessageEcoderPlugin implements MessagePlugin {
    client: MessageBase;
    name: string;
    constructor(client: MessageBase);
    onSend(body: MessageInfo): Promise<MessageInfo>;
    onMessage(body: MessageInfo): Promise<MessageInfo>;
    private dataEncode;
    private dataDecode;
}

declare const MessageEcoders: Array<MessageEcoder<any>>;

declare const ECoderAbortController: MessageEcoder<any>;

declare const rid: () => string;
declare function isNull(data: any): boolean;
declare function objectEval(instance: Object, type: "get" | "set" | "call" | "delete", prop: string, data?: any): Promise<any>;

declare class Json2 {
    private static key;
    static stringify(data: any): string;
    static dataToRefs(data: any): any;
    private static addList;
    static refsToData(refs: any[]): any;
    private static encoder;
    static parse(str: string): any;
    private static decoder;
}

export { ECoderAbortController, type HeartbeatConfig, type HeartbeatStats, Json2, MessageBase, type MessageClass, MessageClient, type MessageEcoder, type MessageEcoderInfo, MessageEcoderPlugin, MessageEcoders, type MessageEventName, type MessageInfo, type MessageListen, type MessageListenArgs, type MessageOptions, MessagePlugin, type MessageProxyClass, type MessageProxyMethods, type MessageProxyShared, MessageServer, MessageShared, type MessageTools, type MessageVarInfo, isNull, objectEval, rid };