improve types

packages/overlayscrollbars-ngx/src/overlayscrollbars.component.ts

@@ -10,7 +10,7 @@ import {
   AfterViewInit,
 } from '@angular/core';
 import { OverlayScrollbars } from 'overlayscrollbars';
-import type { PartialOptions, EventListeners, EventListenerMap } from 'overlayscrollbars';
+import type { PartialOptions, EventListeners, EventListenerArgs } from 'overlayscrollbars';
 import { OverlayScrollbarsDirective } from './overlayscrollbars.directive';
 
 const mergeEventListeners = (emits: EventListeners, events: EventListeners) =>
@@ -43,13 +43,13 @@ export class OverlayScrollbarsComponent implements OnDestroy, AfterViewInit {
   events?: EventListeners | false | null;
 
   @Output('osInitialized')
-  onInitialized = new EventEmitter<EventListenerMap['initialized']>();
+  onInitialized = new EventEmitter<EventListenerArgs['initialized']>();
   @Output('osUpdated')
-  onUpdated = new EventEmitter<EventListenerMap['updated']>();
+  onUpdated = new EventEmitter<EventListenerArgs['updated']>();
   @Output('osDestroyed')
-  onDestroyed = new EventEmitter<EventListenerMap['destroyed']>();
+  onDestroyed = new EventEmitter<EventListenerArgs['destroyed']>();
   @Output('osScroll')
-  onScroll = new EventEmitter<EventListenerMap['scroll']>();
+  onScroll = new EventEmitter<EventListenerArgs['scroll']>();
 
   @ViewChild('content')
   private contentRef?: ElementRef<HTMLDivElement>;

packages/overlayscrollbars-ngx/test/overlayscrollbars.component.spec.ts

@@ -7,7 +7,7 @@ import {
   OverlayscrollbarsModule,
 } from '~/public-api';
 import type { ComponentFixture } from '@angular/core/testing';
-import type { EventListenerMap } from 'overlayscrollbars';
+import type { EventListenerArgs } from 'overlayscrollbars';
 
 @Component({
   template: `
@@ -45,19 +45,19 @@ class Test {
   @ViewChild('ref', { read: OverlayScrollbarsComponent })
   ref?: OverlayScrollbarsComponent;
 
-  onInitialized(args: EventListenerMap['initialized']) {
+  onInitialized(args: EventListenerArgs['initialized']) {
     this.initialized?.(args);
   }
 
-  onUpdated(args: EventListenerMap['updated']) {
+  onUpdated(args: EventListenerArgs['updated']) {
     this.updated?.(args);
   }
 
-  onDestroyed(args: EventListenerMap['destroyed']) {
+  onDestroyed(args: EventListenerArgs['destroyed']) {
     this.destroyed?.(args);
   }
 
-  onScroll(args: EventListenerMap['scroll']) {
+  onScroll(args: EventListenerArgs['scroll']) {
     this.scroll?.(args);
   }
 

packages/overlayscrollbars-vue/src/OverlayScrollbarsComponent.vue

@@ -6,10 +6,10 @@ import type {
   OverlayScrollbarsComponentRef,
 } from './OverlayScrollbarsComponent.types';
 import type { PropType } from 'vue';
-import type { EventListeners, EventListenerMap } from 'overlayscrollbars';
+import type { EventListeners, EventListenerArgs } from 'overlayscrollbars';
 
 type EmitEventsMap = {
-  [N in keyof EventListenerMap]: `os${Capitalize<N>}`;
+  [N in keyof EventListenerArgs]: `os${Capitalize<N>}`;
 };
 
 const emitEvents: EmitEventsMap = {
@@ -27,10 +27,10 @@ const props = defineProps({
   events: { type: Object as PropType<OverlayScrollbarsComponentProps['events']> },
 });
 const emits = defineEmits<{
-  (name: 'osInitialized', ...args: EventListenerMap['initialized']): void;
-  (name: 'osUpdated', ...args: EventListenerMap['updated']): void;
-  (name: 'osDestroyed', ...args: EventListenerMap['destroyed']): void;
-  (name: 'osScroll', ...args: EventListenerMap['scroll']): void;
+  (name: 'osInitialized', ...args: EventListenerArgs['initialized']): void;
+  (name: 'osUpdated', ...args: EventListenerArgs['updated']): void;
+  (name: 'osDestroyed', ...args: EventListenerArgs['destroyed']): void;
+  (name: 'osScroll', ...args: EventListenerArgs['scroll']): void;
 }>();
 
 const elementRef = shallowRef<HTMLElement | null>(null);
@@ -72,7 +72,7 @@ watch(
     ).reduce<EventListeners>(<N extends keyof EventListeners>(obj: EventListeners, name: N) => {
       const eventListener = currEvents[name];
       obj[name] = [
-        (...args: EventListenerMap[N]) =>
+        (...args: EventListenerArgs[N]) =>
           emits(
             emitEvents[name],
             // @ts-ignore

packages/overlayscrollbars/src/environment.ts

@@ -32,7 +32,7 @@ import type { Options, PartialOptions } from '~/options';
 import type { ScrollbarsHidingPluginInstance } from '~/plugins';
 import type { Initialization, PartialInitialization } from '~/initialization';
 
-type EnvironmentEventMap = {
+type EnvironmentEventArgs = {
   z: [];
   r: [];
 };
@@ -88,8 +88,8 @@ export interface InternalEnvironment {
   readonly _cssCustomProperties: boolean;
   readonly _staticDefaultInitialization: Initialization;
   readonly _staticDefaultOptions: Options;
-  _addZoomListener(listener: EventListener<EnvironmentEventMap, 'z'>): () => void;
-  _addResizeListener(listener: EventListener<EnvironmentEventMap, 'r'>): () => void;
+  _addZoomListener(listener: EventListener<EnvironmentEventArgs, 'z'>): () => void;
+  _addResizeListener(listener: EventListener<EnvironmentEventArgs, 'r'>): () => void;
   _getDefaultInitialization(): Initialization;
   _setDefaultInitialization(newInitialization: PartialInitialization): Initialization;
   _getDefaultOptions(): Options;
@@ -183,7 +183,7 @@ const createEnvironment = (): InternalEnvironment => {
   const envDOM = createDOM(`<div class="${classNameEnvironment}"><div></div></div>`);
   const envElm = envDOM[0] as HTMLElement;
   const envChildElm = envElm.firstChild as HTMLElement;
-  const [addEvent, , triggerEvent] = createEventListenerHub<EnvironmentEventMap>();
+  const [addEvent, , triggerEvent] = createEventListenerHub<EnvironmentEventArgs>();
   const [updateNativeScrollbarSizeCache, getNativeScrollbarSizeCache] = createCache(
     {
       _initialValue: getNativeScrollbarSize(body, envElm, envChildElm),

packages/overlayscrollbars/src/eventListeners.ts

@@ -40,7 +40,7 @@ export interface OnUpdatedEventListenerArgs {
 /**
  * A mapping between event names and their listener arguments.
  */
-export type EventListenerMap = {
+export type EventListenerArgs = {
   /** Triggered after all elements are initialized and appended. */
   initialized: [instance: OverlayScrollbars];
   /** Triggered after an update. */
@@ -58,19 +58,19 @@ export type EventListenerMap = {
  *   [eventName: string]: EventListener | EventListener[]
  * }
  */
-export type EventListeners = GeneralEventListeners<EventListenerMap>;
+export type EventListeners = GeneralEventListeners<EventListenerArgs>;
 
 /** An event listener. */
-export type EventListener<N extends keyof EventListenerMap> = GeneralEventListener<
-  EventListenerMap,
+export type EventListener<N extends keyof EventListenerArgs> = GeneralEventListener<
+  EventListenerArgs,
   N
 >;
 
 /** A function which adds event listeners. */
-export type AddEvent = GeneralAddEvent<EventListenerMap>;
+export type AddEvent = GeneralAddEvent<EventListenerArgs>;
 
 /** A function which removes event listeners. */
-export type RemoveEvent = GeneralRemoveEvent<EventListenerMap>;
+export type RemoveEvent = GeneralRemoveEvent<EventListenerArgs>;
 
 /** A function which triggers event listeners. */
-export type TriggerEvent = GeneralTriggerEvent<EventListenerMap>;
+export type TriggerEvent = GeneralTriggerEvent<EventListenerArgs>;

packages/overlayscrollbars/src/index.ts

@@ -8,13 +8,13 @@ export type {
   PartialOptions,
   ReadonlyOptions,
   OverflowBehavior,
-  ScrollbarsVisibilityBehavior as ScrollbarVisibilityBehavior,
-  ScrollbarsAutoHideBehavior as ScrollbarAutoHideBehavior,
+  ScrollbarsVisibilityBehavior,
+  ScrollbarsAutoHideBehavior,
 } from '~/options';
 export type {
-  EventListenerMap,
   EventListener,
   EventListeners,
+  EventListenerArgs,
   OnUpdatedEventListenerArgs,
 } from '~/eventListeners';
 export type {

packages/overlayscrollbars/src/overlayscrollbars.ts

@@ -20,7 +20,7 @@ import type { Options, PartialOptions, ReadonlyOptions } from '~/options';
 import type { Plugin, OptionsValidationPluginInstance, PluginInstance } from '~/plugins';
 import type { InitializationTarget } from '~/initialization';
 import type { OverflowStyle } from '~/typings';
-import type { EventListenerMap, EventListener, EventListeners } from '~/eventListeners';
+import type { EventListenerArgs, EventListener, EventListeners } from '~/eventListeners';
 import type {
   ScrollbarsSetupElement,
   ScrollbarStructure,
@@ -184,27 +184,27 @@ export interface OverlayScrollbars {
    * @param listener The listener which is invoked on that event.
    * @returns Returns a function which removes the added listeners.
    */
-  on<N extends keyof EventListenerMap>(name: N, listener: EventListener<N>): () => void;
+  on<N extends keyof EventListenerArgs>(name: N, listener: EventListener<N>): () => void;
   /**
    * Adds multiple event listeners to the instance.
    * @param name The name of the event.
    * @param listener The listeners which are invoked on that event.
    * @returns Returns a function which removes the added listeners.
    */
-  on<N extends keyof EventListenerMap>(name: N, listener: EventListener<N>[]): () => void;
+  on<N extends keyof EventListenerArgs>(name: N, listener: EventListener<N>[]): () => void;
 
   /**
    * Removes an event listener from the instance.
    * @param name The name of the event.
    * @param listener The listener which shall be removed.
    */
-  off<N extends keyof EventListenerMap>(name: N, listener: EventListener<N>): void;
+  off<N extends keyof EventListenerArgs>(name: N, listener: EventListener<N>): void;
   /**
    * Removes multiple event listeners from the instance.
    * @param name The name of the event.
    * @param listener The listeners which shall be removed.
    */
-  off<N extends keyof EventListenerMap>(name: N, listener: EventListener<N>[]): void;
+  off<N extends keyof EventListenerArgs>(name: N, listener: EventListener<N>[]): void;
 
   /**
    * Updates the instance.

packages/overlayscrollbars/src/support/eventListeners.ts

@@ -2,56 +2,56 @@ import { isArray, isBoolean, isFunction, isString } from '~/support/utils/types'
 import { keys } from '~/support/utils/object';
 import { each, push, from, isEmptyArray, runEachAndClear } from '~/support/utils/array';
 
-export type EventListener<EventMap extends Record<string, any[]>, N extends keyof EventMap> = (
-  ...args: EventMap[N]
+export type EventListener<EventArgs extends Record<string, any[]>, N extends keyof EventArgs> = (
+  ...args: EventArgs[N]
 ) => void;
 
-export type EventListeners<EventMap extends Record<string, any[]>> = {
-  [K in keyof EventMap]?: EventListener<EventMap, K> | EventListener<EventMap, K>[] | null;
+export type EventListeners<EventArgs extends Record<string, any[]>> = {
+  [K in keyof EventArgs]?: EventListener<EventArgs, K> | EventListener<EventArgs, K>[] | null;
 };
 
-export type RemoveEvent<EventMap extends Record<string, any[]>> = {
-  <N extends keyof EventMap>(name?: N, listener?: EventListener<EventMap, N>): void;
-  <N extends keyof EventMap>(name?: N, listener?: EventListener<EventMap, N>[]): void;
-  <N extends keyof EventMap>(
+export type RemoveEvent<EventArgs extends Record<string, any[]>> = {
+  <N extends keyof EventArgs>(name?: N, listener?: EventListener<EventArgs, N>): void;
+  <N extends keyof EventArgs>(name?: N, listener?: EventListener<EventArgs, N>[]): void;
+  <N extends keyof EventArgs>(
     name?: N,
-    listener?: EventListener<EventMap, N> | EventListener<EventMap, N>[]
+    listener?: EventListener<EventArgs, N> | EventListener<EventArgs, N>[]
   ): void;
 };
 
-export type AddEvent<EventMap extends Record<string, any[]>> = {
-  (eventListeners: EventListeners<EventMap>, pure?: boolean): () => void;
-  <N extends keyof EventMap>(name: N, listener: EventListener<EventMap, N>): () => void;
-  <N extends keyof EventMap>(name: N, listener: EventListener<EventMap, N>[]): () => void;
-  <N extends keyof EventMap>(
-    nameOrEventListeners: N | EventListeners<EventMap>,
-    listener?: EventListener<EventMap, N> | EventListener<EventMap, N>[] | boolean
+export type AddEvent<EventArgs extends Record<string, any[]>> = {
+  (eventListeners: EventListeners<EventArgs>, pure?: boolean): () => void;
+  <N extends keyof EventArgs>(name: N, listener: EventListener<EventArgs, N>): () => void;
+  <N extends keyof EventArgs>(name: N, listener: EventListener<EventArgs, N>[]): () => void;
+  <N extends keyof EventArgs>(
+    nameOrEventListeners: N | EventListeners<EventArgs>,
+    listener?: EventListener<EventArgs, N> | EventListener<EventArgs, N>[] | boolean
   ): () => void;
 };
 
-export type TriggerEvent<EventMap extends Record<string, any[]>> = {
-  <N extends keyof EventMap>(name: N, args?: EventMap[N]): void;
+export type TriggerEvent<EventArgs extends Record<string, any[]>> = {
+  <N extends keyof EventArgs>(name: N, args?: EventArgs[N]): void;
 };
 
-export type EventListenerHub<EventMap extends Record<string, any[]>> = [
-  AddEvent<EventMap>,
-  RemoveEvent<EventMap>,
-  TriggerEvent<EventMap>
+export type EventListenerHub<EventArgs extends Record<string, any[]>> = [
+  AddEvent<EventArgs>,
+  RemoveEvent<EventArgs>,
+  TriggerEvent<EventArgs>
 ];
 
-const manageListener = <EventMap extends Record<string, any[]>, N extends keyof EventMap>(
-  callback: (listener?: EventListener<EventMap, N>) => void,
-  listener?: EventListener<EventMap, N> | EventListener<EventMap, N>[]
+const manageListener = <EventArgs extends Record<string, any[]>, N extends keyof EventArgs>(
+  callback: (listener?: EventListener<EventArgs, N>) => void,
+  listener?: EventListener<EventArgs, N> | EventListener<EventArgs, N>[]
 ) => {
   each(isArray(listener) ? listener : [listener], callback);
 };
 
-export const createEventListenerHub = <EventMap extends Record<string, any[]>>(
-  initialEventListeners?: EventListeners<EventMap>
-): EventListenerHub<EventMap> => {
-  const events = new Map<keyof EventMap, Set<EventListener<EventMap, keyof EventMap>>>();
+export const createEventListenerHub = <EventArgs extends Record<string, any[]>>(
+  initialEventListeners?: EventListeners<EventArgs>
+): EventListenerHub<EventArgs> => {
+  const events = new Map<keyof EventArgs, Set<EventListener<EventArgs, keyof EventArgs>>>();
 
-  const removeEvent: RemoveEvent<EventMap> = (name, listener) => {
+  const removeEvent: RemoveEvent<EventArgs> = (name, listener) => {
     if (name) {
       const eventSet = events.get(name);
       manageListener((currListener) => {
@@ -67,11 +67,11 @@ export const createEventListenerHub = <EventMap extends Record<string, any[]>>(
     }
   };
 
-  const addEvent: AddEvent<EventMap> = ((
-    nameOrEventListeners: keyof EventMap | EventListeners<EventMap>,
+  const addEvent: AddEvent<EventArgs> = ((
+    nameOrEventListeners: keyof EventArgs | EventListeners<EventArgs>,
     listenerOrPure:
-      | EventListener<EventMap, keyof EventMap>
-      | EventListener<EventMap, keyof EventMap>[]
+      | EventListener<EventArgs, keyof EventArgs>
+      | EventListener<EventArgs, keyof EventArgs>[]
       | boolean
   ) => {
     if (isString(nameOrEventListeners)) {
@@ -88,22 +88,22 @@ export const createEventListenerHub = <EventMap extends Record<string, any[]>>(
       removeEvent();
     }
 
-    const eventListenerKeys = keys(nameOrEventListeners) as (keyof EventListeners<EventMap>)[];
+    const eventListenerKeys = keys(nameOrEventListeners) as (keyof EventListeners<EventArgs>)[];
     const offFns: (() => void)[] = [];
     each(eventListenerKeys, (key) => {
-      const eventListener = (nameOrEventListeners as EventListeners<EventMap>)[key];
+      const eventListener = (nameOrEventListeners as EventListeners<EventArgs>)[key];
       eventListener && push(offFns, addEvent(key, eventListener));
     });
 
     return runEachAndClear.bind(0, offFns);
-  }) as AddEvent<EventMap>; // sorry!
+  }) as AddEvent<EventArgs>; // sorry!
 
-  const triggerEvent: TriggerEvent<EventMap> = (name, args) => {
+  const triggerEvent: TriggerEvent<EventArgs> = (name, args) => {
     const eventSet = events.get(name);
 
     each(from(eventSet), (event) => {
       if (args && !isEmptyArray(args)) {
-        (event as (...eventArgs: EventMap[keyof EventMap]) => void).apply(0, args as any);
+        (event as (...eventArgs: EventArgs[keyof EventArgs]) => void).apply(0, args as any);
       } else {
         (event as () => void)();
       }