move common electron code to jslib

package.json

@@ -31,6 +31,7 @@
     "@types/papaparse": "4.1.31",
     "@types/webcrypto": "0.0.28",
     "concurrently": "3.5.1",
+    "electron": "1.8.4",
     "jasmine": "^3.1.0",
     "jasmine-ts-console-reporter": "^3.1.1",
     "jasmine-core": "^2.8.0",
@@ -62,6 +63,8 @@
     "angular2-toaster": "4.0.2",
     "angulartics2": "5.0.1",
     "core-js": "2.4.1",
+    "electron-log": "2.2.14",
+    "electron-store": "1.3.0",
     "lunr": "2.1.6",
     "node-forge": "0.7.1",
     "rxjs": "5.5.6",

src/electron/services/electronLog.service.ts

@@ -0,0 +1,64 @@
+import log from 'electron-log';
+import * as path from 'path';
+
+import { isDev } from '../utils';
+
+import { LogLevelType } from '../../enums/logLevelType';
+
+import { LogService as LogServiceAbstraction } from '../../abstractions/log.service';
+
+export class ElectronLogService implements LogServiceAbstraction {
+    constructor(private filter: (level: LogLevelType) => boolean = null, logDir: string = null) {
+        if (log.transports == null) {
+            return;
+        }
+
+        log.transports.file.level = 'info';
+        if (logDir != null) {
+            log.transports.file.file = path.join(logDir, 'app.log');
+        }
+    }
+
+    debug(message: string) {
+        if (!isDev()) {
+            return;
+        }
+
+        this.write(LogLevelType.Debug, message);
+    }
+
+    info(message: string) {
+        this.write(LogLevelType.Info, message);
+    }
+
+    warning(message: string) {
+        this.write(LogLevelType.Warning, message);
+    }
+
+    error(message: string) {
+        this.write(LogLevelType.Error, message);
+    }
+
+    write(level: LogLevelType, message: string) {
+        if (this.filter != null && this.filter(level)) {
+            return;
+        }
+
+        switch (level) {
+            case LogLevelType.Debug:
+                log.debug(message);
+                break;
+            case LogLevelType.Info:
+                log.info(message);
+                break;
+            case LogLevelType.Warning:
+                log.warn(message);
+                break;
+            case LogLevelType.Error:
+                log.error(message);
+                break;
+            default:
+                break;
+        }
+    }
+}

src/electron/services/electronPlatformUtils.service.ts

@@ -0,0 +1,155 @@
+import {
+    clipboard,
+    remote,
+    shell,
+} from 'electron';
+
+import {
+    isDev,
+    isMacAppStore,
+} from '../utils';
+
+import { DeviceType } from '../../enums/deviceType';
+
+import { I18nService } from '../../abstractions/i18n.service';
+import { PlatformUtilsService } from '../../abstractions/platformUtils.service';
+
+import { AnalyticsIds } from '../../misc/analytics';
+import { Utils } from '../../misc/utils';
+
+export class ElectronPlatformUtilsService implements PlatformUtilsService {
+    identityClientId: string;
+
+    private deviceCache: DeviceType = null;
+    private analyticsIdCache: string = null;
+
+    constructor(private i18nService: I18nService, private isDesktopApp: boolean) {
+        this.identityClientId = isDesktopApp ? 'desktop' : 'connector';
+    }
+
+    getDevice(): DeviceType {
+        if (!this.deviceCache) {
+            switch (process.platform) {
+                case 'win32':
+                    this.deviceCache = DeviceType.Windows;
+                    break;
+                case 'darwin':
+                    this.deviceCache = DeviceType.MacOs;
+                    break;
+                case 'linux':
+                default:
+                    this.deviceCache = DeviceType.Linux;
+                    break;
+            }
+        }
+
+        return this.deviceCache;
+    }
+
+    getDeviceString(): string {
+        return DeviceType[this.getDevice()].toLowerCase();
+    }
+
+    isFirefox(): boolean {
+        return false;
+    }
+
+    isChrome(): boolean {
+        return true;
+    }
+
+    isEdge(): boolean {
+        return false;
+    }
+
+    isOpera(): boolean {
+        return false;
+    }
+
+    isVivaldi(): boolean {
+        return false;
+    }
+
+    isSafari(): boolean {
+        return false;
+    }
+
+    isMacAppStore(): boolean {
+        return isMacAppStore();
+    }
+
+    analyticsId(): string {
+        if (!this.isDesktopApp) {
+            return null;
+        }
+
+        if (this.analyticsIdCache) {
+            return this.analyticsIdCache;
+        }
+
+        this.analyticsIdCache = (AnalyticsIds as any)[this.getDevice()];
+        return this.analyticsIdCache;
+    }
+
+    getDomain(uriString: string): string {
+        return Utils.getHostname(uriString);
+    }
+
+    isViewOpen(): boolean {
+        return false;
+    }
+
+    launchUri(uri: string, options?: any): void {
+        shell.openExternal(uri);
+    }
+
+    saveFile(win: Window, blobData: any, blobOptions: any, fileName: string): void {
+        const blob = new Blob([blobData], blobOptions);
+        const a = win.document.createElement('a');
+        a.href = win.URL.createObjectURL(blob);
+        a.download = fileName;
+        window.document.body.appendChild(a);
+        a.click();
+        window.document.body.removeChild(a);
+    }
+
+    getApplicationVersion(): string {
+        return remote.app.getVersion();
+    }
+
+    supportsU2f(win: Window): boolean {
+        // Not supported in Electron at this time.
+        // ref: https://github.com/electron/electron/issues/3226
+        return false;
+    }
+
+    showDialog(text: string, title?: string, confirmText?: string, cancelText?: string, type?: string):
+        Promise<boolean> {
+        const buttons = [confirmText == null ? this.i18nService.t('ok') : confirmText];
+        if (cancelText != null) {
+            buttons.push(cancelText);
+        }
+
+        const result = remote.dialog.showMessageBox(remote.getCurrentWindow(), {
+            type: type,
+            title: title,
+            message: title,
+            detail: text,
+            buttons: buttons,
+            cancelId: buttons.length === 2 ? 1 : null,
+            defaultId: 0,
+            noLink: true,
+        });
+
+        return Promise.resolve(result === 0);
+    }
+
+    isDev(): boolean {
+        return isDev();
+    }
+
+    copyToClipboard(text: string, options?: any): void {
+        const type = options ? options.type : null;
+        clipboard.writeText(text, type);
+    }
+}

src/electron/services/electronRendererSecureStorage.service.ts

@@ -0,0 +1,30 @@
+import { ipcRenderer } from 'electron';
+
+import { StorageService } from '../../abstractions/storage.service';
+
+export class ElectronRendererSecureStorageService implements StorageService {
+    async get<T>(key: string): Promise<T> {
+        const val = ipcRenderer.sendSync('keytar', {
+            action: 'getPassword',
+            key: key,
+        });
+        return Promise.resolve(val != null ? JSON.parse(val) as T : null);
+    }
+
+    async save(key: string, obj: any): Promise<any> {
+        ipcRenderer.sendSync('keytar', {
+            action: 'setPassword',
+            key: key,
+            value: JSON.stringify(obj),
+        });
+        return Promise.resolve();
+    }
+
+    async remove(key: string): Promise<any> {
+        ipcRenderer.sendSync('keytar', {
+            action: 'deletePassword',
+            key: key,
+        });
+        return Promise.resolve();
+    }
+}

src/electron/services/electronStorage.service.ts

@@ -0,0 +1,35 @@
+import { StorageService } from '../../abstractions/storage.service';
+
+import { ConstantsService } from '../../services/constants.service';
+
+// tslint:disable-next-line
+const Store = require('electron-store');
+
+export class ElectronStorageService implements StorageService {
+    private store: any;
+
+    constructor() {
+        const storeConfig: any = {
+            defaults: {} as any,
+            name: 'data',
+        };
+        // Default lock options to "on restart".
+        storeConfig.defaults[ConstantsService.lockOptionKey] = -1;
+        this.store = new Store(storeConfig);
+    }
+
+    get<T>(key: string): Promise<T> {
+        const val = this.store.get(key) as T;
+        return Promise.resolve(val != null ? val : null);
+    }
+
+    save(key: string, obj: any): Promise<any> {
+        this.store.set(key, obj);
+        return Promise.resolve();
+    }
+
+    remove(key: string): Promise<any> {
+        this.store.delete(key);
+        return Promise.resolve();
+    }
+}

src/electron/utils.ts

@@ -0,0 +1,27 @@
+export function isDev() {
+    // ref: https://github.com/sindresorhus/electron-is-dev
+    if ('ELECTRON_IS_DEV' in process.env) {
+        return parseInt(process.env.ELECTRON_IS_DEV, 10) === 1;
+    }
+    return (process.defaultApp || /node_modules[\\/]electron[\\/]/.test(process.execPath));
+}
+
+export function isAppImage() {
+    return process.platform === 'linux' && 'APPIMAGE' in process.env;
+}
+
+export function isMacAppStore() {
+    return process.platform === 'darwin' && process.mas && process.mas === true;
+}
+
+export function isWindowsStore() {
+    return process.platform === 'win32' && process.windowsStore && process.windowsStore === true;
+}
+
+export function isSnapStore() {
+    return process.platform === 'linux' && process.env.SNAP_USER_DATA != null;
+}
+
+export function isWindowsPortable() {
+    return process.platform === 'win32' && process.env.PORTABLE_EXECUTABLE_DIR != null;
+}

src/electron/window.main.ts

@@ -0,0 +1,223 @@
+import { app, BrowserWindow, screen } from 'electron';
+import * as path from 'path';
+import * as url from 'url';
+
+import { isDev, isMacAppStore, isSnapStore } from './utils';
+
+import { StorageService } from '../abstractions/storage.service';
+
+const WindowEventHandlingDelay = 100;
+const Keys = {
+    mainWindowSize: 'mainWindowSize',
+};
+
+export class WindowMain {
+    win: BrowserWindow;
+
+    private windowStateChangeTimer: NodeJS.Timer;
+    private windowStates: { [key: string]: any; } = {};
+
+    constructor(private storageService: StorageService) { }
+
+    init(): Promise<any> {
+        return new Promise((resolve, reject) => {
+            try {
+                if (!isMacAppStore() && !isSnapStore()) {
+                    const shouldQuit = app.makeSingleInstance((args, dir) => {
+                        // Someone tried to run a second instance, we should focus our window.
+                        if (this.win != null) {
+                            if (this.win.isMinimized()) {
+                                this.win.restore();
+                            }
+                            this.win.focus();
+                        }
+                    });
+
+                    if (shouldQuit) {
+                        app.quit();
+                        return;
+                    }
+                }
+
+                // This method will be called when Electron has finished
+                // initialization and is ready to create browser windows.
+                // Some APIs can only be used after this event occurs.
+                app.on('ready', async () => {
+                    await this.createWindow();
+                    resolve();
+                });
+
+                // Quit when all windows are closed.
+                app.on('window-all-closed', () => {
+                    // On OS X it is common for applications and their menu bar
+                    // to stay active until the user quits explicitly with Cmd + Q
+                    if (process.platform !== 'darwin' || isMacAppStore()) {
+                        app.quit();
+                    }
+                });
+
+                app.on('activate', async () => {
+                    // On OS X it's common to re-create a window in the app when the
+                    // dock icon is clicked and there are no other windows open.
+                    if (this.win === null) {
+                        await this.createWindow();
+                    }
+                });
+
+            } catch (e) {
+                // Catch Error
+                // throw e;
+                reject(e);
+            }
+        });
+    }
+
+    private async createWindow() {
+        this.windowStates[Keys.mainWindowSize] = await this.getWindowState(Keys.mainWindowSize, 950, 600);
+
+        // Create the browser window.
+        this.win = new BrowserWindow({
+            width: this.windowStates[Keys.mainWindowSize].width,
+            height: this.windowStates[Keys.mainWindowSize].height,
+            minWidth: 680,
+            minHeight: 500,
+            x: this.windowStates[Keys.mainWindowSize].x,
+            y: this.windowStates[Keys.mainWindowSize].y,
+            title: app.getName(),
+            icon: process.platform === 'linux' ? path.join(__dirname, '/images/icon.png') : undefined,
+            show: false,
+        });
+
+        if (this.windowStates[Keys.mainWindowSize].isMaximized) {
+            this.win.maximize();
+        }
+
+        // Show it later since it might need to be maximized.
+        this.win.show();
+
+        // and load the index.html of the app.
+        this.win.loadURL(url.format({
+            protocol: 'file:',
+            pathname: path.join(__dirname, '/index.html'),
+            slashes: true,
+        }));
+
+        // Open the DevTools.
+        if (isDev()) {
+            this.win.webContents.openDevTools();
+        }
+
+        // Emitted when the window is closed.
+        this.win.on('closed', async () => {
+            await this.updateWindowState(Keys.mainWindowSize, this.win);
+
+            // Dereference the window object, usually you would store window
+            // in an array if your app supports multi windows, this is the time
+            // when you should delete the corresponding element.
+            this.win = null;
+        });
+
+        this.win.on('close', async () => {
+            await this.updateWindowState(Keys.mainWindowSize, this.win);
+        });
+
+        this.win.on('maximize', async () => {
+            await this.updateWindowState(Keys.mainWindowSize, this.win);
+        });
+
+        this.win.on('unmaximize', async () => {
+            await this.updateWindowState(Keys.mainWindowSize, this.win);
+        });
+
+        this.win.on('resize', () => {
+            this.windowStateChangeHandler(Keys.mainWindowSize, this.win);
+        });
+
+        this.win.on('move', () => {
+            this.windowStateChangeHandler(Keys.mainWindowSize, this.win);
+        });
+    }
+
+    private windowStateChangeHandler(configKey: string, win: BrowserWindow) {
+        global.clearTimeout(this.windowStateChangeTimer);
+        this.windowStateChangeTimer = global.setTimeout(async () => {
+            await this.updateWindowState(configKey, win);
+        }, WindowEventHandlingDelay);
+    }
+
+    private async updateWindowState(configKey: string, win: BrowserWindow) {
+        if (win == null) {
+            return;
+        }
+
+        try {
+            const bounds = win.getBounds();
+
+            if (this.windowStates[configKey] == null) {
+                this.windowStates[configKey] = await this.storageService.get<any>(configKey);
+                if (this.windowStates[configKey] == null) {
+                    this.windowStates[configKey] = {};
+                }
+            }
+
+            this.windowStates[configKey].isMaximized = win.isMaximized();
+            this.windowStates[configKey].displayBounds = screen.getDisplayMatching(bounds).bounds;
+
+            if (!win.isMaximized() && !win.isMinimized() && !win.isFullScreen()) {
+                this.windowStates[configKey].x = bounds.x;
+                this.windowStates[configKey].y = bounds.y;
+                this.windowStates[configKey].width = bounds.width;
+                this.windowStates[configKey].height = bounds.height;
+            }
+
+            await this.storageService.save(configKey, this.windowStates[configKey]);
+        } catch (e) { }
+    }
+
+    private async getWindowState(configKey: string, defaultWidth: number, defaultHeight: number) {
+        let state = await this.storageService.get<any>(configKey);
+
+        const isValid = state != null && (this.stateHasBounds(state) || state.isMaximized);
+        let displayBounds: Electron.Rectangle = null;
+        if (!isValid) {
+            state = {
+                width: defaultWidth,
+                height: defaultHeight,
+            };
+
+            displayBounds = screen.getPrimaryDisplay().bounds;
+        } else if (this.stateHasBounds(state) && state.displayBounds) {
+            // Check if the display where the window was last open is still available
+            displayBounds = screen.getDisplayMatching(state.displayBounds).bounds;
+
+            if (displayBounds.width !== state.displayBounds.width ||
+                displayBounds.height !== state.displayBounds.height ||
+                displayBounds.x !== state.displayBounds.x ||
+                displayBounds.y !== state.displayBounds.y) {
+                state.x = undefined;
+                state.y = undefined;
+                displayBounds = screen.getPrimaryDisplay().bounds;
+            }
+        }
+
+        if (displayBounds != null) {
+            if (state.width > displayBounds.width && state.height > displayBounds.height) {
+                state.isMaximized = true;
+            }
+
+            if (state.width > displayBounds.width) {
+                state.width = displayBounds.width - 10;
+            }
+            if (state.height > displayBounds.height) {
+                state.height = displayBounds.height - 10;
+            }
+        }
+
+        return state;
+    }
+
+    private stateHasBounds(state: any): boolean {
+        return state != null && Number.isInteger(state.x) && Number.isInteger(state.y) &&
+            Number.isInteger(state.width) && state.width > 0 && Number.isInteger(state.height) && state.height > 0;
+    }
+}

src/misc/analytics.ts

@@ -4,8 +4,22 @@ import { StorageService } from '../abstractions/storage.service';
 
 import { ConstantsService } from '../services/constants.service';
 
+import { DeviceType } from '../enums/deviceType';
+
 const GaObj = 'ga';
 
+export const AnalyticsIds = {
+    [DeviceType.Chrome]: 'UA-81915606-6',
+    [DeviceType.Firefox]: 'UA-81915606-7',
+    [DeviceType.Opera]: 'UA-81915606-8',
+    [DeviceType.Edge]: 'UA-81915606-9',
+    [DeviceType.Vivaldi]: 'UA-81915606-15',
+    [DeviceType.Safari]: 'UA-81915606-16',
+    [DeviceType.Windows]: 'UA-81915606-17',
+    [DeviceType.Linux]: 'UA-81915606-19',
+    [DeviceType.MacOs]: 'UA-81915606-18',
+};
+
 export class Analytics {
     private gaTrackingId: string = null;
     private defaultDisabled = false;