@eka-care/ekascribe-ts-sdk 1.4.39

package/dist/main/retry-upload-recording.js

@@ -0,0 +1,69 @@
+import postTransactionCommit from '../api/post-transaction-commit';
+import { SDK_STATUS_CODE } from '../constants/constant';
+import { ERROR_CODE } from '../constants/enums';
+import EkaScribeStore from '../store/store';
+const retryUploadFailedFiles = async ({ force_commit, }) => {
+    try {
+        const fileManagerInstance = EkaScribeStore.audioFileManagerInstance;
+        if (!fileManagerInstance) {
+            throw new Error('Class instances are not initialized');
+        }
+        const failedFiles = (await fileManagerInstance.retryFailedUploads()) || [];
+        const audioInfo = fileManagerInstance?.audioChunks;
+        const audioFiles = audioInfo.map((audio) => audio.fileName);
+        if (failedFiles.length > 0 && !force_commit) {
+            return {
+                error_code: ERROR_CODE.AUDIO_UPLOAD_FAILED,
+                status_code: SDK_STATUS_CODE.AUDIO_ERROR,
+                message: 'Audio upload failed for some files after retry.',
+                failed_files: failedFiles,
+                total_audio_files: audioFiles,
+            };
+        }
+        // call commit transaction api
+        const txnID = EkaScribeStore.txnID;
+        if (EkaScribeStore.sessionStatus[txnID].api?.status === 'stop' ||
+            EkaScribeStore.sessionStatus[txnID].api?.status === 'commit') {
+            const { message: txnCommitMsg, code: txnCommitStatusCode } = await postTransactionCommit({
+                txnId: EkaScribeStore.txnID,
+                audioFiles,
+            });
+            if (txnCommitStatusCode != 200) {
+                return {
+                    error_code: ERROR_CODE.TXN_COMMIT_FAILED,
+                    status_code: txnCommitStatusCode,
+                    message: txnCommitMsg || 'Transaction stop failed.',
+                };
+            }
+            EkaScribeStore.sessionStatus[txnID] = {
+                ...EkaScribeStore.sessionStatus[txnID],
+                api: {
+                    status: 'commit',
+                    code: txnCommitStatusCode,
+                    response: txnCommitMsg,
+                },
+            };
+        }
+        else {
+            // transaction is not stopped or committed
+            return {
+                error_code: ERROR_CODE.TXN_STATUS_MISMATCH,
+                status_code: SDK_STATUS_CODE.TXN_ERROR,
+                message: 'Transaction is not initialised or stopped. Cannot end recording.',
+            };
+        }
+        return {
+            status_code: SDK_STATUS_CODE.SUCCESS,
+            message: 'All recordings uploaded successfully.',
+        };
+    }
+    catch (error) {
+        console.error('Error retrying upload: ', error);
+        return {
+            error_code: ERROR_CODE.INTERNAL_SERVER_ERROR,
+            status_code: SDK_STATUS_CODE.INTERNAL_SERVER_ERROR,
+            message: `An error occurred while retrying failed upload: ${error}`,
+        };
+    }
+};
+export default retryUploadFailedFiles;

package/dist/main/start-recording.d.ts

@@ -0,0 +1,3 @@
+import { TStartRecordingResponse } from '../constants/types';
+declare const startVoiceRecording: () => Promise<TStartRecordingResponse>;
+export default startVoiceRecording;

package/dist/main/start-recording.js

@@ -0,0 +1,55 @@
+import { SDK_STATUS_CODE } from '../constants/constant';
+import { ERROR_CODE } from '../constants/enums';
+import EkaScribeStore from '../store/store';
+const startVoiceRecording = async () => {
+    try {
+        const vadInstance = EkaScribeStore.vadInstance;
+        const navigatorPermissionResponse = await navigator.permissions.query({
+            name: 'microphone',
+        });
+        if (navigatorPermissionResponse.state !== 'granted') {
+            return {
+                error_code: ERROR_CODE.MICROPHONE,
+                status_code: SDK_STATUS_CODE.FORBIDDEN,
+                message: 'Microphone access is required to start recording. Please recheck access.',
+            };
+        }
+        console.log('%c Line:22 🍇 vadInstance', 'color:#fca650', vadInstance);
+        const micVad = vadInstance?.getMicVad();
+        const isVadLoading = vadInstance?.isVadLoading();
+        if (isVadLoading || !micVad || Object.keys(micVad).length === 0) {
+            // retry initiating vad once and if still is in loading return error
+            const reinitializeVadResponse = await vadInstance?.reinitializeVad();
+            console.log(reinitializeVadResponse, 'reinitialize vad response');
+            if (reinitializeVadResponse) {
+                return {
+                    error_code: ERROR_CODE.VAD_NOT_INITIALIZED,
+                    status_code: SDK_STATUS_CODE.FORBIDDEN,
+                    message: 'VAD instance is not initialized. Please try again later.',
+                };
+            }
+        }
+        vadInstance?.startVad();
+        const txn_id = EkaScribeStore.txnID;
+        EkaScribeStore.sessionStatus[txn_id] = {
+            ...EkaScribeStore.sessionStatus[txn_id],
+            vad: {
+                status: 'start',
+            },
+        };
+        return {
+            message: 'Recording started successfully.',
+            status_code: SDK_STATUS_CODE.SUCCESS,
+            txn_id,
+        };
+    }
+    catch (err) {
+        console.log('%c Line:102 🍇 startRecording err', 'color:#b03734', err);
+        return {
+            error_code: ERROR_CODE.INTERNAL_SERVER_ERROR,
+            status_code: SDK_STATUS_CODE.INTERNAL_SERVER_ERROR,
+            message: `An error occurred while starting the recording: ${err}`,
+        };
+    }
+};
+export default startVoiceRecording;

package/dist/shared-worker/s3-file-upload.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shared-worker/s3-file-upload.js

@@ -0,0 +1,109 @@
+// window is undefined in sharedWorker so it is needed to decode the XML AWS error
+if (typeof window === 'undefined') {
+    self.window = self;
+}
+import { configureAWS } from '../aws-services/configure-aws';
+import pushFileToS3 from '../aws-services/upload-file-to-s3';
+import { AUDIO_EXTENSION_TYPE_MAP, OUTPUT_FORMAT } from '../constants/constant';
+import { SHARED_WORKER_ACTION } from '../constants/enums';
+import compressAudioToMp3 from '../utils/compress-mp3-audio';
+// onconnect - to establish communication channel with the main thread
+// eslint-disable-next-line
+// @ts-ignore
+onconnect = function (event) {
+    // after connection messages are being channelled through the port
+    const workerPort = event.ports[0];
+    let uploadRequestReceived = 0;
+    let uploadRequestCompleted = 0;
+    // onmessage - to handle messages from the main thread
+    workerPort.onmessage = async function (event) {
+        const workerData = event.data;
+        switch (workerData.action) {
+            case SHARED_WORKER_ACTION.CONFIGURE_AWS: {
+                try {
+                    const { accessKeyId, secretKey, sessionToken } = workerData.payload;
+                    configureAWS({
+                        accessKeyId,
+                        secretKey,
+                        sessionToken,
+                    });
+                    workerPort.postMessage({
+                        action: SHARED_WORKER_ACTION.CONFIGURE_AWS_SUCCESS,
+                        message: 'AWS configured successfully',
+                    });
+                }
+                catch (error) {
+                    workerPort.postMessage({
+                        action: SHARED_WORKER_ACTION.CONFIGURE_AWS_ERROR,
+                        error: error || 'Failed to configure AWS',
+                    });
+                }
+                return;
+            }
+            case SHARED_WORKER_ACTION.UPLOAD_FILE_WITH_WORKER: {
+                const { fileName, audioFrames, txnID, businessID, fileBlob } = workerData.payload;
+                uploadRequestReceived++;
+                let audioBlob;
+                let compressedAudioBuffer;
+                if (fileBlob) {
+                    audioBlob = fileBlob;
+                }
+                else {
+                    compressedAudioBuffer = compressAudioToMp3(audioFrames);
+                    audioBlob = new Blob(compressedAudioBuffer, {
+                        type: AUDIO_EXTENSION_TYPE_MAP[OUTPUT_FORMAT],
+                    });
+                }
+                await pushFileToS3({
+                    fileBlob: audioBlob,
+                    fileName,
+                    txnID,
+                    businessID,
+                    is_shared_worker: true,
+                })
+                    .then((response) => {
+                    uploadRequestCompleted++;
+                    // postMessage - to send messages back to the main thread
+                    workerPort.postMessage({
+                        action: SHARED_WORKER_ACTION.UPLOAD_FILE_WITH_WORKER_SUCCESS,
+                        response,
+                        requestBody: {
+                            ...workerData.payload,
+                            fileBlob: audioBlob,
+                            compressedAudioBuffer,
+                        },
+                    });
+                })
+                    .catch((error) => {
+                    console.log(error, 'shared worker - file upload');
+                    uploadRequestCompleted++;
+                });
+                return;
+            }
+            case SHARED_WORKER_ACTION.WAIT_FOR_ALL_UPLOADS: {
+                if (uploadRequestReceived === uploadRequestCompleted) {
+                    workerPort.postMessage({
+                        action: SHARED_WORKER_ACTION.WAIT_FOR_ALL_UPLOADS_SUCCESS,
+                        response: {
+                            uploadRequestReceived,
+                            uploadRequestCompleted,
+                        },
+                    });
+                    return;
+                }
+                workerPort.postMessage({
+                    action: SHARED_WORKER_ACTION.WAIT_FOR_ALL_UPLOADS_ERROR,
+                    response: {
+                        uploadRequestReceived,
+                        uploadRequestCompleted,
+                    },
+                });
+                return;
+            }
+        }
+    };
+    workerPort.postMessage(`[WORKER] Web worker onmessage established ${JSON.stringify(workerPort)}`);
+    // start the worker port to listen for messages
+    workerPort.start();
+};
+console.log('File upload web worker created');

package/dist/shared-worker/s3-file-upload.ts

@@ -0,0 +1,126 @@
+// window is undefined in sharedWorker so it is needed to decode the XML AWS error
+if (typeof window === 'undefined') {
+  self.window = self;
+}
+
+import { configureAWS } from '../aws-services/configure-aws';
+import pushFileToS3 from '../aws-services/upload-file-to-s3';
+import { AUDIO_EXTENSION_TYPE_MAP, OUTPUT_FORMAT } from '../constants/constant';
+import { SHARED_WORKER_ACTION } from '../constants/enums';
+import compressAudioToMp3 from '../utils/compress-mp3-audio';
+
+// onconnect - to establish communication channel with the main thread
+// eslint-disable-next-line
+// @ts-ignore
+onconnect = function (event: MessageEvent) {
+  // after connection messages are being channelled through the port
+  const workerPort = event.ports[0];
+
+  let uploadRequestReceived: number = 0;
+  let uploadRequestCompleted: number = 0;
+
+  // onmessage - to handle messages from the main thread
+  workerPort.onmessage = async function (event) {
+    const workerData = event.data;
+
+    switch (workerData.action) {
+      case SHARED_WORKER_ACTION.CONFIGURE_AWS: {
+        try {
+          const { accessKeyId, secretKey, sessionToken } = workerData.payload;
+
+          configureAWS({
+            accessKeyId,
+            secretKey,
+            sessionToken,
+          });
+
+          workerPort.postMessage({
+            action: SHARED_WORKER_ACTION.CONFIGURE_AWS_SUCCESS,
+            message: 'AWS configured successfully',
+          });
+        } catch (error: unknown) {
+          workerPort.postMessage({
+            action: SHARED_WORKER_ACTION.CONFIGURE_AWS_ERROR,
+            error: error || 'Failed to configure AWS',
+          });
+        }
+
+        return;
+      }
+
+      case SHARED_WORKER_ACTION.UPLOAD_FILE_WITH_WORKER: {
+        const { fileName, audioFrames, txnID, businessID, fileBlob } = workerData.payload;
+        uploadRequestReceived++;
+
+        let audioBlob: Blob;
+        let compressedAudioBuffer: Uint8Array<ArrayBufferLike>[];
+
+        if (fileBlob) {
+          audioBlob = fileBlob;
+        } else {
+          compressedAudioBuffer = compressAudioToMp3(audioFrames);
+
+          audioBlob = new Blob(compressedAudioBuffer, {
+            type: AUDIO_EXTENSION_TYPE_MAP[OUTPUT_FORMAT],
+          });
+        }
+
+        await pushFileToS3({
+          fileBlob: audioBlob,
+          fileName,
+          txnID,
+          businessID,
+          is_shared_worker: true,
+        })
+          .then((response) => {
+            uploadRequestCompleted++;
+            // postMessage - to send messages back to the main thread
+            workerPort.postMessage({
+              action: SHARED_WORKER_ACTION.UPLOAD_FILE_WITH_WORKER_SUCCESS,
+              response,
+              requestBody: {
+                ...workerData.payload,
+                fileBlob: audioBlob,
+                compressedAudioBuffer,
+              },
+            });
+          })
+          .catch((error) => {
+            console.log(error, 'shared worker - file upload');
+            uploadRequestCompleted++;
+          });
+
+        return;
+      }
+
+      case SHARED_WORKER_ACTION.WAIT_FOR_ALL_UPLOADS: {
+        if (uploadRequestReceived === uploadRequestCompleted) {
+          workerPort.postMessage({
+            action: SHARED_WORKER_ACTION.WAIT_FOR_ALL_UPLOADS_SUCCESS,
+            response: {
+              uploadRequestReceived,
+              uploadRequestCompleted,
+            },
+          });
+          return;
+        }
+
+        workerPort.postMessage({
+          action: SHARED_WORKER_ACTION.WAIT_FOR_ALL_UPLOADS_ERROR,
+          response: {
+            uploadRequestReceived,
+            uploadRequestCompleted,
+          },
+        });
+        return;
+      }
+    }
+  };
+
+  workerPort.postMessage(`[WORKER] Web worker onmessage established ${JSON.stringify(workerPort)}`);
+
+  // start the worker port to listen for messages
+  workerPort.start();
+};
+
+console.log('File upload web worker created');

package/dist/store/store.d.ts

@@ -0,0 +1,35 @@
+import AudioBufferManager from '../audio-chunker/audio-buffer-manager';
+import AudioFileManager from '../audio-chunker/audio-file-manager';
+import VadWebClient from '../audio-chunker/vad-web';
+import { TErrorCallback, TSessionStatus } from '../constants/types';
+declare class EkaScribeStore {
+    private static instance;
+    private _txnID;
+    private _sessionBucketPath;
+    private _vadInstance;
+    private _audioFileManagerInstance;
+    private _audioBufferInstance;
+    private _sessionStatus;
+    private _errorCallback;
+    private _userSpeechCallback;
+    static getInstance(): EkaScribeStore;
+    get vadInstance(): VadWebClient | null;
+    set vadInstance(value: VadWebClient);
+    get audioFileManagerInstance(): AudioFileManager | null;
+    set audioFileManagerInstance(value: AudioFileManager);
+    get audioBufferInstance(): AudioBufferManager | null;
+    set audioBufferInstance(value: AudioBufferManager);
+    get txnID(): string;
+    set txnID(value: string);
+    get sessionBucketPath(): string;
+    set sessionBucketPath(value: string);
+    get sessionStatus(): TSessionStatus;
+    set sessionStatus(value: TSessionStatus);
+    get errorCallback(): TErrorCallback | null;
+    set errorCallback(callback: TErrorCallback | null);
+    get userSpeechCallback(): ((isSpeech: boolean) => void) | null;
+    set userSpeechCallback(callback: ((isSpeech: boolean) => void) | null);
+    resetStore(): void;
+}
+declare const _default: EkaScribeStore;
+export default _default;

package/dist/store/store.js

@@ -0,0 +1,121 @@
+class EkaScribeStore {
+    constructor() {
+        Object.defineProperty(this, "_txnID", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "_sessionBucketPath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "_vadInstance", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        }); // vadWebClient Instance
+        Object.defineProperty(this, "_audioFileManagerInstance", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        }); // AudioFileManager Instance
+        Object.defineProperty(this, "_audioBufferInstance", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        }); // AudioBuffer Instance
+        Object.defineProperty(this, "_sessionStatus", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "_errorCallback", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "_userSpeechCallback", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    static getInstance() {
+        if (!EkaScribeStore.instance) {
+            EkaScribeStore.instance = new EkaScribeStore();
+        }
+        return EkaScribeStore.instance;
+    }
+    // VadWebClient Instance
+    get vadInstance() {
+        return this._vadInstance;
+    }
+    set vadInstance(value) {
+        this._vadInstance = value;
+    }
+    // AudioFileManager Instance
+    get audioFileManagerInstance() {
+        return this._audioFileManagerInstance;
+    }
+    set audioFileManagerInstance(value) {
+        this._audioFileManagerInstance = value;
+    }
+    // AudioBuffer Instance
+    get audioBufferInstance() {
+        return this._audioBufferInstance;
+    }
+    set audioBufferInstance(value) {
+        this._audioBufferInstance = value;
+    }
+    // Transaction ID
+    get txnID() {
+        return this._txnID;
+    }
+    set txnID(value) {
+        this._txnID = value;
+    }
+    // session file Path - date/txnID
+    get sessionBucketPath() {
+        return this._sessionBucketPath;
+    }
+    set sessionBucketPath(value) {
+        this._sessionBucketPath = value;
+    }
+    // Session Status
+    get sessionStatus() {
+        return this._sessionStatus;
+    }
+    set sessionStatus(value) {
+        this._sessionStatus = value;
+    }
+    // Error Callback
+    get errorCallback() {
+        return this._errorCallback;
+    }
+    set errorCallback(callback) {
+        this._errorCallback = callback;
+    }
+    // User Speech Callback
+    get userSpeechCallback() {
+        return this._userSpeechCallback;
+    }
+    set userSpeechCallback(callback) {
+        this._userSpeechCallback = callback;
+    }
+    // Reset store to initial state
+    resetStore() {
+        this._txnID = '';
+        this._sessionBucketPath = '';
+        this._sessionStatus = {};
+    }
+}
+export default EkaScribeStore.getInstance();

package/dist/utils/compress-mp3-audio.d.ts

@@ -0,0 +1,2 @@
+declare const compressAudioToMp3: (audio: Float32Array) => Uint8Array<ArrayBufferLike>[];
+export default compressAudioToMp3;

package/dist/utils/compress-mp3-audio.js

@@ -0,0 +1,24 @@
+import * as lamejs from '@breezystack/lamejs';
+import { BITRATE, SAMPLING_RATE } from '../constants/constant';
+const compressAudioToMp3 = (audio) => {
+    try {
+        const audioEncoder = new lamejs.Mp3Encoder(1, SAMPLING_RATE, BITRATE);
+        // convert Float32Array to Int16Array
+        const samples = new Int16Array(audio.length);
+        for (let i = 0; i < audio.length; i++) {
+            const s = Math.max(-1, Math.min(1, audio[i]));
+            samples[i] = s < 0 ? s * 32768 : s * 32767;
+        }
+        const mp3Data = [];
+        const encodedBuffer = audioEncoder.encodeBuffer(samples);
+        mp3Data.push(encodedBuffer);
+        const lastAudioBuffer = audioEncoder.flush();
+        mp3Data.push(lastAudioBuffer);
+        return mp3Data;
+    }
+    catch (error) {
+        console.error('Error compressing audio to MP3: lamejs: ', error);
+        return [];
+    }
+};
+export default compressAudioToMp3;

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@eka-care/ekascribe-ts-sdk",
+  "version": "1.4.39",
+  "main": "dist/index.js",
+  "repository": "git@github.com:eka-care/eka-js-sdk.git",
+  "author": "Sanikagoyal28 <sanikagoyal9@gmail.com>",
+  "keywords": [
+    "ekascribe",
+    "typescript",
+    "sdk",
+    "javascript",
+    "voice2rx",
+    "eka care"
+  ],
+  "license": "MIT",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc && cp -R eka-sdk/ekascribe-v2rx/shared-worker dist",
+    "lint": "eslint . --ext .ts",
+    "start": "ts-node ./eka-sdk/ekascribe-v2rx/index.ts",
+    "prepare": "yarn build"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.14.1",
+    "@typescript-eslint/eslint-plugin": "^8.30.1",
+    "@typescript-eslint/parser": "^8.30.1",
+    "eslint": "^9.25.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3"
+  },
+  "dependencies": {
+    "@aws-sdk/client-translate": "^3.857.0",
+    "@breezystack/lamejs": "^1.2.7",
+    "@ffmpeg/ffmpeg": "0.9.4",
+    "@ffmpeg/util": "^0.12.2",
+    "@ricky0123/vad-web": "^0.0.22",
+    "@types/chrome": "^0.0.315",
+    "aws-sdk": "^2.1692.0",
+    "lamejs": "^1.2.1",
+    "uuid": "^11.1.0"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ]
+}