@dxyl/utils 1.1.5 → 1.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxyl/utils",
-  "version": "1.1.5",
+  "version": "1.1.6",
   "description": "Collected many useful mathematical tools",
   "publishConfig": {
     "access": "public"

package/types/events/Observable.d.ts

@@ -0,0 +1,28 @@
+export function merge(...sources: any[]): Observable;
+export function combineLatest(...sources: any[]): Observable;
+export function zip(...sources: any[]): Observable;
+export class Observable {
+    [x: number]: () => this;
+    static from(x: any): Observable;
+    static of(...items: any[]): Observable;
+    constructor(subscriber: any);
+    _subscriber: any;
+    subscribe(observer: any, ...args: any[]): Subscription;
+    forEach(fn: any): Promise<any>;
+    map(fn: any): any;
+    filter(fn: any): any;
+    reduce(fn: any, ...args: any[]): any;
+    all(): Promise<any[]>;
+    concat(...sources: any[]): any;
+    flatMap(fn: any): any;
+}
+declare class Subscription {
+    constructor(observer: any, subscriber: any);
+    _cleanup: any;
+    _observer: any;
+    _queue: any;
+    _state: string;
+    get closed(): boolean;
+    unsubscribe(): void;
+}
+export {};

package/types/events/eventmitter.d.ts

@@ -0,0 +1,83 @@
+type Handle = (...args: any[]) => void;
+type HandleData<T extends any[]> = (...args: T) => void;
+type ListenerItem = {
+    handle: Handle;
+    once?: boolean;
+    namespace?: string;
+    stage: number;
+};
+type ListenrOptions = {
+    namespace?: string;
+    capture?: boolean;
+    once?: boolean;
+    stage?: number;
+};
+type EventListener = Record<string, ListenerItem[]>;
+type EventTarget = {
+    parent?: EventTarget | null;
+};
+type EventTargetObj = {
+    [Key: string]: EventListener | Map<string, Map<string, number>> | null | undefined;
+};
+export declare function addEventListener(target: EventTargetObj, listenerName: string, listenerNameNs: string, eventName: string, handle: Handle, options?: ListenrOptions): void;
+export declare function removeEventListener(target: EventTargetObj, listenerName: string, listenerNameNs: string, eventName?: string | null, namespace?: string | null, handler?: Function): void;
+export declare function dispatchEvent(target: EventTargetObj, listenerName: string, listenerNameNs: string, eventName: string, ...args: any[]): void;
+export declare function getListeners(target: EventTargetObj, listenerName: string, eventName: string): ListenerItem[];
+export declare function removeAllListeners(target: EventTargetObj, listenerName: string, listenerNameNs: string): void;
+export declare function hasEventListener(target: EventTargetObj, listenerName: string, eventName: string): boolean;
+export declare function getEventNames(target: EventTargetObj): string[];
+export declare function dispatchBubbleEvent(target: EventTargetObj, listenerName: string, captureListenerName: string, listenerNameNs: string, e: IEmitter4Event<any>): boolean;
+interface IEmitter4Event<D = any> {
+    type: string;
+    data?: D | null;
+    target: EventTarget | null;
+    currentTarget?: EventTarget | null;
+    bubbles: boolean;
+    cancelable: boolean;
+    defaultPrevented: boolean;
+    cancelBubble: boolean;
+    immediateCancelBubble: boolean;
+    eventPhase: number;
+    composedPath(target: EventTarget): EventTarget[];
+    preventDefault(): void;
+    stopPropagation(): void;
+    stopImmediatePropagation(): void;
+}
+export declare class Emitter4Event<D> implements IEmitter4Event<D> {
+    static create<T extends string, D = any>(type: T, data?: D): Emitter4Event<T>;
+    type: string;
+    target: EventTarget | null;
+    currentTarget?: EventTarget | null;
+    data?: D | null;
+    eventPhase: number;
+    bubbles: boolean;
+    cancelable: boolean;
+    defaultPrevented: boolean;
+    cancelBubble: boolean;
+    immediateCancelBubble: boolean;
+    constructor(type: string, bubbles?: boolean, cancelable?: boolean);
+    setData(data: D | null): this;
+    initEvent(type: string, bubbles?: boolean, cancelable?: boolean): this;
+    /**
+     *
+     * @returns {EventTarget[]}
+     */
+    composedPath(target: EventTarget): EventTarget[];
+    preventDefault(): void;
+    stopPropagation(): void;
+    stopImmediatePropagation(): void;
+}
+export declare class EventEmitter4<E extends Record<string, any[]>> implements EventTarget {
+    parent?: EventTarget | null;
+    _listeners?: EventListener;
+    _listenersNs?: Map<string, Map<string, number>>;
+    on<T extends Extract<keyof E, string>, D extends E[T]>(type: T, handle: HandleData<D>, opts?: ListenrOptions): this;
+    emit<T extends Extract<keyof E, string>, D extends E[T]>(type: T, ...args: D): this;
+    createEvent<T extends Extract<keyof E, string>, D extends E[T]>(type: T, data: D[0]): Emitter4Event<T>;
+    emitBubble(e: IEmitter4Event): boolean;
+    off<T extends Extract<keyof E, string>>(type?: T | null, handler?: Function, opts?: ListenrOptions): this;
+    eventNames(): string[];
+    hasEventListener<T extends Extract<keyof E, string>>(type: T): boolean;
+    removeAllListeners(): this;
+}
+export {};

package/types/index.d.ts

@@ -1,6 +1,8 @@
 export * from './events/eventTarget';
 export * from './events/eventemitter3';
 export * from './events/mitt';
+export { EventEmitter4, Emitter4Event } from './events/eventmitter';
+export { default as mitt } from './events/mitt';
 export * from './callbacks';
 export * from './ismobilejs';
 export * from './priority_queue';