@eka-care/ekascribe-ts-sdk 1.5.87 → 1.5.89

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

@@ -1,12 +1,23 @@
-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 { CALLBACK_TYPE, SHARED_WORKER_ACTION } from '../constants/enums';
-import compressAudioToMp3 from '../utils/compress-mp3-audio';
-import EkaScribeStore from '../store/store';
-import { GET_S3_BUCKET_NAME } from '../fetch-client/helper';
-import { getSharedWorkerUrl } from '../utils/get-worker-url';
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const constant_1 = require("../constants/constant");
+const upload_file_to_s3_1 = require("../aws-services/upload-file-to-s3");
+const post_cog_init_1 = require("../api/post-cog-init");
+const configure_aws_1 = require("../aws-services/configure-aws");
+const enums_1 = require("../constants/enums");
+const compress_mp3_audio_1 = require("../utils/compress-mp3-audio");
+const store_1 = require("../store/store");
+const helper_1 = require("../fetch-client/helper");
+const get_worker_url_1 = require("../utils/get-worker-url");
 class AudioFileManager {
     initialiseClassInstance() {
         this.audioChunks = [];
@@ -138,17 +149,17 @@ class AudioFileManager {
             // const worker = new SharedWorker(
             //   'https://unpkg.com/@eka-care/ekascribe-ts-sdk@1.5.80/dist/shared-worker/s3-file-upload.js'
             // );
-            const workerUrl = getSharedWorkerUrl();
+            const workerUrl = (0, get_worker_url_1.getSharedWorkerUrl)();
             const worker = new SharedWorker(workerUrl);
             this.sharedWorkerInstance = worker;
-            const onEventCallback = EkaScribeStore.eventCallback;
-            this.sharedWorkerInstance.port.onmessage = async (event) => {
+            const onEventCallback = store_1.default.eventCallback;
+            this.sharedWorkerInstance.port.onmessage = (event) => __awaiter(this, void 0, void 0, function* () {
                 const workerResponse = event.data;
                 switch (workerResponse.action) {
-                    case SHARED_WORKER_ACTION.CONFIGURE_AWS_SUCCESS: {
+                    case enums_1.SHARED_WORKER_ACTION.CONFIGURE_AWS_SUCCESS: {
                         if (onEventCallback) {
                             onEventCallback({
-                                callback_type: CALLBACK_TYPE.AWS_CONFIGURE_STATUS,
+                                callback_type: enums_1.CALLBACK_TYPE.AWS_CONFIGURE_STATUS,
                                 status: 'success',
                                 message: workerResponse.message,
                                 timestamp: new Date().toISOString(),
@@ -156,10 +167,10 @@ class AudioFileManager {
                         }
                         return;
                     }
-                    case SHARED_WORKER_ACTION.CONFIGURE_AWS_ERROR: {
+                    case enums_1.SHARED_WORKER_ACTION.CONFIGURE_AWS_ERROR: {
                         if (onEventCallback) {
                             onEventCallback({
-                                callback_type: CALLBACK_TYPE.AWS_CONFIGURE_STATUS,
+                                callback_type: enums_1.CALLBACK_TYPE.AWS_CONFIGURE_STATUS,
                                 status: 'error',
                                 message: workerResponse.message,
                                 timestamp: new Date().toISOString(),
@@ -167,11 +178,11 @@ class AudioFileManager {
                         }
                         return;
                     }
-                    case SHARED_WORKER_ACTION.UPLOAD_FILE_WITH_WORKER_SUCCESS: {
+                    case enums_1.SHARED_WORKER_ACTION.UPLOAD_FILE_WITH_WORKER_SUCCESS: {
                         const { fileCount: fileName, chunkIndex, fileBlob, compressedAudioBuffer, } = workerResponse.requestBody;
                         if (onEventCallback && compressedAudioBuffer) {
                             onEventCallback({
-                                callback_type: CALLBACK_TYPE.FILE_UPLOAD_STATUS,
+                                callback_type: enums_1.CALLBACK_TYPE.FILE_UPLOAD_STATUS,
                                 status: 'info',
                                 message: 'Audioframes of chunk to store in IDB',
                                 timestamp: new Date().toISOString(),
@@ -187,17 +198,11 @@ class AudioFileManager {
                             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,
-                                };
+                                this.audioChunks[chunkIndex] = Object.assign(Object.assign({}, this.audioChunks[chunkIndex]), { audioFrames: undefined, fileBlob: undefined, status: 'success', response: workerResponse.response.success });
                             }
                             if (onEventCallback) {
                                 onEventCallback({
-                                    callback_type: CALLBACK_TYPE.FILE_UPLOAD_STATUS,
+                                    callback_type: enums_1.CALLBACK_TYPE.FILE_UPLOAD_STATUS,
                                     status: 'success',
                                     message: workerResponse.response.success,
                                     timestamp: new Date().toISOString(),
@@ -212,7 +217,7 @@ class AudioFileManager {
                         else {
                             if (onEventCallback) {
                                 onEventCallback({
-                                    callback_type: CALLBACK_TYPE.FILE_UPLOAD_STATUS,
+                                    callback_type: enums_1.CALLBACK_TYPE.FILE_UPLOAD_STATUS,
                                     status: 'error',
                                     message: workerResponse.response.error || 'Upload failed',
                                     timestamp: new Date().toISOString(),
@@ -229,13 +234,7 @@ class AudioFileManager {
                             }
                             // 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',
-                                };
+                                this.audioChunks[chunkIndex] = Object.assign(Object.assign({}, 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') {
@@ -246,7 +245,7 @@ class AudioFileManager {
                         }
                     }
                 }
-            };
+            });
             worker.port.start();
             return true;
         }
@@ -264,229 +263,231 @@ class AudioFileManager {
             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: {
+    setupAWSConfiguration(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ is_shared_worker }) {
+            var _b;
+            try {
+                const response = yield (0, post_cog_init_1.default)();
+                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) {
+                    (_b = this.sharedWorkerInstance) === null || _b === void 0 ? void 0 : _b.port.postMessage({
+                        action: enums_1.SHARED_WORKER_ACTION.CONFIGURE_AWS,
+                        payload: {
+                            accessKeyId: AccessKeyId,
+                            secretKey: SecretKey,
+                            sessionToken: SessionToken,
+                        },
+                    });
+                }
+                else {
+                    (0, configure_aws_1.configureAWS)({
                         accessKeyId: AccessKeyId,
                         secretKey: SecretKey,
                         sessionToken: SessionToken,
-                    },
-                });
+                    });
+                }
+                this.isAWSConfigured = true;
+                return true;
             }
-            else {
-                configureAWS({
-                    accessKeyId: AccessKeyId,
-                    secretKey: SecretKey,
-                    sessionToken: SessionToken,
-                });
+            catch (error) {
+                console.log('%c Line:198 🥃 error', 'color:#42b983', error);
+                this.isAWSConfigured = false;
+                return false;
             }
-            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],
-        });
-        const onEventCallback = EkaScribeStore.eventCallback;
-        if (onEventCallback) {
-            onEventCallback({
-                callback_type: CALLBACK_TYPE.FILE_UPLOAD_STATUS,
-                status: 'info',
-                message: 'Audio chunks count to display success/total file count and to store chunks in IDB',
-                timestamp: new Date().toISOString(),
-                data: {
-                    success: this.successfulUploads.length,
-                    total: this.audioChunks.length,
-                    fileName,
-                    chunkData: compressedAudioBuffer,
-                },
+    uploadAudioChunkInMain(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ audioFrames, fileName, chunkIndex, }) {
+            const s3FileName = `${this.filePath}/${fileName}`; // fileName is ${fileCount}.mp3
+            const compressedAudioBuffer = (0, compress_mp3_audio_1.default)(audioFrames);
+            const audioBlob = new Blob(compressedAudioBuffer, {
+                type: constant_1.AUDIO_EXTENSION_TYPE_MAP[constant_1.OUTPUT_FORMAT],
             });
-        }
-        const s3BucketName = GET_S3_BUCKET_NAME();
-        // Push upload promise to track status
-        const uploadPromise = pushFileToS3({
-            s3BucketName,
-            fileBlob: audioBlob,
-            fileName: s3FileName,
-            txnID: this.txnID,
-            businessID: this.businessID,
-            is_shared_worker: false,
-        }).then((response) => {
-            // callback
-            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 (onEventCallback) {
-                    onEventCallback({
-                        callback_type: CALLBACK_TYPE.FILE_UPLOAD_STATUS,
-                        status: 'success',
-                        message: response.success,
-                        timestamp: new Date().toISOString(),
-                        data: {
-                            success: this.successfulUploads.length,
-                            total: this.audioChunks.length,
-                            is_uploaded: true,
-                        },
-                    });
-                }
+            const onEventCallback = store_1.default.eventCallback;
+            if (onEventCallback) {
+                onEventCallback({
+                    callback_type: enums_1.CALLBACK_TYPE.FILE_UPLOAD_STATUS,
+                    status: 'info',
+                    message: 'Audio chunks count to display success/total file count and to store chunks in IDB',
+                    timestamp: new Date().toISOString(),
+                    data: {
+                        success: this.successfulUploads.length,
+                        total: this.audioChunks.length,
+                        fileName,
+                        chunkData: compressedAudioBuffer,
+                    },
+                });
             }
-            else {
-                if (chunkIndex !== -1) {
-                    this.audioChunks[chunkIndex] = {
-                        ...this.audioChunks[chunkIndex],
-                        fileBlob: audioBlob,
-                        audioFrames: undefined,
-                        status: 'failure',
-                        response: response.error || 'Upload failed',
-                    };
+            const s3BucketName = (0, helper_1.GET_S3_BUCKET_NAME)();
+            // Push upload promise to track status
+            const uploadPromise = (0, upload_file_to_s3_1.default)({
+                s3BucketName,
+                fileBlob: audioBlob,
+                fileName: s3FileName,
+                txnID: this.txnID,
+                businessID: this.businessID,
+                is_shared_worker: false,
+            }).then((response) => {
+                // callback
+                if (response.success) {
+                    this.successfulUploads.push(fileName);
+                    // update file status if file uploaded successfully
+                    if (chunkIndex !== -1) {
+                        this.audioChunks[chunkIndex] = Object.assign(Object.assign({}, this.audioChunks[chunkIndex]), { audioFrames: undefined, fileBlob: undefined, status: 'success', response: response.success });
+                    }
+                    if (onEventCallback) {
+                        onEventCallback({
+                            callback_type: enums_1.CALLBACK_TYPE.FILE_UPLOAD_STATUS,
+                            status: 'success',
+                            message: response.success,
+                            timestamp: new Date().toISOString(),
+                            data: {
+                                success: this.successfulUploads.length,
+                                total: this.audioChunks.length,
+                                is_uploaded: true,
+                            },
+                        });
+                    }
                 }
-                if (onEventCallback) {
-                    onEventCallback({
-                        callback_type: CALLBACK_TYPE.FILE_UPLOAD_STATUS,
-                        status: 'error',
-                        message: response.error || 'Upload failed',
-                        timestamp: new Date().toISOString(),
-                        error: {
-                            code: response.code || 500,
-                            msg: response.error || 'Upload failed',
-                            details: response.errorCode,
-                        },
-                        data: {
-                            fileName,
-                            is_uploaded: false,
-                        },
-                    });
+                else {
+                    if (chunkIndex !== -1) {
+                        this.audioChunks[chunkIndex] = Object.assign(Object.assign({}, this.audioChunks[chunkIndex]), { fileBlob: audioBlob, audioFrames: undefined, status: 'failure', response: response.error || 'Upload failed' });
+                    }
+                    if (onEventCallback) {
+                        onEventCallback({
+                            callback_type: enums_1.CALLBACK_TYPE.FILE_UPLOAD_STATUS,
+                            status: 'error',
+                            message: response.error || 'Upload failed',
+                            timestamp: new Date().toISOString(),
+                            error: {
+                                code: response.code || 500,
+                                msg: response.error || 'Upload failed',
+                                details: response.errorCode,
+                            },
+                            data: {
+                                fileName,
+                                is_uploaded: false,
+                            },
+                        });
+                    }
                 }
-            }
-            return response;
+                return response;
+            });
+            this.uploadPromises.push(uploadPromise);
+            return {
+                success: true,
+                fileName,
+            };
         });
-        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}`;
-        const onEventCallback = EkaScribeStore.eventCallback;
-        if (onEventCallback) {
-            onEventCallback({
-                callback_type: CALLBACK_TYPE.FILE_UPLOAD_STATUS,
-                status: 'info',
-                message: 'Audio chunks count to display success/total file count',
-                timestamp: new Date().toISOString(),
-                data: {
-                    success: this.successfulUploads.length,
-                    total: this.audioChunks.length,
+    uploadAudioChunkInWorker(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ audioFrames, fileName, chunkIndex, }) {
+            var _b;
+            const s3FileName = `${this.filePath}/${fileName}`;
+            const onEventCallback = store_1.default.eventCallback;
+            if (onEventCallback) {
+                onEventCallback({
+                    callback_type: enums_1.CALLBACK_TYPE.FILE_UPLOAD_STATUS,
+                    status: 'info',
+                    message: 'Audio chunks count to display success/total file count',
+                    timestamp: new Date().toISOString(),
+                    data: {
+                        success: this.successfulUploads.length,
+                        total: this.audioChunks.length,
+                    },
+                });
+            }
+            const s3BucketName = (0, helper_1.GET_S3_BUCKET_NAME)();
+            (_b = this.sharedWorkerInstance) === null || _b === void 0 ? void 0 : _b.port.postMessage({
+                action: enums_1.SHARED_WORKER_ACTION.UPLOAD_FILE_WITH_WORKER,
+                payload: {
+                    s3BucketName,
+                    audioFrames,
+                    fileName: s3FileName,
+                    txnID: this.txnID,
+                    businessID: this.businessID,
+                    chunkIndex,
+                    fileCount: fileName,
                 },
             });
-        }
-        const s3BucketName = GET_S3_BUCKET_NAME();
-        this.sharedWorkerInstance?.port.postMessage({
-            action: SHARED_WORKER_ACTION.UPLOAD_FILE_WITH_WORKER,
-            payload: {
-                s3BucketName,
-                audioFrames,
-                fileName: s3FileName,
-                txnID: this.txnID,
-                businessID: this.businessID,
-                chunkIndex,
-                fileCount: fileName,
-            },
+            return {
+                success: true,
+                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) {
-                const workerCreated = this.createSharedWorkerInstance();
-                if (!workerCreated) {
-                    // SharedWorker creation failed (likely due to CORS/same-origin policy)
-                    // Fall back to non-worker upload
-                    console.warn('Failed to create SharedWorker instance. Falling back to non-worker upload method.');
-                    await this.uploadAudioToS3WithoutWorker({ audioFrames, fileName, chunkIndex });
-                    return;
+    uploadAudioToS3(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ 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.');
+                yield this.uploadAudioToS3WithoutWorker({ audioFrames, fileName, chunkIndex });
+            }
+            else {
+                // Shared Workers are supported
+                console.log('Shared Workers are supported in this browser.');
+                if (!this.sharedWorkerInstance) {
+                    const workerCreated = this.createSharedWorkerInstance();
+                    if (!workerCreated) {
+                        // SharedWorker creation failed (likely due to CORS/same-origin policy)
+                        // Fall back to non-worker upload
+                        console.warn('Failed to create SharedWorker instance. Falling back to non-worker upload method.');
+                        yield this.uploadAudioToS3WithoutWorker({ audioFrames, fileName, chunkIndex });
+                        return;
+                    }
                 }
+                yield this.uploadAudioToS3WithWorker({ audioFrames, fileName, chunkIndex });
             }
-            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');
+    uploadAudioToS3WithWorker(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ audioFrames, fileName, chunkIndex, }) {
+            try {
+                if (!this.isAWSConfigured) {
+                    const awsConfigResponse = yield this.setupAWSConfiguration({
+                        is_shared_worker: true,
+                    });
+                    if (!awsConfigResponse) {
+                        throw new Error('Failed to configure AWS');
+                    }
                 }
+                yield this.uploadAudioChunkInWorker({ audioFrames, fileName, chunkIndex });
             }
-            await this.uploadAudioChunkInWorker({ audioFrames, fileName, chunkIndex });
-        }
-        catch (error) {
-            console.error('Error uploading audio to S3: uploadAudioToS3WithWorker: ', error);
-            // Fall back to non-worker upload if worker fails
-            await this.uploadAudioToS3WithoutWorker({ audioFrames, fileName, chunkIndex });
-        }
+            catch (error) {
+                console.error('Error uploading audio to S3: uploadAudioToS3WithWorker: ', error);
+                // Fall back to non-worker upload if worker fails
+                yield this.uploadAudioToS3WithoutWorker({ audioFrames, fileName, chunkIndex });
+            }
+        });
     }
-    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');
+    uploadAudioToS3WithoutWorker(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ audioFrames, fileName, chunkIndex, }) {
+            try {
+                if (!this.isAWSConfigured) {
+                    const awsConfigResponse = yield this.setupAWSConfiguration({
+                        is_shared_worker: false,
+                    });
+                    if (!awsConfigResponse) {
+                        throw new Error('Failed to configure AWS');
+                    }
                 }
+                yield this.uploadAudioChunkInMain({ audioFrames, fileName, chunkIndex });
             }
-            await this.uploadAudioChunkInMain({ audioFrames, fileName, chunkIndex });
-        }
-        catch (error) {
-            console.error('Error uploading audio to S3:', error);
-        }
+            catch (error) {
+                console.error('Error uploading audio to S3:', error);
+            }
+        });
     }
     /**
      * Download audio as a file to the user's device (for debugging)
@@ -505,36 +506,41 @@ class AudioFileManager {
     /**
      * 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();
+    waitForAllUploads() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.sharedWorkerInstance) {
+                return new Promise((resolve, reject) => {
+                    var _a, _b;
+                    // one-time message handler to listen for the response
+                    const messageHandler = (event) => {
+                        var _a, _b, _c;
+                        if (event.data.action === enums_1.SHARED_WORKER_ACTION.WAIT_FOR_ALL_UPLOADS_SUCCESS) {
+                            (_a = this.sharedWorkerInstance) === null || _a === void 0 ? void 0 : _a.port.removeEventListener('message', messageHandler);
+                            resolve();
                         }
-                        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 if (event.data.action === enums_1.SHARED_WORKER_ACTION.WAIT_FOR_ALL_UPLOADS_ERROR) {
+                            const { uploadRequestReceived } = event.data.response || {};
+                            if (uploadRequestReceived === 0) {
+                                (_b = this.sharedWorkerInstance) === null || _b === void 0 ? void 0 : _b.port.removeEventListener('message', messageHandler);
+                                reject();
+                            }
+                            (_c = this.sharedWorkerInstance) === null || _c === void 0 ? void 0 : _c.port.postMessage({
+                                action: enums_1.SHARED_WORKER_ACTION.WAIT_FOR_ALL_UPLOADS,
+                            });
+                        }
+                    };
+                    // one-time listener
+                    (_a = this.sharedWorkerInstance) === null || _a === void 0 ? void 0 : _a.port.addEventListener('message', messageHandler);
+                    (_b = this.sharedWorkerInstance) === null || _b === void 0 ? void 0 : _b.port.postMessage({
+                        action: enums_1.SHARED_WORKER_ACTION.WAIT_FOR_ALL_UPLOADS,
+                    });
                 });
-            });
-        }
-        else {
-            await Promise.allSettled(this.uploadPromises);
-        }
+            }
+            else {
+                // ES2015-compatible alternative to Promise.allSettled
+                yield Promise.all(this.uploadPromises.map((promise) => promise.catch((error) => ({ error: String(error) }))));
+            }
+        });
     }
     /**
      * Get list of successfully uploaded files
@@ -563,104 +569,101 @@ class AudioFileManager {
     /**
      * Retry uploading failed files
      */
-    async retryFailedUploads() {
-        const failedFiles = this.getFailedUploads();
-        if (failedFiles.length === 0) {
-            return [];
-        }
-        const onEventCallback = EkaScribeStore.eventCallback;
-        const s3BucketName = GET_S3_BUCKET_NAME();
-        if (this.sharedWorkerInstance) {
-            this.audioChunks.forEach((chunk, index) => {
-                const { fileName, fileBlob, status, audioFrames } = chunk;
-                if (status != 'success') {
-                    // callback
-                    this.sharedWorkerInstance?.port.postMessage({
-                        action: SHARED_WORKER_ACTION.UPLOAD_FILE_WITH_WORKER,
-                        payload: {
-                            s3BucketName,
-                            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 (onEventCallback) {
-                onEventCallback({
-                    callback_type: CALLBACK_TYPE.FILE_UPLOAD_STATUS,
-                    status: 'info',
-                    message: 'Audio chunks count to display success/total file count',
-                    timestamp: new Date().toISOString(),
-                    data: {
-                        success: this.successfulUploads.length,
-                        total: this.audioChunks.length,
-                    },
-                });
+    retryFailedUploads() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const failedFiles = this.getFailedUploads();
+            if (failedFiles.length === 0) {
+                return [];
             }
-            const s3BucketName = GET_S3_BUCKET_NAME();
-            this.audioChunks.forEach((chunk, index) => {
-                const { fileName, fileBlob, status, audioFrames } = chunk;
-                if (status != 'success') {
-                    // callback
-                    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],
+            const onEventCallback = store_1.default.eventCallback;
+            const s3BucketName = (0, helper_1.GET_S3_BUCKET_NAME)();
+            if (this.sharedWorkerInstance) {
+                this.audioChunks.forEach((chunk, index) => {
+                    var _a;
+                    const { fileName, fileBlob, status, audioFrames } = chunk;
+                    if (status != 'success') {
+                        // callback
+                        (_a = this.sharedWorkerInstance) === null || _a === void 0 ? void 0 : _a.port.postMessage({
+                            action: enums_1.SHARED_WORKER_ACTION.UPLOAD_FILE_WITH_WORKER,
+                            payload: {
+                                s3BucketName,
+                                audioFrames,
+                                fileBlob,
+                                fileName: `${this.filePath}/${fileName}`,
+                                txnID: this.txnID,
+                                businessID: this.businessID,
+                                chunkIndex: index,
+                                fileCount: fileName,
+                            },
                         });
                     }
-                    if (failedFileBlob) {
-                        const uploadPromise = pushFileToS3({
-                            s3BucketName,
-                            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 (onEventCallback) {
-                                    onEventCallback({
-                                        callback_type: CALLBACK_TYPE.FILE_UPLOAD_STATUS,
-                                        status: 'info',
-                                        message: 'Audio chunks count to display success/total file count',
-                                        timestamp: new Date().toISOString(),
-                                        data: {
-                                            success: this.successfulUploads.length,
-                                            total: this.audioChunks.length,
-                                        },
-                                    });
+                });
+            }
+            else {
+                this.uploadPromises = []; // Reset upload promises for retries
+                if (onEventCallback) {
+                    onEventCallback({
+                        callback_type: enums_1.CALLBACK_TYPE.FILE_UPLOAD_STATUS,
+                        status: 'info',
+                        message: 'Audio chunks count to display success/total file count',
+                        timestamp: new Date().toISOString(),
+                        data: {
+                            success: this.successfulUploads.length,
+                            total: this.audioChunks.length,
+                        },
+                    });
+                }
+                const s3BucketName = (0, helper_1.GET_S3_BUCKET_NAME)();
+                this.audioChunks.forEach((chunk, index) => {
+                    const { fileName, fileBlob, status, audioFrames } = chunk;
+                    if (status != 'success') {
+                        // callback
+                        let failedFileBlob;
+                        if (status === 'failure') {
+                            failedFileBlob = fileBlob;
+                        }
+                        if (status === 'pending') {
+                            const compressedAudioBuffer = (0, compress_mp3_audio_1.default)(audioFrames);
+                            failedFileBlob = new Blob(compressedAudioBuffer, {
+                                type: constant_1.AUDIO_EXTENSION_TYPE_MAP[constant_1.OUTPUT_FORMAT],
+                            });
+                        }
+                        if (failedFileBlob) {
+                            const uploadPromise = (0, upload_file_to_s3_1.default)({
+                                s3BucketName,
+                                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 (onEventCallback) {
+                                        onEventCallback({
+                                            callback_type: enums_1.CALLBACK_TYPE.FILE_UPLOAD_STATUS,
+                                            status: 'info',
+                                            message: 'Audio chunks count to display success/total file count',
+                                            timestamp: new Date().toISOString(),
+                                            data: {
+                                                success: this.successfulUploads.length,
+                                                total: this.audioChunks.length,
+                                            },
+                                        });
+                                    }
+                                    this.audioChunks[index] = Object.assign(Object.assign({}, this.audioChunks[index]), { audioFrames: undefined, fileBlob: undefined, status: 'success', response: response.success });
                                 }
-                                this.audioChunks[index] = {
-                                    ...this.audioChunks[index],
-                                    audioFrames: undefined,
-                                    fileBlob: undefined,
-                                    status: 'success',
-                                    response: response.success,
-                                };
-                            }
-                            return response;
-                        });
-                        this.uploadPromises.push(uploadPromise);
+                                return response;
+                            });
+                            this.uploadPromises.push(uploadPromise);
+                        }
                     }
-                }
-            });
-        }
-        // Wait for all retry promises to complete
-        await this.waitForAllUploads();
-        return this.getFailedUploads();
+                });
+            }
+            // Wait for all retry promises to complete
+            yield this.waitForAllUploads();
+            return this.getFailedUploads();
+        });
     }
     /**
      * Reset the upload state
@@ -685,4 +688,4 @@ class AudioFileManager {
         this.isAWSConfigured = false;
     }
 }
-export default AudioFileManager;
+exports.default = AudioFileManager;