Adds documentation

Author: julia-script

.eslintrc.json

@@ -7,12 +7,14 @@
   "parser": "@typescript-eslint/parser",
   "parserOptions": { "project": ["./tsconfig.json"] },
   "plugins": [
-    "@typescript-eslint"
+    "@typescript-eslint",
+    "eslint-plugin-tsdoc"
   ],
   "rules": {
     "indent": ["error", 2, { "SwitchCase": 1 }],
     "semi": ["error", "always"],
-    "lines-between-class-members": ["error", "always"]
+    "lines-between-class-members": ["error", "always"],
+    "tsdoc/syntax": "warn"
   },
   "ignorePatterns": [
     "rollup.config.js",

.gitignore

@@ -1,3 +1,4 @@
 .DS_Store
 node_modules
-coverage
+coverage
+.vscode

.vscode/launch.json

@@ -7,7 +7,7 @@
       "console": "integratedTerminal",
       "internalConsoleOptions": "neverOpen",
       "disableOptimisticBPs": true,
-      "program": "${workspaceFolder}/jest",
+      "program": "${workspaceFolder}",
       "cwd": "${workspaceFolder}",
       "args": [
         "--runInBand",

README.md

@@ -1,17 +1,11 @@
-# Advanced Analyser Node
-
-Advanced Analyser Node aims to be an enhanced version of the native Analyser Node. Both Audio nodes provide real-time frequency and time-domain analysis information.
-
-## Why this exists?
-The native Analyser Node offers two primary features: Request frequency data (`.getFloatFrequencyData|.getByteFrequencyData`) and time-domain data (`.getFloatTimeDomainData|.getByteTimeDomainData`). The main problem is that the Analyser Node only gives you the data at the time of the request, meaning that when you request for the frequency data, the node will apply the Fast Fourier Transform to the last n audio samples (n is the fftSize property), or in the case of time-domain data, the last n audio samples.
+[![view on npm](https://badgen.net/npm/v/jsdoc-to-markdown)](https://www.npmjs.org/package/jsdoc-to-markdown)
 
-That's good enough if you are creating an audio visualization of the data currently being played, as the usual approach is to create a loop that requests and draws the data every frame (and if you're doing that, you should probably stick to the native Analyser Node as it will give you better performance).
+# Advanced Analyser Node
 
-The problem happens when you need to display the data **over time** (ex: Spectrograms, the waveform of the whole track). As the native Analyser Node gives you the data at the request time, it's impossible to guarantee that all requests will be evenly spaced in time. That means you will have inconsistent data overlaps or even skip some samples altogether. Depending on your goal, overlapping or skipping samples are not a problem per se; the issue is the inconsistency as the interval between samples will be completely based on your loop FPS.
+Advanced Analyser Node aims to be an enhanced version of the native Analyser Node. It provides real-time frequency and time-domain analysis information.
 
-The Advanced Analyser Node provides all the native version features (with a slightly different API), but also gives you the option of registering events that will be consistently triggered based on its configuration. For advanced users, you also have the option of choosing between different window functions.
 
-## Installation
+## Getting started
 
 Using npm:
 ```bash
@@ -22,7 +16,6 @@ Using yarn:
 yarn add --dev advanced-analyser-node
 ```
 
-
 ## Usage
 
 ```javascript
@@ -60,9 +53,18 @@ init();
 const data = await analyserNode.getByteFrequencyData() // Differently from the native implementation, the request methods are asynchronous, and do not take an array as parameter
 ```
 
-
 ## Documentation
+[You can find the documentation here](docs/DOC.md).
+
+
+## Why this exists?
+The native Analyser Node offers two primary features: Request frequency data (`.getFloatFrequencyData|.getByteFrequencyData`) and time-domain data (`.getFloatTimeDomainData|.getByteTimeDomainData`). The main problem is that the Analyser Node only gives you the data at the time of the request, meaning that when you request for the frequency data, the node will apply the Fast Fourier Transform to the last n audio samples (n is the fftSize property), or in the case of time-domain data, the last n audio samples.
 
+That's good enough if you are creating an audio visualization of the data currently being played, as the usual approach is to create a loop that requests and draws the data every frame (and if you're doing that, you should probably stick to the native Analyser Node as it will give you better performance).
+
+The problem happens when you need to display the data **over time** (ex: Spectrograms, the waveform of the whole track). As the native Analyser Node gives you the data at the request time, it's impossible to guarantee that all requests will be evenly spaced in time. That means you will have inconsistent data overlaps or even skip some samples altogether. Depending on your goal, overlapping or skipping samples are not a problem per se; the issue is the inconsistency as the interval between samples will be completely based on your loop FPS.
+
+The Advanced Analyser Node provides all the native version features (with a slightly different API), but also gives you the option of registering events that will be consistently triggered based on its configuration. For advanced users, you also have the option of choosing between different window functions.
 
 ## Caveats
 

demo/demo1.html

@@ -31,7 +31,7 @@
 
     const [floatFrequencyButton, byteFrequencyButton, floatTimeDomainButton, byteTimeDomainButton] = document.querySelectorAll('button')
 
-    const stream = await  navigator.mediaDevices.getUserMedia({
+    const stream = await navigator.mediaDevices.getUserMedia({
       audio: true,
       video: false
     })
@@ -44,6 +44,7 @@
     snapshotCanvas.width = 1024
 
     const context = new AudioContext({ sampleRate: SAMPLE_RATE })
+    
     const nativeAnalyserNode = context.createAnalyser()
     const audioSource = context.createMediaStreamSource(stream);
 

dist/bundle.js

@@ -0,0 +1,2 @@
+export * from './node';
+export { WindowFunctionTypes, AdvancedAnalyserNodeProperties, EventListenerTypes, } from './types';

dist/bundle.min.js

@@ -0,0 +1,92 @@
+import { AdvancedAnalyserNodeProperties, EventListenerTypes, Listener, WindowFunctionTypes } from "../types";
+/**
+ * The Audio Node class. Do not instantiate this class directly.
+ * Use the `createAdvancedAnalyserNode` method instead.
+ */
+export declare class AdvancedAnalyserNode extends AudioWorkletNode {
+    private _portMapId;
+    private _portMap;
+    private _fftSize;
+    private _samplesBetweenTransforms?;
+    private _timeDomainSamplesCount?;
+    private _windowFunction;
+    private _minDecibels;
+    private _maxDecibels;
+    private _smoothingTimeConstant;
+    readonly channelCount: number;
+    readonly numberOfInputs: number;
+    readonly numberOfOutputs: number;
+    readonly channelCountMode: ChannelCountMode;
+    readonly channelInterpretation: ChannelInterpretation;
+    /**
+     * The size of the FFT used for frequency-domain analysis (in sample-frames).
+     * This MUST be a power of two in the range 32 to 32768. The default value is 2048.
+     * Note that large FFT sizes can be costly to compute.
+     *
+     * @defaultValue 2048
+     */
+    get fftSize(): number;
+    set fftSize(value: number);
+    set samplesBetweenTransforms(value: number);
+    get samplesBetweenTransforms(): number;
+    get frequencyBinCount(): number;
+    set timeDomainSamplesCount(value: number);
+    get timeDomainSamplesCount(): number;
+    set windowFunction(value: WindowFunctionTypes);
+    get windowFunction(): WindowFunctionTypes;
+    /**
+     * Represents the minimum power value in the scaling range for the FFT analysis data,
+     * for conversion to unsigned byte values.
+     * Basically, this specifies the minimum value for the range of results when using `getByteFrequencyData()`
+     * or listening to the `bytefrequencydata` event, in which any frequencies with an amplitude of minDecibels
+     * or lower will be returned as 0.
+     *
+     * An exception will be thrown if set to more than or equal to maxDecibels.
+     * @defaultValue -100 dB
+     */
+    get minDecibels(): number;
+    set minDecibels(value: number);
+    /**
+     * Represents the maximum power value in the scaling range for the FFT analysis data,
+     * for conversion to unsigned byte values.
+     * Basically, this specifies the maximum value for the range of results when using `getByteFrequencyData()`
+     * or listening to the `bytefrequencydata` event, in which any frequencies with an amplitude of maxDecibels
+     * or higher will be returned as 255.
+     *
+     * An exception will be thrown if set to less than or equal to maxDecibels.
+     * @defaultValue -30 dB
+     */
+    get maxDecibels(): number;
+    set maxDecibels(value: number);
+    /**
+     * Represents the averaging constant with the last analysis frame.
+     * It's basically an average between the current buffer and the last buffer the AnalyserNode processed,
+     * and results in a much smoother set of value changes over time.
+     *
+     * @defaultValue 0. No averaging is applied.
+     */
+    get smoothingTimeConstant(): number;
+    set smoothingTimeConstant(value: number);
+    private _eventListenersCount;
+    /**
+     * The Audiio Node class. Do not instantiate this class directly.
+     * Use the `createAdvancedAnalyserNode` method, which registers this Worklet before instantiating it
+     */
+    constructor(context: BaseAudioContext, properties: AdvancedAnalyserNodeProperties);
+    private _uniqId;
+    private _postMessage;
+    onprocessorerror: (err: Event) => void;
+    private _onmessage;
+    private _updateProcessorOptions;
+    private _postIdentifiedDataRequest;
+    getFloatFrequencyData(): Promise<Float32Array>;
+    getByteFrequencyData(): Promise<Uint8Array>;
+    getFloatTimeDomainData(): Promise<Float32Array>;
+    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;
+    addEventListener(type: "processorerror", listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener(type: "processorerror" | EventListenerTypes, listener: EventListenerOrEventListenerObject | Listener<ArrayBuffer>, options?: boolean | EventListenerOptions): void;
+}