@js-toolkit/web-utils 1.66.0 → 1.68.0

package/EventEmitterListener.d.ts

@@ -1,7 +1,7 @@
 import { type DomEventTarget, type GetEventMap, type EmitterTarget, type GetEventType, type GetEventListener } from './EventEmitterListener.utils';
-type GetOnOptions<T extends EmitterTarget> = T extends DomEventTarget ? boolean | AddEventListenerOptions : unknown;
-type GetOnceOptions<T extends EmitterTarget> = T extends DomEventTarget ? boolean | OmitStrict<AddEventListenerOptions, 'once'> : undefined;
-type GetOffOptions<T extends EmitterTarget> = T extends DomEventTarget ? boolean | EventListenerOptions : undefined;
+type GetOnOptions<T> = T extends DomEventTarget ? boolean | AddEventListenerOptions : unknown;
+type GetOnceOptions<T> = T extends DomEventTarget ? boolean | OmitStrict<AddEventListenerOptions, 'once'> : undefined;
+type GetOffOptions<T> = T extends DomEventTarget ? boolean | EventListenerOptions : undefined;
 interface GetListenersOptions {
     event?: string | undefined;
     type?: 'normal' | 'capture' | undefined;

package/EventEmitterListener.js

@@ -1 +1,222 @@
-import{isPassiveSupported,isDomEventTarget,isEventTargetLike,normalizeOptions}from"./EventEmitterListener.utils";function getEventTypeError(){return new Error("Event type can not be null.")}function getEventListenerError(){return new Error("Event listener can not be null.")}export class EventEmitterListener{target;interceptor;normalListeners={};captureListeners={};passiveSupported=isPassiveSupported();constructor(e,t){this.target=e,this.interceptor=t,this.target=e}createWrapper(e,t,r,...s){return(...n)=>{r&&this.off(e,t,...s);const i=this.interceptor&&this.interceptor(...n)||n;t(...i)}}getListenerList({event:e,type:t,wrapper:r}={}){const s="normal"===t&&this.normalListeners||"capture"===t&&this.captureListeners||void 0;if(s){const t=e?s[e]&&{[e]:s[e]}:s;return t?Object.values(t).flatMap(e=>e?Array.from(r?e.values():e.keys()):[]):[]}return this.getListenerList({event:e,type:"normal",wrapper:r}).concat(this.getListenerList({event:e,type:"capture",wrapper:r}))}getListeners({event:e,type:t,wrapper:r}={}){const s="normal"===t&&this.normalListeners||"capture"===t&&this.captureListeners||void 0;if(!s){const t=this.getListeners({event:e,type:"normal",wrapper:r}),s=this.getListeners({event:e,type:"capture",wrapper:r}),n={},i=([e,t])=>{const r=n[e];n[e]=r?r.concat(t):t};return Object.entries(t).forEach(i),Object.entries(s).forEach(i),n}const n=e?s[e]&&{[e]:s[e]}:s;return n?Object.entries(n).reduce((e,[t,s])=>{const n=s?Array.from(r?s.values():s.keys()):[];return n.length>0&&(e[t]=n),e},{}):{}}has(e,t,...r){if(!isDomEventTarget(this.target)){const r=this.normalListeners[e];return!!r&&(t?r.has(t):r.size>0)}const s=r[0],n=!0===s||s&&"object"==typeof s&&(s.capture??!1)?this.captureListeners[e]:this.normalListeners[e];return!!n&&(t?n.has(t):n.size>0)}on(e,t,...r){if(null==e)throw getEventTypeError();if(null==t)throw getEventListenerError();if(!isDomEventTarget(this.target)){const s=this.normalListeners[e]??new Map;this.normalListeners[e]=s;const n=s.get(t)??(this.interceptor?this.createWrapper(e,t,!1,...r):t);return!s.has(t)&&s.set(t,n),isEventTargetLike(this.target)?this.target.addEventListener(e,n,...r):this.target.on(e,n,...r),this}const s=r[0],n=!0===s||s&&"object"==typeof s&&(s.capture??!1),i=(s&&"object"==typeof s&&s.once)??!1;if(n){const n=this.captureListeners[e]??new Map;this.captureListeners[e]=n;const o=n.get(t)??this.createWrapper(e,t,i,...r);!n.has(t)&&n.set(t,o),this.target.addEventListener(e,o,normalizeOptions(s))}else{const n=this.normalListeners[e]??new Map;this.normalListeners[e]=n;const o=n.get(t)??this.createWrapper(e,t,i,...r);!n.has(t)&&n.set(t,o),this.target.addEventListener(e,o,normalizeOptions(s))}return this}once(e,t,...r){if(null==e)throw getEventTypeError();if(null==t)throw getEventListenerError();if(!isDomEventTarget(this.target)){const s=this.normalListeners[e]??new Map;this.normalListeners[e]=s;const n=s.get(t)??this.createWrapper(e,t,!0,...r);return!s.has(t)&&s.set(t,n),isEventTargetLike(this.target)?this.target.addEventListener(e,n,...r):this.target.once?this.target.once(e,n,...r):this.target.on(e,n,...r),this}const s=r[0];return this.on(e,t,{..."object"==typeof s?s:null!=s&&{capture:s},once:!0})}off(e,t,...r){if(!isDomEventTarget(this.target)){const s=this.normalListeners[e],n=s?.get(t);return s&&n&&s.delete(t),0===s?.size&&delete this.normalListeners[e],isEventTargetLike(this.target)?this.target.removeEventListener(e,n??t,...r):this.target.off(e,n??t,...r),this}const s=r[0],n=!0===s||s&&"object"==typeof s&&(s.capture??!1),i=n?this.captureListeners[e]:this.normalListeners[e],o=i?.get(t);return i&&o&&i.delete(t),0===i?.size&&(n?delete this.captureListeners[e]:delete this.normalListeners[e]),this.target.removeEventListener(e,o??t,normalizeOptions(s)),this}removeAllListeners(e){if(e){const t=this.normalListeners[e];t&&t.forEach((t,r)=>this.off(e,r));const r=this.captureListeners[e];r&&r.forEach((t,r)=>this.off(e,r,!0))}else Object.keys(this.normalListeners).forEach(e=>this.removeAllListeners(e)),Object.keys(this.captureListeners).forEach(e=>this.removeAllListeners(e));return this}removeAllListenersBut(...e){return 0===e.length?this.removeAllListeners():(Object.keys(this.normalListeners).forEach(t=>!e.includes(t)&&this.removeAllListeners(t)),Object.keys(this.captureListeners).forEach(t=>!e.includes(t)&&this.removeAllListeners(t)),this)}emit(e,...t){if(null==e)throw getEventTypeError();const[r,...s]=t;return this.getListenerList({event:e,wrapper:!0}).forEach(e=>{e(r,...s)}),this}}
+/* eslint-disable @typescript-eslint/no-unnecessary-type-parameters */
+/* eslint-disable @typescript-eslint/no-dynamic-delete */
+/* eslint-disable @typescript-eslint/strict-boolean-expressions */
+import { isPassiveSupported, isDomEventTarget, isEventTargetLike, normalizeOptions, } from './EventEmitterListener.utils';
+function getEventTypeError() {
+    return new Error('Event type can not be null.');
+}
+function getEventListenerError() {
+    return new Error('Event listener can not be null.');
+}
+export class EventEmitterListener {
+    target;
+    interceptor;
+    normalListeners = {};
+    captureListeners = {};
+    passiveSupported = isPassiveSupported();
+    constructor(target, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    interceptor) {
+        this.target = target;
+        this.interceptor = interceptor;
+        this.target = target;
+    }
+    createWrapper(type, listener, once, ...rest) {
+        return (...params) => {
+            if (once) {
+                this.off(...[type, listener, ...rest]);
+            }
+            const nextParams = this.interceptor?.(...params) ?? params;
+            // if (typeof listener === 'object') {
+            //   (listener.handleEvent as ListenerWrapper)(...params);
+            // } else {
+            listener(...nextParams);
+            // }
+        };
+    }
+    getListenerList({ event, type, wrapper } = {}) {
+        const map = (type === 'normal' && this.normalListeners) ||
+            (type === 'capture' && this.captureListeners) ||
+            undefined;
+        if (map) {
+            const entries = event ? map[event] && { [event]: map[event] } : map;
+            if (!entries)
+                return [];
+            return Object.values(entries).flatMap((m) => (m ? Array.from(wrapper ? m.values() : m.keys()) : []));
+        }
+        return this.getListenerList({ event, type: 'normal', wrapper }).concat(this.getListenerList({ event, type: 'capture', wrapper }));
+    }
+    getListeners({ event, type, wrapper } = {}) {
+        const map = (type === 'normal' && this.normalListeners) ||
+            (type === 'capture' && this.captureListeners) ||
+            undefined;
+        if (!map) {
+            const normal = this.getListeners({ event, type: 'normal', wrapper });
+            const capture = this.getListeners({ event, type: 'capture', wrapper });
+            const acc = {};
+            const callback = ([evtype, l]) => {
+                const list = acc[evtype];
+                acc[evtype] = list ? list.concat(l) : l;
+            };
+            Object.entries(normal).forEach(callback);
+            Object.entries(capture).forEach(callback);
+            return acc;
+        }
+        const entries = event ? map[event] && { [event]: map[event] } : map;
+        if (!entries)
+            return {};
+        return Object.entries(entries).reduce((acc, [evtype, m]) => {
+            const listeners = m ? Array.from(wrapper ? m.values() : m.keys()) : [];
+            if (listeners.length > 0)
+                acc[evtype] = listeners;
+            return acc;
+        }, {});
+    }
+    has(type, listener, ...rest) {
+        if (!isDomEventTarget(this.target)) {
+            // return !!this.normalListeners[type]?.has(listener);
+            const map = this.normalListeners[type];
+            return !!map && (listener ? map.has(listener) : map.size > 0);
+        }
+        // DOM
+        const options = rest[0];
+        const useCapture = options === true || (options && typeof options === 'object' && (options.capture ?? false));
+        const map = useCapture ? this.captureListeners[type] : this.normalListeners[type];
+        // return !!map?.has(listener);
+        return !!map && (listener ? map.has(listener) : map.size > 0);
+    }
+    on(type, listener, ...rest) {
+        if (type == null)
+            throw getEventTypeError();
+        if (listener == null)
+            throw getEventListenerError();
+        if (!isDomEventTarget(this.target)) {
+            const map = this.normalListeners[type] ?? new Map();
+            this.normalListeners[type] = map;
+            const handler = map.get(listener) ??
+                (this.interceptor ? this.createWrapper(type, listener, false, ...rest) : listener);
+            !map.has(listener) && map.set(listener, handler);
+            if (isEventTargetLike(this.target)) {
+                this.target.addEventListener(type, handler, ...rest);
+            }
+            else {
+                this.target.on(type, handler, ...rest);
+            }
+            return this;
+        }
+        // DOM
+        const options = rest[0];
+        const useCapture = options === true || (options && typeof options === 'object' && (options.capture ?? false));
+        const once = (options && typeof options === 'object' && options.once) ?? false;
+        if (useCapture) {
+            const map = this.captureListeners[type] ?? new Map();
+            this.captureListeners[type] = map;
+            const handler = map.get(listener) ?? this.createWrapper(type, listener, once, ...rest);
+            !map.has(listener) && map.set(listener, handler);
+            this.target.addEventListener(type, handler, normalizeOptions(options));
+        }
+        else {
+            const map = this.normalListeners[type] ?? new Map();
+            this.normalListeners[type] = map;
+            const handler = map.get(listener) ?? this.createWrapper(type, listener, once, ...rest);
+            !map.has(listener) && map.set(listener, handler);
+            this.target.addEventListener(type, handler, normalizeOptions(options));
+        }
+        return this;
+    }
+    once(type, listener, ...rest) {
+        if (type == null)
+            throw getEventTypeError();
+        if (listener == null)
+            throw getEventListenerError();
+        if (!isDomEventTarget(this.target)) {
+            const map = this.normalListeners[type] ?? new Map();
+            this.normalListeners[type] = map;
+            const handler = map.get(listener) ?? this.createWrapper(type, listener, true, ...rest);
+            !map.has(listener) && map.set(listener, handler);
+            if (isEventTargetLike(this.target)) {
+                this.target.addEventListener(type, handler, ...rest);
+            }
+            else if (this.target.once) {
+                this.target.once(type, handler, ...rest);
+            }
+            else {
+                this.target.on(type, handler, ...rest);
+            }
+            return this;
+        }
+        // DOM
+        const options = rest[0];
+        return this.on(...[
+            type,
+            listener,
+            {
+                ...(typeof options === 'object' ? options : options != null && { capture: options }),
+                once: true,
+            },
+        ]);
+    }
+    off(type, listener, ...rest) {
+        if (!isDomEventTarget(this.target)) {
+            const map = this.normalListeners[type];
+            const wrapper = map?.get(listener);
+            map && wrapper && map.delete(listener);
+            if (map?.size === 0) {
+                delete this.normalListeners[type];
+            }
+            if (isEventTargetLike(this.target)) {
+                this.target.removeEventListener(type, wrapper ?? listener, ...rest);
+            }
+            else {
+                this.target.off(type, wrapper ?? listener, ...rest);
+            }
+            return this;
+        }
+        // DOM
+        const options = rest[0];
+        const useCapture = options === true || (options && typeof options === 'object' && (options.capture ?? false));
+        const map = useCapture ? this.captureListeners[type] : this.normalListeners[type];
+        const wrapper = map?.get(listener);
+        map && wrapper && map.delete(listener);
+        if (map?.size === 0) {
+            if (useCapture)
+                delete this.captureListeners[type];
+            else
+                delete this.normalListeners[type];
+        }
+        this.target.removeEventListener(type, wrapper ?? listener, normalizeOptions(options));
+        return this;
+    }
+    removeAllListeners(type) {
+        if (type) {
+            const normalMap = this.normalListeners[type];
+            normalMap?.forEach((_, listener) => this.off(...[type, listener]));
+            const captureMap = this.captureListeners[type];
+            captureMap?.forEach((_, listener) => this.off(...[type, listener, true]));
+        }
+        else {
+            Object.keys(this.normalListeners).forEach((k) => this.removeAllListeners(k));
+            Object.keys(this.captureListeners).forEach((k) => this.removeAllListeners(k));
+        }
+        return this;
+    }
+    removeAllListenersBut(...types) {
+        if (types.length === 0)
+            return this.removeAllListeners();
+        Object.keys(this.normalListeners).forEach((k) => !types.includes(k) && this.removeAllListeners(k));
+        Object.keys(this.captureListeners).forEach((k) => !types.includes(k) && this.removeAllListeners(k));
+        return this;
+    }
+    emit(type, ...args) {
+        if (type == null)
+            throw getEventTypeError();
+        const [event, ...rest] = args;
+        this.getListenerList({ event: type, wrapper: true }).forEach((l) => {
+            l(event, ...rest);
+        });
+        return this;
+    }
+}
+// new EventEmitterListener({} as HTMLVideoElement).on('encrypted0', (e) => e, {});
+// new EventEmitterListener({} as HTMLVideoElement).removeAllListeners('sdff');
+// new EventEmitterListener({} as EventEmitterTarget).on('encrypted', (e) => e, {});

package/EventEmitterListener.utils.d.ts

@@ -1,32 +1,43 @@
 import type { EventEmitter } from '@js-toolkit/utils/EventEmitter';
 export type DomEventTarget = EventTarget;
-export type EventTargetLike = {
+export interface EventTargetLike {
     addEventListener: EventEmitterLike['on'];
     removeEventListener: EventEmitterLike['off'];
-};
-export type EventEmitterLike = {
+}
+export interface EventEmitterLike {
     on: (type: any, listener: AnyFunction, ...rest: any[]) => void;
     once?: ((type: any, listener: AnyFunction, ...rest: any[]) => void) | undefined;
     off: (type: any, listener: AnyFunction, ...rest: any[]) => void;
-};
+}
 export type EmitterTarget = DomEventTarget | EventTargetLike | EventEmitterLike;
 export type GetDomEventType<T extends DomEventTarget> = T['addEventListener'] extends {
     (type: infer K, listener: (this: T, ev: any) => any, options?: boolean | AddEventListenerOptions): void;
     (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
 } ? K : string;
-export type GetDomEventListener<E, EM extends AnyObject> = (ev: E extends keyof EM ? EM[E] : Event, ...rest: unknown[]) => unknown;
-export type GetEventTypeFromFn<T extends EventEmitterLike['on']> = T extends {
-    (type: infer K, listener: AnyFunction, ...rest: unknown[]): unknown;
-} ? K : string;
-export type GetEventType<T extends EmitterTarget> = T extends DomEventTarget ? GetDomEventType<T> : T extends EventEmitterLike ? GetEventTypeFromFn<T['on']> : T extends EventTargetLike ? GetEventTypeFromFn<T['addEventListener']> : string;
-export type GetEventListener<T extends EmitterTarget, E, EM extends AnyObject = GetEventMap<T>> = T extends DomEventTarget ? IfExtends<EM, EmptyObject, EventListener, GetDomEventListener<E, EM>> : IfExtends<EM, EmptyObject, Parameters<T extends EventEmitterLike ? T['on'] : T extends EventTargetLike ? T['addEventListener'] : AnyFunction>['1'], (event: E extends keyof EM ? EM[E] : unknown, ...rest: any[]) => unknown>;
+export type GetDomEventListener<E, EM extends AnyObject> = (ev: E extends keyof EM ? EM[E] : Event, ...rest: any[]) => any;
+/** https://github.com/microsoft/TypeScript/issues/32164 */
+export type GetEventTypeFromFn<T> = T extends {
+    (type: infer K1, listener: AnyFunction, ...rest: any[]): any;
+    (type: infer K2, listener: AnyFunction, ...rest: any[]): any;
+    (type: infer K3, listener: AnyFunction, ...rest: any[]): any;
+    (type: infer K4, listener: AnyFunction, ...rest: any[]): any;
+} ? K1 | K2 | K3 | K4 : T extends {
+    (type: infer K1, listener: AnyFunction, ...rest: any[]): any;
+    (type: infer K2, listener: AnyFunction, ...rest: any[]): any;
+    (type: infer K3, listener: AnyFunction, ...rest: any[]): any;
+} ? K1 | K2 | K3 : T extends {
+    (type: infer K1, listener: AnyFunction, ...rest: any[]): any;
+    (type: infer K2, listener: AnyFunction, ...rest: any[]): any;
+} ? K1 | K2 : T extends (type: infer K, listener: AnyFunction, ...rest: any[]) => any ? K : string;
+export type GetEventType<T> = T extends DomEventTarget ? GetDomEventType<T> : T extends EventEmitterLike ? GetEventTypeFromFn<T['on']> : T extends EventTargetLike ? GetEventTypeFromFn<T['addEventListener']> : string;
+export type GetEventListener<T, E, EM extends AnyObject = GetEventMap<T>> = T extends DomEventTarget ? IfExtends<EM, EmptyObject, EventListener, GetDomEventListener<E, EM>> : IfExtends<EM, EmptyObject, Parameters<T extends EventEmitterLike ? T['on'] : T extends EventTargetLike ? T['addEventListener'] : AnyFunction>['1'], (event: E extends keyof EM ? EM[E] : unknown, ...rest: any[]) => unknown>;
 type ListenersMapToEventMap<T extends Record<string, AnyFunction[]>> = {
     [P in keyof T]: Parameters<T[P][number]>[0];
 };
 export type GetEventMap<T> = T extends Window ? WindowEventMap : T extends ServiceWorker ? ServiceWorkerEventMap : T extends Worker ? WorkerEventMap : T extends ShadowRoot ? ShadowRootEventMap : T extends Document ? DocumentEventMap : T extends HTMLBodyElement ? HTMLBodyElementEventMap : T extends HTMLVideoElement ? HTMLVideoElementEventMap : T extends HTMLMediaElement ? HTMLMediaElementEventMap : T extends TextTrackList ? TextTrackListEventMap : T extends HTMLElement ? HTMLElementEventMap : T extends Element ? ElementEventMap : T extends TextTrackList ? TextTrackListEventMap : T extends TextTrackCue ? TextTrackCueEventMap : T extends Animation ? AnimationEventMap : T extends AbortSignal ? AbortSignalEventMap : T extends BroadcastChannel ? BroadcastChannelEventMap : T extends WebSocket ? WebSocketEventMap : T extends MediaStreamTrack ? MediaStreamTrackEventMap : T extends MediaStream ? MediaStreamEventMap : T extends EventSource ? EventSourceEventMap : T extends SourceBuffer ? SourceBufferEventMap : T extends SourceBufferList ? SourceBufferListEventMap : T extends RemotePlayback ? RemotePlaybackEventMap : T extends EventEmitter<any, any> ? ListenersMapToEventMap<ReturnType<T['getEventListeners']>> : EmptyObject;
-export declare function isEventTargetLike(target: EmitterTarget): target is EventTargetLike;
-export declare function isDomEventTarget(target: EmitterTarget): target is DomEventTarget;
-export declare function isEventEmitterLike(target: EmitterTarget): target is EventEmitterLike;
+export declare function isEventTargetLike(target: unknown): target is EventTargetLike;
+export declare function isDomEventTarget(target: unknown): target is DomEventTarget;
+export declare function isEventEmitterLike(target: unknown): target is EventEmitterLike;
 export declare function isPassiveSupported(): boolean;
 export declare function normalizeOptions(options: boolean | AddEventListenerOptions | undefined): typeof options;
 export {};

package/EventEmitterListener.utils.js

@@ -1 +1,41 @@
-import{isEmptyObject}from"@js-toolkit/utils/isEmptyObject";export function isEventTargetLike(e){return void 0!==e.addEventListener&&void 0!==e.removeEventListener}export function isDomEventTarget(e){return isEventTargetLike(e)&&void 0!==e.dispatchEvent}export function isEventEmitterLike(e){return!isEventTargetLike(e)&&!isDomEventTarget(e)&&void 0!==e.on&&void 0!==e.once&&void 0!==e.off}let passiveSupported=!1;export function isPassiveSupported(){return passiveSupported}try{const e={get passive(){return passiveSupported=!0,!1}};window.addEventListener("__testpassive__",null,e)}catch{}export function normalizeOptions(e){if(e&&"object"==typeof e){let t=e;if("passive"in e&&!passiveSupported){const{passive:i,...n}=e;t=n}return isEmptyObject(t)?void 0:t}return e}
+import { isEmptyObject } from '@js-toolkit/utils/isEmptyObject';
+export function isEventTargetLike(target) {
+    return (target.addEventListener !== undefined &&
+        target.removeEventListener !== undefined);
+}
+export function isDomEventTarget(target) {
+    return isEventTargetLike(target) && target.dispatchEvent !== undefined;
+}
+export function isEventEmitterLike(target) {
+    return (!isEventTargetLike(target) &&
+        !isDomEventTarget(target) &&
+        target.on !== undefined &&
+        target.once !== undefined &&
+        target.off !== undefined);
+}
+let passiveSupported = false;
+export function isPassiveSupported() {
+    return passiveSupported;
+}
+try {
+    const options = {
+        get passive() {
+            passiveSupported = true;
+            return false;
+        },
+    };
+    window.addEventListener('__testpassive__', null, options);
+}
+catch { }
+export function normalizeOptions(options) {
+    if (options != null && typeof options === 'object') {
+        let result = options;
+        if ('passive' in options && !passiveSupported) {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const { passive, ...rest } = options;
+            result = rest;
+        }
+        return isEmptyObject(result) ? undefined : result;
+    }
+    return options;
+}

package/EventListeners.js

@@ -1 +1,58 @@
-import{EventEmitterListener}from"./EventEmitterListener";export class EventListeners{listeners=new Map;getScopes(){return this.listeners.keys()}scope(e,s){const t=s??"",r=this.listeners.get(e)??new Map;!this.listeners.has(e)&&this.listeners.set(e,r);const i=r.get(t)??new EventEmitterListener(e);return!r.has(t)&&r.set(t,i),i}removeAllListeners(e,s){if(e){const t=this.listeners.get(e);s?(t?.get(s)?.removeAllListeners(),t?.delete(s),0===t?.size&&this.listeners.delete(e)):(t?.forEach(e=>e.removeAllListeners()),t?.clear(),this.listeners.delete(e))}else this.listeners.forEach(e=>{e.forEach(e=>e.removeAllListeners()),e.clear()}),this.listeners.clear();return this}}
+/* eslint-disable @typescript-eslint/no-unnecessary-type-parameters */
+import { EventEmitterListener } from './EventEmitterListener';
+export class EventListeners {
+    // private readonly listeners = new Map<EmitterTarget, EventEmitterListener<any, any>>();
+    // scope<T extends EmitterTarget, M extends AnyObject = GetEventMap<T>>(
+    //   target: T
+    // ): EventEmitterListener<T, M> {
+    //   const listener = this.listeners.get(target) ?? new EventEmitterListener<T, M>(target);
+    //   !this.listeners.has(target) && this.listeners.set(target, listener);
+    //   return listener as EventEmitterListener<T, M>;
+    // }
+    // removeAllListeners<T extends EmitterTarget>(target?: T | undefined): this {
+    //   if (target) {
+    //     this.listeners.get(target)?.removeAllListeners();
+    //     this.listeners.delete(target);
+    //   } else {
+    //     this.listeners.forEach((l) => l.removeAllListeners());
+    //     this.listeners.clear();
+    //   }
+    //   return this;
+    // }
+    listeners = new Map();
+    getScopes() {
+        return this.listeners.keys();
+    }
+    scope(target, scope) {
+        const id = scope ?? '';
+        const scopeMap = this.listeners.get(target) ??
+            new Map();
+        !this.listeners.has(target) && this.listeners.set(target, scopeMap);
+        const listener = scopeMap.get(id) ?? new EventEmitterListener(target);
+        !scopeMap.has(id) && scopeMap.set(id, listener);
+        return listener;
+    }
+    removeAllListeners(target, scope) {
+        if (target) {
+            const map = this.listeners.get(target);
+            if (scope) {
+                map?.get(scope)?.removeAllListeners();
+                map?.delete(scope);
+                map?.size === 0 && this.listeners.delete(target);
+            }
+            else {
+                map?.forEach((l) => l.removeAllListeners());
+                map?.clear();
+                this.listeners.delete(target);
+            }
+        }
+        else {
+            this.listeners.forEach((m) => {
+                m.forEach((l) => l.removeAllListeners());
+                m.clear();
+            });
+            this.listeners.clear();
+        }
+        return this;
+    }
+}

package/FullscreenController.js

@@ -1 +1,193 @@
-import{EventEmitter}from"@js-toolkit/utils/EventEmitter";import{hasIn}from"@js-toolkit/utils/hasIn";import{toggleNativeSubtitles}from"./media/toggleNativeSubtitles";import{fullscreen}from"./fullscreen";import{enterPseudoFullscreen}from"./fullscreenUtils";export class FullscreenController extends EventEmitter{element;options;static isApiAvailable(){return fullscreen.isApiEnabled()}get Events(){return FullscreenController.Events}fallback;exitPseudoFullscreen;constructor(e,t={}){super(),this.element=e,this.options=t,this.setOptions(t)}unbind(){if(fullscreen.names){const{names:e}=fullscreen;this.element.removeEventListener(e.changeEventName,this.nativeChangeHandler),this.element.removeEventListener(e.errorEventName,this.nativeErrorHandler)}this.fallback instanceof HTMLVideoElement&&(this.fallback.removeEventListener("webkitbeginfullscreen",this.videoBeginFullscreenHandler),this.fallback.removeEventListener("webkitendfullscreen",this.videoEndFullscreenHandler),this.fallback=void 0)}setOptions(e){if(this.unbind(),this.options=e??{},this.fallback=this.options.fallback,fullscreen.names&&fullscreen.isApiEnabled()){const{names:e}=fullscreen;this.element.addEventListener(e.changeEventName,this.nativeChangeHandler),this.element.addEventListener(e.errorEventName,this.nativeErrorHandler)}else this.fallback instanceof HTMLVideoElement&&(this.fallback.addEventListener("webkitbeginfullscreen",this.videoBeginFullscreenHandler),this.fallback.addEventListener("webkitendfullscreen",this.videoEndFullscreenHandler))}isAvailable(){return fullscreen.isApiEnabled()||"pseudo"===this.fallback||this.fallback instanceof HTMLVideoElement&&!!this.fallback.webkitEnterFullscreen&&!!this.fallback.webkitSupportsFullscreen}isFullscreen(){return!!this.getCurrentElement()}isPseudoFullscreen(){return this.isFullscreen()&&!!this.exitPseudoFullscreen}getCurrentElement(){if(fullscreen.isApiEnabled()){if(fullscreen.getElement()===this.element)return this.element}else{if(this.exitPseudoFullscreen)return this.element;if(this.fallback instanceof HTMLVideoElement&&this.fallback.webkitDisplayingFullscreen)return this.fallback}return null}nativeChangeHandler=()=>{this.emit(this.Events.Change,{fullscreen:this.isFullscreen(),type:"native"})};nativeErrorHandler=e=>{this.emit(this.Events.Error,{error:e,type:"native"})};videoBeginFullscreenHandler=(()=>{const e=()=>{const t=this.fallback;e.controls=t.controls,e.nativeSubtitles=hasIn(this.options,"toggleNativeSubtitles")&&this.options.toggleNativeSubtitles&&t.textTracks.length>0,e.nativeSubtitles&&toggleNativeSubtitles(!0,t.textTracks),this.emit(this.Events.Change,{fullscreen:!0,type:"video"})};return e.nativeSubtitles=void 0,e.controls=void 0,e})();videoEndFullscreenHandler=()=>{const e=this.fallback;null!=this.videoBeginFullscreenHandler.controls&&(e.controls=this.videoBeginFullscreenHandler.controls),this.videoBeginFullscreenHandler.nativeSubtitles&&toggleNativeSubtitles(!1,e.textTracks),this.emit(this.Events.Change,{fullscreen:!1,type:"video"})};request(e={}){return new Promise((t,n)=>{if(this.isFullscreen())return void t();if(fullscreen.isApiEnabled())return void fullscreen.request(this.element,e).then(t).catch(n);if("pseudo"===this.fallback)return this.exitPseudoFullscreen=enterPseudoFullscreen(this.element),this.emit(this.Events.Change,{fullscreen:!0,type:"pseudo"}),void t();const l=this.fallback instanceof HTMLVideoElement&&this.fallback||void 0;if(l?.webkitEnterFullscreen&&l.webkitSupportsFullscreen){const e=()=>{l.removeEventListener("webkitbeginfullscreen",e),t()};return l.addEventListener("webkitbeginfullscreen",e),void l.webkitEnterFullscreen()}n(new fullscreen.UnavailableError)})}exit(){return new Promise((e,t)=>{if(!this.isFullscreen())return void e();if(fullscreen.isApiEnabled())return void fullscreen.exit().then(e).catch(t);if(this.exitPseudoFullscreen)return this.exitPseudoFullscreen(),this.exitPseudoFullscreen=void 0,this.emit(this.Events.Change,{fullscreen:!1,type:"pseudo"}),void e();const n=this.fallback instanceof HTMLVideoElement&&this.fallback||void 0;if(n?.webkitExitFullscreen&&n.webkitSupportsFullscreen){const t=()=>{n.removeEventListener("webkitendfullscreen",t),e()};return n.addEventListener("webkitendfullscreen",t),void n.webkitExitFullscreen()}t(new fullscreen.UnavailableError)})}destroy(){return this.exit().then(()=>new Promise(e=>{requestAnimationFrame(()=>{this.removeAllListeners(),this.unbind(),e()})}))}[Symbol.asyncDispose](){return this.destroy()}}!function(e){let t;!function(e){e.Change="change",e.Error="error"}(t=e.Events||(e.Events={}))}(FullscreenController||(FullscreenController={}));
+import { EventEmitter } from '@js-toolkit/utils/EventEmitter';
+import { hasIn } from '@js-toolkit/utils/hasIn';
+import { toggleNativeSubtitles } from './media/toggleNativeSubtitles';
+import { fullscreen } from './fullscreen';
+import { enterPseudoFullscreen } from './fullscreenUtils';
+export class FullscreenController extends EventEmitter {
+    element;
+    options;
+    static isApiAvailable() {
+        return fullscreen.isApiEnabled();
+    }
+    // eslint-disable-next-line class-methods-use-this
+    get Events() {
+        return FullscreenController.Events;
+    }
+    fallback;
+    exitPseudoFullscreen;
+    constructor(element, options = {}) {
+        super();
+        this.element = element;
+        this.options = options;
+        this.setOptions(options);
+    }
+    unbind() {
+        if (fullscreen.names) {
+            const { names } = fullscreen;
+            this.element.removeEventListener(names.changeEventName, this.nativeChangeHandler);
+            this.element.removeEventListener(names.errorEventName, this.nativeErrorHandler);
+        }
+        if (this.fallback instanceof HTMLVideoElement) {
+            this.fallback.removeEventListener('webkitbeginfullscreen', this.videoBeginFullscreenHandler);
+            this.fallback.removeEventListener('webkitendfullscreen', this.videoEndFullscreenHandler);
+            this.fallback = undefined;
+        }
+    }
+    setOptions(options) {
+        this.unbind();
+        this.options = options ?? {};
+        this.fallback = this.options.fallback;
+        if (fullscreen.names && fullscreen.isApiEnabled()) {
+            const { names } = fullscreen;
+            this.element.addEventListener(names.changeEventName, this.nativeChangeHandler);
+            this.element.addEventListener(names.errorEventName, this.nativeErrorHandler);
+        }
+        // Use video if regular fullscreen api unavailable (probably ios).
+        else if (this.fallback instanceof HTMLVideoElement) {
+            this.fallback.addEventListener('webkitbeginfullscreen', this.videoBeginFullscreenHandler);
+            this.fallback.addEventListener('webkitendfullscreen', this.videoEndFullscreenHandler);
+        }
+    }
+    isAvailable() {
+        return (fullscreen.isApiEnabled() ||
+            this.fallback === 'pseudo' ||
+            (this.fallback instanceof HTMLVideoElement &&
+                !!this.fallback.webkitEnterFullscreen &&
+                !!this.fallback.webkitSupportsFullscreen));
+    }
+    isFullscreen() {
+        return !!this.getCurrentElement();
+    }
+    isPseudoFullscreen() {
+        return this.isFullscreen() && !!this.exitPseudoFullscreen;
+    }
+    getCurrentElement() {
+        if (fullscreen.isApiEnabled()) {
+            if (fullscreen.getElement() === this.element)
+                return this.element;
+        }
+        else if (this.exitPseudoFullscreen) {
+            return this.element;
+        }
+        else if (this.fallback instanceof HTMLVideoElement &&
+            this.fallback.webkitDisplayingFullscreen) {
+            return this.fallback;
+        }
+        return null;
+    }
+    nativeChangeHandler = () => {
+        this.emit(this.Events.Change, { fullscreen: this.isFullscreen(), type: 'native' });
+    };
+    nativeErrorHandler = (event) => {
+        this.emit(this.Events.Error, { error: event, type: 'native' });
+    };
+    videoBeginFullscreenHandler = (() => {
+        const handler = () => {
+            const video = this.fallback;
+            handler.controls = video.controls;
+            handler.nativeSubtitles =
+                hasIn(this.options, 'toggleNativeSubtitles') &&
+                    this.options.toggleNativeSubtitles &&
+                    video.textTracks.length > 0;
+            if (handler.nativeSubtitles)
+                toggleNativeSubtitles(true, video.textTracks);
+            this.emit(this.Events.Change, { fullscreen: true, type: 'video' });
+        };
+        handler.nativeSubtitles = undefined;
+        handler.controls = undefined;
+        return handler;
+    })();
+    videoEndFullscreenHandler = () => {
+        const video = this.fallback;
+        // Fix swiped exit fullscreen
+        if (this.videoBeginFullscreenHandler.controls != null) {
+            video.controls = this.videoBeginFullscreenHandler.controls;
+        }
+        if (this.videoBeginFullscreenHandler.nativeSubtitles) {
+            toggleNativeSubtitles(false, video.textTracks);
+        }
+        this.emit(this.Events.Change, { fullscreen: false, type: 'video' });
+    };
+    request(options = {}) {
+        return new Promise((resolve, reject) => {
+            if (this.isFullscreen()) {
+                resolve();
+                return;
+            }
+            if (fullscreen.isApiEnabled()) {
+                fullscreen.request(this.element, options).then(resolve).catch(reject);
+                return;
+            }
+            if (this.fallback === 'pseudo') {
+                this.exitPseudoFullscreen = enterPseudoFullscreen(this.element);
+                this.emit(this.Events.Change, { fullscreen: true, type: 'pseudo' });
+                resolve();
+                return;
+            }
+            const video = this.fallback instanceof HTMLVideoElement ? this.fallback : undefined;
+            if (video?.webkitEnterFullscreen && video.webkitSupportsFullscreen) {
+                const beginFullscreenHandler = () => {
+                    video.removeEventListener('webkitbeginfullscreen', beginFullscreenHandler);
+                    resolve();
+                };
+                video.addEventListener('webkitbeginfullscreen', beginFullscreenHandler);
+                video.webkitEnterFullscreen();
+                return;
+            }
+            reject(new fullscreen.UnavailableError());
+        });
+    }
+    exit() {
+        return new Promise((resolve, reject) => {
+            if (!this.isFullscreen()) {
+                resolve();
+                return;
+            }
+            if (fullscreen.isApiEnabled()) {
+                fullscreen.exit().then(resolve).catch(reject);
+                return;
+            }
+            if (this.exitPseudoFullscreen) {
+                this.exitPseudoFullscreen();
+                this.exitPseudoFullscreen = undefined;
+                this.emit(this.Events.Change, { fullscreen: false, type: 'pseudo' });
+                resolve();
+                return;
+            }
+            const video = this.fallback instanceof HTMLVideoElement ? this.fallback : undefined;
+            if (video?.webkitExitFullscreen && video.webkitSupportsFullscreen) {
+                const endFullscreenHandler = () => {
+                    video.removeEventListener('webkitendfullscreen', endFullscreenHandler);
+                    resolve();
+                };
+                video.addEventListener('webkitendfullscreen', endFullscreenHandler);
+                video.webkitExitFullscreen();
+                return;
+            }
+            reject(new fullscreen.UnavailableError());
+        });
+    }
+    destroy() {
+        return this.exit().then(() => {
+            // Because of unbind is calling before the change event will be fired.
+            return new Promise((resolve) => {
+                requestAnimationFrame(() => {
+                    this.removeAllListeners();
+                    this.unbind();
+                    resolve();
+                });
+            });
+        });
+    }
+    [Symbol.asyncDispose]() {
+        return this.destroy();
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-namespace
+(function (FullscreenController) {
+    let Events;
+    (function (Events) {
+        Events["Change"] = "change";
+        Events["Error"] = "error";
+    })(Events = FullscreenController.Events || (FullscreenController.Events = {}));
+})(FullscreenController || (FullscreenController = {}));