cross-domain-emitter/dist/index.d.ts

a cross domain or carrier event emittier

import EventEmitter from '@wxwzl/eventemitter';

interface TransceiverHandler {
    onMessage: (data: SignalPart) => void;
}
declare abstract class BaseTransceiver {
    abstract send(eventName: string, data?: unknown, option?: SignalOption): void;
    abstract start(): void;
    abstract stop(): void;
    abstract addHandler(handler: TransceiverHandler): void;
    abstract removeHandler(handler: TransceiverHandler): void;
    abstract clearHandler(): void;
    abstract checkStatus(): boolean;
}
interface SignalOption {
    returnEvent?: string;
    local?: boolean;
    transceiver?: BaseTransceiver;
    emitterId?: string;
    event?: Event;
}
interface SignalPart {
    name: string;
    data: unknown;
    option?: SignalOption;
}
declare class Signal {
    uuid: string;
    name: string;
    data: any;
    option: SignalOption;
    timestamp: number;
    constructor(uuid: string, name: string, data?: unknown, option?: SignalOption);
    serialize(): string;
    static deserialize(serializeStr: string | null): Signal;
    static copyFrom(data: {
        uuid: string;
        name: string;
        data?: unknown;
        option?: SignalOption;
    }): Signal;
}

declare class EventBus extends EventEmitter {
    id: string;
    transceivers: Array<BaseTransceiver>;
    emitters: Array<EventBus>;
    emit(eventName: string, data?: unknown, option?: SignalOption, transceivers?: BaseTransceiver | EventBus | Array<BaseTransceiver | EventBus>): this;
    bindTransceiver(transceiver: BaseTransceiver): void;
    addTransceiver(transceiver: BaseTransceiver): void;
    removeTransceiver(transceiver: BaseTransceiver): void;
    unBindTransceiver(transceiver: BaseTransceiver): void;
    clearTransceiver(): void;
    onMessage(data: SignalPart): void;
    addEmitter(emiter: EventBus): void;
    removeEmitter(emiter: EventBus): void;
}

type ServiceCallBack = (data: unknown, option: SignalOption | undefined, resolve: (value: unknown) => void) => void;
/**
 *
 * 返回 模拟的 Broswer/Server 模式 的请求。
 * 请求标识：eventName 即http请求中的请求路径
 * set: 设置响应的处理函数（调用resolve 发送处理结果）/或固定的值
 * get：发起请求 获取set 设置的数据
 * on: 接收 set 主动推送的数据变化
 * off: 停止接收set 主动推送的数据变化
 * destroy: 销毁
 * @param {EventBus} instance
 * @param {string} eventName
 * @returns
 */
declare function createVirtualService(instance: EventBus, eventName: string): {
    get(): Promise<unknown>;
    set(callBack: ServiceCallBack | unknown, clear?: boolean): void;
    on(callBack: (data: {
        newVal: unknown;
        oldVal?: unknown;
    }) => void): void;
    off(callBack: (data: {
        newVal: unknown;
        oldVal?: unknown;
    }) => void): void;
    destroy(): void;
};

declare class Store extends EventBus {
    store: Record<string, unknown>;
    set(key: string, value: unknown): void;
    get(key: string): unknown;
}

declare function hingeJointTransceiver(transceiver: BaseTransceiver, transceiverHandler: TransceiverHandler & {
    addTransceiver: (transceiver: BaseTransceiver) => void;
}): void;
declare function unHingeJointTransceiver(transceiver: BaseTransceiver, transceiverHandler: TransceiverHandler & {
    removeTransceiver: (transceiver: BaseTransceiver) => void;
}): void;

declare enum Status$2 {
    close = 0,
    open = 1
}
type Filter = (event: Event) => boolean;
declare class LocalStorageTransceiver extends BaseTransceiver {
    status: Status$2;
    handlers: Array<TransceiverHandler>;
    context: Window;
    keyPrefix: string;
    filter: Filter | undefined;
    uuid: string;
    constructor(option: CreateLocalStorageTransceiverOption);
    isValidName(eventName: string): boolean;
    getRealName(name: string): string;
    messageHandler(event: StorageEvent): void;
    send(eventName: string, data?: unknown, option?: SignalOption): this;
    getEventName(eventName: string): string;
    start(): void;
    stop(): void;
    clearHandler(): void;
    addHandler(handler: TransceiverHandler): void;
    removeHandler(handler: TransceiverHandler): void;
    checkStatus(): boolean;
    readHistoryMessage(): void;
}
interface CreateLocalStorageTransceiverOption {
    win: Window;
    filter?: Filter;
    keyPrefix?: string;
}
declare function createLocalStorageTransceiver(option: CreateLocalStorageTransceiverOption): LocalStorageTransceiver;

/**
 * 接收器状态
 * 0 处于关闭状态，1处于打开状态，3 处于链接中状态，4：处于链接失败状态，只有处于打开状态才能可接收和发送数据
 *
 * @enum {number}
 */
declare enum Status$1 {
    close = 0,
    open = 1,
    connecting = 3,
    error = 4
}
declare class WindowTransceiver extends BaseTransceiver {
    handlers: Array<TransceiverHandler>;
    context: Window;
    status: Status$1;
    host: string;
    allowHost: Array<string> | undefined;
    id: string;
    private uuidKey;
    private uuidValue;
    maxRetryTimes: number;
    private retryTimes;
    reconnectInterval: number;
    private timeOutId;
    connectError: Error | undefined;
    private _messageHandlerWrap;
    private connectedCall;
    constructor(option: createWindowTransceiverOption);
    messageHandler(event: Event & {
        origin: string;
        data: any;
    }): void;
    send(eventName: string, data?: unknown, option?: SignalOption): this;
    start(): void;
    stop(): void;
    clearHandler(): void;
    addHandler(handler: TransceiverHandler): void;
    removeHandler(handler: TransceiverHandler): void;
    checkStatus(): boolean;
    setUUID(str: string): void;
    getUUID(): string;
    setUUIDKey(str: string): void;
    getUUIDKey(): string;
    changeOption(option: createWindowTransceiverOption): void;
    private connect;
    private connected;
    private excuteConnectedCall;
    private connectedFailure;
    onConnected(callBack: (error?: Error) => void): void;
    private resetProperties;
}
interface createWindowTransceiverOption {
    win: Window;
    host: string;
    allowHost?: Array<string>;
    idGenerator?: Function | string;
}

declare class WindowEventBus extends EventBus {
    protected uuidKey: string;
    store: Store;
    windowTransceivers: Map<Window, WindowTransceiver>;
    constructor(uuidKey: string);
    addWindowTransceiver(option: createWindowTransceiverOption): WindowTransceiver;
    removeWindowTransceiver(transceiver: WindowTransceiver): void;
    removeWindowTransceiverByWindow(win: Window): void;
    findWindowTransceiverByWindowIds(ids: Array<string>): BaseTransceiver[];
    clearWindowTransceiver(): void;
}

declare class WindowClient extends WindowEventBus {
    createIframeTransceiver(host: string): WindowTransceiver;
    getUUID(url: string): any;
}

interface AddIframeTransceiverOption {
    iframe: HTMLIFrameElement;
    host: string;
    allowHost?: Array<string>;
    url?: string;
    uuidKey?: string;
    uuidValue?: string;
}
declare class WindowServer extends WindowEventBus {
    addIframeTransceiver(option: AddIframeTransceiverOption): WindowTransceiver;
    changeIframeTransceiver(transceiver: WindowTransceiver, option: AddIframeTransceiverOption): WindowTransceiver;
    removeIframeTransceiver(iframe: HTMLIFrameElement): void;
    addUUIDtoUrl(url: string, uuidKey: string, uuidValue: string): string;
}

declare enum Status {
    close = 0,
    open = 1
}
type BroadcastFilter = (event: MessageEvent) => boolean;
interface CreateBroadcastChannelTransceiverOption {
    filter?: BroadcastFilter;
    channelName?: string;
}
declare class BroadcastChannelTransceiver extends BaseTransceiver {
    status: Status;
    handlers: Array<TransceiverHandler>;
    channelName: string;
    filter: BroadcastFilter | undefined;
    uuid: string;
    broadcastChannel: BroadcastChannel | null;
    constructor(option: CreateBroadcastChannelTransceiverOption);
    private messageHandler;
    send(eventName: string, data?: unknown, option?: SignalOption): this;
    start(): void;
    stop(): void;
    clearHandler(): void;
    addHandler(handler: TransceiverHandler): void;
    removeHandler(handler: TransceiverHandler): void;
    checkStatus(): boolean;
    /**
     * 检查BroadcastChannel是否可用
     */
    static isBroadcastChannelSupported(): boolean;
}
declare function createBroadcastChannelTransceiver(option: CreateBroadcastChannelTransceiverOption): BroadcastChannelTransceiver;

interface CreateTabEventBusOption {
    channelName?: string;
    filter?: (event: MessageEvent) => boolean;
}
interface TabConnectionEvent {
    tabId: string;
    timestamp: number;
}
interface TabMessageEvent {
    uuid: string;
    type: "message";
    name: string;
    data: unknown;
    option?: SignalOption;
    timestamp: number;
}
interface TabPortOfferEvent {
    type: "port-offer";
    channelName: string;
    timestamp: number;
}
interface TabPortResponseEvent {
    type: "port-response";
    port: MessagePort;
    timestamp: number;
}
type TabEvent = TabMessageEvent | TabPortOfferEvent | TabPortResponseEvent;

type SameOriginFilter = (event: Event | MessageEvent) => boolean;
interface CreateSameOriginTransceiverOption {
    win?: Window;
    filter?: SameOriginFilter;
    channelName?: string;
    keyPrefix?: string;
    preferBroadcastChannel?: boolean;
}
declare enum TransceiverType {
    broadcastChannel = 0,
    localStorage = 1
}
declare class SameOriginTransceiver {
    private context;
    private filter?;
    private channelName;
    private keyPrefix;
    private uuid;
    private preferBroadcastChannel;
    private localStorageTransceiver;
    private broadcastChannelTransceiver;
    currentTransceiver: LocalStorageTransceiver | BroadcastChannelTransceiver | null;
    private currentType;
    private isStarted;
    private handlers;
    constructor(option: CreateSameOriginTransceiverOption);
    private initializeTransceivers;
    send(eventName: string, data?: unknown, option?: SignalOption): this;
    start(): this;
    stop(): this;
    restart(): this;
    addHandler(handler: TransceiverHandler): this;
    removeHandler(handler: TransceiverHandler): this;
    clearHandler(): this;
    checkStatus(): boolean;
    getCurrentTransceiverType(): TransceiverType;
    static isBroadcastChannelSupported(): boolean;
    switchToBroadcastChannel(): boolean;
    switchToLocalStorage(): boolean;
    private switchTransceiver;
}
declare function createSameOriginTransceiver(option: CreateSameOriginTransceiverOption): SameOriginTransceiver;

interface CreateSameOriginEventBusOption {
    channelName?: string;
    keyPrefix?: string;
    filter?: SameOriginFilter;
    preferBroadcastChannel?: boolean;
}
declare class SameOriginEventBus extends EventBus {
    private transceiver;
    private channelName;
    private keyPrefix;
    constructor(option?: CreateSameOriginEventBusOption);
    /**
     * 发送消息到其他tab
     * @param eventName 事件名
     * @param data 数据
     * @param option 选项
     */
    sendToOtherTabs(eventName: string, data?: unknown, option?: any): this;
    /**
     * 发送消息到所有tab（包括当前tab）
     * @param eventName 事件名
     * @param data 数据
     * @param option 选项
     */
    sendToAllTabs(eventName: string, data?: unknown, option?: any): this;
    /**
     * 监听其他tab的连接事件
     * @param callback 回调函数
     */
    onTabConnected(callback: (tabId: string) => void): void;
    /**
     * 监听其他tab的断开连接事件
     * @param callback 回调函数
     */
    onTabDisconnected(callback: (tabId: string) => void): void;
    /**
     * 获取当前使用的通信方式
     */
    getCurrentTransceiverType(): TransceiverType;
    isBroadcastChannelSupported(): boolean;
    /**
     * 切换到BroadcastChannel（如果支持）
     */
    switchToBroadcastChannel(): boolean;
    /**
     * 切换到localStorage
     */
    switchToLocalStorage(): boolean;
    /**
     * 检查通信状态
     */
    checkStatus(): boolean;
    /**
     * 停止同域通信
     */
    stop(): void;
    /**
     * 重新启动同域通信
     */
    restart(): void;
    /**
     * 强制刷新连接
     */
    refreshConnection(): void;
}
/**
 * 创建SameOriginEventBus的工厂函数
 */
declare function createSameOriginEventBus(option?: CreateSameOriginEventBusOption): SameOriginEventBus;

export { AddIframeTransceiverOption, BaseTransceiver, BroadcastChannelTransceiver, BroadcastFilter, CreateBroadcastChannelTransceiverOption, CreateLocalStorageTransceiverOption, CreateSameOriginTransceiverOption, CreateTabEventBusOption, EventBus, Filter, LocalStorageTransceiver, SameOriginEventBus, SameOriginFilter, SameOriginTransceiver, ServiceCallBack, Signal, SignalOption, SignalPart, Store, TabConnectionEvent, TabEvent, TabMessageEvent, TabPortOfferEvent, TabPortResponseEvent, TransceiverHandler, TransceiverType, WindowClient, WindowEventBus, WindowServer, WindowTransceiver, createBroadcastChannelTransceiver, createLocalStorageTransceiver, createSameOriginEventBus, createSameOriginTransceiver, createVirtualService, createWindowTransceiverOption, hingeJointTransceiver, unHingeJointTransceiver };