@itwin/core-electron 4.0.0-dev.6 → 4.0.0-dev.60

package/lib/cjs/backend/ElectronHost.js

@@ -1,244 +1,241 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ElectronHost = void 0;
-const fs = require("fs");
-const path = require("path");
-const core_bentley_1 = require("@itwin/core-bentley");
-const core_backend_1 = require("@itwin/core-backend");
-const core_common_1 = require("@itwin/core-common");
-const ElectronRpcManager_1 = require("../common/ElectronRpcManager");
-const ElectronIpcInterface_1 = require("../common/ElectronIpcInterface");
-// cSpell:ignore signin devserver webcontents copyfile unmaximize eopt
-class ElectronIpc {
-    addListener(channel, listener) {
-        ElectronHost.ipcMain.addListener(channel, listener);
-        return () => ElectronHost.ipcMain.removeListener(channel, listener);
-    }
-    removeListener(channel, listener) {
-        ElectronHost.ipcMain.removeListener(channel, listener);
-    }
-    send(channel, ...args) {
-        var _a;
-        const window = (_a = ElectronHost.mainWindow) !== null && _a !== void 0 ? _a : ElectronHost.electron.BrowserWindow.getAllWindows()[0];
-        window === null || window === void 0 ? void 0 : window.webContents.send(channel, ...args);
-    }
-    handle(channel, listener) {
-        ElectronHost.ipcMain.removeHandler(channel); // make sure there's not already a handler registered
-        ElectronHost.ipcMain.handle(channel, listener);
-        return () => ElectronHost.ipcMain.removeHandler(channel);
-    }
-}
-/**
- * The backend for Electron-based desktop applications
- * @beta
- */
-class ElectronHost {
-    constructor() { }
-    static get ipcMain() { var _a; return (_a = this._electron) === null || _a === void 0 ? void 0 : _a.ipcMain; }
-    static get app() { var _a; return (_a = this._electron) === null || _a === void 0 ? void 0 : _a.app; }
-    static get electron() { return this._electron; }
-    /**
-     * Converts an "electron://frontend/" URL to an absolute file path.
-     *
-     * We use this protocol in production builds because our frontend must be built with absolute URLs,
-     * however, since we're loading everything directly from the install directory, we cannot know the
-     * absolute path at build time.
-     */
-    static parseElectronUrl(requestedUrl) {
-        // Note that the "frontend/" path is arbitrary - this is just so we can handle *some* relative URLs...
-        let assetPath = requestedUrl.substring(this._electronFrontend.length);
-        if (assetPath.length === 0)
-            assetPath = "index.html";
-        assetPath = path.normalize(`${this.webResourcesPath}/${assetPath}`);
-        // File protocols don't follow symlinks, so we need to resolve this to a real path.
-        // However, if the file doesn't exist, it's fine to return an invalid path here - the request will just fail with net::ERR_FILE_NOT_FOUND
-        try {
-            assetPath = fs.realpathSync(assetPath);
-        }
-        catch (error) {
-            // eslint-disable-next-line no-console
-            // console.warn(`WARNING: Frontend requested "${requestedUrl}", but ${assetPath} does not exist`);
-        }
-        if (!assetPath.startsWith(this.webResourcesPath))
-            throw new Error(`Access to files outside installation directory (${this.webResourcesPath}) is prohibited`);
-        return assetPath;
-    }
-    static _openWindow(options) {
-        const webPreferences = {
-            ...options === null || options === void 0 ? void 0 : options.webPreferences,
-            // These web preference variables should not be overriden by the ElectronHostWindowOptions
-            preload: require.resolve(/* webpack: copyfile */ "./ElectronPreload.js"),
-            experimentalFeatures: false,
-            nodeIntegration: false,
-            contextIsolation: true,
-            sandbox: true,
-            nativeWindowOpen: true,
-            nodeIntegrationInWorker: false,
-            nodeIntegrationInSubFrames: false,
-        };
-        const opts = {
-            ...options,
-            autoHideMenuBar: true,
-            icon: this.appIconPath,
-            webPreferences,
-        };
-        this._mainWindow = new (this.electron.BrowserWindow)(opts);
-        ElectronRpcManager_1.ElectronRpcConfiguration.targetWindowId = this._mainWindow.id;
-        this._mainWindow.on("closed", () => this._mainWindow = undefined);
-        this._mainWindow.loadURL(this.frontendURL); // eslint-disable-line @typescript-eslint/no-floating-promises
-        /** Monitors and saves main window size, position and maximized state */
-        if (options === null || options === void 0 ? void 0 : options.storeWindowName) {
-            const mainWindow = this._mainWindow;
-            const name = options.storeWindowName;
-            const saveWindowPosition = (key) => {
-                const bounds = mainWindow.getBounds();
-                core_backend_1.NativeHost.settingsStore.setData(`${key}-${name}`, JSON.stringify(bounds));
-            };
-            const saveMaximized = (maximized) => {
-                if (!maximized)
-                    saveWindowPosition(this._deprecatedSizeAndPosStoreKey);
-                core_backend_1.NativeHost.settingsStore.setData(`windowMaximized-${name}`, maximized);
-            };
-            mainWindow.on("maximize", () => saveMaximized(true));
-            mainWindow.on("unmaximize", () => saveMaximized(false));
-            saveMaximized(mainWindow.isMaximized());
-            mainWindow.on("resized", () => saveWindowPosition(this._deprecatedSizeAndPosStoreKey));
-            mainWindow.on("moved", () => saveWindowPosition(this._deprecatedSizeAndPosStoreKey));
-            const debouncedSaveWindowSizeAndPos = debounce(() => saveWindowPosition(this._sizeAndPosStoreKey));
-            mainWindow.on("resize", () => debouncedSaveWindowSizeAndPos());
-            mainWindow.on("move", () => debouncedSaveWindowSizeAndPos());
-            saveWindowPosition(this._sizeAndPosStoreKey);
-        }
-    }
-    /** The "main" BrowserWindow for this application. */
-    static get mainWindow() { return this._mainWindow; }
-    /**
-     * Gets window size and position for a window, by name, from settings file, if present.
-     * @note Size and position values in the settings file will be updated differently depending on platform.
-     *       On Linux values are only updated on window "unmaximize".
-     *       On Windows and MacOS values are also updated on window manual resize or move.
-     *       To get consistent behavior across different platforms, use [[ElectronHost.getWindowSizeAndPositionSetting]].
-     * @deprecated in 3.6. Use [[ElectronHost.getWindowSizeAndPositionSetting]].
-     */
-    static getWindowSizeSetting(windowName) {
-        const saved = core_backend_1.NativeHost.settingsStore.getString(`${this._deprecatedSizeAndPosStoreKey}-${windowName}`);
-        return saved ? JSON.parse(saved) : undefined;
-    }
-    /**
-     * Gets window size and position for a window, by name, from settings file, if present.
-     */
-    static getWindowSizeAndPositionSetting(windowName) {
-        const saved = core_backend_1.NativeHost.settingsStore.getString(`${this._sizeAndPosStoreKey}-${windowName}`);
-        return saved ? JSON.parse(saved) : undefined;
-    }
-    /** Gets "window maximized" flag for a window, by name, from settings file if present */
-    static getWindowMaximizedSetting(windowName) {
-        return core_backend_1.NativeHost.settingsStore.getBoolean(`windowMaximized-${windowName}`);
-    }
-    /**
-     * Open the main Window when the app is ready.
-     * @param windowOptions Options for constructing the main BrowserWindow. See: https://electronjs.org/docs/api/browser-window#new-browserwindowoptions
-     */
-    static async openMainWindow(windowOptions) {
-        const app = this.app;
-        // quit the application when all windows are closed (unless we're running on MacOS)
-        app.on("window-all-closed", () => {
-            if (process.platform !== "darwin")
-                app.quit();
-        });
-        // re-open the main window if it was closed and the app is re-activated (this is the normal MacOS behavior)
-        app.on("activate", () => {
-            if (!this._mainWindow)
-                this._openWindow(windowOptions);
-        });
-        if (this._developmentServer) {
-            // Occasionally, the electron backend may start before the webpack devserver has even started.
-            // If this happens, we'll just retry and keep reloading the page.
-            app.on("web-contents-created", (_e, webcontents) => {
-                webcontents.on("did-fail-load", async (_event, errorCode, _errorDescription, _validatedURL, isMainFrame) => {
-                    // errorCode -102 is CONNECTION_REFUSED - see https://cs.chromium.org/chromium/src/net/base/net_error_list.h
-                    if (isMainFrame && errorCode === -102) {
-                        await core_bentley_1.BeDuration.wait(100);
-                        webcontents.reload();
-                    }
-                });
-            });
-        }
-        await app.whenReady();
-        if (!this._developmentServer) {
-            // handle any "electron://" requests and redirect them to "file://" URLs
-            this.electron.protocol.registerFileProtocol("electron", (request, callback) => callback(this.parseElectronUrl(request.url))); // eslint-disable-line @typescript-eslint/no-var-requires
-        }
-        this._openWindow(windowOptions);
-    }
-    static get isValid() { return this._ipc !== undefined; }
-    /**
-     * Initialize the backend of an Electron app.
-     * This method configures the backend for all of the inter-process communication (RPC and IPC) for an
-     * Electron app. It should be called from your Electron main function.
-     * @param opts Options that control aspects of your backend.
-     * @note This method must only be called from the backend of an Electron app (i.e. when [ProcessDetector.isElectronAppBackend]($bentley) is `true`).
-     */
-    static async startup(opts) {
-        var _a, _b, _c, _d, _f, _g, _h, _j;
-        if (!core_bentley_1.ProcessDetector.isElectronAppBackend)
-            throw new Error("Not running under Electron");
-        if (!this.isValid) {
-            this._electron = require("electron");
-            this._ipc = new ElectronIpc();
-            const app = this.app;
-            if (!app.isReady())
-                this.electron.protocol.registerSchemesAsPrivileged([{
-                        scheme: "electron",
-                        privileges: {
-                            standard: true,
-                            secure: true,
-                            supportFetchAPI: true,
-                        },
-                    }]);
-            const eopt = opts === null || opts === void 0 ? void 0 : opts.electronHost;
-            this._developmentServer = (_a = eopt === null || eopt === void 0 ? void 0 : eopt.developmentServer) !== null && _a !== void 0 ? _a : false;
-            const frontendPort = (_b = eopt === null || eopt === void 0 ? void 0 : eopt.frontendPort) !== null && _b !== void 0 ? _b : 3000;
-            this.webResourcesPath = (_c = eopt === null || eopt === void 0 ? void 0 : eopt.webResourcesPath) !== null && _c !== void 0 ? _c : "";
-            this.frontendURL = (_d = eopt === null || eopt === void 0 ? void 0 : eopt.frontendURL) !== null && _d !== void 0 ? _d : (this._developmentServer ? `http://localhost:${frontendPort}` : `${this._electronFrontend}index.html`);
-            this.appIconPath = path.join(this.webResourcesPath, (_f = eopt === null || eopt === void 0 ? void 0 : eopt.iconName) !== null && _f !== void 0 ? _f : "appicon.ico");
-            this.rpcConfig = ElectronRpcManager_1.ElectronRpcManager.initializeBackend(this._ipc, eopt === null || eopt === void 0 ? void 0 : eopt.rpcInterfaces);
-        }
-        opts = opts !== null && opts !== void 0 ? opts : {};
-        opts.ipcHost = (_g = opts.ipcHost) !== null && _g !== void 0 ? _g : {};
-        opts.ipcHost.socket = this._ipc;
-        await core_backend_1.NativeHost.startup(opts);
-        if (core_backend_1.IpcHost.isValid) {
-            ElectronDialogHandler.register();
-            (_j = (_h = opts.electronHost) === null || _h === void 0 ? void 0 : _h.ipcHandlers) === null || _j === void 0 ? void 0 : _j.forEach((ipc) => ipc.register());
-        }
-    }
-}
-exports.ElectronHost = ElectronHost;
-ElectronHost._deprecatedSizeAndPosStoreKey = "windowPos";
-ElectronHost._sizeAndPosStoreKey = "windowSizeAndPos";
-ElectronHost._electronFrontend = "electron://frontend/";
-class ElectronDialogHandler extends core_backend_1.IpcHandler {
-    get channelName() { return ElectronIpcInterface_1.dialogChannel; }
-    async callDialog(method, ...args) {
-        const dialog = ElectronHost.electron.dialog;
-        const dialogMethod = dialog[method];
-        if (typeof dialogMethod !== "function")
-            throw new core_common_1.IModelError(core_bentley_1.IModelStatus.FunctionNotFound, `illegal electron dialog method`);
-        return dialogMethod.call(dialog, ...args);
-    }
-}
-function debounce(func, ms = 200) {
-    let timeout;
-    return function (...args) {
-        clearTimeout(timeout);
-        timeout = setTimeout(() => {
-            func.apply(this, args);
-        }, ms);
-    };
-}
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElectronHost = void 0;
+const fs = require("fs");
+const path = require("path");
+const core_bentley_1 = require("@itwin/core-bentley");
+const core_backend_1 = require("@itwin/core-backend");
+const core_common_1 = require("@itwin/core-common");
+const ElectronRpcManager_1 = require("../common/ElectronRpcManager");
+const ElectronIpcInterface_1 = require("../common/ElectronIpcInterface");
+// cSpell:ignore signin devserver webcontents copyfile unmaximize eopt
+class ElectronIpc {
+    addListener(channel, listener) {
+        ElectronHost.ipcMain.addListener(channel, listener);
+        return () => ElectronHost.ipcMain.removeListener(channel, listener);
+    }
+    removeListener(channel, listener) {
+        ElectronHost.ipcMain.removeListener(channel, listener);
+    }
+    send(channel, ...args) {
+        const window = ElectronHost.mainWindow ?? ElectronHost.electron.BrowserWindow.getAllWindows()[0];
+        window?.webContents.send(channel, ...args);
+    }
+    handle(channel, listener) {
+        ElectronHost.ipcMain.removeHandler(channel); // make sure there's not already a handler registered
+        ElectronHost.ipcMain.handle(channel, listener);
+        return () => ElectronHost.ipcMain.removeHandler(channel);
+    }
+}
+/**
+ * The backend for Electron-based desktop applications
+ * @beta
+ */
+class ElectronHost {
+    static get ipcMain() { return this._electron?.ipcMain; }
+    static get app() { return this._electron?.app; }
+    static get electron() { return this._electron; }
+    constructor() { }
+    /**
+     * Converts an "electron://frontend/" URL to an absolute file path.
+     *
+     * We use this protocol in production builds because our frontend must be built with absolute URLs,
+     * however, since we're loading everything directly from the install directory, we cannot know the
+     * absolute path at build time.
+     */
+    static parseElectronUrl(requestedUrl) {
+        // Note that the "frontend/" path is arbitrary - this is just so we can handle *some* relative URLs...
+        let assetPath = requestedUrl.substring(this._electronFrontend.length);
+        if (assetPath.length === 0)
+            assetPath = "index.html";
+        assetPath = path.normalize(`${this.webResourcesPath}/${assetPath}`);
+        // File protocols don't follow symlinks, so we need to resolve this to a real path.
+        // However, if the file doesn't exist, it's fine to return an invalid path here - the request will just fail with net::ERR_FILE_NOT_FOUND
+        try {
+            assetPath = fs.realpathSync(assetPath);
+        }
+        catch (error) {
+            // eslint-disable-next-line no-console
+            // console.warn(`WARNING: Frontend requested "${requestedUrl}", but ${assetPath} does not exist`);
+        }
+        if (!assetPath.startsWith(this.webResourcesPath))
+            throw new Error(`Access to files outside installation directory (${this.webResourcesPath}) is prohibited`);
+        return assetPath;
+    }
+    static _openWindow(options) {
+        const webPreferences = {
+            ...options?.webPreferences,
+            // These web preference variables should not be overriden by the ElectronHostWindowOptions
+            preload: require.resolve(/* webpack: copyfile */ "./ElectronPreload.js"),
+            experimentalFeatures: false,
+            nodeIntegration: false,
+            contextIsolation: true,
+            sandbox: true,
+            nodeIntegrationInWorker: false,
+            nodeIntegrationInSubFrames: false,
+        };
+        const opts = {
+            ...options,
+            autoHideMenuBar: true,
+            icon: this.appIconPath,
+            webPreferences,
+        };
+        this._mainWindow = new (this.electron.BrowserWindow)(opts);
+        ElectronRpcManager_1.ElectronRpcConfiguration.targetWindowId = this._mainWindow.id;
+        this._mainWindow.on("closed", () => this._mainWindow = undefined);
+        this._mainWindow.loadURL(this.frontendURL); // eslint-disable-line @typescript-eslint/no-floating-promises
+        /** Monitors and saves main window size, position and maximized state */
+        if (options?.storeWindowName) {
+            const mainWindow = this._mainWindow;
+            const name = options.storeWindowName;
+            const saveWindowPosition = (key) => {
+                const bounds = mainWindow.getBounds();
+                core_backend_1.NativeHost.settingsStore.setData(`${key}-${name}`, JSON.stringify(bounds));
+            };
+            const saveMaximized = (maximized) => {
+                if (!maximized)
+                    saveWindowPosition(this._deprecatedSizeAndPosStoreKey);
+                core_backend_1.NativeHost.settingsStore.setData(`windowMaximized-${name}`, maximized);
+            };
+            mainWindow.on("maximize", () => saveMaximized(true));
+            mainWindow.on("unmaximize", () => saveMaximized(false));
+            saveMaximized(mainWindow.isMaximized());
+            mainWindow.on("resized", () => saveWindowPosition(this._deprecatedSizeAndPosStoreKey));
+            mainWindow.on("moved", () => saveWindowPosition(this._deprecatedSizeAndPosStoreKey));
+            const debouncedSaveWindowSizeAndPos = debounce(() => saveWindowPosition(this._sizeAndPosStoreKey));
+            mainWindow.on("resize", () => debouncedSaveWindowSizeAndPos());
+            mainWindow.on("move", () => debouncedSaveWindowSizeAndPos());
+            saveWindowPosition(this._sizeAndPosStoreKey);
+        }
+    }
+    /** The "main" BrowserWindow for this application. */
+    static get mainWindow() { return this._mainWindow; }
+    /**
+     * Gets window size and position for a window, by name, from settings file, if present.
+     * @note Size and position values in the settings file will be updated differently depending on platform.
+     *       On Linux values are only updated on window "unmaximize".
+     *       On Windows and MacOS values are also updated on window manual resize or move.
+     *       To get consistent behavior across different platforms, use [[ElectronHost.getWindowSizeAndPositionSetting]].
+     * @deprecated in 3.6. Use [[ElectronHost.getWindowSizeAndPositionSetting]].
+     */
+    static getWindowSizeSetting(windowName) {
+        const saved = core_backend_1.NativeHost.settingsStore.getString(`${this._deprecatedSizeAndPosStoreKey}-${windowName}`);
+        return saved ? JSON.parse(saved) : undefined;
+    }
+    /**
+     * Gets window size and position for a window, by name, from settings file, if present.
+     */
+    static getWindowSizeAndPositionSetting(windowName) {
+        const saved = core_backend_1.NativeHost.settingsStore.getString(`${this._sizeAndPosStoreKey}-${windowName}`);
+        return saved ? JSON.parse(saved) : undefined;
+    }
+    /** Gets "window maximized" flag for a window, by name, from settings file if present */
+    static getWindowMaximizedSetting(windowName) {
+        return core_backend_1.NativeHost.settingsStore.getBoolean(`windowMaximized-${windowName}`);
+    }
+    /**
+     * Open the main Window when the app is ready.
+     * @param windowOptions Options for constructing the main BrowserWindow. See: https://electronjs.org/docs/api/browser-window#new-browserwindowoptions
+     */
+    static async openMainWindow(windowOptions) {
+        const app = this.app;
+        // quit the application when all windows are closed (unless we're running on MacOS)
+        app.on("window-all-closed", () => {
+            if (process.platform !== "darwin")
+                app.quit();
+        });
+        // re-open the main window if it was closed and the app is re-activated (this is the normal MacOS behavior)
+        app.on("activate", () => {
+            if (!this._mainWindow)
+                this._openWindow(windowOptions);
+        });
+        if (this._developmentServer) {
+            // Occasionally, the electron backend may start before the webpack devserver has even started.
+            // If this happens, we'll just retry and keep reloading the page.
+            app.on("web-contents-created", (_e, webcontents) => {
+                webcontents.on("did-fail-load", async (_event, errorCode, _errorDescription, _validatedURL, isMainFrame) => {
+                    // errorCode -102 is CONNECTION_REFUSED - see https://cs.chromium.org/chromium/src/net/base/net_error_list.h
+                    if (isMainFrame && errorCode === -102) {
+                        await core_bentley_1.BeDuration.wait(100);
+                        webcontents.reload();
+                    }
+                });
+            });
+        }
+        await app.whenReady();
+        if (!this._developmentServer) {
+            // handle any "electron://" requests and redirect them to "file://" URLs
+            this.electron.protocol.registerFileProtocol("electron", (request, callback) => callback(this.parseElectronUrl(request.url))); // eslint-disable-line @typescript-eslint/no-var-requires
+        }
+        this._openWindow(windowOptions);
+    }
+    static get isValid() { return this._ipc !== undefined; }
+    /**
+     * Initialize the backend of an Electron app.
+     * This method configures the backend for all of the inter-process communication (RPC and IPC) for an
+     * Electron app. It should be called from your Electron main function.
+     * @param opts Options that control aspects of your backend.
+     * @note This method must only be called from the backend of an Electron app (i.e. when [ProcessDetector.isElectronAppBackend]($bentley) is `true`).
+     */
+    static async startup(opts) {
+        if (!core_bentley_1.ProcessDetector.isElectronAppBackend)
+            throw new Error("Not running under Electron");
+        if (!this.isValid) {
+            this._electron = require("electron");
+            this._ipc = new ElectronIpc();
+            const app = this.app;
+            if (!app.isReady())
+                this.electron.protocol.registerSchemesAsPrivileged([{
+                        scheme: "electron",
+                        privileges: {
+                            standard: true,
+                            secure: true,
+                            supportFetchAPI: true,
+                        },
+                    }]);
+            const eopt = opts?.electronHost;
+            this._developmentServer = eopt?.developmentServer ?? false;
+            const frontendPort = eopt?.frontendPort ?? 3000;
+            this.webResourcesPath = eopt?.webResourcesPath ?? "";
+            this.frontendURL = eopt?.frontendURL ?? (this._developmentServer ? `http://localhost:${frontendPort}` : `${this._electronFrontend}index.html`);
+            this.appIconPath = path.join(this.webResourcesPath, eopt?.iconName ?? "appicon.ico");
+            this.rpcConfig = ElectronRpcManager_1.ElectronRpcManager.initializeBackend(this._ipc, eopt?.rpcInterfaces);
+        }
+        opts = opts ?? {};
+        opts.ipcHost = opts.ipcHost ?? {};
+        opts.ipcHost.socket = this._ipc;
+        await core_backend_1.NativeHost.startup(opts);
+        if (core_backend_1.IpcHost.isValid) {
+            ElectronDialogHandler.register();
+            opts.electronHost?.ipcHandlers?.forEach((ipc) => ipc.register());
+        }
+    }
+}
+ElectronHost._deprecatedSizeAndPosStoreKey = "windowPos";
+ElectronHost._sizeAndPosStoreKey = "windowSizeAndPos";
+ElectronHost._electronFrontend = "electron://frontend/";
+exports.ElectronHost = ElectronHost;
+class ElectronDialogHandler extends core_backend_1.IpcHandler {
+    get channelName() { return ElectronIpcInterface_1.dialogChannel; }
+    async callDialog(method, ...args) {
+        const dialog = ElectronHost.electron.dialog;
+        const dialogMethod = dialog[method];
+        if (typeof dialogMethod !== "function")
+            throw new core_common_1.IModelError(core_bentley_1.IModelStatus.FunctionNotFound, `illegal electron dialog method`);
+        return dialogMethod.call(dialog, ...args);
+    }
+}
+function debounce(func, ms = 200) {
+    let timeout;
+    return function (...args) {
+        clearTimeout(timeout);
+        timeout = setTimeout(() => {
+            func.apply(this, args);
+        }, ms);
+    };
+}
 //# sourceMappingURL=ElectronHost.js.map