@dxyl/utils 1.1.1 → 1.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxyl/utils",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "Collected many useful mathematical tools",
   "keywords": [
     "graphic",

package/types/events/eventTarget.d.ts

@@ -1,93 +1,60 @@
-export interface EventListener<T = any> {
-    (evt: Event<T>): void;
-}
-interface EventListenerObject<T = any> {
-    handleEvent(object: Event<T>): void;
-}
-interface EventInit {
-    bubbles?: boolean;
-    cancelable?: boolean;
-    composed?: boolean;
-}
-interface EventListenerOptions {
-    capture?: boolean;
-}
-type EventListenerOrEventListenerObject<T = any> = EventListener<T> | EventListenerObject<T>;
-interface AddEventListenerOptions extends EventListenerOptions {
+interface EventOptions {
     once?: boolean;
-    passive?: boolean;
-    signal?: AbortSignal;
+    capture?: boolean;
 }
-export declare class Event<T = any> {
-    readonly NONE = 0;
-    readonly CAPTURING_PHASE = 1;
-    readonly AT_TARGET = 2;
-    readonly BUBBLING_PHASE = 3;
+type EventCallback<T> = (event: Event<T>) => void;
+export declare const EventPhase: {
+    readonly NONE: 0;
+    readonly CAPTURING_PHASE: 1;
+    readonly AT_TARGET: 2;
+    readonly BUBBLING_PHASE: 3;
+};
+export type EventPhase = typeof EventPhase[keyof typeof EventPhase];
+export declare const NONE: 0;
+export declare const CAPTURING_PHASE: 1;
+export declare const AT_TARGET: 2;
+export declare const BUBBLING_PHASE: 3;
+export declare class Event<T = any, E extends Extract<keyof Record<string, any>, string> = ''> {
+    static create<T = any, E extends Extract<keyof Record<string, any>, string> = ''>(type: E, bubbles?: boolean, cancelable?: boolean): Event<T, E>;
+    type: E;
+    parentNode: null;
+    target: EventTarget | null;
+    currentTarget: EventTarget | null;
     data: T | null;
-    /** 事件类型 */
-    type: string;
-    /** 事件是否冒泡 */
+    eventPhase: number;
     bubbles: boolean;
-    /** 阻止事件冒泡的标志 */
-    cancelBubble: boolean;
-    /** 事件是否可以取消 */
     cancelable: boolean;
-    /** 事件是否支持跨文档冒泡 */
-    composed: boolean;
-    /** 事件是否被默认行为阻止 */
     defaultPrevented: boolean;
-    /** 事件是否由用户操作生成 */
-    isTrusted: boolean;
-    /** 事件的目标对象 */
-    target: EventTarget | null;
-    /** 当前正在处理事件的对象 */
-    currentTarget: EventTarget | null;
-    /** 事件阶段 */
-    eventPhase: number;
-    /** 事件的时间戳 */
-    timeStamp: number;
-    /**
-     * 标记事件是否应该立即停止传播
-     */
-    stopImmediatePropagationInternal: boolean;
-    /**
-     * 构造函数
-     * @param type 事件类型
-     * @param eventInitDict 可选的事件初始化字典
-     */
-    constructor(type: string, eventInitDict?: EventInit);
-    setData(data: T): this;
-    /**
-      * 初始化事件对象的属性
-      * @param type 事件类型
-      * @param bubbles 是否冒泡
-      * @param cancelable 是否可以取消
-      */
-    initEvent(type: string, bubbles?: boolean, cancelable?: boolean): void;
-    /**
-     * 阻止事件冒泡
-     */
-    stopPropagation(): void;
+    cancelBubble: boolean;
+    immediateCancelBubble: boolean;
+    constructor(type: E, bubbles?: boolean, cancelable?: boolean);
+    setData(data: T | null): this;
+    initEvent(type: E, bubbles?: boolean, cancelable?: boolean): void;
     /**
-     * 阻止事件的默认行为
+     *
+     * @returns {EventTarget[]}
      */
+    composedPath(): EventTarget<{}>[];
     preventDefault(): void;
-    /**
-     * 阻止事件冒泡并停止调用事件监听器
-     */
+    stopPropagation(): void;
     stopImmediatePropagation(): void;
-    /**
-     * 返回事件的目标对象及其祖先对象的路径
-     * @returns 事件路径的数组
-     */
-    composedPath(): EventTarget[];
 }
-export declare class EventTarget<Events extends Record<string, any> = any> {
-    private listeners;
+export interface EventTarget<Events extends Record<string, any> = {}> {
+    on<K extends keyof Events>(type: K, fn: EventCallback<Events[K]>, options?: EventOptions | boolean): void;
+    off<K extends keyof Events>(type: K, fn: EventCallback<Events[K]>, options?: EventOptions | boolean): void;
+    emit<K extends Extract<keyof Events, string>>(e: Event<Events[K], K>): void;
+}
+export declare class EventTarget<Events extends Record<string, any> = {}> {
     parentNode: EventTarget | null;
-    constructor();
-    addEventListener<E extends keyof Events>(type: E, callback: EventListenerOrEventListenerObject<Events[E]>, options?: AddEventListenerOptions | boolean): void;
-    dispatchEvent<E extends keyof Events>(event: Event<Events[E]>): boolean;
-    removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+    private _bubble_emitter;
+    private _capture_emitter;
+    addEventListener<K extends keyof Events>(type: K, fn: EventCallback<Events[K]>, options?: EventOptions | boolean): void;
+    removeEventListener<K extends keyof Events>(type: K, fn: EventCallback<Events[K]>, options?: EventOptions | boolean): void;
+    /**
+     *
+     * @param {Event} e
+     */
+    dispatchEvent<K extends Extract<keyof Events, string>>(e: Event<Events[K], K>): boolean;
+    removeAllListeners(): void;
 }
-export {};
+export { EventTarget as EventPropagation };