fix comments and docs

react/features/local-recording/recording/WavAdapter.js

  * using big endianness. Required by WAVE headers.
  *
  * @param {ArrayBuffer} view - The view to memory.
- * @param {*} offset - Offset.
- * @param {*} string - The string to be written.
+ * @param {number} offset - Offset.
+ * @param {string} string - The string to be written.
  * @returns {void}
  */
 function writeUTFBytes(view, offset, string) {
 /**
  * Helper function for converting Float32Array to Int16Array.
  *
- * @param {*} output - The output buffer.
- * @param {*} offset - The offset in output buffer to write from.
- * @param {*} inputBuffers - The input buffers.
+ * @param {DataView} output - View to the output buffer.
+ * @param {number} offset - The offset in output buffer to write from.
+ * @param {Float32Array[]} inputBuffers - The input buffers.
  * @returns {void}
  */
 function floatTo16BitPCM(output, offset, inputBuffers) {

react/features/local-recording/recording/flac/FlacAdapter.js

 export class FlacAdapter extends AbstractAudioContextAdapter {
 
     /**
-     * Instance of flacEncodeWorker.
+     * Instance of WebWorker (flacEncodeWorker).
      */
     _encoder = null;
 
     /**
-     * Resolve function of the promise returned by {@code stop()}.
+     * Resolve function of the Promise returned by {@code stop()}.
      * This is called after the WebWorker sends back {@code WORKER_BLOB_READY}.
      */
     _stopPromiseResolver = null;
 
-    _initPromiseResolver = null;
+    /**
+     * Resolve function of the Promise that initializes the flacEncodeWorker.
+     */
+    _initWorkerPromiseResolver = null;
 
     /**
      * Initialization promise.
                 reject();
             }
 
-            // save the Promise's resolver to resolve it later.
-            this._initPromiseResolver = resolve;
+            // Save the Promise's resolver to resolve it later.
+            // This Promise is only resolved in _onWorkerMessage when we
+            // receive WORKER_LIBFLAC_READY from the WebWorker.
+            this._initWorkerPromiseResolver = resolve;
 
             // set up listener for messages from the WebWorker
             this._encoder.onmessage = this._onWorkerMessage;
             break;
         case WORKER_LIBFLAC_READY:
             logger.log('libflac is ready.');
-            this._initPromiseResolver();
+            this._initWorkerPromiseResolver();
             break;
         default:
             logger.error(

react/features/local-recording/recording/flac/flacEncodeWorker.js

 /**
  * Concat multiple Uint8Arrays into one.
  *
- * @param {Array} arrays - Array of Uint8 arrays.
- * @param {*} totalLength - Total length of all Uint8Arrays.
+ * @param {Uint8Array[]} arrays - Array of Uint8 arrays.
+ * @param {number} totalLength - Total length of all Uint8Arrays.
  * @returns {Uint8Array}
  */
 function mergeUint8Arrays(arrays, totalLength) {
      * This is invoked by libflac.
      *
      * @private
-     * @param {*} buffer - The encoded Flac data.
-     * @param {*} bytes - Number of bytes in the data.
+     * @param {Uint8Array} buffer - The encoded Flac data.
+     * @param {number} bytes - Number of bytes in the data.
      * @returns {void}
      */
     _onEncodedData(buffer, bytes) {

react/features/local-recording/session/SessionManager.js

 
 // Have to use string literal here, instead of Symbols,
 // because these values need to be JSON-serializible.
+
+/**
+ * Types of SessionEvents.
+ */
 const SessionEventType = Object.freeze({
+    /**
+     * Start of local recording session. This is recorded when the
+     * {@code RecordingController} receives the signal to start local recording,
+     * before the actual adapter is engaged.
+     */
     SESSION_STARTED: 'SESSION_STARTED',
+
+    /**
+     * Start of a continuous segment. This is recorded when the adapter is
+     * engaged. Can happen multiple times in a local recording session,
+     * due to browser reloads or switching of recording device.
+     */
     SEGMENT_STARTED: 'SEGMENT_STARTED',
+
+    /**
+     * End of a continuous segment. This is recorded when the adapter unengages.
+     */
     SEGMENT_ENDED: 'SEGMENT_ENDED'
 });
 
     /**
      * Creates a session if not exists.
      *
-     * @param {string} sessionToken - .
-     * @param {string} format - .
+     * @param {string} sessionToken - The local recording session token.
+     * @param {string} format - The local recording format.
      * @returns {void}
      */
     createSession(sessionToken: string, format: string) {
     /**
      * Removes session metadata.
      *
-     * @param {*} sessionToken - The session token.
+     * @param {string} sessionToken - The session token.
      * @returns {void}
      */
     removeSession(sessionToken: string) {
      * {@code SessionEvent}s.
      *
      * @private
-     * @param {*} events - The array of {@code SessionEvent}s.
+     * @param {SessionEvent[]} events - The array of {@code SessionEvent}s.
      * @returns {SegmentInfo[]}
      */
     _constructSegments(events: SessionEvent[]): SegmentInfo[] {
  */
 export const sessionManager = new SessionManager();
 
-// For debug only. Remove later.
+// For debug only. To remove later.
 window.sessionManager = sessionManager;