zulip-desktop/app/renderer/js/electron-bridge.ts

import {ipcRenderer, remote} from 'electron';
import {EventEmitter} from 'events';

import {ClipboardDecrypterImpl} from './clipboard-decrypter';
import type {NotificationData} from './notification';
import {newNotification} from './notification';

type ListenerType = ((...args: any[]) => void);

let notificationReplySupported = false;
// Indicates if the user is idle or not
let idle = false;
// Indicates the time at which user was last active
let lastActive = Date.now();

export const bridgeEvents = new EventEmitter();

const electron_bridge: ElectronBridge = {
	send_event: (eventName: string | symbol, ...args: unknown[]): boolean =>
		bridgeEvents.emit(eventName, ...args),

	on_event: (eventName: string, listener: ListenerType): void => {
		bridgeEvents.on(eventName, listener);
	},

	new_notification: (
		title: string,
		options: NotificationOptions | undefined,
		dispatch: (type: string, eventInit: EventInit) => boolean
	): NotificationData =>
		newNotification(title, options, dispatch),

	get_idle_on_system: (): boolean => idle,

	get_last_active_on_system: (): number => lastActive,

	get_send_notification_reply_message_supported: (): boolean =>
		notificationReplySupported,

	set_send_notification_reply_message_supported: (value: boolean): void => {
		notificationReplySupported = value;
	},

	decrypt_clipboard: (version: number): ClipboardDecrypterImpl =>
		new ClipboardDecrypterImpl(version)
};

bridgeEvents.on('total_unread_count', (...args) => {
	ipcRenderer.send('unread-count', ...args);
});

bridgeEvents.on('realm_name', realmName => {
	const serverURL = location.origin;
	ipcRenderer.send('realm-name-changed', serverURL, realmName);
});

bridgeEvents.on('realm_icon_url', (iconURL: unknown) => {
	if (typeof iconURL !== 'string') {
		throw new TypeError('Expected string for iconURL');
	}

	const serverURL = location.origin;
	iconURL = iconURL.includes('http') ? iconURL : `${serverURL}${iconURL}`;
	ipcRenderer.send('realm-icon-changed', serverURL, iconURL);
});

// Set user as active and update the time of last activity
ipcRenderer.on('set-active', () => {
	if (!remote.app.isPackaged) {
		console.log('active');
	}

	idle = false;
	lastActive = Date.now();
});

// Set user as idle and time of last activity is left unchanged
ipcRenderer.on('set-idle', () => {
	if (!remote.app.isPackaged) {
		console.log('idle');
	}

	idle = true;
});

// This follows node's idiomatic implementation of event
// emitters to make event handling more simpler instead of using
// functions zulip side will emit event using ElectronBrigde.send_event
// which is alias of .emit and on this side we can handle the data by adding
// a listener for the event.
export default electron_bridge;