@todesktop/plugin-recall/dist/store.js

ToDesktop plugin for Recall.ai Desktop Recording SDK - Plugin package

/**
 * Recall Desktop SDK plugin state management and storage
 */
class RecallSdkStore {
    constructor() {
        this.config = {
            enabled: true,
            apiUrl: 'https://us-east-1.recall.ai',
            requestPermissionsOnStartup: true,
        };
        this.initialized = false;
        this.sdkInitialized = false;
        this.currentSdkState = 'idle';
        // Active meetings and recordings
        this.activeMeetings = new Map();
        this.activeRecordings = new Map();
        // Permission status
        this.permissions = {
            accessibility: false,
            screenCapture: false,
            microphone: false,
            systemAudio: false,
        };
        // Event listeners for SDK events
        this.eventListeners = new Set();
    }
    /**
     * Initialize the plugin store
     */
    async initialize() {
        // Load configuration from ToDesktop preferences
        try {
            // In a real implementation, this would load from ToDesktop's preference system
            // For now, we'll use the defaults
            this.initialized = true;
            console.log('RecallSdkStore: Initialized successfully');
        }
        catch (error) {
            console.error('RecallSdkStore: Failed to initialize:', error);
            throw error;
        }
    }
    /**
     * Get current plugin configuration
     */
    getConfig() {
        return { ...this.config };
    }
    /**
     * Update plugin configuration
     */
    setConfig(updates) {
        this.config = { ...this.config, ...updates };
        console.log('RecallSdkStore: Configuration updated:', this.config);
    }
    /**
     * Load configuration from ToDesktop preferences
     */
    loadFromPreferences(preferences) {
        if (preferences.enabled !== undefined) {
            this.config.enabled = preferences.enabled;
        }
        if (preferences.apiUrl !== undefined) {
            this.config.apiUrl = preferences.apiUrl;
        }
        // autoRecord removed by design
        if (preferences.requestPermissionsOnStartup !== undefined) {
            this.config.requestPermissionsOnStartup = preferences.requestPermissionsOnStartup;
        }
        console.log('RecallSdkStore: Loaded configuration from preferences:', this.config);
    }
    /**
     * Check if plugin is initialized
     */
    isInitialized() {
        return this.initialized;
    }
    /**
     * Check if plugin is enabled
     */
    isEnabled() {
        return this.config.enabled;
    }
    /**
     * Set SDK initialization status
     */
    setSdkInitialized(initialized) {
        this.sdkInitialized = initialized;
    }
    /**
     * Check if SDK is initialized
     */
    isSdkInitialized() {
        return this.sdkInitialized;
    }
    /**
     * Set current SDK state
     */
    setSdkState(state) {
        this.currentSdkState = state;
    }
    /**
     * Get current SDK state
     */
    getSdkState() {
        return this.currentSdkState;
    }
    /**
     * Add an active meeting
     */
    addMeeting(meeting) {
        this.activeMeetings.set(meeting.id, meeting);
        console.log(`RecallSdkStore: Added meeting ${meeting.id}:`, meeting);
    }
    /**
     * Remove a meeting
     */
    removeMeeting(windowId) {
        this.activeMeetings.delete(windowId);
        console.log(`RecallSdkStore: Removed meeting ${windowId}`);
    }
    /**
     * Get active meeting by window ID
     */
    getMeeting(windowId) {
        return this.activeMeetings.get(windowId);
    }
    /**
     * Get all active meetings
     */
    getAllMeetings() {
        return Array.from(this.activeMeetings.values());
    }
    /**
     * Start a recording
     */
    startRecording(windowId, uploadToken) {
        const window = this.activeMeetings.get(windowId);
        if (window) {
            this.activeRecordings.set(windowId, { window, uploadToken });
            console.log(`RecallSdkStore: Started recording for ${windowId}`);
        }
    }
    /**
     * Stop a recording
     */
    stopRecording(windowId) {
        this.activeRecordings.delete(windowId);
        console.log(`RecallSdkStore: Stopped recording for ${windowId}`);
    }
    /**
     * Get active recording by window ID
     */
    getRecording(windowId) {
        return this.activeRecordings.get(windowId);
    }
    /**
     * Get all active recordings
     */
    getAllRecordings() {
        return Array.from(this.activeRecordings.values());
    }
    /**
     * Update permission status
     */
    setPermissionStatus(permission, status) {
        const granted = status === 'granted' || status === 'authorized' || status === 'ALLOWED';
        if (permission === 'screen-capture') {
            this.permissions.screenCapture = granted;
        }
        else if (permission === 'system-audio') {
            this.permissions.systemAudio = granted;
        }
        else {
            // permission is 'accessibility' | 'microphone'
            // @ts-ignore - index by key
            this.permissions[permission] = granted;
        }
        console.log(`RecallSdkStore: Permission ${permission} status: ${status}`);
    }
    /**
     * Get permission status
     */
    getPermissions() {
        return { ...this.permissions };
    }
    /**
     * Check if all required permissions are granted
     */
    arePermissionsGranted() {
        return (this.permissions.accessibility &&
            this.permissions.screenCapture &&
            this.permissions.microphone);
    }
    /**
     * Add event listener for SDK events
     */
    addEventListener(listener) {
        this.eventListeners.add(listener);
    }
    /**
     * Remove event listener
     */
    removeEventListener(listener) {
        this.eventListeners.delete(listener);
    }
    /**
     * Emit event to all listeners
     */
    emitEvent(event) {
        this.eventListeners.forEach(listener => {
            try {
                listener(event);
            }
            catch (error) {
                console.error('RecallSdkStore: Error in event listener:', error);
            }
        });
    }
    /**
     * Clear all state (useful for shutdown/reset)
     */
    clearState() {
        this.activeMeetings.clear();
        this.activeRecordings.clear();
        this.setSdkInitialized(false);
        this.setSdkState('idle');
        this.permissions = {
            accessibility: false,
            screenCapture: false,
            microphone: false,
            systemAudio: false,
        };
        console.log('RecallSdkStore: Cleared all state');
    }
}
export const recallSdkStore = new RecallSdkStore();
//# sourceMappingURL=store.js.map