fix(ts) adjust syntax so TSC doesn't complain

Emitting declarations generated these errors:

~~~~
modules/transcription/audioRecorder.js:3:1 - error TS9005: Declaration emit for this file requires using private name 'TrackRecorder'. An explicit type annotation may unblock declaration emit.

3 const RecordingResult = require('./recordingResult');
  ~~~~~

modules/transcription/recordingResult.js:13:1 - error TS9005: Declaration emit for this file requires using private name 'RecordingResult'. An explicit type annotation may unblock declaration emit.

13 const RecordingResult = function(blob, name, startTime, wordArray) {
   ~~~~~

modules/transcription/transcriber.js:1:1 - error TS9006: Declaration emit for this file requires using private name 'SphinxService' from module '"/Users/saghul/work/jitsi/lib-jitsi-meet/modules/transcription/transcriptionServices/SphinxTranscriptionService"'. An explicit type annotation may unblock declaration emit.

1 const AudioRecorder = require('./audioRecorder');
  ~~~~~

modules/transcription/word.js:7:1 - error TS9005: Declaration emit for this file requires using private name 'Word'. An explicit type annotation may unblock declaration emit.

7 const Word = function(word, begin, end) {
  ~~~~~

Found 4 errors.
~~~~

modules/transcription/audioRecorder.js

@@ -1,4 +1,5 @@
-const RecordingResult = require('./recordingResult');
+import RecordingResult from './recordingResult';
+import TrackRecorder from './trackRecorder';
 
 /**
  * Possible audio formats MIME types
@@ -6,30 +7,6 @@ const RecordingResult = require('./recordingResult');
 const AUDIO_WEBM = 'audio/webm'; // Supported in chrome
 const AUDIO_OGG = 'audio/ogg'; // Supported in firefox
 
-/**
- * A TrackRecorder object holds all the information needed for recording a
- * single JitsiTrack (either remote or local)
- * @param track The JitsiTrack the object is going to hold
- */
-const TrackRecorder = function(track) {
-    // The JitsiTrack holding the stream
-    this.track = track;
-
-    // The MediaRecorder recording the stream
-    this.recorder = null;
-
-    // The array of data chunks recorded from the stream
-    // acts as a buffer until the data is stored on disk
-    this.data = null;
-
-    // the name of the person of the JitsiTrack. This can be undefined and/or
-    // not unique
-    this.name = null;
-
-    // the time of the start of the recording
-    this.startTime = null;
-};
-
 /**
  * Starts the recording of a JitsiTrack in a TrackRecorder object.
  * This will also define the timestamp and try to update the name
@@ -301,4 +278,4 @@ AudioRecorder.prototype.getFileType = function() {
 /**
  * export the main object AudioRecorder
  */
-module.exports = AudioRecorder;
+export default AudioRecorder;

modules/transcription/recordingResult.js

@@ -4,19 +4,18 @@
  * This object stores variables needed around the recording of an audio stream
  * and passing this recording along with additional information along to
  * different processes
- * @param blob the recording audio stream as a single blob
- * @param name the name of the person of the audio stream
- * @param startTime the time in UTC when recording of the audiostream started
- * @param wordArray the recorder audio stream transcribed as an array of Word
- *                  objects
  */
-const RecordingResult = function(blob, name, startTime, wordArray) {
-    this.blob = blob;
-    this.name = name;
-    this.startTime = startTime;
-    this.wordArray = wordArray;
-};
-
-/* eslint-enable max-params */
-
-module.exports = RecordingResult;
+export default class RecordingResult {
+    /**
+     * @param blob the recording audio stream as a single blob
+     * @param name the name of the person of the audio stream
+     * @param startTime the time in UTC when recording of the audiostream started
+     * @param wordArray the recorder audio stream transcribed as an array of Word objects
+     */
+    constructor(blob, name, startTime, wordArray) {
+        this.blob = blob;
+        this.name = name;
+        this.startTime = startTime;
+        this.wordArray = wordArray;
+    }
+}

modules/transcription/trackRecorder.js

@@ -0,0 +1,28 @@
+/**
+ * A TrackRecorder object holds all the information needed for recording a
+ * single JitsiTrack (either remote or local)
+ * @param track The JitsiTrack the object is going to hold
+ */
+export default class TrackRecorder {
+    /**
+     * @param track The JitsiTrack the object is going to hold
+     */
+    constructor(track) {
+        // The JitsiTrack holding the stream
+        this.track = track;
+
+        // The MediaRecorder recording the stream
+        this.recorder = null;
+
+        // The array of data chunks recorded from the stream
+        // acts as a buffer until the data is stored on disk
+        this.data = null;
+
+        // the name of the person of the JitsiTrack. This can be undefined and/or
+        // not unique
+        this.name = null;
+
+        // the time of the start of the recording
+        this.startTime = null;
+    }
+}

modules/transcription/transcriber.js

@@ -1,6 +1,5 @@
-const AudioRecorder = require('./audioRecorder');
-const SphinxService = require(
-    './transcriptionServices/SphinxTranscriptionService');
+import AudioRecorder from './audioRecorder';
+import SphinxService from './transcriptionServices/SphinxTranscriptionService';
 
 const BEFORE_STATE = 'before';
 const RECORDING_STATE = 'recording';
@@ -357,4 +356,4 @@ Transcriber.prototype.reset = function() {
     this.lineLength = 0;
 };
 
-module.exports = Transcriber;
+export default Transcriber;

modules/transcription/transcriptionServices/AbstractTranscriptionService.js

@@ -2,75 +2,75 @@
  * Abstract class representing an interface to implement a speech-to-text
  * service on.
  */
-const TranscriptionService = function() {
-    throw new Error('TranscriptionService is abstract and cannot be'
-        + 'created');
-};
+export default class TranscriptionService {
+    /**
+     * Abstract class representing an interface to implement a speech-to-text
+     * service on.
+     */
+    constructor() {
+        throw new Error('TranscriptionService is abstract and cannot be created');
+    }
 
-/**
- * This method can be used to send the recorder audio stream and
- * retrieve the answer from the transcription service from the callback
- *
- * @param {RecordingResult} recordingResult a recordingResult object which
- * includes the recorded audio stream as a blob
- * @param {Function} callback  which will retrieve the a RecordingResult with
- *        the answer as a WordArray
- */
-TranscriptionService.prototype.send = function send(recordingResult, callback) {
-    this.sendRequest(recordingResult.blob, response => {
-        if (this.verify(response)) {
-            recordingResult.wordArray = this.formatResponse(response);
-        } else {
-            console.log('the retrieved response from the server is not valid!');
-            recordingResult.wordArray = [];
-        }
-        callback(recordingResult);
-    });
-};
+    /**
+     * This method can be used to send the recorder audio stream and
+     * retrieve the answer from the transcription service from the callback
+     *
+     * @param {RecordingResult} recordingResult a recordingResult object which
+     * includes the recorded audio stream as a blob
+     * @param {Function} callback  which will retrieve the a RecordingResult with
+     *        the answer as a WordArray
+     */
+    send(recordingResult, callback) {
+        this.sendRequest(recordingResult.blob, response => {
+            if (this.verify(response)) {
+                recordingResult.wordArray = this.formatResponse(response);
+            } else {
+                console.log('the retrieved response from the server is not valid!');
+                recordingResult.wordArray = [];
+            }
+            callback(recordingResult);
+        });
+    }
 
-/**
- * Abstract method which will rend the recorder audio stream to the implemented
- * transcription service and will retrieve an answer, which will be
- * called on the given callback method
- *
- * @param {Blob} audioBlob the recorded audio stream as a single Blob
- * @param {function} callback function which will retrieve the answer
- *                            from the service
- */
-// eslint-disable-next-line no-unused-vars
-TranscriptionService.prototype.sendRequest = function(audioBlob, callback) {
-    throw new Error('TranscriptionService.sendRequest is abstract');
-};
+    /**
+     * Abstract method which will rend the recorder audio stream to the implemented
+     * transcription service and will retrieve an answer, which will be
+     * called on the given callback method
+     *
+     * @param {Blob} audioBlob the recorded audio stream as a single Blob
+     * @param {function} callback function which will retrieve the answer
+     *                            from the service
+     */
+    sendRequest(audioBlob, callback) { // eslint-disable-line no-unused-vars
+        throw new Error('TranscriptionService.sendRequest is abstract');
+    }
 
-/**
- * Abstract method which will parse the output from the implemented
- * transcription service to the expected format
- *
- * The transcriber class expect an array of word objects, where each word
- * object is one transcribed word by the service.
- *
- * The expected output of this method is an array of word objects, in
- * the correct order. That is, the first object in the array is the first word
- * being said, and the last word in the array is the last word being said
- *
- * @param response the answer from the speech-to-text server which needs to be
- *                 formatted
- * @return {Array<Word>} an array of Word objects
- */
-// eslint-disable-next-line no-unused-vars
-TranscriptionService.prototype.formatResponse = function(response) {
-    throw new Error('TranscriptionService.format is abstract');
-};
-
-/**
- * Abstract method which will verify that the response from the server is valid
- *
- * @param response the response from the server
- * @return {boolean} true if response is valid, false otherwise
- */
-// eslint-disable-next-line no-unused-vars
-TranscriptionService.prototype.verify = function(response) {
-    throw new Error('TranscriptionService.verify is abstract');
-};
+    /**
+     * Abstract method which will parse the output from the implemented
+     * transcription service to the expected format
+     *
+     * The transcriber class expect an array of word objects, where each word
+     * object is one transcribed word by the service.
+     *
+     * The expected output of this method is an array of word objects, in
+     * the correct order. That is, the first object in the array is the first word
+     * being said, and the last word in the array is the last word being said
+     *
+     * @param response the answer from the speech-to-text server which needs to be
+     *                 formatted
+     * @return {Array<Word>} an array of Word objects
+     */
+    formatResponse(response) { // eslint-disable-line no-unused-vars
+        throw new Error('TranscriptionService.format is abstract');
+    }
 
-module.exports = TranscriptionService;
+    /**
+     * Abstract method which will verify that the response from the server is valid
+     *
+     * @param response the response from the server
+     * @return {boolean} true if response is valid, false otherwise
+     */
+    verify(response) { // eslint-disable-line no-unused-vars
+        throw new Error('TranscriptionService.verify is abstract');
+    }
+}

modules/transcription/transcriptionServices/SphinxTranscriptionService.js

@@ -1,121 +1,115 @@
 /* global config */
 
-const Word = require('../word');
+import Word from '../word';
 
-const audioRecorder = require('./../audioRecorder');
-const TranscriptionService = require('./AbstractTranscriptionService');
+import audioRecorder from './../audioRecorder';
+import AbstractTranscriptionService from './AbstractTranscriptionService';
 
 /**
  * Implements a TranscriptionService for a Sphinx4 http server
  */
-const SphinxService = function() {
-    // set the correct url
-    this.url = getURL();
-};
-
-/**
- * Subclass of AbstractTranscriptionService
- */
-SphinxService.prototype = Object.create(TranscriptionService.prototype);
-
-/**
- * Set the right constructor
- */
-SphinxService.constructor = SphinxService;
-
-/**
- * Overrides the sendRequest method from AbstractTranscriptionService
- * it will send the audio stream the a Sphinx4 server to get the transcription
- *
- * @param audioFileBlob the recorder audio stream an a single Blob
- * @param callback the callback function retrieving the server response
- */
-SphinxService.prototype.sendRequest = function(audioFileBlob, callback) {
-    console.log(`sending an audio file  to ${this.url}`);
-    console.log(`the audio file being sent: ${audioFileBlob}`);
-    const request = new XMLHttpRequest();
-
-    request.onreadystatechange = function() {
-        if (request.readyState === XMLHttpRequest.DONE
-            && request.status === 200) {
-            callback(request.responseText);
-        } else if (request.readyState === XMLHttpRequest.DONE) {
-            throw new Error(
-                `unable to accept response from sphinx server. status: ${
-                    request.status}`);
-        }
-
-        // if not ready no point to throw an error
-    };
-    request.open('POST', this.url);
-    request.setRequestHeader('Content-Type',
-        audioRecorder.determineCorrectFileType());
-    request.send(audioFileBlob);
-    console.log(`send ${audioFileBlob}`);
-};
-
-/**
- * Overrides the formatResponse method from AbstractTranscriptionService
- * It will parse the answer from the server in the expected format
- *
- * @param response the JSON body retrieved from the Sphinx4 server
- */
-SphinxService.prototype.formatResponse = function(response) {
-    const result = JSON.parse(response).objects;
-
-    // make sure to delete the session id object, which is always
-    // the first value in the JSON array
+export default class SphinxService extends AbstractTranscriptionService {
+    /**
+     * Implements a TranscriptionService for a Sphinx4 http server
+     */
+    constructor() {
+        super();
+
+        // set the correct url
+        this.url = getURL();
+    }
 
-    result.shift();
-    const array = [];
+    /**
+     * Overrides the sendRequest method from AbstractTranscriptionService
+     * it will send the audio stream the a Sphinx4 server to get the transcription
+     *
+     * @param audioFileBlob the recorder audio stream an a single Blob
+     * @param callback the callback function retrieving the server response
+     */
+    sendRequest(audioFileBlob, callback) {
+        console.log(`sending an audio file  to ${this.url}`);
+        console.log(`the audio file being sent: ${audioFileBlob}`);
+        const request = new XMLHttpRequest();
+
+        request.onreadystatechange = function() {
+            if (request.readyState === XMLHttpRequest.DONE
+                && request.status === 200) {
+                callback(request.responseText);
+            } else if (request.readyState === XMLHttpRequest.DONE) {
+                throw new Error(
+                    `unable to accept response from sphinx server. status: ${request.status}`);
+            }
+
+            // if not ready no point to throw an error
+        };
+        request.open('POST', this.url);
+        request.setRequestHeader('Content-Type',
+            audioRecorder.determineCorrectFileType());
+        request.send(audioFileBlob);
+        console.log(`send ${audioFileBlob}`);
+    }
 
-    result.forEach(
-        word =>
-            word.filler
+    /**
+     * Overrides the formatResponse method from AbstractTranscriptionService
+     * It will parse the answer from the server in the expected format
+     *
+     * @param response the JSON body retrieved from the Sphinx4 server
+     */
+    formatResponse(response) {
+        const result = JSON.parse(response).objects;
+
+        // make sure to delete the session id object, which is always
+        // the first value in the JSON array
+        result.shift();
+        const array = [];
+
+        result.forEach(
+            word => word.filler
                 || array.push(new Word(word.word, word.start, word.end)));
 
-    return array;
-};
+        return array;
+    }
 
-/**
- * checks wether the reply is empty, or doesn't contain a correct JSON object
- * @param response the server response
- * @return {boolean} whether the response is valid
- */
-SphinxService.prototype.verify = function(response) {
-    console.log(`response from server:${response.toString()}`);
+    /**
+     * checks wether the reply is empty, or doesn't contain a correct JSON object
+     * @param response the server response
+     * @return {boolean} whether the response is valid
+     */
+    verify(response) {
+        console.log(`response from server:${response.toString()}`);
+
+        // test if server responded with a string object
+        if (typeof response !== 'string') {
+            return false;
+        }
 
-    // test if server responded with a string object
-    if (typeof response !== 'string') {
-        return false;
-    }
+        // test if the string can be parsed into valid JSON
+        let json;
 
-    // test if the string can be parsed into valid JSON
-    let json;
+        try {
+            json = JSON.parse(response);
+        } catch (error) {
+            console.log(error);
 
-    try {
-        json = JSON.parse(response);
-    } catch (error) {
-        console.log(error);
+            return false;
+        }
 
-        return false;
-    }
+        // check if the JSON has a "objects" value
+        if (json.objects === undefined) {
+            return false;
+        }
 
-    // check if the JSON has a "objects" value
-    if (json.objects === undefined) {
-        return false;
-    }
+        // get the "objects" value and check for a session ID
+        const array = json.objects;
 
-    // get the "objects" value and check for a session ID
-    const array = json.objects;
+        if (!(array[0] && array[0]['session-id'])) {
+            return false;
+        }
 
-    if (!(array[0] && array[0]['session-id'])) {
-        return false;
+        // everything seems to be in order
+        return true;
     }
-
-    // everything seems to be in order
-    return true;
-};
+}
 
 /**
  * Gets the URL to the Sphinx4 server from the config file. If it's not there,
@@ -138,5 +132,3 @@ function getURL() {
 
     }
 }
-
-module.exports = SphinxService;

modules/transcription/word.js

@@ -4,34 +4,39 @@
  * @param begin the time the word was started being uttered
  * @param end the time the word stopped being uttered
  */
-const Word = function(word, begin, end) {
-    this.word = word;
-    this.begin = begin;
-    this.end = end;
-};
+export default class Word {
+    /**
+     * @param word the word
+     * @param begin the time the word was started being uttered
+     * @param end the time the word stopped being uttered
+     */
+    constructor(word, begin, end) {
+        this.word = word;
+        this.begin = begin;
+        this.end = end;
+    }
 
-/**
- * Get the string representation of the word
- * @returns {*} the word as a string
- */
-Word.prototype.getWord = function() {
-    return this.word;
-};
+    /**
+     * Get the string representation of the word
+     * @returns {*} the word as a string
+     */
+    getWord() {
+        return this.word;
+    }
 
-/**
- * Get the time the word started being uttered
- * @returns {*} the start time as an integer
- */
-Word.prototype.getBeginTime = function() {
-    return this.begin;
-};
-
-/**
- * Get the time the word stopped being uttered
- * @returns {*} the end time as an integer
- */
-Word.prototype.getEndTime = function() {
-    return this.end;
-};
+    /**
+     * Get the time the word started being uttered
+     * @returns {*} the start time as an integer
+     */
+    getBeginTime() {
+        return this.begin;
+    }
 
-module.exports = Word;
+    /**
+     * Get the time the word stopped being uttered
+     * @returns {*} the end time as an integer
+     */
+    getEndTime() {
+        return this.end;
+    }
+}