u-node-mq/index.d.ts

基于发布订阅模型的消息通信插件

// Generated by dts-bundle-generator v6.12.0

declare class Collection<D, ExchangeCollection extends Record<string, Exchange<D>>, QueueCollection extends Record<string, Queue<D>>> {
	/**
	 * 交换机集合
	 */
	private readonly exchangeCollectionHandle;
	/**
	 * 队列集合
	 */
	private readonly queueCollectionHandle;
	constructor(exchangeCollection: ExchangeCollection, queueCollection: QueueCollection);
	/**
	 * 根据交换机名称获取交换机
	 * @param exchangeName
	 * @returns
	 */
	getExchange<E extends keyof ExchangeCollection & string>(exchangeName: E): Exchange<D> | null;
	/**
	 * 获取交换机集合列表
	 * @returns
	 */
	getExchangeList(): Exchange<D>[];
	/**
	 * 添加交换机
	 * @param exchangeName
	 * @param exchange
	 * @returns
	 */
	addExchage(exchangeName: string, exchange: Exchange<D>): Map<string, Exchange<D>>;
	/**
	 * 根据
	 * @param queueName
	 * @returns
	 */
	getQueue<Q extends keyof QueueCollection & string>(queueName: Q): Queue<D> | null;
	/**
	 * 获取队列集合列表
	 * @returns
	 */
	getQueueList(): Queue<D>[];
	/**
	 * 添加一个队列到队列集合
	 * @param queurName
	 * @param queue
	 * @returns
	 */
	addQueue(queurName: string, queue: Queue<D>): Map<string, Queue<D>>;
	/**
	 * 发送消息到交换机
	 * @param exchangeName
	 * @param news
	 */
	pushNewsListToExchange<E extends keyof ExchangeCollection & string>(exchangeName: E, ...news: News<D>[]): void;
	/**
	 * 发送消息到队列
	 * @param queueName
	 * @param news
	 */
	pushNewsListToQueue<Q extends keyof QueueCollection & string>(queueName: Q, ...news: News<D>[]): void;
	/**
	 * 发送消息内容到交换机
	 * @param exchangeName
	 * @param contentList
	 */
	pushContentListToExchange<E extends keyof ExchangeCollection & string>(exchangeName: E, ...contentList: D[]): void;
	/**
	 *  发送消息内容到队列
	 * @param queueName
	 * @param contentList
	 */
	pushContentListToQueue<Q extends keyof QueueCollection & string>(queueName: Q, ...contentList: D[]): void;
	/**
	 * 订阅队列
	 * @param queueName
	 * @param consume
	 * @param payload
	 */
	subscribeQueue<Q extends keyof QueueCollection & string>(queueName: Q, consume: Consume<any>, payload?: any): void;
	/**
	 * 取消订阅队列
	 */
	unsubscribeQueue<Q extends keyof QueueCollection & string>(queueName: Q, consume?: Consume<any>): void;
}
declare class UNodeMQ<D, ExchangeCollection extends Record<string, Exchange<D>>, QueueCollection extends Record<string, Queue<D>>> extends Collection<D, ExchangeCollection, QueueCollection> {
	constructor(exchangeCollection: ExchangeCollection, queueCollection: QueueCollection);
	private readonly installedPlugins;
	use(plugin: Plugin, ...options: any[]): this;
	/**
	 * 发射数据到交换机
	 * @param contentList 消息体列表
	 * @returns
	 */
	emit<E extends keyof ExchangeCollection & string>(exchangeName: E, ...contentList: ReturnPanShapeExchange<ExchangeCollection[E]>[]): this;
	/**
	 * 发射数据到队列
	 * @param queueName
	 * @param contentList
	 * @returns
	 */
	emitToQueue<Q extends keyof QueueCollection & string>(queueName: Q, ...contentList: ReturnPanShapeQueue<QueueCollection[Q]>[]): this;
	/**
	 * 订阅队列消息
	 * @param queueName 队列名称
	 * @param consume 消费方法
	 * @param payload 固定参数，有效载荷，在每次消费的时候都传给消费者
	 * @returns
	 */
	on<Q extends keyof QueueCollection & string>(queueName: Q, consume: Consume<ReturnPanShapeQueue<QueueCollection[Q]>>, payload?: any): () => this;
	/**
	 * 移除消费者
	 * @param queueName
	 * @param consume
	 */
	off<Q extends keyof QueueCollection & string>(queueName: Q, consume?: Consume<ReturnPanShapeQueue<QueueCollection[Q]>>): this;
	/**
	 * 订阅一条消息
	 * 不传入消费方法，则返回Promise<D>
	 * @param queueName
	 * @param consume
	 * @param payload
	 * @returns
	 */
	once<Q extends keyof QueueCollection & string>(queueName: Q, consume: Consume<ReturnPanShapeQueue<QueueCollection[Q]>>, payload?: any): this;
	once<Q extends keyof QueueCollection & string>(queueName: Q): Promise<ReturnPanShapeQueue<QueueCollection[Q]>>;
}
declare enum ComponentEnum {
	"EXCHANGE" = "exchange",
	"QUEUE" = "queue",
	"NEWS" = "news",
	"CONSUMER" = "consumer",
	"LOGS" = "logs"
}
declare enum LogsEnum {
	"CUSTOM" = "custom",
	"CONSOLE" = "console"
}
declare type IframeOption = {
	autoSize?: boolean;
	arg?: string | HTMLElement;
};
declare type LogsComponent = ComponentEnum.EXCHANGE | ComponentEnum.QUEUE | ComponentEnum.NEWS | ComponentEnum.CONSUMER;
declare type LogsType = LogsEnum.CUSTOM | LogsEnum.CONSOLE;
declare type Next = (value?: boolean) => void;
declare type Repeater<D> = (content: D) => Promise<string[]> | string[];
declare type ReturnPanShapeExchange<T> = T extends Exchange<infer U> ? U : never;
declare type ReturnPanShapeQueue<T> = T extends Queue<infer U> ? U : never;
declare type ThenParameter = (isOk: boolean) => void;
export declare class Consumer<D> {
	[k: string]: any;
	/**
	 * id
	 */
	private readonly id;
	getId(): string;
	/**
	 * 消费者创建时间戳
	 */
	createdTime: number;
	/**
	 * 消费方法
	 */
	consume: Consume<D>;
	/**
	 * 固定参数
	 */
	payload?: any;
	constructor(consume: Consume<D>, payload?: any);
	/**
	 * 消费消息
	 * @param news
	 * @param ask
	 * @returns
	 */
	consumption(news: News<D>, ask: boolean): Payload;
}
/**
 * 交换机
 */
export declare class Exchange<D> {
	[k: string]: any;
	name?: string;
	/**
	 * 创建时间戳
	 */
	readonly createdTime: number;
	/**
	 * id
	 */
	private readonly id;
	getId(): string;
	/**
	 * 静态路由
	 */
	private routes;
	getRoutes(): string[];
	pushRoutes(routes: string[]): void;
	setRoutes(routes: string[]): void;
	/**
	 * 动态路由（中继器）
	 */
	private repeater;
	getRepeater(): Repeater<D>;
	setRepeater(repeater: Repeater<D>): void;
	constructor(option?: ExchangeOption<D>);
	/**
	 * 删除routes
	 * @param routes
	 */
	removeRoutes(routes?: string[]): void;
	/**
	 * 获取队列名称列表
	 * @param content
	 * @returns
	 */
	getQueueNameList(content: D): Promise<string[]>;
}
export declare class IframePlugin {
	private readonly name;
	private unmq;
	constructor(name: string, option?: IframeOption);
	install(unmq: UNodeMQ<any, Record<string, Exchange<any>>, Record<string, Queue<any>>>): void;
	/**
	 * 接收消息
	 * @param param0
	 * @returns
	 */
	private receiveMessage;
	/**
	 *发送消息
	 * @param currentWindow
	 * @param type
	 * @param message
	 * @param origin
	 * @param transfer
	 */
	private postMessage;
	/**
	 *广播消息
	 * @param type
	 * @param message
	 */
	private broadcastMessage;
}
/**
 * 全局日志组件
 */
export declare class Logs {
	private static logs;
	private static types;
	private static logsComponents;
	private static customFunction;
	static setLogsConfig(logsConfig: LogsConfig): void;
	/**
	 * 获取日志实例
	 * @returns
	 */
	static getLogsInstance(): {
		setLogs: typeof Logs.setLogs;
	} | undefined;
	/**
	 * 设置日志
	 * @param name
	 * @param data
	 * @returns
	 */
	private static setLogs;
}
export declare class News<D> {
	[k: string]: any;
	/**
	 * id
	 */
	private readonly id;
	getId(): string;
	/**
	 * 消费者创建时间戳
	 */
	readonly createdTime: number;
	/**
	 * 消息内容
	 */
	content: D;
	/**
	 * 剩余可重复消费次数
	 */
	consumedTimes: number;
	constructor(content: D);
}
/**
 * 队列，理论上一个队列的数据格式应该具有一致性
 *
 */
export declare class Queue<D> {
	[k: string]: unknown;
	name?: string;
	/**
	 * 创建时间戳
	 */
	readonly createdTime: number;
	/**
	 * id
	 */
	private readonly id;
	getId(): string;
	/**
	 * 是否需要消息确认
	 */
	ask: boolean;
	/**
	 * 可重新消费次数，消费失败会重复消费
	 */
	rcn: number;
	/**
	 * 消费模式
	 * - Random 随机抽取消费者消费
	 * - All 一条消息所有消费者都消费
	 */
	mode: ConsumMode;
	/**
	 * 是否是异步消费，默认false是同步消费
	 *
	 * 如果是同步消费，则一条消息消费完成或者消费失败才会消费下一条消息
	 * 为同步消费时，mode为ALL则需要所有消费者都消费完或者消费失败才能消费下一条消息
	 *
	 * 如果是异步消费，则会在同一时间内去消费所有消息
	 */
	async: boolean;
	/**
	 * 消费状态，true为正在消费，false为未在消费
	 * 用于同步消费判断当前的消费状态
	 */
	private state;
	/**
	 * 每个消费者最长消费时长
	 * 同步阻塞型代码计算所花时长不计算入内，仅仅控制异步消费者消费代码所花时长
	 * 设置为-1表示无时长限制
	 * 在ask为true和async为false的情况下设置maxTime为-1可能会导致队列将被阻塞
	 */
	maxTime: number;
	/**
	 * 消息 list
	 */
	private news;
	getNews(): News<D>[];
	/**
	 * 移除所有消息
	 * @returns
	 */
	removeAllNews(): boolean;
	/**
	 * 加入消息
	 * @param news
	 */
	pushNews(news: News<D>): void;
	/**
	 * 弹出一条消息
	 * @returns
	 *
	 */
	eject(start?: number): Promise<News<D> | null>;
	/**
	 * 加入消息内容
	 * @param content
	 */
	pushContent(content: D): void;
	/**
	 * 通过id移除指定消息
	 * @param newsId
	 * @returns
	 */
	removeNewsById(newsId: string): boolean;
	/**
	 * 消费者 list
	 */
	private consumerList;
	getConsumerList(): Consumer<D>[];
	/**
	 * 加入消费者
	 * @param consumerList
	 */
	pushConsumer(consumer: Consumer<D>): void;
	/**
	 *
	 * 通过消费方法移除指定消费者
	 * @param consume
	 * @returns
	 */
	removeConsumer(consume: Consume<D>): boolean;
	/**
	 * 加入消费者消费主体
	 *
	 * @param consume
	 * @param payload 消费载体，每次消费都会传入给消费者
	 */
	pushConsume(consume: Consume<D>, payload?: unknown): void;
	/**
	 * 通过id移除指定消费者
	 * @param consumerId
	 * @returns
	 */
	removeConsumerById(consumerId: string): boolean;
	/**
	 * 移除所有消费者
	 * @returns
	 */
	removeAllConsumer(): boolean;
	/**
	 * 操作符集合
	 */
	private operators;
	/**
	 * 添加钩子函数方法
	 * @param operators
	 * @returns
	 */
	add(...operators: Operator<D>[]): this;
	/**
	 * 管道操作符执行
	 * 其中需要阻塞获取返回值（boolea）的是按顺序执行的
	 * @param fun
	 * @param args
	 * @returns
	 */
	private operate;
	constructor(option?: QueueOption<D>);
	/**
	 * 消费方法
	 * 每次执行消费一条消息
	 * @returns
	 */
	consumeNews(): void;
	/**
	 * 指定消费者消费某一条消息的方法
	 * @param news
	 * @param consumer
	 * @returns
	 */
	consumption(news: News<D>, consumer: Consumer<D>): Promise<boolean>;
}
/**
 * 单交换机的UNodeMQ类
 */
export declare class QuickUNodeMQ<D, QueueCollection extends Record<string, Queue<D>>> {
	private exchange;
	private queueCollection;
	private readonly installedPlugins;
	use(plugin: Plugin, ...options: any[]): this;
	constructor(x: ExchangeOption<D> | Exchange<D>, y: QueueCollection);
	/**
	 * 发射数据到交换机
	 * @param contentList 消息体列表
	 * @returns
	 */
	emit(...contentList: D[]): this;
	/**
	 * 发射数据到队列
	 * @param queueName
	 * @param contentList
	 * @returns
	 */
	emitToQueue<Q extends keyof QueueCollection & string>(queueName: Q, ...contentList: D[]): this;
	/**
	 * 订阅队列消息
	 * @param queueName 队列名称
	 * @param consume 消费方法
	 * @param payload 固定参数，有效载荷，在每次消费的时候都传给消费者
	 * @returns
	 */
	on<Q extends keyof QueueCollection & string>(queueName: Q, consume: Consume<D>, payload?: any): () => this;
	/**
	 * 移除消费者
	 * @param queueName
	 * @param consume
	 */
	off<Q extends keyof QueueCollection & string>(queueName: Q, consume?: Consume<D>): this;
	/**
	 * 订阅一条消息
	 * @param queueName
	 * @param consume
	 * @param payload
	 * @returns
	 */
	once<Q extends keyof QueueCollection & string>(queueName: Q, consume: Consume<D>, payload?: any): this;
	once<Q extends keyof QueueCollection & string>(queueName: Q): Promise<D>;
}
/**
 * 单Queue的UNodeMQ类
 */
export declare class SingleUNodeMQ<D> {
	private queue;
	constructor(x?: QueueOption<D> | Queue<D>);
	/**
	 * 发送消息
	 * @param contentList
	 * @returns
	 */
	emit(...contentList: D[]): this;
	/**
	 * 订阅消息
	 * @param consume
	 * @param payload
	 * @returns
	 */
	on(consume: Consume<D>, payload?: any): () => this;
	/**
	 * 移除消费者
	 * @param consume
	 */
	off(consume: Consume<D>): this;
	off(): this;
	/**
	 * 订阅一条消息
	 * @param consume
	 * @param payload
	 */
	once(consume: Consume<D>, payload?: any): this;
	once(): Promise<D>;
	/**
	 * 添加operators
	 * @param operators
	 * @returns
	 */
	add(...operators: Operator<D>[]): this;
	/**
	 * fork一份队列，用于监听当前队列数据输出
	 * @param x
	 * @returns
	 */
	fork(x?: QueueOption<D> | Queue<D>): SingleUNodeMQ<D>;
}
/**
 * 队列消费类型
 * Random：随机选择一个消费者消费；
 * All：所有消费者都消费消息；
 */
export declare enum ConsumMode {
	"Random" = "Random",
	"All" = "All"
}
/**
 * 创建QuickUNodeMQ函数
 * @param x
 * @param y
 * @returns
 */
export declare function createQuickUnmq<D, QueueCollection extends Record<string, Queue<D>>>(x: ExchangeOption<D> | Exchange<D>, y: QueueCollection): QuickUNodeMQ<D, QueueCollection>;
/**
 * 创建SingleUNodeMQ函数
 * @param x
 */
export declare function createSingleUnmq<D>(x?: QueueOption<D> | Queue<D>): SingleUNodeMQ<D>;
/**
 * 使用普通函数创建unmq
 * @param exchangeCollection
 * @param queueCollection
 * @returns
 */
export declare function createUnmq<ExchangeCollection extends Record<string, Exchange<any>>, QueueCollection extends Record<string, Queue<any>>>(exchangeCollection: ExchangeCollection, queueCollection: QueueCollection): UNodeMQ<unknown, ExchangeCollection, QueueCollection>;
export declare type ExchangeOption<D> = {
	routes?: string[];
	repeater?: Repeater<D>;
	name?: string;
	[k: string]: any;
};
/**
 * 队列和消息在队列中的生命周期
 */
export declare type Operator<D> = AsyncOperator<D> & SyncOperator<D>;
export declare type Plugin = (PluginInstallFunction & {
	install?: PluginInstallFunction;
}) | {
	install: PluginInstallFunction;
};
/**
 * 安装插件的方法
 */
export declare type PluginInstallFunction = (unmq: any, ...options: any[]) => void;
/**
 * debounceTime 防抖函数
 * @param dueTime 抖动间隔时间，单位毫秒
 * @param immediate 是否立即执行，默认为false
 * @returns
 * 立即执行代表第一个回调函数会立马执行，防抖函数一般不需要立即执行
 */
export function debounceTime<D>(dueTime: number, immediate?: boolean): Operator<D>;
/**
 * filter 过滤
 * @param fun
 * @returns boolean 返回值控制是否加入队列
 */
export function filter<D>(fun: (res: D) => boolean | Promise<boolean>): Operator<D>;
/**
 * 扩展为观察者模式，即在同一事件循环内消费所有消息
 * 使用off方法可以移除此属性，开发时请注意协调
 * @returns
 */
export function instant<D>(): Operator<D>;
/**
 * setinterval发射数据，发射内容为从0开始的数字
 * @param period 1000 间隔时长
 * @param optimal true 是否在没有消费者的时候暂停发射数据，有消费者则会自动开启发射
 * @returns
 */
export function interval(period?: number, optimal?: boolean): Operator<number>;
/**
 * map 方法返回的数据类型和队列一致
 * @param project
 * @returns
 */
export function map<D>(project: (value: D, index: number) => D): Operator<D>;
/**
 * newsTime 设置消息存活时长
 * @param time 存活时长毫秒数
 * @returns
 */
export function newsTime<D>(time: number): Operator<D>;
/**
 * 提前发射数据，可用来设置默认值或者用来快速测试
 * @param args
 * @returns
 */
export function of<D>(...args: D[]): Operator<D>;
/**
 * removeDuplicates 去重
 * @param fun 根据fun 返回的id进行判断是否需要去重
 * @returns
 */
export function removeDuplicates<D>(fun: (res: any) => any): Operator<D>;
/**
 * 使用ResizeObserver订阅内容区域大小变化
 * https://developer.mozilla.org/zh-CN/docs/Web/API/ResizeObserver
 * @param arg 需要订阅目标元素的id或者dom节点，默认为html元素
 * @returns
 */
export function resizeObserver(arg?: string | HTMLElement): Operator<ResizeObserverEntry>;
/**
 * task 控制队列能存入几条消息
 * @param count
 * @returns
 */
export function task<D>(count: number): Operator<D>;
/**
 * throttleTime 节流函数
 * @param duration 节流间隔时间，单位毫秒
 * @param immediate 是否立即执行，默认为false：
 * 如果为false，则会拿第一次触发的参数到结束时间执行，而不是拿结束时间之前的最后一次触发的参数去执行；
 * 如果为true，则会拿第一次触发的参数立即执行
 * @returns
 */
export function throttleTime<D>(duration: number, immediate?: boolean): Operator<D>;
export interface QueueOption<D> {
	ask?: boolean;
	rcn?: number;
	mode?: ConsumMode;
	name?: string;
	async?: boolean;
	maxTime?: number;
	operators?: Operator<D>[];
	[k: string]: unknown;
}
interface AsyncOperator<D> {
	/**
	 * 操作挂载执行方法
	 * 多个操作符的同个钩子函数会同时执行，所以应该谨慎操作数据，避免产生异步操作数据的问题
	 */
	mounted?: (that: Queue<D>) => unknown;
	/**
	 * 消息成功添加到队列以后
	 */
	addedNews?: (news: News<D>) => unknown;
	/**
	 * 消费者成功加入到队列以后
	 */
	addedConsumer?: (consumer: Consumer<D>) => unknown;
	/**
	 * 消费者成功被移除以后
	 * consumerList 被删除的消费列表
	 */
	removedConsumer?: (consumerList: Consumer<D>[]) => unknown;
}
interface Consume<D> {
	(content: D, next?: Next, payload?: any): Promise<any> | any;
	(content: D, payload?: any): any;
}
interface LogsConfig {
	logs: boolean;
	types?: LogsType[];
	logsComponents?: LogsComponent[];
	customFunction?: <D>(name: LogsComponent, data: D) => void;
}
interface Payload {
	then: (res: ThenParameter) => void;
}
interface SyncOperator<D> {
	/**
	 * 将消息添加到队列之前
	 * 返回的boolean控制消息是否加入队列
	 */
	beforeAddNews?: (news: News<D>) => boolean | Promise<boolean>;
	/**
	 * 加入消费者之前
	 * 返回的boolean控制消费者是否能加入队列
	 */
	/**
	 * 控制消息是否可以被弹出，为false则移除消息
	 */
	ejectNews?: (news: News<D>) => boolean | Promise<boolean>;
}

export {
	UNodeMQ as default,
};

export {};