@eka-care/ekascribe-ts-sdk 1.4.39

package/dist/api/post-cog-init.d.ts

@@ -0,0 +1,3 @@
+import { TPostCogResponse } from '../constants/types';
+declare function postCogInit(): Promise<TPostCogResponse>;
+export default postCogInit;

package/dist/api/post-cog-init.js

@@ -0,0 +1,15 @@
+import fetchWrapper from '../fetch-client';
+async function postCogInit() {
+    try {
+        const options = {
+            method: 'GET',
+        };
+        const respJson = await fetchWrapper(`https://cog.eka.care/credentials`, options);
+        const resp = await respJson.json();
+        return resp;
+    }
+    catch (error) {
+        throw error;
+    }
+}
+export default postCogInit;

package/dist/api/post-transaction-commit.d.ts

@@ -0,0 +1,3 @@
+import { TPostTransactionCommitRequest, TPostTransactionResponse } from '../constants/types';
+declare function postTransactionCommit({ audioFiles, txnId, }: TPostTransactionCommitRequest): Promise<TPostTransactionResponse>;
+export default postTransactionCommit;

package/dist/api/post-transaction-commit.js

@@ -0,0 +1,32 @@
+import { SDK_STATUS_CODE } from '../constants/constant';
+import fetchWrapper from '../fetch-client';
+import { GET_EKA_V2RX_HOST_V2 } from '../fetch-client/helper';
+async function postTransactionCommit({ audioFiles, txnId, }) {
+    try {
+        const headers = new Headers();
+        headers.append('Content-Type', 'application/json');
+        const raw = {
+            audio_files: audioFiles,
+        };
+        const options = {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(raw),
+        };
+        const response = await fetchWrapper(`${GET_EKA_V2RX_HOST_V2()}/transaction/commit/${txnId}`, options);
+        let res = await response.json();
+        res = {
+            ...res,
+            code: response.status,
+        };
+        return res;
+    }
+    catch (error) {
+        console.log('%c Line:52 🥖 postTransactionInit -> error', 'color:#f5ce50', error);
+        return {
+            code: SDK_STATUS_CODE.INTERNAL_SERVER_ERROR,
+            message: `Something went wrong! ${error}`,
+        };
+    }
+}
+export default postTransactionCommit;

package/dist/api/post-transaction-init.d.ts

@@ -0,0 +1,3 @@
+import { TPostTransactionInitRequest, TPostTransactionResponse } from '../constants/types';
+declare function postTransactionInit({ mode, txnId, s3Url, input_language, output_format_template, model_training_consent, auto_download, transfer, system_info, patient_details, }: TPostTransactionInitRequest): Promise<TPostTransactionResponse>;
+export default postTransactionInit;

package/dist/api/post-transaction-init.js

@@ -0,0 +1,40 @@
+import { SDK_STATUS_CODE } from '../constants/constant';
+import fetchWrapper from '../fetch-client';
+import { GET_EKA_V2RX_HOST_V2 } from '../fetch-client/helper';
+async function postTransactionInit({ mode, txnId, s3Url, input_language, output_format_template, model_training_consent, auto_download, transfer, system_info, patient_details, }) {
+    try {
+        const headers = new Headers();
+        headers.append('Content-Type', 'application/json');
+        const raw = {
+            mode,
+            s3_url: s3Url,
+            input_language,
+            output_format_template,
+            model_training_consent,
+            auto_download,
+            transfer,
+            system_info,
+            patient_details,
+        };
+        const options = {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(raw),
+        };
+        const response = await fetchWrapper(`${GET_EKA_V2RX_HOST_V2()}/transaction/init/${txnId}`, options);
+        let res = await response.json();
+        res = {
+            ...res,
+            code: response.status,
+        };
+        return res;
+    }
+    catch (error) {
+        console.log('%c Line:52 🥖 postTransactionInit -> error', 'color:#f5ce50', error);
+        return {
+            code: SDK_STATUS_CODE.INTERNAL_SERVER_ERROR,
+            message: `Something went wrong! ${error}`,
+        };
+    }
+}
+export default postTransactionInit;

package/dist/api/post-transaction-stop.d.ts

@@ -0,0 +1,3 @@
+import { TPostTransactionCommitRequest, TPostTransactionResponse } from '../constants/types';
+declare function postTransactionStop({ txnId, audioFiles, }: TPostTransactionCommitRequest): Promise<TPostTransactionResponse>;
+export default postTransactionStop;

package/dist/api/post-transaction-stop.js

@@ -0,0 +1,32 @@
+import { SDK_STATUS_CODE } from '../constants/constant';
+import fetchWrapper from '../fetch-client';
+import { GET_EKA_V2RX_HOST_V2 } from '../fetch-client/helper';
+async function postTransactionStop({ txnId, audioFiles, }) {
+    try {
+        const headers = new Headers();
+        headers.append('Content-Type', 'application/json');
+        const raw = {
+            audio_files: audioFiles,
+        };
+        const options = {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(raw),
+        };
+        const response = await fetchWrapper(`${GET_EKA_V2RX_HOST_V2()}/transaction/stop/${txnId}`, options);
+        let res = await response.json();
+        res = {
+            ...res,
+            code: response.status,
+        };
+        return res;
+    }
+    catch (error) {
+        console.log('%c Line:52 🥖 postTransactionInit -> error', 'color:#f5ce50', error);
+        return {
+            code: SDK_STATUS_CODE.INTERNAL_SERVER_ERROR,
+            message: `Something went wrong! ${error}`,
+        };
+    }
+}
+export default postTransactionStop;

package/dist/audio-chunker/__tests__/audio-file-manager.test.d.ts

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

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

@@ -0,0 +1,5 @@
+describe('AudioFileManager', () => {
+    let audioFileManager;
+    test('', () => { });
+});
+export {};

package/dist/audio-chunker/audio-buffer-manager.d.ts

@@ -0,0 +1,53 @@
+declare class AudioBufferManager {
+    private buffer;
+    private currentSampleLength;
+    private currentFrameLength;
+    private samplingRate;
+    private incrementalAllocationSize;
+    /**
+     * Class that creates an audio buffer to store frame data
+     * @param samplingRate - The sampling rate of the audio in Hz
+     * @param allocationTimeInSeconds - The size of each incremental allocation in seconds
+     */
+    constructor(samplingRate: number, allocationTimeInSeconds: number);
+    /**
+     * Append audio frame to the buffer
+     * @param audioFrame - Float32Array containing audio samples to append
+     * @returns The current position in the buffer after appending
+     */
+    append(audioFrame: Float32Array): number;
+    /**
+     * Get the current audio data as a Float32Array
+     */
+    getAudioData(): Float32Array;
+    /**
+     * Get the current length of audio data in samples
+     * @returns The number of samples currently in the buffer
+     */
+    getCurrentSampleLength(): number;
+    /**
+     * Get the current length of audio data in samples
+     * @returns The number of samples currently in the buffer
+     */
+    getCurrentFrameLength(): number;
+    /**
+     * Get the current length of audio data in seconds
+     * @returns The duration of audio currently in the buffer in seconds
+     */
+    getDurationInSeconds(): number;
+    /**
+     * Expand the buffer by allocating a new block of memory
+     * @private
+     */
+    private expandBuffer;
+    /**
+     * Calculate timestamps for an audio chunk
+     */
+    calculateChunkTimestamps(rawSamplesLength: number): {
+        start: string;
+        end: string;
+    };
+    resetBufferState(): void;
+    resetBufferManagerInstance(): void;
+}
+export default AudioBufferManager;

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

@@ -0,0 +1,136 @@
+import { SAMPLING_RATE } from '../constants/constant';
+class AudioBufferManager {
+    /**
+     * Class that creates an audio buffer to store frame data
+     * @param samplingRate - The sampling rate of the audio in Hz
+     * @param allocationTimeInSeconds - The size of each incremental allocation in seconds
+     */
+    constructor(samplingRate, allocationTimeInSeconds) {
+        Object.defineProperty(this, "buffer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "currentSampleLength", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "currentFrameLength", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "samplingRate", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "incrementalAllocationSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        this.samplingRate = samplingRate;
+        // Calculate the size of each incremental allocation in samples
+        this.incrementalAllocationSize = Math.floor(samplingRate * allocationTimeInSeconds);
+        // Initialize buffer with the first allocation block
+        this.buffer = new Float32Array(this.incrementalAllocationSize);
+        this.currentSampleLength = 0;
+    }
+    /**
+     * Append audio frame to the buffer
+     * @param audioFrame - Float32Array containing audio samples to append
+     * @returns The current position in the buffer after appending
+     */
+    append(audioFrame) {
+        // Check if we need to allocate more memory
+        if (this.currentSampleLength + audioFrame.length > this.buffer.length) {
+            this.expandBuffer();
+        }
+        // Copy the new frame into the buffer
+        this.buffer.set(audioFrame, this.currentSampleLength);
+        this.currentSampleLength += audioFrame.length; // for 1 frame increase by 1024
+        this.currentFrameLength += 1; // for 1 frame increase by 1
+        return this.currentSampleLength;
+    }
+    /**
+     * Get the current audio data as a Float32Array
+     */
+    getAudioData() {
+        return this.buffer.slice(0, this.currentSampleLength);
+    }
+    /**
+     * Get the current length of audio data in samples
+     * @returns The number of samples currently in the buffer
+     */
+    getCurrentSampleLength() {
+        return this.currentSampleLength;
+    }
+    /**
+     * Get the current length of audio data in samples
+     * @returns The number of samples currently in the buffer
+     */
+    getCurrentFrameLength() {
+        return this.currentFrameLength;
+    }
+    /**
+     * Get the current length of audio data in seconds
+     * @returns The duration of audio currently in the buffer in seconds
+     */
+    getDurationInSeconds() {
+        return this.currentSampleLength / this.samplingRate;
+    }
+    /**
+     * Expand the buffer by allocating a new block of memory
+     * @private
+     */
+    expandBuffer() {
+        const newSize = this.buffer.length + this.incrementalAllocationSize;
+        const newBuffer = new Float32Array(newSize);
+        // Copy existing data to the new buffer
+        newBuffer.set(this.buffer, 0);
+        // Replace old buffer with new one
+        this.buffer = newBuffer;
+    }
+    /**
+     * Calculate timestamps for an audio chunk
+     */
+    calculateChunkTimestamps(rawSamplesLength) {
+        const start = rawSamplesLength / SAMPLING_RATE - this.getDurationInSeconds();
+        const end = start + this.getDurationInSeconds();
+        // Format start time as MM:SS.ffffff
+        const startMinutes = Math.floor(start / 60)
+            .toString()
+            .padStart(2, '0');
+        const startSeconds = (start % 60).toFixed(6).toString().padStart(2, '0');
+        const formattedStartTime = `${startMinutes}:${startSeconds}`;
+        // Format end time as MM:SS.ffffff
+        const endMinutes = Math.floor(end / 60)
+            .toString()
+            .padStart(2, '0');
+        const endSeconds = (end % 60).toFixed(6).toString().padStart(2, '0');
+        const formattedEndTime = `${endMinutes}:${endSeconds}`;
+        // Return timestamp object
+        return {
+            start: formattedStartTime,
+            end: formattedEndTime,
+        };
+    }
+    resetBufferState() {
+        // Zero out the existing buffer instead of allocating new memory
+        this.currentSampleLength = 0;
+        this.currentFrameLength = 0;
+    }
+    resetBufferManagerInstance() {
+        this.buffer = new Float32Array(this.incrementalAllocationSize);
+        this.currentSampleLength = 0;
+        this.currentFrameLength = 0;
+    }
+}
+export default AudioBufferManager;

package/dist/audio-chunker/audio-file-manager.d.ts

@@ -0,0 +1,96 @@
+import { TAudioChunksInfo, TFileUploadProgressCallback } from '../constants/types';
+type TUploadAudioChunkParams = {
+    audioFrames: Float32Array;
+    fileName: string;
+    chunkIndex: number;
+};
+declare class AudioFileManager {
+    /**
+     * Class that handles uploading audio files to S3
+     * and downloading audio files for debugging
+     */
+    private txnID;
+    private filePath;
+    audioChunks: TAudioChunksInfo[];
+    private uploadPromises;
+    private successfulUploads;
+    private onProgressCallback?;
+    private totalRawSamples;
+    private totalRawFrames;
+    private totalInsertedSamples;
+    private totalInsertedFrames;
+    private businessID;
+    private isAWSConfigured;
+    private sharedWorkerInstance;
+    initialiseClassInstance(): void;
+    constructor();
+    /**
+     * Set basic file information
+     */
+    setSessionInfo({ sessionId, filePath, businessID, }: {
+        filePath: string;
+        businessID: string;
+        sessionId: string;
+    }): void;
+    getRawSampleDetails(): {
+        totalRawSamples: number;
+        totalRawFrames: number;
+    };
+    incrementTotalRawSamples(frames: Float32Array): void;
+    incrementInsertedSamples(samples: number, frames: number): void;
+    getInsertedSampleDetails(): {
+        totalInsertedSamples: number;
+        totalInsertedFrames: number;
+    };
+    /**
+     * Set callback for upload progress updates
+     */
+    setProgressCallback(callback: TFileUploadProgressCallback): void;
+    /**
+     * Update audio information array, this will update the audio chunks info
+     * (+ the latest chunk , affects the length of chunks data struct)
+     */
+    updateAudioInfo(audioChunks: TAudioChunksInfo): number;
+    createSharedWorkerInstance(): boolean;
+    private setupAWSConfiguration;
+    /**
+     * Upload a chunk of audio data to S3 in main thread
+     */
+    private uploadAudioChunkInMain;
+    /**
+     * Upload audio chunks to S3 in shared worker
+     */
+    private uploadAudioChunkInWorker;
+    uploadAudioToS3({ audioFrames, fileName, chunkIndex }: TUploadAudioChunkParams): Promise<void>;
+    private uploadAudioToS3WithWorker;
+    private uploadAudioToS3WithoutWorker;
+    /**
+     * Download audio as a file to the user's device (for debugging)
+     */
+    downloadAudio(audioBlob: Blob, fileName: string): void;
+    /**
+     * Wait for all upload promises to complete
+     */
+    waitForAllUploads(): Promise<void>;
+    /**
+     * Get list of successfully uploaded files
+     */
+    getSuccessfulUploads(): string[];
+    /**
+     * Get list of all failed files
+     */
+    getFailedUploads(): string[];
+    /**
+     * Get list of all audio chunks
+     */
+    getTotalAudioChunks(): TAudioChunksInfo[];
+    /**
+     * Retry uploading failed files
+     */
+    retryFailedUploads(): Promise<string[]>;
+    /**
+     * Reset the upload state
+     */
+    resetFileManagerInstance(): void;
+}
+export default AudioFileManager;