cuoral-ionic 0.0.1

package/dist/index.js

@@ -0,0 +1,825 @@
+'use strict';
+
+var core = require('@capacitor/core');
+
+/**
+ * Message types for communication between WebView and Native code
+ */
+exports.CuoralMessageType = void 0;
+(function (CuoralMessageType) {
+    // Screen Recording
+    CuoralMessageType["START_RECORDING"] = "CUORAL_START_RECORDING";
+    CuoralMessageType["STOP_RECORDING"] = "CUORAL_STOP_RECORDING";
+    CuoralMessageType["RECORDING_STARTED"] = "CUORAL_RECORDING_STARTED";
+    CuoralMessageType["RECORDING_STOPPED"] = "CUORAL_RECORDING_STOPPED";
+    CuoralMessageType["RECORDING_ERROR"] = "CUORAL_RECORDING_ERROR";
+    // Screenshot
+    CuoralMessageType["TAKE_SCREENSHOT"] = "CUORAL_TAKE_SCREENSHOT";
+    CuoralMessageType["SCREENSHOT_TAKEN"] = "CUORAL_SCREENSHOT_TAKEN";
+    CuoralMessageType["SCREENSHOT_ERROR"] = "CUORAL_SCREENSHOT_ERROR";
+    // Widget Communication
+    CuoralMessageType["WIDGET_READY"] = "CUORAL_WIDGET_READY";
+    CuoralMessageType["WIDGET_CLOSED"] = "CUORAL_WIDGET_CLOSED";
+    // File Upload
+    CuoralMessageType["UPLOAD_FILE"] = "CUORAL_UPLOAD_FILE";
+    CuoralMessageType["UPLOAD_PROGRESS"] = "CUORAL_UPLOAD_PROGRESS";
+    CuoralMessageType["UPLOAD_COMPLETE"] = "CUORAL_UPLOAD_COMPLETE";
+    CuoralMessageType["UPLOAD_ERROR"] = "CUORAL_UPLOAD_ERROR";
+})(exports.CuoralMessageType || (exports.CuoralMessageType = {}));
+
+/**
+ * Register the Capacitor plugin
+ */
+const CuoralPlugin = core.registerPlugin('CuoralPlugin', {
+    web: () => Promise.resolve().then(function () { return web; }).then(m => new m.CuoralPluginWeb()),
+});
+/**
+ * High-level API for easier integration
+ */
+class CuoralRecorder {
+    constructor() {
+        this.isRecording = false;
+    }
+    /**
+     * Start recording with automatic permission handling
+     */
+    async startRecording(options) {
+        try {
+            // Check if already recording
+            if (this.isRecording) {
+                console.warn('[Cuoral] Already recording');
+                return false;
+            }
+            // Check support
+            const { supported } = await CuoralPlugin.isRecordingSupported();
+            if (!supported) {
+                throw new Error('Screen recording is not supported on this device');
+            }
+            // Request permissions
+            const { granted } = await CuoralPlugin.requestPermissions();
+            if (!granted) {
+                throw new Error('Recording permissions not granted');
+            }
+            // Start recording
+            const result = await CuoralPlugin.startRecording(options);
+            if (result.success) {
+                this.isRecording = true;
+                this.recordingStartTime = Date.now();
+                // Post message to widget
+                this.postMessage({
+                    type: exports.CuoralMessageType.RECORDING_STARTED,
+                    payload: { timestamp: this.recordingStartTime },
+                });
+            }
+            return result.success;
+        }
+        catch (error) {
+            console.error('[Cuoral] Failed to start recording:', error);
+            this.postMessage({
+                type: exports.CuoralMessageType.RECORDING_ERROR,
+                payload: { error: error.message },
+            });
+            return false;
+        }
+    }
+    /**
+     * Stop recording
+     */
+    async stopRecording() {
+        try {
+            if (!this.isRecording) {
+                console.warn('[Cuoral] Not recording');
+                return null;
+            }
+            const result = await CuoralPlugin.stopRecording();
+            if (result.success) {
+                this.isRecording = false;
+                const duration = this.recordingStartTime
+                    ? Math.floor((Date.now() - this.recordingStartTime) / 1000)
+                    : 0;
+                // Post message to widget
+                this.postMessage({
+                    type: exports.CuoralMessageType.RECORDING_STOPPED,
+                    payload: {
+                        filePath: result.filePath,
+                        duration: result.duration || duration,
+                    },
+                });
+                return {
+                    filePath: result.filePath,
+                    duration: result.duration || duration,
+                };
+            }
+            return null;
+        }
+        catch (error) {
+            console.error('[Cuoral] Failed to stop recording:', error);
+            this.postMessage({
+                type: exports.CuoralMessageType.RECORDING_ERROR,
+                payload: { error: error.message },
+            });
+            return null;
+        }
+    }
+    /**
+     * Take screenshot
+     */
+    async takeScreenshot(options) {
+        try {
+            const screenshot = await CuoralPlugin.takeScreenshot(options);
+            // Post message to widget
+            this.postMessage({
+                type: exports.CuoralMessageType.SCREENSHOT_TAKEN,
+                payload: screenshot,
+            });
+            return screenshot;
+        }
+        catch (error) {
+            console.error('[Cuoral] Failed to take screenshot:', error);
+            this.postMessage({
+                type: exports.CuoralMessageType.SCREENSHOT_ERROR,
+                payload: { error: error.message },
+            });
+            return null;
+        }
+    }
+    /**
+     * Get current recording state
+     */
+    async getState() {
+        return await CuoralPlugin.getRecordingState();
+    }
+    /**
+     * Post message to WebView
+     */
+    postMessage(message) {
+        if (typeof window !== 'undefined' && window.postMessage) {
+            window.postMessage(message, '*');
+        }
+    }
+}
+
+/**
+ * Bridge for bidirectional communication between WebView and Native code
+ */
+class CuoralBridge {
+    constructor(config) {
+        this.messageHandlers = new Map();
+        this.isInitialized = false;
+        this.widgetIframe = null;
+        this.config = config;
+        this.setupMessageListener();
+    }
+    /**
+     * Initialize the bridge
+     */
+    initialize() {
+        if (this.isInitialized) {
+            this.log('Bridge already initialized');
+            return;
+        }
+        this.isInitialized = true;
+        this.log('Bridge initialized');
+        // Notify widget that bridge is ready
+        this.sendToWidget({
+            type: exports.CuoralMessageType.WIDGET_READY,
+            timestamp: Date.now(),
+        });
+    }
+    /**
+     * Send message to native code
+     */
+    sendToNative(message) {
+        if (!message.timestamp) {
+            message.timestamp = Date.now();
+        }
+        this.log('Sending to native:', message);
+        // For Capacitor - use window.postMessage
+        if (window.webkit?.messageHandlers?.cuoral) {
+            // iOS WKWebView
+            window.webkit.messageHandlers.cuoral.postMessage(message);
+        }
+        else if (window.CuoralAndroid) {
+            // Android JavascriptInterface
+            window.CuoralAndroid.postMessage(JSON.stringify(message));
+        }
+        else {
+            // Fallback - use postMessage for any other WebView
+            window.postMessage(message, '*');
+        }
+    }
+    /**
+     * Send message to widget iframe
+     */
+    sendToWidget(message) {
+        if (!message.timestamp) {
+            message.timestamp = Date.now();
+        }
+        this.log('Sending to widget:', message);
+        // Find the iframe element
+        const iframe = document.getElementById('cuoral-widget-iframe');
+        if (iframe?.contentWindow) {
+            try {
+                // Use postMessage for cross-origin communication
+                iframe.contentWindow.postMessage(message, '*');
+                this.log('Message sent via postMessage');
+                return;
+            }
+            catch (error) {
+                this.log('Error using postMessage:', error);
+            }
+        }
+        else {
+            this.log('Iframe not found or not ready');
+        }
+        // Fallback: Use localStorage for same-origin
+        try {
+            const storageKey = `cuoral_message_${Date.now()}`;
+            localStorage.setItem(storageKey, JSON.stringify(message));
+            // Clean up after 5 seconds
+            setTimeout(() => {
+                localStorage.removeItem(storageKey);
+            }, 5000);
+            // Trigger a storage event by updating a counter
+            const counter = parseInt(localStorage.getItem('cuoral_message_counter') || '0');
+            localStorage.setItem('cuoral_message_counter', (counter + 1).toString());
+        }
+        catch (error) {
+            this.log('Error using localStorage:', error);
+        }
+    }
+    /**
+     * Register message handler
+     */
+    on(type, handler) {
+        if (!this.messageHandlers.has(type)) {
+            this.messageHandlers.set(type, []);
+        }
+        const handlers = this.messageHandlers.get(type);
+        handlers.push(handler);
+        this.log(`Registered handler for ${type}`);
+        // Return unsubscribe function
+        return () => {
+            const index = handlers.indexOf(handler);
+            if (index > -1) {
+                handlers.splice(index, 1);
+            }
+        };
+    }
+    /**
+     * Setup window message listener
+     */
+    setupMessageListener() {
+        window.addEventListener('message', (event) => {
+            // Only process messages FROM the iframe
+            const widgetFrame = document.querySelector('iframe[src*="mobile.html"]');
+            if (widgetFrame && event.source === widgetFrame.contentWindow) {
+                this.widgetIframe = widgetFrame;
+            }
+            else if (widgetFrame) {
+                return;
+            }
+            // Validate message structure
+            if (!event.data || !event.data.type) {
+                return;
+            }
+            const message = event.data;
+            // Check if it's a Cuoral message
+            if (!Object.values(exports.CuoralMessageType).includes(message.type)) {
+                return;
+            }
+            this.log('Cuoral message received:', message);
+            // Call custom handler if provided
+            if (this.config.onMessage) {
+                this.config.onMessage(message);
+            }
+            // Call registered handlers
+            const handlers = this.messageHandlers.get(message.type);
+            if (handlers) {
+                handlers.forEach(handler => handler(message.payload));
+            }
+        });
+    }
+    /**
+     * Debug logging
+     */
+    log(...args) {
+        if (this.config.debug) {
+            console.log('[CuoralBridge]', ...args);
+        }
+    }
+    /**
+     * Destroy the bridge
+     */
+    destroy() {
+        this.messageHandlers.clear();
+        this.isInitialized = false;
+        this.log('Bridge destroyed');
+    }
+}
+
+/**
+ * Cuoral Modal Manager
+ * Handles full-screen modal display with floating button
+ */
+class CuoralModal {
+    constructor(widgetUrl, showFloatingButton = true) {
+        this.isOpen = false;
+        this.widgetUrl = widgetUrl;
+        this.showFloatingButton = showFloatingButton;
+    }
+    /**
+     * Initialize the modal and floating button
+     */
+    initialize() {
+        if (this.showFloatingButton) {
+            this.createFloatingButton();
+        }
+        this.createModal();
+    }
+    /**
+     * Create floating chat button
+     */
+    createFloatingButton() {
+        this.floatingButton = document.createElement('div');
+        this.floatingButton.id = 'cuoral-floating-button';
+        this.floatingButton.innerHTML = `
+      <svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+        <path d="M20 2H4C2.9 2 2 2.9 2 4V22L6 18H20C21.1 18 22 17.1 22 16V4C22 2.9 21.1 2 20 2ZM20 16H6L4 18V4H20V16Z" fill="white"/>
+      </svg>
+    `;
+        // Styles
+        Object.assign(this.floatingButton.style, {
+            position: 'fixed',
+            bottom: '20px',
+            right: '20px',
+            width: '56px',
+            height: '56px',
+            borderRadius: '50%',
+            backgroundColor: '#007AFF',
+            display: 'flex',
+            alignItems: 'center',
+            justifyContent: 'center',
+            cursor: 'pointer',
+            boxShadow: '0 4px 12px rgba(0, 122, 255, 0.4)',
+            zIndex: '999999',
+            transition: 'transform 0.2s, box-shadow 0.2s'
+        });
+        // Hover effect
+        this.floatingButton.addEventListener('mouseenter', () => {
+            if (this.floatingButton) {
+                this.floatingButton.style.transform = 'scale(1.1)';
+                this.floatingButton.style.boxShadow = '0 6px 16px rgba(0, 122, 255, 0.5)';
+            }
+        });
+        this.floatingButton.addEventListener('mouseleave', () => {
+            if (this.floatingButton) {
+                this.floatingButton.style.transform = 'scale(1)';
+                this.floatingButton.style.boxShadow = '0 4px 12px rgba(0, 122, 255, 0.4)';
+            }
+        });
+        // Click to open modal
+        this.floatingButton.addEventListener('click', () => {
+            this.open();
+        });
+        document.body.appendChild(this.floatingButton);
+    }
+    /**
+     * Create modal structure
+     */
+    createModal() {
+        // Modal container
+        this.modalElement = document.createElement('div');
+        this.modalElement.id = 'cuoral-modal';
+        Object.assign(this.modalElement.style, {
+            position: 'fixed',
+            top: '0',
+            left: '0',
+            width: '100%',
+            height: '100%',
+            backgroundColor: 'rgba(0, 0, 0, 0.5)',
+            display: 'none',
+            alignItems: 'center',
+            justifyContent: 'center',
+            zIndex: '1000000',
+            opacity: '0',
+            transition: 'opacity 0.3s ease',
+            padding: '60px 0'
+        });
+        // Modal content (with margin)
+        const modalContent = document.createElement('div');
+        Object.assign(modalContent.style, {
+            width: '100%',
+            height: '100%',
+            maxWidth: '100%',
+            maxHeight: '100%',
+            position: 'relative',
+            backgroundColor: 'transparent',
+            display: 'flex',
+            flexDirection: 'column',
+            borderRadius: '12px',
+            overflow: 'hidden'
+        });
+        // Close button
+        const closeButton = document.createElement('div');
+        closeButton.innerHTML = `
+      <svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+        <path d="M18 6L6 18M6 6L18 18" stroke="white" stroke-width="2" stroke-linecap="round"/>
+      </svg>
+    `;
+        Object.assign(closeButton.style, {
+            position: 'absolute',
+            top: '20px',
+            right: '20px',
+            width: '40px',
+            height: '40px',
+            borderRadius: '50%',
+            backgroundColor: 'rgba(0, 0, 0, 0.5)',
+            display: 'flex',
+            alignItems: 'center',
+            justifyContent: 'center',
+            cursor: 'pointer',
+            zIndex: '1000001',
+            transition: 'background-color 0.2s'
+        });
+        closeButton.addEventListener('mouseenter', () => {
+            closeButton.style.backgroundColor = 'rgba(0, 0, 0, 0.7)';
+        });
+        closeButton.addEventListener('mouseleave', () => {
+            closeButton.style.backgroundColor = 'rgba(0, 0, 0, 0.5)';
+        });
+        closeButton.addEventListener('click', () => {
+            this.close();
+        });
+        // Iframe
+        this.iframeElement = document.createElement('iframe');
+        this.iframeElement.id = 'cuoral-widget-iframe';
+        this.iframeElement.src = this.widgetUrl;
+        Object.assign(this.iframeElement.style, {
+            width: '100%',
+            height: '100%',
+            border: 'none',
+            backgroundColor: 'white'
+        });
+        modalContent.appendChild(closeButton);
+        modalContent.appendChild(this.iframeElement);
+        this.modalElement.appendChild(modalContent);
+        // Close on backdrop click
+        this.modalElement.addEventListener('click', (e) => {
+            if (e.target === this.modalElement) {
+                this.close();
+            }
+        });
+        document.body.appendChild(this.modalElement);
+    }
+    /**
+     * Open the modal
+     */
+    open() {
+        if (this.isOpen || !this.modalElement)
+            return;
+        this.isOpen = true;
+        this.modalElement.style.display = 'flex';
+        // Trigger animation
+        setTimeout(() => {
+            if (this.modalElement) {
+                this.modalElement.style.opacity = '1';
+            }
+        }, 10);
+        // Hide floating button when modal is open
+        if (this.floatingButton) {
+            this.floatingButton.style.display = 'none';
+        }
+        // Prevent body scroll
+        document.body.style.overflow = 'hidden';
+    }
+    /**
+     * Close the modal
+     */
+    close() {
+        if (!this.isOpen || !this.modalElement)
+            return;
+        this.isOpen = false;
+        this.modalElement.style.opacity = '0';
+        setTimeout(() => {
+            if (this.modalElement) {
+                this.modalElement.style.display = 'none';
+            }
+            // Show floating button again
+            if (this.floatingButton) {
+                this.floatingButton.style.display = 'flex';
+            }
+            // Restore body scroll
+            document.body.style.overflow = '';
+        }, 300);
+    }
+    /**
+     * Check if modal is open
+     */
+    isModalOpen() {
+        return this.isOpen;
+    }
+    /**
+     * Destroy modal and floating button
+     */
+    destroy() {
+        if (this.modalElement) {
+            this.modalElement.remove();
+        }
+        if (this.floatingButton) {
+            this.floatingButton.remove();
+        }
+        document.body.style.overflow = '';
+    }
+    /**
+     * Get iframe element for communication
+     */
+    getIframe() {
+        return this.iframeElement;
+    }
+}
+
+/**
+ * Main Cuoral class - simple API for users
+ */
+class Cuoral {
+    constructor(options) {
+        this.options = {
+            showFloatingButton: true,
+            useModal: true,
+            ...options
+        };
+        // Determine widget base URL
+        const baseUrl = options.widgetBaseUrl || Cuoral.PRODUCTION_WIDGET_URL;
+        const params = new URLSearchParams({
+            auto_start: 'true',
+            key: options.publicKey,
+            _t: Date.now().toString(),
+        });
+        if (options.email)
+            params.set('email', options.email);
+        if (options.firstName)
+            params.set('first_name', options.firstName);
+        if (options.lastName)
+            params.set('last_name', options.lastName);
+        const widgetUrl = `${baseUrl}?${params.toString()}`;
+        // Initialize modal if enabled
+        if (this.options.useModal) {
+            this.modal = new CuoralModal(widgetUrl, this.options.showFloatingButton);
+        }
+        // Initialize bridge and recorder
+        this.bridge = new CuoralBridge({
+            widgetUrl,
+            debug: options.debug || false
+        });
+        this.recorder = new CuoralRecorder();
+        // Setup automatic message handlers
+        this.setupMessageHandlers();
+    }
+    /**
+     * Initialize Cuoral
+     */
+    initialize() {
+        this.bridge.initialize();
+        // Initialize modal if enabled
+        if (this.modal) {
+            this.modal.initialize();
+        }
+    }
+    /**
+     * Open the widget modal
+     */
+    openModal() {
+        if (this.modal) {
+            this.modal.open();
+        }
+    }
+    /**
+     * Close the widget modal
+     */
+    closeModal() {
+        if (this.modal) {
+            this.modal.close();
+        }
+    }
+    /**
+     * Check if modal is open
+     */
+    isModalOpen() {
+        return this.modal?.isModalOpen() || false;
+    }
+    /**
+     * Get the widget URL for iframe embedding
+     */
+    getWidgetUrl() {
+        const baseUrl = this.options.widgetBaseUrl || Cuoral.PRODUCTION_WIDGET_URL;
+        const params = new URLSearchParams({
+            auto_start: 'true',
+            key: this.options.publicKey,
+            _t: Date.now().toString(),
+        });
+        if (this.options.email)
+            params.set('email', this.options.email);
+        if (this.options.firstName)
+            params.set('first_name', this.options.firstName);
+        if (this.options.lastName)
+            params.set('last_name', this.options.lastName);
+        return `${baseUrl}?${params.toString()}`;
+    }
+    /**
+     * Clean up resources
+     */
+    destroy() {
+        this.bridge.destroy();
+        // Destroy modal if exists
+        if (this.modal) {
+            this.modal.destroy();
+        }
+    }
+    /**
+     * Setup automatic message handlers
+     */
+    setupMessageHandlers() {
+        // Handle start recording requests from widget
+        this.bridge.on(exports.CuoralMessageType.START_RECORDING, async () => {
+            await this.recorder.startRecording();
+        });
+        // Handle stop recording requests from widget
+        this.bridge.on(exports.CuoralMessageType.STOP_RECORDING, async () => {
+            const result = await this.recorder.stopRecording();
+            if (result) {
+                // Convert file path to web-accessible URL
+                const capacitorUrl = result.filePath ? core.Capacitor.convertFileSrc(result.filePath) : '';
+                try {
+                    // Fetch the video blob from the capacitor URL
+                    const response = await fetch(capacitorUrl);
+                    const videoBlob = await response.blob();
+                    // Convert blob to base64 data URL so it can be serialized and transferred cross-origin
+                    const reader = new FileReader();
+                    reader.onloadend = () => {
+                        const base64data = reader.result;
+                        // Send the base64 data via bridge to CDN widget
+                        this.bridge.sendToWidget({
+                            type: exports.CuoralMessageType.RECORDING_STOPPED,
+                            payload: {
+                                videoData: base64data,
+                                videoType: 'video/mp4',
+                                originalPath: result.filePath,
+                                duration: result.duration,
+                                timestamp: Date.now()
+                            }
+                        });
+                    };
+                    reader.onerror = (error) => {
+                        console.error('[Cuoral] Error reading blob:', error);
+                        this.bridge.sendToWidget({
+                            type: exports.CuoralMessageType.RECORDING_STOPPED,
+                            payload: {
+                                error: 'Failed to process recording',
+                                duration: result.duration,
+                                timestamp: Date.now()
+                            }
+                        });
+                    };
+                    // Start reading the blob as data URL
+                    reader.readAsDataURL(videoBlob);
+                }
+                catch (error) {
+                    console.error('[Cuoral] Error processing video file:', error);
+                    this.bridge.sendToWidget({
+                        type: exports.CuoralMessageType.RECORDING_STOPPED,
+                        payload: {
+                            error: 'Failed to process recording',
+                            duration: result.duration,
+                            timestamp: Date.now()
+                        }
+                    });
+                }
+            }
+            else {
+                console.error('[Cuoral] No result from stopRecording');
+            }
+        });
+    }
+}
+Cuoral.PRODUCTION_WIDGET_URL = 'https://js.cuoral.com/mobile.html';
+Cuoral.DEV_WIDGET_URL = 'assets/mobile.html';
+
+/**
+ * Web implementation (for testing in browser)
+ */
+class CuoralPluginWeb extends core.WebPlugin {
+    constructor() {
+        super(...arguments);
+        this.isRecording = false;
+    }
+    async startRecording(options) {
+        console.log('[Cuoral Web] Start recording', options);
+        // Check if Screen Capture API is available
+        if (!navigator.mediaDevices || !navigator.mediaDevices.getDisplayMedia) {
+            throw new Error('Screen recording is not supported in this browser');
+        }
+        try {
+            // Request screen capture
+            const stream = await navigator.mediaDevices.getDisplayMedia({
+                video: true,
+                audio: options?.includeAudio || false,
+            });
+            this.isRecording = true;
+            this.recordingStartTime = Date.now();
+            // Store stream for later stopping
+            window.__cuoralRecordingStream = stream;
+            return { success: true };
+        }
+        catch (error) {
+            console.error('[Cuoral Web] Failed to start recording:', error);
+            return { success: false };
+        }
+    }
+    async stopRecording() {
+        console.log('[Cuoral Web] Stop recording');
+        if (!this.isRecording) {
+            return { success: false };
+        }
+        const stream = window.__cuoralRecordingStream;
+        if (stream) {
+            stream.getTracks().forEach(track => track.stop());
+            delete window.__cuoralRecordingStream;
+        }
+        const duration = this.recordingStartTime
+            ? Math.floor((Date.now() - this.recordingStartTime) / 1000)
+            : 0;
+        this.isRecording = false;
+        this.recordingStartTime = undefined;
+        return {
+            success: true,
+            duration,
+            filePath: 'web-recording-not-saved',
+        };
+    }
+    async getRecordingState() {
+        return {
+            isRecording: this.isRecording,
+            duration: this.recordingStartTime
+                ? Math.floor((Date.now() - this.recordingStartTime) / 1000)
+                : undefined,
+        };
+    }
+    async takeScreenshot(options) {
+        console.log('[Cuoral Web] Take screenshot', options);
+        try {
+            // Use Screen Capture API
+            const stream = await navigator.mediaDevices.getDisplayMedia({
+                video: { width: 1920, height: 1080 },
+            });
+            // Capture frame from video stream
+            const video = document.createElement('video');
+            video.srcObject = stream;
+            video.play();
+            await new Promise(resolve => {
+                video.onloadedmetadata = resolve;
+            });
+            const canvas = document.createElement('canvas');
+            canvas.width = video.videoWidth;
+            canvas.height = video.videoHeight;
+            const ctx = canvas.getContext('2d');
+            ctx?.drawImage(video, 0, 0);
+            // Stop stream
+            stream.getTracks().forEach(track => track.stop());
+            // Convert to base64
+            const format = options?.format || 'png';
+            const quality = options?.quality || 0.92;
+            const base64 = canvas.toDataURL(`image/${format}`, quality);
+            return {
+                base64: base64.split(',')[1],
+                mimeType: `image/${format}`,
+                width: canvas.width,
+                height: canvas.height,
+            };
+        }
+        catch (error) {
+            console.error('[Cuoral Web] Failed to take screenshot:', error);
+            throw error;
+        }
+    }
+    async isRecordingSupported() {
+        const supported = !!(navigator.mediaDevices && navigator.mediaDevices.getDisplayMedia);
+        return { supported };
+    }
+    async requestPermissions() {
+        // Web doesn't require explicit permissions - they're requested on demand
+        return { granted: true };
+    }
+}
+
+var web = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  CuoralPluginWeb: CuoralPluginWeb
+});
+
+exports.Cuoral = Cuoral;
+exports.CuoralBridge = CuoralBridge;
+exports.CuoralModal = CuoralModal;
+exports.CuoralPlugin = CuoralPlugin;
+exports.CuoralRecorder = CuoralRecorder;
+//# sourceMappingURL=index.js.map