@eka-care/medassist-core 1.0.65 → 1.0.67

package/dist/esm/media/audio/Audio.copy.js

@@ -0,0 +1,363 @@
+import { RecordingError, SynapseError } from "../../internal/Error/Error";
+export class AudioManager {
+    mediaRecorder = null;
+    mediaStream = null;
+    recordingStartTime = 0;
+    autoPauseTimer = null;
+    config;
+    onAudioData = null;
+    onAudioError = null;
+    suppressCallbacks = false; //gurad against late recorder events like ondatavaailable after cancel () or cleanup() is called
+    constructor(config = {}) {
+        this.config = {
+            mimeType: "audio/webm;codecs=opus",
+            audioBitsPerSecond: 128000,
+            maxRecordingDuration: 900000, // 15 minutes
+            autoPauseEnabled: true,
+            ...config,
+        };
+    }
+    /**
+     * Best-effort permission check.
+     *
+     * NOTE: On some environments (especially iOS Safari / WKWebView),
+     * the Permissions API is missing or incomplete for "microphone".
+     * In those cases we **skip** the explicit check and rely on
+     * `getUserMedia` to trigger the OS permission prompt.
+     */
+    async checkCurrentPermissionState() {
+        try {
+            // Guard: Permissions API not supported or not fully implemented
+            if (typeof navigator === "undefined" ||
+                !("permissions" in navigator) ||
+                !navigator.permissions ||
+                typeof navigator.permissions.query !== "function") {
+                // Treat as "prompt" – let getUserMedia drive the permission flow.
+                return "prompt";
+            }
+            // Try to query microphone permission
+            // On iOS WebView, this may throw "query does not support this api"
+            const permission = await navigator.permissions.query({
+                name: "microphone",
+            });
+            if (permission.state === "denied") {
+                throw new RecordingError("Microphone permission denied", {
+                    context: { permissionState: permission.state },
+                    hint: "Ensure the browser or device has microphone access enabled for this site/app.",
+                });
+            }
+            return permission.state;
+        }
+        catch (error) {
+            // Some browsers (notably iOS WebKit/WKWebView) throw for unsupported permission names
+            // or return errors like "Permission :: query doesnot support" or "query does not support this api".
+            // Fall back to letting getUserMedia handle prompting.
+            const errorMessage = (error instanceof Error ? error.message : String(error)).toLowerCase();
+            if (errorMessage.includes("does not support") ||
+                errorMessage.includes("doesnot support") ||
+                errorMessage.includes("not supported") ||
+                errorMessage.includes("query does not support") ||
+                errorMessage.includes("permission::query") ||
+                errorMessage.includes("permission :: query doesnot support")) {
+                // Silently skip permission check for unsupported APIs - this is expected on iOS WebView
+                return "prompt";
+            }
+            // For other errors, log a warning but still proceed
+            console.warn("Permissions API for microphone is unavailable, falling back to getUserMedia-only flow:", error);
+            return "prompt";
+        }
+    }
+    async start(onAudioData, onAudioError //Clearly handles the error inside the callback without unhandled rejections
+    ) {
+        try {
+            // Check if mediaDevices is available
+            if (!navigator.mediaDevices) {
+                throw new RecordingError("Media devices API is not available. This usually means the page is not served over HTTPS or there are browser restrictions.", {
+                    context: { feature: "mediaDevices" },
+                    hint: "Serve the app over HTTPS and verify browser/device microphone support.",
+                    displayMessage: "Microphone access is unavailable."
+                });
+            }
+            // Check if MediaRecorder is supported
+            if (!window.MediaRecorder) {
+                throw new RecordingError("MediaRecorder is not supported in this browser", {
+                    context: { feature: "MediaRecorder" },
+                    hint: "Use a browser that supports the MediaRecorder API.",
+                    displayMessage: "Microphone access is unavailable."
+                });
+            }
+            // Check for supported audio formats in order of preference
+            const supportedTypes = [
+                "audio/mp3",
+                "audio/ogg;codecs=opus",
+                "audio/mp4",
+                "audio/ogg",
+                "audio/wav",
+            ].filter((type) => MediaRecorder.isTypeSupported(type));
+            if (supportedTypes.length === 0) {
+                throw new RecordingError("No supported audio formats found in this browser", {
+                    context: { requestedTypes: supportedTypes },
+                    hint: "Verify codec support or adjust the requested MIME types.",
+                    displayMessage: "Microphone access is unavailable."
+                });
+            }
+            // Update config with best supported mime type
+            this.config.mimeType = supportedTypes[0];
+            await this.checkCurrentPermissionState();
+            this.onAudioData = onAudioData;
+            this.onAudioError = onAudioError ?? null;
+            this.suppressCallbacks = false; //reset the guard against late recorder events
+            // Get user media with fallback for iOS WebView compatibility
+            // iOS WebView may throw "query does not support this api" for specific audio constraints
+            try {
+                this.mediaStream = await navigator.mediaDevices.getUserMedia({
+                    audio: {
+                        echoCancellation: false,
+                        noiseSuppression: false,
+                        autoGainControl: false,
+                        sampleRate: 44100,
+                        channelCount: 1,
+                    },
+                });
+            }
+            catch (constraintError) {
+                const errorMessage = (constraintError instanceof Error ? constraintError.message : String(constraintError)).toLowerCase();
+                // If the error indicates unsupported constraints (common on iOS WebView),
+                // fall back to minimal audio constraints
+                // Error formats: "Permission :: query doesnot support", "query does not support", etc.
+                if (errorMessage.includes("does not support") ||
+                    errorMessage.includes("doesnot support") ||
+                    errorMessage.includes("not supported") ||
+                    errorMessage.includes("query does not support") ||
+                    errorMessage.includes("permission :: query") ||
+                    errorMessage.includes("permission::query") ||
+                    errorMessage.includes("constraintnotsatisfiederror")) {
+                    // Fall back to simplest audio constraint for iOS WebView compatibility
+                    this.mediaStream = await navigator.mediaDevices.getUserMedia({
+                        audio: true,
+                    });
+                }
+                else {
+                    // Re-throw other errors (permission denied, etc.)
+                    if (errorMessage.includes("permission::query") || errorMessage.includes("permission :: query")) {
+                        throw new RecordingError("Microphone permission denied", {
+                            context: { permissionState: "denied" },
+                            hint: `Please grant microphone access to the website. You can change this in the browser settings.`,
+                        });
+                    }
+                    throw constraintError;
+                }
+            }
+            // Create MediaRecorder with fallback if the selected format fails
+            this.mediaRecorder = new MediaRecorder(this.mediaStream, {
+                mimeType: this.config.mimeType,
+                audioBitsPerSecond: this.config.audioBitsPerSecond,
+            });
+            // Verify MediaRecorder is in a valid state
+            if (this.mediaRecorder.state !== "inactive") {
+                throw new RecordingError("MediaRecorder is in an invalid state for start()", {
+                    context: { recorderState: this.mediaRecorder.state },
+                    displayMessage: "Failed to start recording"
+                });
+            }
+            // Set up event handlers
+            this.setupMediaRecorderEvents();
+            // Start recording
+            this.mediaRecorder.start();
+            this.recordingStartTime = Date.now();
+            // Set up auto-pause timer if enabled
+            if (this.config.autoPauseEnabled) {
+                this.setupAutoPauseTimer();
+            }
+        }
+        catch (error) {
+            throw this.toRecordingError(error, "Failed to start audio recording", {
+                stage: "start",
+            });
+        }
+    }
+    async processAudioChunk(blob) {
+        try {
+            const base64Audio = await this.blobToBase64(blob);
+            const now = Date.now();
+            if (!this.onAudioData) {
+                return;
+            }
+            const audioData = {
+                audio: base64Audio,
+                format: this.config.mimeType,
+                duration: this.recordingStartTime > 0 ? now - this.recordingStartTime : 0,
+                timestamp: this.recordingStartTime > 0 ? this.recordingStartTime : now,
+            };
+            this.onAudioData(audioData);
+        }
+        catch (error) {
+            this.handleError(error, { stage: "process_audio_chunk" });
+        }
+    }
+    toRecordingError(error, fallbackMessage, context) {
+        if (error instanceof RecordingError) {
+            return error;
+        }
+        if (error instanceof SynapseError) {
+            return new RecordingError(error.message, {
+                cause: error,
+                context: { ...error.context, ...context },
+                hint: error.hint,
+            });
+        }
+        const message = error instanceof Error && error.message ? error.message : fallbackMessage;
+        return new RecordingError(message, {
+            cause: error,
+            context,
+        });
+    }
+    handleError(error, context) {
+        const recordingError = this.toRecordingError(error, "Unexpected recording error", context);
+        if (this.onAudioError) {
+            try {
+                this.onAudioError(recordingError);
+            }
+            catch (callbackError) {
+                console.error("Audio error callback failed:", callbackError);
+            }
+        }
+        else {
+            console.error("AudioManager error:", recordingError);
+        }
+    }
+    /**
+     * Set up auto-pause timer for 15-minute limit
+     */
+    setupAutoPauseTimer() {
+        if (this.autoPauseTimer) {
+            clearTimeout(this.autoPauseTimer);
+        }
+        this.autoPauseTimer = setTimeout(() => {
+            this.stop();
+        }, this.config.maxRecordingDuration);
+    }
+    setupMediaRecorderEvents() {
+        if (!this.mediaRecorder)
+            return;
+        this.mediaRecorder.ondataavailable = (event) => {
+            if (this.suppressCallbacks || event.data.size <= 0) {
+                return;
+            }
+            this.processAudioChunk(event.data).catch((error) => this.handleError(error, {
+                stage: "media_recorder_ondataavailable",
+                hasData: event.data.size > 0,
+            }));
+        };
+        this.mediaRecorder.onstop = async () => {
+            this.recordingStartTime = 0;
+        };
+        this.mediaRecorder.onerror = (event) => {
+            this.handleError(event.error instanceof Error
+                ? event.error
+                : new Error("MediaRecorder encountered an unknown error"), { stage: "media_recorder_onerror" });
+        };
+        this.mediaRecorder.onstart = () => {
+        };
+    }
+    /**
+     * Convert blob to base64 string
+     */
+    blobToBase64(blob) {
+        return new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.onload = () => {
+                if (typeof reader.result === "string") {
+                    // Remove data URL prefix (e.g., "data:audio/mp3;base64,")
+                    const base64 = reader.result.split(",")[1];
+                    resolve(base64);
+                }
+                else {
+                    reject(new RecordingError("Failed to convert blob to base64", {
+                        context: { stage: "blob_to_base64" },
+                    }));
+                }
+            };
+            reader.onerror = () => reject(new RecordingError("FileReader error while converting audio chunk to base64", {
+                cause: reader.error ?? undefined,
+                context: { stage: "blob_to_base64" },
+            }));
+            reader.readAsDataURL(blob);
+        });
+    }
+    /**
+     * Stop recording manually
+     */
+    stop() {
+        if (!this.mediaRecorder)
+            return;
+        try {
+            // Clear auto-pause timer
+            if (this.autoPauseTimer) {
+                clearTimeout(this.autoPauseTimer);
+                this.autoPauseTimer = null;
+            }
+            // Stop MediaRecorder
+            if (this.mediaRecorder.state === "recording") {
+                this.mediaRecorder.stop();
+            }
+            // Stop media stream
+            if (this.mediaStream) {
+                this.mediaStream.getTracks().forEach((track) => track.stop());
+                this.mediaStream = null;
+            }
+        }
+        catch (error) {
+            throw this.toRecordingError(error, "Failed to stop audio recording", {
+                stage: "stop",
+            });
+        }
+    }
+    /**
+     * Cancel recording (discard data and suppress callbacks)
+     */
+    cancel() {
+        if (!this.mediaRecorder)
+            return;
+        try {
+            this.suppressCallbacks = true;
+            if (this.autoPauseTimer) {
+                clearTimeout(this.autoPauseTimer);
+                this.autoPauseTimer = null;
+            }
+            // Prevent ondataavailable from pushing chunks
+            this.mediaRecorder.ondataavailable = null;
+            // Stop MediaRecorder
+            if (this.mediaRecorder.state === "recording") {
+                this.mediaRecorder.stop();
+            }
+            // Stop media stream
+            if (this.mediaStream) {
+                this.mediaStream.getTracks().forEach((track) => track.stop());
+                this.mediaStream = null;
+            }
+        }
+        catch (error) {
+            throw this.toRecordingError(error, "Failed to cancel audio recording", {
+                stage: "cancel",
+            });
+        }
+    }
+    destroy() {
+        try {
+            this.cancel();
+            if (this.mediaRecorder) {
+                this.mediaRecorder = null;
+            }
+            if (this.mediaStream) {
+                this.mediaStream.getTracks().forEach((track) => track.stop());
+                this.mediaStream = null;
+            }
+        }
+        catch (error) {
+            throw this.toRecordingError(error, "Failed to destroy audio resources", {
+                stage: "destroy",
+            });
+        }
+    }
+}

package/dist/esm/media/audio/Audio.js

@@ -0,0 +1,310 @@
+import { RecordingError, SynapseError } from "../../internal/Error/Error";
+export class AudioManager {
+    mediaRecorder = null;
+    mediaStream = null;
+    recordingStartTime = 0;
+    autoPauseTimer = null;
+    config;
+    onAudioData = null;
+    onAudioError = null;
+    suppressCallbacks = false; //gurad against late recorder events like ondatavaailable after cancel () or cleanup() is called
+    constructor(config = {}) {
+        this.config = {
+            mimeType: "audio/webm;codecs=opus",
+            audioBitsPerSecond: 128000,
+            maxRecordingDuration: 900000, // 15 minutes
+            autoPauseEnabled: true,
+            ...config,
+        };
+    }
+    async checkCurrentPermissionState() {
+        if (!navigator.permissions || !navigator.permissions.query) {
+            return "prompt";
+        }
+        try {
+            const permission = await navigator.permissions.query({
+                name: "microphone",
+            });
+            if (permission.state === "denied") {
+                throw new RecordingError("Microphone permission denied", {
+                    context: { permissionState: permission.state },
+                    hint: "Ensure the browser has microphone access enabled for this site.",
+                });
+            }
+            return permission.state;
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === "NotSupportedError")
+                return "prompt";
+        }
+        return "prompt";
+    }
+    async start(onAudioData, onAudioError //Clearly handles the error inside the callback without unhandled rejections
+    ) {
+        try {
+            // Check if mediaDevices is available
+            if (!navigator.mediaDevices) {
+                throw new RecordingError("Media devices API is not available. This usually means the page is not served over HTTPS or there are browser restrictions.", {
+                    context: { feature: "mediaDevices" },
+                    hint: "Serve the app over HTTPS and verify browser/device microphone support.",
+                    displayMessage: "Microphone access is unavailable."
+                });
+            }
+            // Check if MediaRecorder is supported
+            if (!window.MediaRecorder) {
+                throw new RecordingError("MediaRecorder is not supported in this browser", {
+                    context: { feature: "MediaRecorder" },
+                    hint: "Use a browser that supports the MediaRecorder API.",
+                    displayMessage: "Microphone access is unavailable."
+                });
+            }
+            // Check for supported audio formats in order of preference
+            const supportedTypes = [
+                "audio/mp3",
+                "audio/ogg;codecs=opus",
+                "audio/mp4",
+                "audio/ogg",
+                "audio/wav",
+            ].filter((type) => MediaRecorder.isTypeSupported(type));
+            if (supportedTypes.length === 0) {
+                throw new RecordingError("No supported audio formats found in this browser", {
+                    context: { requestedTypes: supportedTypes },
+                    hint: "Verify codec support or adjust the requested MIME types.",
+                    displayMessage: "Microphone access is unavailable."
+                });
+            }
+            // Update config with best supported mime type
+            this.config.mimeType = supportedTypes[0];
+            await this.checkCurrentPermissionState();
+            this.onAudioData = onAudioData;
+            this.onAudioError = onAudioError ?? null;
+            this.suppressCallbacks = false; //reset the guard against late recorder events
+            // Get user media
+            this.mediaStream = await navigator.mediaDevices.getUserMedia({
+                audio: {
+                    echoCancellation: false,
+                    noiseSuppression: false,
+                    autoGainControl: false,
+                    sampleRate: 44100,
+                    channelCount: 1,
+                },
+            });
+            // Create MediaRecorder with fallback if the selected format fails
+            this.mediaRecorder = new MediaRecorder(this.mediaStream, {
+                mimeType: this.config.mimeType,
+                audioBitsPerSecond: this.config.audioBitsPerSecond,
+            });
+            // Verify MediaRecorder is in a valid state
+            if (this.mediaRecorder.state !== "inactive") {
+                throw new RecordingError("MediaRecorder is in an invalid state for start()", {
+                    context: { recorderState: this.mediaRecorder.state },
+                    displayMessage: "Failed to start recording"
+                });
+            }
+            // Set up event handlers
+            this.setupMediaRecorderEvents();
+            // Start recording
+            this.mediaRecorder.start();
+            this.recordingStartTime = Date.now();
+            // Set up auto-pause timer if enabled
+            if (this.config.autoPauseEnabled) {
+                this.setupAutoPauseTimer();
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === "NotAllowedError") {
+                throw new RecordingError("Microphone permission denied", {
+                    context: { permissionState: "denied" },
+                    hint: "Ensure the browser or device has microphone access enabled for this site/app.",
+                });
+            }
+            throw this.toRecordingError(error, "Failed to start audio recording", {
+                stage: "start",
+            });
+        }
+    }
+    async processAudioChunk(blob) {
+        try {
+            const base64Audio = await this.blobToBase64(blob);
+            const now = Date.now();
+            if (!this.onAudioData) {
+                return;
+            }
+            const audioData = {
+                audio: base64Audio,
+                format: this.config.mimeType,
+                duration: this.recordingStartTime > 0 ? now - this.recordingStartTime : 0,
+                timestamp: this.recordingStartTime > 0 ? this.recordingStartTime : now,
+            };
+            this.onAudioData(audioData);
+        }
+        catch (error) {
+            this.handleError(error, { stage: "process_audio_chunk" });
+        }
+    }
+    toRecordingError(error, fallbackMessage, context) {
+        if (error instanceof RecordingError) {
+            return error;
+        }
+        if (error instanceof SynapseError) {
+            return new RecordingError(error.message, {
+                cause: error,
+                context: { ...error.context, ...context },
+                hint: error.hint,
+            });
+        }
+        const message = error instanceof Error && error.message ? error.message : fallbackMessage;
+        return new RecordingError(message, {
+            cause: error,
+            context,
+        });
+    }
+    handleError(error, context) {
+        const recordingError = this.toRecordingError(error, "Unexpected recording error", context);
+        if (this.onAudioError) {
+            try {
+                this.onAudioError(recordingError);
+            }
+            catch (callbackError) {
+                console.error("Audio error callback failed:", callbackError);
+            }
+        }
+        else {
+            console.error("AudioManager error:", recordingError);
+        }
+    }
+    /**
+     * Set up auto-pause timer for 15-minute limit
+     */
+    setupAutoPauseTimer() {
+        if (this.autoPauseTimer) {
+            clearTimeout(this.autoPauseTimer);
+        }
+        this.autoPauseTimer = setTimeout(() => {
+            this.stop();
+        }, this.config.maxRecordingDuration);
+    }
+    setupMediaRecorderEvents() {
+        if (!this.mediaRecorder)
+            return;
+        this.mediaRecorder.ondataavailable = (event) => {
+            if (this.suppressCallbacks || event.data.size <= 0) {
+                return;
+            }
+            this.processAudioChunk(event.data).catch((error) => this.handleError(error, {
+                stage: "media_recorder_ondataavailable",
+                hasData: event.data.size > 0,
+            }));
+        };
+        this.mediaRecorder.onstop = async () => {
+            this.recordingStartTime = 0;
+        };
+        this.mediaRecorder.onerror = (event) => {
+            this.handleError(event.error instanceof Error
+                ? event.error
+                : new Error("MediaRecorder encountered an unknown error"), { stage: "media_recorder_onerror" });
+        };
+        this.mediaRecorder.onstart = () => {
+        };
+    }
+    /**
+     * Convert blob to base64 string
+     */
+    blobToBase64(blob) {
+        return new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.onload = () => {
+                if (typeof reader.result === "string") {
+                    // Remove data URL prefix (e.g., "data:audio/mp3;base64,")
+                    const base64 = reader.result.split(",")[1];
+                    resolve(base64);
+                }
+                else {
+                    reject(new RecordingError("Failed to convert blob to base64", {
+                        context: { stage: "blob_to_base64" },
+                    }));
+                }
+            };
+            reader.onerror = () => reject(new RecordingError("FileReader error while converting audio chunk to base64", {
+                cause: reader.error ?? undefined,
+                context: { stage: "blob_to_base64" },
+            }));
+            reader.readAsDataURL(blob);
+        });
+    }
+    /**
+     * Stop recording manually
+     */
+    stop() {
+        if (!this.mediaRecorder)
+            return;
+        try {
+            // Clear auto-pause timer
+            if (this.autoPauseTimer) {
+                clearTimeout(this.autoPauseTimer);
+                this.autoPauseTimer = null;
+            }
+            // Stop MediaRecorder
+            if (this.mediaRecorder.state === "recording") {
+                this.mediaRecorder.stop();
+            }
+            // Stop media stream
+            if (this.mediaStream) {
+                this.mediaStream.getTracks().forEach((track) => track.stop());
+                this.mediaStream = null;
+            }
+        }
+        catch (error) {
+            throw this.toRecordingError(error, "Failed to stop audio recording", {
+                stage: "stop",
+            });
+        }
+    }
+    /**
+     * Cancel recording (discard data and suppress callbacks)
+     */
+    cancel() {
+        if (!this.mediaRecorder)
+            return;
+        try {
+            this.suppressCallbacks = true;
+            if (this.autoPauseTimer) {
+                clearTimeout(this.autoPauseTimer);
+                this.autoPauseTimer = null;
+            }
+            // Prevent ondataavailable from pushing chunks
+            this.mediaRecorder.ondataavailable = null;
+            // Stop MediaRecorder
+            if (this.mediaRecorder.state === "recording") {
+                this.mediaRecorder.stop();
+            }
+            // Stop media stream
+            if (this.mediaStream) {
+                this.mediaStream.getTracks().forEach((track) => track.stop());
+                this.mediaStream = null;
+            }
+        }
+        catch (error) {
+            throw this.toRecordingError(error, "Failed to cancel audio recording", {
+                stage: "cancel",
+            });
+        }
+    }
+    destroy() {
+        try {
+            this.cancel();
+            if (this.mediaRecorder) {
+                this.mediaRecorder = null;
+            }
+            if (this.mediaStream) {
+                this.mediaStream.getTracks().forEach((track) => track.stop());
+                this.mediaStream = null;
+            }
+        }
+        catch (error) {
+            throw this.toRecordingError(error, "Failed to destroy audio resources", {
+                stage: "destroy",
+            });
+        }
+    }
+}

package/dist/esm/media/audio/types.js

@@ -0,0 +1,13 @@
+export {};
+// export const AudioRecordingStatus = {
+//   IDLE: "idle",
+//   LISTENING: "listening",
+//   ERROR: "error",
+//   PROCESSING: "processing",
+//   TRANSCRIBING: "transcribing",
+// } as const;
+// export type AudioRecordingStatus =
+//   (typeof AudioRecordingStatus)[keyof typeof AudioRecordingStatus];
+// export type AudioRecordingStatusCallback = (
+//   status: AudioRecordingStatus
+// ) => void;