13.5.1

If we provide the Version parameter and haven't included the version …

.gitignore

@@ -260,3 +260,6 @@ paket-files/
 # Python Tools for Visual Studio (PTVS)
 __pycache__/
 *.pyc
+
+# Mac Only settings file
+.DS_Store

Changelog.md

@@ -1,5 +1,115 @@
 # Not released
 
+# 13.5.1
+
+ElectronNET.CLI:
+
+* New Feature: Using exit code instead of seek for the term 'error' (thanks [TSrgy](https://github.com/TSrgy)) [\#562](https://github.com/ElectronNET/Electron.NET/pull/562)  
+* Fixed bug: Allow for property overrides to be passed in (thanks [danatcofo](https://github.com/danatcofo)) [\#531](https://github.com/ElectronNET/Electron.NET/pull/531)  
+Use `/p:propertyName=value` or `/property:propertyName=value` to pass in property overrides. This is equivalent to the `-p:` option documented here: [https://docs.microsoft.com/en-us/dotnet/core/tools/dotnet-publish](https://docs.microsoft.com/en-us/dotnet/core/tools/dotnet-publish)  
+* Fixed bug: Add ability to pass an argument for "Version" for both the "dotnet publish" and "electron-builder" commands (thanks [tub5](https://github.com/tub5)) [\#546](https://github.com/ElectronNET/Electron.NET/pull/546)  
+* Fixed bug: Version flag not persisting with the referenced executable (thanks [tub5](https://github.com/tub5)) [\#585](https://github.com/ElectronNET/Electron.NET/pull/585)  
+* Fixed bug: Changes PublishSingleFile default to false for NET5 compatibility (thanks [cristiangiagante](https://github.com/cristiangiagante)) [\#570](https://github.com/ElectronNET/Electron.NET/pull/570)  
+  
+ElectronNET.API:  
+  
+* New Feature: Native Electron 13.1.5 support, but not all new features (we search contributors)   
+* Breaking API Changes (from native Electron 13.1.5): 
+   - `Shell.MoveItemToTrashAsync` renamed with `Shell.TrashItemAsync`  
+   - The deprecated extension APIs have been removed: `BrowserWindow.GetAllExtensionsAsync()`, `BrowserWindow.RemoveExtension()`, `BrowserWindow.AddExtensionAsync()`. Use the session APIs instead: `Session.GetAllExtensionsAsync()`, `Session.RemoveExtension()`, `Session.LoadExtensionAsync()`.  
+* New Feature: singleInstance handle command line arguments [\#520](https://github.com/ElectronNET/Electron.NET/issues/520)  
+* New Feature: Add WebContents [insertCSS](https://www.electronjs.org/docs/api/web-contents#contentsinsertcsscss-options) functionality (thanks [nfichter](https://github.com/nfichter)) [\#559](https://github.com/ElectronNET/Electron.NET/pull/559)  
+* New Feature: Allow IpcMain to send IPC messages to BrowserViews (thanks [nfichter](https://github.com/nfichter)) [\#560](https://github.com/ElectronNET/Electron.NET/pull/560)  
+* New Feature: Add support for proxies that require basic username/password authentication (thanks [nfichter](https://github.com/nfichter)) [\#561](https://github.com/ElectronNET/Electron.NET/pull/561)  
+* New Feature: Add PostData to LoadURLOptions to allow http-posts in LoadURL calls (thanks [Funkrusha](https://github.com/Funkrusha)) [\#547](https://github.com/ElectronNET/Electron.NET/pull/547)  
+* Fixed bug: Fix splash screen interaction causing crashes, ghost dragging, and resizable behavior #540 (thanks [MiniguyBrendan](https://github.com/MiniguyBrendan)) [\#540](https://github.com/ElectronNET/Electron.NET/pull/540)  
+* Fixed bug: Vibrancy serialization fix (thanks [tantumalice](https://github.com/tantumalice)) [\#573](https://github.com/ElectronNET/Electron.NET/pull/573)  
+
+
+# Released
+
+# 11.5.1
+
+ElectronNET.CLI:
+
+* New Feature: Added new build and start commandline options for single exe (thanks [nathanwienand](https://github.com/nathanwienand)) [\#506](https://github.com/ElectronNET/Electron.NET/pull/506)
+* New Feature: Set a description of the app in `electron.manifest.json` (thanks [BurtsevC](https://github.com/BurtsevC)) [\#433](https://github.com/ElectronNET/Electron.NET/pull/433)
+* New Feature: Set a target for the start command (thanks [gabecook](https://github.com/gabecook)) [\#463](https://github.com/ElectronNET/Electron.NET/pull/463)
+* New Feature: `electronize init` support for F# projects (thanks [kojo12228](https://github.com/kojo12228)) [\#457](https://github.com/ElectronNET/Electron.NET/pull/457)
+* New Feature: Linux support for the buildAll.sh (thanks [duncanawoods](https://github.com/duncanawoods)) [\#465](https://github.com/ElectronNET/Electron.NET/pull/465)
+* Fixed bug: ERR_UNKNOWN_URL_SCHEME by intercepting file:// protocol (thanks [duncanawoods](https://github.com/duncanawoods)) [\#467](https://github.com/ElectronNET/Electron.NET/pull/467)
+
+ElectronNET.API:
+
+* New Feature: Native Electron 11.1.1 support, but not all new features (we search contributors)
+* Breaking API Changes (from native Electron 11.0): - Removed: BrowserView.{destroy, fromId, fromWebContents, getAllViews} and id property of BrowserView
+* New Feature: Upgrade to .NET 5 (thanks [scottkuhl](https://github.com/scottkuhl)) [\#509](https://github.com/ElectronNET/Electron.NET/pull/509)
+* New Feature: Extension Method for adding the Electron static class members to the standard MS DI Containers, this is a QOL issue only. `services.AddElectron()` (thanks [danatcofo](https://github.com/danatcofo )) [\#528](https://github.com/ElectronNET/Electron.NET/pull/528)
+* New Feature: SetMenu completed for the Dock (MacOS) (thanks [danatcofo](https://github.com/danatcofo )) [\#528](https://github.com/ElectronNET/Electron.NET/pull/528)
+
+Example for the Dock Menu
+
+`Electron.Dock.SetMenu(new [] {
+   new MenuItem {
+      Label = "Dock Menu Item",
+      Click = () => {
+         // do something
+      }
+   },
+});`
+
+Example for consuming the activate event (MacOs only)
+
+`Electron.App.On("activate", obj => {
+   var hasWindows = (bool)obj;
+   // do something
+});`
+
+* New Feature: On and Once implementations for the App and Tray to cover the plethora of events that are not mapped explicitly in those two modules. (thanks [danatcofo](https://github.com/danatcofo )) [\#528](https://github.com/ElectronNET/Electron.NET/pull/528)
+* New Feature: Adding the `EnableRemoteModule` property to the WebPreferences object. As of Electron 10, this property defaulted to false and without it exposed you can't use the remote module within a window. (thanks [danatcofo](https://github.com/danatcofo )) [\#528](https://github.com/ElectronNET/Electron.NET/pull/528)
+* New Feature: Adding a configurable default electron port. (thanks [aarong-av](https://github.com/aarong-av)) [\#505](https://github.com/ElectronNET/Electron.NET/pull/505)
+* New Feature: Added support for launching the application with a file on MacOS (thanks [dlitty](https://github.com/dlitty)) [\#478](https://github.com/ElectronNET/Electron.NET/pull/478)
+* Improved: Avoid Blocking Calls in App and AutoUpdater (thanks [freosc](https://github.com/freosc)) [\#474](https://github.com/ElectronNET/Electron.NET/pull/474)
+* Fixed bug: Maintain references between socket.io connection events (thanks [danatcofo](https://github.com/danatcofo )) [\#468](https://github.com/ElectronNET/Electron.NET/pull/486)
+* Fixed bug: Set default WebPreferences.DefaultFontSize (thanks [duncanawoods](https://github.com/duncanawoods)) [\#468](https://github.com/ElectronNET/Electron.NET/pull/468)
+
+# 9.31.2
+
+* Electron-Builder fixed for Windows builds.
+
+# 9.31.1
+
+ElectronNET.CLI:
+
+* New Feature: Added config parameter (thanks [konstantingross](https://github.com/konstantingross)) [\#409](https://github.com/ElectronNET/Electron.NET/pull/409)
+* New Feature: Set the configuration environment with the electron.manifest.json file.
+* Fixed bug: Custom user path removed and replaced by the correct directory with VS macro (When ElectronNET.CLI is the Startup Project, press F5 (Debug) and the ElectronNET.WebApp starts correctly without error!) (thanks [konstantingross](https://github.com/konstantingross)) [\#409](https://github.com/ElectronNET/Electron.NET/pull/409)
+
+ElectronNET.API:
+
+* New Feature: Native Electron 9.0.3 support, but not all new features (we search contributors)
+* New Feature: PowerMonitor API Support (thanks [gustavo-lara-molina](https://github.com/gustavo-lara-molina)) [\#399](https://github.com/ElectronNET/Electron.NET/pull/399) [\#423](https://github.com/ElectronNET/Electron.NET/pull/423)
+* New Feature: NativeTheme API Support (thanks [konstantingross](https://github.com/konstantingross)) [\#402](https://github.com/ElectronNET/Electron.NET/pull/402)
+* New Feature: Cookie API Support (thanks [freosc](https://github.com/freosc)) [\#413](https://github.com/ElectronNET/Electron.NET/pull/413)
+* Changed Feature: Removed dock methods from App API and moved to Dock API (thanks [konstantingross](https://github.com/konstantingross)) [\#422](https://github.com/ElectronNET/Electron.NET/pull/422)
+* App-Api Enhancement: MenuItems with Submenus need an submenu type workaround [\#412](https://github.com/ElectronNET/Electron.NET/issues/412)
+* App-Api Enhancement: Added UserAgentFallback (thanks [Mandrakia](https://github.com/Mandrakia)) [\#406](https://github.com/ElectronNET/Electron.NET/pull/406)
+* App-Api Enhancement: Summaries rewritten, new App.IsReady / App.HasSingleInstanceLock property, App.Ready event, App.Focus with force parameter method, many parameters changes (thanks [konstantingross](https://github.com/konstantingross)) [\#415](https://github.com/ElectronNET/Electron.NET/pull/415) [\#422](https://github.com/ElectronNET/Electron.NET/pull/422)
+* App-Api Enhancement: New App.IsReady property and App.Ready event (thanks [konstantingross](https://github.com/konstantingross)) [\#415](https://github.com/ElectronNET/Electron.NET/pull/415)
+* Shell-Api Enhancement: API fixes for Electron 9.0.0 / Added missing parameters / Summaries rewritten (thanks [konstantingross](https://github.com/konstantingross)) [\#417](https://github.com/ElectronNET/Electron.NET/pull/417) [\#418](https://github.com/ElectronNET/Electron.NET/pull/418)
+* Notification-Api Enhancement: Added missing properties in Notifications (thanks [konstantingross](https://github.com/konstantingross)) [\#410](https://github.com/ElectronNET/Electron.NET/pull/410)
+* BrowserWindows-Api Enhancement: Add missing API call for SetProgressBar options (thanks [konstantingross](https://github.com/konstantingross)) [\#416](https://github.com/ElectronNET/Electron.NET/pull/416)
+* BrowserWindow Enhancement: Add BrowserWindow.GetNativeWindowHandle() (thanks [kdlslyv](https://github.com/kdlslyv)) [\#429](https://github.com/ElectronNET/Electron.NET/pull/429)
+* HostHook-Api Enhancement: HostHook.CallAsync should use TaskCompletionSource.SetException instead of throwing exception (thanks [Fre V](https://github.com/freosc)) [\#430](https://github.com/ElectronNET/Electron.NET/pull/430)
+* MacOS Enhancement: Application exit logic (thanks [dafergu2](https://github.com/dafergu2)) [\#405](https://github.com/ElectronNET/Electron.NET/pull/405)
+* Fixed bug: ElectronNET.API.Entities.WebPreferences.ContextIsolation [DefaultValue(true)] [\#411](https://github.com/ElectronNET/Electron.NET/issues/411)
+
+ElectronNET.WebApp (internal use):
+* Improvement debugging and testing new API calls (without install ElectronNET.CLI) (thanks [konstantingross](https://github.com/konstantingross)) [\#425](https://github.com/ElectronNET/Electron.NET/pull/425)
+* Fixed bug: Cannot find modules in ElectronHostHook (thanks [konstantingross](https://github.com/konstantingross)) [\#425](https://github.com/ElectronNET/Electron.NET/pull/425)
+
+Thank you for donation [Phil Seeman](https://github.com/mpnow) ❤
+
 # 8.31.2
 
 ElectronNET.CLI:
@@ -15,8 +125,6 @@ ElectronNET.API:
 * New Feature: Update menu items for context menu and system tray on-the-fly. [\#270](https://github.com/ElectronNET/Electron.NET/pull/270)  
 
 
-# Released
-
 # 8.31.1
 
 ElectronNET.CLI:

ElectronNET.API/AutoUpdater.cs

@@ -1,6 +1,9 @@
 using ElectronNET.API.Entities;
+using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Serialization;
 using System;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 
 namespace ElectronNET.API
@@ -182,11 +185,48 @@ namespace ElectronNET.API
             }
         }
 
+        /// <summary>
+        /// The current application version
+        /// </summary>
+        public Task<SemVer> CurrentVersionAsync
+        {
+            get
+            {
+                return Task.Run<SemVer>(() =>
+                {
+                    var taskCompletionSource = new TaskCompletionSource<SemVer>();
+
+                    BridgeConnector.Socket.On("autoUpdater-currentVersion-get-reply", (result) =>
+                    {
+                        BridgeConnector.Socket.Off("autoUpdater-currentVersion-get-reply");
+                        SemVer version = ((JObject)result).ToObject<SemVer>();
+                        taskCompletionSource.SetResult(version);
+                    });
+                    BridgeConnector.Socket.Emit("autoUpdater-currentVersion-get");
+
+                    return taskCompletionSource.Task;
+                });
+            }
+        }
+
         /// <summary>
         /// Get the update channel. Not applicable for GitHub. 
         /// Doesn’t return channel from the update configuration, only if was previously set.
         /// </summary>
+        [Obsolete("Use the asynchronous version ChannelAsync instead")]
         public string Channel
+        {
+            get
+            {
+                return ChannelAsync.Result;
+            }
+        }
+
+        /// <summary>
+        /// Get the update channel. Not applicable for GitHub. 
+        /// Doesn’t return channel from the update configuration, only if was previously set.
+        /// </summary>
+        public Task<string> ChannelAsync
         {
             get
             {
@@ -199,11 +239,45 @@ namespace ElectronNET.API
                         BridgeConnector.Socket.Off("autoUpdater-channel-get-reply");
                         taskCompletionSource.SetResult(result.ToString());
                     });
-
                     BridgeConnector.Socket.Emit("autoUpdater-channel-get");
 
                     return taskCompletionSource.Task;
-                }).Result;
+                });
+            }
+        }
+
+
+
+        /// <summary>
+        /// The request headers.
+        /// </summary>
+        public Task<Dictionary<string, string>> RequestHeadersAsync
+        {
+            get
+            {
+                return Task.Run(() =>
+                {
+                    var taskCompletionSource = new TaskCompletionSource<Dictionary<string, string>>();
+                    BridgeConnector.Socket.On("autoUpdater-requestHeaders-get-reply", (headers) =>
+                    {
+                        BridgeConnector.Socket.Off("autoUpdater-requestHeaders-get-reply");
+                        Dictionary<string, string> result = ((JObject)headers).ToObject<Dictionary<string, string>>();
+                        taskCompletionSource.SetResult(result);
+                    });
+                    BridgeConnector.Socket.Emit("autoUpdater-requestHeaders-get");
+                    return taskCompletionSource.Task;
+                });
+            }
+        }
+
+        /// <summary>
+        /// The request headers.
+        /// </summary>
+        public Dictionary<string, string> RequestHeaders
+        {
+            set
+            {
+                BridgeConnector.Socket.Emit("autoUpdater-requestHeaders-set", JObject.FromObject(value, _jsonSerializer));
             }
         }
 
@@ -416,9 +490,26 @@ namespace ElectronNET.API
             string guid = Guid.NewGuid().ToString();
 
             BridgeConnector.Socket.On("autoUpdaterCheckForUpdatesComplete" + guid, (updateCheckResult) =>
+            {
+                try
+                {
+                    BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesComplete" + guid);
+                    BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesError" + guid);
+                    taskCompletionSource.SetResult(JObject.Parse(updateCheckResult.ToString()).ToObject<UpdateCheckResult>());
+                }
+                catch (Exception ex)
+                {
+                    taskCompletionSource.SetException(ex);
+                }
+            });
+            BridgeConnector.Socket.On("autoUpdaterCheckForUpdatesError" + guid, (error) =>
             {
                 BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesComplete" + guid);
-                taskCompletionSource.SetResult(JObject.Parse(updateCheckResult.ToString()).ToObject<UpdateCheckResult>());
+                BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesError" + guid);
+                string message = "An error occurred in CheckForUpdatesAsync";
+                if (error != null && !string.IsNullOrEmpty(error.ToString()))
+                    message = JsonConvert.SerializeObject(error);
+                taskCompletionSource.SetException(new Exception(message));
             });
 
             BridgeConnector.Socket.Emit("autoUpdaterCheckForUpdates", guid);
@@ -438,9 +529,29 @@ namespace ElectronNET.API
             string guid = Guid.NewGuid().ToString();
 
             BridgeConnector.Socket.On("autoUpdaterCheckForUpdatesAndNotifyComplete" + guid, (updateCheckResult) =>
+            {
+                try
+                {
+                    BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesAndNotifyComplete" + guid);
+                    BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesAndNotifyError" + guid);
+                    if (updateCheckResult == null)
+                        taskCompletionSource.SetResult(null);
+                    else
+                        taskCompletionSource.SetResult(JObject.Parse(updateCheckResult.ToString()).ToObject<UpdateCheckResult>());
+                }
+                catch (Exception ex)
+                {
+                    taskCompletionSource.SetException(ex);
+                }
+            });
+            BridgeConnector.Socket.On("autoUpdaterCheckForUpdatesAndNotifyError" + guid, (error) =>
             {
                 BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesAndNotifyComplete" + guid);
-                taskCompletionSource.SetResult(JObject.Parse(updateCheckResult.ToString()).ToObject<UpdateCheckResult>());
+                BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesAndNotifyError" + guid);
+                string message = "An error occurred in autoUpdaterCheckForUpdatesAndNotify";
+                if (error != null)
+                    message = JsonConvert.SerializeObject(error);
+                taskCompletionSource.SetException(new Exception(message));
             });
 
             BridgeConnector.Socket.Emit("autoUpdaterCheckForUpdatesAndNotify", guid);
@@ -501,5 +612,10 @@ namespace ElectronNET.API
 
             return taskCompletionSource.Task;
         }
+
+        private readonly JsonSerializer _jsonSerializer = new JsonSerializer()
+        {
+            ContractResolver = new CamelCasePropertyNamesContractResolver()
+        };
     }
 }

ElectronNET.API/BrowserView.cs

@@ -2,9 +2,6 @@
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using Newtonsoft.Json.Serialization;
-using System;
-using System.Collections.Generic;
-using System.Text;
 using System.Threading.Tasks;
 
 namespace ElectronNET.API
@@ -29,30 +26,6 @@ namespace ElectronNET.API
         /// </summary>
         public WebContents WebContents { get; internal set; }
 
-        /// <summary>
-        /// Whether the view is destroyed.
-        /// </summary>
-        public Task<bool> IsDestroyedAsync
-        {
-            get
-            {
-                return Task.Run<bool>(() =>
-                {
-                    var taskCompletionSource = new TaskCompletionSource<bool>();
-
-                    BridgeConnector.Socket.On("browserView-isDestroyed-reply", (result) =>
-                    {
-                        BridgeConnector.Socket.Off("browserView-isDestroyed-reply");
-                        taskCompletionSource.SetResult((bool)result);
-                    });
-
-                    BridgeConnector.Socket.Emit("browserView-isDestroyed", Id);
-
-                    return taskCompletionSource.Task;
-                });
-            }
-        }
-
         /// <summary>
         /// Resizes and moves the view to the supplied bounds relative to the window.
         /// 
@@ -83,8 +56,6 @@ namespace ElectronNET.API
             }
         }
 
-        internal Action<BrowserView> Destroyed;
-
         /// <summary>
         /// BrowserView
         /// </summary>
@@ -97,18 +68,6 @@ namespace ElectronNET.API
             WebContents = new WebContents(id + 1000);
         }
 
-        /// <summary>
-        /// Force closing the view, the `unload` and `beforeunload` events won't be emitted
-        /// for the web page.After you're done with a view, call this function in order to
-        /// free memory and other resources as soon as possible.
-        /// </summary>
-        public void Destroy()
-        {
-            BridgeConnector.Socket.Emit("browserView-destroy", Id);
-
-            Destroyed?.Invoke(this);
-        }
-
         /// <summary>
         /// (experimental)
         /// </summary>

ElectronNET.API/BrowserWindow.cs

@@ -1809,6 +1809,25 @@ namespace ElectronNET.API
             return taskCompletionSource.Task;
         }
 
+        /// <summary>
+        /// Returns the native type of the handle is HWND on Windows, NSView* on macOS, and Window (unsigned long) on Linux.
+        /// </summary>
+        /// <returns>string of the native handle obtained, HWND on Windows, NSView* on macOS, and Window (unsigned long) on Linux.</returns>
+        public Task<string> GetNativeWindowHandle()
+        {
+            var taskCompletionSource = new TaskCompletionSource<string>();
+
+            BridgeConnector.Socket.On("browserWindow-getNativeWindowHandle-completed", (nativeWindowHandle) =>
+            {
+                BridgeConnector.Socket.Off("browserWindow-getNativeWindowHandle-completed");
+                taskCompletionSource.SetResult(nativeWindowHandle.ToString());
+            });
+
+            BridgeConnector.Socket.Emit("browserWindowGetNativeWindowHandle", Id);
+
+            return taskCompletionSource.Task;
+        }
+
         /// <summary>
         /// Sets the pathname of the file the window represents, 
         /// and the icon of the file will show in window’s title bar.
@@ -2321,58 +2340,5 @@ namespace ElectronNET.API
             ContractResolver = new CamelCasePropertyNamesContractResolver(),
             NullValueHandling = NullValueHandling.Ignore
         };
-
-        /// <summary>
-        /// Adds Chrome extension located at path, and returns extension's name.
-        /// The method will also not return if the extension's manifest is missing or incomplete.
-        /// Note: This API cannot be called before the ready event of the app module is emitted.
-        /// </summary>
-        /// <param name="path">Path to the Chrome extension</param>
-        /// <returns></returns>
-        public static Task<string> AddExtensionAsync(string path)
-        {
-            var taskCompletionSource = new TaskCompletionSource<string>();
-
-            BridgeConnector.Socket.On("browserWindow-addExtension-completed", (extensionname) => {
-                BridgeConnector.Socket.Off("browserWindow-addExtension-completed");
-
-                taskCompletionSource.SetResult(extensionname.ToString());
-            });
-
-            BridgeConnector.Socket.Emit("browserWindowAddExtension", path);
-
-            return taskCompletionSource.Task;
-        }
-
-        /// <summary>
-        /// Remove Chrome extension with the specified name.
-        /// Note: This API cannot be called before the ready event of the app module is emitted.
-        /// </summary>
-        /// <param name="name">Name of the Chrome extension to remove</param>
-        public static void RemoveExtension(string name)
-        {
-            BridgeConnector.Socket.Emit("browserWindowRemoveExtension", name);
-        }
-
-        /// <summary>
-        /// The keys are the extension names and each value is an object containing name and version properties.
-        /// Note: This API cannot be called before the ready event of the app module is emitted.
-        /// </summary>
-        /// <returns></returns>
-        public static Task<ChromeExtensionInfo[]> GetExtensionsAsync()
-        {
-            var taskCompletionSource = new TaskCompletionSource<ChromeExtensionInfo[]>();
-
-            BridgeConnector.Socket.On("browserWindow-getExtensions-completed", (extensionslist) => {
-                BridgeConnector.Socket.Off("browserWindow-getExtensions-completed");
-                var chromeExtensionInfos = ((JArray)extensionslist).ToObject<ChromeExtensionInfo[]>();
-                
-                taskCompletionSource.SetResult(chromeExtensionInfos);
-            });
-
-            BridgeConnector.Socket.Emit("browserWindowGetExtensions");
-
-            return taskCompletionSource.Task;
-        }
     }
 }

ElectronNET.API/Cookies.cs

@@ -0,0 +1,154 @@
+using System;
+using System.Threading.Tasks;
+using ElectronNET.API.Entities;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Serialization;
+
+namespace ElectronNET.API
+{
+    /// <summary>
+    /// Query and modify a session's cookies.
+    /// </summary>
+    public class Cookies
+    {
+        /// <summary>
+        /// Gets the identifier.
+        /// </summary>
+        /// <value>
+        /// The identifier.
+        /// </value>
+        public int Id { get; private set; }
+
+        internal Cookies(int id)
+        {
+            Id = id;
+        }
+
+        /// <summary>
+        /// Emitted when a cookie is changed because it was added, edited, removed, or expired.
+        /// </summary>
+        public event Action<Cookie, CookieChangedCause, bool> OnChanged
+        {
+            add
+            {
+                if (_changed == null)
+                {
+                    BridgeConnector.Socket.On("webContents-session-cookies-changed" + Id, (args) =>
+                    {
+                        Cookie cookie = ((JArray)args)[0].ToObject<Cookie>();
+                        CookieChangedCause cause = ((JArray)args)[1].ToObject<CookieChangedCause>();
+                        bool removed = ((JArray)args)[2].ToObject<bool>();
+                        _changed(cookie, cause, removed);
+                    });
+
+                    BridgeConnector.Socket.Emit("register-webContents-session-cookies-changed", Id);
+                }
+                _changed += value;
+            }
+            remove
+            {
+                _changed -= value;
+
+                if (_changed == null)
+                    BridgeConnector.Socket.Off("webContents-session-cookies-changed" + Id);
+            }
+        }
+
+        private event Action<Cookie, CookieChangedCause, bool> _changed;
+
+        /// <summary>
+        /// Sends a request to get all cookies matching filter, and resolves a callack with the response.
+        /// </summary>
+        /// <param name="filter">
+        /// </param>
+        /// <returns>A task which resolves an array of cookie objects.</returns>
+        public Task<Cookie[]> GetAsync(CookieFilter filter)
+        {
+            var taskCompletionSource = new TaskCompletionSource<Cookie[]>();
+            string guid = Guid.NewGuid().ToString();
+
+            BridgeConnector.Socket.On("webContents-session-cookies-get-completed" + guid, (cookies) =>
+            {
+                Cookie[] result = ((JArray)cookies).ToObject<Cookie[]>();
+
+                BridgeConnector.Socket.Off("webContents-session-cookies-get-completed" + guid);
+                taskCompletionSource.SetResult(result);
+            });
+
+            BridgeConnector.Socket.Emit("webContents-session-cookies-get", Id, JObject.FromObject(filter, _jsonSerializer), guid);
+
+            return taskCompletionSource.Task;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="details"></param>
+        /// <returns></returns>
+        public Task SetAsync(CookieDetails details)
+        {
+            var taskCompletionSource = new TaskCompletionSource<object>();
+            string guid = Guid.NewGuid().ToString();
+
+            BridgeConnector.Socket.On("webContents-session-cookies-set-completed" + guid, () =>
+            {
+                BridgeConnector.Socket.Off("webContents-session-cookies-set-completed" + guid);
+                taskCompletionSource.SetResult(null);
+            });
+
+            BridgeConnector.Socket.Emit("webContents-session-cookies-set", Id, JObject.FromObject(details, _jsonSerializer), guid);
+
+            return taskCompletionSource.Task;
+        }
+
+        /// <summary>
+        /// Removes the cookies matching url and name
+        /// </summary>
+        /// <param name="url">The URL associated with the cookie.</param>
+        /// <param name="name">The name of cookie to remove.</param>
+        /// <returns>A task which resolves when the cookie has been removed</returns>
+        public Task RemoveAsync(string url, string name)
+        {
+            var taskCompletionSource = new TaskCompletionSource<object>();
+            string guid = Guid.NewGuid().ToString();
+
+            BridgeConnector.Socket.On("webContents-session-cookies-remove-completed" + guid, () =>
+            {
+                BridgeConnector.Socket.Off("webContents-session-cookies-remove-completed" + guid);
+                taskCompletionSource.SetResult(null);
+            });
+
+            BridgeConnector.Socket.Emit("webContents-session-cookies-remove", Id, url, name, guid);
+
+            return taskCompletionSource.Task;
+        }
+
+        /// <summary>
+        /// Writes any unwritten cookies data to disk.
+        /// </summary>
+        /// <returns>A task which resolves when the cookie store has been flushed</returns>
+        public Task FlushStoreAsync()
+        {
+            var taskCompletionSource = new TaskCompletionSource<object>();
+            string guid = Guid.NewGuid().ToString();
+
+            BridgeConnector.Socket.On("webContents-session-cookies-flushStore-completed" + guid, () =>
+            {
+                BridgeConnector.Socket.Off("webContents-session-cookies-flushStore-completed" + guid);
+                taskCompletionSource.SetResult(null);
+            });
+
+            BridgeConnector.Socket.Emit("webContents-session-cookies-flushStore", Id, guid);
+
+            return taskCompletionSource.Task;
+        }
+
+        private JsonSerializer _jsonSerializer = new JsonSerializer()
+        {
+            ContractResolver = new CamelCasePropertyNamesContractResolver(),
+            NullValueHandling = NullValueHandling.Ignore,
+            DefaultValueHandling = DefaultValueHandling.Ignore
+        };
+    }
+}

ElectronNET.API/Dock.cs

@@ -0,0 +1,232 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using ElectronNET.API.Entities;
+using ElectronNET.API.Extensions;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Serialization;
+
+namespace ElectronNET.API
+{
+    /// <summary>
+    /// Control your app in the macOS dock.
+    /// </summary>
+    public sealed class Dock
+    {
+        private static Dock _dock;
+        private static object _syncRoot = new object();
+
+        internal Dock()
+        {
+        }
+
+        internal static Dock Instance
+        {
+            get
+            {
+                if (_dock == null)
+                {
+                    lock (_syncRoot)
+                    {
+                        if (_dock == null)
+                        {
+                            _dock = new Dock();
+                        }
+                    }
+                }
+
+                return _dock;
+            }
+        }
+
+        /// <summary>
+        /// When <see cref="DockBounceType.Critical"/> is passed, the dock icon will bounce until either the application becomes
+        /// active or the request is canceled. When <see cref="DockBounceType.Informational"/> is passed, the dock icon will bounce
+        /// for one second. However, the request remains active until either the application becomes active or the request is canceled.
+        /// <para/>
+        /// Note: This method can only be used while the app is not focused; when the app is focused it will return -1.
+        /// </summary>
+        /// <param name="type">Can be critical or informational. The default is informational.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Return an ID representing the request.</returns>
+        public async Task<int> BounceAsync(DockBounceType type, CancellationToken cancellationToken = default)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            var taskCompletionSource = new TaskCompletionSource<int>();
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
+            {
+                BridgeConnector.Socket.On("dock-bounce-completed", (id) =>
+                {
+                    BridgeConnector.Socket.Off("dock-bounce-completed");
+                    taskCompletionSource.SetResult((int) id);
+                });
+
+                BridgeConnector.Socket.Emit("dock-bounce", type.GetDescription());
+
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
+        }
+
+        /// <summary>
+        /// Cancel the bounce of id.
+        /// </summary>
+        /// <param name="id">Id of the request.</param>
+        public void CancelBounce(int id)
+        {
+            BridgeConnector.Socket.Emit("dock-cancelBounce", id);
+        }
+
+        /// <summary>
+        /// Bounces the Downloads stack if the filePath is inside the Downloads folder.
+        /// </summary>
+        /// <param name="filePath"></param>
+        public void DownloadFinished(string filePath)
+        {
+            BridgeConnector.Socket.Emit("dock-downloadFinished", filePath);
+        }
+
+        /// <summary>
+        /// Sets the string to be displayed in the dock’s badging area.
+        /// </summary>
+        /// <param name="text"></param>
+        public void SetBadge(string text)
+        {
+            BridgeConnector.Socket.Emit("dock-setBadge", text);
+        }
+
+        /// <summary>
+        /// Gets the string to be displayed in the dock’s badging area.
+        /// </summary>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>The badge string of the dock.</returns>
+        public async Task<string> GetBadgeAsync(CancellationToken cancellationToken = default)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            var taskCompletionSource = new TaskCompletionSource<string>();
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
+            {
+                BridgeConnector.Socket.On("dock-getBadge-completed", (text) =>
+                {
+                    BridgeConnector.Socket.Off("dock-getBadge-completed");
+                    taskCompletionSource.SetResult((string) text);
+                });
+
+                BridgeConnector.Socket.Emit("dock-getBadge");
+
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
+        }
+
+        /// <summary>
+        /// Hides the dock icon.
+        /// </summary>
+        public void Hide()
+        {
+            BridgeConnector.Socket.Emit("dock-hide");
+        }
+
+        /// <summary>
+        /// Shows the dock icon.
+        /// </summary>
+        public void Show()
+        {
+            BridgeConnector.Socket.Emit("dock-show");
+        }
+
+        /// <summary>
+        /// Whether the dock icon is visible. The app.dock.show() call is asynchronous
+        /// so this method might not return true immediately after that call.
+        /// </summary>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Whether the dock icon is visible.</returns>
+        public async Task<bool> IsVisibleAsync(CancellationToken cancellationToken = default)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            var taskCompletionSource = new TaskCompletionSource<bool>();
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
+            {
+                BridgeConnector.Socket.On("dock-isVisible-completed", (isVisible) =>
+                {
+                    BridgeConnector.Socket.Off("dock-isVisible-completed");
+                    taskCompletionSource.SetResult((bool) isVisible);
+                });
+
+                BridgeConnector.Socket.Emit("dock-isVisible");
+
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
+        }
+
+        /// <summary>
+        /// Gets the dock menu items.
+        /// </summary>
+        /// <value>
+        /// The menu items.
+        /// </value>
+        public IReadOnlyCollection<MenuItem> MenuItems { get { return _items.AsReadOnly(); } }
+        private List<MenuItem> _items = new List<MenuItem>();
+
+        /// <summary>
+        /// Sets the application's dock menu.
+        /// </summary>
+        public void SetMenu(MenuItem[] menuItems)
+        {
+            menuItems.AddMenuItemsId();
+            BridgeConnector.Socket.Emit("dock-setMenu", JArray.FromObject(menuItems, _jsonSerializer));
+            _items.AddRange(menuItems);
+
+            BridgeConnector.Socket.Off("dockMenuItemClicked");
+            BridgeConnector.Socket.On("dockMenuItemClicked", (id) => {
+                MenuItem menuItem = _items.GetMenuItem(id.ToString());
+                menuItem?.Click();
+            });
+           
+        }
+
+        /// <summary>
+        /// TODO: Menu (macOS) still to be implemented
+        /// Gets the application's dock menu.
+        /// </summary>
+        public async Task<Menu> GetMenu(CancellationToken cancellationToken = default)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            var taskCompletionSource = new TaskCompletionSource<Menu>();
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
+            {
+                BridgeConnector.Socket.On("dock-getMenu-completed", (menu) =>
+                {
+                    BridgeConnector.Socket.Off("dock-getMenu-completed");
+                    taskCompletionSource.SetResult(((JObject)menu).ToObject<Menu>());
+                });
+
+                BridgeConnector.Socket.Emit("dock-getMenu");
+
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
+        }
+
+        /// <summary>
+        /// Sets the image associated with this dock icon.
+        /// </summary>
+        /// <param name="image"></param>
+        public void SetIcon(string image)
+        {
+            BridgeConnector.Socket.Emit("dock-setIcon", image);
+        }
+
+        private JsonSerializer _jsonSerializer = new JsonSerializer()
+        {
+            ContractResolver = new CamelCasePropertyNamesContractResolver(),
+            NullValueHandling = NullValueHandling.Ignore
+        };
+    }
+}

ElectronNET.API/Electron.cs

@@ -73,5 +73,20 @@
         /// <c>electronize add HostHook</c>
         /// </summary>
         public static HostHook HostHook { get { return HostHook.Instance; } }
+
+        /// <summary>
+        /// Allows you to execute native Lock and Unlock process.       
+        /// </summary>
+        public static PowerMonitor PowerMonitor { get { return PowerMonitor.Instance; } }
+
+        /// <summary>
+        /// Read and respond to changes in Chromium's native color theme.
+        /// </summary>
+        public static NativeTheme NativeTheme { get { return NativeTheme.Instance; } }
+
+        /// <summary>
+        /// Control your app in the macOS dock.
+        /// </summary>
+        public static Dock Dock { get { return Dock.Instance; } }
     }
-}
+}

ElectronNET.API/ElectronNET.API.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <TargetFramework>net5.0</TargetFramework>
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
     <PackageOutputPath>..\artifacts</PackageOutputPath>
     <PackageId>ElectronNET.API</PackageId>
@@ -36,12 +36,12 @@ This package contains the API to access the "native" electron API.</Description>
    <FrameworkReference Include="Microsoft.AspNetCore.App" />
 </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0-beta2-19367-01">
+    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>
     <PackageReference Include="SocketIoClientDotNet" Version="1.0.5" />
-    <PackageReference Include="System.Drawing.Common" Version="4.7.0" />
+    <PackageReference Include="System.Drawing.Common" Version="5.0.0" />
   </ItemGroup>
 
 </Project>

ElectronNET.API/Entities/AboutPanelOptions.cs

@@ -1,7 +1,7 @@
 namespace ElectronNET.API.Entities
 {
     /// <summary>
-    /// 
+    /// About panel options.
     /// </summary>
     public class AboutPanelOptions
     {
@@ -20,14 +20,29 @@
         /// </summary>
         public string Copyright { get; set; }
 
+        /// <summary>
+        /// The app's build version number.
+        /// </summary>
+        public string Version { get; set; }
+
         /// <summary>
         /// Credit information.
         /// </summary>
         public string Credits { get; set; }
 
         /// <summary>
-        /// The app's build version number.
+        /// List of app authors.
         /// </summary>
-        public string Version { get; set; }
+        public string[] Authors { get; set; }
+
+        /// <summary>
+        /// The app's website.
+        /// </summary>
+        public string Website { get; set; }
+
+        /// <summary>
+        /// Path to the app's icon. On Linux, will be shown as 64x64 pixels while retaining aspect ratio.
+        /// </summary>
+        public string IconPath { get; set; }
     }
 }

ElectronNET.API/Entities/Blob.cs

@@ -0,0 +1,18 @@
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class Blob : IPostData
+    {
+        /// <summary>
+        /// The object represents a Blob
+        /// </summary>
+        public string Type { get; } = "blob";
+
+        /// <summary>
+        /// The UUID of the Blob being uploaded
+        /// </summary>
+        public string BlobUUID { get; set; }
+    }
+}

ElectronNET.API/Entities/BrowserViewConstructorOptions.cs

@@ -9,5 +9,17 @@
         /// See BrowserWindow.
         /// </summary>
         public WebPreferences WebPreferences { get; set; }
+
+        /// <summary>
+        /// A proxy to set on creation in the format host:port.
+        /// The proxy can be alternatively set using the BrowserView.WebContents.SetProxyAsync function.
+        /// </summary>
+        public string Proxy { get; set; }
+
+        /// <summary>
+        /// The credentials of the Proxy in the format username:password.
+        /// These will only be used if the Proxy field is also set.
+        /// </summary>
+        public string ProxyCredentials { get; set; }
     }
 }

ElectronNET.API/Entities/BrowserWindowOptions.cs

@@ -258,5 +258,17 @@ namespace ElectronNET.API.Entities
         /// Settings of web page's features.
         /// </summary>
         public WebPreferences WebPreferences { get; set; }
+
+        /// <summary>
+        /// A proxy to set on creation in the format host:port.
+        /// The proxy can be alternatively set using the BrowserWindow.WebContents.SetProxyAsync function.
+        /// </summary>
+        public string Proxy { get; set; }
+
+        /// <summary>
+        /// The credentials of the Proxy in the format username:password.
+        /// These will only be used if the Proxy field is also set.
+        /// </summary>
+        public string ProxyCredentials { get; set; }
     }
 }

ElectronNET.API/Entities/CPUUsage.cs

@@ -5,15 +5,15 @@
     /// </summary>
     public class CPUUsage
     {
+        /// <summary>
+        /// Percentage of CPU used since the last call to getCPUUsage. First call returns 0.
+        /// </summary>
+        public int PercentCPUUsage { get; set; }
+
         /// <summary>
         /// The number of average idle cpu wakeups per second since the last call to 
         /// getCPUUsage.First call returns 0.
         /// </summary>
         public int IdleWakeupsPerSecond { get; set; }
-
-        /// <summary>
-        /// Percentage of CPU used since the last call to getCPUUsage. First call returns 0.
-        /// </summary>
-        public int PercentCPUUsage { get; set; }
     }
 }

ElectronNET.API/Entities/Cookie.cs

@@ -0,0 +1,51 @@
+namespace ElectronNET.API.Entities {
+    /// <summary>
+    /// 
+    /// </summary>
+    public class Cookie {
+        /// <summary>
+        /// The name of the cookie.
+        /// </summary>
+        public string Name { get; set;}
+
+        /// <summary>
+        /// The value of the cookie.
+        /// </summary>
+        public string Value { get; set; }
+
+        /// <summary>
+        /// (optional) - The domain of the cookie; this will be normalized with a preceding dot so that it's also valid for subdomains.
+        /// </summary>
+        public string Domain { get; set; }
+
+        /// <summary>
+        /// (optional) - Whether the cookie is a host-only cookie; this will only be true if no domain was passed.
+        /// </summary>
+        public bool HostOnly { get; set; }
+
+        /// <summary>
+        /// (optional) - The path of the cookie.
+        /// </summary>
+        public string Path  { get; set; }
+
+        /// <summary>
+        /// (optional) - Whether the cookie is marked as secure.
+        /// </summary>
+        public bool Secure { get; set; }
+
+        /// <summary>
+        /// (optional) - Whether the cookie is marked as HTTP only.
+        /// </summary>
+        public bool HttpOnly  { get; set; }
+
+        /// <summary>
+        /// (optional) - Whether the cookie is a session cookie or a persistent cookie with an expiration date.
+        /// </summary>
+        public bool Session { get; set; }
+
+        /// <summary>
+        /// (optional) - The expiration date of the cookie as the number of seconds since the UNIX epoch. Not provided for session cookies.
+        /// </summary>
+        public long ExpirationDate { get; set; }
+    }
+}

ElectronNET.API/Entities/CookieChangedCause.cs

@@ -0,0 +1,38 @@
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+
+namespace ElectronNET.API.Entities {
+    /// <summary>
+    /// The cause of the change 
+    /// </summary>
+    [JsonConverter(typeof(StringEnumConverter))]
+    public enum CookieChangedCause 
+    {
+        /// <summary>
+        ///The cookie was changed directly by a consumer's action.
+        /// </summary>
+        [JsonProperty("explicit")]
+        @explicit,
+
+        /// <summary>
+        /// The cookie was automatically removed due to an insert operation that overwrote it.
+        /// </summary>
+        overwrite,
+
+        /// <summary>
+        ///  The cookie was automatically removed as it expired.
+        /// </summary>
+        expired,
+
+        /// <summary>
+        ///  The cookie was automatically evicted during garbage collection.
+        /// </summary>
+        evicted,
+
+        /// <summary>
+        ///   The cookie was overwritten with an already-expired expiration date.
+        /// </summary>
+        [JsonProperty("expired_overwrite")]
+        expiredOverwrite
+    }
+}

ElectronNET.API/Entities/CookieDetails.cs

@@ -0,0 +1,56 @@
+using System.ComponentModel;
+
+namespace ElectronNET.API.Entities {
+    /// <summary>
+    /// 
+    /// </summary>
+    public class CookieDetails {
+        /// <summary>
+        /// The URL to associate the cookie with. The callback will be rejected if the URL is invalid.
+        /// </summary>
+        public string Url { get; set; }
+
+        /// <summary>
+        /// (optional) - The name of the cookie. Empty by default if omitted.
+        /// </summary>
+        [DefaultValue("")]
+        public string Name { get; set; }
+
+        /// <summary>
+        /// (optional) - The value of the cookie. Empty by default if omitted.
+        /// </summary>
+        [DefaultValue("")] 
+        public string Value { get; set; }
+
+        /// <summary>
+        /// (optional) - The domain of the cookie; this will be normalized with a preceding dot so that it's also valid for subdomains. Empty by default if omitted.
+        /// </summary>
+        [DefaultValue("")]
+        public string Domain { get; set; }
+
+        /// <summary>
+        /// (optional) - The path of the cookie. Empty by default if omitted.
+        /// </summary>
+        [DefaultValue("")] 
+        public string Path { get; set; }
+
+        /// <summary>
+        /// (optional) - Whether the cookie is marked as secure. Defaults to false.
+        /// </summary>
+        [DefaultValue(false)] 
+        public bool Secure { get; set; }
+
+        /// <summary>
+        /// (optional) - Whether the cookie is marked as HTTP only. Defaults to false.
+        /// </summary>
+        [DefaultValue(false)]
+        public bool HttpOnly { get; set; }
+
+        /// <summary>
+        /// (optional) - The expiration date of the cookie as the number of seconds since the UNIX epoch. 
+        /// If omitted then the cookie becomes a session cookie and will not be retained between sessions.
+        /// </summary>
+        [DefaultValue(0)]
+        public long ExpirationDate { get; set; }
+    }
+}

ElectronNET.API/Entities/CookieFilter.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace ElectronNET.API.Entities 
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class CookieFilter 
+    {
+        /// <summary>
+        /// (optional) - Retrieves cookies which are associated with url.Empty implies retrieving cookies of all URLs.
+        /// </summary>
+        public string Url { get; set; }
+
+        /// <summary>
+        /// (optional) - Filters cookies by name.
+        /// </summary>
+        public string Name { get; set; }
+
+        /// <summary>
+        /// (optional) - Retrieves cookies whose domains match or are subdomains of domains.
+        /// </summary>
+        public string Domain { get; set; }
+
+        /// <summary>
+        /// (optional) - Retrieves cookies whose path matches path.
+        /// </summary>
+        public string Path { get; set; }
+
+        /// <summary>
+        /// (optional) - Filters cookies by their Secure property.
+        /// </summary>
+        public bool Secure { get; set; }
+
+        /// <summary>
+        /// (optional) - Filters out session or persistent cookies.
+        /// </summary>
+        public bool Session { get; set; }
+
+    }
+}

ElectronNET.API/Entities/DockBounceType.cs

@@ -1,18 +1,22 @@
-namespace ElectronNET.API
+using System.ComponentModel;
+
+namespace ElectronNET.API.Entities
 {
     /// <summary>
-    /// 
+    /// Defines the DockBounceType enumeration.
     /// </summary>
     public enum DockBounceType
     {
         /// <summary>
-        /// The critical
+        /// Dock icon will bounce until either the application becomes active or the request is canceled.
         /// </summary>
-        critical,
+        [Description("critical")]
+        Critical,
 
         /// <summary>
-        /// The informational
+        /// The dock icon will bounce for one second.
         /// </summary>
-        informational
+        [Description("informational")]
+        Informational
     }
 }

ElectronNET.API/Entities/Error.cs

@@ -1,16 +0,0 @@
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public class Error
-    {
-        /// <summary>
-        /// Gets or sets the stack.
-        /// </summary>
-        /// <value>
-        /// The stack.
-        /// </value>
-        public string Stack { get; set; }
-    }
-}

ElectronNET.API/Entities/Extension.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// Docs: https://electronjs.org/docs/api/structures/extension
+    /// </summary>
+    public class Extension
+    {
+        /// <summary>
+        /// 
+        /// </summary>
+        public string Id { get; set; }
+
+        /// <summary>
+        /// Copy of the extension's manifest data.
+        /// </summary>
+        public dynamic Manifest { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public string Name { get; set; }
+
+        /// <summary>
+        /// The extension's file path.
+        /// </summary>
+        public string Path { get; set; }
+
+        /// <summary>
+        /// The extension's `chrome-extension://` URL.
+        /// </summary>
+        public string Url { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public string Version { get; set; }
+    }
+}

ElectronNET.API/Entities/FocusOptions.cs

@@ -0,0 +1,15 @@
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// Controls the behavior of <see cref="App.Focus(FocusOptions)"/>.
+    /// </summary>
+    public class FocusOptions
+    {
+        /// <summary>
+        /// Make the receiver the active app even if another app is currently active.
+        /// <para/>
+        /// You should seek to use the <see cref="Steal"/> option as sparingly as possible.
+        /// </summary>
+        public bool Steal { get; set; }
+    }
+}

ElectronNET.API/Entities/GPUFeatureStatus.cs

@@ -8,77 +8,77 @@ namespace ElectronNET.API.Entities
     public class GPUFeatureStatus
     {
         /// <summary>
-        /// Canvas
+        /// Canvas.
         /// </summary>
         [JsonProperty("2d_canvas")]
         public string Canvas { get; set; }
 
         /// <summary>
-        /// Flash
+        /// Flash.
         /// </summary>
         [JsonProperty("flash_3d")]
         public string Flash3D { get; set; }
 
         /// <summary>
-        /// Flash Stage3D
+        /// Flash Stage3D.
         /// </summary>
         [JsonProperty("flash_stage3d")]
         public string FlashStage3D { get; set; }
 
         /// <summary>
-        /// Flash Stage3D Baseline profile
+        /// Flash Stage3D Baseline profile.
         /// </summary>
         [JsonProperty("flash_stage3d_baseline")]
         public string FlashStage3dBaseline { get; set; }
 
         /// <summary>
-        /// Compositing
+        /// Compositing.
         /// </summary>
         [JsonProperty("gpu_compositing")]
         public string GpuCompositing { get; set; }
 
         /// <summary>
-        /// Multiple Raster Threads
+        /// Multiple Raster Threads.
         /// </summary>
         [JsonProperty("multiple_raster_threads")]
         public string MultipleRasterThreads { get; set; }
 
         /// <summary>
-        /// Native GpuMemoryBuffers
+        /// Native GpuMemoryBuffers.
         /// </summary>
         [JsonProperty("native_gpu_memory_buffers")]
         public string NativeGpuMemoryBuffers { get; set; }
 
         /// <summary>
-        /// Rasterization
+        /// Rasterization.
         /// </summary>
         public string Rasterization { get; set; }
 
         /// <summary>
-        /// Video Decode
+        /// Video Decode.
         /// </summary>
         [JsonProperty("video_decode")]
         public string VideoDecode { get; set; }
 
         /// <summary>
-        /// Video Encode
+        /// Video Encode.
         /// </summary>
         [JsonProperty("video_encode")]
         public string VideoEncode { get; set; }
 
         /// <summary>
-        /// VPx Video Decode
+        /// VPx Video Decode.
         /// </summary>
         [JsonProperty("vpx_decode")]
         public string VpxDecode { get; set; }
 
         /// <summary>
-        /// WebGL
+        /// WebGL.
         /// </summary>
         public string Webgl { get; set; }
 
         /// <summary>
-        /// WebGL2
+        /// WebGL2.
         /// </summary>
         public string Webgl2 { get; set; }
     }

ElectronNET.API/Entities/IPostData.cs

@@ -0,0 +1,16 @@
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// Interface to use Electrons PostData Object
+    /// </summary>
+    public interface IPostData
+    {
+        /// <summary>
+        /// One of the following:
+        /// rawData - <see cref="UploadRawData"/> The data is available as a Buffer, in the rawData field.
+        /// file - <see cref="UploadFile"/> The object represents a file. The filePath, offset, length and modificationTime fields will be used to describe the file.
+        /// blob - <see cref="Blob"/> The object represents a Blob. The blobUUID field will be used to describe the Blob.
+        /// </summary>
+        public string Type { get; }
+    }
+}

ElectronNET.API/Entities/JumpListCategory.cs

@@ -1,8 +1,7 @@
-using ElectronNET.API.Entities;
-using Newtonsoft.Json;
+using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
 
-namespace ElectronNET.API
+namespace ElectronNET.API.Entities
 {
     /// <summary>
     /// 
@@ -25,4 +24,4 @@ namespace ElectronNET.API
         [JsonConverter(typeof(StringEnumConverter))]
         public JumpListCategoryType Type { get; set; }
     }
-}
+}

ElectronNET.API/Entities/JumpListCategoryType.cs

@@ -1,4 +1,4 @@
-namespace ElectronNET.API
+namespace ElectronNET.API.Entities
 {
     /// <summary>
     /// 

ElectronNET.API/Entities/JumpListSettings.cs

@@ -6,13 +6,16 @@
     public class JumpListSettings
     {
         /// <summary>
-        /// The minimum number of items that will be shown in the Jump List (for a more detailed description of this value see the MSDN docs).
+        /// The minimum number of items that will be shown in the Jump List (for a more detailed description of this value see the
+        /// <see href="https://msdn.microsoft.com/en-us/library/windows/desktop/dd378398(v=vs.85).aspx">MSDN</see> docs).
         /// </summary>
         public int MinItems { get; set; } = 0;
 
         /// <summary>
-        /// Array of JumpListItem objects that correspond to items that the user has explicitly removed from custom categories in the Jump List. These items must not be re-added to the Jump List in the next call to app.setJumpList(), Windows will not display any custom category that contains any of the removed items.
+        /// Array of JumpListItem objects that correspond to items that the user has explicitly removed from custom categories
+        /// in the Jump List. These items must not be re-added to the Jump List in the next call to <see cref="App.SetJumpList"/>, Windows will
+        /// not display any custom category that contains any of the removed items.
         /// </summary>
         public JumpListItem[] RemovedItems { get; set; } = new JumpListItem[0];
     }
-}
+}

ElectronNET.API/Entities/LoadURLOptions.cs

@@ -26,5 +26,11 @@
         /// Extra headers for the request.
         /// </summary>
         public string ExtraHeaders { get; set; }
+
+        /// <summary>
+        /// PostData Object for the request.
+        /// Can be <see cref="UploadRawData"/>, <see cref="UploadFile"/> or <see cref="Blob"/>
+        /// </summary>
+        public IPostData[] PostData { get; set; }
     }
 }

ElectronNET.API/Entities/LoginItemSettings.cs

@@ -6,33 +6,33 @@
     public class LoginItemSettings
     {
         /// <summary>
-        /// true if the app is set to open at login.
+        /// <see langword="true"/> if the app is set to open at login.
         /// </summary>
         public bool OpenAtLogin { get; set; }
 
         /// <summary>
-        /// true if the app is set to open as hidden at login. This setting is only 
-        /// supported on macOS.
+        /// <see langword="true"/> if the app is set to open as hidden at login. This setting is not available
+        /// on <see href="https://www.electronjs.org/docs/tutorial/mac-app-store-submission-guide">MAS builds</see>.
         /// </summary>
         public bool OpenAsHidden { get; set; }
 
         /// <summary>
-        /// true if the app was opened at login automatically. This setting is only 
-        /// supported on macOS.
+        /// <see langword="true"/> if the app was opened at login automatically. This setting is not available
+        /// on <see href="https://www.electronjs.org/docs/tutorial/mac-app-store-submission-guide">MAS builds</see>.
         /// </summary>
         public bool WasOpenedAtLogin { get; set; }
 
         /// <summary>
-        /// true if the app was opened as a hidden login item. This indicates that the app 
-        /// should not open any windows at startup.This setting is only supported on macOS.
+        /// <see langword="true"/> if the app was opened as a hidden login item. This indicates that the app should not
+        /// open any windows at startup. This setting is not available on
+        /// <see href="https://www.electronjs.org/docs/tutorial/mac-app-store-submission-guide">MAS builds</see>.
         /// </summary>
         public bool WasOpenedAsHidden { get; set; }
 
         /// <summary>
-        /// true if the app was opened as a login item that should restore the state from
-        /// the previous session.This indicates that the app should restore the windows
-        /// that were open the last time the app was closed.This setting is only supported
-        /// on macOS.
+        /// <see langword="true"/> if the app was opened as a login item that should restore the state from the previous
+        /// session. This indicates that the app should restore the windows that were open the last time the app was closed.
+        /// This setting is not available on <see href="https://www.electronjs.org/docs/tutorial/mac-app-store-submission-guide">MAS builds</see>.
         /// </summary>
         public bool RestoreState { get; set; }
     }

ElectronNET.API/Entities/LoginSettings.cs

@@ -6,16 +6,15 @@
     public class LoginSettings
     {
         /// <summary>
-        /// true to open the app at login, false to remove the app as a login item. Defaults
-        /// to false.
+        /// <see langword="true"/> to open the app at login, <see langword="false"/> to remove the app as a login item.
+        /// Defaults to <see langword="false"/>.
         /// </summary>
         public bool OpenAtLogin { get; set; }
 
         /// <summary>
-        /// true to open the app as hidden. Defaults to false. The user can edit this
-        /// setting from the System Preferences so
-        /// app.getLoginItemStatus().wasOpenedAsHidden should be checked when the app is
-        /// opened to know the current value.This setting is only supported on macOS.
+        /// <see langword="true"/> to open the app as hidden. Defaults to <see langword="false"/>. The user can edit this
+        /// setting from the System Preferences so app.getLoginItemSettings().wasOpenedAsHidden should be checked when the app is
+        /// opened to know the current value. This setting is not available on <see href="https://www.electronjs.org/docs/tutorial/mac-app-store-submission-guide">MAS builds</see>.
         /// </summary>
         public bool OpenAsHidden { get; set; }
 

ElectronNET.API/Entities/MemoryInfo.cs

@@ -6,31 +6,19 @@
     public class MemoryInfo
     {
         /// <summary>
-        /// The maximum amount of memory that has ever been pinned to actual physical RAM. 
-        /// On macOS its value will always be 0.
+        /// The amount of memory currently pinned to actual physical RAM.
         /// </summary>
-        public int PeakWorkingSetSize { get; set; }
+        public int WorkingSetSize { get; set; }
 
         /// <summary>
-        /// Process id of the process.
+        /// The maximum amount of memory that has ever been pinned to actual physical RAM. 
         /// </summary>
-        public int Pid { get; set; }
+        public int PeakWorkingSetSize { get; set; }
 
         /// <summary>
         /// The amount of memory not shared by other processes, such as JS heap or HTML
         /// content.
         /// </summary>
         public int PrivateBytes { get; set; }
-
-        /// <summary>
-        /// The amount of memory shared between processes, typically memory consumed by the 
-        /// Electron code itself
-        /// </summary>
-        public int SharedBytes { get; set; }
-
-        /// <summary>
-        /// The amount of memory currently pinned to actual physical RAM.
-        /// </summary>
-        public int WorkingSetSize {get; set; }
     }
-}
+}

ElectronNET.API/Entities/NotificationOptions.cs

@@ -10,28 +10,28 @@ namespace ElectronNET.API.Entities
     {
         /// <summary>
         /// A title for the notification, which will be shown at the top of the notification
-        /// window when it is shown
+        /// window when it is shown.
         /// </summary>
         public string Title { get; set; }
 
+        /// <summary>
+        /// A subtitle for the notification, which will be displayed below the title.
+        /// </summary>
+        public string SubTitle { get; set; }
+
         /// <summary>
         /// The body text of the notification, which will be displayed below the title or
-        /// subtitle
+        /// subtitle.
         /// </summary>
         public string Body { get; set; }
 
         /// <summary>
-        /// A subtitle for the notification, which will be displayed below the title.
-        /// </summary>
-        public string Subtitle { get; set; }
-
-        /// <summary>
-        /// Whether or not to emit an OS notification noise when showing the notification
+        /// Whether or not to emit an OS notification noise when showing the notification.
         /// </summary>
         public bool Silent { get; set; }
 
         /// <summary>
-        /// An icon to use in the notification
+        /// An icon to use in the notification.
         /// </summary>
         public string Icon { get; set; }
 
@@ -40,6 +40,11 @@ namespace ElectronNET.API.Entities
         /// </summary>
         public bool HasReply { get; set; }
 
+        /// <summary>
+        /// The timeout duration of the notification. Can be 'default' or 'never'.
+        /// </summary>
+        public string TimeoutType { get; set; }
+
         /// <summary>
         /// The placeholder to write in the inline reply input field.
         /// </summary>
@@ -50,16 +55,27 @@ namespace ElectronNET.API.Entities
         /// </summary>
         public string Sound { get; set; }
 
+        /// <summary>
+        /// The urgency level of the notification. Can be 'normal', 'critical', or 'low'.
+        /// </summary>
+        public string Urgency { get; set; }
+
         /// <summary>
         /// Actions to add to the notification. Please read the available actions and
-        /// limitations in the NotificationAction documentation
+        /// limitations in the NotificationAction documentation.
         /// </summary>
         public NotificationAction Actions { get; set; }
 
         /// <summary>
-        /// Emitted when the notification is shown to the user, 
-        /// note this could be fired multiple times as a notification 
-        /// can be shown multiple times through the Show() method.
+        /// A custom title for the close button of an alert. An empty string will cause the
+        /// default localized text to be used.
+        /// </summary>
+        public string CloseButtonText { get; set; }
+
+        /// <summary>
+        /// Emitted when the notification is shown to the user, note this could be fired
+        /// multiple times as a notification can be shown multiple times through the Show()
+        /// method.
         /// </summary>
         [JsonIgnore]
         public Action OnShow { get; set; }
@@ -148,4 +164,4 @@ namespace ElectronNET.API.Entities
             Body = body;
         }
     }
-}
+}

ElectronNET.API/Entities/OpenExternalOptions.cs

@@ -1,16 +1,22 @@
-using System.ComponentModel;
+using System;
+using System.ComponentModel;
 
 namespace ElectronNET.API.Entities
 {
     /// <summary>
-    /// 
+    /// Controls the behavior of OpenExternal.
     /// </summary>
     public class OpenExternalOptions
     {
         /// <summary>
-        /// true to bring the opened application to the foreground. The default is true.
+        /// <see langword="true"/> to bring the opened application to the foreground. The default is <see langword="true"/>.
         /// </summary>
         [DefaultValue(true)]
         public bool Activate { get; set; } = true;
+
+        /// <summary>
+        /// The working directory.
+        /// </summary>
+        public string WorkingDirectory { get; set; }
     }
 }

ElectronNET.API/Entities/PathName.cs

@@ -1,79 +1,95 @@
-namespace ElectronNET.API.Entities
+using System.ComponentModel;
+
+namespace ElectronNET.API.Entities
 {
     /// <summary>
-    /// 
+    /// Defines the PathName enumeration.
     /// </summary>
     public enum PathName
     {
         /// <summary>
         /// User’s home directory.
         /// </summary>
-        home,
+        [Description("home")]
+        Home,
 
         /// <summary>
         /// Per-user application data directory.
         /// </summary>
-        appData,
+        [Description("appData")]
+        AppData,
 
         /// <summary>
         /// The directory for storing your app’s configuration files, 
         /// which by default it is the appData directory appended with your app’s name.
         /// </summary>
-        userData,
+        [Description("userData")]
+        UserData,
 
         /// <summary>
         /// Temporary directory.
         /// </summary>
-        temp,
+        [Description("temp")]
+        Temp,
 
         /// <summary>
         /// The current executable file.
         /// </summary>
-        exe,
+        [Description("exe")]
+        Exe,
 
         /// <summary>
         /// The libchromiumcontent library.
         /// </summary>
-        module,
+        [Description("Module")]
+        Module,
 
         /// <summary>
         /// The current user’s Desktop directory.
         /// </summary>
-        desktop,
+        [Description("desktop")]
+        Desktop,
 
         /// <summary>
         /// Directory for a user’s “My Documents”.
         /// </summary>
-        documents,
+        [Description("documents")]
+        Documents,
 
         /// <summary>
         /// Directory for a user’s downloads.
         /// </summary>
-        downloads,
+        [Description("downloads")]
+        Downloads,
 
         /// <summary>
         /// Directory for a user’s music.
         /// </summary>
-        music,
+        [Description("music")]
+        Music,
 
         /// <summary>
         /// Directory for a user’s pictures.
         /// </summary>
-        pictures,
+        [Description("pictures")]
+        Pictures,
 
         /// <summary>
         /// Directory for a user’s videos.
         /// </summary>
-        videos,
+        [Description("videos")]
+        Videos,
 
         /// <summary>
-        /// The logs
+        /// The logs.
         /// </summary>
-        logs,
+        [Description("logs")]
+        Logs,
 
         /// <summary>
         /// Full path to the system version of the Pepper Flash plugin.
         /// </summary>
-        pepperFlashSystemPlugin
+        [Description("PepperFlashSystemPlugin")]
+        PepperFlashSystemPlugin
     }
 }

ElectronNET.API/Entities/ProcessMetric.cs

@@ -5,24 +5,42 @@
     /// </summary>
     public class ProcessMetric
     {
-      /// <summary>
-      /// CPU usage of the process.
-      /// </summary>
-      public CPUUsage Cpu { get; set; }
+        /// <summary>
+        /// Process id of the process.
+        /// </summary>
+        public int PId { get; set; }
 
-      /// <summary>
-      /// Memory information for the process.
-      /// </summary>
-      public MemoryInfo Memory {get; set;}
+        /// <summary>
+        /// Process type (Browser or Tab or GPU etc).
+        /// </summary>
+        public string Type { get; set; }
 
-      /// <summary>
-      /// Process id of the process.
-      /// </summary>
-      public int Pid { get; set; }
+        /// <summary>
+        /// CPU usage of the process.
+        /// </summary>
+        public CPUUsage Cpu { get; set; }
 
-      /// <summary>
-      /// Process type (Browser or Tab or GPU etc).
-      /// </summary>
-      public string Type { get; set; }
+        /// <summary>
+        /// Creation time for this process. The time is represented as number of milliseconds since epoch.
+        /// Since the <see cref="PId"/> can be reused after a process dies, it is useful to use both the <see cref="PId"/>
+        /// and the <see cref="CreationTime"/> to uniquely identify a process.
+        /// </summary>
+        public int CreationTime { get; set; }
+
+        /// <summary>
+        /// Memory information for the process.
+        /// </summary>
+        public MemoryInfo Memory { get; set; }
+
+        /// <summary>
+        /// Whether the process is sandboxed on OS level.
+        /// </summary>
+        public bool Sandboxed { get; set; }
+
+        /// <summary>
+        ///  One of the following values:
+        /// untrusted | low | medium | high | unknown
+        /// </summary>
+        public string IntegrityLevel { get; set; }
     }
-}
+}

ElectronNET.API/Entities/RelaunchOptions.cs

@@ -1,7 +1,7 @@
 namespace ElectronNET.API.Entities
 {
     /// <summary>
-    /// 
+    /// Controls the behavior of <see cref="App.Relaunch(RelaunchOptions)"/>.
     /// </summary>
     public class RelaunchOptions
     {
@@ -21,4 +21,4 @@
         /// </value>
         public string ExecPath { get; set; }
     }
-}
+}

ElectronNET.API/Entities/RemoveClientCertificate.cs

@@ -1,31 +0,0 @@
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public class RemoveClientCertificate
-    {
-        /// <summary>
-        /// Origin of the server whose associated client certificate must be removed from
-        /// the cache.
-        /// </summary>
-        public string Origin { get; set; }
-
-        /// <summary>
-        /// clientCertificate.
-        /// </summary>
-        public string Type { get; set; }
-
-        /// <summary>
-        /// 
-        /// </summary>
-        /// <param name="origin">Origin of the server whose associated client certificate 
-        /// must be removed from the cache.</param>
-        /// <param name="type">clientCertificate.</param>
-        public RemoveClientCertificate(string origin, string type)
-        {
-            Origin = origin;
-            Type = type;
-        }
-    }
-}

ElectronNET.API/Entities/SemVer.cs

@@ -0,0 +1,59 @@
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class SemVer
+    {
+        /// <summary>
+        /// 
+        /// </summary>
+       public string  Raw { get; set; }
+        /// <summary>
+        /// 
+        /// </summary>
+        public bool Loose { get; set; }
+        /// <summary>
+        /// 
+        /// </summary>
+        public SemVerOptions Options { get; set; }
+        /// <summary>
+        /// 
+        /// </summary>
+        public int Major { get; set; }
+        /// <summary>
+        /// 
+        /// </summary>
+        public int Minor { get; set; }
+        /// <summary>
+        /// 
+        /// </summary>
+        public int Patch { get; set; }
+        /// <summary>
+        /// 
+        /// </summary>
+        public string Version { get; set; }
+        /// <summary>
+        /// 
+        /// </summary>
+        public string[] Build { get; set; }
+        /// <summary>
+        /// 
+        /// </summary>
+        public string[] Prerelease { get; set; }
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public class SemVerOptions {
+        /// <summary>
+        /// 
+        /// </summary>
+        public bool? Loose { get; set; }
+        /// <summary>
+        /// 
+        /// </summary>
+        public bool? IncludePrerelease { get; set; }
+    }
+}

ElectronNET.API/Entities/ShortcutDetails.cs

@@ -1,38 +1,38 @@
-namespace ElectronNET.API
+namespace ElectronNET.API.Entities
 {
     /// <summary>
-    /// 
+    /// Structure of a shortcut.
     /// </summary>
     public class ShortcutDetails
     {
         /// <summary>
-        /// The Application User Model ID. Default is empty.
+        /// The Application User Model ID. Default is <see cref="string.Empty"/>.
         /// </summary>
         public string AppUserModelId { get; set; }
 
         /// <summary>
-        /// The arguments to be applied to target when launching from this shortcut. Default is empty.
+        /// The arguments to be applied to <see cref="Target"/> when launching from this shortcut. Default is <see cref="string.Empty"/>.
         /// </summary>
         public string Args { get; set; }
 
         /// <summary>
-        /// The working directory. Default is empty.
+        /// The working directory. Default is <see cref="string.Empty"/>.
         /// </summary>
         public string Cwd { get; set; }
 
         /// <summary>
-        /// The description of the shortcut. Default is empty.
+        /// The description of the shortcut. Default is <see cref="string.Empty"/>.
         /// </summary>
         public string Description { get; set; }
 
         /// <summary>
-        /// The path to the icon, can be a DLL or EXE. icon and iconIndex have to be set
-        /// together.Default is empty, which uses the target's icon.
+        /// The path to the icon, can be a DLL or EXE. <see cref="Icon"/> and <see cref="IconIndex"/> have to be set
+        /// together. Default is <see cref="string.Empty"/>, which uses the target's icon.
         /// </summary>
         public string Icon { get; set; }
 
         /// <summary>
-        /// The resource ID of icon when icon is a DLL or EXE. Default is 0.
+        /// The resource ID of icon when <see cref="Icon"/> is a DLL or EXE. Default is 0.
         /// </summary>
         public int IconIndex { get; set; }
 

ElectronNET.API/Entities/ShortcutLinkOperation.cs

@@ -1,23 +1,28 @@
-namespace ElectronNET.API
+using System.ComponentModel;
+
+namespace ElectronNET.API.Entities
 {
     /// <summary>
-    /// 
+    /// Defines the ShortcutLinkOperation enumeration.
     /// </summary>
     public enum ShortcutLinkOperation
     {
         /// <summary>
         /// Creates a new shortcut, overwriting if necessary.
         /// </summary>
-        create,
+        [Description("create")]
+        Create,
 
         /// <summary>
         /// Updates specified properties only on an existing shortcut.
         /// </summary>
-        update,
+        [Description("update")]
+        Update,
 
         /// <summary>
-        /// Overwrites an existing shortcut, fails if the shortcut doesn’t exist.
+        /// Overwrites an existing shortcut, fails if the shortcut doesn't exist.
         /// </summary>
-        replace
+        [Description("replace")]
+        Replace
     }
-}
+}

ElectronNET.API/Entities/ThemeSourceMode.cs

@@ -0,0 +1,28 @@
+using System.ComponentModel;
+
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// Defines the ThemeSourceMode enumeration.
+    /// </summary>
+    public enum ThemeSourceMode
+    {
+        /// <summary>
+        /// Operating system default.
+        /// </summary>
+        [Description("system")]
+        System,
+
+        /// <summary>
+        /// Light theme.
+        /// </summary>
+        [Description("light")]
+        Light,
+
+        /// <summary>
+        /// Dark theme.
+        /// </summary>
+        [Description("dark")]
+        Dark
+    }
+}

ElectronNET.API/Entities/UploadFile.cs

@@ -0,0 +1,34 @@
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class UploadFile : IPostData
+    {
+        /// <summary>
+        /// The object represents a file.
+        /// </summary>
+        public string Type { get; } = "file";
+
+        /// <summary>
+        /// The path of the file being uploaded.
+        /// </summary>
+        public string FilePath { get; set; }
+
+        /// <summary>
+        /// The offset from the beginning of the file being uploaded, in bytes. Defaults to 0.
+        /// </summary>
+        public long Offset { get; set; } = 0;
+
+        /// <summary>
+        /// The length of the file being uploaded, <see cref="Offset"/>. Defaults to 0.
+        /// If set to -1, the whole file will be uploaded.
+        /// </summary>
+        public long Length { get; set; } = 0;
+
+        /// <summary>
+        /// The modification time of the file represented by a double, which is the number of seconds since the UNIX Epoch (Jan 1, 1970)
+        /// </summary>
+        public double ModificationTime { get; set; }
+    }
+}

ElectronNET.API/Entities/UploadRawData.cs

@@ -0,0 +1,18 @@
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class UploadRawData : IPostData
+    {
+        /// <summary>
+        /// The data is available as a Buffer, in the rawData field.
+        /// </summary>
+        public string Type { get; } = "rawData";
+        
+        /// <summary>
+        /// The raw bytes of the post data in a Buffer.
+        /// </summary>
+        public byte[] Bytes { get; set; }
+    }
+}

ElectronNET.API/Entities/UserTask.cs

@@ -52,5 +52,10 @@
         /// The title.
         /// </value>
         public string Title { get; set; }
+
+        /// <summary>
+        /// The working directory. Default is <see cref="string.Empty"/>.
+        /// </summary>
+        public string WorkingDirectory { get; set; }
     }
-}
+}

ElectronNET.API/Entities/Vibrancy.cs

@@ -1,4 +1,4 @@
-using Newtonsoft.Json;
+using System.Runtime.Serialization;
 
 namespace ElectronNET.API.Entities
 {
@@ -10,7 +10,7 @@ namespace ElectronNET.API.Entities
         /// <summary>
         /// The appearance based
         /// </summary>
-        [JsonProperty("appearance-based")]
+        [EnumMember(Value = "appearance-based")]
         appearanceBased,
 
         /// <summary>
@@ -51,13 +51,13 @@ namespace ElectronNET.API.Entities
         /// <summary>
         /// The medium light
         /// </summary>
-        [JsonProperty("medium-light")]
+        [EnumMember(Value = "medium-light")]
         mediumLight,
 
         /// <summary>
         /// The ultra dark
         /// </summary>
-        [JsonProperty("ultra-dark")]
+        [EnumMember(Value = "ultra-dark")]
         ultraDark
     }
 }

ElectronNET.API/Entities/WebPreferences.cs

@@ -1,4 +1,4 @@
-using System.ComponentModel;
+using System.ComponentModel;
 
 namespace ElectronNET.API.Entities
 {
@@ -142,7 +142,7 @@ namespace ElectronNET.API.Entities
         /// <summary>
         /// Defaults to 16.
         /// </summary>
-        public int DefaultFontSize { get; set; }
+        public int DefaultFontSize { get; set; } = 16;
 
         /// <summary>
         /// Defaults to 13.
@@ -173,7 +173,7 @@ namespace ElectronNET.API.Entities
 
         /// <summary>
         /// Whether to run Electron APIs and the specified preload script in a separate
-        /// JavaScript context.Defaults to false. The context that the preload script runs
+        /// JavaScript context. Defaults to false. The context that the preload script runs
         /// in will still have full access to the document and window globals but it will
         /// use its own set of JavaScript builtins (Array, Object, JSON, etc.) and will be
         /// isolated from any changes made to the global environment by the loaded page.The
@@ -185,8 +185,8 @@ namespace ElectronNET.API.Entities
         /// Context' entry in the combo box at the top of the Console tab. This option is
         /// currently experimental and may change or be removed in future Electron releases.
         /// </summary>
-        [DefaultValue(true)]
-        public bool ContextIsolation { get; set; } = true;
+        [DefaultValue(false)]
+        public bool ContextIsolation { get; set; } = false;
 
         /// <summary>
         /// Whether to use native window.open(). Defaults to false. This option is currently experimental.
@@ -206,5 +206,11 @@ namespace ElectronNET.API.Entities
         /// </value>
         [DefaultValue(false)]
         public bool WebviewTag { get; set; } = false;
+
+        /// <summary>
+        /// Whether to enable the remote module. Defaults to false.
+        /// </summary>
+        [DefaultValue(false)]
+        public bool EnableRemoteModule { get; set; } = false;
     }
 }

ElectronNET.API/Events.cs

@@ -0,0 +1,105 @@
+using System;
+using System.Globalization;
+using Quobject.EngineIoClientDotNet.ComponentEmitter;
+
+namespace ElectronNET.API
+{
+    /// <summary>
+    /// Generic Event Consumers for Electron Modules
+    /// </summary>
+    internal class Events
+    {
+        private static Events _events;
+        private static object _syncRoot = new object();
+        private TextInfo _ti = new CultureInfo("en-US", false).TextInfo;
+        private Events()
+        {
+
+        }
+
+        public static Events Instance
+        {
+            get
+            {
+                if (_events == null)
+                {
+                    lock (_syncRoot)
+                    {
+                        if (_events == null)
+                        {
+                            _events = new Events();
+                        }
+                    }
+                }
+
+                return _events;
+            }
+        }
+
+        /// <summary>
+        /// Subscribe to an unmapped electron event.
+        /// </summary>
+        /// <param name="moduleName">The name of the module, e.g. app, dock, etc...</param>
+        /// <param name="eventName">The name of the event</param>
+        /// <param name="fn">The event handler</param>
+        public void On(string moduleName, string eventName, Action fn)
+            => On(moduleName, eventName, new ListenerImpl(fn));
+
+        /// <summary>
+        /// Subscribe to an unmapped electron event.
+        /// </summary>
+        /// <param name="moduleName">The name of the module, e.g. app, dock, etc...</param>
+        /// <param name="eventName">The name of the event</param>
+        /// <param name="fn">The event handler</param>
+        public void On(string moduleName, string eventName, Action<object> fn)
+            => On(moduleName, eventName, new ListenerImpl(fn));
+
+        /// <summary>
+        /// Subscribe to an unmapped electron event.
+        /// </summary>
+        /// <param name="moduleName">The name of the module, e.g. app, dock, etc...</param>
+        /// <param name="eventName">The name of the event</param>
+        /// <param name="fn">The event handler</param>
+        private void On(string moduleName, string eventName, IListener fn)
+        {
+            var listener = $"{moduleName}{_ti.ToTitleCase(eventName)}Completed";
+            var subscriber = $"register-{moduleName}-on-event";
+            
+            BridgeConnector.Socket.On(listener, fn);
+            BridgeConnector.Socket.Emit(subscriber, eventName, listener);
+        }
+
+        /// <summary>
+        /// Subscribe to an unmapped electron event.
+        /// </summary>
+        /// <param name="moduleName">The name of the module, e.g. app, dock, etc...</param>
+        /// <param name="eventName">The name of the event</param>
+        /// <param name="fn">The event handler</param>
+        public void Once(string moduleName, string eventName, Action fn)
+            => Once(moduleName, eventName, new ListenerImpl(fn));
+
+        /// <summary>
+        /// Subscribe to an unmapped electron event.
+        /// </summary>
+        /// <param name="moduleName">The name of the module, e.g. app, dock, etc...</param>
+        /// <param name="eventName">The name of the event</param>
+        /// <param name="fn">The event handler</param>
+        public void Once(string moduleName, string eventName, Action<object> fn)
+            => Once(moduleName, eventName, new ListenerImpl(fn));
+
+        /// <summary>
+        /// Subscribe to an unmapped electron event.
+        /// </summary>
+        /// <param name="moduleName">The name of the module, e.g. app, dock, etc...</param>
+        /// <param name="eventName">The name of the event</param>
+        /// <param name="fn">The event handler</param>
+        private void Once(string moduleName, string eventName, IListener fn)
+        {
+            var listener = $"{moduleName}{_ti.ToTitleCase(eventName)}Completed";
+            var subscriber = $"register-{moduleName}-once-event";
+            BridgeConnector.Socket.Once(listener, fn);
+            BridgeConnector.Socket.Emit(subscriber, eventName, listener);
+        }
+
+    }
+}

ElectronNET.API/Extensions/MenuItemExtensions.cs

@@ -48,5 +48,24 @@ namespace ElectronNET.API.Extensions
 
             return result;
         }
+
+        public static MenuItem[] AddSubmenuTypes(this MenuItem[] menuItems)
+        {
+            for (int index = 0; index < menuItems.Length; index++)
+            {
+                var menuItem = menuItems[index];
+                if (menuItem?.Submenu?.Length > 0)
+                {
+                    if(menuItem.Type == MenuType.normal)
+                    {
+                        menuItem.Type = MenuType.submenu;
+                    }
+
+                    AddSubmenuTypes(menuItem.Submenu);
+                }
+            }
+
+            return menuItems;
+        }
     }
 }

ElectronNET.API/HostHook.cs

@@ -72,13 +72,14 @@ namespace ElectronNET.API
             {
                 BridgeConnector.Socket.Off(socketEventName + "Error" + guid);
                 Electron.Dialog.ShowErrorBox("Host Hook Exception", result.ToString());
+                taskCompletionSource.SetException(new Exception($"Host Hook Exception {result}"));
             });
 
             BridgeConnector.Socket.On(socketEventName + "Complete" + guid, (result) =>
             {
                 BridgeConnector.Socket.Off(socketEventName + "Error" + guid);
                 BridgeConnector.Socket.Off(socketEventName + "Complete" + guid);
-                T data;
+                T data = default;
 
                 try
                 {
@@ -105,7 +106,8 @@ namespace ElectronNET.API
                 }
                 catch (Exception exception)
                 {
-                    throw new InvalidCastException("Return value does not match with the generic type.", exception);
+                    taskCompletionSource.SetException(exception);
+                    //throw new InvalidCastException("Return value does not match with the generic type.", exception);
                 }
 
                 taskCompletionSource.SetResult(data);

ElectronNET.API/IpcMain.cs

@@ -179,6 +179,45 @@ namespace ElectronNET.API
             }
         }
 
+        /// <summary>
+        /// Send a message to the BrowserView renderer process asynchronously via channel, you can also send
+        /// arbitrary arguments. Arguments will be serialized in JSON internally and hence
+        /// no functions or prototype chain will be included. The renderer process handles it by
+        /// listening for channel with ipcRenderer module.
+        /// </summary>
+        /// <param name="browserView">BrowserView with channel.</param>
+        /// <param name="channel">Channelname.</param>
+        /// <param name="data">Arguments data.</param>
+        public void Send(BrowserView browserView, string channel, params object[] data)
+        {
+            List<JObject> jobjects = new List<JObject>();
+            List<JArray> jarrays = new List<JArray>();
+            List<object> objects = new List<object>();
+
+            foreach (var parameterObject in data)
+            {
+                if(parameterObject.GetType().IsArray || parameterObject.GetType().IsGenericType && parameterObject is IEnumerable)
+                {
+                    jarrays.Add(JArray.FromObject(parameterObject, _jsonSerializer));
+                } else if(parameterObject.GetType().IsClass && !parameterObject.GetType().IsPrimitive && !(parameterObject is string))
+                {
+                    jobjects.Add(JObject.FromObject(parameterObject, _jsonSerializer));
+                } else if(parameterObject.GetType().IsPrimitive || (parameterObject is string))
+                {
+                    objects.Add(parameterObject);
+                }
+            }
+
+            if(jobjects.Count > 0 || jarrays.Count > 0)
+            {
+                BridgeConnector.Socket.Emit("sendToIpcRendererBrowserView", browserView.Id, channel, jarrays.ToArray(), jobjects.ToArray(), objects.ToArray());
+            }
+            else
+            {
+                BridgeConnector.Socket.Emit("sendToIpcRendererBrowserView", browserView.Id, channel, data);
+            }
+        }
+
         private JsonSerializer _jsonSerializer = new JsonSerializer()
         {
             ContractResolver = new CamelCasePropertyNamesContractResolver(),

ElectronNET.API/LifetimeServiceHost.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Hosting;
+
+namespace ElectronNET.API
+{
+    /// <summary>
+    /// Base class that reports if ASP.NET Core has fully started.
+    /// </summary>
+    internal class LifetimeServiceHost : IHostedService
+    {
+        public LifetimeServiceHost(IHostApplicationLifetime lifetime)
+        {
+            lifetime.ApplicationStarted.Register(() =>
+            {
+                App.Instance.IsReady = true;
+
+                Console.WriteLine("ASP.NET Core host has fully started.");
+            });
+        }
+
+        /// <summary>
+        /// Triggered when the application host is ready to start the service.
+        /// </summary>
+        /// <param name="cancellationToken">Indicates that the start process has been aborted.</param>
+        public Task StartAsync(CancellationToken cancellationToken)
+        {
+            return Task.CompletedTask;
+        }
+
+        /// <summary>
+        /// Triggered when the application host is performing a graceful shutdown.
+        /// </summary>
+        /// <param name="cancellationToken">Indicates that the shutdown process should no longer be graceful.</param>
+        public Task StopAsync(CancellationToken cancellationToken)
+        {
+            return Task.CompletedTask;
+        }
+    }
+}

ElectronNET.API/Menu.cs

@@ -56,6 +56,8 @@ namespace ElectronNET.API
             _menuItems.Clear();
 
             menuItems.AddMenuItemsId();
+            menuItems.AddSubmenuTypes();
+
             BridgeConnector.Socket.Emit("menu-setApplicationMenu", JArray.FromObject(menuItems, _jsonSerializer));
             _menuItems.AddRange(menuItems);
 
@@ -83,6 +85,8 @@ namespace ElectronNET.API
         public void SetContextMenu(BrowserWindow browserWindow, MenuItem[] menuItems)
         {
             menuItems.AddMenuItemsId();
+            menuItems.AddSubmenuTypes();
+
             BridgeConnector.Socket.Emit("menu-setContextMenu", browserWindow.Id, JArray.FromObject(menuItems, _jsonSerializer));
 
             if (!_contextMenuItems.ContainsKey(browserWindow.Id))

ElectronNET.API/NativeTheme.cs

@@ -0,0 +1,212 @@
+using System;
+using System.Threading.Tasks;
+using ElectronNET.API.Entities;
+using ElectronNET.API.Extensions;
+
+namespace ElectronNET.API
+{
+    /// <summary>
+    /// Read and respond to changes in Chromium's native color theme.
+    /// </summary>
+    public sealed class NativeTheme
+    {
+        private static NativeTheme _nativeTheme;
+        private static object _syncRoot = new object();
+
+        internal NativeTheme() { }
+
+        internal static NativeTheme Instance
+        {
+            get
+            {
+                if (_nativeTheme == null)
+                {
+                    lock (_syncRoot)
+                    {
+                        if (_nativeTheme == null)
+                        {
+                            _nativeTheme = new NativeTheme();
+                        }
+                    }
+                }
+
+                return _nativeTheme;
+            }
+        }
+
+        /// <summary>
+        /// Setting this property to <see cref="ThemeSourceMode.System"/> will remove the override and everything will be reset to the OS default. By default 'ThemeSource' is <see cref="ThemeSourceMode.System"/>.
+        /// <para/>
+        /// Settings this property to <see cref="ThemeSourceMode.Dark"/> will have the following effects:
+        /// <list type="bullet">
+        /// <item>
+        /// <description><see cref="ShouldUseDarkColorsAsync"/> will be <see langword="true"/> when accessed</description>
+        /// </item>
+        /// <item>
+        /// <description>Any UI Electron renders on Linux and Windows including context menus, devtools, etc. will use the dark UI.</description>
+        /// </item>
+        /// <item>
+        /// <description>Any UI the OS renders on macOS including menus, window frames, etc. will use the dark UI.</description>
+        /// </item>
+        /// <item>
+        /// <description>The 'prefers-color-scheme' CSS query will match 'dark' mode.</description>
+        /// </item>
+        /// <item>
+        /// <description>The 'updated' event will be emitted</description>
+        /// </item> 
+        /// </list>
+        /// <para/>
+        /// Settings this property to <see cref="ThemeSourceMode.Light"/> will have the following effects:
+        /// <list type="bullet">
+        /// <item>
+        /// <description><see cref="ShouldUseDarkColorsAsync"/> will be <see langword="false"/> when accessed</description>
+        /// </item>
+        /// <item>
+        /// <description>Any UI Electron renders on Linux and Windows including context menus, devtools, etc. will use the light UI.</description>
+        /// </item>
+        /// <item>
+        /// <description>Any UI the OS renders on macOS including menus, window frames, etc. will use the light UI.</description>
+        /// </item>
+        /// <item>
+        /// <description>The 'prefers-color-scheme' CSS query will match 'light' mode.</description>
+        /// </item>
+        /// <item>
+        /// <description>The 'updated' event will be emitted</description>
+        /// </item>
+        /// </list> 
+        /// The usage of this property should align with a classic "dark mode" state machine in your application where the user has three options.
+        /// <para/>
+        /// <list type="bullet">
+        /// <item>
+        /// <description>Follow OS: SetThemeSource(ThemeSourceMode.System);</description>
+        /// </item>
+        /// <item>
+        /// <description>Dark Mode: SetThemeSource(ThemeSourceMode.Dark);</description>
+        /// </item>
+        /// <item>
+        /// <description>Light Mode: SetThemeSource(ThemeSourceMode.Light);</description>
+        /// </item>
+        /// </list>
+        /// Your application should then always use <see cref="ShouldUseDarkColorsAsync"/> to determine what CSS to apply.
+        /// </summary>
+        /// <param name="themeSourceMode">The new ThemeSource.</param>
+        public void SetThemeSource(ThemeSourceMode themeSourceMode)
+        {
+            var themeSource = themeSourceMode.GetDescription();
+
+            BridgeConnector.Socket.Emit("nativeTheme-themeSource", themeSource);
+        }
+
+        /// <summary>
+        /// A <see cref="ThemeSourceMode"/> property that can be <see cref="ThemeSourceMode.System"/>, <see cref="ThemeSourceMode.Light"/> or <see cref="ThemeSourceMode.Dark"/>. It is used to override (<seealso cref="SetThemeSource"/>) and
+        /// supercede the value that Chromium has chosen to use internally.
+        /// </summary>
+        public Task<ThemeSourceMode> GetThemeSourceAsync()
+        {
+            var taskCompletionSource = new TaskCompletionSource<ThemeSourceMode>();
+
+            BridgeConnector.Socket.On("nativeTheme-themeSource-getCompleted", (themeSource) =>
+            {
+                BridgeConnector.Socket.Off("nativeTheme-themeSource-getCompleted");
+
+                var themeSourceValue = (ThemeSourceMode)Enum.Parse(typeof(ThemeSourceMode), (string)themeSource, true);
+
+                taskCompletionSource.SetResult(themeSourceValue);
+            });
+
+            BridgeConnector.Socket.Emit("nativeTheme-themeSource-get");
+
+            return taskCompletionSource.Task;
+        }
+
+        /// <summary>
+        /// A <see cref="bool"/> for if the OS / Chromium currently has a dark mode enabled or is
+        /// being instructed to show a dark-style UI. If you want to modify this value you
+        /// should use <see cref="SetThemeSource"/>.
+        /// </summary>
+        public Task<bool> ShouldUseDarkColorsAsync()
+        {
+            var taskCompletionSource = new TaskCompletionSource<bool>();
+
+            BridgeConnector.Socket.On("nativeTheme-shouldUseDarkColors-completed", (shouldUseDarkColors) => {
+                BridgeConnector.Socket.Off("nativeTheme-shouldUseDarkColors-completed");
+
+                taskCompletionSource.SetResult((bool)shouldUseDarkColors);
+            });
+
+            BridgeConnector.Socket.Emit("nativeTheme-shouldUseDarkColors");
+
+            return taskCompletionSource.Task;
+        }
+
+        /// <summary>
+        /// A <see cref="bool"/> for if the OS / Chromium currently has high-contrast mode enabled or is
+        /// being instructed to show a high-contrast UI.
+        /// </summary>
+        public Task<bool> ShouldUseHighContrastColorsAsync()
+        {
+            var taskCompletionSource = new TaskCompletionSource<bool>();
+
+            BridgeConnector.Socket.On("nativeTheme-shouldUseHighContrastColors-completed", (shouldUseHighContrastColors) => {
+                BridgeConnector.Socket.Off("nativeTheme-shouldUseHighContrastColors-completed");
+
+                taskCompletionSource.SetResult((bool)shouldUseHighContrastColors);
+            });
+
+            BridgeConnector.Socket.Emit("nativeTheme-shouldUseHighContrastColors");
+
+            return taskCompletionSource.Task;
+        }
+
+        /// <summary>
+        /// A <see cref="bool"/> for if the OS / Chromium currently has an inverted color scheme or is
+        /// being instructed to use an inverted color scheme.
+        /// </summary>
+        public Task<bool> ShouldUseInvertedColorSchemeAsync()
+        {
+            var taskCompletionSource = new TaskCompletionSource<bool>();
+
+            BridgeConnector.Socket.On("nativeTheme-shouldUseInvertedColorScheme-completed", (shouldUseInvertedColorScheme) => {
+                BridgeConnector.Socket.Off("nativeTheme-shouldUseInvertedColorScheme-completed");
+
+                taskCompletionSource.SetResult((bool)shouldUseInvertedColorScheme);
+            });
+
+            BridgeConnector.Socket.Emit("nativeTheme-shouldUseInvertedColorScheme");
+
+            return taskCompletionSource.Task;
+        }
+
+        /// <summary>
+        /// Emitted when something in the underlying NativeTheme has changed. This normally means that either the value of <see cref="ShouldUseDarkColorsAsync"/>,
+        /// <see cref="ShouldUseHighContrastColorsAsync"/> or <see cref="ShouldUseInvertedColorSchemeAsync"/> has changed. You will have to check them to determine which one has changed.
+        /// </summary>
+        public event Action Updated
+        {
+            add
+            {
+                if (_updated == null)
+                {
+                    BridgeConnector.Socket.On("nativeTheme-updated" + GetHashCode(), () =>
+                    {
+                        _updated();
+                    });
+
+                    BridgeConnector.Socket.Emit("register-nativeTheme-updated-event", GetHashCode());
+                }
+                _updated += value;
+            }
+            remove
+            {
+                _updated -= value;
+
+                if (_updated == null)
+                {
+                    BridgeConnector.Socket.Off("nativeTheme-updated" + GetHashCode());
+                }
+            }
+        }
+
+        private event Action _updated;
+    }
+}

ElectronNET.API/PowerMonitor.cs

@@ -0,0 +1,242 @@
+using System;
+using System.Threading.Tasks;
+
+namespace ElectronNET.API
+{
+    /// <summary>
+    /// Monitor power state changes..
+    /// </summary>
+    public sealed class PowerMonitor
+    {
+        /// <summary>
+        /// Emitted when the system is about to lock the screen. 
+        /// </summary>
+        public event Action OnLockScreen
+        {
+            add
+            {
+                if (_lockScreen == null)
+                {
+                    BridgeConnector.Socket.On("pm-lock-screen" , () =>
+                    {
+                        _lockScreen();
+                    });
+
+                    BridgeConnector.Socket.Emit("register-pm-lock-screen");
+                }
+                _lockScreen += value;
+            }
+            remove
+            {
+                _lockScreen -= value;
+
+                if (_lockScreen == null)
+                    BridgeConnector.Socket.Off("pm-lock-screen");
+            }
+        }
+
+        private event Action _lockScreen;
+
+        /// <summary>
+        /// Emitted when the system is about to unlock the screen. 
+        /// </summary>
+        public event Action OnUnLockScreen
+        {
+            add
+            {
+                if (_unlockScreen == null)
+                {
+                    BridgeConnector.Socket.On("pm-unlock-screen", () =>
+                    {
+                        _unlockScreen();
+                    });
+
+                    BridgeConnector.Socket.Emit("register-pm-unlock-screen");
+                }
+                _unlockScreen += value;
+            }
+            remove
+            {
+                _unlockScreen -= value;
+
+                if (_unlockScreen == null)
+                    BridgeConnector.Socket.Off("pm-unlock-screen");
+            }
+        }
+
+        private event Action _unlockScreen;
+
+        /// <summary>
+        /// Emitted when the system is suspending.
+        /// </summary>
+        public event Action OnSuspend
+        {
+            add
+            {
+                if (_suspend == null)
+                {
+                    BridgeConnector.Socket.On("pm-suspend", () =>
+                    {
+                        _suspend();
+                    });
+
+                    BridgeConnector.Socket.Emit("register-pm-suspend");
+                }
+                _suspend += value;
+            }
+            remove
+            {
+                _suspend -= value;
+
+                if (_suspend == null)
+                    BridgeConnector.Socket.Off("pm-suspend");
+            }
+        }
+
+        private event Action _suspend;
+
+        /// <summary>
+        /// Emitted when system is resuming.
+        /// </summary>
+        public event Action OnResume
+        {
+            add
+            {
+                if (_resume == null)
+                {
+                    BridgeConnector.Socket.On("pm-resume", () =>
+                    {
+                        _resume();
+                    });
+
+                    BridgeConnector.Socket.Emit("register-pm-resume");
+                }
+                _resume += value;
+            }
+            remove
+            {
+                _resume -= value;
+
+                if (_resume == null)
+                    BridgeConnector.Socket.Off("pm-resume");
+            }
+        }
+
+        private event Action _resume;
+
+        /// <summary>
+        /// Emitted when the system changes to AC power.
+        /// </summary>
+        public event Action OnAC
+        {
+            add
+            {
+                if (_onAC == null)
+                {
+                    BridgeConnector.Socket.On("pm-on-ac", () =>
+                    {
+                        _onAC();
+                    });
+
+                    BridgeConnector.Socket.Emit("register-pm-on-ac");
+                }
+                _onAC += value;
+            }
+            remove
+            {
+                _onAC -= value;
+
+                if (_onAC == null)
+                    BridgeConnector.Socket.Off("pm-on-ac");
+            }
+        }
+
+        private event Action _onAC;
+
+        /// <summary>
+        /// Emitted when system changes to battery power.
+        /// </summary>
+        public event Action OnBattery
+        {
+            add
+            {
+                if (_onBattery == null)
+                {
+                    BridgeConnector.Socket.On("pm-on-battery", () =>
+                    {
+                        _onBattery();
+                    });
+
+                    BridgeConnector.Socket.Emit("register-pm-on-battery");
+                }
+                _onBattery += value;
+            }
+            remove
+            {
+                _onBattery -= value;
+
+                if (_onBattery == null)
+                    BridgeConnector.Socket.Off("pm-on-battery");
+            }
+        }
+
+        private event Action _onBattery;
+
+
+        /// <summary>
+        /// Emitted when the system is about to reboot or shut down. If the event handler
+        /// invokes `e.preventDefault()`, Electron will attempt to delay system shutdown in
+        /// order for the app to exit cleanly.If `e.preventDefault()` is called, the app
+        /// should exit as soon as possible by calling something like `app.quit()`.
+        /// </summary>
+        public event Action OnShutdown
+        {
+            add
+            {
+                if (_shutdown == null)
+                {
+                    BridgeConnector.Socket.On("pm-shutdown", () =>
+                    {
+                        _shutdown();
+                    });
+
+                    BridgeConnector.Socket.Emit("register-pm-shutdown");
+                }
+                _shutdown += value;
+            }
+            remove
+            {
+                _shutdown -= value;
+
+                if (_shutdown == null)
+                    BridgeConnector.Socket.Off("pm-on-shutdown");
+            }
+        }
+
+        private event Action _shutdown;
+
+        private static PowerMonitor _powerMonitor;
+        private static object _syncRoot = new object();
+
+        internal PowerMonitor() { }
+
+        internal static PowerMonitor Instance
+        {
+            get
+            {
+                if (_powerMonitor == null)
+                {
+                    lock (_syncRoot)
+                    {
+                        if (_powerMonitor == null)
+                        {
+                            _powerMonitor = new PowerMonitor();
+                        }
+                    }
+                }
+
+                return _powerMonitor;
+            }
+        }
+    }
+}

ElectronNET.API/QuitEventArgs.cs

@@ -1,7 +1,7 @@
 namespace ElectronNET.API
 {
     /// <summary>
-    /// 
+    /// Event arguments for the <see cref="App.BeforeQuit"/> / <see cref="App.WillQuit"/> event.
     /// </summary>
     public sealed class QuitEventArgs
     {
@@ -13,4 +13,4 @@
             Electron.App.PreventQuit();
         }
     }
-}
+}

ElectronNET.API/ServiceCollectionExtensions.cs

@@ -0,0 +1,33 @@
+using Microsoft.Extensions.DependencyInjection;
+
+namespace ElectronNET.API
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public static class ServiceCollectionExtensions
+    {
+        /// <summary>
+        /// Adds the <see cref="Electron"/> Members to the Service Collection
+        /// </summary>
+        public static IServiceCollection AddElectron(this IServiceCollection services)
+            => services
+                // adding in this manner to ensure late binding.
+                .AddSingleton(provider => IpcMain.Instance)
+                .AddSingleton(provider => App.Instance)
+                .AddSingleton(provider => AutoUpdater.Instance)
+                .AddSingleton(provider => WindowManager.Instance)
+                .AddSingleton(provider => Menu.Instance)
+                .AddSingleton(provider => Dialog.Instance)
+                .AddSingleton(provider => Notification.Instance)
+                .AddSingleton(provider => Tray.Instance)
+                .AddSingleton(provider => GlobalShortcut.Instance)
+                .AddSingleton(provider => Shell.Instance)
+                .AddSingleton(provider => Screen.Instance)
+                .AddSingleton(provider => Clipboard.Instance)
+                .AddSingleton(provider => HostHook.Instance)
+                .AddSingleton(provider => PowerMonitor.Instance)
+                .AddSingleton(provider => NativeTheme.Instance)
+                .AddSingleton(provider => Dock.Instance);
+    }
+}

ElectronNET.API/Session.cs

@@ -20,9 +20,15 @@ namespace ElectronNET.API
         /// </value>
         public int Id { get; private set; }
 
+        /// <summary>
+        /// Query and modify a session's cookies.
+        /// </summary>
+        public Cookies Cookies { get; }
+
         internal Session(int id)
         {
             Id = id;
+            Cookies = new Cookies(id);
         }
 
         /// <summary>
@@ -58,8 +64,7 @@ namespace ElectronNET.API
         /// <summary>
         /// Clears the session’s HTTP authentication cache.
         /// </summary>
-        /// <param name="options"></param>
-        public Task ClearAuthCacheAsync(RemoveClientCertificate options)
+        public Task ClearAuthCacheAsync()
         {
             var taskCompletionSource = new TaskCompletionSource<object>();
             string guid = Guid.NewGuid().ToString();
@@ -70,7 +75,7 @@ namespace ElectronNET.API
                 taskCompletionSource.SetResult(null);
             });
 
-            BridgeConnector.Socket.Emit("webContents-session-clearAuthCache", Id, JObject.FromObject(options, _jsonSerializer), guid);
+            BridgeConnector.Socket.Emit("webContents-session-clearAuthCache", Id, guid);
 
             return taskCompletionSource.Task;
         }
@@ -370,6 +375,81 @@ namespace ElectronNET.API
             BridgeConnector.Socket.Emit("webContents-session-setUserAgent", Id, userAgent, acceptLanguages);
         }
 
+        /// <summary>
+        /// The keys are the extension names and each value is an object containing name and version properties.
+        /// Note: This API cannot be called before the ready event of the app module is emitted.
+        /// </summary>
+        /// <returns></returns>
+        public Task<ChromeExtensionInfo[]> GetAllExtensionsAsync()
+        {
+            var taskCompletionSource = new TaskCompletionSource<ChromeExtensionInfo[]>();
+
+            BridgeConnector.Socket.On("webContents-session-getAllExtensions-completed", (extensionslist) =>
+            {
+                BridgeConnector.Socket.Off("webContents-session-getAllExtensions-completed");
+                var chromeExtensionInfos = ((JArray)extensionslist).ToObject<ChromeExtensionInfo[]>();
+
+                taskCompletionSource.SetResult(chromeExtensionInfos);
+            });
+
+            BridgeConnector.Socket.Emit("webContents-session-getAllExtensions", Id);
+
+            return taskCompletionSource.Task;
+        }
+
+        /// <summary>
+        /// Remove Chrome extension with the specified name.
+        /// Note: This API cannot be called before the ready event of the app module is emitted.
+        /// </summary>
+        /// <param name="name">Name of the Chrome extension to remove</param>
+        public void RemoveExtension(string name)
+        {
+            BridgeConnector.Socket.Emit("webContents-session-removeExtension", Id, name);
+        }
+
+        /// <summary>
+        /// resolves when the extension is loaded.
+        ///
+        /// This method will raise an exception if the extension could not be loaded.If
+        /// there are warnings when installing the extension (e.g. if the extension requests
+        /// an API that Electron does not support) then they will be logged to the console.
+        ///
+        /// Note that Electron does not support the full range of Chrome extensions APIs.
+        /// See Supported Extensions APIs for more details on what is supported.
+        ///
+        /// Note that in previous versions of Electron, extensions that were loaded would be
+        /// remembered for future runs of the application.This is no longer the case:
+        /// `loadExtension` must be called on every boot of your app if you want the
+        /// extension to be loaded.
+        ///
+        /// This API does not support loading packed (.crx) extensions.
+        ///
+        ///** Note:** This API cannot be called before the `ready` event of the `app` module
+        /// is emitted.
+        ///
+        ///** Note:** Loading extensions into in-memory(non-persistent) sessions is not supported and will throw an error.
+        /// </summary>
+        /// <param name="path">Path to the Chrome extension</param>
+        /// <param name="allowFileAccess">Whether to allow the extension to read local files over `file://` protocol and
+        /// inject content scripts into `file://` pages. This is required e.g. for loading
+        /// devtools extensions on `file://` URLs. Defaults to false.</param>
+        /// <returns></returns>
+        public Task<Extension> LoadExtensionAsync(string path, bool allowFileAccess = false)
+        {
+            var taskCompletionSource = new TaskCompletionSource<Extension>();
+
+            BridgeConnector.Socket.On("webContents-session-loadExtension-completed", (extension) =>
+            {
+                BridgeConnector.Socket.Off("webContents-session-loadExtension-completed");
+
+                taskCompletionSource.SetResult(((JObject)extension).ToObject<Extension>());
+            });
+
+            BridgeConnector.Socket.Emit("webContents-session-loadExtension", Id, path, allowFileAccess);
+
+            return taskCompletionSource.Task;
+        }
+
         private JsonSerializer _jsonSerializer = new JsonSerializer()
         {
             ContractResolver = new CamelCasePropertyNamesContractResolver(),

ElectronNET.API/Shell.cs

@@ -2,9 +2,8 @@
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using Newtonsoft.Json.Serialization;
-using System;
-using System.Collections.Generic;
 using System.Threading.Tasks;
+using ElectronNET.API.Extensions;
 
 namespace ElectronNET.API
 {
@@ -40,17 +39,14 @@ namespace ElectronNET.API
         /// <summary>
         /// Show the given file in a file manager. If possible, select the file.
         /// </summary>
-        /// <param name="fullPath"></param>
-        /// <returns>Whether the item was successfully shown.</returns>
-        public Task<bool> ShowItemInFolderAsync(string fullPath)
+        /// <param name="fullPath">The full path to the directory / file.</param>
+        public Task ShowItemInFolderAsync(string fullPath)
         {
-            var taskCompletionSource = new TaskCompletionSource<bool>();
+            var taskCompletionSource = new TaskCompletionSource<object>();
 
-            BridgeConnector.Socket.On("shell-showItemInFolderCompleted", (success) =>
+            BridgeConnector.Socket.On("shell-showItemInFolderCompleted", () =>
             {
                 BridgeConnector.Socket.Off("shell-showItemInFolderCompleted");
-
-                taskCompletionSource.SetResult((bool)success);
             });
 
             BridgeConnector.Socket.Emit("shell-showItemInFolder", fullPath);
@@ -59,22 +55,22 @@ namespace ElectronNET.API
         }
 
         /// <summary>
-        /// Open the given file in the desktop’s default manner.
+        /// Open the given file in the desktop's default manner.
         /// </summary>
-        /// <param name="fullPath"></param>
-        /// <returns>Whether the item was successfully opened.</returns>
-        public Task<bool> OpenItemAsync(string fullPath)
+        /// <param name="path">The path to the directory / file.</param>
+        /// <returns>The error message corresponding to the failure if a failure occurred, otherwise <see cref="string.Empty"/>.</returns>
+        public Task<string> OpenPathAsync(string path)
         {
-            var taskCompletionSource = new TaskCompletionSource<bool>();
+            var taskCompletionSource = new TaskCompletionSource<string>();
 
-            BridgeConnector.Socket.On("shell-openItemCompleted", (success) =>
+            BridgeConnector.Socket.On("shell-openPathCompleted", (errorMessage) =>
             {
-                BridgeConnector.Socket.Off("shell-openItemCompleted");
+                BridgeConnector.Socket.Off("shell-openPathCompleted");
 
-                taskCompletionSource.SetResult((bool)success);
+                taskCompletionSource.SetResult((string) errorMessage);
             });
 
-            BridgeConnector.Socket.Emit("shell-openItem", fullPath);
+            BridgeConnector.Socket.Emit("shell-openPath", path);
 
             return taskCompletionSource.Task;
         }
@@ -83,106 +79,60 @@ namespace ElectronNET.API
         /// Open the given external protocol URL in the desktop’s default manner. 
         /// (For example, mailto: URLs in the user’s default mail agent).
         /// </summary>
-        /// <param name="url"></param>
-        /// <returns>Whether an application was available to open the URL. 
-        /// If callback is specified, always returns true.</returns>
-        public Task<bool> OpenExternalAsync(string url)
+        /// <param name="url">Max 2081 characters on windows.</param>
+        /// <returns>The error message corresponding to the failure if a failure occurred, otherwise <see cref="string.Empty"/>.</returns>
+        public Task<string> OpenExternalAsync(string url)
         {
-            var taskCompletionSource = new TaskCompletionSource<bool>();
-
-            BridgeConnector.Socket.On("shell-openExternalCompleted", (success) =>
-            {
-                BridgeConnector.Socket.Off("shell-openExternalCompleted");
-
-                taskCompletionSource.SetResult((bool)success);
-            });
-
-            BridgeConnector.Socket.Emit("shell-openExternal", url);
-
-            return taskCompletionSource.Task;
+            return OpenExternalAsync(url, null);
         }
 
         /// <summary>
         /// Open the given external protocol URL in the desktop’s default manner. 
         /// (For example, mailto: URLs in the user’s default mail agent).
         /// </summary>
-        /// <param name="url"></param>
-        /// <param name="options">macOS only</param>
-        /// <returns>Whether an application was available to open the URL. 
-        /// If callback is specified, always returns true.</returns>
-        public Task<bool> OpenExternalAsync(string url, OpenExternalOptions options)
+        /// <param name="url">Max 2081 characters on windows.</param>
+        /// <param name="options">Controls the behavior of OpenExternal.</param>
+        /// <returns>The error message corresponding to the failure if a failure occurred, otherwise <see cref="string.Empty"/>.</returns>
+        public Task<string> OpenExternalAsync(string url, OpenExternalOptions options)
         {
-            var taskCompletionSource = new TaskCompletionSource<bool>();
+            var taskCompletionSource = new TaskCompletionSource<string>();
 
-            BridgeConnector.Socket.On("shell-openExternalCompleted", (success) =>
+            BridgeConnector.Socket.On("shell-openExternalCompleted", (error) =>
             {
                 BridgeConnector.Socket.Off("shell-openExternalCompleted");
 
-                taskCompletionSource.SetResult((bool)success);
+                taskCompletionSource.SetResult((string) error);
             });
 
-            BridgeConnector.Socket.Emit("shell-openExternal", url, JObject.FromObject(options, _jsonSerializer));
+            if (options == null)
+            {
+                BridgeConnector.Socket.Emit("shell-openExternal", url);
+            }
+            else
+            {
+                BridgeConnector.Socket.Emit("shell-openExternal", url, JObject.FromObject(options, _jsonSerializer));
+            }
 
             return taskCompletionSource.Task;
         }
 
         /// <summary>
-        /// Open the given external protocol URL in the desktop’s default manner. 
-        /// (For example, mailto: URLs in the user’s default mail agent).
+        /// Move the given file to trash and returns a <see cref="bool"/> status for the operation.
         /// </summary>
-        /// <param name="url"></param>
-        /// <param name="options">macOS only</param>
-        /// <param name="errorAction">Action to get the error message.</param>
-        /// <returns>Whether an application was available to open the URL. 
-        /// If callback is specified, always returns true.</returns>
-        public Task<bool> OpenExternalAsync(string url, OpenExternalOptions options, Action<Error> errorAction)
-        {
-            var taskCompletionSource = new TaskCompletionSource<bool>();
-
-            BridgeConnector.Socket.On("shell-openExternalCompleted", (success) =>
-            {
-                BridgeConnector.Socket.Off("shell-openExternalCompleted");
-
-                taskCompletionSource.SetResult((bool)success);
-            });
-
-            BridgeConnector.Socket.Off("shell-openExternalCallback");
-            BridgeConnector.Socket.On("shell-openExternalCallback", (args) => {
-                var urlKey = ((JArray)args).First.ToString();
-                var error = ((JArray)args).Last.ToObject<Error>();
-
-                if(_openExternalCallbacks.ContainsKey(urlKey))
-                {
-                    _openExternalCallbacks[urlKey](error);
-                }
-            });
-
-            _openExternalCallbacks.Add(url, errorAction);
-
-            BridgeConnector.Socket.Emit("shell-openExternal", url, JObject.FromObject(options, _jsonSerializer), true);
-
-            return taskCompletionSource.Task;
-        }
-
-        private Dictionary<string, Action<Error>> _openExternalCallbacks = new Dictionary<string, Action<Error>>();
-
-        /// <summary>
-        /// Move the given file to trash and returns a boolean status for the operation.
-        /// </summary>
-        /// <param name="fullPath"></param>
+        /// <param name="fullPath">The full path to the directory / file.</param>
         /// <returns> Whether the item was successfully moved to the trash.</returns>
-        public Task<bool> MoveItemToTrashAsync(string fullPath)
+        public Task<bool> TrashItemAsync(string fullPath)
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("shell-moveItemToTrashCompleted", (success) =>
+            BridgeConnector.Socket.On("shell-trashItem-completed", (success) =>
             {
-                BridgeConnector.Socket.Off("shell-moveItemToTrashCompleted");
+                BridgeConnector.Socket.Off("shell-trashItem-completed");
 
-                taskCompletionSource.SetResult((bool)success);
+                taskCompletionSource.SetResult((bool) success);
             });
 
-            BridgeConnector.Socket.Emit("shell-moveItemToTrash", fullPath);
+            BridgeConnector.Socket.Emit("shell-trashItem", fullPath);
 
             return taskCompletionSource.Task;
         }
@@ -198,9 +148,9 @@ namespace ElectronNET.API
         /// <summary>
         /// Creates or updates a shortcut link at shortcutPath.
         /// </summary>
-        /// <param name="shortcutPath"></param>
-        /// <param name="operation"></param>
-        /// <param name="options"></param>
+        /// <param name="shortcutPath">The path to the shortcut.</param>
+        /// <param name="operation">Default is <see cref="ShortcutLinkOperation.Create"/></param>
+        /// <param name="options">Structure of a shortcut.</param>
         /// <returns>Whether the shortcut was created successfully.</returns>
         public Task<bool> WriteShortcutLinkAsync(string shortcutPath, ShortcutLinkOperation operation, ShortcutDetails options)
         {
@@ -210,21 +160,20 @@ namespace ElectronNET.API
             {
                 BridgeConnector.Socket.Off("shell-writeShortcutLinkCompleted");
 
-                taskCompletionSource.SetResult((bool)success);
+                taskCompletionSource.SetResult((bool) success);
             });
 
-            BridgeConnector.Socket.Emit("shell-writeShortcutLink", shortcutPath, operation.ToString(), JObject.FromObject(options, _jsonSerializer));
+            BridgeConnector.Socket.Emit("shell-writeShortcutLink", shortcutPath, operation.GetDescription(), JObject.FromObject(options, _jsonSerializer));
 
             return taskCompletionSource.Task;
         }
 
         /// <summary>
         /// Resolves the shortcut link at shortcutPath.
-        /// 
         /// An exception will be thrown when any error happens.
         /// </summary>
-        /// <param name="shortcutPath"></param>
-        /// <returns></returns>
+        /// <param name="shortcutPath">The path tot the shortcut.</param>
+        /// <returns><see cref="ShortcutDetails"/> of the shortcut.</returns>
         public Task<ShortcutDetails> ReadShortcutLinkAsync(string shortcutPath)
         {
             var taskCompletionSource = new TaskCompletionSource<ShortcutDetails>();
@@ -233,7 +182,10 @@ namespace ElectronNET.API
             {
                 BridgeConnector.Socket.Off("shell-readShortcutLinkCompleted");
 
-                taskCompletionSource.SetResult((ShortcutDetails)shortcutDetails);
+                var shortcutObject = shortcutDetails as JObject;
+                var details = shortcutObject?.ToObject<ShortcutDetails>();
+
+                taskCompletionSource.SetResult(details);
             });
 
             BridgeConnector.Socket.Emit("shell-readShortcutLink", shortcutPath);
@@ -241,11 +193,11 @@ namespace ElectronNET.API
             return taskCompletionSource.Task;
         }
 
-        private JsonSerializer _jsonSerializer = new JsonSerializer()
+        private readonly JsonSerializer _jsonSerializer = new JsonSerializer()
         {
             ContractResolver = new CamelCasePropertyNamesContractResolver(),
             NullValueHandling = NullValueHandling.Ignore,
             DefaultValueHandling = DefaultValueHandling.Ignore
         };
     }
-}
+}

ElectronNET.API/Tray.cs

@@ -263,6 +263,15 @@ namespace ElectronNET.API
             });
         }
 
+        /// <summary>
+        /// Shows the Traybar (empty).
+        /// </summary>
+        /// <param name="image">The image.</param>
+        public void Show(string image)
+        {
+            BridgeConnector.Socket.Emit("create-tray", image);
+        }
+
         /// <summary>
         /// Destroys the tray icon immediately.
         /// </summary>
@@ -342,5 +351,35 @@ namespace ElectronNET.API
             ContractResolver = new CamelCasePropertyNamesContractResolver(),
             NullValueHandling = NullValueHandling.Ignore
         };
+
+        private const string ModuleName = "tray";
+        /// <summary>
+        /// Subscribe to an unmapped event on the <see cref="Tray"/> module.
+        /// </summary>
+        /// <param name="eventName">The event name</param>
+        /// <param name="fn">The handler</param>
+        public void On(string eventName, Action fn)
+            => Events.Instance.On(ModuleName, eventName, fn);
+        /// <summary>
+        /// Subscribe to an unmapped event on the <see cref="Tray"/> module.
+        /// </summary>
+        /// <param name="eventName">The event name</param>
+        /// <param name="fn">The handler</param>
+        public void On(string eventName, Action<object> fn)
+            => Events.Instance.On(ModuleName, eventName, fn);
+        /// <summary>
+        /// Subscribe to an unmapped event on the <see cref="Tray"/> module once.
+        /// </summary>
+        /// <param name="eventName">The event name</param>
+        /// <param name="fn">The handler</param>
+        public void Once(string eventName, Action fn)
+            => Events.Instance.Once(ModuleName, eventName, fn);
+        /// <summary>
+        /// Subscribe to an unmapped event on the <see cref="Tray"/> module once.
+        /// </summary>
+        /// <param name="eventName">The event name</param>
+        /// <param name="fn">The handler</param>
+        public void Once(string eventName, Action<object> fn)
+            => Events.Instance.Once(ModuleName, eventName, fn);
     }
 }

ElectronNET.API/WebContents.cs

@@ -258,6 +258,18 @@ namespace ElectronNET.API
             return taskCompletionSource.Task;
         }
 
+        /// <summary>
+        /// Inserts CSS into the web page.
+        /// See: https://www.electronjs.org/docs/api/web-contents#contentsinsertcsscss-options
+        /// Works for both BrowserWindows and BrowserViews.
+        /// </summary>
+        /// <param name="isBrowserWindow">Whether the webContents belong to a BrowserWindow or not (the other option is a BrowserView)</param>
+        /// <param name="path">Absolute path to the CSS file location</param>
+        public void InsertCSS(bool isBrowserWindow, string path)
+        {
+            BridgeConnector.Socket.Emit("webContents-insertCSS", Id, isBrowserWindow, path);
+        }
+
         private JsonSerializer _jsonSerializer = new JsonSerializer()
         {
             ContractResolver = new CamelCasePropertyNamesContractResolver(),

ElectronNET.API/WebHostBuilderExtensions.cs

@@ -1,6 +1,7 @@
 using Microsoft.AspNetCore.Hosting;
 using System;
 using System.IO;
+using Microsoft.Extensions.DependencyInjection;
 
 namespace ElectronNET.API
 {
@@ -32,6 +33,11 @@ namespace ElectronNET.API
 
             if (HybridSupport.IsElectronActive)
             {
+                builder.ConfigureServices(services =>
+                {
+                    services.AddHostedService<LifetimeServiceHost>();
+                });
+
                 // check for the content folder if its exists in base director otherwise no need to include
                 // It was used before because we are publishing the project which copies everything to bin folder and contentroot wwwroot was folder there.
                 // now we have implemented the live reload if app is run using /watch then we need to use the default project path.
@@ -49,4 +55,4 @@ namespace ElectronNET.API
             return builder;
         }
     }
-}
+}

ElectronNET.API/WindowManager.cs

@@ -192,7 +192,6 @@ namespace ElectronNET.API
 
                 string browserViewId = id.ToString();
                 BrowserView browserView = new BrowserView(int.Parse(browserViewId));
-                browserView.Destroyed += (b) => _browserViews.Remove(b);
 
                 _browserViews.Add(browserView);
 

ElectronNET.CLI/Commands/Actions/DeployEmbeddedElectronFiles.cs

@@ -20,6 +20,7 @@ namespace ElectronNET.CLI.Commands.Actions
             EmbeddedFileHelper.DeployEmbeddedFile(hostApiFolder, "browserWindows.js", "api.");
             EmbeddedFileHelper.DeployEmbeddedFile(hostApiFolder, "commandLine.js", "api.");
             EmbeddedFileHelper.DeployEmbeddedFile(hostApiFolder, "dialog.js", "api.");
+            EmbeddedFileHelper.DeployEmbeddedFile(hostApiFolder, "dock.js", "api.");
             EmbeddedFileHelper.DeployEmbeddedFile(hostApiFolder, "menu.js", "api.");
             EmbeddedFileHelper.DeployEmbeddedFile(hostApiFolder, "notification.js", "api.");
             EmbeddedFileHelper.DeployEmbeddedFile(hostApiFolder, "tray.js", "api.");
@@ -30,6 +31,8 @@ namespace ElectronNET.CLI.Commands.Actions
             EmbeddedFileHelper.DeployEmbeddedFile(hostApiFolder, "clipboard.js", "api.");
             EmbeddedFileHelper.DeployEmbeddedFile(hostApiFolder, "autoUpdater.js", "api.");
             EmbeddedFileHelper.DeployEmbeddedFile(hostApiFolder, "browserView.js", "api.");
+            EmbeddedFileHelper.DeployEmbeddedFile(hostApiFolder, "powerMonitor.js", "api.");
+            EmbeddedFileHelper.DeployEmbeddedFile(hostApiFolder, "nativeTheme.js", "api.");
 
             string splashscreenFolder = Path.Combine(tempPath, "splashscreen");
             if (Directory.Exists(splashscreenFolder) == false)

ElectronNET.CLI/Commands/AddCommand.cs

@@ -75,13 +75,16 @@ namespace ElectronNET.CLI.Commands
                 // ToDo: Not sure if this runs under linux/macos
                 ProcessHelper.CmdExecute(@"npx tsc -p ../../", targetFilePath);
 
-                // search .csproj
-                Console.WriteLine($"Search your .csproj to add configure CopyToPublishDirectory to 'Never'");
-                var projectFile = Directory.EnumerateFiles(currentDirectory, "*.csproj", SearchOption.TopDirectoryOnly).FirstOrDefault();
+                // search .csproj or .fsproj (.csproj has higher precedence)
+                Console.WriteLine($"Search your .csproj/.fsproj to add configure CopyToPublishDirectory to 'Never'");
+                var projectFile = Directory.EnumerateFiles(currentDirectory, "*.csproj", SearchOption.TopDirectoryOnly)
+                    .Union(Directory.EnumerateFiles(currentDirectory, "*.fsproj", SearchOption.TopDirectoryOnly))
+                    .FirstOrDefault();
 
-                Console.WriteLine($"Found your .csproj: {projectFile} - check for existing CopyToPublishDirectory setting or update it.");
+                var extension = Path.GetExtension(projectFile);
+                Console.WriteLine($"Found your {extension}: {projectFile} - check for existing CopyToPublishDirectory setting or update it.");
 
-                if (!EditCsProj(projectFile)) return false;
+                if (!EditProjectFile(projectFile)) return false;
 
                 Console.WriteLine($"Everything done - happy electronizing with your custom npm packages!");
 
@@ -90,7 +93,7 @@ namespace ElectronNET.CLI.Commands
         }
 
         // ToDo: Cleanup this copy/past code.
-        private static bool EditCsProj(string projectFile)
+        private static bool EditProjectFile(string projectFile)
         {
             using (var stream = File.Open(projectFile, FileMode.OpenOrCreate, FileAccess.ReadWrite))
             {
@@ -128,7 +131,7 @@ namespace ElectronNET.CLI.Commands
 
             }
 
-            Console.WriteLine($"Publish setting added in csproj!");
+            Console.WriteLine($"Publish setting added in csproj/fsproj!");
             return true;
         }
 

ElectronNET.CLI/Commands/BuildCommand.cs

@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Runtime.InteropServices;
 using System.Threading.Tasks;
 using ElectronNET.CLI.Commands.Actions;
 
@@ -14,14 +13,16 @@ namespace ElectronNET.CLI.Commands
         public const string COMMAND_DESCRIPTION = "Build your Electron Application.";
         public static string COMMAND_ARGUMENTS = "Needed: '/target' with params 'win/osx/linux' to build for a typical app or use 'custom' and specify .NET Core build config & electron build config" + Environment.NewLine +
                                                  " for custom target, check .NET Core RID Catalog and Electron build target/" + Environment.NewLine +
-                                                 " e.g. '/target win' or '/target custom \"win7-x86;win32\"'" + Environment.NewLine +
+                                                 " e.g. '/target win' or '/target custom \"win7-x86;win\"'" + Environment.NewLine +
                                                  "Optional: '/dotnet-configuration' with the desired .NET Core build config e.g. release or debug. Default = Release" + Environment.NewLine +
                                                  "Optional: '/electron-arch' to specify the resulting electron processor architecture (e.g. ia86 for x86 builds). Be aware to use the '/target custom' param as well!" + Environment.NewLine +
                                                  "Optional: '/electron-params' specify any other valid parameter, which will be routed to the electron-packager." + Environment.NewLine +
                                                  "Optional: '/relative-path' to specify output a subdirectory for output." + Environment.NewLine +
                                                  "Optional: '/absolute-path to specify and absolute path for output." + Environment.NewLine +
                                                  "Optional: '/package-json' to specify a custom package.json file." + Environment.NewLine +
-                                                 "Optional: '/install-modules' to force node module install. Implied by '/package-json'"  + Environment.NewLine +                                 
+                                                 "Optional: '/install-modules' to force node module install. Implied by '/package-json'" + Environment.NewLine +
+                                                 "Optional: '/Version' to specify the version that should be applied to both the `dotnet publish` and `electron-builder` commands. Implied by '/Version'" + Environment.NewLine +
+                                                 "Optional: '/p:[property]' or '/property:[property]' to pass in dotnet publish properties.  Example: '/property:Version=1.0.0' to override the FileVersion" + Environment.NewLine +
                                                  "Full example for a 32bit debug build with electron prune: build /target custom win7-x86;win32 /dotnet-configuration Debug /electron-arch ia32  /electron-params \"--prune=true \"";
 
         public static IList<CommandOption> CommandOptions { get; set; } = new List<CommandOption>();
@@ -43,6 +44,8 @@ namespace ElectronNET.CLI.Commands
         private string _paramForceNodeInstall = "install-modules";
         private string _manifest = "manifest";
         private string _paramPublishReadyToRun = "PublishReadyToRun";
+        private string _paramPublishSingleFile = "PublishSingleFile";
+        private string _paramVersion = "Version";
 
         public Task<bool> ExecuteAsync()
         {
@@ -53,6 +56,11 @@ namespace ElectronNET.CLI.Commands
                 SimpleCommandLineParser parser = new SimpleCommandLineParser();
                 parser.Parse(_args);
 
+                //This version will be shared between the dotnet publish and electron-builder commands
+                string version = null;
+                if (parser.Arguments.ContainsKey(_paramVersion))
+                    version = parser.Arguments[_paramVersion][0];
+
                 if (!parser.Arguments.ContainsKey(_paramTarget))
                 {
                     Console.WriteLine($"Error: missing '{_paramTarget}' argument.");
@@ -78,35 +86,35 @@ namespace ElectronNET.CLI.Commands
                 Console.WriteLine($"Build ASP.NET Core App for {platformInfo.NetCorePublishRid}...");
 
                 string tempPath = Path.Combine(Directory.GetCurrentDirectory(), "obj", "desktop", desiredPlatform);
-                
+
                 if (Directory.Exists(tempPath) == false)
                 {
                     Directory.CreateDirectory(tempPath);
-                } 
+                }
                 else
                 {
                     Directory.Delete(tempPath, true);
                     Directory.CreateDirectory(tempPath);
                 }
-                
+
 
                 Console.WriteLine("Executing dotnet publish in this directory: " + tempPath);
 
                 string tempBinPath = Path.Combine(tempPath, "bin");
 
                 Console.WriteLine($"Build ASP.NET Core App for {platformInfo.NetCorePublishRid} under {configuration}-Configuration...");
+                
+                var dotNetPublishFlags = GetDotNetPublishFlags(parser);
 
-                string publishReadyToRun = "/p:PublishReadyToRun=";
-                if (parser.Arguments.ContainsKey(_paramPublishReadyToRun))
-                {
-                    publishReadyToRun += parser.Arguments[_paramPublishReadyToRun][0];
-                } 
-                else
-                {
-                    publishReadyToRun += "true";
-                }
+                var command =
+                    $"dotnet publish -r {platformInfo.NetCorePublishRid} -c \"{configuration}\" --output \"{tempBinPath}\" {string.Join(' ', dotNetPublishFlags.Select(kvp => $"{kvp.Key}={kvp.Value}"))} --self-contained";
+                
+                // output the command 
+                Console.ForegroundColor = ConsoleColor.Green;
+                Console.WriteLine(command);
+                Console.ResetColor();
 
-                var resultCode = ProcessHelper.CmdExecute($"dotnet publish -r {platformInfo.NetCorePublishRid} -c {configuration} --output \"{tempBinPath}\" {publishReadyToRun} --self-contained", Directory.GetCurrentDirectory());
+                var resultCode = ProcessHelper.CmdExecute(command, Directory.GetCurrentDirectory());
 
                 if (resultCode != 0)
                 {
@@ -128,7 +136,7 @@ namespace ElectronNET.CLI.Commands
 
                 if (Directory.Exists(checkForNodeModulesDirPath) == false || parser.Contains(_paramForceNodeInstall) || parser.Contains(_paramPackageJson))
 
-                Console.WriteLine("Start npm install...");
+                    Console.WriteLine("Start npm install...");
                 ProcessHelper.CmdExecute("npm install --production", tempPath);
 
                 Console.WriteLine("ElectronHostHook handling started...");
@@ -157,7 +165,7 @@ namespace ElectronNET.CLI.Commands
                 }
                 else if (parser.Arguments.ContainsKey(_paramOutputDirectory))
                 {
-                    buildPath = Path.Combine(Directory.GetCurrentDirectory(),parser.Arguments[_paramOutputDirectory][0]);
+                    buildPath = Path.Combine(Directory.GetCurrentDirectory(), parser.Arguments[_paramOutputDirectory][0]);
                 }
 
                 Console.WriteLine("Executing electron magic in this directory: " + buildPath);
@@ -179,20 +187,69 @@ namespace ElectronNET.CLI.Commands
 
                 string manifestFileName = "electron.manifest.json";
 
-                if(parser.Arguments.ContainsKey(_manifest))
+                if (parser.Arguments.ContainsKey(_manifest))
                 {
                     manifestFileName = parser.Arguments[_manifest].First();
                 }
 
-                ProcessHelper.CmdExecute($"node build-helper.js " + manifestFileName, tempPath);
+                ProcessHelper.CmdExecute(
+                    string.IsNullOrWhiteSpace(version)
+                        ? $"node build-helper.js {manifestFileName}"
+                        : $"node build-helper.js {manifestFileName} {version}", tempPath);
 
                 Console.WriteLine($"Package Electron App for Platform {platformInfo.ElectronPackerPlatform}...");
-                ProcessHelper.CmdExecute($"npx electron-builder . --config=./bin/electron-builder.json --{platformInfo.ElectronPackerPlatform} --{electronArch} -c.electronVersion=8.2.3 {electronParams}", tempPath);
+                ProcessHelper.CmdExecute($"npx electron-builder --config=./bin/electron-builder.json --{platformInfo.ElectronPackerPlatform} --{electronArch} -c.electronVersion=13.1.5 {electronParams}", tempPath);
 
                 Console.WriteLine("... done");
 
                 return true;
             });
         }
+
+        private Dictionary<string, string> GetDotNetPublishFlags(SimpleCommandLineParser parser)
+        {
+            var dotNetPublishFlags = new Dictionary<string, string>
+            {
+                {"/p:PublishReadyToRun", parser.TryGet(_paramPublishReadyToRun, out var rtr) ? rtr[0] : "true"},
+                {"/p:PublishSingleFile", parser.TryGet(_paramPublishSingleFile, out var psf) ? psf[0] : "true"},
+            };
+
+            if (parser.Arguments.ContainsKey(_paramVersion))
+            {
+                if(parser.Arguments.Keys.All(key => !key.StartsWith("p:Version=") && !key.StartsWith("property:Version=")))
+                    dotNetPublishFlags.Add("/p:Version", parser.Arguments[_paramVersion][0]);
+                if(parser.Arguments.Keys.All(key => !key.StartsWith("p:ProductVersion=") && !key.StartsWith("property:ProductVersion=")))
+                    dotNetPublishFlags.Add("/p:ProductVersion", parser.Arguments[_paramVersion][0]);
+            }
+
+            foreach (var parm in parser.Arguments.Keys.Where(key => key.StartsWith("p:") || key.StartsWith("property:")))
+            {
+                var split = parm.IndexOf('=');
+                if (split < 0)
+                {
+                    continue;
+                }
+
+                var key = $"/{parm.Substring(0, split)}";
+                // normalize the key
+                if (key.StartsWith("/property:"))
+                {
+                    key = key.Replace("/property:", "/p:");
+                }
+
+                var value = parm.Substring(split + 1);
+
+                if (dotNetPublishFlags.ContainsKey(key))
+                {
+                    dotNetPublishFlags[key] = value;
+                }
+                else
+                {
+                    dotNetPublishFlags.Add(key, value);
+                }
+            }
+
+            return dotNetPublishFlags;
+        }
     }
-}
+}

ElectronNET.CLI/Commands/InitCommand.cs

@@ -70,19 +70,22 @@ namespace ElectronNET.CLI.Commands
                 // Deploy config file
                 EmbeddedFileHelper.DeployEmbeddedFileToTargetFile(currentDirectory, DefaultConfigFileName, ConfigName);
 
-                // search .csproj
-                Console.WriteLine($"Search your .csproj to add the needed {ConfigName}...");
-                var projectFile = Directory.EnumerateFiles(currentDirectory, "*.csproj", SearchOption.TopDirectoryOnly).FirstOrDefault();
+                // search .csproj/.fsproj (.csproj has higher precedence)
+                Console.WriteLine($"Search your .csproj/fsproj to add the needed {ConfigName}...");
+                var projectFile = Directory.EnumerateFiles(currentDirectory, "*.csproj", SearchOption.TopDirectoryOnly)
+                    .Union(Directory.EnumerateFiles(currentDirectory, "*.fsproj", SearchOption.TopDirectoryOnly))
+                    .FirstOrDefault();
 
-                // update config file with the name of the csproj
-                // ToDo: If the csproj name != application name, this will fail
+                // update config file with the name of the csproj/fsproj
+                // ToDo: If the csproj/fsproj name != application name, this will fail
                 string text = File.ReadAllText(targetFilePath);
                 text = text.Replace("{{executable}}", Path.GetFileNameWithoutExtension(projectFile));
                 File.WriteAllText(targetFilePath, text);
 
-                Console.WriteLine($"Found your .csproj: {projectFile} - check for existing config or update it.");
+                var extension = Path.GetExtension(projectFile);
+                Console.WriteLine($"Found your {extension}: {projectFile} - check for existing config or update it.");
 
-                if (!EditCsProj(projectFile)) return false;
+                if (!EditProjectFile(projectFile)) return false;
 
                 // search launchSettings.json
                 Console.WriteLine($"Search your .launchSettings to add our electron debug profile...");
@@ -158,7 +161,7 @@ namespace ElectronNET.CLI.Commands
             }
         }
 
-        private static bool EditCsProj(string projectFile)
+        private static bool EditProjectFile(string projectFile)
         {
             using (var stream = File.Open(projectFile, FileMode.OpenOrCreate, FileAccess.ReadWrite))
             {
@@ -174,11 +177,11 @@ namespace ElectronNET.CLI.Commands
 
                 if (xmlDocument.ToString().Contains($"Content Update=\"{ConfigName}\""))
                 {
-                    Console.WriteLine($"{ConfigName} already in csproj.");
+                    Console.WriteLine($"{ConfigName} already in csproj/fsproj.");
                     return false;
                 }
 
-                Console.WriteLine($"{ConfigName} will be added to csproj.");
+                Console.WriteLine($"{ConfigName} will be added to csproj/fsproj.");
 
                 string itemGroupXmlString = "<ItemGroup>" +
                                             "<Content Update=\"" + ConfigName + "\">" +
@@ -204,7 +207,7 @@ namespace ElectronNET.CLI.Commands
 
             }
 
-            Console.WriteLine($"{ConfigName} added in csproj!");
+            Console.WriteLine($"{ConfigName} added in csproj/fsproj!");
             return true;
         }
     }

ElectronNET.CLI/Commands/StartElectronCommand.cs

@@ -27,6 +27,9 @@ namespace ElectronNET.CLI.Commands
         private string _manifest = "manifest";
         private string _clearCache = "clear-cache";
         private string _paramPublishReadyToRun = "PublishReadyToRun";
+        private string _paramPublishSingleFile = "PublishSingleFile";
+        private string _paramDotNetConfig = "dotnet-configuration";
+        private string _paramTarget = "target";
 
         public Task<bool> ExecuteAsync()
         {
@@ -58,8 +61,6 @@ namespace ElectronNET.CLI.Commands
                     Directory.CreateDirectory(tempPath);
                 }
 
-                var platformInfo = GetTargetPlatformInformation.Do(string.Empty, string.Empty);
-
                 string tempBinPath = Path.Combine(tempPath, "bin");
                 var resultCode = 0;
 
@@ -73,9 +74,40 @@ namespace ElectronNET.CLI.Commands
                     publishReadyToRun += "true";
                 }
 
+                string publishSingleFile = "/p:PublishSingleFile=";
+                if (parser.Arguments.ContainsKey(_paramPublishSingleFile))
+                {
+                    publishSingleFile += parser.Arguments[_paramPublishSingleFile][0];
+                }
+                else
+                {
+                    publishSingleFile += "true";
+                }
+
+                // If target is specified as a command line argument, use it.
+                // Format is the same as the build command.
+                // If target is not specified, autodetect it.
+                var platformInfo = GetTargetPlatformInformation.Do(string.Empty, string.Empty);
+                if (parser.Arguments.ContainsKey(_paramTarget))
+                {
+                    var desiredPlatform = parser.Arguments[_paramTarget][0];
+                    string specifiedFromCustom = string.Empty;
+                    if (desiredPlatform == "custom" && parser.Arguments[_paramTarget].Length > 1)
+                    {
+                        specifiedFromCustom = parser.Arguments[_paramTarget][1];
+                    }
+                    platformInfo = GetTargetPlatformInformation.Do(desiredPlatform, specifiedFromCustom);
+                }
+
+                string configuration = "Debug";
+                if (parser.Arguments.ContainsKey(_paramDotNetConfig))
+                {
+                    configuration = parser.Arguments[_paramDotNetConfig][0];
+                }
+
                 if (parser != null && !parser.Arguments.ContainsKey("watch"))
                 {
-                    resultCode = ProcessHelper.CmdExecute($"dotnet publish -r {platformInfo.NetCorePublishRid} --output \"{tempBinPath}\" {publishReadyToRun} --no-self-contained", aspCoreProjectPath);
+                    resultCode = ProcessHelper.CmdExecute($"dotnet publish -r {platformInfo.NetCorePublishRid} -c \"{configuration}\" --output \"{tempBinPath}\" {publishReadyToRun} {publishSingleFile} --no-self-contained", aspCoreProjectPath);
                 }
 
                 if (resultCode != 0)
@@ -149,7 +181,5 @@ namespace ElectronNET.CLI.Commands
                 return true;
             });
         }
-
-
     }
 }

ElectronNET.CLI/ElectronNET.CLI.csproj

@@ -3,7 +3,7 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
 
-    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <TargetFramework>net5.0</TargetFramework>
     <AssemblyName>dotnet-electronize</AssemblyName>
     <ToolCommandName>electronize</ToolCommandName>
 
@@ -61,6 +61,7 @@
     <EmbeddedResource Include="..\ElectronNET.Host\api\browserWindows.js" Link="ElectronHost\api\browserWindows.js" />
     <EmbeddedResource Include="..\ElectronNET.Host\api\commandLine.js" Link="ElectronHost\api\commandLine.js" />
     <EmbeddedResource Include="..\ElectronNET.Host\api\dialog.js" Link="ElectronHost\api\dialog.js" />
+    <EmbeddedResource Include="..\ElectronNET.Host\api\dock.js" Link="ElectronHost\api\dock.js" />
     <EmbeddedResource Include="..\ElectronNET.Host\api\menu.js" Link="ElectronHost\api\menu.js" />
     <EmbeddedResource Include="..\ElectronNET.Host\api\notification.js" Link="ElectronHost\api\notification.js" />
     <EmbeddedResource Include="..\ElectronNET.Host\api\tray.js" Link="ElectronHost\api\tray.js" />
@@ -71,10 +72,12 @@
     <EmbeddedResource Include="..\ElectronNET.Host\api\clipboard.js" Link="ElectronHost\api\clipboard.js" />
     <EmbeddedResource Include="..\ElectronNET.Host\api\autoUpdater.js" Link="ElectronHost\api\autoUpdater.js" />
     <EmbeddedResource Include="..\ElectronNET.Host\api\browserView.js" Link="ElectronHost\api\browserView.js" />
+    <EmbeddedResource Include="..\ElectronNET.Host\api\powerMonitor.js" Link="ElectronHost\api\powerMonitor.js" />
+    <EmbeddedResource Include="..\ElectronNET.Host\api\nativeTheme.js" Link="ElectronHost\api\nativeTheme.js" />
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0-beta2-19367-01">
+    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>

ElectronNET.CLI/ProcessHelper.cs

@@ -1,14 +1,11 @@
 using System;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
-using System.Text.RegularExpressions;
 
 namespace ElectronNET.CLI
 {
     public class ProcessHelper
     {
-        private readonly static Regex ErrorRegex = new Regex(@"\berror\b", RegexOptions.IgnoreCase | RegexOptions.Compiled);
-
         public static int CmdExecute(string command, string workingDirectoryPath, bool output = true, bool waitForExit = true)
         {
             using (Process cmd = new Process())
@@ -17,12 +14,13 @@ namespace ElectronNET.CLI
 
                 if (isWindows)
                 {
-                    cmd.StartInfo.FileName = "cmd.exe";
+                    cmd.StartInfo = new ProcessStartInfo("cmd.exe", "/c " + command);
                 }
                 else
                 {
                     // works for OSX and Linux (at least on Ubuntu)
-                    cmd.StartInfo.FileName = "bash";
+                    var escapedArgs = command.Replace("\"", "\\\"");
+                    cmd.StartInfo = new ProcessStartInfo("bash", $"-c \"{escapedArgs}\"");
                 }
 
                 cmd.StartInfo.RedirectStandardInput = true;
@@ -32,65 +30,23 @@ namespace ElectronNET.CLI
                 cmd.StartInfo.UseShellExecute = false;
                 cmd.StartInfo.WorkingDirectory = workingDirectoryPath;
 
-                int returnCode = 0;
-
                 if (output)
                 {
-                    cmd.OutputDataReceived += (s, e) =>
-                    {
-                        // (sometimes error messages are only visbile here)
-                        // poor mans solution, we just seek for the term 'error'
-
-                        // we can't just use cmd.ExitCode, because
-                        // we delegate it to cmd.exe, which runs fine
-                        // but we can catch any error here and return
-                        // 1 if something fails
-                        if (e != null && string.IsNullOrWhiteSpace(e.Data) == false)
-                        {
-                            if (ErrorRegex.IsMatch(e.Data))
-                            {
-                                returnCode = 1;
-                            }
-
-                            Console.WriteLine(e.Data);
-                        }
-
-                    };
-                    cmd.ErrorDataReceived += (s, e) =>
-                    {
-                        // poor mans solution, we just seek for the term 'error'
-
-                        // we can't just use cmd.ExitCode, because
-                        // we delegate it to cmd.exe, which runs fine
-                        // but we can catch any error here and return
-                        // 1 if something fails
-                        if (e != null && string.IsNullOrWhiteSpace(e.Data) == false)
-                        {
-                            if (ErrorRegex.IsMatch(e.Data))
-                            {
-                                returnCode = 1;
-                            }
-
-                            Console.WriteLine(e.Data);
-                        }
-
-                    };
+                    cmd.OutputDataReceived += (s, e) => Console.WriteLine(e.Data);
+                    cmd.ErrorDataReceived += (s, e) => Console.WriteLine(e.Data);
                 }
 
+                Console.WriteLine(command);
                 cmd.Start();
                 cmd.BeginOutputReadLine();
                 cmd.BeginErrorReadLine();
 
-                cmd.StandardInput.WriteLine(command);
-                cmd.StandardInput.Flush();
-                cmd.StandardInput.Close();
-
                 if (waitForExit)
                 {
                     cmd.WaitForExit();
                 }
 
-                return returnCode;
+                return cmd.ExitCode;
             }
         }
     }

ElectronNET.CLI/Properties/launchSettings.json

@@ -2,7 +2,7 @@
   "profiles": {
     "ElectronNET.CLI": {
       "commandName": "Project",
-      "commandLineArgs": "start /project-path \"C:\\Users\\Rizvi\\source\\repos\\Electron.NET\\ElectronNET.WebApp\" /watch"
+      "commandLineArgs": "start /project-path \"$(SolutionDir)ElectronNET.WebApp\" /watch"
     }
   }
 }

ElectronNET.CLI/SimpleCommandLineParser.cs

@@ -1,4 +1,6 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace ElectronNET.CLI
 {
@@ -29,10 +31,24 @@ namespace ElectronNET.CLI
             }
             if (currentName != "")
                 Arguments[currentName] = values.ToArray();
+
+            Console.ForegroundColor = ConsoleColor.Green;
+            Console.WriteLine($"Arguments: \n\t{string.Join("\n\t",Arguments.Keys.Select(i => $"{i} = {string.Join(" ", Arguments[i])}"))}");
+            Console.ResetColor();
         }
         public bool Contains(string name)
         {
             return Arguments.ContainsKey(name);
         }
+
+        internal bool TryGet(string key, out string[] value)
+        {
+            value = null;
+            if (!Contains(key)) {
+                return false;
+            }
+            value = Arguments[key];
+            return true;
+        }
     }
 }

ElectronNET.Host/ElectronHostHook/connector.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Connector = void 0;
 class Connector {
     constructor(socket, 
     // @ts-ignore

ElectronNET.Host/ElectronHostHook/connector.js.map

@@ -1 +1 @@
-{"version":3,"file":"connector.js","sourceRoot":"","sources":["connector.ts"],"names":[],"mappings":";;AAAA,MAAa,SAAS;IAClB,YAAoB,MAAuB;IACvC,aAAa;IACN,GAAiB;QAFR,WAAM,GAAN,MAAM,CAAiB;QAEhC,QAAG,GAAH,GAAG,CAAc;IAAI,CAAC;IAEjC,EAAE,CAAC,GAAW,EAAE,cAAwB;QACpC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,IAAW,EAAE,EAAE;YACnC,MAAM,EAAE,GAAW,IAAI,CAAC,GAAG,EAAE,CAAC;YAE9B,IAAI;gBACA,cAAc,CAAC,GAAG,IAAI,EAAE,CAAC,IAAI,EAAE,EAAE;oBAC7B,IAAI,IAAI,EAAE;wBACN,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,GAAG,WAAW,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC;qBACjD;gBACL,CAAC,CAAC,CAAC;aACN;YAAC,OAAO,KAAK,EAAE;gBACZ,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,GAAG,QAAQ,EAAE,EAAE,EAAE,qBAAqB,EAAE,KAAK,CAAC,CAAC;aACtE;QACL,CAAC,CAAC,CAAC;IACP,CAAC;CACJ;AApBD,8BAoBC"}
+{"version":3,"file":"connector.js","sourceRoot":"","sources":["connector.ts"],"names":[],"mappings":";;;AAAA,MAAa,SAAS;IAClB,YAAoB,MAAuB;IACvC,aAAa;IACN,GAAiB;QAFR,WAAM,GAAN,MAAM,CAAiB;QAEhC,QAAG,GAAH,GAAG,CAAc;IAAI,CAAC;IAEjC,EAAE,CAAC,GAAW,EAAE,cAAwB;QACpC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,IAAW,EAAE,EAAE;YACnC,MAAM,EAAE,GAAW,IAAI,CAAC,GAAG,EAAE,CAAC;YAE9B,IAAI;gBACA,cAAc,CAAC,GAAG,IAAI,EAAE,CAAC,IAAI,EAAE,EAAE;oBAC7B,IAAI,IAAI,EAAE;wBACN,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,GAAG,WAAW,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC;qBACjD;gBACL,CAAC,CAAC,CAAC;aACN;YAAC,OAAO,KAAK,EAAE;gBACZ,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,GAAG,QAAQ,EAAE,EAAE,EAAE,qBAAqB,EAAE,KAAK,CAAC,CAAC;aACtE;QACL,CAAC,CAAC,CAAC;IACP,CAAC;CACJ;AApBD,8BAoBC"}

ElectronNET.Host/ElectronHostHook/index.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookService = void 0;
 const connector_1 = require("./connector");
 class HookService extends connector_1.Connector {
     constructor(socket, app) {

ElectronNET.Host/ElectronHostHook/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":";;AAEA,2CAAwC;AAExC,MAAa,WAAY,SAAQ,qBAAS;IACtC,YAAY,MAAuB,EAAS,GAAiB;QACzD,KAAK,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QADqB,QAAG,GAAH,GAAG,CAAc;IAE7D,CAAC;IAED,WAAW;QACP,8CAA8C;IAClD,CAAC;CACJ;AARD,kCAQC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":";;;AAEA,2CAAwC;AAExC,MAAa,WAAY,SAAQ,qBAAS;IACtC,YAAY,MAAuB,EAAS,GAAiB;QACzD,KAAK,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QADqB,QAAG,GAAH,GAAG,CAAc;IAE7D,CAAC;IAED,WAAW;QACP,8CAA8C;IAClD,CAAC;CACJ;AARD,kCAQC"}

ElectronNET.Host/ElectronHostHook/index.ts

@@ -11,4 +11,3 @@ export class HookService extends Connector {
         // execute your own JavaScript Host logic here
     }
 }
-

ElectronNET.Host/ElectronHostHook/package.json

@@ -13,7 +13,7 @@
   "author": "Gregor Biswanger",
   "license": "MIT",
   "devDependencies": {
-    "@types/socket.io": "^2.1.2",
-    "typescript": "^3.4.5"
+    "@types/socket.io": "^2.1.12",
+    "typescript": "^4.3.5"
   }
 }

ElectronNET.Host/api/app.js

@@ -1,23 +1,28 @@
 "use strict";
 let isQuitWindowAllClosed = true, electronSocket;
+let appWindowAllClosedEventId;
 module.exports = (socket, app) => {
     electronSocket = socket;
-    // Quit when all windows are closed.
+    // By default, quit when all windows are closed
     app.on('window-all-closed', () => {
         // On macOS it is common for applications and their menu bar
         // to stay active until the user quits explicitly with Cmd + Q
-        if (process.platform !== 'darwin' &&
-            isQuitWindowAllClosed) {
+        if (process.platform !== 'darwin' && isQuitWindowAllClosed) {
             app.quit();
         }
+        else if (appWindowAllClosedEventId) {
+            // If the user is on macOS
+            // - OR -
+            // If the user has indicated NOT to quit when all windows are closed,
+            // emit the event.
+            electronSocket.emit('app-window-all-closed' + appWindowAllClosedEventId);
+        }
     });
     socket.on('quit-app-window-all-closed-event', (quit) => {
         isQuitWindowAllClosed = quit;
     });
     socket.on('register-app-window-all-closed-event', (id) => {
-        app.on('window-all-closed', () => {
-            electronSocket.emit('app-window-all-closed' + id);
-        });
+        appWindowAllClosedEventId = id;
     });
     socket.on('register-app-before-quit-event', (id) => {
         app.on('before-quit', (event) => {
@@ -65,8 +70,8 @@ module.exports = (socket, app) => {
     socket.on('appRelaunch', (options) => {
         app.relaunch(options);
     });
-    socket.on('appFocus', () => {
-        app.focus();
+    socket.on('appFocus', (options) => {
+        app.focus(options);
     });
     socket.on('appHide', () => {
         app.hide();
@@ -78,19 +83,13 @@ module.exports = (socket, app) => {
         const path = app.getAppPath();
         electronSocket.emit('appGetAppPathCompleted', path);
     });
+    socket.on('appSetAppLogsPath', (path) => {
+        app.setAppLogsPath(path);
+    });
     socket.on('appGetPath', (name) => {
         const path = app.getPath(name);
         electronSocket.emit('appGetPathCompleted', path);
     });
-    // const nativeImages = {};
-    // function addNativeImage(nativeImage: Electron.NativeImage) {
-    //     if(Object.keys(nativeImages).length === 0) {
-    //         nativeImage['1'] = nativeImage;
-    //     } else {
-    //         let indexCount = Object.keys(nativeImages).length + 1;
-    //         nativeImage[indexCount] = nativeImage;
-    //     }
-    // }
     socket.on('appGetFileIcon', async (path, options) => {
         let error = {};
         if (options) {
@@ -149,22 +148,32 @@ module.exports = (socket, app) => {
         app.setJumpList(categories);
     });
     socket.on('appRequestSingleInstanceLock', () => {
-        app.on('second-instance', (args, workingDirectory) => {
-            electronSocket.emit('secondInstance', [args, workingDirectory]);
-        });
         const success = app.requestSingleInstanceLock();
         electronSocket.emit('appRequestSingleInstanceLockCompleted', success);
+        app.on('second-instance', (event, args = [], workingDirectory = '') => {
+            electronSocket.emit('secondInstance', [args, workingDirectory]);
+        });
+    });
+    socket.on('appHasSingleInstanceLock', () => {
+        const hasLock = app.hasSingleInstanceLock();
+        electronSocket.emit('appHasSingleInstanceLockCompleted', hasLock);
     });
     socket.on('appReleaseSingleInstanceLock', () => {
         app.releaseSingleInstanceLock();
     });
-    socket.on('appSetUserActivity', (type, userInfo, webpageURL) => {
-        app.setUserActivity(type, userInfo, webpageURL);
+    socket.on('appSetUserActivity', (type, userInfo, webpageUrl) => {
+        app.setUserActivity(type, userInfo, webpageUrl);
     });
     socket.on('appGetCurrentActivityType', () => {
         const activityType = app.getCurrentActivityType();
         electronSocket.emit('appGetCurrentActivityTypeCompleted', activityType);
     });
+    socket.on('appInvalidateCurrentActivity', () => {
+        app.invalidateCurrentActivity();
+    });
+    socket.on('appResignCurrentActivity', () => {
+        app.resignCurrentActivity();
+    });
     socket.on('appSetAppUserModelId', (id) => {
         app.setAppUserModelId(id);
     });
@@ -204,42 +213,40 @@ module.exports = (socket, app) => {
         const isAccessibilitySupportEnabled = app.isAccessibilitySupportEnabled();
         electronSocket.emit('appIsAccessibilitySupportEnabledCompleted', isAccessibilitySupportEnabled);
     });
+    socket.on('appSetAccessibilitySupportEnabled', (enabled) => {
+        app.setAccessibilitySupportEnabled(enabled);
+    });
+    socket.on('appShowAboutPanel', () => {
+        app.showAboutPanel();
+    });
     socket.on('appSetAboutPanelOptions', (options) => {
         app.setAboutPanelOptions(options);
     });
-    socket.on('appDockBounce', (type) => {
-        const id = app.dock.bounce(type);
-        electronSocket.emit('appDockBounceCompleted', id);
+    socket.on('appGetUserAgentFallback', () => {
+        electronSocket.emit('appGetUserAgentFallbackCompleted', app.userAgentFallback);
     });
-    socket.on('appDockCancelBounce', (id) => {
-        app.dock.cancelBounce(id);
+    socket.on('appSetUserAgentFallback', (userAgent) => {
+        app.userAgentFallback = userAgent;
     });
-    socket.on('appDockDownloadFinished', (filePath) => {
-        app.dock.downloadFinished(filePath);
+    socket.on('register-app-on-event', (eventName, listenerName) => {
+        app.on(eventName, (...args) => {
+            if (args.length > 1) {
+                electronSocket.emit(listenerName, args[1]);
+            }
+            else {
+                electronSocket.emit(listenerName);
+            }
+        });
     });
-    socket.on('appDockSetBadge', (text) => {
-        app.dock.setBadge(text);
-    });
-    socket.on('appDockGetBadge', () => {
-        const text = app.dock.getBadge();
-        electronSocket.emit('appDockGetBadgeCompleted', text);
-    });
-    socket.on('appDockHide', () => {
-        app.dock.hide();
-    });
-    socket.on('appDockShow', () => {
-        app.dock.show();
-    });
-    socket.on('appDockIsVisible', () => {
-        const isVisible = app.dock.isVisible();
-        electronSocket.emit('appDockIsVisibleCompleted', isVisible);
-    });
-    // TODO: Menü Lösung muss noch implementiert werden
-    socket.on('appDockSetMenu', (menu) => {
-        app.dock.setMenu(menu);
-    });
-    socket.on('appDockSetIcon', (image) => {
-        app.dock.setIcon(image);
+    socket.on('register-app-once-event', (eventName, listenerName) => {
+        app.once(eventName, (...args) => {
+            if (args.length > 1) {
+                electronSocket.emit(listenerName, args[1]);
+            }
+            else {
+                electronSocket.emit(listenerName);
+            }
+        });
     });
 };
 //# sourceMappingURL=app.js.map

ElectronNET.Host/api/app.ts

@@ -1,13 +1,22 @@
+import { Socket } from "net";
+
 let isQuitWindowAllClosed = true, electronSocket;
-export = (socket: SocketIO.Socket, app: Electron.App) => {
+let appWindowAllClosedEventId;
+export = (socket: Socket, app: Electron.App) => {
     electronSocket = socket;
-    // Quit when all windows are closed.
+
+    // By default, quit when all windows are closed
     app.on('window-all-closed', () => {
         // On macOS it is common for applications and their menu bar
         // to stay active until the user quits explicitly with Cmd + Q
-        if (process.platform !== 'darwin' &&
-            isQuitWindowAllClosed) {
+        if (process.platform !== 'darwin' && isQuitWindowAllClosed) {
             app.quit();
+        } else if (appWindowAllClosedEventId) {
+            // If the user is on macOS
+            // - OR -
+            // If the user has indicated NOT to quit when all windows are closed,
+            // emit the event.
+            electronSocket.emit('app-window-all-closed' + appWindowAllClosedEventId);
         }
     });
 
@@ -16,9 +25,7 @@ export = (socket: SocketIO.Socket, app: Electron.App) => {
     });
 
     socket.on('register-app-window-all-closed-event', (id) => {
-        app.on('window-all-closed', () => {
-            electronSocket.emit('app-window-all-closed' + id);
-        });
+        appWindowAllClosedEventId = id;
     });
 
     socket.on('register-app-before-quit-event', (id) => {
@@ -79,8 +86,8 @@ export = (socket: SocketIO.Socket, app: Electron.App) => {
         app.relaunch(options);
     });
 
-    socket.on('appFocus', () => {
-        app.focus();
+    socket.on('appFocus', (options) => {
+        app.focus(options);
     });
 
     socket.on('appHide', () => {
@@ -96,23 +103,15 @@ export = (socket: SocketIO.Socket, app: Electron.App) => {
         electronSocket.emit('appGetAppPathCompleted', path);
     });
 
+    socket.on('appSetAppLogsPath', (path) => {
+        app.setAppLogsPath(path);
+    });
+
     socket.on('appGetPath', (name) => {
         const path = app.getPath(name);
         electronSocket.emit('appGetPathCompleted', path);
     });
 
-    // const nativeImages = {};
-
-    // function addNativeImage(nativeImage: Electron.NativeImage) {
-
-    //     if(Object.keys(nativeImages).length === 0) {
-    //         nativeImage['1'] = nativeImage;
-    //     } else {
-    //         let indexCount = Object.keys(nativeImages).length + 1;
-    //         nativeImage[indexCount] = nativeImage;
-    //     }
-    // }
-
     socket.on('appGetFileIcon', async (path, options) => {
         let error = {};
 
@@ -187,20 +186,26 @@ export = (socket: SocketIO.Socket, app: Electron.App) => {
     });
 
     socket.on('appRequestSingleInstanceLock', () => {
-        app.on('second-instance', (args, workingDirectory) => {
-            electronSocket.emit('secondInstance', [args, workingDirectory]);
-        });
-
         const success = app.requestSingleInstanceLock();
         electronSocket.emit('appRequestSingleInstanceLockCompleted', success);
+
+        app.on('second-instance', (event, args = [], workingDirectory = '') => {
+            electronSocket.emit('secondInstance', [args, workingDirectory]);
+        });
+    });
+
+    socket.on('appHasSingleInstanceLock', () => {
+        const hasLock = app.hasSingleInstanceLock();
+
+        electronSocket.emit('appHasSingleInstanceLockCompleted', hasLock);
     });
 
     socket.on('appReleaseSingleInstanceLock', () => {
         app.releaseSingleInstanceLock();
     });
 
-    socket.on('appSetUserActivity', (type, userInfo, webpageURL) => {
-        app.setUserActivity(type, userInfo, webpageURL);
+    socket.on('appSetUserActivity', (type, userInfo, webpageUrl) => {
+        app.setUserActivity(type, userInfo, webpageUrl);
     });
 
     socket.on('appGetCurrentActivityType', () => {
@@ -208,6 +213,14 @@ export = (socket: SocketIO.Socket, app: Electron.App) => {
         electronSocket.emit('appGetCurrentActivityTypeCompleted', activityType);
     });
 
+    socket.on('appInvalidateCurrentActivity', () => {
+        app.invalidateCurrentActivity();
+    });
+
+    socket.on('appResignCurrentActivity', () => {
+        app.resignCurrentActivity();
+    });
+
     socket.on('appSetAppUserModelId', (id) => {
         app.setAppUserModelId(id);
     });
@@ -257,51 +270,43 @@ export = (socket: SocketIO.Socket, app: Electron.App) => {
         electronSocket.emit('appIsAccessibilitySupportEnabledCompleted', isAccessibilitySupportEnabled);
     });
 
+    socket.on('appSetAccessibilitySupportEnabled', (enabled) => {
+        app.setAccessibilitySupportEnabled(enabled);
+    });
+
+    socket.on('appShowAboutPanel', () => {
+        app.showAboutPanel();
+    });
+
     socket.on('appSetAboutPanelOptions', (options) => {
         app.setAboutPanelOptions(options);
     });
 
-    socket.on('appDockBounce', (type) => {
-        const id = app.dock.bounce(type);
-        electronSocket.emit('appDockBounceCompleted', id);
+    socket.on('appGetUserAgentFallback', () => {
+        electronSocket.emit('appGetUserAgentFallbackCompleted', app.userAgentFallback);
     });
 
-    socket.on('appDockCancelBounce', (id) => {
-        app.dock.cancelBounce(id);
+    socket.on('appSetUserAgentFallback', (userAgent) => {
+        app.userAgentFallback = userAgent;
     });
 
-    socket.on('appDockDownloadFinished', (filePath) => {
-        app.dock.downloadFinished(filePath);
+    socket.on('register-app-on-event', (eventName, listenerName) => {
+        app.on(eventName, (...args) => {
+            if (args.length > 1) {
+                electronSocket.emit(listenerName, args[1]);
+            } else {
+                electronSocket.emit(listenerName);
+            }
+        });
     });
 
-    socket.on('appDockSetBadge', (text) => {
-        app.dock.setBadge(text);
-    });
-
-    socket.on('appDockGetBadge', () => {
-        const text = app.dock.getBadge();
-        electronSocket.emit('appDockGetBadgeCompleted', text);
-    });
-
-    socket.on('appDockHide', () => {
-        app.dock.hide();
-    });
-
-    socket.on('appDockShow', () => {
-        app.dock.show();
-    });
-
-    socket.on('appDockIsVisible', () => {
-        const isVisible = app.dock.isVisible();
-        electronSocket.emit('appDockIsVisibleCompleted', isVisible);
-    });
-
-    // TODO: Menü Lösung muss noch implementiert werden
-    socket.on('appDockSetMenu', (menu) => {
-        app.dock.setMenu(menu);
-    });
-
-    socket.on('appDockSetIcon', (image) => {
-        app.dock.setIcon(image);
+    socket.on('register-app-once-event', (eventName, listenerName) => {
+        app.once(eventName, (...args) => {
+            if (args.length > 1) {
+                electronSocket.emit(listenerName, args[1]);
+            } else {
+                electronSocket.emit(listenerName);
+            }
+        });
     });
 };

ElectronNET.Host/api/autoUpdater.js

@@ -1,10 +1,8 @@
 "use strict";
 const electron_updater_1 = require("electron-updater");
-const path = require('path');
 let electronSocket;
 module.exports = (socket) => {
     electronSocket = socket;
-    // Events ********
     socket.on('register-autoUpdater-error-event', (id) => {
         electron_updater_1.autoUpdater.on('error', (error) => {
             electronSocket.emit('autoUpdater-error' + id, error.message);
@@ -72,21 +70,34 @@ module.exports = (socket) => {
     socket.on('autoUpdater-updateConfigPath-set', (value) => {
         electron_updater_1.autoUpdater.updateConfigPath = value;
     });
+    socket.on('autoUpdater-currentVersion-get', () => {
+        electronSocket.emit('autoUpdater-currentVersion-get-reply', electron_updater_1.autoUpdater.currentVersion);
+    });
     socket.on('autoUpdater-channel-get', () => {
         electronSocket.emit('autoUpdater-channel-get-reply', electron_updater_1.autoUpdater.channel || '');
     });
     socket.on('autoUpdater-channel-set', (value) => {
         electron_updater_1.autoUpdater.channel = value;
     });
-    // Methods ********
+    socket.on('autoUpdater-requestHeaders-get', () => {
+        electronSocket.emit('autoUpdater-requestHeaders-get-reply', electron_updater_1.autoUpdater.requestHeaders);
+    });
+    socket.on('autoUpdater-requestHeaders-set', (value) => {
+        electron_updater_1.autoUpdater.requestHeaders = value;
+    });
     socket.on('autoUpdaterCheckForUpdatesAndNotify', async (guid) => {
-        const updateCheckResult = await electron_updater_1.autoUpdater.checkForUpdatesAndNotify();
-        electronSocket.emit('autoUpdaterCheckForUpdatesAndNotifyComplete' + guid, updateCheckResult);
+        electron_updater_1.autoUpdater.checkForUpdatesAndNotify().then((updateCheckResult) => {
+            electronSocket.emit('autoUpdaterCheckForUpdatesAndNotifyComplete' + guid, updateCheckResult);
+        }).catch((error) => {
+            electronSocket.emit('autoUpdaterCheckForUpdatesAndNotifyError' + guid, error);
+        });
     });
     socket.on('autoUpdaterCheckForUpdates', async (guid) => {
-        // autoUpdater.updateConfigPath = path.join(__dirname, 'dev-app-update.yml');
-        const updateCheckResult = await electron_updater_1.autoUpdater.checkForUpdates();
-        electronSocket.emit('autoUpdaterCheckForUpdatesComplete' + guid, updateCheckResult);
+        electron_updater_1.autoUpdater.checkForUpdates().then((updateCheckResult) => {
+            electronSocket.emit('autoUpdaterCheckForUpdatesComplete' + guid, updateCheckResult);
+        }).catch((error) => {
+            electronSocket.emit('autoUpdaterCheckForUpdatesError' + guid, error);
+        });
     });
     socket.on('autoUpdaterQuitAndInstall', async (isSilent, isForceRunAfter) => {
         electron_updater_1.autoUpdater.quitAndInstall(isSilent, isForceRunAfter);

ElectronNET.Host/api/autoUpdater.js.map

@@ -1 +1 @@
-{"version":3,"file":"autoUpdater.js","sourceRoot":"","sources":["autoUpdater.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"autoUpdater.js","sourceRoot":"","sources":["autoUpdater.ts"],"names":[],"mappings":"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"}

ElectronNET.Host/api/autoUpdater.ts

@@ -1,12 +1,10 @@
+import { Socket } from 'net';
 import { autoUpdater } from 'electron-updater';
-const path = require('path');
 let electronSocket;
 
-export = (socket: SocketIO.Socket) => {
+export = (socket: Socket) => {
     electronSocket = socket;
 
-    // Events ********
-
     socket.on('register-autoUpdater-error-event', (id) => {
         autoUpdater.on('error', (error) => {
             electronSocket.emit('autoUpdater-error' + id, error.message);
@@ -93,6 +91,10 @@ export = (socket: SocketIO.Socket) => {
         autoUpdater.updateConfigPath = value;
     });
 
+    socket.on('autoUpdater-currentVersion-get', () => {
+        electronSocket.emit('autoUpdater-currentVersion-get-reply', autoUpdater.currentVersion);
+    });
+
     socket.on('autoUpdater-channel-get', () => {
         electronSocket.emit('autoUpdater-channel-get-reply', autoUpdater.channel || '');
     });
@@ -101,17 +103,28 @@ export = (socket: SocketIO.Socket) => {
         autoUpdater.channel = value;
     });
 
-    // Methods ********
+    socket.on('autoUpdater-requestHeaders-get', () => {
+        electronSocket.emit('autoUpdater-requestHeaders-get-reply', autoUpdater.requestHeaders);
+    });
+
+    socket.on('autoUpdater-requestHeaders-set', (value) => {
+        autoUpdater.requestHeaders = value;
+    });
 
     socket.on('autoUpdaterCheckForUpdatesAndNotify', async (guid) => {
-        const updateCheckResult = await autoUpdater.checkForUpdatesAndNotify();
-        electronSocket.emit('autoUpdaterCheckForUpdatesAndNotifyComplete' + guid, updateCheckResult);
+        autoUpdater.checkForUpdatesAndNotify().then((updateCheckResult) => {
+            electronSocket.emit('autoUpdaterCheckForUpdatesAndNotifyComplete' + guid, updateCheckResult);
+        }).catch((error) => {
+            electronSocket.emit('autoUpdaterCheckForUpdatesAndNotifyError' + guid, error);
+        });
     });
 
     socket.on('autoUpdaterCheckForUpdates', async (guid) => {
-        // autoUpdater.updateConfigPath = path.join(__dirname, 'dev-app-update.yml');
-        const updateCheckResult = await autoUpdater.checkForUpdates();
-        electronSocket.emit('autoUpdaterCheckForUpdatesComplete' + guid, updateCheckResult);
+        autoUpdater.checkForUpdates().then((updateCheckResult) => {
+            electronSocket.emit('autoUpdaterCheckForUpdatesComplete' + guid, updateCheckResult);
+        }).catch((error) => {
+            electronSocket.emit('autoUpdaterCheckForUpdatesError' + guid, error);
+        });
     });
 
     socket.on('autoUpdaterQuitAndInstall', async (isSilent, isForceRunAfter) => {

ElectronNET.Host/api/browserView.js

@@ -1,20 +1,26 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.browserViewMediateService = exports.browserViewApi = void 0;
 const electron_1 = require("electron");
-let browserViews = [];
+const browserViews = (global['browserViews'] = global['browserViews'] || []);
 let browserView, electronSocket;
-module.exports = (socket) => {
+const proxyToCredentialsMap = (global['proxyToCredentialsMap'] = global['proxyToCredentialsMap'] || []);
+const browserViewApi = (socket) => {
     electronSocket = socket;
     socket.on('createBrowserView', (options) => {
         if (!hasOwnChildreen(options, 'webPreferences', 'nodeIntegration')) {
-            options = { ...options, webPreferences: { nodeIntegration: true } };
+            options = { ...options, webPreferences: { nodeIntegration: true, contextIsolation: false } };
         }
         browserView = new electron_1.BrowserView(options);
+        browserView['id'] = browserViews.length + 1;
+        if (options.proxy) {
+            browserView.webContents.session.setProxy({ proxyRules: options.proxy });
+        }
+        if (options.proxy && options.proxyCredentials) {
+            proxyToCredentialsMap[options.proxy] = options.proxyCredentials;
+        }
         browserViews.push(browserView);
-        electronSocket.emit('BrowserViewCreated', browserView.id);
-    });
-    socket.on('browserView-isDestroyed', (id) => {
-        const isDestroyed = getBrowserViewById(id).isDestroyed();
-        electronSocket.emit('browserView-isDestroyed-reply', isDestroyed);
+        electronSocket.emit('BrowserViewCreated', browserView['id']);
     });
     socket.on('browserView-getBounds', (id) => {
         const bounds = getBrowserViewById(id).getBounds();
@@ -23,11 +29,6 @@ module.exports = (socket) => {
     socket.on('browserView-setBounds', (id, bounds) => {
         getBrowserViewById(id).setBounds(bounds);
     });
-    socket.on('browserView-destroy', (id) => {
-        const browserViewIndex = browserViews.findIndex(b => b.id === id);
-        getBrowserViewById(id).destroy();
-        browserViews.splice(browserViewIndex, 1);
-    });
     socket.on('browserView-setAutoResize', (id, options) => {
         getBrowserViewById(id).setAutoResize(options);
     });
@@ -43,13 +44,18 @@ module.exports = (socket) => {
         }
         return true;
     }
-    function getBrowserViewById(id) {
-        for (let index = 0; index < browserViews.length; index++) {
-            const browserViewItem = browserViews[index];
-            if (browserViewItem.id === id) {
-                return browserViewItem;
-            }
+};
+exports.browserViewApi = browserViewApi;
+const browserViewMediateService = (browserViewId) => {
+    return getBrowserViewById(browserViewId);
+};
+exports.browserViewMediateService = browserViewMediateService;
+function getBrowserViewById(id) {
+    for (let index = 0; index < browserViews.length; index++) {
+        const browserViewItem = browserViews[index];
+        if (browserViewItem['id'] === id) {
+            return browserViewItem;
         }
     }
-};
+}
 //# sourceMappingURL=browserView.js.map

ElectronNET.Host/api/browserView.js.map

@@ -1 +1 @@
-{"version":3,"file":"browserView.js","sourceRoot":"","sources":["browserView.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"browserView.js","sourceRoot":"","sources":["browserView.ts"],"names":[],"mappings":"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"}

ElectronNET.Host/api/browserView.ts

@@ -1,25 +1,31 @@
+import { Socket } from 'net';
 import { BrowserView } from 'electron';
-let browserViews: Electron.BrowserView[] = [];
+const browserViews: BrowserView[] = (global['browserViews'] = global['browserViews'] || []) as BrowserView[];
 let browserView: BrowserView, electronSocket;
+const proxyToCredentialsMap: { [proxy: string]: string } = (global['proxyToCredentialsMap'] = global['proxyToCredentialsMap'] || []) as { [proxy: string]: string };
 
-export = (socket: SocketIO.Socket) => {
+const browserViewApi = (socket: Socket) => {
     electronSocket = socket;
 
     socket.on('createBrowserView', (options) => {
         if (!hasOwnChildreen(options, 'webPreferences', 'nodeIntegration')) {
-            options = { ...options, webPreferences: { nodeIntegration: true } };
+            options = { ...options, webPreferences: { nodeIntegration: true, contextIsolation: false } };
         }
 
         browserView = new BrowserView(options);
+        browserView['id'] = browserViews.length + 1;
+
+        if (options.proxy) {
+            browserView.webContents.session.setProxy({proxyRules: options.proxy});
+        }
+
+        if (options.proxy && options.proxyCredentials) {
+            proxyToCredentialsMap[options.proxy] = options.proxyCredentials;
+        }
+
         browserViews.push(browserView);
 
-        electronSocket.emit('BrowserViewCreated', browserView.id);
-    });
-
-    socket.on('browserView-isDestroyed', (id) => {
-        const isDestroyed = getBrowserViewById(id).isDestroyed();
-
-        electronSocket.emit('browserView-isDestroyed-reply', isDestroyed);
+        electronSocket.emit('BrowserViewCreated', browserView['id']);
     });
 
     socket.on('browserView-getBounds', (id) => {
@@ -32,12 +38,6 @@ export = (socket: SocketIO.Socket) => {
         getBrowserViewById(id).setBounds(bounds);
     });
 
-    socket.on('browserView-destroy', (id) => {
-        const browserViewIndex = browserViews.findIndex(b => b.id === id);
-        getBrowserViewById(id).destroy();
-        browserViews.splice(browserViewIndex, 1);
-    });
-
     socket.on('browserView-setAutoResize', (id, options) => {
         getBrowserViewById(id).setAutoResize(options);
     });
@@ -56,13 +56,19 @@ export = (socket: SocketIO.Socket) => {
 
         return true;
     }
+};
 
-    function getBrowserViewById(id: number) {
-        for (let index = 0; index < browserViews.length; index++) {
-            const browserViewItem = browserViews[index];
-            if (browserViewItem.id === id) {
-                return browserViewItem;
-            }
+const browserViewMediateService = (browserViewId: number): BrowserView => {
+    return getBrowserViewById(browserViewId);
+};
+
+function getBrowserViewById(id: number) {
+    for (let index = 0; index < browserViews.length; index++) {
+        const browserViewItem = browserViews[index];
+        if (browserViewItem['id'] === id) {
+            return browserViewItem;
         }
     }
-};
+}
+
+export { browserViewApi, browserViewMediateService };

ElectronNET.Host/api/browserWindows.js

@@ -1,12 +1,25 @@
 "use strict";
 const electron_1 = require("electron");
+const browserView_1 = require("./browserView");
 const path = require('path');
-const windows = [];
+const windows = (global['browserWindows'] = global['browserWindows'] || []);
 let readyToShowWindowsIds = [];
 let window, lastOptions, electronSocket;
 let mainWindowURL;
+const proxyToCredentialsMap = (global['proxyToCredentialsMap'] = global['proxyToCredentialsMap'] || []);
 module.exports = (socket, app) => {
     electronSocket = socket;
+    app.on('login', (event, webContents, request, authInfo, callback) => {
+        if (authInfo.isProxy) {
+            let proxy = `${authInfo.host}:${authInfo.port}`;
+            if (proxy in proxyToCredentialsMap && proxyToCredentialsMap[proxy].split(':').length === 2) {
+                event.preventDefault();
+                let user = proxyToCredentialsMap[proxy].split(':')[0];
+                let pass = proxyToCredentialsMap[proxy].split(':')[1];
+                callback(user, pass);
+            }
+        }
+    });
     socket.on('register-browserWindow-ready-to-show', (id) => {
         if (readyToShowWindowsIds.includes(id)) {
             readyToShowWindowsIds = readyToShowWindowsIds.filter(value => value !== id);
@@ -164,10 +177,10 @@ module.exports = (socket, app) => {
     });
     socket.on('createBrowserWindow', (options, loadUrl) => {
         if (options.webPreferences && !('nodeIntegration' in options.webPreferences)) {
-            options = { ...options, webPreferences: { ...options.webPreferences, nodeIntegration: true } };
+            options = { ...options, webPreferences: { ...options.webPreferences, nodeIntegration: true, contextIsolation: false } };
         }
         else if (!options.webPreferences) {
-            options = { ...options, webPreferences: { nodeIntegration: true } };
+            options = { ...options, webPreferences: { nodeIntegration: true, contextIsolation: false } };
         }
         // we dont want to recreate the window when watch is ready.
         if (app.commandLine.hasSwitch('watch') && app['mainWindowURL'] === loadUrl) {
@@ -182,6 +195,12 @@ module.exports = (socket, app) => {
         else {
             window = new electron_1.BrowserWindow(options);
         }
+        if (options.proxy) {
+            window.webContents.session.setProxy({ proxyRules: options.proxy });
+        }
+        if (options.proxy && options.proxyCredentials) {
+            proxyToCredentialsMap[options.proxy] = options.proxyCredentials;
+        }
         window.on('ready-to-show', () => {
             if (readyToShowWindowsIds.includes(window.id)) {
                 readyToShowWindowsIds = readyToShowWindowsIds.filter(value => value !== window.id);
@@ -435,6 +454,10 @@ module.exports = (socket, app) => {
         const isKiosk = getWindowById(id).isKiosk();
         electronSocket.emit('browserWindow-isKiosk-completed', isKiosk);
     });
+    socket.on('browserWindowGetNativeWindowHandle', (id) => {
+        const nativeWindowHandle = getWindowById(id).getNativeWindowHandle().readInt32LE(0).toString(16);
+        electronSocket.emit('browserWindow-getNativeWindowHandle-completed', nativeWindowHandle);
+    });
     socket.on('browserWindowSetRepresentedFilename', (id, filename) => {
         getWindowById(id).setRepresentedFilename(filename);
     });
@@ -487,6 +510,9 @@ module.exports = (socket, app) => {
     socket.on('browserWindowSetProgressBar', (id, progress) => {
         getWindowById(id).setProgressBar(progress);
     });
+    socket.on('browserWindowSetProgressBar', (id, progress, options) => {
+        getWindowById(id).setProgressBar(progress, options);
+    });
     socket.on('browserWindowSetHasShadow', (id, hasShadow) => {
         getWindowById(id).setHasShadow(hasShadow);
     });
@@ -569,29 +595,13 @@ module.exports = (socket, app) => {
     socket.on('browserWindowSetVibrancy', (id, type) => {
         getWindowById(id).setVibrancy(type);
     });
-    socket.on('browserWindowAddExtension', (path) => {
-        const extensionName = electron_1.BrowserWindow.addExtension(path);
-        electronSocket.emit('browserWindow-addExtension-completed', extensionName);
-    });
-    socket.on('browserWindowRemoveExtension', (name) => {
-        electron_1.BrowserWindow.removeExtension(name);
-    });
-    socket.on('browserWindowGetExtensions', () => {
-        const extensionsList = electron_1.BrowserWindow.getExtensions();
-        const chromeExtensionInfo = [];
-        Object.keys(extensionsList).forEach(key => {
-            chromeExtensionInfo.push(extensionsList[key]);
-        });
-        electronSocket.emit('browserWindow-getExtensions-completed', chromeExtensionInfo);
-    });
     socket.on('browserWindow-setBrowserView', (id, browserViewId) => {
-        const browserView = electron_1.BrowserView.fromId(browserViewId);
-        getWindowById(id).setBrowserView(browserView);
+        getWindowById(id).setBrowserView(browserView_1.browserViewMediateService(browserViewId));
     });
     function getWindowById(id) {
         for (let index = 0; index < windows.length; index++) {
             const element = windows[index];
-            if (element.id == id) {
+            if (element.id === id) {
                 return element;
             }
         }

ElectronNET.Host/api/browserWindows.ts

@@ -1,11 +1,28 @@
-import { BrowserWindow, Menu, nativeImage, BrowserView } from 'electron';
+import { Socket } from 'net';
+import { BrowserWindow, Menu, nativeImage } from 'electron';
+import { browserViewMediateService } from './browserView';
 const path = require('path');
-const windows: Electron.BrowserWindow[] = [];
+const windows: Electron.BrowserWindow[] = (global['browserWindows'] = global['browserWindows'] || []) as Electron.BrowserWindow[];
 let readyToShowWindowsIds: number[] = [];
 let window, lastOptions, electronSocket;
 let mainWindowURL;
-export = (socket: SocketIO.Socket, app: Electron.App) => {
+const proxyToCredentialsMap: { [proxy: string]: string } = (global['proxyToCredentialsMap'] = global['proxyToCredentialsMap'] || []) as { [proxy: string]: string };
+
+export = (socket: Socket, app: Electron.App) => {
     electronSocket = socket;
+
+    app.on('login', (event, webContents, request, authInfo, callback) => {
+        if (authInfo.isProxy) {
+            let proxy = `${authInfo.host}:${authInfo.port}`
+            if (proxy in proxyToCredentialsMap && proxyToCredentialsMap[proxy].split(':').length === 2) {
+                event.preventDefault()
+                let user = proxyToCredentialsMap[proxy].split(':')[0]
+                let pass = proxyToCredentialsMap[proxy].split(':')[1]
+                callback(user, pass)
+            }
+        }
+    })
+
     socket.on('register-browserWindow-ready-to-show', (id) => {
         if (readyToShowWindowsIds.includes(id)) {
             readyToShowWindowsIds = readyToShowWindowsIds.filter(value => value !== id);
@@ -194,9 +211,9 @@ export = (socket: SocketIO.Socket, app: Electron.App) => {
 
     socket.on('createBrowserWindow', (options, loadUrl) => {
         if (options.webPreferences && !('nodeIntegration' in options.webPreferences)) {
-            options = { ...options, webPreferences: { ...options.webPreferences, nodeIntegration: true } };
+            options = { ...options, webPreferences: { ...options.webPreferences, nodeIntegration: true, contextIsolation: false } };
         } else if (!options.webPreferences) {
-            options = { ...options, webPreferences: { nodeIntegration: true } };
+            options = { ...options, webPreferences: { nodeIntegration: true, contextIsolation: false } };
         }
 
         // we dont want to recreate the window when watch is ready.
@@ -212,6 +229,14 @@ export = (socket: SocketIO.Socket, app: Electron.App) => {
             window = new BrowserWindow(options);
         }
 
+        if (options.proxy) {
+            window.webContents.session.setProxy({proxyRules: options.proxy});
+        }
+
+        if (options.proxy && options.proxyCredentials) {
+            proxyToCredentialsMap[options.proxy] = options.proxyCredentials;
+        }
+
         window.on('ready-to-show', () => {
             if (readyToShowWindowsIds.includes(window.id)) {
                 readyToShowWindowsIds = readyToShowWindowsIds.filter(value => value !== window.id);
@@ -553,6 +578,11 @@ export = (socket: SocketIO.Socket, app: Electron.App) => {
         electronSocket.emit('browserWindow-isKiosk-completed', isKiosk);
     });
 
+    socket.on('browserWindowGetNativeWindowHandle', (id) => {
+        const nativeWindowHandle = getWindowById(id).getNativeWindowHandle().readInt32LE(0).toString(16);
+        electronSocket.emit('browserWindow-getNativeWindowHandle-completed', nativeWindowHandle);
+    });
+
     socket.on('browserWindowSetRepresentedFilename', (id, filename) => {
         getWindowById(id).setRepresentedFilename(filename);
     });
@@ -623,6 +653,10 @@ export = (socket: SocketIO.Socket, app: Electron.App) => {
         getWindowById(id).setProgressBar(progress);
     });
 
+    socket.on('browserWindowSetProgressBar', (id, progress, options) => {
+        getWindowById(id).setProgressBar(progress, options);
+    });
+
     socket.on('browserWindowSetHasShadow', (id, hasShadow) => {
         getWindowById(id).setHasShadow(hasShadow);
     });
@@ -736,37 +770,14 @@ export = (socket: SocketIO.Socket, app: Electron.App) => {
         getWindowById(id).setVibrancy(type);
     });
 
-    socket.on('browserWindowAddExtension', (path) => {
-        const extensionName = BrowserWindow.addExtension(path);
-
-        electronSocket.emit('browserWindow-addExtension-completed', extensionName);
-    });
-
-    socket.on('browserWindowRemoveExtension', (name) => {
-        BrowserWindow.removeExtension(name);
-    });
-
-    socket.on('browserWindowGetExtensions', () => {
-        const extensionsList = BrowserWindow.getExtensions();
-        const chromeExtensionInfo = [];
-
-        Object.keys(extensionsList).forEach(key => {
-            chromeExtensionInfo.push(extensionsList[key]);
-        });
-
-        electronSocket.emit('browserWindow-getExtensions-completed', chromeExtensionInfo);
-    });
-
     socket.on('browserWindow-setBrowserView', (id, browserViewId) => {
-        const browserView = BrowserView.fromId(browserViewId);
-        getWindowById(id).setBrowserView(browserView);
+        getWindowById(id).setBrowserView(browserViewMediateService(browserViewId));
     });
 
-
     function getWindowById(id: number): Electron.BrowserWindow {
         for (let index = 0; index < windows.length; index++) {
             const element = windows[index];
-            if (element.id == id) {
+            if (element.id === id) {
                 return element;
             }
         }

ElectronNET.Host/api/clipboard.js

@@ -49,19 +49,20 @@ module.exports = (socket) => {
         electron_1.clipboard.write(data, type);
     });
     socket.on('clipboard-readImage', (type) => {
-        var image = electron_1.clipboard.readImage(type);
+        const image = electron_1.clipboard.readImage(type);
         electronSocket.emit('clipboard-readImage-Completed', { 1: image.toPNG().toString('base64') });
     });
     socket.on('clipboard-writeImage', (data, type) => {
-        var data = JSON.parse(data);
-        const ni = electron_1.nativeImage.createEmpty();
-        for (var i in data) {
-            var scaleFactor = i;
-            var bytes = data[i];
-            var buff = Buffer.from(bytes, 'base64');
-            ni.addRepresentation({ scaleFactor: +scaleFactor, buffer: buff });
+        const dataContent = JSON.parse(data);
+        const image = electron_1.nativeImage.createEmpty();
+        // tslint:disable-next-line: forin
+        for (const key in dataContent) {
+            const scaleFactor = key;
+            const bytes = data[key];
+            const buffer = Buffer.from(bytes, 'base64');
+            image.addRepresentation({ scaleFactor: +scaleFactor, buffer: buffer });
         }
-        electron_1.clipboard.writeImage(ni, type);
+        electron_1.clipboard.writeImage(image, type);
     });
 };
 //# sourceMappingURL=clipboard.js.map

ElectronNET.Host/api/clipboard.js.map

@@ -1 +1 @@
-{"version":3,"file":"clipboard.js","sourceRoot":"","sources":["clipboard.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"clipboard.js","sourceRoot":"","sources":["clipboard.ts"],"names":[],"mappings":"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"}

ElectronNET.Host/api/clipboard.ts

@@ -1,7 +1,8 @@
+import { Socket } from 'net';
 import { clipboard, nativeImage } from 'electron';
 let electronSocket;
 
-export = (socket: SocketIO.Socket) => {
+export = (socket: Socket) => {
     electronSocket = socket;
     socket.on('clipboard-readText', (type) => {
         const text = clipboard.readText(type);
@@ -62,20 +63,22 @@ export = (socket: SocketIO.Socket) => {
     });
 
     socket.on('clipboard-readImage', (type) => {
-        var image = clipboard.readImage(type);
+        const image = clipboard.readImage(type);
         electronSocket.emit('clipboard-readImage-Completed', { 1: image.toPNG().toString('base64') });
     });
 
     socket.on('clipboard-writeImage', (data, type) => {
-        var data = JSON.parse(data);
-        const ni = nativeImage.createEmpty();
-        for (var i in data) {
-            var scaleFactor = i;
-            var bytes = data[i];
-            var buff = Buffer.from(bytes, 'base64');
-            ni.addRepresentation({ scaleFactor: +scaleFactor, buffer: buff });
+        const dataContent = JSON.parse(data);
+        const image = nativeImage.createEmpty();
+
+        // tslint:disable-next-line: forin
+        for (const key in dataContent) {
+            const scaleFactor = key;
+            const bytes = data[key];
+            const buffer = Buffer.from(bytes, 'base64');
+            image.addRepresentation({ scaleFactor: +scaleFactor, buffer: buffer });
         }
-        
-        clipboard.writeImage(ni, type);
+
+        clipboard.writeImage(image, type);
     });
 };

ElectronNET.Host/api/commandLine.js.map

@@ -1 +1 @@
-{"version":3,"file":"commandLine.js","sourceRoot":"","sources":["commandLine.ts"],"names":[],"mappings":";AAAA,IAAI,cAAc,CAAC;AAEnB,iBAAS,CAAC,MAAuB,EAAE,GAAiB,EAAE,EAAE;IACpD,cAAc,GAAG,MAAM,CAAC;IAExB,MAAM,CAAC,EAAE,CAAC,4BAA4B,EAAE,CAAC,UAAkB,EAAE,KAAa,EAAE,EAAE;QAC1E,GAAG,CAAC,WAAW,CAAC,YAAY,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;IACpD,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,8BAA8B,EAAE,CAAC,KAAa,EAAE,EAAE;QACxD,GAAG,CAAC,WAAW,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;IAC1C,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,yBAAyB,EAAE,CAAC,KAAa,EAAE,EAAE;QACnD,MAAM,SAAS,GAAG,GAAG,CAAC,WAAW,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACnD,cAAc,CAAC,IAAI,CAAC,kCAAkC,EAAE,SAAS,CAAC,CAAC;IACvE,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,8BAA8B,EAAE,CAAC,UAAkB,EAAE,EAAE;QAC7D,MAAM,KAAK,GAAG,GAAG,CAAC,WAAW,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;QACzD,cAAc,CAAC,IAAI,CAAC,uCAAuC,EAAE,KAAK,CAAC,CAAC;IACxE,CAAC,CAAC,CAAC;AACP,CAAC,CAAC"}
+{"version":3,"file":"commandLine.js","sourceRoot":"","sources":["commandLine.ts"],"names":[],"mappings":";AACA,IAAI,cAAc,CAAC;AAEnB,iBAAS,CAAC,MAAc,EAAE,GAAiB,EAAE,EAAE;IAC3C,cAAc,GAAG,MAAM,CAAC;IAExB,MAAM,CAAC,EAAE,CAAC,4BAA4B,EAAE,CAAC,UAAkB,EAAE,KAAa,EAAE,EAAE;QAC1E,GAAG,CAAC,WAAW,CAAC,YAAY,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;IACpD,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,8BAA8B,EAAE,CAAC,KAAa,EAAE,EAAE;QACxD,GAAG,CAAC,WAAW,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;IAC1C,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,yBAAyB,EAAE,CAAC,KAAa,EAAE,EAAE;QACnD,MAAM,SAAS,GAAG,GAAG,CAAC,WAAW,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACnD,cAAc,CAAC,IAAI,CAAC,kCAAkC,EAAE,SAAS,CAAC,CAAC;IACvE,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,8BAA8B,EAAE,CAAC,UAAkB,EAAE,EAAE;QAC7D,MAAM,KAAK,GAAG,GAAG,CAAC,WAAW,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;QACzD,cAAc,CAAC,IAAI,CAAC,uCAAuC,EAAE,KAAK,CAAC,CAAC;IACxE,CAAC,CAAC,CAAC;AACP,CAAC,CAAC"}

ElectronNET.Host/api/commandLine.ts

@@ -1,6 +1,7 @@
+import { Socket } from 'net';
 let electronSocket;
 
-export = (socket: SocketIO.Socket, app: Electron.App) => {
+export = (socket: Socket, app: Electron.App) => {
     electronSocket = socket;
 
     socket.on('appCommandLineAppendSwitch', (the_switch: string, value: string) => {

ElectronNET.Host/api/dialog.js.map

@@ -1 +1 @@
-{"version":3,"file":"dialog.js","sourceRoot":"","sources":["dialog.ts"],"names":[],"mappings":";AAAA,uCAAiD;AACjD,IAAI,cAAc,CAAC;AAEnB,iBAAS,CAAC,MAAuB,EAAE,EAAE;IACjC,cAAc,GAAG,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,CAAC,gBAAgB,EAAE,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE;QAC/D,IAAI,IAAI,IAAI,aAAa,EAAE;YACvB,MAAM,MAAM,GAAG,wBAAa,CAAC,MAAM,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC;YAEtD,MAAM,qBAAqB,GAAG,MAAM,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;YAC3E,cAAc,CAAC,IAAI,CAAC,wBAAwB,GAAG,IAAI,EAAE,CAAC,qBAAqB,CAAC,QAAQ,EAAE,qBAAqB,CAAC,eAAe,CAAC,CAAC,CAAC;SACjI;aAAM;YACH,MAAM,EAAE,GAAG,IAAI,IAAI,OAAO,CAAC;YAC3B,MAAM,qBAAqB,GAAG,MAAM,iBAAM,CAAC,cAAc,CAAC,aAAa,CAAC,CAAC;YAEzE,cAAc,CAAC,IAAI,CAAC,wBAAwB,GAAG,EAAE,EAAE,CAAC,qBAAqB,CAAC,QAAQ,EAAE,qBAAqB,CAAC,eAAe,CAAC,CAAC,CAAC;SAC/H;IACL,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,gBAAgB,EAAE,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE;QAC/D,MAAM,MAAM,GAAG,wBAAa,CAAC,MAAM,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC;QACtD,MAAM,qBAAqB,GAAG,MAAM,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAE3E,cAAc,CAAC,IAAI,CAAC,wBAAwB,GAAG,IAAI,EAAE,qBAAqB,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC;IAChG,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,gBAAgB,EAAE,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE;QAC/D,MAAM,MAAM,GAAG,wBAAa,CAAC,MAAM,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC;QACtD,MAAM,qBAAqB,GAAG,MAAM,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAE3E,cAAc,CAAC,IAAI,CAAC,wBAAwB,GAAG,IAAI,EAAE,qBAAqB,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC;IAC/F,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,cAAc,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;QACzC,iBAAM,CAAC,YAAY,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IACxC,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,4BAA4B,EAAE,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE;QAC3E,MAAM,MAAM,GAAG,wBAAa,CAAC,MAAM,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC;QACtD,MAAM,iBAAM,CAAC,0BAA0B,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAEzD,cAAc,CAAC,IAAI,CAAC,oCAAoC,GAAG,IAAI,CAAC,CAAC;IACrE,CAAC,CAAC,CAAC;AACP,CAAC,CAAC"}
+{"version":3,"file":"dialog.js","sourceRoot":"","sources":["dialog.ts"],"names":[],"mappings":";AACA,uCAAiD;AACjD,IAAI,cAAc,CAAC;AAEnB,iBAAS,CAAC,MAAc,EAAE,EAAE;IACxB,cAAc,GAAG,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,CAAC,gBAAgB,EAAE,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE;QAC/D,IAAI,IAAI,IAAI,aAAa,EAAE;YACvB,MAAM,MAAM,GAAG,wBAAa,CAAC,MAAM,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC;YAEtD,MAAM,qBAAqB,GAAG,MAAM,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;YAC3E,cAAc,CAAC,IAAI,CAAC,wBAAwB,GAAG,IAAI,EAAE,CAAC,qBAAqB,CAAC,QAAQ,EAAE,qBAAqB,CAAC,eAAe,CAAC,CAAC,CAAC;SACjI;aAAM;YACH,MAAM,EAAE,GAAG,IAAI,IAAI,OAAO,CAAC;YAC3B,MAAM,qBAAqB,GAAG,MAAM,iBAAM,CAAC,cAAc,CAAC,aAAa,CAAC,CAAC;YAEzE,cAAc,CAAC,IAAI,CAAC,wBAAwB,GAAG,EAAE,EAAE,CAAC,qBAAqB,CAAC,QAAQ,EAAE,qBAAqB,CAAC,eAAe,CAAC,CAAC,CAAC;SAC/H;IACL,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,gBAAgB,EAAE,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE;QAC/D,MAAM,MAAM,GAAG,wBAAa,CAAC,MAAM,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC;QACtD,MAAM,qBAAqB,GAAG,MAAM,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAE3E,cAAc,CAAC,IAAI,CAAC,wBAAwB,GAAG,IAAI,EAAE,qBAAqB,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC;IAChG,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,gBAAgB,EAAE,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE;QAC/D,MAAM,MAAM,GAAG,wBAAa,CAAC,MAAM,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC;QACtD,MAAM,qBAAqB,GAAG,MAAM,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAE3E,cAAc,CAAC,IAAI,CAAC,wBAAwB,GAAG,IAAI,EAAE,qBAAqB,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC;IAC/F,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,cAAc,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;QACzC,iBAAM,CAAC,YAAY,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IACxC,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,4BAA4B,EAAE,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE;QAC3E,MAAM,MAAM,GAAG,wBAAa,CAAC,MAAM,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC;QACtD,MAAM,iBAAM,CAAC,0BAA0B,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAEzD,cAAc,CAAC,IAAI,CAAC,oCAAoC,GAAG,IAAI,CAAC,CAAC;IACrE,CAAC,CAAC,CAAC;AACP,CAAC,CAAC"}

ElectronNET.Host/api/dialog.ts

@@ -1,7 +1,8 @@
+import { Socket } from 'net';
 import { BrowserWindow, dialog } from 'electron';
 let electronSocket;
 
-export = (socket: SocketIO.Socket) => {
+export = (socket: Socket) => {
     electronSocket = socket;
     socket.on('showMessageBox', async (browserWindow, options, guid) => {
         if ('id' in browserWindow) {

ElectronNET.Host/api/dock.js

@@ -0,0 +1,62 @@
+"use strict";
+const electron_1 = require("electron");
+let electronSocket;
+module.exports = (socket) => {
+    electronSocket = socket;
+    socket.on('dock-bounce', (type) => {
+        const id = electron_1.app.dock.bounce(type);
+        electronSocket.emit('dock-bounce-completed', id);
+    });
+    socket.on('dock-cancelBounce', (id) => {
+        electron_1.app.dock.cancelBounce(id);
+    });
+    socket.on('dock-downloadFinished', (filePath) => {
+        electron_1.app.dock.downloadFinished(filePath);
+    });
+    socket.on('dock-setBadge', (text) => {
+        electron_1.app.dock.setBadge(text);
+    });
+    socket.on('dock-getBadge', () => {
+        const text = electron_1.app.dock.getBadge();
+        electronSocket.emit('dock-getBadge-completed', text);
+    });
+    socket.on('dock-hide', () => {
+        electron_1.app.dock.hide();
+    });
+    socket.on('dock-show', () => {
+        electron_1.app.dock.show();
+    });
+    socket.on('dock-isVisible', () => {
+        const isVisible = electron_1.app.dock.isVisible();
+        electronSocket.emit('dock-isVisible-completed', isVisible);
+    });
+    socket.on('dock-setMenu', (menuItems) => {
+        let menu = null;
+        if (menuItems) {
+            menu = electron_1.Menu.buildFromTemplate(menuItems);
+            addMenuItemClickConnector(menu.items, (id) => {
+                electronSocket.emit('dockMenuItemClicked', id);
+            });
+        }
+        electron_1.app.dock.setMenu(menu);
+    });
+    // TODO: Menu (macOS) still to be implemented
+    socket.on('dock-getMenu', () => {
+        const menu = electron_1.app.dock.getMenu();
+        electronSocket.emit('dock-getMenu-completed', menu);
+    });
+    socket.on('dock-setIcon', (image) => {
+        electron_1.app.dock.setIcon(image);
+    });
+    function addMenuItemClickConnector(menuItems, callback) {
+        menuItems.forEach((item) => {
+            if (item.submenu && item.submenu.items.length > 0) {
+                addMenuItemClickConnector(item.submenu.items, callback);
+            }
+            if ('id' in item && item.id) {
+                item.click = () => { callback(item.id); };
+            }
+        });
+    }
+};
+//# sourceMappingURL=dock.js.map

ElectronNET.Host/api/dock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dock.js","sourceRoot":"","sources":["dock.ts"],"names":[],"mappings":"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"}

ElectronNET.Host/api/dock.ts

@@ -0,0 +1,78 @@
+import { Socket } from 'net';
+import { app, Menu } from 'electron';
+let electronSocket;
+
+export = (socket: Socket) => {
+    electronSocket = socket;
+
+    socket.on('dock-bounce', (type) => {
+        const id = app.dock.bounce(type);
+        electronSocket.emit('dock-bounce-completed', id);
+    });
+
+    socket.on('dock-cancelBounce', (id) => {
+        app.dock.cancelBounce(id);
+    });
+
+    socket.on('dock-downloadFinished', (filePath) => {
+        app.dock.downloadFinished(filePath);
+    });
+
+    socket.on('dock-setBadge', (text) => {
+        app.dock.setBadge(text);
+    });
+
+    socket.on('dock-getBadge', () => {
+        const text = app.dock.getBadge();
+        electronSocket.emit('dock-getBadge-completed', text);
+    });
+
+    socket.on('dock-hide', () => {
+        app.dock.hide();
+    });
+
+    socket.on('dock-show', () => {
+        app.dock.show();
+    });
+
+    socket.on('dock-isVisible', () => {
+        const isVisible = app.dock.isVisible();
+        electronSocket.emit('dock-isVisible-completed', isVisible);
+    });
+
+    socket.on('dock-setMenu', (menuItems) => {
+        let menu = null;
+
+        if (menuItems) {
+            menu = Menu.buildFromTemplate(menuItems);
+
+            addMenuItemClickConnector(menu.items, (id) => {
+                electronSocket.emit('dockMenuItemClicked', id);
+            });
+        }
+
+        app.dock.setMenu(menu);
+    });
+
+    // TODO: Menu (macOS) still to be implemented
+    socket.on('dock-getMenu', () => {
+        const menu = app.dock.getMenu();
+        electronSocket.emit('dock-getMenu-completed', menu);
+    });
+
+    socket.on('dock-setIcon', (image) => {
+        app.dock.setIcon(image);
+    });
+
+    function addMenuItemClickConnector(menuItems, callback) {
+        menuItems.forEach((item) => {
+            if (item.submenu && item.submenu.items.length > 0) {
+                addMenuItemClickConnector(item.submenu.items, callback);
+            }
+
+            if ('id' in item && item.id) {
+                item.click = () => { callback(item.id); };
+            }
+        });
+    }
+};