Changes the event types to not force the usage of the event types enum

Author: julia-script

dist/bundle.browser.js

@@ -85,8 +85,27 @@ export declare class AdvancedAnalyserNode extends AudioWorkletNode {
     getByteTimeDomainData(): Promise<Uint8Array>;
     private _pushEventListener;
     private _removeEventListener;
-    addEventListener(type: EventListenerTypes.bytefrequencydata | EventListenerTypes.bytetimedomaindata, listener: Listener<Uint8Array>): void;
-    addEventListener(type: EventListenerTypes.frequencydata | EventListenerTypes.timedomaindata, listener: Listener<Float32Array>): void;
+    /**
+     * Listens to Time-domain data events. The interval between calls is defined the `timeDomainSamplesCount` property.
+     * Returns a Uint8Array with the size defined by `timeDomainSamplesCount`, with the current time-domain data.
+     */
+    addEventListener(type: "bytetimedomaindata", listener: Listener<Uint8Array>): void;
+    /**
+     * Listens to Frequency data events. The interval between calls is defined by the `samplesBetweenTransforms` property.
+     * The data is represented in bytes
+     * Returns a Uint8Array with half the `fftSize`, with the current frequency data.
+     */
+    addEventListener(type: "bytefrequencydata", listener: Listener<Uint8Array>): void;
+    /**
+     * Listens to Time-domain data events. The interval between calls is defined the `timeDomainSamplesCount` property.
+     * Returns a Float32Array with the size defined by `timeDomainSamplesCount`, with the current time-domain data.
+     */
+    addEventListener(type: "timedomaindata", listener: Listener<Float32Array>): void;
+    /**
+     * Listens to Frequency data events. The interval between calls is defined by the `samplesBetweenTransforms` property.
+     * Returns a Float32Array with half the `fftSize`, with the current frequency data.
+     */
+    addEventListener(type: "frequencydata", listener: Listener<Float32Array>): void;
     addEventListener(type: "processorerror", listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
     removeEventListener(type: "processorerror" | EventListenerTypes, listener: EventListenerOrEventListenerObject | Listener<ArrayBuffer>, options?: boolean | EventListenerOptions): void;
 }

dist/bundle.min.js

@@ -1,2 +1,2 @@
-import { AdvancedAnalyserNodeProperties } from '../types';
+import { AdvancedAnalyserNodeProperties } from "../types";
 export declare const createAdvancedAnalyserNode: (context: BaseAudioContext, options?: AdvancedAnalyserNodeProperties) => Promise<import("./advanced-analyser-node").AdvancedAnalyserNode>;

dist/bundle.server.js

@@ -1,2 +1,2 @@
-export * from './create-advanced-analyser';
-export { type AdvancedAnalyserNode } from './advanced-analyser-node';
+export * from "./create-advanced-analyser";
+export { type AdvancedAnalyserNode } from "./advanced-analyser-node";

dist/processor.worklet.js

@@ -61,29 +61,7 @@ export declare enum ProcessorParameters {
     maxDecibels = "maxDecibels",
     smoothingTimeConstant = "smoothingTimeConstant"
 }
-export declare enum EventListenerTypes {
-    /**
-     * Listens to Frequency data events. The interval between calls is defined by the `samplesBetweenTransforms` property.
-     * Returns a Float32Array with half the `fftSize`, with the current frequency data.
-     */
-    frequencydata = "frequencydata",
-    /**
-     * Listens to Frequency data events. The interval between calls is defined by the `samplesBetweenTransforms` property.
-     * The data is represented in bytes
-     * Returns a Uint8Array with half the `fftSize`, with the current frequency data.
-     */
-    bytefrequencydata = "bytefrequencydata",
-    /**
-     * Listens to Time-domain data events. The interval between calls is defined the `timeDomainSamplesCount` property.
-     * Returns a Float32Array with the size defined by `timeDomainSamplesCount`, with the current time-domain data.
-     */
-    timedomaindata = "timedomaindata",
-    /**
-     * Listens to Time-domain data events. The interval between calls is defined the `timeDomainSamplesCount` property.
-     * Returns a Uint8Array with the size defined by `timeDomainSamplesCount`, with the current time-domain data.
-     */
-    bytetimedomaindata = "bytetimedomaindata"
-}
+export declare type EventListenerTypes = "frequencydata" | "bytefrequencydata" | "timedomaindata" | "bytetimedomaindata";
 export declare enum WindowFunctionTypes {
     /**
      * Retangular window - Doesn't change the signal

dist/src/node/advanced-analyser-node.d.ts

@@ -187,11 +187,11 @@ export class AdvancedAnalyserNode extends AudioWorkletNode  {
   }
 
 
-  private _eventListenersCount:Record<EventListenerTypes, (EventListenerOrEventListenerObject| Listener<ArrayBuffer>)[]> = {
-    [EventListenerTypes.frequencydata]: [],
-    [EventListenerTypes.bytefrequencydata]: [],
-    [EventListenerTypes.timedomaindata]: [],
-    [EventListenerTypes.bytetimedomaindata]: [],
+  private _eventListenersCount:Record<EventListenerTypes, (EventListenerOrEventListenerObject|Listener<ArrayBuffer>)[]> = {
+    frequencydata: [],
+    bytefrequencydata: [],
+    timedomaindata: [],
+    bytetimedomaindata: []
   };
 
 
@@ -257,19 +257,19 @@ export class AdvancedAnalyserNode extends AudioWorkletNode  {
   private _onmessage(event: Message) {
     switch(event.type) {
       case MessageTypes.frequencyDataAvailable: {
-        this.dispatchEvent(new CustomEvent<Float32Array>(EventListenerTypes.frequencydata, { detail: new Float32Array(event.payload) }));
+        this.dispatchEvent(new CustomEvent<Float32Array>('frequencydata', { detail: new Float32Array(event.payload) }));
         break;
       }
       case MessageTypes.byteFrequencyDataAvailable: {
-        this.dispatchEvent(new CustomEvent<Uint8Array>(EventListenerTypes.bytefrequencydata, { detail: new Uint8Array(event.payload) }));
+        this.dispatchEvent(new CustomEvent<Uint8Array>('bytefrequencydata', { detail: new Uint8Array(event.payload) }));
         break;
       }
       case MessageTypes.timeDomainDataAvailable: {
-        this.dispatchEvent(new CustomEvent<Float32Array>(EventListenerTypes.timedomaindata, { detail: new Float32Array(event.payload) }));
+        this.dispatchEvent(new CustomEvent<Float32Array>('timedomaindata', { detail: new Float32Array(event.payload) }));
         break;
       }
       case MessageTypes.byteTimeDomainDataAvailable: {
-        this.dispatchEvent(new CustomEvent<Uint8Array>(EventListenerTypes.bytetimedomaindata, { detail: new Uint8Array(event.payload) }));
+        this.dispatchEvent(new CustomEvent<Uint8Array>('bytetimedomaindata', { detail: new Uint8Array(event.payload) }));
         break;
       }
       case MessageTypes.requestedFloatFrequencyDataAvailable:
@@ -350,11 +350,31 @@ export class AdvancedAnalyserNode extends AudioWorkletNode  {
       });
     }
   }
+  
+  /**
+   * Listens to Time-domain data events. The interval between calls is defined the `timeDomainSamplesCount` property.
+   * Returns a Uint8Array with the size defined by `timeDomainSamplesCount`, with the current time-domain data.
+   */
+  addEventListener(type: 'bytetimedomaindata' , listener: Listener<Uint8Array>): void;
 
-  addEventListener(type: EventListenerTypes.bytefrequencydata | EventListenerTypes.bytetimedomaindata, listener: Listener<Uint8Array>): void;
+  /**
+   * Listens to Frequency data events. The interval between calls is defined by the `samplesBetweenTransforms` property.
+   * The data is represented in bytes
+   * Returns a Uint8Array with half the `fftSize`, with the current frequency data.
+   */
+  addEventListener(type: 'bytefrequencydata' , listener: Listener<Uint8Array>): void;
 
-  addEventListener(type: EventListenerTypes.frequencydata | EventListenerTypes.timedomaindata, listener: Listener<Float32Array>): void;
+  /**
+   * Listens to Time-domain data events. The interval between calls is defined the `timeDomainSamplesCount` property.
+   * Returns a Float32Array with the size defined by `timeDomainSamplesCount`, with the current time-domain data.
+   */
+  addEventListener(type: 'timedomaindata', listener: Listener<Float32Array>): void;
 
+  /**
+   * Listens to Frequency data events. The interval between calls is defined by the `samplesBetweenTransforms` property.
+   * Returns a Float32Array with half the `fftSize`, with the current frequency data.
+   */
+  addEventListener(type: 'frequencydata', listener: Listener<Float32Array>): void;
 
   addEventListener(type: "processorerror", listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void ;
 

dist/src/node/create-advanced-analyser.d.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/ban-ts-comment */
 
 import { noop } from "lodash";
-import { EventListenerTypes, MessageTypes, WindowFunctionTypes } from "../types";
+import { MessageTypes, WindowFunctionTypes } from "../types";
 import { MAX_FFT_SIZE, MIN_FFT_SIZE, PROCESSOR_NAME } from "../constants";
 
 jest.mock('processor', () => ({
@@ -525,18 +525,18 @@ describe('AdvancedAnalyserNode', () => {
   });
 
   describe('Events', () => {
-    describe(EventListenerTypes.frequencydata, () => {
+    describe('frequencydata', () => {
       it(`register event`, () => {
         const node = new AdvancedAnalyserNode(context, {
           fftSize: 1024,
         });
 
 
-        node.addEventListener(EventListenerTypes.frequencydata, ({ detail }:CustomEvent<Float32Array>) => {
+        node.addEventListener('frequencydata', ({ detail }) => {
           console.log(detail);
         });
 
-        expect(addEventListenerSpy.mock.calls[0][0]).toEqual(EventListenerTypes.frequencydata);
+        expect(addEventListenerSpy.mock.calls[0][0]).toEqual('frequencydata');
 
       });
 
@@ -545,7 +545,7 @@ describe('AdvancedAnalyserNode', () => {
           fftSize: 1024,
         });
 
-        node.addEventListener(EventListenerTypes.frequencydata, ({ detail }:CustomEvent<Float32Array>) => {
+        node.addEventListener('frequencydata', ({ detail }:CustomEvent<Float32Array>) => {
           console.log(detail);
         });
         const payload =  Float32Array.from([0, 1, 2, 3]);
@@ -567,23 +567,23 @@ describe('AdvancedAnalyserNode', () => {
         const listener =  ({ detail }:CustomEvent<Float32Array>) => {
           console.log(detail);
         };
-        node.removeEventListener(EventListenerTypes.frequencydata, listener);
-        expect(removeEventListenerSpy).toHaveBeenLastCalledWith(EventListenerTypes.frequencydata, listener, undefined);
+        node.removeEventListener('frequencydata', listener);
+        expect(removeEventListenerSpy).toHaveBeenLastCalledWith('frequencydata', listener, undefined);
       });
     });
 
 
-    describe(EventListenerTypes.bytefrequencydata, () => {
+    describe('bytefrequencydata', () => {
       it('register event', () => {
         const node = new AdvancedAnalyserNode(context, {
           fftSize: 1024,
         });
 
-        node.addEventListener(EventListenerTypes.bytefrequencydata, ({ detail }:CustomEvent<Uint8Array>) => {
+        node.addEventListener('bytefrequencydata', ({ detail }:CustomEvent<Uint8Array>) => {
           console.log(detail);
         });
 
-        expect(addEventListenerSpy.mock.calls[0][0]).toEqual(EventListenerTypes.bytefrequencydata);
+        expect(addEventListenerSpy.mock.calls[0][0]).toEqual('bytefrequencydata');
 
       });
 
@@ -592,7 +592,7 @@ describe('AdvancedAnalyserNode', () => {
           fftSize: 1024,
         });
 
-        node.addEventListener(EventListenerTypes.bytefrequencydata, ({ detail }:CustomEvent<Uint8Array>) => {
+        node.addEventListener('bytefrequencydata', ({ detail }:CustomEvent<Uint8Array>) => {
           console.log(detail);
         });
         const payload = Uint8Array.from([0, 1, 2, 3]);
@@ -615,21 +615,21 @@ describe('AdvancedAnalyserNode', () => {
         const listener =  ({ detail }:CustomEvent<Uint8Array>) => {
           console.log(detail);
         };
-        node.removeEventListener(EventListenerTypes.bytefrequencydata, listener);
-        expect(removeEventListenerSpy).toHaveBeenLastCalledWith(EventListenerTypes.bytefrequencydata, listener, undefined);
+        node.removeEventListener('bytefrequencydata', listener);
+        expect(removeEventListenerSpy).toHaveBeenLastCalledWith('bytefrequencydata', listener, undefined);
       });
     });
-    describe(EventListenerTypes.timedomaindata, () => {
+    describe('timedomaindata', () => {
       it(`register event`, () => {
         const node = new AdvancedAnalyserNode(context, {
           fftSize: 1024,
         });
 
-        node.addEventListener(EventListenerTypes.timedomaindata, ({ detail }:CustomEvent<Float32Array>) => {
+        node.addEventListener('timedomaindata', ({ detail }:CustomEvent<Float32Array>) => {
           console.log(detail);
         });
 
-        expect(addEventListenerSpy.mock.calls[0][0]).toEqual(EventListenerTypes.timedomaindata);
+        expect(addEventListenerSpy.mock.calls[0][0]).toEqual('timedomaindata');
 
       });
 
@@ -638,7 +638,7 @@ describe('AdvancedAnalyserNode', () => {
           fftSize: 1024,
         });
 
-        node.addEventListener(EventListenerTypes.timedomaindata, ({ detail }:CustomEvent<Float32Array>) => {
+        node.addEventListener('timedomaindata', ({ detail }:CustomEvent<Float32Array>) => {
           console.log(detail);
         });
 
@@ -661,24 +661,24 @@ describe('AdvancedAnalyserNode', () => {
         const listener =  ({ detail }:CustomEvent<Float32Array>) => {
           console.log(detail);
         };
-        node.removeEventListener(EventListenerTypes.timedomaindata, listener);
-        expect(removeEventListenerSpy).toHaveBeenLastCalledWith(EventListenerTypes.timedomaindata, listener, undefined);
+        node.removeEventListener('timedomaindata', listener);
+        expect(removeEventListenerSpy).toHaveBeenLastCalledWith('timedomaindata', listener, undefined);
       });
     });
 
 
-    describe(EventListenerTypes.bytetimedomaindata, () => {
+    describe('bytetimedomaindata', () => {
       it('register event', () => {
         const node = new AdvancedAnalyserNode(context, {
           fftSize: 1024,
         });
 
         addEventListenerSpy.mockClear();
-        node.addEventListener(EventListenerTypes.bytetimedomaindata, ({ detail }) => {
+        node.addEventListener('bytetimedomaindata', ({ detail }) => {
           console.log(detail);
         });
 
-        expect(addEventListenerSpy.mock.calls[0][0]).toEqual(EventListenerTypes.bytetimedomaindata);
+        expect(addEventListenerSpy.mock.calls[0][0]).toEqual('bytetimedomaindata');
 
       });
 
@@ -688,7 +688,7 @@ describe('AdvancedAnalyserNode', () => {
         });
         dispatchEventSpy.mockClear();
         addEventListenerSpy.mockClear();
-        node.addEventListener(EventListenerTypes.bytetimedomaindata, ({ detail }) => {
+        node.addEventListener('bytetimedomaindata', ({ detail }) => {
           console.log(detail);
         });
         const payload = Uint8Array.from([0, 1, 2, 3]);
@@ -710,8 +710,8 @@ describe('AdvancedAnalyserNode', () => {
         const listener =  ({ detail }:CustomEvent<Uint8Array>) => {
           console.log(detail);
         };
-        node.removeEventListener(EventListenerTypes.bytetimedomaindata, listener);
-        expect(removeEventListenerSpy).toHaveBeenLastCalledWith(EventListenerTypes.bytetimedomaindata, listener, undefined);
+        node.removeEventListener('bytetimedomaindata', listener);
+        expect(removeEventListenerSpy).toHaveBeenLastCalledWith('bytetimedomaindata', listener, undefined);
       });
     });
   });