@eka-care/ekascribe-ts-sdk 1.4.39

package/dist/audio-chunker/audio-file-manager.js

@@ -0,0 +1,579 @@
+import { AUDIO_EXTENSION_TYPE_MAP, OUTPUT_FORMAT } from '../constants/constant';
+import pushFileToS3 from '../aws-services/upload-file-to-s3';
+import postCogInit from '../api/post-cog-init';
+import { configureAWS } from '../aws-services/configure-aws';
+import { SHARED_WORKER_ACTION } from '../constants/enums';
+import compressAudioToMp3 from '../utils/compress-mp3-audio';
+class AudioFileManager {
+    initialiseClassInstance() {
+        this.audioChunks = [];
+        this.uploadPromises = [];
+        this.successfulUploads = [];
+        this.totalInsertedFrames = 0;
+        this.totalInsertedSamples = 0;
+        this.totalRawSamples = 0;
+        this.totalRawFrames = 0;
+    }
+    constructor() {
+        /**
+         * Class that handles uploading audio files to S3
+         * and downloading audio files for debugging
+         */
+        Object.defineProperty(this, "txnID", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "filePath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "audioChunks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "uploadPromises", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "successfulUploads", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "onProgressCallback", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "totalRawSamples", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "totalRawFrames", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "totalInsertedSamples", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "totalInsertedFrames", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "businessID", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "isAWSConfigured", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "sharedWorkerInstance", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        this.initialiseClassInstance();
+    }
+    /**
+     * Set basic file information
+     */
+    setSessionInfo({ sessionId, filePath, businessID, }) {
+        this.txnID = sessionId;
+        this.filePath = filePath;
+        this.businessID = businessID;
+    }
+    getRawSampleDetails() {
+        return {
+            totalRawSamples: this.totalRawSamples,
+            totalRawFrames: this.totalRawFrames,
+        };
+    }
+    incrementTotalRawSamples(frames) {
+        this.totalRawSamples += frames.length;
+        this.totalRawFrames += 1;
+    }
+    incrementInsertedSamples(samples, frames) {
+        this.totalInsertedSamples += samples;
+        this.totalInsertedFrames += frames;
+    }
+    getInsertedSampleDetails() {
+        return {
+            totalInsertedSamples: this.totalInsertedSamples,
+            totalInsertedFrames: this.totalInsertedFrames,
+        };
+    }
+    /**
+     * Set callback for upload progress updates
+     */
+    setProgressCallback(callback) {
+        this.onProgressCallback = callback;
+    }
+    /**
+     * Update audio information array, this will update the audio chunks info
+     * (+ the latest chunk , affects the length of chunks data struct)
+     */
+    updateAudioInfo(audioChunks) {
+        this.audioChunks.push(audioChunks);
+        return this.audioChunks.length;
+    }
+    createSharedWorkerInstance() {
+        try {
+            // new URL(relativeOrAbsolutePath, baseUrl)
+            const worker = new SharedWorker(new URL('../shared-worker/s3-file-upload.js', import.meta.url));
+            this.sharedWorkerInstance = worker;
+            this.sharedWorkerInstance.port.onmessage = async (event) => {
+                const workerResponse = event.data;
+                switch (workerResponse.action) {
+                    case SHARED_WORKER_ACTION.CONFIGURE_AWS_SUCCESS: {
+                        console.log('AWS configured successfully in worker');
+                        return;
+                    }
+                    case SHARED_WORKER_ACTION.CONFIGURE_AWS_ERROR: {
+                        console.error('Error configuring AWS in worker:', workerResponse.error);
+                        return;
+                    }
+                    case SHARED_WORKER_ACTION.UPLOAD_FILE_WITH_WORKER_SUCCESS: {
+                        console.log('File uploaded successfully in worker:', workerResponse.response);
+                        const { fileCount: fileName, chunkIndex, fileBlob, compressedAudioBuffer, } = workerResponse.requestBody;
+                        if (this.onProgressCallback && compressedAudioBuffer) {
+                            this.onProgressCallback({
+                                success: this.successfulUploads.length,
+                                total: this.audioChunks.length,
+                                fileName,
+                                chunkData: compressedAudioBuffer,
+                            });
+                        }
+                        if (workerResponse.response.success) {
+                            this.successfulUploads.push(fileName);
+                            // remove audioFrames if file uploaded successfully
+                            if (chunkIndex !== -1) {
+                                this.audioChunks[chunkIndex] = {
+                                    ...this.audioChunks[chunkIndex],
+                                    audioFrames: undefined,
+                                    fileBlob: undefined,
+                                    status: 'success',
+                                    response: workerResponse.response.success,
+                                };
+                            }
+                            if (this.onProgressCallback) {
+                                this.onProgressCallback({
+                                    success: this.successfulUploads.length,
+                                    total: this.audioChunks.length,
+                                    is_uploaded: true,
+                                });
+                            }
+                        }
+                        else {
+                            if (this.onProgressCallback) {
+                                this.onProgressCallback({
+                                    success: this.successfulUploads.length,
+                                    total: this.audioChunks.length,
+                                    fileName,
+                                    is_uploaded: false,
+                                    error: {
+                                        code: workerResponse.response.code,
+                                        msg: 'Tokens expired.',
+                                    },
+                                });
+                            }
+                            // store that audioFrames in audioChunks
+                            if (chunkIndex !== -1) {
+                                this.audioChunks[chunkIndex] = {
+                                    ...this.audioChunks[chunkIndex],
+                                    fileBlob,
+                                    audioFrames: undefined,
+                                    status: 'failure',
+                                    response: workerResponse.response.error || 'Upload failed',
+                                };
+                            }
+                            // call COG if S3 throws ExpiredToken error
+                            if (workerResponse.response.errorCode === 'ExpiredToken') {
+                                this.setupAWSConfiguration({
+                                    is_shared_worker: true,
+                                });
+                            }
+                        }
+                    }
+                }
+            };
+            worker.port.start();
+            return true;
+        }
+        catch (error) {
+            console.error('Error creating shared worker instance:', error);
+            return false;
+        }
+    }
+    async setupAWSConfiguration({ is_shared_worker }) {
+        try {
+            const response = await postCogInit();
+            const { credentials, is_session_expired } = response;
+            if (is_session_expired || !credentials) {
+                this.isAWSConfigured = false;
+                return false;
+            }
+            const { AccessKeyId, SecretKey, SessionToken } = credentials;
+            if (is_shared_worker) {
+                this.sharedWorkerInstance?.port.postMessage({
+                    action: SHARED_WORKER_ACTION.CONFIGURE_AWS,
+                    payload: {
+                        accessKeyId: AccessKeyId,
+                        secretKey: SecretKey,
+                        sessionToken: SessionToken,
+                    },
+                });
+            }
+            else {
+                configureAWS({
+                    accessKeyId: AccessKeyId,
+                    secretKey: SecretKey,
+                    sessionToken: SessionToken,
+                });
+            }
+            this.isAWSConfigured = true;
+            return true;
+        }
+        catch (error) {
+            console.log('%c Line:198 🥃 error', 'color:#42b983', error);
+            this.isAWSConfigured = false;
+            return false;
+        }
+    }
+    /**
+     * Upload a chunk of audio data to S3 in main thread
+     */
+    async uploadAudioChunkInMain({ audioFrames, fileName, chunkIndex, }) {
+        const s3FileName = `${this.filePath}/${fileName}`; // fileName is ${fileCount}.mp3
+        const compressedAudioBuffer = compressAudioToMp3(audioFrames);
+        const audioBlob = new Blob(compressedAudioBuffer, {
+            type: AUDIO_EXTENSION_TYPE_MAP[OUTPUT_FORMAT],
+        });
+        if (this.onProgressCallback) {
+            this.onProgressCallback({
+                success: this.successfulUploads.length,
+                total: this.audioChunks.length,
+                fileName,
+                chunkData: compressedAudioBuffer,
+            });
+        }
+        // Push upload promise to track status
+        const uploadPromise = pushFileToS3({
+            fileBlob: audioBlob,
+            fileName: s3FileName,
+            txnID: this.txnID,
+            businessID: this.businessID,
+            is_shared_worker: false,
+        }).then((response) => {
+            if (response.success) {
+                this.successfulUploads.push(fileName);
+                // update file status if file uploaded successfully
+                if (chunkIndex !== -1) {
+                    this.audioChunks[chunkIndex] = {
+                        ...this.audioChunks[chunkIndex],
+                        audioFrames: undefined,
+                        fileBlob: undefined,
+                        status: 'success',
+                        response: response.success,
+                    };
+                }
+                if (this.onProgressCallback) {
+                    this.onProgressCallback({
+                        success: this.successfulUploads.length,
+                        total: this.audioChunks.length,
+                        is_uploaded: true,
+                    });
+                }
+            }
+            else {
+                if (chunkIndex !== -1) {
+                    this.audioChunks[chunkIndex] = {
+                        ...this.audioChunks[chunkIndex],
+                        fileBlob: audioBlob,
+                        audioFrames: undefined,
+                        status: 'failure',
+                        response: response.error || 'Upload failed',
+                    };
+                }
+                if (this.onProgressCallback) {
+                    this.onProgressCallback({
+                        success: this.successfulUploads.length,
+                        total: this.audioChunks.length,
+                        fileName,
+                        is_uploaded: false,
+                        error: {
+                            code: response.code || 500,
+                            msg: 'Tokens expired.',
+                        },
+                    });
+                }
+            }
+            return response;
+        });
+        this.uploadPromises.push(uploadPromise);
+        return {
+            success: true,
+            fileName,
+        };
+    }
+    /**
+     * Upload audio chunks to S3 in shared worker
+     */
+    async uploadAudioChunkInWorker({ audioFrames, fileName, chunkIndex, }) {
+        const s3FileName = `${this.filePath}/${fileName}`;
+        if (this.onProgressCallback) {
+            this.onProgressCallback({
+                success: this.successfulUploads.length,
+                total: this.audioChunks.length,
+            });
+        }
+        this.sharedWorkerInstance?.port.postMessage({
+            action: SHARED_WORKER_ACTION.UPLOAD_FILE_WITH_WORKER,
+            payload: {
+                audioFrames,
+                fileName: s3FileName,
+                txnID: this.txnID,
+                businessID: this.businessID,
+                chunkIndex,
+                fileCount: fileName,
+            },
+        });
+        return {
+            success: true,
+            fileName,
+        };
+    }
+    async uploadAudioToS3({ audioFrames, fileName, chunkIndex }) {
+        if (typeof SharedWorker === 'undefined' || !SharedWorker) {
+            // Shared Workers are not supported in this browser
+            console.log('Shared Workers are NOT supported in this browser.');
+            await this.uploadAudioToS3WithoutWorker({ audioFrames, fileName, chunkIndex });
+        }
+        else {
+            // Shared Workers are supported
+            console.log('Shared Workers are supported in this browser.');
+            if (!this.sharedWorkerInstance) {
+                this.createSharedWorkerInstance();
+            }
+            await this.uploadAudioToS3WithWorker({ audioFrames, fileName, chunkIndex });
+        }
+    }
+    async uploadAudioToS3WithWorker({ audioFrames, fileName, chunkIndex, }) {
+        try {
+            if (!this.isAWSConfigured) {
+                const awsConfigResponse = await this.setupAWSConfiguration({
+                    is_shared_worker: true,
+                });
+                if (!awsConfigResponse) {
+                    throw new Error('Failed to configure AWS');
+                }
+            }
+            await this.uploadAudioChunkInWorker({ audioFrames, fileName, chunkIndex });
+        }
+        catch (error) {
+            console.error('Error uploading audio to S3: uploadAudioToS3WithWorker: ', error);
+        }
+    }
+    async uploadAudioToS3WithoutWorker({ audioFrames, fileName, chunkIndex, }) {
+        try {
+            if (!this.isAWSConfigured) {
+                const awsConfigResponse = await this.setupAWSConfiguration({
+                    is_shared_worker: false,
+                });
+                if (!awsConfigResponse) {
+                    throw new Error('Failed to configure AWS');
+                }
+            }
+            await this.uploadAudioChunkInMain({ audioFrames, fileName, chunkIndex });
+        }
+        catch (error) {
+            console.error('Error uploading audio to S3:', error);
+        }
+    }
+    /**
+     * Download audio as a file to the user's device (for debugging)
+     */
+    downloadAudio(audioBlob, fileName) {
+        const url = URL.createObjectURL(audioBlob);
+        const a = document.createElement('a');
+        a.style.display = 'none';
+        a.href = url;
+        a.download = fileName;
+        document.body.appendChild(a);
+        a.click();
+        URL.revokeObjectURL(url);
+        document.body.removeChild(a);
+    }
+    /**
+     * Wait for all upload promises to complete
+     */
+    async waitForAllUploads() {
+        if (this.sharedWorkerInstance) {
+            return new Promise((resolve, reject) => {
+                // one-time message handler to listen for the response
+                const messageHandler = (event) => {
+                    if (event.data.action === SHARED_WORKER_ACTION.WAIT_FOR_ALL_UPLOADS_SUCCESS) {
+                        this.sharedWorkerInstance?.port.removeEventListener('message', messageHandler);
+                        resolve();
+                    }
+                    else if (event.data.action === SHARED_WORKER_ACTION.WAIT_FOR_ALL_UPLOADS_ERROR) {
+                        const { uploadRequestReceived } = event.data.response || {};
+                        if (uploadRequestReceived === 0) {
+                            this.sharedWorkerInstance?.port.removeEventListener('message', messageHandler);
+                            reject();
+                        }
+                        this.sharedWorkerInstance?.port.postMessage({
+                            action: SHARED_WORKER_ACTION.WAIT_FOR_ALL_UPLOADS,
+                        });
+                    }
+                };
+                // one-time listener
+                this.sharedWorkerInstance?.port.addEventListener('message', messageHandler);
+                this.sharedWorkerInstance?.port.postMessage({
+                    action: SHARED_WORKER_ACTION.WAIT_FOR_ALL_UPLOADS,
+                });
+            });
+        }
+        else {
+            await Promise.allSettled(this.uploadPromises);
+        }
+    }
+    /**
+     * Get list of successfully uploaded files
+     */
+    getSuccessfulUploads() {
+        return [...this.successfulUploads];
+    }
+    /**
+     * Get list of all failed files
+     */
+    getFailedUploads() {
+        const failedUploads = [];
+        this.audioChunks.forEach((chunk) => {
+            if (chunk.status != 'success') {
+                failedUploads.push(chunk.fileName);
+            }
+        });
+        return failedUploads;
+    }
+    /**
+     * Get list of all audio chunks
+     */
+    getTotalAudioChunks() {
+        return this.audioChunks;
+    }
+    /**
+     * Retry uploading failed files
+     */
+    async retryFailedUploads() {
+        const failedFiles = this.getFailedUploads();
+        if (failedFiles.length === 0) {
+            return [];
+        }
+        if (this.sharedWorkerInstance) {
+            this.audioChunks.forEach((chunk, index) => {
+                const { fileName, fileBlob, status, audioFrames } = chunk;
+                if (status != 'success') {
+                    this.sharedWorkerInstance?.port.postMessage({
+                        action: SHARED_WORKER_ACTION.UPLOAD_FILE_WITH_WORKER,
+                        payload: {
+                            audioFrames,
+                            fileBlob,
+                            fileName: `${this.filePath}/${fileName}`,
+                            txnID: this.txnID,
+                            businessID: this.businessID,
+                            chunkIndex: index,
+                            fileCount: fileName,
+                        },
+                    });
+                }
+            });
+        }
+        else {
+            this.uploadPromises = []; // Reset upload promises for retries
+            if (this.onProgressCallback) {
+                this.onProgressCallback({
+                    success: this.successfulUploads.length,
+                    total: this.audioChunks.length,
+                });
+            }
+            this.audioChunks.forEach((chunk, index) => {
+                const { fileName, fileBlob, status, audioFrames } = chunk;
+                if (status != 'success') {
+                    let failedFileBlob;
+                    if (status === 'failure') {
+                        failedFileBlob = fileBlob;
+                    }
+                    if (status === 'pending') {
+                        const compressedAudioBuffer = compressAudioToMp3(audioFrames);
+                        failedFileBlob = new Blob(compressedAudioBuffer, {
+                            type: AUDIO_EXTENSION_TYPE_MAP[OUTPUT_FORMAT],
+                        });
+                    }
+                    if (failedFileBlob) {
+                        const uploadPromise = pushFileToS3({
+                            fileBlob: failedFileBlob,
+                            fileName: `${this.filePath}/${fileName}`,
+                            txnID: this.txnID,
+                            businessID: this.businessID,
+                            is_shared_worker: false,
+                        }).then((response) => {
+                            if (response.success) {
+                                this.successfulUploads.push(fileName);
+                                if (this.onProgressCallback) {
+                                    this.onProgressCallback({
+                                        success: this.successfulUploads.length,
+                                        total: this.audioChunks.length,
+                                    });
+                                }
+                                this.audioChunks[index] = {
+                                    ...this.audioChunks[index],
+                                    audioFrames: undefined,
+                                    fileBlob: undefined,
+                                    status: 'success',
+                                    response: response.success,
+                                };
+                            }
+                            return response;
+                        });
+                        this.uploadPromises.push(uploadPromise);
+                    }
+                }
+            });
+        }
+        // Wait for all retry promises to complete
+        await this.waitForAllUploads();
+        return this.getFailedUploads();
+    }
+    /**
+     * Reset the upload state
+     */
+    resetFileManagerInstance() {
+        this.initialiseClassInstance();
+    }
+}
+export default AudioFileManager;

package/dist/audio-chunker/vad-web.d.ts

@@ -0,0 +1,90 @@
+import { MicVAD } from '@ricky0123/vad-web';
+declare class VadWebClient {
+    private vad_past;
+    private last_clip_index;
+    private clip_points;
+    private sil_duration_acc;
+    private pref_length_samples;
+    private desp_length_samples;
+    private max_length_samples;
+    private shor_thsld;
+    private long_thsld;
+    private frame_size;
+    private speech_pad_frames;
+    private micVad;
+    private is_vad_loading;
+    private noSpeechStartTime;
+    private recording_started;
+    private lastWarningTime;
+    private warningCooldownPeriod;
+    /**
+     * Class that handle Vad functions and manages audio chunk
+     * @param pref_length Preferred length in seconds
+     * @param desp_length Desperate length in seconds
+     * @param max_length Maximum length in seconds
+     * @param sr Sample rate in Hz
+     */
+    constructor(pref_length: number, desp_length: number, max_length: number, sr: number);
+    /**
+     * Check for continuous silence and trigger periodic warnings
+     * @param isSpeech - vad probability (0 or 1)
+     */
+    checkNoSpeech(isSpeech: number): void;
+    /**
+     * Get the micVad instance
+     */
+    getMicVad(): MicVAD;
+    /**
+     * Check if VAD is loading
+     */
+    isVadLoading(): boolean;
+    /**
+     * Process a VAD frame and determine if it's a clip point
+     * @param vad_frame Voice activity detection frame (0 for silence, 1 for speech)
+     */
+    processVadFrame(vad_frame: number): [boolean, number];
+    /**
+     * initialize the VAD instance
+     */
+    initVad(): Promise<boolean>;
+    /**
+     * reinitialize the vad instance
+     */
+    reinitializeVad(): Promise<boolean>;
+    /**
+     * process and upload audio chunk to s3
+     */
+    processAudioChunk({ audioFrames }: {
+        audioFrames?: Float32Array;
+    }): Promise<void>;
+    /**
+     * Start VAD
+     */
+    startVad(): void;
+    /**
+     * Pause VAD
+     */
+    pauseVad(): void;
+    /**
+     * reset vadWeb instance
+     */
+    resetVadWebInstance(): void;
+    /**
+     * monitor initial audio capture within starting 4 seconds
+     */
+    monitorAudioCapture(): void;
+    /**
+     * Callback to configure constants
+     */
+    configureVadConstants({ pref_length, desp_length, max_length, sr, frame_size, pre_speech_pad_frames, short_thsld, long_thsld, }: {
+        pref_length: number;
+        desp_length: number;
+        max_length: number;
+        sr: number;
+        frame_size: number;
+        pre_speech_pad_frames: number;
+        short_thsld: number;
+        long_thsld: number;
+    }): void;
+}
+export default VadWebClient;