Review corrections

Release 0.4.1

.github/workflows/retry-test-jobs.yml

@@ -27,24 +27,23 @@ jobs:
         run: |
           echo "Inspecting jobs of workflow run $RUN_ID in $REPO"
 
-          jobs_json="$(gh api repos/$REPO/actions/runs/$RUN_ID/jobs)"
+          jobs_json="$(gh api -R $REPO repos/$REPO/actions/runs/$RUN_ID/jobs)"
 
           echo "Jobs and conclusions:"
           echo "$jobs_json" | jq '.jobs[] | {name: .name, conclusion: .conclusion}'
 
-          failed_matrix_jobs=$(echo "$jobs_json" | jq '
+          failed_matrix_jobs=$(echo "$jobs_json" | jq -r '
             [ .jobs[]
               | select(.conclusion == "failure"
                        and (.name | contains(" API-")))
             ]
-            | length
+            | length // 0
           ')
+          failed_matrix_jobs=${failed_matrix_jobs:-0}
 
-          echo "Failed Integration Tests matrix jobs: $failed_matrix_jobs"
-
-          if [ "$failed_matrix_jobs" -gt 0 ]; then
+          if [ "${failed_matrix_jobs}" -gt 0 ]; then
             echo "Detected failing Integration Tests jobs – re-running failed jobs for this run."
-            gh run rerun "$RUN_ID" --failed
+            gh run rerun -R "$REPO" "$RUN_ID" --failed
           else
             echo "Only non-matrix jobs (like Test Results) failed – not auto-rerunning."
           fi

Changelog.md

@@ -1,3 +1,32 @@
+# 0.4.1
+
+## ElectronNET.Core
+
+- Updated documentation for preload scripts (#1031) @AeonSake
+- Updated timeout for electron-builder (#1013) @softworkz
+- Updated disposal avoiding exceptions on teardown (#1026) @softworkz
+- Updated migration guide (#1015) @hilin
+- Fixed handling of `Center` property for windows (#1001)
+- Fixed false alarm for `ELECTRON001`, `ELECTRON008`, and `ELECTRON009` (#1012) @softworkz
+- Added missing methods on `Cookies` (#1000)
+- Added overload for `GetAllDisplaysAsync` with timeout (#1033) @softworkz
+- Added `OnBoundsChanged` event (#1014) @softworkz
+- Added new events for `ipcMain` (#1019) @DYH1319
+
+# 0.4.0
+
+## ElectronNET.Core
+
+- Fixed ElectronSingleInstance handling (#996) @softworkz
+- Fixed `PackageId` handling (#993) @softworkz
+- Added cross-platform npm restore and check mismatch on publish (#988) @softworkz
+
+# 0.3.1
+
+## ElectronNET.Core
+
+- Fixed issue transforming the project ID (#989, #990) @softworkz
+
 # 0.3.0
 
 ## ElectronNET.Core

docs/Core/Migration-Checks.md

@@ -8,7 +8,9 @@ When you build an Electron.NET project, the following validation checks are perf
 
 | Code | Check | Description |
 |------|-------|-------------|
-| [ELECTRON001](#1-packagejson-not-allowed) | package.json not allowed | Ensures no package.json exists outside ElectronHostHook |
+| [ELECTRON001](#1-packagejson-rules) | package.json location rules | Ensures `package.json`/`package-lock.json` aren’t present in unsupported locations (root `package.json` handled separately) |
+| [ELECTRON008](#1-packagejson-rules) | root package.json contains electron | Warns when root `package.json` contains the word `electron` (case-insensitive) |
+| [ELECTRON009](#1-packagejson-rules) | root package.json copied to output | Warns when root `package.json` is configured to be copied to output/publish |
 | [ELECTRON002](#2-electron-manifestjson-not-allowed) | electron-manifest.json not allowed | Detects deprecated manifest files |
 | [ELECTRON003](#3-electron-builderjson-location) | electron-builder.json location | Verifies electron-builder.json exists in Properties folder |
 | [ELECTRON004](#3-electron-builderjson-location) | electron-builder.json wrong location | Warns if electron-builder.json is found in incorrect locations |
@@ -18,30 +20,44 @@ When you build an Electron.NET project, the following validation checks are perf
 
 ---
 
-## 1. package.json not allowed
+## 1. package.json rules
 
-**Warning Code:** `ELECTRON001`
+**Warning Codes:** `ELECTRON001`, `ELECTRON008`, `ELECTRON009`
 
 ### What is checked
 
-The build system scans for `package.json` and `package-lock.json` files in your project directory. These files should not exist in the project root or subdirectories (with one exception).
+The build system scans for `package.json` and `package-lock.json` files in your project directory.
+
+Rules:
+
+- **ELECTRON001**: `package.json` / `package-lock.json` must not exist in the project directory or subdirectories
+  - Exception: `ElectronHostHook` folder is allowed
+  - Note: a **root** `package.json` is **excluded** from `ELECTRON001` and validated by `ELECTRON008` / `ELECTRON009`
+
+- **ELECTRON008**: If a root `package.json` exists, it must **not** contain electron-related dependencies or configuration.
+
+- **ELECTRON009**: If a root `package.json` exists, it must **not** be configured to be copied to output/publish (for example via `CopyToOutputDirectory` / `CopyToPublishDirectory` metadata)
 
 ### Why this matters
 
-In previous versions of Electron.NET, a `package.json` file was required in the project. The new version generates this file automatically from MSBuild properties defined in your `.csproj` file.
+Electron.NET generates its Electron-related `package.json` during publishing based on MSBuild properties. A user-maintained Electron-related `package.json` can conflict with that process.
+
+Also, ensuring the root `package.json` is not copied prevents accidentally shipping it with the published app.
 
 ### Exception
 
-A `package.json` file **is allowed** in the `ElectronHostHook` folder if you're using custom host hooks. This is the only valid location for a manually maintained package.json.
+A `package.json` / `package-lock.json` file **is allowed** in the `ElectronHostHook` folder if you're using custom host hooks.
 
 ### How to fix
 
+If you have an Electron-related `package.json` from older Electron.NET versions:
+
 1. **Open your project's `.csproj` file**
 2. **Add the required properties** to a PropertyGroup with the label `ElectronNetCommon`:
 
 ```xml
 <PropertyGroup Label="ElectronNetCommon">
-  <PackageId>my-electron-app</PackageId>
+  <ElectronPackageId>my-electron-app</ElectronPackageId>
   <Title>My Electron App</Title>
   <Version>1.0.0</Version>
   <Description>My awesome Electron.NET application</Description>
@@ -51,7 +67,12 @@ A `package.json` file **is allowed** in the `ElectronHostHook` folder if you're
 </PropertyGroup>
 ```
 
-3. **Delete the old `package.json`** file from your project root
+3. **Delete** Electron-related `package.json` / `package-lock.json` files (except those under `ElectronHostHook` if applicable)
+
+If you keep a root `package.json` for non-Electron reasons:
+
+- Ensure it does **not** contain electron dependencies or configuration (fixes `ELECTRON008`)
+- Ensure it is **not** copied to output/publish (fixes `ELECTRON009`)
 
 > **See also:** [Migration Guide](Migration-Guide.md) for complete migration instructions.
 

docs/Core/Migration-Guide.md

@@ -31,7 +31,7 @@ dotnet add package ElectronNET.Core.AspNet  # For ASP.NET projects
 ### Step 2: Configure Project Settings
 
 **Auto-generated Configuration:**  
-ElectronNET.Core automatically creates `electron-builder.json` during the first build or NuGet restore. No manual configuration is needed for basic setups.
+ElectronNET.Core automatically creates `electron-builder.json` in the `Properties` folder of your project during the first build or NuGet restore. No manual configuration is needed for basic setups.
 
 **Migrate Existing Configuration:**  
 If you have an existing `electron.manifest.json` file:
@@ -63,6 +63,9 @@ You can also manually edit `electron-builder.json`:
 }
 ```
 
+**Modify Launch Settings:**
+ElectronNET.Core no longer needs a separate CLI tool (electronize.exe) for launching. You should update your launch settings to use either the ASP.NET-first or Electron-first approach. See [Debugging](../Using/Debugging.md) for details.
+
 ## 🎯 Testing Migration
 
 After completing the migration steps:

docs/Dev/Authentication.md

@@ -0,0 +1,583 @@
+# Electron.NET SignalR Authentication Guide
+
+This guide explains the token-based authentication system implemented for SignalR mode in Electron.NET, designed to protect applications in multi-user environments.
+
+## Table of Contents
+
+1. [Overview](#overview)
+2. [Threat Model](#threat-model)
+3. [Authentication Architecture](#authentication-architecture)
+4. [Implementation Details](#implementation-details)
+5. [Security Properties](#security-properties)
+6. [Troubleshooting](#troubleshooting)
+7. [FAQ](#faq)
+
+## Overview
+
+Electron.NET's SignalR mode includes built-in authentication to ensure that only the Electron process spawned by a specific .NET instance can connect to that instance's HTTP and SignalR endpoints.
+
+**When is this important?**
+- Multi-user Windows Server environments (Terminal Services, RDP)
+- Shared development machines with multiple users
+- Any scenario where multiple users run the same application simultaneously
+
+**What does it protect against?**
+- User A's Electron process connecting to User B's .NET backend
+- Unauthorized port scanning and connection attempts from other users
+- Accidental misconfigurations causing cross-user connections
+
+## Threat Model
+
+### The Problem
+
+When multiple users run the same Electron.NET application on a shared server:
+
+1. Each .NET process binds to a TCP port (e.g., `http://localhost:58971`)
+2. TCP ports are visible to **all users** on the machine
+3. Without authentication, User A's Electron could connect to User B's backend
+
+```
+┌─────────────────────────────────────────────────┐
+│ Windows Server (Terminal Services)             │
+├─────────────────────────────────────────────────┤
+│ User A Session                                  │
+│   ├─ .NET Process (localhost:58971)            │
+│   └─ Electron Process                          │
+│                                                 │
+│ User B Session                                  │
+│   ├─ .NET Process (localhost:61234)            │
+│   └─ Electron Process (could connect to 58971) │ ❌ Prevent this!
+└─────────────────────────────────────────────────┘
+```
+
+### The Solution
+
+Each .NET process generates a unique authentication token when launching Electron. Only requests with the correct token are allowed to connect.
+
+```
+┌─────────────────────────────────────────────────┐
+│ User A Session                                  │
+│   ├─ .NET (token: abc123...)                   │
+│   └─ Electron (has token abc123...)            │ ✅ Authenticated
+│                                                 │
+│ User B Session                                  │
+│   ├─ .NET (token: xyz789...)                   │
+│   └─ Electron (has token xyz789...)            │ ✅ Authenticated
+│                                                 │
+│   ❌ User B's Electron → User A's .NET          │
+│      (lacks token abc123...)                    │ ❌ Rejected (401)
+└─────────────────────────────────────────────────┘
+```
+
+## Authentication Architecture
+
+### Flow Diagram
+
+```
+┌──────────────┐                                    ┌─────────────────┐
+│ .NET Process │                                    │ Electron Process│
+└──────┬───────┘                                    └────────┬────────┘
+       │                                                     │
+       │ 1. Generate Token (GUID)                           │
+       │    Token: a3f8b2c1d4e5...                         │
+       │                                                     │
+       │ 2. Launch Electron                                 │
+       │    --authtoken=a3f8b2c1d4e5...                    │
+       │────────────────────────────────────────────────────>│
+       │                                                     │
+       │                                                     │ 3. Extract Token
+       │                                                     │    global.authToken = ...
+       │                                                     │
+       │                                                     │ 4. Initial Page Load
+       │<────────────────────────────────────────────────────│
+       │    GET /?token=a3f8b2c1d4e5...                     │
+       │                                                     │
+       │ 5. Validate Token                                  │
+       │    ✓ Valid → Set Cookie                            │
+       │────────────────────────────────────────────────────>│
+       │    HTTP 200 + Set-Cookie: ElectronAuth=...        │
+       │                                                     │
+       │                                                     │ 6. SignalR Connection
+       │<────────────────────────────────────────────────────│
+       │    GET /electron-hub?token=a3f8b2c1d4e5...         │
+       │                                                     │
+       │ 7. Validate Token, Set Cookie                      │
+       │────────────────────────────────────────────────────>│
+       │    HTTP 200 + Set-Cookie                           │
+       │                                                     │
+       │                                                     │ 8. Subsequent Requests
+       │<────────────────────────────────────────────────────│
+       │    GET /api/data                                   │
+       │    Cookie: ElectronAuth=a3f8b2c1d4e5...            │
+       │                                                     │
+       │ 9. Validate Cookie                                 │
+       │────────────────────────────────────────────────────>│
+       │    HTTP 200 (authenticated)                        │
+       │                                                     │
+```
+
+### Key Steps
+
+1. **Token Generation**: .NET generates 128-bit cryptographic random GUID
+2. **Command-Line Passing**: Token passed to Electron via `--authtoken` parameter
+3. **Token Extraction**: Electron stores token in `global.authToken`
+4. **URL Appending**: Token appended to initial page and SignalR connection URLs
+5. **Middleware Validation**: Every HTTP request validated by middleware
+6. **Cookie Setting**: Valid token results in secure HttpOnly cookie
+7. **Cookie-Based Requests**: Subsequent requests use cookie (no token in URL)
+
+## Implementation Details
+
+### 1. Token Generation (.NET)
+
+**File**: `src/ElectronNET.AspNet/Runtime/Controllers/RuntimeControllerAspNetDotnetFirstSignalR.cs`
+
+```csharp
+private void LaunchElectron()
+{
+    // Generate secure authentication token (128-bit cryptographic random GUID)
+    this.authenticationToken = Guid.NewGuid().ToString("N"); // 32 hex chars
+    
+    // Register token with authentication service
+    this.authenticationService.SetExpectedToken(this.authenticationToken);
+    
+    // Launch Electron with token
+    var args = $"--unpackeddotnetsignalr --electronurl={this.actualUrl} --authtoken={this.authenticationToken}";
+    this.electronProcess = new ElectronProcessActive(isUnPacked, ElectronNetRuntime.ElectronExecutable, args, this.port.Value);
+    _ = this.electronProcess.Start();
+}
+```
+
+**Token Format**: 32-character hexadecimal string (e.g., `a3f8b2c1d4e5f6a7b8c9d0e1f2a3b4c5`)
+
+### 2. Authentication Service (.NET)
+
+**File**: `src/ElectronNET.AspNet/Services/ElectronAuthenticationService.cs`
+
+```csharp
+public class ElectronAuthenticationService : IElectronAuthenticationService
+{
+    private string _expectedToken;
+    private readonly object _lock = new object();
+
+    public void SetExpectedToken(string token)
+    {
+        lock (_lock)
+        {
+            _expectedToken = token;
+        }
+    }
+
+    public bool ValidateToken(string token)
+    {
+        if (string.IsNullOrEmpty(token))
+            return false;
+
+        lock (_lock)
+        {
+            if (string.IsNullOrEmpty(_expectedToken))
+                return false;
+
+            // Constant-time comparison prevents timing attacks
+            return ConstantTimeEquals(token, _expectedToken);
+        }
+    }
+
+    private static bool ConstantTimeEquals(string a, string b)
+    {
+        if (a == null || b == null || a.Length != b.Length)
+            return false;
+
+        var result = 0;
+        for (int i = 0; i < a.Length; i++)
+        {
+            result |= a[i] ^ b[i];
+        }
+        return result == 0;
+    }
+}
+```
+
+**Key Features**:
+- Thread-safe with lock
+- Constant-time comparison (prevents timing attacks)
+- Singleton lifetime (one per .NET instance)
+
+### 3. Authentication Middleware (.NET)
+
+**File**: `src/ElectronNET.AspNet/Middleware/ElectronAuthenticationMiddleware.cs`
+
+```csharp
+public async Task InvokeAsync(HttpContext context)
+{
+    // Check if authentication cookie exists
+    var authCookie = context.Request.Cookies["ElectronAuth"];
+    
+    if (!string.IsNullOrEmpty(authCookie))
+    {
+        if (_authService.ValidateToken(authCookie))
+        {
+            await _next(context);
+            return;
+        }
+        else
+        {
+            _logger.LogWarning("Invalid cookie for path {Path}", context.Request.Path);
+            context.Response.StatusCode = 401;
+            await context.Response.WriteAsync("Unauthorized: Invalid authentication");
+            return;
+        }
+    }
+
+    // No cookie - check for token in query string
+    var token = context.Request.Query["token"].ToString();
+    
+    if (!string.IsNullOrEmpty(token) && _authService.ValidateToken(token))
+    {
+        // Valid token - set cookie for future requests
+        context.Response.Cookies.Append("ElectronAuth", token, new CookieOptions
+        {
+            HttpOnly = true,
+            SameSite = SameSiteMode.Strict,
+            Path = "/",
+            Secure = false,  // localhost is HTTP
+            IsEssential = true
+        });
+        
+        await _next(context);
+        return;
+    }
+
+    // Reject - no valid cookie or token
+    context.Response.StatusCode = 401;
+    await context.Response.WriteAsync("Unauthorized: Authentication required");
+}
+```
+
+**Middleware Order** (IMPORTANT):
+```csharp
+app.UseMiddleware<ElectronAuthenticationMiddleware>();  // ← FIRST
+app.UseRouting();
+app.UseStaticFiles();
+app.UseAntiforgery();
+app.MapHub<ElectronHub>("/electron-hub");
+app.MapRazorComponents<App>();
+```
+
+### 4. Token Extraction (Electron)
+
+**File**: `src/ElectronNET.Host/main.js`
+
+```javascript
+// Extract authentication token from command-line
+if (app.commandLine.hasSwitch('authtoken')) {
+    global.authToken = app.commandLine.getSwitchValue('authtoken');
+}
+```
+
+### 5. Token in URLs (Electron)
+
+**Initial Page Load** (`src/ElectronNET.Host/api/browserWindows.js`):
+```javascript
+// Append token to window URL
+if (global.authToken) {
+    const separator = electronUrl.includes('?') ? '&' : '?';
+    electronUrl = `${electronUrl}${separator}token=${global.authToken}`;
+}
+window.loadURL(electronUrl);
+```
+
+**SignalR Connection** (`src/ElectronNET.Host/api/signalr-bridge.js`):
+```javascript
+async connect() {
+    // Append token to SignalR hub URL
+    const connectionUrl = this.authToken ? 
+        `${this.hubUrl}?token=${this.authToken}` : 
+        this.hubUrl;
+    
+    this.connection = new signalR.HubConnectionBuilder()
+        .withUrl(connectionUrl)
+        .build();
+    
+    await this.connection.start();
+}
+```
+
+### 6. Service Registration (Application)
+
+**File**: Your application's `Program.cs`
+
+```csharp
+var builder = WebApplication.CreateBuilder(args);
+
+// Register authentication service as singleton
+builder.Services.AddSingleton<IElectronAuthenticationService, ElectronAuthenticationService>();
+
+builder.Services.AddElectron();
+
+var app = builder.Build();
+
+// Register middleware BEFORE UseRouting()
+app.UseMiddleware<ElectronAuthenticationMiddleware>();
+
+app.UseRouting();
+app.MapHub<ElectronHub>("/electron-hub");
+app.Run();
+```
+
+## Security Properties
+
+### Cookie Configuration
+
+| Property | Value | Purpose |
+|----------|-------|---------|
+| `HttpOnly` | `true` | Prevents JavaScript access (XSS protection) |
+| `SameSite` | `Strict` | Prevents CSRF attacks |
+| `Path` | `/` | Cookie sent with all requests |
+| `Secure` | `false` | Cannot use on localhost HTTP |
+| `IsEssential` | `true` | Required for app to function |
+| **Lifetime** | Session | Expires when Electron closes |
+
+### Token Properties
+
+- **Entropy**: 128 bits (2^128 possible values)
+- **Format**: 32 hexadecimal characters (GUID without hyphens)
+- **Generation**: `Guid.NewGuid()` uses cryptographically secure RNG
+- **Lifetime**: Entire application session
+- **Uniqueness**: Each .NET instance generates unique token
+
+### What's Protected
+
+✅ **All HTTP endpoints**:
+- Blazor Server pages (`/`, `/counter`, etc.)
+- Static files (`/css/app.css`, `/js/script.js`)
+- API endpoints (custom controllers)
+- SignalR hub (`/electron-hub`)
+
+✅ **Both transport modes**:
+- Initial token-based authentication (query parameter)
+- Cookie-based subsequent requests
+
+✅ **Cross-user isolation**:
+- Different users = different tokens
+- Invalid token = 401 Unauthorized
+
+### What's NOT Protected Against
+
+❌ **Same-user attacks** (by design):
+- Process memory inspection
+- Debugger attachment
+- Command-line parameter visibility
+
+**Rationale**: A malicious process running as the same user already has full access to:
+- Process memory (can read token from RAM)
+- Cookies (stored in Electron's data directory)
+- All files owned by the user
+
+Token-based authentication focuses on **cross-user isolation**, not same-user security.
+
+## Troubleshooting
+
+### Problem: 401 Unauthorized on Initial Load
+
+**Symptoms**:
+```
+GET / HTTP/1.1
+Response: 401 Unauthorized
+```
+
+**Possible Causes**:
+1. Token not passed to Electron
+2. Token not appended to URL
+3. Middleware rejecting valid token
+
+**Debugging Steps**:
+
+1. Check Electron command-line:
+   ```javascript
+   console.log('Auth Token:', global.authToken);
+   ```
+   Should print 32-character hex string.
+
+2. Check URL in browser window:
+   ```javascript
+   console.log('Loading URL:', electronUrl);
+   ```
+   Should include `?token=<guid>` parameter.
+
+3. Check .NET logs:
+   ```
+   [Warning] Authentication failed: Invalid token (prefix: a3f8b2c1...)
+   ```
+
+4. Verify middleware registration:
+   ```csharp
+   app.UseMiddleware<ElectronAuthenticationMiddleware>(); // Before UseRouting()
+   ```
+
+### Problem: SignalR Connection Fails
+
+**Symptoms**:
+```
+[SignalRBridge] Authentication failed: The authentication token is invalid or missing.
+```
+
+**Possible Causes**:
+1. Token not passed to `SignalRBridge` constructor
+2. Token not appended to hub URL
+3. Cookie not being sent
+
+**Debugging Steps**:
+
+1. Check token passed to SignalRBridge:
+   ```javascript
+   console.log('SignalRBridge token:', this.authToken);
+   ```
+
+2. Check connection URL:
+   ```javascript
+   console.log('Hub URL:', connectionUrl);
+   ```
+   Should be `http://localhost:PORT/electron-hub?token=<guid>`.
+
+3. Enable verbose logging:
+   ```javascript
+   .configureLogging(signalR.LogLevel.Debug)
+   ```
+
+### Problem: Cookie Not Persisting
+
+**Symptoms**: Every request includes token in URL, cookie never set.
+
+**Possible Causes**:
+1. Cookie settings incompatible with browser
+2. Middleware not setting cookie
+3. Response headers not sent
+
+**Debugging Steps**:
+
+1. Check response headers:
+   ```
+   Set-Cookie: ElectronAuth=a3f8b2c1...; Path=/; HttpOnly; SameSite=Strict
+   ```
+
+2. Check subsequent requests:
+   ```
+   Cookie: ElectronAuth=a3f8b2c1...
+   ```
+
+3. Enable middleware logging:
+   ```csharp
+   _logger.LogInformation("Setting cookie for path {Path}", path);
+   ```
+
+### Problem: Token Visible in Process List
+
+**Observation**:
+```powershell
+wmic process where "name='electron.exe'" get commandline
+...--authtoken=a3f8b2c1d4e5f6a7b8c9d0e1f2a3b4c5...
+```
+
+**Is this a problem?** No, by design.
+
+**Explanation**:
+- Command-line parameters are visible to same-user processes
+- This is acceptable because:
+  - Same user already has access to process memory
+  - Same user can read cookies from Electron's data directory
+  - Token-based auth protects against **other users**, not same-user processes
+
+**If you need same-user protection**: Use OS-level access controls (file permissions, process isolation) or consider named pipes with ACLs.
+
+## FAQ
+
+### Q: Why use tokens instead of Process ID validation?
+
+**A**: PIDs can be recycled and reused, making validation unreliable. Additionally:
+- PIDs don't provide cryptographic security
+- Parent-child validation is platform-specific
+- Adds complexity without meaningful security benefit
+
+Token-based authentication provides:
+- Cryptographic randomness (128-bit entropy)
+- Simple cross-platform implementation
+- No race conditions or PID recycling issues
+
+### Q: Why not use HTTPS with certificates?
+
+**A**: Localhost doesn't support HTTPS certificates easily:
+- Self-signed certificates trigger browser warnings
+- Certificate management adds complexity
+- Token-based auth provides equivalent security for localhost IPC
+
+### Q: Can I disable authentication?
+
+**A**: Not recommended, but possible by removing middleware registration:
+
+```csharp
+// Remove this line:
+// app.UseMiddleware<ElectronAuthenticationMiddleware>();
+```
+
+**Warning**: Only do this if:
+- Application runs on single-user machines only
+- No Terminal Services / RDP access
+- You understand the security implications
+
+### Q: Does this work with hot reload?
+
+**A**: Yes, cookie persists across hot reload as long as Electron process keeps running.
+
+### Q: What about multiple Electron windows?
+
+**A**: All windows in the same Electron process share cookies automatically. Authentication works seamlessly across multiple windows.
+
+### Q: How do I test authentication?
+
+**Test 1 - Happy Path**:
+1. Run application normally
+2. Check logs for "Authentication successful"
+3. Verify cookie is set (DevTools → Application → Cookies)
+4. Subsequent requests should not include token in URL
+
+**Test 2 - Invalid Token**:
+1. Modify token in browser URL: `?token=invalid`
+2. Should receive 401 Unauthorized
+3. Check logs for "Authentication failed: Invalid token"
+
+**Test 3 - No Token**:
+1. Open browser manually to `http://localhost:PORT/`
+2. Should receive 401 Unauthorized
+3. Check logs for "Authentication failed: No cookie or token"
+
+**Test 4 - Multi-User** (Windows Server/Terminal Services):
+1. Launch app as User A
+2. In User B session, try to connect to User A's port
+3. Should receive 401 Unauthorized
+
+### Q: What about packaged applications?
+
+**A**: Authentication works identically in packaged mode. The `--authtoken` parameter is included in the packaged Electron executable.
+
+### Q: Can I customize the cookie name?
+
+**A**: Yes, modify `AuthCookieName` constant in `ElectronAuthenticationMiddleware.cs`:
+
+```csharp
+private const string AuthCookieName = "MyCustomCookieName";
+```
+
+## Summary
+
+Electron.NET's token-based authentication provides:
+
+✅ **Security**: 128-bit entropy, constant-time comparison, secure cookies  
+✅ **Simplicity**: Automatic token generation and validation  
+✅ **Compatibility**: Works with Blazor, SignalR, and static files  
+✅ **Monitoring**: Structured logging for security events  
+✅ **Multi-User**: Cross-user isolation on shared servers  
+
+The authentication system is **enabled by default** in SignalR mode and requires minimal configuration. For most applications, simply register the services and middleware - everything else happens automatically.
+
+For additional help or questions, see the [SignalR Implementation Summary](SignalR-Implementation-Summary.md) or open an issue on GitHub.

docs/GettingStarted/Console-App.md

@@ -54,7 +54,7 @@ Add the Electron.NET configuration to your `.csproj` file:
 </PropertyGroup>
 
 <ItemGroup>
-  <PackageReference Include="ElectronNET.Core" Version="0.3.0" />
+  <PackageReference Include="ElectronNET.Core" Version="0.4.1" />
 </ItemGroup>
 ```
 

docs/Using/Configuration.md

@@ -25,7 +25,7 @@ These are the current default values when you don't make any changes:
     <ElectronSingleInstance>true</ElectronSingleInstance>
     <ElectronSplashScreen></ElectronSplashScreen>
     <ElectronIcon></ElectronIcon>
-    <PackageId>$(MSBuildProjectName.Replace(".", "-").ToLower())</PackageId>
+    <ElectronPackageId>$(MSBuildProjectName.Replace(".", "-").ToLower())</ElectronPackageId>
     <ElectronBuilderJson>electron-builder.json</ElectronBuilderJson>
     <Title>$(MSBuildProjectName)</Title>
 </PropertyGroup>
@@ -38,15 +38,15 @@ Since electron builder still expects a `package.json` file to exist, ElectronNET
 
 ```json
 {
-  "name": "$(PackageId)",
+  "name": "$(ElectronPackageId)",
   "productName": "$(ElectronTitle)",
   "build": {
-    "appId": "$(PackageId)",
+    "appId": "$(ElectronPackageId)",
     "linux": {
       "desktop": {
         "entry": { "Name": "$(Title)" }
       },
-      "executableName": "$(PackageId)"
+      "executableName": "$(ElectronPackageId)"
     },
     "deb": {
       "desktop": {
@@ -85,6 +85,26 @@ BrowserWindowOptions browserWindowOptions = new BrowserWindowOptions
 ```
 
 
+### Preload Script
+
+If you require the use of a [preload script](https://www.electronjs.org/docs/latest/tutorial/tutorial-preload), you can specify the file path of the script when creating a new window like so:
+
+```csharp
+WebPreferences wp = new WebPreferences();
+wp.Preload = "path/to/preload.js";
+BrowserWindowOptions browserWindowOptions = new BrowserWindowOptions
+{
+    WebPreferences = wp
+};
+```
+
+> [!IMPORTANT]
+> When using a preload script _AND_ running a Blazor app, `IsRunningBlazor` must be set to `false` (or removed) and the following lines must be added to the preload script:
+> ```js
+> global.process = undefined;
+> global.module = undefined;
+> ```
+
 
 ## 🚀 Next Steps
 

src/ElectronNET.API/API/ApiBase.cs

@@ -314,7 +314,9 @@ namespace ElectronNET.API
                         {
                             if (this.tcs != null)
                             {
-                                var ex = new TimeoutException($"No response after {timeout:D}ms trying to retrieve value {apiBase.objectName}.{callerName}()");
+                                var ex = new TimeoutException(
+                                    $"No response after {(long)timeout.TotalMilliseconds}ms trying to retrieve value {apiBase.objectName}.{callerName}()"
+                                );
                                 this.tcs.TrySetException(ex);
                                 this.tcs = null;
                             }

src/ElectronNET.API/API/App.cs

@@ -427,7 +427,7 @@ namespace ElectronNET.API
 
         public void DisposeSocket()
         {
-            BridgeConnector.Socket.DisposeSocket();
+            BridgeConnector.Socket.Dispose();
         }
 
         /// <summary>

src/ElectronNET.API/API/BrowserWindow.cs

@@ -186,6 +186,19 @@ public class BrowserWindow : ApiBase
         remove => RemoveEvent(value, Id);
     }
 
+    /// <summary>
+    /// Emitted when the window is moved or resized.
+    /// </summary>
+    /// <remarks>
+    ///     While not being an original Electron event, this one includes the bounds values,
+    ///     saving the additional roundtrip for calling <see cref="GetBoundsAsync"/>.
+    /// </remarks>
+    public event Action<Rectangle> OnBoundsChanged
+    {
+        add => AddEvent(value, Id);
+        remove => RemoveEvent(value, Id);
+    }
+
     /// <summary>
     /// macOS: Emitted once when the window is moved to a new position.
     /// </summary>

src/ElectronNET.API/API/Cookies.cs

@@ -2,6 +2,7 @@ using ElectronNET.API.Entities;
 using ElectronNET.API.Serialization;
 using System;
 using System.Text.Json;
+using System.Threading.Tasks;
 
 namespace ElectronNET.API
 {
@@ -54,10 +55,79 @@ namespace ElectronNET.API
                 _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 tcs = new TaskCompletionSource<Cookie[]>();
+            var guid = Guid.NewGuid().ToString();
+
+            BridgeConnector.Socket.Once<Cookie[]>("webContents-session-cookies-get-completed" + guid, tcs.SetResult);
+            BridgeConnector.Socket.Emit("webContents-session-cookies-get", Id, filter, guid);
+
+            return tcs.Task;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="details"></param>
+        /// <returns></returns>
+        public Task SetAsync(CookieDetails details)
+        {
+            var tcs = new TaskCompletionSource<object>();
+            var guid = Guid.NewGuid().ToString();
+
+            BridgeConnector.Socket.Once<object>("webContents-session-cookies-set-completed" + guid, tcs.SetResult);
+            BridgeConnector.Socket.Emit("webContents-session-cookies-set", Id, details, guid);
+
+            return tcs.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 tcs = new TaskCompletionSource<object>();
+            var guid = Guid.NewGuid().ToString();
+
+            BridgeConnector.Socket.Once<object>("webContents-session-cookies-remove-completed" + guid, tcs.SetResult);
+            BridgeConnector.Socket.Emit("webContents-session-cookies-remove", Id, url, name, guid);
+
+            return tcs.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 tcs = new TaskCompletionSource<object>();
+            var guid = Guid.NewGuid().ToString();
+
+            BridgeConnector.Socket.Once<object>("webContents-session-cookies-flushStore-completed" + guid, tcs.SetResult);
+            BridgeConnector.Socket.Emit("webContents-session-cookies-flushStore", Id, guid);
+
+            return tcs.Task;
+        }
     }
 }

src/ElectronNET.API/API/Entities/BrowserWindowOptions.cs

@@ -24,13 +24,13 @@ namespace ElectronNET.API.Entities
         /// ( if y is used) Window's left offset from screen. Default is to center the
         /// window.
         /// </summary>
-        public int X { get; set; } = -1;
+        public int? X { get; set; }
 
         /// <summary>
         /// ( if x is used) Window's top offset from screen. Default is to center the
         /// window.
         /// </summary>
-        public int Y { get; set; } = -1;
+        public int? Y { get; set; }
 
         /// <summary>
         /// The width and height would be used as web page's size, which means the actual

src/ElectronNET.API/API/Entities/Cookie.cs

@@ -24,7 +24,7 @@
         /// <summary>
         /// Gets or sets a value indicating whether the cookie is a host-only cookie; this will only be true if no domain was passed.
         /// </summary>
-        public bool HostOnly { get; set; }
+        public bool? HostOnly { get; set; }
 
         /// <summary>
         /// Gets or sets the path of the cookie.
@@ -34,22 +34,22 @@
         /// <summary>
         /// Gets or sets a value indicating whether the cookie is marked as secure.
         /// </summary>
-        public bool Secure { get; set; }
+        public bool? Secure { get; set; }
 
         /// <summary>
         /// Gets or sets a value indicating whether the cookie is marked as HTTP only.
         /// </summary>
-        public bool HttpOnly { get; set; }
+        public bool? HttpOnly { get; set; }
 
         /// <summary>
         /// Gets or sets a value indicating whether the cookie is a session cookie or a persistent cookie with an expiration date.
         /// </summary>
-        public bool Session { get; set; }
+        public bool? Session { get; set; }
 
         /// <summary>
         /// Gets or sets the expiration date of the cookie as the number of seconds since the UNIX epoch. Not provided for session cookies.
         /// </summary>
-        public double ExpirationDate { get; set; }
+        public double? ExpirationDate { get; set; }
 
         /// <summary>
         /// Gets or sets the SameSite policy applied to this cookie. Can be "unspecified", "no_restriction", "lax" or "strict".

src/ElectronNET.API/API/Entities/CookieFilter.cs

@@ -29,16 +29,16 @@
         /// <summary>
         /// (optional) - Filters cookies by their Secure property.
         /// </summary>
-        public bool Secure { get; set; }
+        public bool? Secure { get; set; }
 
         /// <summary>
         /// (optional) - Filters out session or persistent cookies.
         /// </summary>
-        public bool Session { get; set; }
+        public bool? Session { get; set; }
 
         /// <summary>
         /// (optional) - Filters cookies by httpOnly.
         /// </summary>
-        public bool HttpOnly { get; set; }
+        public bool? HttpOnly { get; set; }
     }
 }

src/ElectronNET.API/API/IpcMain.cs

@@ -102,6 +102,29 @@ namespace ElectronNET.API
             });
         }
 
+        /// <summary>
+        /// Send a message to the renderer process synchronously via channel,
+        /// you can also send arbitrary arguments.
+        /// 
+        /// Note: Sending a synchronous message will block the whole renderer process,
+        /// unless you know what you are doing you should never use it.
+        /// </summary>
+        /// <param name="channel"></param>
+        /// <param name="listener"></param>
+        public void OnSync(string channel, Func<object, Task<object>> listener)
+        {
+            BridgeConnector.Socket.Emit("registerSyncIpcMainChannel", channel);
+            BridgeConnector.Socket.On<JsonElement>(channel, (args) =>
+            {
+                Task.Run(async () =>
+                {
+                    var arg = FormatArguments(args);
+                    var result = await listener(arg);
+                    BridgeConnector.Socket.Emit(channel + "Sync", result);
+                });
+            });
+        }
+
         /// <summary>
         /// Adds a one time listener method for the event. This listener is invoked only
         ///  the next time a message is sent to channel, after which it is removed.
@@ -154,5 +177,88 @@ namespace ElectronNET.API
         {
             BridgeConnector.Socket.Emit("sendToIpcRendererBrowserView", browserView.Id, channel, data);
         }
+
+        /// <summary>
+        /// Adds a handler for an invokeable IPC. This handler will be called
+        /// whenever a renderer calls ipcRenderer.invoke(channel, ...args).
+        /// </summary>
+        /// <param name="channel">Channelname.</param>
+        /// <param name="listener">Callback Method.</param>
+        public void Handle(string channel, Func<object, object> listener)
+        {
+            BridgeConnector.Socket.Emit("registerHandleIpcMainChannel", channel);
+            BridgeConnector.Socket.On<JsonElement>(channel, (args) =>
+            {
+                var arg = FormatArguments(args);
+                var result = listener(arg);
+                BridgeConnector.Socket.Emit(channel + "Handle", result);
+            });
+        }
+
+        /// <summary>
+        /// Adds a handler for an invokeable IPC. This handler will be called
+        /// whenever a renderer calls ipcRenderer.invoke(channel, ...args).
+        /// </summary>
+        /// <param name="channel">Channelname.</param>
+        /// <param name="listener">Callback Method.</param>
+        public void Handle(string channel, Func<object, Task<object>> listener)
+        {
+            BridgeConnector.Socket.Emit("registerHandleIpcMainChannel", channel);
+            BridgeConnector.Socket.On<JsonElement>(channel, (args) =>
+            {
+                Task.Run(async () =>
+                {
+                    var arg = FormatArguments(args);
+                    var result = await listener(arg);
+                    BridgeConnector.Socket.Emit(channel + "Handle", result);
+                });
+            });
+        }
+
+        /// <summary>
+        /// Handles a single invokeable IPC message, then removes the listener.
+        /// See ipcMain.handle(channel, listener).
+        /// </summary>
+        /// <param name="channel">Channelname.</param>
+        /// <param name="listener">Callback Method.</param>
+        public void HandleOnce(string channel, Func<object, object> listener)
+        {
+            BridgeConnector.Socket.Emit("registerHandleOnceIpcMainChannel", channel);
+            BridgeConnector.Socket.Once<JsonElement>(channel, (args) =>
+            {
+                var arg = FormatArguments(args);
+                var result = listener(arg);
+                BridgeConnector.Socket.Emit(channel + "HandleOnce", result);
+            });
+        }
+
+        /// <summary>
+        /// Handles a single invokeable IPC message, then removes the listener.
+        /// See ipcMain.handle(channel, listener).
+        /// </summary>
+        /// <param name="channel">Channelname.</param>
+        /// <param name="listener">Callback Method.</param>
+        public void HandleOnce(string channel, Func<object, Task<object>> listener)
+        {
+            BridgeConnector.Socket.Emit("registerHandleOnceIpcMainChannel", channel);
+            BridgeConnector.Socket.Once<JsonElement>(channel, (args) =>
+            {
+                Task.Run(async () =>
+                {
+                    var arg = FormatArguments(args);
+                    var result = await listener(arg);
+                    BridgeConnector.Socket.Emit(channel + "HandleOnce", result);
+                });
+            });
+        }
+
+        /// <summary>
+        /// Removes any handler for channel, if present.
+        /// </summary>
+        /// <param name="channel">Channelname.</param>
+        public void RemoveHandler(string channel)
+        {
+            BridgeConnector.Socket.Emit("removeHandlerIpcMainChannel", channel);
+        }
     }
 }

src/ElectronNET.API/API/Screen.cs

@@ -124,6 +124,15 @@ namespace ElectronNET.API
         /// <returns>An array of displays that are currently available.</returns>
         public Task<Display[]> GetAllDisplaysAsync() => this.InvokeAsync<Display[]>();
 
+        /// <summary>
+        /// An array of displays that are currently available.
+        /// </summary>
+        /// <param name="invocationTimeout">The invocation timeout.</param>
+        /// <returns>
+        /// An array of displays that are currently available.
+        /// </returns>
+        public Task<Display[]> GetAllDisplaysAsync(TimeSpan invocationTimeout) => this.InvokeAsyncWithTimeout<Display[]>(invocationTimeout);
+
         /// <summary>
         /// The display nearest the specified point.
         /// </summary>

src/ElectronNET.API/API/WindowManager.cs

@@ -130,11 +130,8 @@ namespace ElectronNET.API
                 options.Height += 7;
             }
 
-            if (options.X == -1 && options.Y == -1)
+            if (!options.X.HasValue && !options.Y.HasValue)
             {
-                options.X = 0;
-                options.Y = 0;
-
                 await BridgeConnector.Socket.Emit("createBrowserWindow", options, loadUrl).ConfigureAwait(false);
             }
             else

src/ElectronNET.API/Bridge/BridgeConnector.cs

@@ -2,9 +2,11 @@
 // ReSharper disable once CheckNamespace
 namespace ElectronNET.API
 {
+    using ElectronNET.API.Bridge;
+
     internal static class BridgeConnector
     {
-        public static SocketIoFacade Socket
+        public static ISocketConnection Socket
         {
             get
             {

src/ElectronNET.API/Bridge/ISocketConnection.cs

@@ -0,0 +1,57 @@
+namespace ElectronNET.API.Bridge
+{
+    using System;
+    using System.Threading.Tasks;
+
+    /// <summary>
+    /// Common interface for communication facades.
+    /// Provides methods for bidirectional communication between .NET and Electron.
+    /// </summary>
+    internal interface ISocketConnection : IDisposable
+    {
+        /// <summary>
+        /// Raised when the bridge connection is established.
+        /// </summary>
+        event EventHandler BridgeConnected;
+
+        /// <summary>
+        /// Raised when the bridge connection is lost.
+        /// </summary>
+        event EventHandler BridgeDisconnected;
+
+        /// <summary>
+        /// Establishes the connection to Electron.
+        /// </summary>
+        void Connect();
+
+        /// <summary>
+        /// Registers a persistent event handler.
+        /// </summary>
+        void On(string eventName, Action action);
+
+        /// <summary>
+        /// Registers a persistent event handler with a typed parameter.
+        /// </summary>
+        void On<T>(string eventName, Action<T> action);
+
+        /// <summary>
+        /// Registers a one-time event handler.
+        /// </summary>
+        void Once(string eventName, Action action);
+
+        /// <summary>
+        /// Registers a one-time event handler with a typed parameter.
+        /// </summary>
+        void Once<T>(string eventName, Action<T> action);
+
+        /// <summary>
+        /// Removes an event handler.
+        /// </summary>
+        void Off(string eventName);
+
+        /// <summary>
+        /// Sends a message to Electron.
+        /// </summary>
+        Task Emit(string eventName, params object[] args);
+    }
+}

src/ElectronNET.API/Bridge/SocketIOConnection.cs

@@ -3,19 +3,30 @@
 namespace ElectronNET.API;
 
 using System;
+using System.Collections.Generic;
 using System.Threading.Tasks;
+using ElectronNET.API.Bridge;
 using ElectronNET.API.Serialization;
 using SocketIO.Serializer.SystemTextJson;
 using SocketIO = SocketIOClient.SocketIO;
+using SocketIOOptions = SocketIOClient.SocketIOOptions;
 
-internal class SocketIoFacade
+internal class SocketIOConnection : ISocketConnection
 {
     private readonly SocketIO _socket;
     private readonly object _lockObj = new object();
+    private bool _isDisposed;
 
-    public SocketIoFacade(string uri)
+    public SocketIOConnection(string uri, string authorization)
     {
-        _socket = new SocketIO(uri);
+        var opts = string.IsNullOrEmpty(authorization) ? new SocketIOOptions() : new SocketIOOptions
+        {
+            ExtraHeaders = new Dictionary<string, string>
+            {
+                ["authorization"] = authorization
+            },
+        };
+        _socket = new SocketIO(uri, opts);
         _socket.Serializer = new SystemTextJsonSerializer(ElectronJson.Options);
         // Use default System.Text.Json serializer from SocketIOClient.
         // Outgoing args are normalized to camelCase via SerializeArg in Emit.
@@ -27,6 +38,8 @@ internal class SocketIoFacade
 
     public void Connect()
     {
+        this.CheckDisposed();
+
         _socket.OnError += (sender, e) => { Console.WriteLine($"BridgeConnector Error: {sender} {e}"); };
 
         _socket.OnConnected += (_, _) =>
@@ -46,6 +59,8 @@ internal class SocketIoFacade
 
     public void On(string eventName, Action action)
     {
+        this.CheckDisposed();
+
         lock (_lockObj)
         {
             _socket.On(eventName, _ => { Task.Run(action); });
@@ -54,6 +69,8 @@ internal class SocketIoFacade
 
     public void On<T>(string eventName, Action<T> action)
     {
+        this.CheckDisposed();
+
         lock (_lockObj)
         {
             _socket.On(eventName, response =>
@@ -66,6 +83,8 @@ internal class SocketIoFacade
 
     public void Once(string eventName, Action action)
     {
+        this.CheckDisposed();
+
         lock (_lockObj)
         {
             _socket.On(eventName, _ =>
@@ -78,6 +97,8 @@ internal class SocketIoFacade
 
     public void Once<T>(string eventName, Action<T> action)
     {
+        this.CheckDisposed();
+
         lock (_lockObj)
         {
             _socket.On(eventName, (socketIoResponse) =>
@@ -90,6 +111,11 @@ internal class SocketIoFacade
 
     public void Off(string eventName)
     {
+        if (_isDisposed)
+        {
+            return;
+        }
+
         lock (_lockObj)
         {
             _socket.Off(eventName);
@@ -98,11 +124,33 @@ internal class SocketIoFacade
 
     public async Task Emit(string eventName, params object[] args)
     {
-        await _socket.EmitAsync(eventName, args).ConfigureAwait(false);
+        if (!_isDisposed)
+        {
+            await _socket.EmitAsync(eventName, args).ConfigureAwait(false);
+        }
     }
 
-    public void DisposeSocket()
+    /// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
+    public void Dispose()
     {
-        _socket.Dispose();
+        Dispose(true);
+        GC.SuppressFinalize(this);
+    }
+
+    protected virtual void Dispose(bool disposing)
+    {
+        if (disposing)
+        {
+            _isDisposed = true;
+            _socket.Dispose();
+        }
+    }
+
+    private void CheckDisposed()
+    {
+        if (this._isDisposed)
+        {
+            throw new ObjectDisposedException(nameof(SocketIOConnection));
+        }
     }
 }

src/ElectronNET.API/Common/ProcessRunner.cs

@@ -26,6 +26,8 @@
         private readonly StringBuilder stdOut = new StringBuilder(4 * 1024);
         private readonly StringBuilder stdErr = new StringBuilder(4 * 1024);
 
+        public event EventHandler<string> LineReceived;
+
         private volatile ManualResetEvent stdOutEvent;
         private volatile ManualResetEvent stdErrEvent;
         private volatile Stopwatch stopwatch;
@@ -571,6 +573,7 @@
             if (e.Data != null)
             {
                 Console.WriteLine("|| " + e.Data);
+                LineReceived?.Invoke(this, e.Data);
             }
             else
             {

src/ElectronNET.API/ElectronNetRuntime.cs

@@ -1,6 +1,7 @@
 namespace ElectronNET
 {
     using ElectronNET.API;
+    using ElectronNET.API.Bridge;
     using ElectronNET.Runtime;
     using ElectronNET.Runtime.Controllers;
     using ElectronNET.Runtime.Data;
@@ -16,6 +17,7 @@
         internal const int DefaultWebPort = 8001;
         internal const string ElectronPortArgumentName = "electronPort";
         internal const string ElectronPidArgumentName = "electronPID";
+        internal const string ElectronAuthTokenArgumentName = "electronAuthToken";
 
         /// <summary>Initializes the <see cref="ElectronNetRuntime"/> class.</summary>
         static ElectronNetRuntime()
@@ -26,6 +28,8 @@
 
         public static string ElectronExtraArguments { get; set; }
 
+        public static string ElectronAuthToken { get; internal set; }
+
         public static int? ElectronSocketPort { get; internal set; }
 
         public static int? AspNetWebPort { get; internal set; }
@@ -49,7 +53,7 @@
 
         internal static Func<Task> OnAppReadyCallback { get; set; }
 
-        internal static SocketIoFacade GetSocket()
+        internal static ISocketConnection GetSocket()
         {
             return RuntimeControllerCore?.Socket;
         }

src/ElectronNET.API/Runtime/Controllers/RuntimeControllerBase.cs

@@ -1,6 +1,7 @@
 namespace ElectronNET.Runtime.Controllers
 {
     using ElectronNET.API;
+    using ElectronNET.API.Bridge;
     using ElectronNET.Runtime.Services;
     using ElectronNET.Runtime.Services.ElectronProcess;
     using ElectronNET.Runtime.Services.SocketBridge;
@@ -12,7 +13,7 @@
         {
         }
 
-        internal abstract SocketIoFacade Socket { get; }
+        internal abstract ISocketConnection Socket { get; }
 
         internal abstract ElectronProcessBase ElectronProcess { get; }
 

src/ElectronNET.API/Runtime/Controllers/RuntimeControllerDotNetFirst.cs

@@ -1,6 +1,7 @@
 namespace ElectronNET.Runtime.Controllers
 {
     using ElectronNET.API;
+    using ElectronNET.API.Bridge;
     using ElectronNET.Common;
     using ElectronNET.Runtime.Data;
     using ElectronNET.Runtime.Helpers;
@@ -13,13 +14,12 @@
     {
         private ElectronProcessBase electronProcess;
         private SocketBridgeService socketBridge;
-        private int? port;
 
         public RuntimeControllerDotNetFirst()
         {
         }
 
-        internal override SocketIoFacade Socket
+        internal override ISocketConnection Socket
         {
             get
             {
@@ -41,19 +41,13 @@
             var isUnPacked = ElectronNetRuntime.StartupMethod.IsUnpackaged();
             var electronBinaryName = ElectronNetRuntime.ElectronExecutable;
             var args = string.Format("{0} {1}", ElectronNetRuntime.ElectronExtraArguments, Environment.CommandLine).Trim();
-            this.port = ElectronNetRuntime.ElectronSocketPort;
-
-            if (!this.port.HasValue)
-            {
-                this.port = PortHelper.GetFreePort(ElectronNetRuntime.DefaultSocketPort);
-                ElectronNetRuntime.ElectronSocketPort = this.port;
-            }
+            var port = ElectronNetRuntime.ElectronSocketPort ?? 0;
 
             Console.Error.WriteLine("[StartCore]: isUnPacked: {0}", isUnPacked);
             Console.Error.WriteLine("[StartCore]: electronBinaryName: {0}", electronBinaryName);
             Console.Error.WriteLine("[StartCore]: args: {0}", args);
 
-            this.electronProcess = new ElectronProcessActive(isUnPacked, electronBinaryName, args, this.port.Value);
+            this.electronProcess = new ElectronProcessActive(isUnPacked, electronBinaryName, args, port);
             this.electronProcess.Ready += this.ElectronProcess_Ready;
             this.electronProcess.Stopped += this.ElectronProcess_Stopped;
 
@@ -63,8 +57,10 @@
 
         private void ElectronProcess_Ready(object sender, EventArgs e)
         {
+            var port = ElectronNetRuntime.ElectronSocketPort.Value;
+            var token = ElectronNetRuntime.ElectronAuthToken;
             this.TransitionState(LifetimeState.Started);
-            this.socketBridge = new SocketBridgeService(this.port!.Value);
+            this.socketBridge = new SocketBridgeService(port, token);
             this.socketBridge.Ready += this.SocketBridge_Ready;
             this.socketBridge.Stopped += this.SocketBridge_Stopped;
             this.socketBridge.Start();

src/ElectronNET.API/Runtime/Controllers/RuntimeControllerElectronFirst.cs

@@ -11,13 +11,12 @@
     {
         private ElectronProcessBase electronProcess;
         private SocketBridgeService socketBridge;
-        private int? port;
 
         public RuntimeControllerElectronFirst()
         {
         }
 
-        internal override SocketIoFacade Socket
+        internal override SocketIOConnection Socket
         {
             get
             {
@@ -36,12 +35,8 @@
 
         protected override Task StartCore()
         {
-            this.port = ElectronNetRuntime.ElectronSocketPort;
-
-            if (!this.port.HasValue)
-            {
-                throw new Exception("No port has been specified by Electron!");
-            }
+            var port = ElectronNetRuntime.ElectronSocketPort.Value;
+            var token = ElectronNetRuntime.ElectronAuthToken;
 
             if (!ElectronNetRuntime.ElectronProcessId.HasValue)
             {
@@ -49,7 +44,7 @@
             }
 
             this.TransitionState(LifetimeState.Starting);
-            this.socketBridge = new SocketBridgeService(this.port!.Value);
+            this.socketBridge = new SocketBridgeService(port, token);
             this.socketBridge.Ready += this.SocketBridge_Ready;
             this.socketBridge.Stopped += this.SocketBridge_Stopped;
             this.socketBridge.Start();

src/ElectronNET.API/Runtime/Data/BuildInfo.cs

@@ -8,7 +8,7 @@
 
         public string RuntimeIdentifier { get; internal set; }
 
-        public string ElectronSingleInstance { get; internal set; }
+        public bool ElectronSingleInstance { get; internal set; }
 
         public string Title { get; internal set; }
 

src/ElectronNET.API/Runtime/Helpers/UnpackagedDetector.cs

@@ -63,13 +63,15 @@
 
         private static bool? CheckUnpackaged2()
         {
-            var dir = new DirectoryInfo(AppDomain.CurrentDomain.BaseDirectory);
+            var baseDir = AppDomain.CurrentDomain.BaseDirectory;
+            var dir = new DirectoryInfo(baseDir);
+
             if (dir.Name == "bin" && dir.Parent?.Name == "resources")
             {
                 return false;
             }
 
-            if (dir.GetDirectories().Any(e => e.Name == ".electron"))
+            if (Directory.Exists(Path.Combine(baseDir, ".electron")))
             {
                 return true;
             }
@@ -84,7 +86,6 @@
                 return true;
             }
 
-
             return null;
         }
 

src/ElectronNET.API/Runtime/Services/ElectronProcess/ElectronProcessActive.cs

@@ -1,12 +1,15 @@
 namespace ElectronNET.Runtime.Services.ElectronProcess
 {
-    using ElectronNET.Common;
-    using ElectronNET.Runtime.Data;
     using System;
     using System.ComponentModel;
+    using System.Diagnostics;
     using System.IO;
+    using System.Linq;
     using System.Runtime.InteropServices;
+    using System.Text.RegularExpressions;
     using System.Threading.Tasks;
+    using ElectronNET.Common;
+    using ElectronNET.Runtime.Data;
 
     /// <summary>
     /// Launches and manages the Electron app process.
@@ -14,6 +17,7 @@
     [Localizable(false)]
     internal class ElectronProcessActive : ElectronProcessBase
     {
+        private readonly Regex extractor = new Regex("^Electron Socket: listening on port (\\d+) at .* using ([a-f0-9]+)$");
         private readonly bool isUnpackaged;
         private readonly string electronBinaryName;
         private readonly string extraArguments;
@@ -33,14 +37,42 @@
             this.socketPort = socketPort;
         }
 
-        protected override Task StartCore()
+        protected override async Task StartCore()
         {
             var dir = new DirectoryInfo(AppDomain.CurrentDomain.BaseDirectory);
             string startCmd, args, workingDir;
 
             if (this.isUnpackaged)
             {
+                this.CheckRuntimeIdentifier();
+
                 var electrondir = Path.Combine(dir.FullName, ".electron");
+
+                ProcessRunner chmodRunner = null;
+
+                try
+                {
+                    if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+                    {
+                        var distFolder = Path.Combine(electrondir, "node_modules", "electron", "dist");
+
+                        chmodRunner = new ProcessRunner("ElectronRunner-Chmod");
+                        chmodRunner.Run("chmod", "-R +x " + distFolder, electrondir);
+                        await chmodRunner.WaitForExitAsync().ConfigureAwait(true);
+
+                        if (chmodRunner.LastExitCode != 0)
+                        {
+                            throw new Exception("Failed to set executable permissions on Electron dist folder.");
+                        }
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Console.Error.WriteLine("[StartCore]: Exception: " + chmodRunner?.StandardError);
+                    Console.Error.WriteLine("[StartCore]: Exception: " + chmodRunner?.StandardOutput);
+                    Console.Error.WriteLine("[StartCore]: Exception: " + ex);
+                }
+
                 startCmd = Path.Combine(electrondir, "node_modules", "electron", "dist", "electron");
 
                 if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
@@ -53,17 +85,71 @@
             }
             else
             {
-                dir = dir.Parent?.Parent;
+                dir = dir.Parent!.Parent!;
                 startCmd = Path.Combine(dir.FullName, this.electronBinaryName);
                 args = $"-dotnetpacked -electronforcedport={this.socketPort:D} " + this.extraArguments;
                 workingDir = dir.FullName;
             }
 
-
             // We don't await this in order to let the state transition to "Starting"
             Task.Run(async () => await this.StartInternal(startCmd, args, workingDir).ConfigureAwait(false));
+        }
 
-            return Task.CompletedTask;
+        private void CheckRuntimeIdentifier()
+        {
+            var buildInfoRid = ElectronNetRuntime.BuildInfo.RuntimeIdentifier;
+            if (string.IsNullOrEmpty(buildInfoRid))
+            {
+                return;
+            }
+
+            var osPart = buildInfoRid.Split('-').First();
+
+            var mismatch = false;
+
+            switch (osPart)
+            {
+                case "win":
+
+                    if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+                    {
+                        mismatch = true;
+                    }
+
+                    break;
+
+                case "linux":
+
+                    if (!RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+                    {
+                        mismatch = true;
+                    }
+
+                    break;
+
+                case "osx":
+
+                    if (!RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
+                    {
+                        mismatch = true;
+                    }
+
+                    break;
+
+                case "freebsd":
+
+                    if (!RuntimeInformation.IsOSPlatform(OSPlatform.FreeBSD))
+                    {
+                        mismatch = true;
+                    }
+
+                    break;
+            }
+
+            if (mismatch)
+            {
+                throw new PlatformNotSupportedException($"This Electron.NET application was built for '{buildInfoRid}'. It cannot run on this platform.");
+            }
         }
 
         protected override Task StopCore()
@@ -74,18 +160,36 @@
 
         private async Task StartInternal(string startCmd, string args, string directoriy)
         {
+            var tcs = new TaskCompletionSource();
+
+            void Read_SocketIO_Parameters(object sender, string line)
+            {
+                // Look for "Electron Socket: listening on port %s at ..."
+                var match = extractor.Match(line);
+
+                if (match?.Success ?? false)
+                {
+                    var port = int.Parse(match.Groups[1].Value);
+                    var token = match.Groups[2].Value;
+
+                    this.process.LineReceived -= Read_SocketIO_Parameters;
+                    ElectronNetRuntime.ElectronAuthToken = token;
+                    ElectronNetRuntime.ElectronSocketPort = port;
+                    tcs.SetResult();
+                }
+            }
+
             try
             {
-                await Task.Delay(10.ms()).ConfigureAwait(false);
-
                 Console.Error.WriteLine("[StartInternal]: startCmd: {0}", startCmd);
                 Console.Error.WriteLine("[StartInternal]: args: {0}", args);
 
                 this.process = new ProcessRunner("ElectronRunner");
                 this.process.ProcessExited += this.Process_Exited;
+                this.process.LineReceived += Read_SocketIO_Parameters;
                 this.process.Run(startCmd, args, directoriy);
 
-                await Task.Delay(500.ms()).ConfigureAwait(false);
+                await tcs.Task.ConfigureAwait(false);
 
                 Console.Error.WriteLine("[StartInternal]: after run:");
 

src/ElectronNET.API/Runtime/Services/SocketBridge/SocketBridgeService.cs

@@ -8,22 +8,24 @@
     internal class SocketBridgeService : LifetimeServiceBase
     {
         private readonly int socketPort;
+        private readonly string authorization;
         private readonly string socketUrl;
-        private SocketIoFacade socket;
+        private SocketIOConnection socket;
 
-        public SocketBridgeService(int socketPort)
+        public SocketBridgeService(int socketPort, string authorization)
         {
             this.socketPort = socketPort;
+            this.authorization = authorization;
             this.socketUrl = $"http://localhost:{this.socketPort}";
         }
 
         public int SocketPort => this.socketPort;
 
-        internal SocketIoFacade Socket => this.socket;
+        internal SocketIOConnection Socket => this.socket;
 
         protected override Task StartCore()
         {
-            this.socket = new SocketIoFacade(this.socketUrl);
+            this.socket = new SocketIOConnection(this.socketUrl, this.authorization);
             this.socket.BridgeConnected += this.Socket_BridgeConnected;
             this.socket.BridgeDisconnected += this.Socket_BridgeDisconnected;
             Task.Run(this.Connect);
@@ -33,7 +35,7 @@
 
         protected override Task StopCore()
         {
-            this.socket.DisposeSocket();
+            this.socket.Dispose();
             return Task.CompletedTask;
         }
 

src/ElectronNET.API/Runtime/StartupManager.cs

@@ -25,7 +25,6 @@
             this.CollectProcessData();
             this.SetElectronExecutable();
 
-
             ElectronNetRuntime.StartupMethod = this.DetectAppTypeAndStartup();
             Console.WriteLine((string)("Evaluated StartupMethod: " + ElectronNetRuntime.StartupMethod));
 
@@ -57,21 +56,11 @@
 
             if (isLaunchedByDotNet)
             {
-                if (isUnPackaged)
-                {
-                    return StartupMethod.UnpackedDotnetFirst;
-                }
-
-                return StartupMethod.PackagedDotnetFirst;
+                return isUnPackaged ? StartupMethod.UnpackedDotnetFirst: StartupMethod.PackagedDotnetFirst;
             }
             else
             {
-                if (isUnPackaged)
-                {
-                    return StartupMethod.UnpackedElectronFirst;
-                }
-
-                return StartupMethod.PackagedElectronFirst;
+                return isUnPackaged ? StartupMethod.UnpackedElectronFirst: StartupMethod.PackagedElectronFirst;
             }
         }
 
@@ -86,10 +75,10 @@
             if (portArg != null)
             {
                 var parts = portArg.Split('=', StringSplitOptions.TrimEntries);
+
                 if (parts.Length > 1 && int.TryParse(parts[1], NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out var result))
                 {
                     ElectronNetRuntime.ElectronSocketPort = result;
-
                     Console.WriteLine("Use Electron Port: " + result);
                 }
             }
@@ -99,18 +88,33 @@
             if (pidArg != null)
             {
                 var parts = pidArg.Split('=', StringSplitOptions.TrimEntries);
+
                 if (parts.Length > 1 && int.TryParse(parts[1], NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out var result))
                 {
                     ElectronNetRuntime.ElectronProcessId = result;
-
                     Console.WriteLine("Electron Process ID: " + result);
                 }
             }
+
+            var authTokenArg = argsList.FirstOrDefault(e => e.Contains(ElectronNetRuntime.ElectronAuthTokenArgumentName, StringComparison.OrdinalIgnoreCase));
+
+            if (authTokenArg != null)
+            {
+                var parts = authTokenArg.Split('=', StringSplitOptions.TrimEntries);
+
+                if (parts.Length > 1 && !string.IsNullOrWhiteSpace(parts[1]))
+                {
+                    var result = parts[1];
+                    ElectronNetRuntime.ElectronAuthToken = result;
+                    Console.WriteLine("Use Auth Token: " + result);
+                }
+            }
         }
 
         private void SetElectronExecutable()
         {
-            string executable = ElectronNetRuntime.BuildInfo.ElectronExecutable;
+            var executable = ElectronNetRuntime.BuildInfo.ElectronExecutable;
+
             if (string.IsNullOrEmpty(executable))
             {
                 throw new Exception("AssemblyMetadataAttribute 'ElectronExecutable' could not be found!");
@@ -165,13 +169,9 @@
                     ElectronNetRuntime.DotnetAppType = DotnetAppType.AspNetCoreApp;
                 }
 
-                if (isSingleInstance?.Length > 0 && bool.TryParse(isSingleInstance, out var isSingleInstanceActive) && isSingleInstanceActive)
+                if (bool.TryParse(isSingleInstance, out var parsedBool))
                 {
-                    buildInfo.ElectronSingleInstance = "yes";
-                }
-                else
-                {
-                    buildInfo.ElectronSingleInstance = "no";
+                    buildInfo.ElectronSingleInstance = parsedBool;
                 }
 
                 if (httpPort?.Length > 0 && int.TryParse(httpPort, out var port))

src/ElectronNET.AspNet/API/WebHostBuilderExtensions.cs

@@ -1,6 +1,7 @@
 namespace ElectronNET.API
 {
     using System;
+    using System.Diagnostics;
     using System.IO;
     using System.Threading.Tasks;
     using ElectronNET.AspNet;
@@ -10,6 +11,7 @@
     using ElectronNET.Runtime.Helpers;
     using Microsoft.AspNetCore.Hosting;
     using Microsoft.Extensions.DependencyInjection;
+    using Microsoft.Extensions.Hosting;
 
     /// <summary>
     /// Provides extension methods for <see cref="IWebHostBuilder"/> to enable Electron.NET
@@ -66,23 +68,26 @@
             // work as expected, see issue #952
             Environment.SetEnvironmentVariable("ELECTRON_RUN_AS_NODE", null);
 
-            var webPort = PortHelper.GetFreePort(ElectronNetRuntime.AspNetWebPort ?? ElectronNetRuntime.DefaultWebPort);
-            ElectronNetRuntime.AspNetWebPort = webPort;
+            var webPort = ElectronNetRuntime.AspNetWebPort ?? 0;
 
             // 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.
+
+            // For port 0 (dynamic port assignment), Kestrel requires binding to specific IP (127.0.0.1) not localhost
+            var host = webPort == 0? "127.0.0.1" : "localhost";
+
             if (Directory.Exists($"{AppDomain.CurrentDomain.BaseDirectory}\\wwwroot"))
             {
                 builder = builder.UseContentRoot(AppDomain.CurrentDomain.BaseDirectory)
-                    .UseUrls("http://localhost:" + webPort);
+                    .UseUrls($"http://{host}:{webPort}");
             }
             else
             {
-                builder = builder.UseUrls("http://localhost:" + webPort);
+                builder = builder.UseUrls($"http://{host}:{webPort}");
             }
 
-            builder = builder.ConfigureServices(services =>
+            builder = builder.ConfigureServices((context, services) =>
             {
                 services.AddTransient<IStartupFilter, ServerReadyStartupFilter>();
                 services.AddSingleton<AspNetLifetimeAdapter>();

src/ElectronNET.AspNet/Middleware/ElectronAuthenticationMiddleware.cs

@@ -0,0 +1,100 @@
+namespace ElectronNET.AspNet.Middleware
+{
+    using System;
+    using System.Threading.Tasks;
+    using Microsoft.AspNetCore.Http;
+    using Microsoft.Extensions.Logging;
+    using ElectronNET.AspNet.Services;
+
+    /// <summary>
+    /// Middleware that validates authentication for all Electron requests.
+    /// Checks for authentication cookie or token query parameter on first request.
+    /// Sets HttpOnly cookie for subsequent requests.
+    /// 
+    /// Security Model:
+    /// - First request includes token as query parameter (?token=guid)
+    /// - Middleware validates token and sets secure HttpOnly cookie
+    /// - Subsequent requests use cookie (no token in URL)
+    /// - HTTP endpoints protected
+    /// </summary>
+    public class ElectronAuthenticationMiddleware
+    {
+        private readonly RequestDelegate _next;
+        private readonly IElectronAuthenticationService _authService;
+        private readonly ILogger<ElectronAuthenticationMiddleware> _logger;
+        private const string AuthCookieName = "ElectronAuth";
+
+        public ElectronAuthenticationMiddleware(
+            RequestDelegate next,
+            IElectronAuthenticationService authService,
+            ILogger<ElectronAuthenticationMiddleware> logger)
+        {
+            _next = next;
+            _authService = authService;
+            _logger = logger;
+        }
+
+        public async Task InvokeAsync(HttpContext context)
+        {
+            var path = context.Request.Path.Value;
+
+            // Check if authentication cookie exists
+            var authCookie = context.Request.Cookies[AuthCookieName];
+
+            if (!string.IsNullOrEmpty(authCookie))
+            {
+                // Cookie present - validate it
+                if (_authService.ValidateToken(authCookie))
+                {
+                    await _next(context);
+                    return;
+                }
+                else
+                {
+                    // Invalid cookie - reject
+                    _logger.LogWarning("Authentication failed: Invalid cookie for path {Path} from {RemoteIp}", path, context.Connection.RemoteIpAddress);
+                    context.Response.StatusCode = 401;
+                    await context.Response.WriteAsync("Unauthorized: Invalid authentication");
+                    return;
+                }
+            }
+
+            // No cookie - check for token in query string (first-time authentication)
+            var token = context.Request.Query["token"].ToString();
+
+            if (!string.IsNullOrEmpty(token))
+            {
+                if (_authService.ValidateToken(token))
+                {
+                    // Valid token - set cookie for future requests
+                    _logger.LogInformation("Authentication successful: Setting cookie for path {Path}", path);
+
+                    context.Response.Cookies.Append(AuthCookieName, token, new CookieOptions
+                    {
+                        HttpOnly = true,                     // Prevent JavaScript access (XSS protection)
+                        SameSite = SameSiteMode.Strict,      // CSRF protection
+                        Path = "/",                          // Valid for all routes
+                        Secure = false,                      // False because localhost is HTTP
+                        IsEssential = true                   // Required for app to function
+                    });
+
+                    await _next(context);
+                    return;
+                }
+                else
+                {
+                    // Invalid token - reject
+                    _logger.LogWarning("Authentication failed: Invalid token (prefix: {TokenPrefix}...) for path {Path} from {RemoteIp}", token.Length > 8 ? token.Substring(0, 8) : token, path, context.Connection.RemoteIpAddress);
+                    context.Response.StatusCode = 401;
+                    await context.Response.WriteAsync("Unauthorized: Invalid authentication");
+                    return;
+                }
+            }
+
+            // Neither cookie nor valid token present - reject
+            _logger.LogWarning("Authentication failed: No cookie or token provided for path {Path} from {RemoteIp}", path, context.Connection.RemoteIpAddress);
+            context.Response.StatusCode = 401;
+            await context.Response.WriteAsync("Unauthorized: Authentication required");
+        }
+    }
+}

src/ElectronNET.AspNet/Runtime/Controllers/RuntimeControllerAspNetBase.cs

@@ -1,8 +1,14 @@
 namespace ElectronNET.AspNet.Runtime
 {
     using System;
+    using System.Linq;
     using System.Threading.Tasks;
+    using Microsoft.AspNetCore.Hosting.Server;
+    using Microsoft.AspNetCore.Hosting.Server.Features;
+    using Microsoft.Extensions.DependencyInjection;
     using ElectronNET.API;
+    using ElectronNET.API.Bridge;
+    using ElectronNET.AspNet.Services;
     using ElectronNET.Common;
     using ElectronNET.Runtime.Controllers;
     using ElectronNET.Runtime.Data;
@@ -10,12 +16,16 @@
 
     internal abstract class RuntimeControllerAspNetBase : RuntimeControllerBase
     {
+        private readonly IServer server;
         private readonly AspNetLifetimeAdapter aspNetLifetimeAdapter;
+        private readonly IElectronAuthenticationService authenticationService;
         private SocketBridgeService socketBridge;
 
-        protected RuntimeControllerAspNetBase(AspNetLifetimeAdapter aspNetLifetimeAdapter)
+        protected RuntimeControllerAspNetBase(IServer server, AspNetLifetimeAdapter aspNetLifetimeAdapter, IElectronAuthenticationService authenticationService = null)
         {
+            this.server = server;
             this.aspNetLifetimeAdapter = aspNetLifetimeAdapter;
+            this.authenticationService = authenticationService;
             this.aspNetLifetimeAdapter.Ready += this.AspNetLifetimeAdapter_Ready;
             this.aspNetLifetimeAdapter.Stopping += this.AspNetLifetimeAdapter_Stopping;
             this.aspNetLifetimeAdapter.Stopped += this.AspNetLifetimeAdapter_Stopped;
@@ -25,7 +35,7 @@
 
         internal override SocketBridgeService SocketBridge => this.socketBridge;
 
-        internal override SocketIoFacade Socket
+        internal override ISocketConnection Socket
         {
             get
             {
@@ -38,9 +48,9 @@
             }
         }
 
-        protected void CreateSocketBridge(int port)
+        protected void CreateSocketBridge(int port, string authorization)
         {
-            this.socketBridge = new SocketBridgeService(port);
+            this.socketBridge = new SocketBridgeService(port, authorization);
             this.socketBridge.Ready += this.SocketBridge_Ready;
             this.socketBridge.Stopped += this.SocketBridge_Stopped;
             this.socketBridge.Start();
@@ -52,6 +62,15 @@
                 this.ElectronProcess.IsReady() &&
                 this.aspNetLifetimeAdapter.IsReady())
             {
+                var token = ElectronNetRuntime.ElectronAuthToken;
+                var serverAddressesFeature = this.server.Features.Get<IServerAddressesFeature>();
+                var address = serverAddressesFeature.Addresses.First();
+                var uri = new Uri(address);
+
+                // Only if somebody registered an IElectronAuthenticationService service - otherwise we do not care
+                this.authenticationService?.SetExpectedToken(token);
+                ElectronNetRuntime.AspNetWebPort = uri.Port;
+
                 this.TransitionState(LifetimeState.Ready);
                 Task.Run(this.RunReadyCallback);
             }

src/ElectronNET.AspNet/Runtime/Controllers/RuntimeControllerAspNetDotnetFirst.cs

@@ -2,17 +2,19 @@
 {
     using System;
     using System.Threading.Tasks;
+    using Microsoft.AspNetCore.Hosting.Server;
+    using ElectronNET.AspNet.Services;
     using ElectronNET.Common;
     using ElectronNET.Runtime.Data;
     using ElectronNET.Runtime.Helpers;
     using ElectronNET.Runtime.Services.ElectronProcess;
+    using System.Security.Principal;
 
     internal class RuntimeControllerAspNetDotnetFirst : RuntimeControllerAspNetBase
     {
         private ElectronProcessBase electronProcess;
-        private int? port;
 
-        public RuntimeControllerAspNetDotnetFirst(AspNetLifetimeAdapter aspNetLifetimeAdapter) : base(aspNetLifetimeAdapter)
+        public RuntimeControllerAspNetDotnetFirst(IServer server, AspNetLifetimeAdapter aspNetLifetimeAdapter, IElectronAuthenticationService authenticationService = null) : base(server, aspNetLifetimeAdapter, authenticationService)
         {
         }
 
@@ -22,16 +24,10 @@
         {
             var isUnPacked = ElectronNetRuntime.StartupMethod.IsUnpackaged();
             var electronBinaryName = ElectronNetRuntime.ElectronExecutable;
+            var port = ElectronNetRuntime.ElectronSocketPort ?? 0;
             var args = Environment.CommandLine;
-            this.port = ElectronNetRuntime.ElectronSocketPort;
 
-            if (!this.port.HasValue)
-            {
-                this.port = PortHelper.GetFreePort(ElectronNetRuntime.DefaultSocketPort);
-                ElectronNetRuntime.ElectronSocketPort = this.port;
-            }
-
-            this.electronProcess = new ElectronProcessActive(isUnPacked, electronBinaryName, args, this.port.Value);
+            this.electronProcess = new ElectronProcessActive(isUnPacked, electronBinaryName, args, port);
             this.electronProcess.Ready += this.ElectronProcess_Ready;
             this.electronProcess.Stopped += this.ElectronProcess_Stopped;
 
@@ -46,8 +42,10 @@
 
         private void ElectronProcess_Ready(object sender, EventArgs e)
         {
+            var port = ElectronNetRuntime.ElectronSocketPort.Value;
+            var token = ElectronNetRuntime.ElectronAuthToken;
             this.TransitionState(LifetimeState.Started);
-            this.CreateSocketBridge(this.port!.Value);
+            this.CreateSocketBridge(port, token);
         }
 
         private void ElectronProcess_Stopped(object sender, EventArgs e)

src/ElectronNET.AspNet/Runtime/Controllers/RuntimeControllerAspNetElectronFirst.cs

@@ -2,15 +2,16 @@
 {
     using System;
     using System.Threading.Tasks;
+    using Microsoft.AspNetCore.Hosting.Server;
+    using ElectronNET.AspNet.Services;
     using ElectronNET.Runtime.Data;
     using ElectronNET.Runtime.Services.ElectronProcess;
 
     internal class RuntimeControllerAspNetElectronFirst : RuntimeControllerAspNetBase
     {
         private ElectronProcessBase electronProcess;
-        private int? port;
 
-        public RuntimeControllerAspNetElectronFirst(AspNetLifetimeAdapter aspNetLifetimeAdapter) : base(aspNetLifetimeAdapter)
+        public RuntimeControllerAspNetElectronFirst(IServer server, AspNetLifetimeAdapter aspNetLifetimeAdapter, IElectronAuthenticationService authenticationService = null) : base(server, aspNetLifetimeAdapter, authenticationService)
         {
         }
 
@@ -18,19 +19,15 @@
 
         protected override Task StartCore()
         {
-            this.port = ElectronNetRuntime.ElectronSocketPort;
-
-            if (!this.port.HasValue)
-            {
-                throw new Exception("No port has been specified by Electron!");
-            }
+            var port = ElectronNetRuntime.ElectronSocketPort.Value;
+            var token = ElectronNetRuntime.ElectronAuthToken;
 
             if (!ElectronNetRuntime.ElectronProcessId.HasValue)
             {
                 throw new Exception("No electronPID has been specified by Electron!");
             }
 
-            this.CreateSocketBridge(this.port!.Value);
+            this.CreateSocketBridge(port, token);
 
             this.electronProcess = new ElectronProcessPassive(ElectronNetRuntime.ElectronProcessId.Value);
             this.electronProcess.Stopped += this.ElectronProcess_Stopped;

src/ElectronNET.AspNet/Services/ElectronAuthenticationService.cs

@@ -0,0 +1,53 @@
+namespace ElectronNET.AspNet.Services
+{
+    /// <summary>
+    /// Implementation of authentication service for Electron clients.
+    /// Stores and validates the authentication token to ensure only the spawned Electron process can connect.
+    /// </summary>
+    public class ElectronAuthenticationService : IElectronAuthenticationService
+    {
+        private string _expectedToken;
+        private readonly object _lock = new object();
+
+        /// <inheritdoc />
+        public void SetExpectedToken(string token)
+        {
+            lock (_lock)
+            {
+                _expectedToken = token;
+            }
+        }
+
+        /// <inheritdoc />
+        public bool ValidateToken(string token)
+        {
+            if (string.IsNullOrEmpty(token))
+                return false;
+
+            lock (_lock)
+            {
+                if (string.IsNullOrEmpty(_expectedToken))
+                    return false;
+
+                // Constant-time comparison to prevent timing attacks
+                return ConstantTimeEquals(token, _expectedToken);
+            }
+        }
+
+        /// <summary>
+        /// Performs constant-time string comparison to prevent timing attacks.
+        /// </summary>
+        private static bool ConstantTimeEquals(string a, string b)
+        {
+            if (a == null || b == null || a.Length != b.Length)
+                return false;
+
+            var result = 0;
+            for (int i = 0; i < a.Length; i++)
+            {
+                result |= a[i] ^ b[i];
+            }
+            return result == 0;
+        }
+    }
+}

src/ElectronNET.AspNet/Services/IElectronAuthenticationService.cs

@@ -0,0 +1,24 @@
+namespace ElectronNET.AspNet.Services
+{
+    /// <summary>
+    /// Service for validating authentication tokens from Electron clients.
+    /// Used to ensure only the Electron process spawned by this .NET instance can connect.
+    /// </summary>
+    public interface IElectronAuthenticationService
+    {
+        /// <summary>
+        /// Sets the expected authentication token for this instance.
+        /// Should be called when launching Electron with the generated token.
+        /// </summary>
+        /// <param name="token">The authentication token</param>
+        void SetExpectedToken(string token);
+
+        /// <summary>
+        /// Validates an incoming token against the expected token.
+        /// Uses constant-time comparison to prevent timing attacks.
+        /// </summary>
+        /// <param name="token">The token to validate</param>
+        /// <returns>True if token is valid, false otherwise</returns>
+        bool ValidateToken(string token);
+    }
+}

src/ElectronNET.ConsoleApp/ElectronNET.ConsoleApp.csproj

@@ -70,7 +70,7 @@
     <ProjectReference Include="..\ElectronNET.API\ElectronNET.API.csproj" Condition="$(ElectronNetDevMode)" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="ElectronNET.Core" Version="0.3.0" Condition="'$(ElectronNetDevMode)' != 'true'" />
+    <PackageReference Include="ElectronNET.Core" Version="0.4.1" Condition="'$(ElectronNetDevMode)' != 'true'" />
   </ItemGroup>
 
   <Import Project="..\ElectronNET\build\ElectronNET.Core.targets" Condition="$(ElectronNetDevMode)" />

src/ElectronNET.Host/ElectronNET.Host.esproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.VisualStudio.JavaScript.Sdk/1.0.4110890">
+<Project Sdk="Microsoft.VisualStudio.JavaScript.Sdk/1.0.3864779">
   <ItemGroup>
     <None Include=".vscode\tasks.json" />
   </ItemGroup>

src/ElectronNET.Host/api/app.js

@@ -1,13 +1,14 @@
 "use strict";
-let isQuitWindowAllClosed = true, electronSocket;
+let isQuitWindowAllClosed = true;
+let electronSocket;
 let appWindowAllClosedEventId;
 module.exports = (socket, app) => {
     electronSocket = socket;
     // By default, quit when all windows are closed
-    app.on('window-all-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) {
@@ -15,220 +16,224 @@ module.exports = (socket, app) => {
             // - OR -
             // If the user has indicated NOT to quit when all windows are closed,
             // emit the event.
-            electronSocket.emit('app-window-all-closed' + appWindowAllClosedEventId);
+            electronSocket.emit("app-window-all-closed" + appWindowAllClosedEventId);
         }
     });
-    socket.on('quit-app-window-all-closed', (quit) => {
+    socket.on("quit-app-window-all-closed", (quit) => {
         isQuitWindowAllClosed = quit;
     });
-    socket.on('register-app-window-all-closed', (id) => {
+    socket.on("register-app-window-all-closed", (id) => {
         appWindowAllClosedEventId = id;
     });
-    socket.on('register-app-before-quit', (id) => {
-        app.on('before-quit', (event) => {
+    socket.on("register-app-before-quit", (id) => {
+        app.on("before-quit", (event) => {
             event.preventDefault();
-            electronSocket.emit('app-before-quit' + id);
+            electronSocket.emit("app-before-quit" + id);
         });
     });
-    socket.on('register-app-will-quit', (id) => {
-        app.on('will-quit', (event) => {
+    socket.on("register-app-will-quit", (id) => {
+        app.on("will-quit", (event) => {
             event.preventDefault();
-            electronSocket.emit('app-will-quit' + id);
+            electronSocket.emit("app-will-quit" + id);
         });
     });
-    socket.on('register-app-browser-window-blur', (id) => {
-        app.on('browser-window-blur', () => {
-            electronSocket.emit('app-browser-window-blur' + id);
+    socket.on("register-app-browser-window-blur", (id) => {
+        app.on("browser-window-blur", () => {
+            electronSocket.emit("app-browser-window-blur" + id);
         });
     });
-    socket.on('register-app-browser-window-focus', (id) => {
-        app.on('browser-window-focus', () => {
-            electronSocket.emit('app-browser-window-focus' + id);
+    socket.on("register-app-browser-window-focus", (id) => {
+        app.on("browser-window-focus", () => {
+            electronSocket.emit("app-browser-window-focus" + id);
         });
     });
-    socket.on('register-app-browser-window-created', (id) => {
-        app.on('browser-window-created', () => {
-            electronSocket.emit('app-browser-window-created' + id);
+    socket.on("register-app-browser-window-created", (id) => {
+        app.on("browser-window-created", () => {
+            electronSocket.emit("app-browser-window-created" + id);
         });
     });
-    socket.on('register-app-web-contents-created', (id) => {
-        app.on('web-contents-created', () => {
-            electronSocket.emit('app-web-contents-created' + id);
+    socket.on("register-app-web-contents-created", (id) => {
+        app.on("web-contents-created", () => {
+            electronSocket.emit("app-web-contents-created" + id);
         });
     });
-    socket.on('register-app-accessibility-support-changed', (id) => {
-        app.on('accessibility-support-changed', (event, accessibilitySupportEnabled) => {
-            electronSocket.emit('app-accessibility-support-changed' + id, accessibilitySupportEnabled);
+    socket.on("register-app-accessibility-support-changed", (id) => {
+        app.on("accessibility-support-changed", (event, accessibilitySupportEnabled) => {
+            electronSocket.emit("app-accessibility-support-changed" + id, accessibilitySupportEnabled);
         });
     });
-    socket.on('appQuit', () => {
+    socket.on("appQuit", () => {
         app.quit();
     });
-    socket.on('appExit', (exitCode = 0) => {
+    socket.on("appExit", (exitCode = 0) => {
         app.exit(exitCode);
     });
-    socket.on('appRelaunch', (options) => {
+    socket.on("appRelaunch", (options) => {
         app.relaunch(options);
     });
-    socket.on('appFocus', (options) => {
+    socket.on("appFocus", (options) => {
         app.focus(options);
     });
-    socket.on('appHide', () => {
+    socket.on("appHide", () => {
         app.hide();
     });
-    socket.on('appShow', () => {
+    socket.on("appShow", () => {
         app.show();
     });
-    socket.on('appGetAppPath', () => {
+    socket.on("appGetAppPath", () => {
         const path = app.getAppPath();
-        electronSocket.emit('appGetAppPathCompleted', path);
+        electronSocket.emit("appGetAppPathCompleted", path);
     });
-    socket.on('appSetAppLogsPath', (path) => {
+    socket.on("appSetAppLogsPath", (path) => {
         app.setAppLogsPath(path);
     });
-    socket.on('appGetPath', (name) => {
+    socket.on("appGetPath", (name) => {
         const path = app.getPath(name);
-        electronSocket.emit('appGetPathCompleted', path);
+        electronSocket.emit("appGetPathCompleted", path);
     });
-    socket.on('appGetFileIcon', async (path, options) => {
+    socket.on("appGetFileIcon", async (path, options) => {
         let error = {};
         if (options) {
-            const nativeImage = await app.getFileIcon(path, options).catch((errorFileIcon) => error = errorFileIcon);
-            electronSocket.emit('appGetFileIconCompleted', [error, nativeImage]);
+            const nativeImage = await app
+                .getFileIcon(path, options)
+                .catch((errorFileIcon) => (error = errorFileIcon));
+            electronSocket.emit("appGetFileIconCompleted", [error, nativeImage]);
         }
         else {
-            const nativeImage = await app.getFileIcon(path).catch((errorFileIcon) => error = errorFileIcon);
-            electronSocket.emit('appGetFileIconCompleted', [error, nativeImage]);
+            const nativeImage = await app
+                .getFileIcon(path)
+                .catch((errorFileIcon) => (error = errorFileIcon));
+            electronSocket.emit("appGetFileIconCompleted", [error, nativeImage]);
         }
     });
-    socket.on('appSetPath', (name, path) => {
+    socket.on("appSetPath", (name, path) => {
         app.setPath(name, path);
     });
-    socket.on('appGetVersion', () => {
+    socket.on("appGetVersion", () => {
         const version = app.getVersion();
-        electronSocket.emit('appGetVersionCompleted', version);
+        electronSocket.emit("appGetVersionCompleted", version);
     });
-    socket.on('appGetName', () => {
-        electronSocket.emit('appGetNameCompleted', app.name);
+    socket.on("appGetName", () => {
+        electronSocket.emit("appGetNameCompleted", app.name);
     });
-    socket.on('appSetName', (name) => {
+    socket.on("appSetName", (name) => {
         app.name = name;
     });
-    socket.on('appGetLocale', () => {
+    socket.on("appGetLocale", () => {
         const locale = app.getLocale();
-        electronSocket.emit('appGetLocaleCompleted', locale);
+        electronSocket.emit("appGetLocaleCompleted", locale);
     });
-    socket.on('appAddRecentDocument', (path) => {
+    socket.on("appAddRecentDocument", (path) => {
         app.addRecentDocument(path);
     });
-    socket.on('appClearRecentDocuments', () => {
+    socket.on("appClearRecentDocuments", () => {
         app.clearRecentDocuments();
     });
-    socket.on('appSetAsDefaultProtocolClient', (protocol, path, args) => {
+    socket.on("appSetAsDefaultProtocolClient", (protocol, path, args) => {
         const success = app.setAsDefaultProtocolClient(protocol, path, args);
-        electronSocket.emit('appSetAsDefaultProtocolClientCompleted', success);
+        electronSocket.emit("appSetAsDefaultProtocolClientCompleted", success);
     });
-    socket.on('appRemoveAsDefaultProtocolClient', (protocol, path, args) => {
+    socket.on("appRemoveAsDefaultProtocolClient", (protocol, path, args) => {
         const success = app.removeAsDefaultProtocolClient(protocol, path, args);
-        electronSocket.emit('appRemoveAsDefaultProtocolClientCompleted', success);
+        electronSocket.emit("appRemoveAsDefaultProtocolClientCompleted", success);
     });
-    socket.on('appIsDefaultProtocolClient', (protocol, path, args) => {
+    socket.on("appIsDefaultProtocolClient", (protocol, path, args) => {
         const success = app.isDefaultProtocolClient(protocol, path, args);
-        electronSocket.emit('appIsDefaultProtocolClientCompleted', success);
+        electronSocket.emit("appIsDefaultProtocolClientCompleted", success);
     });
-    socket.on('appSetUserTasks', (tasks) => {
+    socket.on("appSetUserTasks", (tasks) => {
         const success = app.setUserTasks(tasks);
-        electronSocket.emit('appSetUserTasksCompleted', success);
+        electronSocket.emit("appSetUserTasksCompleted", success);
     });
-    socket.on('appGetJumpListSettings', () => {
+    socket.on("appGetJumpListSettings", () => {
         const jumpListSettings = app.getJumpListSettings();
-        electronSocket.emit('appGetJumpListSettingsCompleted', jumpListSettings);
+        electronSocket.emit("appGetJumpListSettingsCompleted", jumpListSettings);
     });
-    socket.on('appSetJumpList', (categories) => {
+    socket.on("appSetJumpList", (categories) => {
         app.setJumpList(categories);
     });
-    socket.on('appRequestSingleInstanceLock', () => {
+    socket.on("appRequestSingleInstanceLock", () => {
         const success = app.requestSingleInstanceLock();
-        electronSocket.emit('appRequestSingleInstanceLockCompleted', success);
-        app.on('second-instance', (event, args = [], workingDirectory = '') => {
-            electronSocket.emit('secondInstance', [args, workingDirectory]);
+        electronSocket.emit("appRequestSingleInstanceLockCompleted", success);
+        app.on("second-instance", (event, args = [], workingDirectory = "") => {
+            electronSocket.emit("secondInstance", [args, workingDirectory]);
         });
     });
-    socket.on('appHasSingleInstanceLock', () => {
+    socket.on("appHasSingleInstanceLock", () => {
         const hasLock = app.hasSingleInstanceLock();
-        electronSocket.emit('appHasSingleInstanceLockCompleted', hasLock);
+        electronSocket.emit("appHasSingleInstanceLockCompleted", hasLock);
     });
-    socket.on('appReleaseSingleInstanceLock', () => {
+    socket.on("appReleaseSingleInstanceLock", () => {
         app.releaseSingleInstanceLock();
     });
-    socket.on('appSetUserActivity', (type, userInfo, webpageUrl) => {
+    socket.on("appSetUserActivity", (type, userInfo, webpageUrl) => {
         app.setUserActivity(type, userInfo, webpageUrl);
     });
-    socket.on('appGetCurrentActivityType', () => {
+    socket.on("appGetCurrentActivityType", () => {
         const activityType = app.getCurrentActivityType();
-        electronSocket.emit('appGetCurrentActivityTypeCompleted', activityType);
+        electronSocket.emit("appGetCurrentActivityTypeCompleted", activityType);
     });
-    socket.on('appInvalidateCurrentActivity', () => {
+    socket.on("appInvalidateCurrentActivity", () => {
         app.invalidateCurrentActivity();
     });
-    socket.on('appResignCurrentActivity', () => {
+    socket.on("appResignCurrentActivity", () => {
         app.resignCurrentActivity();
     });
-    socket.on('appSetAppUserModelId', (id) => {
+    socket.on("appSetAppUserModelId", (id) => {
         app.setAppUserModelId(id);
     });
-    socket.on('appImportCertificate', (options) => {
+    socket.on("appImportCertificate", (options) => {
         app.importCertificate(options, (result) => {
-            electronSocket.emit('appImportCertificateCompleted', result);
+            electronSocket.emit("appImportCertificateCompleted", result);
         });
     });
-    socket.on('appGetAppMetrics', () => {
+    socket.on("appGetAppMetrics", () => {
         const processMetrics = app.getAppMetrics();
-        electronSocket.emit('appGetAppMetricsCompleted', processMetrics);
+        electronSocket.emit("appGetAppMetricsCompleted", processMetrics);
     });
-    socket.on('appGetGpuFeatureStatus', () => {
+    socket.on("appGetGpuFeatureStatus", () => {
         const gpuFeatureStatus = app.getGPUFeatureStatus();
-        electronSocket.emit('appGetGpuFeatureStatusCompleted', gpuFeatureStatus);
+        electronSocket.emit("appGetGpuFeatureStatusCompleted", gpuFeatureStatus);
     });
-    socket.on('appSetBadgeCount', (count) => {
+    socket.on("appSetBadgeCount", (count) => {
         const success = app.setBadgeCount(count);
-        electronSocket.emit('appSetBadgeCountCompleted', success);
+        electronSocket.emit("appSetBadgeCountCompleted", success);
     });
-    socket.on('appGetBadgeCount', () => {
+    socket.on("appGetBadgeCount", () => {
         const count = app.getBadgeCount();
-        electronSocket.emit('appGetBadgeCountCompleted', count);
+        electronSocket.emit("appGetBadgeCountCompleted", count);
     });
-    socket.on('appIsUnityRunning', () => {
+    socket.on("appIsUnityRunning", () => {
         const isUnityRunning = app.isUnityRunning();
-        electronSocket.emit('appIsUnityRunningCompleted', isUnityRunning);
+        electronSocket.emit("appIsUnityRunningCompleted", isUnityRunning);
     });
-    socket.on('appGetLoginItemSettings', (options) => {
+    socket.on("appGetLoginItemSettings", (options) => {
         const loginItemSettings = app.getLoginItemSettings(options);
-        electronSocket.emit('appGetLoginItemSettingsCompleted', loginItemSettings);
+        electronSocket.emit("appGetLoginItemSettingsCompleted", loginItemSettings);
     });
-    socket.on('appSetLoginItemSettings', (settings) => {
+    socket.on("appSetLoginItemSettings", (settings) => {
         app.setLoginItemSettings(settings);
     });
-    socket.on('appIsAccessibilitySupportEnabled', () => {
+    socket.on("appIsAccessibilitySupportEnabled", () => {
         const isAccessibilitySupportEnabled = app.isAccessibilitySupportEnabled();
-        electronSocket.emit('appIsAccessibilitySupportEnabledCompleted', isAccessibilitySupportEnabled);
+        electronSocket.emit("appIsAccessibilitySupportEnabledCompleted", isAccessibilitySupportEnabled);
     });
-    socket.on('appSetAccessibilitySupportEnabled', (enabled) => {
+    socket.on("appSetAccessibilitySupportEnabled", (enabled) => {
         app.setAccessibilitySupportEnabled(enabled);
     });
-    socket.on('appShowAboutPanel', () => {
+    socket.on("appShowAboutPanel", () => {
         app.showAboutPanel();
     });
-    socket.on('appSetAboutPanelOptions', (options) => {
+    socket.on("appSetAboutPanelOptions", (options) => {
         app.setAboutPanelOptions(options);
     });
-    socket.on('appGetUserAgentFallback', () => {
-        electronSocket.emit('appGetUserAgentFallbackCompleted', app.userAgentFallback);
+    socket.on("appGetUserAgentFallback", () => {
+        electronSocket.emit("appGetUserAgentFallbackCompleted", app.userAgentFallback);
     });
-    socket.on('appSetUserAgentFallback', (userAgent) => {
+    socket.on("appSetUserAgentFallback", (userAgent) => {
         app.userAgentFallback = userAgent;
     });
-    socket.on('register-app-on-event', (eventName, listenerName) => {
+    socket.on("register-app-on-event", (eventName, listenerName) => {
         app.on(eventName, (...args) => {
             if (args.length > 1) {
                 electronSocket.emit(listenerName, args[1]);
@@ -238,7 +243,7 @@ module.exports = (socket, app) => {
             }
         });
     });
-    socket.on('register-app-once-event', (eventName, listenerName) => {
+    socket.on("register-app-once-event", (eventName, listenerName) => {
         app.once(eventName, (...args) => {
             if (args.length > 1) {
                 electronSocket.emit(listenerName, args[1]);

src/ElectronNET.Host/api/app.ts

@@ -1,313 +1,338 @@
-import { RelaunchOptions, LoginItemSettingsOptions, Settings, AboutPanelOptionsOptions } from "electron";
-import { Socket } from "net";
+import type { Socket } from "net";
+import {
+  RelaunchOptions,
+  LoginItemSettingsOptions,
+  Settings,
+  AboutPanelOptionsOptions,
+} from "electron";
+
+let isQuitWindowAllClosed = true;
+let electronSocket: Socket;
+let appWindowAllClosedEventId: string;
 
-let isQuitWindowAllClosed = true, electronSocket;
-let appWindowAllClosedEventId;
 export = (socket: Socket, app: Electron.App) => {
-    electronSocket = socket;
+  electronSocket = socket;
 
-    // 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) {
-            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);
-        }
+  // 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) {
+      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", (quit) => {
+    isQuitWindowAllClosed = quit;
+  });
+
+  socket.on("register-app-window-all-closed", (id) => {
+    appWindowAllClosedEventId = id;
+  });
+
+  socket.on("register-app-before-quit", (id) => {
+    app.on("before-quit", (event) => {
+      event.preventDefault();
+
+      electronSocket.emit("app-before-quit" + id);
     });
+  });
 
-    socket.on('quit-app-window-all-closed', (quit) => {
-        isQuitWindowAllClosed = quit;
+  socket.on("register-app-will-quit", (id) => {
+    app.on("will-quit", (event) => {
+      event.preventDefault();
+
+      electronSocket.emit("app-will-quit" + id);
     });
+  });
 
-    socket.on('register-app-window-all-closed', (id) => {
-        appWindowAllClosedEventId = id;
+  socket.on("register-app-browser-window-blur", (id) => {
+    app.on("browser-window-blur", () => {
+      electronSocket.emit("app-browser-window-blur" + id);
     });
+  });
 
-    socket.on('register-app-before-quit', (id) => {
-        app.on('before-quit', (event) => {
-            event.preventDefault();
-
-            electronSocket.emit('app-before-quit' + id);
-        });
+  socket.on("register-app-browser-window-focus", (id) => {
+    app.on("browser-window-focus", () => {
+      electronSocket.emit("app-browser-window-focus" + id);
     });
+  });
 
-    socket.on('register-app-will-quit', (id) => {
-        app.on('will-quit', (event) => {
-            event.preventDefault();
-
-            electronSocket.emit('app-will-quit' + id);
-        });
+  socket.on("register-app-browser-window-created", (id) => {
+    app.on("browser-window-created", () => {
+      electronSocket.emit("app-browser-window-created" + id);
     });
+  });
 
-    socket.on('register-app-browser-window-blur', (id) => {
-        app.on('browser-window-blur', () => {
-            electronSocket.emit('app-browser-window-blur' + id);
-        });
+  socket.on("register-app-web-contents-created", (id) => {
+    app.on("web-contents-created", () => {
+      electronSocket.emit("app-web-contents-created" + id);
     });
+  });
 
-    socket.on('register-app-browser-window-focus', (id) => {
-        app.on('browser-window-focus', () => {
-            electronSocket.emit('app-browser-window-focus' + id);
-        });
+  socket.on("register-app-accessibility-support-changed", (id) => {
+    app.on(
+      "accessibility-support-changed",
+      (event, accessibilitySupportEnabled) => {
+        electronSocket.emit(
+          "app-accessibility-support-changed" + id,
+          accessibilitySupportEnabled,
+        );
+      },
+    );
+  });
+
+  socket.on("appQuit", () => {
+    app.quit();
+  });
+
+  socket.on("appExit", (exitCode = 0) => {
+    app.exit(exitCode);
+  });
+
+  socket.on("appRelaunch", (options) => {
+    app.relaunch(options as RelaunchOptions);
+  });
+
+  socket.on("appFocus", (options) => {
+    app.focus(options);
+  });
+
+  socket.on("appHide", () => {
+    app.hide();
+  });
+
+  socket.on("appShow", () => {
+    app.show();
+  });
+
+  socket.on("appGetAppPath", () => {
+    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);
+  });
+
+  socket.on("appGetFileIcon", async (path, options) => {
+    let error = {};
+
+    if (options) {
+      const nativeImage = await app
+        .getFileIcon(path, options)
+        .catch((errorFileIcon) => (error = errorFileIcon));
+
+      electronSocket.emit("appGetFileIconCompleted", [error, nativeImage]);
+    } else {
+      const nativeImage = await app
+        .getFileIcon(path)
+        .catch((errorFileIcon) => (error = errorFileIcon));
+
+      electronSocket.emit("appGetFileIconCompleted", [error, nativeImage]);
+    }
+  });
+
+  socket.on("appSetPath", (name, path) => {
+    app.setPath(name, path);
+  });
+
+  socket.on("appGetVersion", () => {
+    const version = app.getVersion();
+    electronSocket.emit("appGetVersionCompleted", version);
+  });
+
+  socket.on("appGetName", () => {
+    electronSocket.emit("appGetNameCompleted", app.name);
+  });
+
+  socket.on("appSetName", (name) => {
+    app.name = name;
+  });
+
+  socket.on("appGetLocale", () => {
+    const locale = app.getLocale();
+    electronSocket.emit("appGetLocaleCompleted", locale);
+  });
+
+  socket.on("appAddRecentDocument", (path) => {
+    app.addRecentDocument(path);
+  });
+
+  socket.on("appClearRecentDocuments", () => {
+    app.clearRecentDocuments();
+  });
+
+  socket.on("appSetAsDefaultProtocolClient", (protocol, path, args) => {
+    const success = app.setAsDefaultProtocolClient(protocol, path, args);
+    electronSocket.emit("appSetAsDefaultProtocolClientCompleted", success);
+  });
+
+  socket.on("appRemoveAsDefaultProtocolClient", (protocol, path, args) => {
+    const success = app.removeAsDefaultProtocolClient(protocol, path, args);
+    electronSocket.emit("appRemoveAsDefaultProtocolClientCompleted", success);
+  });
+
+  socket.on("appIsDefaultProtocolClient", (protocol, path, args) => {
+    const success = app.isDefaultProtocolClient(protocol, path, args);
+    electronSocket.emit("appIsDefaultProtocolClientCompleted", success);
+  });
+
+  socket.on("appSetUserTasks", (tasks) => {
+    const success = app.setUserTasks(tasks);
+    electronSocket.emit("appSetUserTasksCompleted", success);
+  });
+
+  socket.on("appGetJumpListSettings", () => {
+    const jumpListSettings = app.getJumpListSettings();
+    electronSocket.emit("appGetJumpListSettingsCompleted", jumpListSettings);
+  });
+
+  socket.on("appSetJumpList", (categories) => {
+    app.setJumpList(categories);
+  });
+
+  socket.on("appRequestSingleInstanceLock", () => {
+    const success = app.requestSingleInstanceLock();
+    electronSocket.emit("appRequestSingleInstanceLockCompleted", success);
+
+    app.on("second-instance", (event, args = [], workingDirectory = "") => {
+      electronSocket.emit("secondInstance", [args, workingDirectory]);
     });
+  });
 
-    socket.on('register-app-browser-window-created', (id) => {
-        app.on('browser-window-created', () => {
-            electronSocket.emit('app-browser-window-created' + id);
-        });
+  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("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);
+  });
+
+  socket.on("appImportCertificate", (options) => {
+    app.importCertificate(options, (result) => {
+      electronSocket.emit("appImportCertificateCompleted", result);
     });
+  });
 
-    socket.on('register-app-web-contents-created', (id) => {
-        app.on('web-contents-created', () => {
-            electronSocket.emit('app-web-contents-created' + id);
-        });
+  socket.on("appGetAppMetrics", () => {
+    const processMetrics = app.getAppMetrics();
+    electronSocket.emit("appGetAppMetricsCompleted", processMetrics);
+  });
+
+  socket.on("appGetGpuFeatureStatus", () => {
+    const gpuFeatureStatus = app.getGPUFeatureStatus();
+    electronSocket.emit("appGetGpuFeatureStatusCompleted", gpuFeatureStatus);
+  });
+
+  socket.on("appSetBadgeCount", (count) => {
+    const success = app.setBadgeCount(count);
+    electronSocket.emit("appSetBadgeCountCompleted", success);
+  });
+
+  socket.on("appGetBadgeCount", () => {
+    const count = app.getBadgeCount();
+    electronSocket.emit("appGetBadgeCountCompleted", count);
+  });
+
+  socket.on("appIsUnityRunning", () => {
+    const isUnityRunning = app.isUnityRunning();
+    electronSocket.emit("appIsUnityRunningCompleted", isUnityRunning);
+  });
+
+  socket.on("appGetLoginItemSettings", (options) => {
+    const loginItemSettings = app.getLoginItemSettings(
+      options as LoginItemSettingsOptions,
+    );
+    electronSocket.emit("appGetLoginItemSettingsCompleted", loginItemSettings);
+  });
+
+  socket.on("appSetLoginItemSettings", (settings) => {
+    app.setLoginItemSettings(settings as Settings);
+  });
+
+  socket.on("appIsAccessibilitySupportEnabled", () => {
+    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 as AboutPanelOptionsOptions);
+  });
+
+  socket.on("appGetUserAgentFallback", () => {
+    electronSocket.emit(
+      "appGetUserAgentFallbackCompleted",
+      app.userAgentFallback,
+    );
+  });
+
+  socket.on("appSetUserAgentFallback", (userAgent) => {
+    app.userAgentFallback = userAgent;
+  });
+
+  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('register-app-accessibility-support-changed', (id) => {
-        app.on('accessibility-support-changed', (event, accessibilitySupportEnabled) => {
-            electronSocket.emit('app-accessibility-support-changed' + id, accessibilitySupportEnabled);
-        });
-    });
-
-    socket.on('appQuit', () => {
-        app.quit();
-    });
-
-    socket.on('appExit', (exitCode = 0) => {
-        app.exit(exitCode);
-    });
-
-    socket.on('appRelaunch', (options) => {
-        app.relaunch(options as RelaunchOptions);
-    });
-
-    socket.on('appFocus', (options) => {
-        app.focus(options);
-    });
-
-    socket.on('appHide', () => {
-        app.hide();
-    });
-
-    socket.on('appShow', () => {
-        app.show();
-    });
-
-    socket.on('appGetAppPath', () => {
-        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);
-    });
-
-    socket.on('appGetFileIcon', async (path, options) => {
-        let error = {};
-
-        if (options) {
-            const nativeImage = await app.getFileIcon(path, options).catch((errorFileIcon) =>  error = errorFileIcon);
-
-            electronSocket.emit('appGetFileIconCompleted', [error, nativeImage]);
-        } else {
-            const nativeImage = await app.getFileIcon(path).catch((errorFileIcon) =>  error = errorFileIcon);
-
-            electronSocket.emit('appGetFileIconCompleted', [error, nativeImage]);
-        }
-    });
-
-    socket.on('appSetPath', (name, path) => {
-        app.setPath(name, path);
-    });
-
-    socket.on('appGetVersion', () => {
-        const version = app.getVersion();
-        electronSocket.emit('appGetVersionCompleted', version);
-    });
-
-    socket.on('appGetName', () => {
-        electronSocket.emit('appGetNameCompleted', app.name);
-    });
-
-    socket.on('appSetName', (name) => {
-        app.name = name;
-    });
-
-    socket.on('appGetLocale', () => {
-        const locale = app.getLocale();
-        electronSocket.emit('appGetLocaleCompleted', locale);
-    });
-
-    socket.on('appAddRecentDocument', (path) => {
-        app.addRecentDocument(path);
-    });
-
-    socket.on('appClearRecentDocuments', () => {
-        app.clearRecentDocuments();
-    });
-
-    socket.on('appSetAsDefaultProtocolClient', (protocol, path, args) => {
-        const success = app.setAsDefaultProtocolClient(protocol, path, args);
-        electronSocket.emit('appSetAsDefaultProtocolClientCompleted', success);
-    });
-
-    socket.on('appRemoveAsDefaultProtocolClient', (protocol, path, args) => {
-        const success = app.removeAsDefaultProtocolClient(protocol, path, args);
-        electronSocket.emit('appRemoveAsDefaultProtocolClientCompleted', success);
-    });
-
-    socket.on('appIsDefaultProtocolClient', (protocol, path, args) => {
-        const success = app.isDefaultProtocolClient(protocol, path, args);
-        electronSocket.emit('appIsDefaultProtocolClientCompleted', success);
-    });
-
-    socket.on('appSetUserTasks', (tasks) => {
-        const success = app.setUserTasks(tasks);
-        electronSocket.emit('appSetUserTasksCompleted', success);
-    });
-
-    socket.on('appGetJumpListSettings', () => {
-        const jumpListSettings = app.getJumpListSettings();
-        electronSocket.emit('appGetJumpListSettingsCompleted', jumpListSettings);
-    });
-
-    socket.on('appSetJumpList', (categories) => {
-        app.setJumpList(categories);
-    });
-
-    socket.on('appRequestSingleInstanceLock', () => {
-        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('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);
-    });
-
-    socket.on('appImportCertificate', (options) => {
-        app.importCertificate(options, (result) => {
-            electronSocket.emit('appImportCertificateCompleted', result);
-        });
-    });
-
-    socket.on('appGetAppMetrics', () => {
-        const processMetrics = app.getAppMetrics();
-        electronSocket.emit('appGetAppMetricsCompleted', processMetrics);
-    });
-
-    socket.on('appGetGpuFeatureStatus', () => {
-        const gpuFeatureStatus = app.getGPUFeatureStatus();
-        electronSocket.emit('appGetGpuFeatureStatusCompleted', gpuFeatureStatus);
-    });
-
-    socket.on('appSetBadgeCount', (count) => {
-        const success = app.setBadgeCount(count);
-        electronSocket.emit('appSetBadgeCountCompleted', success);
-    });
-
-    socket.on('appGetBadgeCount', () => {
-        const count = app.getBadgeCount();
-        electronSocket.emit('appGetBadgeCountCompleted', count);
-    });
-
-    socket.on('appIsUnityRunning', () => {
-        const isUnityRunning = app.isUnityRunning();
-        electronSocket.emit('appIsUnityRunningCompleted', isUnityRunning);
-    });
-
-    socket.on('appGetLoginItemSettings', (options) => {
-        const loginItemSettings = app.getLoginItemSettings(options as LoginItemSettingsOptions);
-        electronSocket.emit('appGetLoginItemSettingsCompleted', loginItemSettings);
-    });
-
-    socket.on('appSetLoginItemSettings', (settings) => {
-        app.setLoginItemSettings(settings as Settings);
-    });
-
-    socket.on('appIsAccessibilitySupportEnabled', () => {
-        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 as AboutPanelOptionsOptions);
-    });
-
-    socket.on('appGetUserAgentFallback', () => {
-        electronSocket.emit('appGetUserAgentFallbackCompleted', app.userAgentFallback);
-    });
-
-    socket.on('appSetUserAgentFallback', (userAgent) => {
-        app.userAgentFallback = userAgent;
-    });
-
-    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('register-app-once-event', (eventName, listenerName) => {
-        app.once(eventName, (...args) => {
-            if (args.length > 1) {
-                electronSocket.emit(listenerName, args[1]);
-            } else {
-                electronSocket.emit(listenerName);
-            }
-        });
+  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);
+      }
     });
+  });
 };

src/ElectronNET.Host/api/autoUpdater.js

@@ -3,112 +3,118 @@ const electron_updater_1 = require("electron-updater");
 let electronSocket;
 module.exports = (socket) => {
     electronSocket = socket;
-    socket.on('register-autoUpdater-error', (id) => {
-        electron_updater_1.autoUpdater.on('error', (error) => {
-            electronSocket.emit('autoUpdater-error' + id, error.message);
+    socket.on("register-autoUpdater-error", (id) => {
+        electron_updater_1.autoUpdater.on("error", (error) => {
+            electronSocket.emit("autoUpdater-error" + id, error.message);
         });
     });
-    socket.on('register-autoUpdater-checking-for-update', (id) => {
-        electron_updater_1.autoUpdater.on('checking-for-update', () => {
-            electronSocket.emit('autoUpdater-checking-for-update' + id);
+    socket.on("register-autoUpdater-checking-for-update", (id) => {
+        electron_updater_1.autoUpdater.on("checking-for-update", () => {
+            electronSocket.emit("autoUpdater-checking-for-update" + id);
         });
     });
-    socket.on('register-autoUpdater-update-available', (id) => {
-        electron_updater_1.autoUpdater.on('update-available', (updateInfo) => {
-            electronSocket.emit('autoUpdater-update-available' + id, updateInfo);
+    socket.on("register-autoUpdater-update-available", (id) => {
+        electron_updater_1.autoUpdater.on("update-available", (updateInfo) => {
+            electronSocket.emit("autoUpdater-update-available" + id, updateInfo);
         });
     });
-    socket.on('register-autoUpdater-update-not-available', (id) => {
-        electron_updater_1.autoUpdater.on('update-not-available', (updateInfo) => {
-            electronSocket.emit('autoUpdater-update-not-available' + id, updateInfo);
+    socket.on("register-autoUpdater-update-not-available", (id) => {
+        electron_updater_1.autoUpdater.on("update-not-available", (updateInfo) => {
+            electronSocket.emit("autoUpdater-update-not-available" + id, updateInfo);
         });
     });
-    socket.on('register-autoUpdater-download-progress', (id) => {
-        electron_updater_1.autoUpdater.on('download-progress', (progressInfo) => {
-            electronSocket.emit('autoUpdater-download-progress' + id, progressInfo);
+    socket.on("register-autoUpdater-download-progress", (id) => {
+        electron_updater_1.autoUpdater.on("download-progress", (progressInfo) => {
+            electronSocket.emit("autoUpdater-download-progress" + id, progressInfo);
         });
     });
-    socket.on('register-autoUpdater-update-downloaded', (id) => {
-        electron_updater_1.autoUpdater.on('update-downloaded', (updateInfo) => {
-            electronSocket.emit('autoUpdater-update-downloaded' + id, updateInfo);
+    socket.on("register-autoUpdater-update-downloaded", (id) => {
+        electron_updater_1.autoUpdater.on("update-downloaded", (updateInfo) => {
+            electronSocket.emit("autoUpdater-update-downloaded" + id, updateInfo);
         });
     });
     // Properties *****
-    socket.on('autoUpdater-autoDownload', () => {
-        electronSocket.emit('autoUpdater-autoDownload-completed', electron_updater_1.autoUpdater.autoDownload);
+    socket.on("autoUpdater-autoDownload", () => {
+        electronSocket.emit("autoUpdater-autoDownload-completed", electron_updater_1.autoUpdater.autoDownload);
     });
-    socket.on('autoUpdater-autoDownload-set', (value) => {
+    socket.on("autoUpdater-autoDownload-set", (value) => {
         electron_updater_1.autoUpdater.autoDownload = value;
     });
-    socket.on('autoUpdater-autoInstallOnAppQuit', () => {
-        electronSocket.emit('autoUpdater-autoInstallOnAppQuit-completed', electron_updater_1.autoUpdater.autoInstallOnAppQuit);
+    socket.on("autoUpdater-autoInstallOnAppQuit", () => {
+        electronSocket.emit("autoUpdater-autoInstallOnAppQuit-completed", electron_updater_1.autoUpdater.autoInstallOnAppQuit);
     });
-    socket.on('autoUpdater-autoInstallOnAppQuit-set', (value) => {
+    socket.on("autoUpdater-autoInstallOnAppQuit-set", (value) => {
         electron_updater_1.autoUpdater.autoInstallOnAppQuit = value;
     });
-    socket.on('autoUpdater-allowPrerelease', () => {
-        electronSocket.emit('autoUpdater-allowPrerelease-completed', electron_updater_1.autoUpdater.allowPrerelease);
+    socket.on("autoUpdater-allowPrerelease", () => {
+        electronSocket.emit("autoUpdater-allowPrerelease-completed", electron_updater_1.autoUpdater.allowPrerelease);
     });
-    socket.on('autoUpdater-allowPrerelease-set', (value) => {
+    socket.on("autoUpdater-allowPrerelease-set", (value) => {
         electron_updater_1.autoUpdater.allowPrerelease = value;
     });
-    socket.on('autoUpdater-fullChangelog', () => {
-        electronSocket.emit('autoUpdater-fullChangelog-completed', electron_updater_1.autoUpdater.fullChangelog);
+    socket.on("autoUpdater-fullChangelog", () => {
+        electronSocket.emit("autoUpdater-fullChangelog-completed", electron_updater_1.autoUpdater.fullChangelog);
     });
-    socket.on('autoUpdater-fullChangelog-set', (value) => {
+    socket.on("autoUpdater-fullChangelog-set", (value) => {
         electron_updater_1.autoUpdater.fullChangelog = value;
     });
-    socket.on('autoUpdater-allowDowngrade', () => {
-        electronSocket.emit('autoUpdater-allowDowngrade-completed', electron_updater_1.autoUpdater.allowDowngrade);
+    socket.on("autoUpdater-allowDowngrade", () => {
+        electronSocket.emit("autoUpdater-allowDowngrade-completed", electron_updater_1.autoUpdater.allowDowngrade);
     });
-    socket.on('autoUpdater-allowDowngrade-set', (value) => {
+    socket.on("autoUpdater-allowDowngrade-set", (value) => {
         electron_updater_1.autoUpdater.allowDowngrade = value;
     });
-    socket.on('autoUpdater-updateConfigPath', () => {
-        electronSocket.emit('autoUpdater-updateConfigPath-completed', electron_updater_1.autoUpdater.updateConfigPath || '');
+    socket.on("autoUpdater-updateConfigPath", () => {
+        electronSocket.emit("autoUpdater-updateConfigPath-completed", electron_updater_1.autoUpdater.updateConfigPath || "");
     });
-    socket.on('autoUpdater-updateConfigPath-set', (value) => {
+    socket.on("autoUpdater-updateConfigPath-set", (value) => {
         electron_updater_1.autoUpdater.updateConfigPath = value;
     });
-    socket.on('autoUpdater-currentVersion', () => {
-        electronSocket.emit('autoUpdater-currentVersion-completed', electron_updater_1.autoUpdater.currentVersion);
+    socket.on("autoUpdater-currentVersion", () => {
+        electronSocket.emit("autoUpdater-currentVersion-completed", electron_updater_1.autoUpdater.currentVersion);
     });
-    socket.on('autoUpdater-channel', () => {
-        electronSocket.emit('autoUpdater-channel-completed', electron_updater_1.autoUpdater.channel || '');
+    socket.on("autoUpdater-channel", () => {
+        electronSocket.emit("autoUpdater-channel-completed", electron_updater_1.autoUpdater.channel || "");
     });
-    socket.on('autoUpdater-channel-set', (value) => {
+    socket.on("autoUpdater-channel-set", (value) => {
         electron_updater_1.autoUpdater.channel = value;
     });
-    socket.on('autoUpdater-requestHeaders', () => {
-        electronSocket.emit('autoUpdater-requestHeaders-completed', electron_updater_1.autoUpdater.requestHeaders);
+    socket.on("autoUpdater-requestHeaders", () => {
+        electronSocket.emit("autoUpdater-requestHeaders-completed", electron_updater_1.autoUpdater.requestHeaders);
     });
-    socket.on('autoUpdater-requestHeaders-set', (value) => {
+    socket.on("autoUpdater-requestHeaders-set", (value) => {
         electron_updater_1.autoUpdater.requestHeaders = value;
     });
-    socket.on('autoUpdater-checkForUpdatesAndNotify', async (guid) => {
-        electron_updater_1.autoUpdater.checkForUpdatesAndNotify().then((updateCheckResult) => {
-            electronSocket.emit('autoUpdater-checkForUpdatesAndNotify-completed' + guid, updateCheckResult);
-        }).catch((error) => {
-            electronSocket.emit('autoUpdater-checkForUpdatesAndNotifyError' + guid, error);
+    socket.on("autoUpdater-checkForUpdatesAndNotify", async (guid) => {
+        electron_updater_1.autoUpdater
+            .checkForUpdatesAndNotify()
+            .then((updateCheckResult) => {
+            electronSocket.emit("autoUpdater-checkForUpdatesAndNotify-completed" + guid, updateCheckResult);
+        })
+            .catch((error) => {
+            electronSocket.emit("autoUpdater-checkForUpdatesAndNotifyError" + guid, error);
         });
     });
-    socket.on('autoUpdater-checkForUpdates', async (guid) => {
-        electron_updater_1.autoUpdater.checkForUpdates().then((updateCheckResult) => {
-            electronSocket.emit('autoUpdater-checkForUpdates-completed' + guid, updateCheckResult);
-        }).catch((error) => {
-            electronSocket.emit('autoUpdater-checkForUpdatesError' + guid, error);
+    socket.on("autoUpdater-checkForUpdates", async (guid) => {
+        electron_updater_1.autoUpdater
+            .checkForUpdates()
+            .then((updateCheckResult) => {
+            electronSocket.emit("autoUpdater-checkForUpdates-completed" + guid, updateCheckResult);
+        })
+            .catch((error) => {
+            electronSocket.emit("autoUpdater-checkForUpdatesError" + guid, error);
         });
     });
-    socket.on('autoUpdater-quitAndInstall', async (isSilent, isForceRunAfter) => {
+    socket.on("autoUpdater-quitAndInstall", async (isSilent, isForceRunAfter) => {
         electron_updater_1.autoUpdater.quitAndInstall(isSilent, isForceRunAfter);
     });
-    socket.on('autoUpdater-downloadUpdate', async (guid) => {
+    socket.on("autoUpdater-downloadUpdate", async (guid) => {
         const downloadedPath = await electron_updater_1.autoUpdater.downloadUpdate();
-        electronSocket.emit('autoUpdater-downloadUpdate-completed' + guid, downloadedPath);
+        electronSocket.emit("autoUpdater-downloadUpdate-completed" + guid, downloadedPath);
     });
-    socket.on('autoUpdater-getFeedURL', async (guid) => {
+    socket.on("autoUpdater-getFeedURL", async (guid) => {
         const feedUrl = await electron_updater_1.autoUpdater.getFeedURL();
-        electronSocket.emit('autoUpdater-getFeedURL-completed' + guid, feedUrl || '');
+        electronSocket.emit("autoUpdater-getFeedURL-completed" + guid, feedUrl || "");
     });
 };
 //# sourceMappingURL=autoUpdater.js.map

src/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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"}

src/ElectronNET.Host/api/autoUpdater.ts

@@ -1,143 +1,192 @@
-import { Socket } from 'net';
-import { autoUpdater } from 'electron-updater';
-let electronSocket;
+import type { Socket } from "net";
+import { autoUpdater } from "electron-updater";
+
+let electronSocket: Socket;
 
 export = (socket: Socket) => {
-    electronSocket = socket;
+  electronSocket = socket;
 
-    socket.on('register-autoUpdater-error', (id) => {
-        autoUpdater.on('error', (error) => {
-            electronSocket.emit('autoUpdater-error' + id, error.message);
-        });
+  socket.on("register-autoUpdater-error", (id) => {
+    autoUpdater.on("error", (error) => {
+      electronSocket.emit("autoUpdater-error" + id, error.message);
     });
+  });
 
-    socket.on('register-autoUpdater-checking-for-update', (id) => {
-        autoUpdater.on('checking-for-update', () => {
-            electronSocket.emit('autoUpdater-checking-for-update' + id);
-        });
+  socket.on("register-autoUpdater-checking-for-update", (id) => {
+    autoUpdater.on("checking-for-update", () => {
+      electronSocket.emit("autoUpdater-checking-for-update" + id);
     });
+  });
 
-    socket.on('register-autoUpdater-update-available', (id) => {
-        autoUpdater.on('update-available', (updateInfo) => {
-            electronSocket.emit('autoUpdater-update-available' + id, updateInfo);
-        });
+  socket.on("register-autoUpdater-update-available", (id) => {
+    autoUpdater.on("update-available", (updateInfo) => {
+      electronSocket.emit("autoUpdater-update-available" + id, updateInfo);
     });
+  });
 
-    socket.on('register-autoUpdater-update-not-available', (id) => {
-        autoUpdater.on('update-not-available', (updateInfo) => {
-            electronSocket.emit('autoUpdater-update-not-available' + id, updateInfo);
-        });
+  socket.on("register-autoUpdater-update-not-available", (id) => {
+    autoUpdater.on("update-not-available", (updateInfo) => {
+      electronSocket.emit("autoUpdater-update-not-available" + id, updateInfo);
     });
+  });
 
-    socket.on('register-autoUpdater-download-progress', (id) => {
-        autoUpdater.on('download-progress', (progressInfo) => {
-            electronSocket.emit('autoUpdater-download-progress' + id, progressInfo);
-        });
+  socket.on("register-autoUpdater-download-progress", (id) => {
+    autoUpdater.on("download-progress", (progressInfo) => {
+      electronSocket.emit("autoUpdater-download-progress" + id, progressInfo);
     });
+  });
 
-    socket.on('register-autoUpdater-update-downloaded', (id) => {
-        autoUpdater.on('update-downloaded', (updateInfo) => {
-            electronSocket.emit('autoUpdater-update-downloaded' + id, updateInfo);
-        });
+  socket.on("register-autoUpdater-update-downloaded", (id) => {
+    autoUpdater.on("update-downloaded", (updateInfo) => {
+      electronSocket.emit("autoUpdater-update-downloaded" + id, updateInfo);
     });
+  });
 
-    // Properties *****
+  // Properties *****
 
-    socket.on('autoUpdater-autoDownload', () => {
-        electronSocket.emit('autoUpdater-autoDownload-completed', autoUpdater.autoDownload);
-    });
+  socket.on("autoUpdater-autoDownload", () => {
+    electronSocket.emit(
+      "autoUpdater-autoDownload-completed",
+      autoUpdater.autoDownload,
+    );
+  });
 
-    socket.on('autoUpdater-autoDownload-set', (value) => {
-        autoUpdater.autoDownload = value;
-    });
+  socket.on("autoUpdater-autoDownload-set", (value) => {
+    autoUpdater.autoDownload = value;
+  });
 
-    socket.on('autoUpdater-autoInstallOnAppQuit', () => {
-        electronSocket.emit('autoUpdater-autoInstallOnAppQuit-completed', autoUpdater.autoInstallOnAppQuit);
-    });
+  socket.on("autoUpdater-autoInstallOnAppQuit", () => {
+    electronSocket.emit(
+      "autoUpdater-autoInstallOnAppQuit-completed",
+      autoUpdater.autoInstallOnAppQuit,
+    );
+  });
 
-    socket.on('autoUpdater-autoInstallOnAppQuit-set', (value) => {
-        autoUpdater.autoInstallOnAppQuit = value;
-    });
+  socket.on("autoUpdater-autoInstallOnAppQuit-set", (value) => {
+    autoUpdater.autoInstallOnAppQuit = value;
+  });
 
-    socket.on('autoUpdater-allowPrerelease', () => {
-        electronSocket.emit('autoUpdater-allowPrerelease-completed', autoUpdater.allowPrerelease);
-    });
+  socket.on("autoUpdater-allowPrerelease", () => {
+    electronSocket.emit(
+      "autoUpdater-allowPrerelease-completed",
+      autoUpdater.allowPrerelease,
+    );
+  });
 
-    socket.on('autoUpdater-allowPrerelease-set', (value) => {
-        autoUpdater.allowPrerelease = value;
-    });
+  socket.on("autoUpdater-allowPrerelease-set", (value) => {
+    autoUpdater.allowPrerelease = value;
+  });
 
-    socket.on('autoUpdater-fullChangelog', () => {
-        electronSocket.emit('autoUpdater-fullChangelog-completed', autoUpdater.fullChangelog);
-    });
+  socket.on("autoUpdater-fullChangelog", () => {
+    electronSocket.emit(
+      "autoUpdater-fullChangelog-completed",
+      autoUpdater.fullChangelog,
+    );
+  });
 
-    socket.on('autoUpdater-fullChangelog-set', (value) => {
-        autoUpdater.fullChangelog = value;
-    });
+  socket.on("autoUpdater-fullChangelog-set", (value) => {
+    autoUpdater.fullChangelog = value;
+  });
 
-    socket.on('autoUpdater-allowDowngrade', () => {
-        electronSocket.emit('autoUpdater-allowDowngrade-completed', autoUpdater.allowDowngrade);
-    });
+  socket.on("autoUpdater-allowDowngrade", () => {
+    electronSocket.emit(
+      "autoUpdater-allowDowngrade-completed",
+      autoUpdater.allowDowngrade,
+    );
+  });
 
-    socket.on('autoUpdater-allowDowngrade-set', (value) => {
-        autoUpdater.allowDowngrade = value;
-    });
+  socket.on("autoUpdater-allowDowngrade-set", (value) => {
+    autoUpdater.allowDowngrade = value;
+  });
 
-    socket.on('autoUpdater-updateConfigPath', () => {
-        electronSocket.emit('autoUpdater-updateConfigPath-completed', autoUpdater.updateConfigPath || '');
-    });
+  socket.on("autoUpdater-updateConfigPath", () => {
+    electronSocket.emit(
+      "autoUpdater-updateConfigPath-completed",
+      autoUpdater.updateConfigPath || "",
+    );
+  });
 
-    socket.on('autoUpdater-updateConfigPath-set', (value) => {
-        autoUpdater.updateConfigPath = value;
-    });
+  socket.on("autoUpdater-updateConfigPath-set", (value) => {
+    autoUpdater.updateConfigPath = value;
+  });
 
-    socket.on('autoUpdater-currentVersion', () => {
-        electronSocket.emit('autoUpdater-currentVersion-completed', autoUpdater.currentVersion);
-    });
+  socket.on("autoUpdater-currentVersion", () => {
+    electronSocket.emit(
+      "autoUpdater-currentVersion-completed",
+      autoUpdater.currentVersion,
+    );
+  });
 
-    socket.on('autoUpdater-channel', () => {
-        electronSocket.emit('autoUpdater-channel-completed', autoUpdater.channel || '');
-    });
+  socket.on("autoUpdater-channel", () => {
+    electronSocket.emit(
+      "autoUpdater-channel-completed",
+      autoUpdater.channel || "",
+    );
+  });
 
-    socket.on('autoUpdater-channel-set', (value) => {
-        autoUpdater.channel = value;
-    });
+  socket.on("autoUpdater-channel-set", (value) => {
+    autoUpdater.channel = value;
+  });
 
-    socket.on('autoUpdater-requestHeaders', () => {
-        electronSocket.emit('autoUpdater-requestHeaders-completed', autoUpdater.requestHeaders);
-    });
+  socket.on("autoUpdater-requestHeaders", () => {
+    electronSocket.emit(
+      "autoUpdater-requestHeaders-completed",
+      autoUpdater.requestHeaders,
+    );
+  });
 
-    socket.on('autoUpdater-requestHeaders-set', (value) => {
-        autoUpdater.requestHeaders = value;
-    });
+  socket.on("autoUpdater-requestHeaders-set", (value) => {
+    autoUpdater.requestHeaders = value;
+  });
 
-    socket.on('autoUpdater-checkForUpdatesAndNotify', async (guid) => {
-        autoUpdater.checkForUpdatesAndNotify().then((updateCheckResult) => {
-            electronSocket.emit('autoUpdater-checkForUpdatesAndNotify-completed' + guid, updateCheckResult);
-        }).catch((error) => {
-            electronSocket.emit('autoUpdater-checkForUpdatesAndNotifyError' + guid, error);
-        });
-    });
+  socket.on("autoUpdater-checkForUpdatesAndNotify", async (guid) => {
+    autoUpdater
+      .checkForUpdatesAndNotify()
+      .then((updateCheckResult) => {
+        electronSocket.emit(
+          "autoUpdater-checkForUpdatesAndNotify-completed" + guid,
+          updateCheckResult,
+        );
+      })
+      .catch((error) => {
+        electronSocket.emit(
+          "autoUpdater-checkForUpdatesAndNotifyError" + guid,
+          error,
+        );
+      });
+  });
 
-    socket.on('autoUpdater-checkForUpdates', async (guid) => {
-        autoUpdater.checkForUpdates().then((updateCheckResult) => {
-            electronSocket.emit('autoUpdater-checkForUpdates-completed' + guid, updateCheckResult);
-        }).catch((error) => {
-            electronSocket.emit('autoUpdater-checkForUpdatesError' + guid, error);
-        });
-    });
+  socket.on("autoUpdater-checkForUpdates", async (guid) => {
+    autoUpdater
+      .checkForUpdates()
+      .then((updateCheckResult) => {
+        electronSocket.emit(
+          "autoUpdater-checkForUpdates-completed" + guid,
+          updateCheckResult,
+        );
+      })
+      .catch((error) => {
+        electronSocket.emit("autoUpdater-checkForUpdatesError" + guid, error);
+      });
+  });
 
-    socket.on('autoUpdater-quitAndInstall', async (isSilent, isForceRunAfter) => {
-        autoUpdater.quitAndInstall(isSilent, isForceRunAfter);
-    });
+  socket.on("autoUpdater-quitAndInstall", async (isSilent, isForceRunAfter) => {
+    autoUpdater.quitAndInstall(isSilent, isForceRunAfter);
+  });
 
-    socket.on('autoUpdater-downloadUpdate', async (guid) => {
-        const downloadedPath = await autoUpdater.downloadUpdate();
-        electronSocket.emit('autoUpdater-downloadUpdate-completed' + guid, downloadedPath);
-    });
+  socket.on("autoUpdater-downloadUpdate", async (guid) => {
+    const downloadedPath = await autoUpdater.downloadUpdate();
+    electronSocket.emit(
+      "autoUpdater-downloadUpdate-completed" + guid,
+      downloadedPath,
+    );
+  });
 
-    socket.on('autoUpdater-getFeedURL', async (guid) => {
-        const feedUrl = await autoUpdater.getFeedURL();
-        electronSocket.emit('autoUpdater-getFeedURL-completed' + guid, feedUrl || '');
-    });
+  socket.on("autoUpdater-getFeedURL", async (guid) => {
+    const feedUrl = await autoUpdater.getFeedURL();
+    electronSocket.emit(
+      "autoUpdater-getFeedURL-completed" + guid,
+      feedUrl || "",
+    );
+  });
 };

src/ElectronNET.Host/api/browserView.js

@@ -2,17 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.browserViewMediateService = exports.browserViewApi = void 0;
 const electron_1 = require("electron");
-const browserViews = (global['browserViews'] = global['browserViews'] || []);
-let browserView, electronSocket;
-const proxyToCredentialsMap = (global['proxyToCredentialsMap'] = global['proxyToCredentialsMap'] || []);
+const browserViews = (global["browserViews"] =
+    global["browserViews"] || []);
+const proxyToCredentialsMap = (global["proxyToCredentialsMap"] = global["proxyToCredentialsMap"] || []);
+let browserView;
+let electronSocket;
 const browserViewApi = (socket) => {
     electronSocket = socket;
-    socket.on('createBrowserView', (options) => {
-        if (!hasOwnChildreen(options, 'webPreferences', 'nodeIntegration')) {
-            options = { ...options, webPreferences: { nodeIntegration: true, contextIsolation: false } };
+    socket.on("createBrowserView", (options) => {
+        if (!hasOwnChildreen(options, "webPreferences", "nodeIntegration")) {
+            options = {
+                ...options,
+                webPreferences: { nodeIntegration: true, contextIsolation: false },
+            };
         }
         browserView = new electron_1.BrowserView(options);
-        browserView['id'] = browserViews.length + 1;
+        browserView["id"] = browserViews.length + 1;
         if (options.proxy) {
             browserView.webContents.session.setProxy({ proxyRules: options.proxy });
         }
@@ -20,19 +25,19 @@ const browserViewApi = (socket) => {
             proxyToCredentialsMap[options.proxy] = options.proxyCredentials;
         }
         browserViews.push(browserView);
-        electronSocket.emit('BrowserViewCreated', browserView['id']);
+        electronSocket.emit("BrowserViewCreated", browserView["id"]);
     });
-    socket.on('browserView-bounds', (id) => {
+    socket.on("browserView-bounds", (id) => {
         const bounds = getBrowserViewById(id).getBounds();
-        electronSocket.emit('browserView-bounds-completed', bounds);
+        electronSocket.emit("browserView-bounds-completed", bounds);
     });
-    socket.on('browserView-bounds-set', (id, bounds) => {
+    socket.on("browserView-bounds-set", (id, bounds) => {
         getBrowserViewById(id).setBounds(bounds);
     });
-    socket.on('browserView-setAutoResize', (id, options) => {
+    socket.on("browserView-setAutoResize", (id, options) => {
         getBrowserViewById(id).setAutoResize(options);
     });
-    socket.on('browserView-setBackgroundColor', (id, color) => {
+    socket.on("browserView-setBackgroundColor", (id, color) => {
         getBrowserViewById(id).setBackgroundColor(color);
     });
     function hasOwnChildreen(obj, ...childNames) {
@@ -53,7 +58,7 @@ exports.browserViewMediateService = browserViewMediateService;
 function getBrowserViewById(id) {
     for (let index = 0; index < browserViews.length; index++) {
         const browserViewItem = browserViews[index];
-        if (browserViewItem['id'] === id) {
+        if (browserViewItem["id"] === id) {
             return browserViewItem;
         }
     }

src/ElectronNET.Host/api/browserView.js.map

@@ -1 +1 @@
-{"version":3,"file":"browserView.js","sourceRoot":"","sources":["browserView.ts"],"names":[],"mappings":";;;AACA,uCAAuC;AACvC,MAAM,YAAY,GAAkB,CAAC,MAAM,CAAC,cAAc,CAAC,GAAG,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,CAAkB,CAAC;AAC7G,IAAI,WAAwB,EAAE,cAAc,CAAC;AAC7C,MAAM,qBAAqB,GAAgC,CAAC,MAAM,CAAC,uBAAuB,CAAC,GAAG,MAAM,CAAC,uBAAuB,CAAC,IAAI,EAAE,CAAgC,CAAC;AAEpK,MAAM,cAAc,GAAG,CAAC,MAAc,EAAE,EAAE;IACtC,cAAc,GAAG,MAAM,CAAC;IAExB,MAAM,CAAC,EAAE,CAAC,mBAAmB,EAAE,CAAC,OAAO,EAAE,EAAE;QACvC,IAAI,CAAC,eAAe,CAAC,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,CAAC,EAAE,CAAC;YACjE,OAAO,GAAG,EAAE,GAAG,OAAO,EAAE,cAAc,EAAE,EAAE,eAAe,EAAE,IAAI,EAAE,gBAAgB,EAAE,KAAK,EAAE,EAAE,CAAC;QACjG,CAAC;QAED,WAAW,GAAG,IAAI,sBAAW,CAAC,OAAO,CAAC,CAAC;QACvC,WAAW,CAAC,IAAI,CAAC,GAAG,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC;QAE5C,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;YAChB,WAAW,CAAC,WAAW,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAC,UAAU,EAAE,OAAO,CAAC,KAAK,EAAC,CAAC,CAAC;QAC1E,CAAC;QAED,IAAI,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC;YAC5C,qBAAqB,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,gBAAgB,CAAC;QACpE,CAAC;QAED,YAAY,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAE/B,cAAc,CAAC,IAAI,CAAC,oBAAoB,EAAE,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC;IACjE,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,oBAAoB,EAAE,CAAC,EAAE,EAAE,EAAE;QACnC,MAAM,MAAM,GAAG,kBAAkB,CAAC,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC;QAElD,cAAc,CAAC,IAAI,CAAC,8BAA8B,EAAE,MAAM,CAAC,CAAC;IAChE,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,wBAAwB,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE;QAC/C,kBAAkB,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IAC7C,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,2BAA2B,EAAE,CAAC,EAAE,EAAE,OAAO,EAAE,EAAE;QACnD,kBAAkB,CAAC,EAAE,CAAC,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;IAClD,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,gCAAgC,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE;QACtD,kBAAkB,CAAC,EAAE,CAAC,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;IACrD,CAAC,CAAC,CAAC;IAEH,SAAS,eAAe,CAAC,GAAG,EAAE,GAAG,UAAU;QACvC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACzC,IAAI,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC7C,OAAO,KAAK,CAAC;YACjB,CAAC;YACD,GAAG,GAAG,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;QAC7B,CAAC;QAED,OAAO,IAAI,CAAC;IAChB,CAAC;AACL,CAAC,CAAC;AAeO,wCAAc;AAbvB,MAAM,yBAAyB,GAAG,CAAC,aAAqB,EAAe,EAAE;IACrE,OAAO,kBAAkB,CAAC,aAAa,CAAC,CAAC;AAC7C,CAAC,CAAC;AAWuB,8DAAyB;AATlD,SAAS,kBAAkB,CAAC,EAAU;IAClC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;QACvD,MAAM,eAAe,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC;QAC5C,IAAI,eAAe,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,CAAC;YAC/B,OAAO,eAAe,CAAC;QAC3B,CAAC;IACL,CAAC;AACL,CAAC"}
+{"version":3,"file":"browserView.js","sourceRoot":"","sources":["browserView.ts"],"names":[],"mappings":"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"}

src/ElectronNET.Host/api/browserView.ts

@@ -1,74 +1,83 @@
-import { Socket } from 'net';
-import { BrowserView } from 'electron';
-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 };
+import type { Socket } from "net";
+import { BrowserView } from "electron";
+
+const browserViews: BrowserView[] = (global["browserViews"] =
+  global["browserViews"] || []) as BrowserView[];
+const proxyToCredentialsMap: { [proxy: string]: string } = (global[
+  "proxyToCredentialsMap"
+] = global["proxyToCredentialsMap"] || []) as { [proxy: string]: string };
+
+let browserView: BrowserView;
+let electronSocket: Socket;
 
 const browserViewApi = (socket: Socket) => {
-    electronSocket = socket;
+  electronSocket = socket;
 
-    socket.on('createBrowserView', (options) => {
-        if (!hasOwnChildreen(options, 'webPreferences', 'nodeIntegration')) {
-            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-bounds', (id) => {
-        const bounds = getBrowserViewById(id).getBounds();
-
-        electronSocket.emit('browserView-bounds-completed', bounds);
-    });
-
-    socket.on('browserView-bounds-set', (id, bounds) => {
-        getBrowserViewById(id).setBounds(bounds);
-    });
-
-    socket.on('browserView-setAutoResize', (id, options) => {
-        getBrowserViewById(id).setAutoResize(options);
-    });
-
-    socket.on('browserView-setBackgroundColor', (id, color) => {
-        getBrowserViewById(id).setBackgroundColor(color);
-    });
-
-    function hasOwnChildreen(obj, ...childNames) {
-        for (let i = 0; i < childNames.length; i++) {
-            if (!obj || !obj.hasOwnProperty(childNames[i])) {
-                return false;
-            }
-            obj = obj[childNames[i]];
-        }
-
-        return true;
+  socket.on("createBrowserView", (options) => {
+    if (!hasOwnChildreen(options, "webPreferences", "nodeIntegration")) {
+      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-bounds", (id) => {
+    const bounds = getBrowserViewById(id).getBounds();
+
+    electronSocket.emit("browserView-bounds-completed", bounds);
+  });
+
+  socket.on("browserView-bounds-set", (id, bounds) => {
+    getBrowserViewById(id).setBounds(bounds);
+  });
+
+  socket.on("browserView-setAutoResize", (id, options) => {
+    getBrowserViewById(id).setAutoResize(options);
+  });
+
+  socket.on("browserView-setBackgroundColor", (id, color) => {
+    getBrowserViewById(id).setBackgroundColor(color);
+  });
+
+  function hasOwnChildreen(obj, ...childNames) {
+    for (let i = 0; i < childNames.length; i++) {
+      if (!obj || !obj.hasOwnProperty(childNames[i])) {
+        return false;
+      }
+      obj = obj[childNames[i]];
+    }
+
+    return true;
+  }
 };
 
 const browserViewMediateService = (browserViewId: number): BrowserView => {
-    return getBrowserViewById(browserViewId);
+  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;
-        }
+  for (let index = 0; index < browserViews.length; index++) {
+    const browserViewItem = browserViews[index];
+    if (browserViewItem["id"] === id) {
+      return browserViewItem;
     }
+  }
 }
 
 export { browserViewApi, browserViewMediateService };

src/ElectronNET.Host/api/browserWindows.js

@@ -1,12 +1,46 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+const path = __importStar(require("path"));
 const electron_1 = require("electron");
 const browserView_1 = require("./browserView");
-const path = require("path");
 const windows = (global["browserWindows"] =
     global["browserWindows"] || []);
 let readyToShowWindowsIds = [];
-let window, lastOptions, electronSocket;
-let mainWindowURL;
+let window;
+let lastOptions;
+let electronSocket;
 const proxyToCredentialsMap = (global["proxyToCredentialsMap"] = global["proxyToCredentialsMap"] || []);
 module.exports = (socket, app) => {
     electronSocket = socket;
@@ -112,6 +146,12 @@ module.exports = (socket, app) => {
             electronSocket.emit("browserWindow-move" + id);
         });
     });
+    socket.on("register-browserWindow-bounds-changed", (id) => {
+        const window = getWindowById(id);
+        const cb = () => electronSocket.emit("browserWindow-bounds-changed" + id, window.getBounds());
+        window.on("resize", cb);
+        window.on("move", cb);
+    });
     socket.on("register-browserWindow-moved", (id) => {
         getWindowById(id).on("moved", () => {
             electronSocket.emit("browserWindow-moved" + id);
@@ -237,7 +277,15 @@ module.exports = (socket, app) => {
             }
         });
         if (loadUrl) {
-            window.loadURL(loadUrl);
+            // Append authentication token to initial URL if available
+            const token = global["authToken"];
+            if (token) {
+                const separator = loadUrl.includes("?") ? "&" : "?";
+                window.loadURL(`${loadUrl}${separator}token=${token}`);
+            }
+            else {
+                window.loadURL(loadUrl);
+            }
         }
         if (app.commandLine.hasSwitch("clear-cache") &&
             app.commandLine.getSwitchValue("clear-cache")) {

src/ElectronNET.Host/api/browserWindows.ts

@@ -1,12 +1,18 @@
-import { Socket } from "net";
-import { BrowserWindow, Menu, nativeImage } from "electron";
+import * as path from "path";
+import type { Socket } from "net";
+import { BrowserWindow, Menu } from "electron";
+
 import { browserViewMediateService } from "./browserView";
-const path = require("path");
+
 const windows: Electron.BrowserWindow[] = (global["browserWindows"] =
   global["browserWindows"] || []) as Electron.BrowserWindow[];
+
 let readyToShowWindowsIds: number[] = [];
-let window, lastOptions, electronSocket;
-let mainWindowURL;
+
+let window;
+let lastOptions;
+let electronSocket;
+
 const proxyToCredentialsMap: { [proxy: string]: string } = (global[
   "proxyToCredentialsMap"
 ] = global["proxyToCredentialsMap"] || []) as { [proxy: string]: string };
@@ -32,7 +38,7 @@ export = (socket: Socket, app: Electron.App) => {
   socket.on("register-browserWindow-ready-to-show", (id) => {
     if (readyToShowWindowsIds.includes(id)) {
       readyToShowWindowsIds = readyToShowWindowsIds.filter(
-        (value) => value !== id
+        (value) => value !== id,
       );
       electronSocket.emit("browserWindow-ready-to-show" + id);
     }
@@ -139,6 +145,17 @@ export = (socket: Socket, app: Electron.App) => {
     });
   });
 
+  socket.on("register-browserWindow-bounds-changed", (id) => {
+    const window = getWindowById(id);
+    const cb = () =>
+      electronSocket.emit(
+        "browserWindow-bounds-changed" + id,
+        window.getBounds(),
+      );
+    window.on("resize", cb);
+    window.on("move", cb);
+  });
+
   socket.on("register-browserWindow-moved", (id) => {
     getWindowById(id).on("moved", () => {
       electronSocket.emit("browserWindow-moved" + id);
@@ -224,7 +241,7 @@ export = (socket: Socket, app: Electron.App) => {
         __dirname,
         "..",
         "scripts",
-        "blazor-preload.js"
+        "blazor-preload.js",
       );
     }
 
@@ -257,7 +274,7 @@ export = (socket: Socket, app: Electron.App) => {
     window.on("ready-to-show", () => {
       if (readyToShowWindowsIds.includes(window.id)) {
         readyToShowWindowsIds = readyToShowWindowsIds.filter(
-          (value) => value !== window.id
+          (value) => value !== window.id,
         );
       } else {
         readyToShowWindowsIds.push(window.id);
@@ -292,7 +309,15 @@ export = (socket: Socket, app: Electron.App) => {
     });
 
     if (loadUrl) {
-      window.loadURL(loadUrl);
+      // Append authentication token to initial URL if available
+      const token = global["authToken"];
+
+      if (token) {
+        const separator = loadUrl.includes("?") ? "&" : "?";
+        window.loadURL(`${loadUrl}${separator}token=${token}`);
+      } else {
+        window.loadURL(loadUrl);
+      }
     }
 
     if (
@@ -524,7 +549,7 @@ export = (socket: Socket, app: Electron.App) => {
 
     electronSocket.emit(
       "browserWindow-isFullScreenable-completed",
-      fullscreenable
+      fullscreenable,
     );
   });
 
@@ -609,7 +634,7 @@ export = (socket: Socket, app: Electron.App) => {
       .toString(16);
     electronSocket.emit(
       "browserWindow-getNativeWindowHandle-completed",
-      nativeWindowHandle
+      nativeWindowHandle,
     );
   });
 
@@ -622,7 +647,7 @@ export = (socket: Socket, app: Electron.App) => {
     } catch (e) {
       console.warn(
         "setRepresentedFilename failed (likely unsupported platform):",
-        e
+        e,
       );
     }
   });
@@ -637,12 +662,12 @@ export = (socket: Socket, app: Electron.App) => {
     } catch (e) {
       console.warn(
         "getRepresentedFilename failed (likely unsupported platform):",
-        e
+        e,
       );
     }
     electronSocket.emit(
       "browserWindow-getRepresentedFilename-completed",
-      pathname
+      pathname,
     );
   });
 
@@ -734,7 +759,7 @@ export = (socket: Socket, app: Electron.App) => {
           imagePath = path.join(
             __dirname.replace("api", ""),
             "bin",
-            originalIconPath
+            originalIconPath,
           );
         }
         const { nativeImage } = require("electron");
@@ -751,7 +776,7 @@ export = (socket: Socket, app: Electron.App) => {
 
       const success = getWindowById(id).setThumbarButtons(thumbarButtons);
       electronSocket.emit("browserWindowSetThumbarButtons-completed", success);
-    }
+    },
   );
 
   socket.on("browserWindowSetThumbnailClip", (id, rectangle) => {
@@ -779,7 +804,7 @@ export = (socket: Socket, app: Electron.App) => {
 
     electronSocket.emit(
       "browserWindow-isMenuBarAutoHide-completed",
-      isMenuBarAutoHide
+      isMenuBarAutoHide,
     );
   });
 
@@ -792,7 +817,7 @@ export = (socket: Socket, app: Electron.App) => {
 
     electronSocket.emit(
       "browserWindow-isMenuBarVisible-completed",
-      isMenuBarVisible
+      isMenuBarVisible,
     );
   });
 
@@ -806,7 +831,7 @@ export = (socket: Socket, app: Electron.App) => {
 
     electronSocket.emit(
       "browserWindow-isVisibleOnAllWorkspaces-completed",
-      isVisibleOnAllWorkspaces
+      isVisibleOnAllWorkspaces,
     );
   });
 
@@ -838,7 +863,7 @@ export = (socket: Socket, app: Electron.App) => {
 
     electronSocket.emit(
       "browserWindow-getParentWindow-completed",
-      browserWindow.id
+      browserWindow.id,
     );
   });
 

src/ElectronNET.Host/api/clipboard.js

@@ -3,63 +3,65 @@ const electron_1 = require("electron");
 let electronSocket;
 module.exports = (socket) => {
     electronSocket = socket;
-    socket.on('clipboard-readText', (type) => {
+    socket.on("clipboard-readText", (type) => {
         const text = electron_1.clipboard.readText(type);
-        electronSocket.emit('clipboard-readText-completed', text);
+        electronSocket.emit("clipboard-readText-completed", text);
     });
-    socket.on('clipboard-writeText', (text, type) => {
+    socket.on("clipboard-writeText", (text, type) => {
         electron_1.clipboard.writeText(text, type);
     });
-    socket.on('clipboard-readHTML', (type) => {
+    socket.on("clipboard-readHTML", (type) => {
         const content = electron_1.clipboard.readHTML(type);
-        electronSocket.emit('clipboard-readHTML-completed', content);
+        electronSocket.emit("clipboard-readHTML-completed", content);
     });
-    socket.on('clipboard-writeHTML', (markup, type) => {
+    socket.on("clipboard-writeHTML", (markup, type) => {
         electron_1.clipboard.writeHTML(markup, type);
     });
-    socket.on('clipboard-readRTF', (type) => {
+    socket.on("clipboard-readRTF", (type) => {
         const content = electron_1.clipboard.readRTF(type);
-        electronSocket.emit('clipboard-readRTF-completed', content);
+        electronSocket.emit("clipboard-readRTF-completed", content);
     });
-    socket.on('clipboard-writeRTF', (text, type) => {
+    socket.on("clipboard-writeRTF", (text, type) => {
         electron_1.clipboard.writeHTML(text, type);
     });
-    socket.on('clipboard-readBookmark', () => {
+    socket.on("clipboard-readBookmark", () => {
         const bookmark = electron_1.clipboard.readBookmark();
-        electronSocket.emit('clipboard-readBookmark-completed', bookmark);
+        electronSocket.emit("clipboard-readBookmark-completed", bookmark);
     });
-    socket.on('clipboard-writeBookmark', (title, url, type) => {
+    socket.on("clipboard-writeBookmark", (title, url, type) => {
         electron_1.clipboard.writeBookmark(title, url, type);
     });
-    socket.on('clipboard-readFindText', () => {
+    socket.on("clipboard-readFindText", () => {
         const content = electron_1.clipboard.readFindText();
-        electronSocket.emit('clipboard-readFindText-completed', content);
+        electronSocket.emit("clipboard-readFindText-completed", content);
     });
-    socket.on('clipboard-writeFindText', (text) => {
+    socket.on("clipboard-writeFindText", (text) => {
         electron_1.clipboard.writeFindText(text);
     });
-    socket.on('clipboard-clear', (type) => {
+    socket.on("clipboard-clear", (type) => {
         electron_1.clipboard.clear(type);
     });
-    socket.on('clipboard-availableFormats', (type) => {
+    socket.on("clipboard-availableFormats", (type) => {
         const formats = electron_1.clipboard.availableFormats(type);
-        electronSocket.emit('clipboard-availableFormats-completed', formats);
+        electronSocket.emit("clipboard-availableFormats-completed", formats);
     });
-    socket.on('clipboard-write', (data, type) => {
+    socket.on("clipboard-write", (data, type) => {
         electron_1.clipboard.write(data, type);
     });
-    socket.on('clipboard-readImage', (type) => {
+    socket.on("clipboard-readImage", (type) => {
         const image = electron_1.clipboard.readImage(type);
-        electronSocket.emit('clipboard-readImage-completed', { 1: image.toPNG().toString('base64') });
+        electronSocket.emit("clipboard-readImage-completed", {
+            1: image.toPNG().toString("base64"),
+        });
     });
-    socket.on('clipboard-writeImage', (data, type) => {
+    socket.on("clipboard-writeImage", (data, type) => {
         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');
+            const buffer = Buffer.from(bytes, "base64");
             image.addRepresentation({ scaleFactor: +scaleFactor, buffer: buffer });
         }
         electron_1.clipboard.writeImage(image, type);

src/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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"}

src/ElectronNET.Host/api/clipboard.ts

@@ -1,84 +1,87 @@
-import { Socket } from 'net';
-import { clipboard, nativeImage } from 'electron';
-let electronSocket;
+import type { Socket } from "net";
+import { clipboard, nativeImage } from "electron";
+
+let electronSocket: Socket;
 
 export = (socket: Socket) => {
-    electronSocket = socket;
-    socket.on('clipboard-readText', (type) => {
-        const text = clipboard.readText(type);
-        electronSocket.emit('clipboard-readText-completed', text);
+  electronSocket = socket;
+  socket.on("clipboard-readText", (type) => {
+    const text = clipboard.readText(type);
+    electronSocket.emit("clipboard-readText-completed", text);
+  });
+
+  socket.on("clipboard-writeText", (text, type) => {
+    clipboard.writeText(text, type);
+  });
+
+  socket.on("clipboard-readHTML", (type) => {
+    const content = clipboard.readHTML(type);
+    electronSocket.emit("clipboard-readHTML-completed", content);
+  });
+
+  socket.on("clipboard-writeHTML", (markup, type) => {
+    clipboard.writeHTML(markup, type);
+  });
+
+  socket.on("clipboard-readRTF", (type) => {
+    const content = clipboard.readRTF(type);
+    electronSocket.emit("clipboard-readRTF-completed", content);
+  });
+
+  socket.on("clipboard-writeRTF", (text, type) => {
+    clipboard.writeHTML(text, type);
+  });
+
+  socket.on("clipboard-readBookmark", () => {
+    const bookmark = clipboard.readBookmark();
+    electronSocket.emit("clipboard-readBookmark-completed", bookmark);
+  });
+
+  socket.on("clipboard-writeBookmark", (title, url, type) => {
+    clipboard.writeBookmark(title, url, type);
+  });
+
+  socket.on("clipboard-readFindText", () => {
+    const content = clipboard.readFindText();
+    electronSocket.emit("clipboard-readFindText-completed", content);
+  });
+
+  socket.on("clipboard-writeFindText", (text) => {
+    clipboard.writeFindText(text);
+  });
+
+  socket.on("clipboard-clear", (type) => {
+    clipboard.clear(type);
+  });
+
+  socket.on("clipboard-availableFormats", (type) => {
+    const formats = clipboard.availableFormats(type);
+    electronSocket.emit("clipboard-availableFormats-completed", formats);
+  });
+
+  socket.on("clipboard-write", (data, type) => {
+    clipboard.write(data, type);
+  });
+
+  socket.on("clipboard-readImage", (type) => {
+    const image = clipboard.readImage(type);
+    electronSocket.emit("clipboard-readImage-completed", {
+      1: image.toPNG().toString("base64"),
     });
+  });
 
-    socket.on('clipboard-writeText', (text, type) => {
-        clipboard.writeText(text, type);
-    });
+  socket.on("clipboard-writeImage", (data, type) => {
+    const dataContent = JSON.parse(data);
+    const image = nativeImage.createEmpty();
 
-    socket.on('clipboard-readHTML', (type) => {
-        const content = clipboard.readHTML(type);
-        electronSocket.emit('clipboard-readHTML-completed', content);
-    });
+    // 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 });
+    }
 
-    socket.on('clipboard-writeHTML', (markup, type) => {
-        clipboard.writeHTML(markup, type);
-    });
-
-    socket.on('clipboard-readRTF', (type) => {
-        const content = clipboard.readRTF(type);
-        electronSocket.emit('clipboard-readRTF-completed', content);
-    });
-
-    socket.on('clipboard-writeRTF', (text, type) => {
-        clipboard.writeHTML(text, type);
-    });
-
-    socket.on('clipboard-readBookmark', () => {
-        const bookmark = clipboard.readBookmark();
-        electronSocket.emit('clipboard-readBookmark-completed', bookmark);
-    });
-
-    socket.on('clipboard-writeBookmark', (title, url, type) => {
-        clipboard.writeBookmark(title, url, type);
-    });
-
-    socket.on('clipboard-readFindText', () => {
-        const content = clipboard.readFindText();
-        electronSocket.emit('clipboard-readFindText-completed', content);
-    });
-
-    socket.on('clipboard-writeFindText', (text) => {
-        clipboard.writeFindText(text);
-    });
-
-    socket.on('clipboard-clear', (type) => {
-        clipboard.clear(type);
-    });
-
-    socket.on('clipboard-availableFormats', (type) => {
-        const formats = clipboard.availableFormats(type);
-        electronSocket.emit('clipboard-availableFormats-completed', formats);
-    });
-
-    socket.on('clipboard-write', (data, type) => {
-        clipboard.write(data, type);
-    });
-
-    socket.on('clipboard-readImage', (type) => {
-        const image = clipboard.readImage(type);
-        electronSocket.emit('clipboard-readImage-completed', { 1: image.toPNG().toString('base64') });
-    });
-
-    socket.on('clipboard-writeImage', (data, type) => {
-        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(image, type);
-    });
+    clipboard.writeImage(image, type);
+  });
 };

src/ElectronNET.Host/api/commandLine.js

@@ -2,19 +2,19 @@
 let electronSocket;
 module.exports = (socket, app) => {
     electronSocket = socket;
-    socket.on('appCommandLineAppendSwitch', (the_switch, value) => {
+    socket.on("appCommandLineAppendSwitch", (the_switch, value) => {
         app.commandLine.appendSwitch(the_switch, value);
     });
-    socket.on('appCommandLineAppendArgument', (value) => {
+    socket.on("appCommandLineAppendArgument", (value) => {
         app.commandLine.appendArgument(value);
     });
-    socket.on('appCommandLineHasSwitch', (value) => {
+    socket.on("appCommandLineHasSwitch", (value) => {
         const hasSwitch = app.commandLine.hasSwitch(value);
-        electronSocket.emit('appCommandLineHasSwitchCompleted', hasSwitch);
+        electronSocket.emit("appCommandLineHasSwitchCompleted", hasSwitch);
     });
-    socket.on('appCommandLineGetSwitchValue', (the_switch) => {
+    socket.on("appCommandLineGetSwitchValue", (the_switch) => {
         const value = app.commandLine.getSwitchValue(the_switch);
-        electronSocket.emit('appCommandLineGetSwitchValueCompleted', value);
+        electronSocket.emit("appCommandLineGetSwitchValueCompleted", value);
     });
 };
 //# sourceMappingURL=commandLine.js.map

src/ElectronNET.Host/api/commandLine.js.map

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"commandLine.js","sourceRoot":"","sources":["commandLine.ts"],"names":[],"mappings":";AAEA,IAAI,cAAsB,CAAC;AAE3B,iBAAS,CAAC,MAAc,EAAE,GAAiB,EAAE,EAAE;IAC7C,cAAc,GAAG,MAAM,CAAC;IAExB,MAAM,CAAC,EAAE,CACP,4BAA4B,EAC5B,CAAC,UAAkB,EAAE,KAAa,EAAE,EAAE;QACpC,GAAG,CAAC,WAAW,CAAC,YAAY,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;IAClD,CAAC,CACF,CAAC;IAEF,MAAM,CAAC,EAAE,CAAC,8BAA8B,EAAE,CAAC,KAAa,EAAE,EAAE;QAC1D,GAAG,CAAC,WAAW,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;IACxC,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,yBAAyB,EAAE,CAAC,KAAa,EAAE,EAAE;QACrD,MAAM,SAAS,GAAG,GAAG,CAAC,WAAW,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACnD,cAAc,CAAC,IAAI,CAAC,kCAAkC,EAAE,SAAS,CAAC,CAAC;IACrE,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,8BAA8B,EAAE,CAAC,UAAkB,EAAE,EAAE;QAC/D,MAAM,KAAK,GAAG,GAAG,CAAC,WAAW,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;QACzD,cAAc,CAAC,IAAI,CAAC,uCAAuC,EAAE,KAAK,CAAC,CAAC;IACtE,CAAC,CAAC,CAAC;AACL,CAAC,CAAC"}

src/ElectronNET.Host/api/commandLine.ts

@@ -1,24 +1,28 @@
-import { Socket } from 'net';
-let electronSocket;
+import type { Socket } from "net";
+
+let electronSocket: Socket;
 
 export = (socket: Socket, app: Electron.App) => {
-    electronSocket = socket;
+  electronSocket = socket;
 
-    socket.on('appCommandLineAppendSwitch', (the_switch: string, value: string) => {
-        app.commandLine.appendSwitch(the_switch, value);
-    });
+  socket.on(
+    "appCommandLineAppendSwitch",
+    (the_switch: string, value: string) => {
+      app.commandLine.appendSwitch(the_switch, value);
+    },
+  );
 
-    socket.on('appCommandLineAppendArgument', (value: string) => {
-        app.commandLine.appendArgument(value);
-    });
+  socket.on("appCommandLineAppendArgument", (value: string) => {
+    app.commandLine.appendArgument(value);
+  });
 
-    socket.on('appCommandLineHasSwitch', (value: string) => {
-        const hasSwitch = app.commandLine.hasSwitch(value);
-        electronSocket.emit('appCommandLineHasSwitchCompleted', hasSwitch);
-    });
+  socket.on("appCommandLineHasSwitch", (value: string) => {
+    const hasSwitch = app.commandLine.hasSwitch(value);
+    electronSocket.emit("appCommandLineHasSwitchCompleted", hasSwitch);
+  });
 
-    socket.on('appCommandLineGetSwitchValue', (the_switch: string) => {
-        const value = app.commandLine.getSwitchValue(the_switch);
-        electronSocket.emit('appCommandLineGetSwitchValueCompleted', value);
-    });
+  socket.on("appCommandLineGetSwitchValue", (the_switch: string) => {
+    const value = app.commandLine.getSwitchValue(the_switch);
+    electronSocket.emit("appCommandLineGetSwitchValueCompleted", value);
+  });
 };

src/ElectronNET.Host/api/dialog.js

@@ -3,35 +3,41 @@ const electron_1 = require("electron");
 let electronSocket;
 module.exports = (socket) => {
     electronSocket = socket;
-    socket.on('showMessageBox', async (browserWindow, options, guid) => {
-        if ('id' in browserWindow) {
+    socket.on("showMessageBox", async (browserWindow, options, guid) => {
+        if ("id" in browserWindow) {
             const window = electron_1.BrowserWindow.fromId(browserWindow.id);
             const messageBoxReturnValue = await electron_1.dialog.showMessageBox(window, options);
-            electronSocket.emit('showMessageBoxComplete' + guid, [messageBoxReturnValue.response, messageBoxReturnValue.checkboxChecked]);
+            electronSocket.emit("showMessageBoxComplete" + guid, [
+                messageBoxReturnValue.response,
+                messageBoxReturnValue.checkboxChecked,
+            ]);
         }
         else {
             const id = guid || options;
             const messageBoxReturnValue = await electron_1.dialog.showMessageBox(browserWindow);
-            electronSocket.emit('showMessageBoxComplete' + id, [messageBoxReturnValue.response, messageBoxReturnValue.checkboxChecked]);
+            electronSocket.emit("showMessageBoxComplete" + id, [
+                messageBoxReturnValue.response,
+                messageBoxReturnValue.checkboxChecked,
+            ]);
         }
     });
-    socket.on('showOpenDialog', async (browserWindow, options, guid) => {
+    socket.on("showOpenDialog", async (browserWindow, options, guid) => {
         const window = electron_1.BrowserWindow.fromId(browserWindow.id);
         const openDialogReturnValue = await electron_1.dialog.showOpenDialog(window, options);
-        electronSocket.emit('showOpenDialogComplete' + guid, openDialogReturnValue.filePaths || []);
+        electronSocket.emit("showOpenDialogComplete" + guid, openDialogReturnValue.filePaths || []);
     });
-    socket.on('showSaveDialog', async (browserWindow, options, guid) => {
+    socket.on("showSaveDialog", async (browserWindow, options, guid) => {
         const window = electron_1.BrowserWindow.fromId(browserWindow.id);
         const saveDialogReturnValue = await electron_1.dialog.showSaveDialog(window, options);
-        electronSocket.emit('showSaveDialogComplete' + guid, saveDialogReturnValue.filePath || '');
+        electronSocket.emit("showSaveDialogComplete" + guid, saveDialogReturnValue.filePath || "");
     });
-    socket.on('showErrorBox', (title, content) => {
+    socket.on("showErrorBox", (title, content) => {
         electron_1.dialog.showErrorBox(title, content);
     });
-    socket.on('showCertificateTrustDialog', async (browserWindow, options, guid) => {
+    socket.on("showCertificateTrustDialog", async (browserWindow, options, guid) => {
         const window = electron_1.BrowserWindow.fromId(browserWindow.id);
         await electron_1.dialog.showCertificateTrustDialog(window, options);
-        electronSocket.emit('showCertificateTrustDialogComplete' + guid);
+        electronSocket.emit("showCertificateTrustDialogComplete" + guid);
     });
 };
 //# sourceMappingURL=dialog.js.map

src/ElectronNET.Host/api/dialog.js.map

@@ -1 +1 @@
-{"version":3,"file":"dialog.js","sourceRoot":"","sources":["dialog.ts"],"names":[],"mappings":";AACA,uCAAiD;AACjD,IAAI,cAAsB,CAAC;AAE3B,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,CAAC;YACxB,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;QAClI,CAAC;aAAM,CAAC;YACJ,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;QAChI,CAAC;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;AAEjD,IAAI,cAAsB,CAAC;AAE3B,iBAAS,CAAC,MAAc,EAAE,EAAE;IAC1B,cAAc,GAAG,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,CAAC,gBAAgB,EAAE,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE;QACjE,IAAI,IAAI,IAAI,aAAa,EAAE,CAAC;YAC1B,MAAM,MAAM,GAAG,wBAAa,CAAC,MAAM,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC;YAEtD,MAAM,qBAAqB,GAAG,MAAM,iBAAM,CAAC,cAAc,CACvD,MAAM,EACN,OAAO,CACR,CAAC;YACF,cAAc,CAAC,IAAI,CAAC,wBAAwB,GAAG,IAAI,EAAE;gBACnD,qBAAqB,CAAC,QAAQ;gBAC9B,qBAAqB,CAAC,eAAe;aACtC,CAAC,CAAC;QACL,CAAC;aAAM,CAAC;YACN,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;gBACjD,qBAAqB,CAAC,QAAQ;gBAC9B,qBAAqB,CAAC,eAAe;aACtC,CAAC,CAAC;QACL,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,gBAAgB,EAAE,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE;QACjE,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,CACjB,wBAAwB,GAAG,IAAI,EAC/B,qBAAqB,CAAC,SAAS,IAAI,EAAE,CACtC,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,gBAAgB,EAAE,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE;QACjE,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,CACjB,wBAAwB,GAAG,IAAI,EAC/B,qBAAqB,CAAC,QAAQ,IAAI,EAAE,CACrC,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,cAAc,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;QAC3C,iBAAM,CAAC,YAAY,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IACtC,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CACP,4BAA4B,EAC5B,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE;QACrC,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;IACnE,CAAC,CACF,CAAC;AACJ,CAAC,CAAC"}

src/ElectronNET.Host/api/dialog.ts

@@ -1,45 +1,64 @@
-import { Socket } from 'net';
-import { BrowserWindow, dialog } from 'electron';
+import type { Socket } from "net";
+import { BrowserWindow, dialog } from "electron";
+
 let electronSocket: Socket;
 
 export = (socket: Socket) => {
-    electronSocket = socket;
-    socket.on('showMessageBox', async (browserWindow, options, guid) => {
-        if ('id' in browserWindow) {
-            const window = BrowserWindow.fromId(browserWindow.id);
+  electronSocket = socket;
+  socket.on("showMessageBox", async (browserWindow, options, guid) => {
+    if ("id" in browserWindow) {
+      const window = BrowserWindow.fromId(browserWindow.id);
 
-            const messageBoxReturnValue = await dialog.showMessageBox(window, options);
-            electronSocket.emit('showMessageBoxComplete' + guid, [messageBoxReturnValue.response, messageBoxReturnValue.checkboxChecked]);
-        } else {
-            const id = guid || options;
-            const messageBoxReturnValue = await dialog.showMessageBox(browserWindow);
+      const messageBoxReturnValue = await dialog.showMessageBox(
+        window,
+        options,
+      );
+      electronSocket.emit("showMessageBoxComplete" + guid, [
+        messageBoxReturnValue.response,
+        messageBoxReturnValue.checkboxChecked,
+      ]);
+    } else {
+      const id = guid || options;
+      const messageBoxReturnValue = await dialog.showMessageBox(browserWindow);
 
-            electronSocket.emit('showMessageBoxComplete' + id, [messageBoxReturnValue.response, messageBoxReturnValue.checkboxChecked]);
-        }
-    });
+      electronSocket.emit("showMessageBoxComplete" + id, [
+        messageBoxReturnValue.response,
+        messageBoxReturnValue.checkboxChecked,
+      ]);
+    }
+  });
 
-    socket.on('showOpenDialog', async (browserWindow, options, guid) => {
-        const window = BrowserWindow.fromId(browserWindow.id);
-        const openDialogReturnValue = await dialog.showOpenDialog(window, options);
+  socket.on("showOpenDialog", async (browserWindow, options, guid) => {
+    const window = BrowserWindow.fromId(browserWindow.id);
+    const openDialogReturnValue = await dialog.showOpenDialog(window, options);
 
-        electronSocket.emit('showOpenDialogComplete' + guid, openDialogReturnValue.filePaths || []);
-    });
+    electronSocket.emit(
+      "showOpenDialogComplete" + guid,
+      openDialogReturnValue.filePaths || [],
+    );
+  });
 
-    socket.on('showSaveDialog', async (browserWindow, options, guid) => {
-        const window = BrowserWindow.fromId(browserWindow.id);
-        const saveDialogReturnValue = await dialog.showSaveDialog(window, options);
+  socket.on("showSaveDialog", async (browserWindow, options, guid) => {
+    const window = BrowserWindow.fromId(browserWindow.id);
+    const saveDialogReturnValue = await dialog.showSaveDialog(window, options);
 
-        electronSocket.emit('showSaveDialogComplete' + guid, saveDialogReturnValue.filePath || '');
-    });
+    electronSocket.emit(
+      "showSaveDialogComplete" + guid,
+      saveDialogReturnValue.filePath || "",
+    );
+  });
 
-    socket.on('showErrorBox', (title, content) => {
-        dialog.showErrorBox(title, content);
-    });
+  socket.on("showErrorBox", (title, content) => {
+    dialog.showErrorBox(title, content);
+  });
 
-    socket.on('showCertificateTrustDialog', async (browserWindow, options, guid) => {
-        const window = BrowserWindow.fromId(browserWindow.id);
-        await dialog.showCertificateTrustDialog(window, options);
+  socket.on(
+    "showCertificateTrustDialog",
+    async (browserWindow, options, guid) => {
+      const window = BrowserWindow.fromId(browserWindow.id);
+      await dialog.showCertificateTrustDialog(window, options);
 
-        electronSocket.emit('showCertificateTrustDialogComplete' + guid);
-    });
+      electronSocket.emit("showCertificateTrustDialogComplete" + guid);
+    },
+  );
 };

src/ElectronNET.Host/api/dock.js

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

src/ElectronNET.Host/api/dock.js.map

@@ -1 +1 @@
-{"version":3,"file":"dock.js","sourceRoot":"","sources":["dock.ts"],"names":[],"mappings":";AACA,uCAAqC;AACrC,IAAI,cAAc,CAAC;AAEnB,iBAAS,CAAC,MAAc,EAAE,EAAE;IACxB,cAAc,GAAG,MAAM,CAAC;IAExB,MAAM,CAAC,EAAE,CAAC,aAAa,EAAE,CAAC,IAAI,EAAE,EAAE;QAC9B,MAAM,EAAE,GAAG,cAAG,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACjC,cAAc,CAAC,IAAI,CAAC,uBAAuB,EAAE,EAAE,CAAC,CAAC;IACrD,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,mBAAmB,EAAE,CAAC,EAAE,EAAE,EAAE;QAClC,cAAG,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC;IAC9B,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,uBAAuB,EAAE,CAAC,QAAQ,EAAE,EAAE;QAC5C,cAAG,CAAC,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC;IACxC,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,eAAe,EAAE,CAAC,IAAI,EAAE,EAAE;QAChC,cAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IAC5B,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,eAAe,EAAE,GAAG,EAAE;QAC5B,MAAM,IAAI,GAAG,cAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;QACjC,cAAc,CAAC,IAAI,CAAC,yBAAyB,EAAE,IAAI,CAAC,CAAC;IACzD,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,WAAW,EAAE,GAAG,EAAE;QACxB,cAAG,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;IACpB,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,WAAW,EAAE,GAAG,EAAE;QACxB,cAAG,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;IACpB,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,gBAAgB,EAAE,GAAG,EAAE;QAC7B,MAAM,SAAS,GAAG,cAAG,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;QACvC,cAAc,CAAC,IAAI,CAAC,0BAA0B,EAAE,SAAS,CAAC,CAAC;IAC/D,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,cAAc,EAAE,CAAC,SAAS,EAAE,EAAE;QACpC,IAAI,IAAI,GAAG,IAAI,CAAC;QAEhB,IAAI,SAAS,EAAE,CAAC;YACZ,IAAI,GAAG,eAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;YAEzC,yBAAyB,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE;gBACzC,cAAc,CAAC,IAAI,CAAC,qBAAqB,EAAE,EAAE,CAAC,CAAC;YACnD,CAAC,CAAC,CAAC;QACP,CAAC;QAED,cAAG,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3B,CAAC,CAAC,CAAC;IAEH,6CAA6C;IAC7C,MAAM,CAAC,EAAE,CAAC,cAAc,EAAE,GAAG,EAAE;QAC3B,MAAM,IAAI,GAAG,cAAG,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;QAChC,cAAc,CAAC,IAAI,CAAC,wBAAwB,EAAE,IAAI,CAAC,CAAC;IACxD,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,cAAc,EAAE,CAAC,KAAK,EAAE,EAAE;QAChC,cAAG,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IAC5B,CAAC,CAAC,CAAC;IAEH,SAAS,yBAAyB,CAAC,SAAS,EAAE,QAAQ;QAClD,SAAS,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;YACvB,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAChD,yBAAyB,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;YAC5D,CAAC;YAED,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,CAAC,EAAE,EAAE,CAAC;gBAC1B,IAAI,CAAC,KAAK,GAAG,GAAG,EAAE,GAAG,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;YAC9C,CAAC;QACL,CAAC,CAAC,CAAC;IACP,CAAC;AACL,CAAC,CAAC"}
+{"version":3,"file":"dock.js","sourceRoot":"","sources":["dock.ts"],"names":[],"mappings":"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"}

src/ElectronNET.Host/api/dock.ts

@@ -1,78 +1,81 @@
-import { Socket } from 'net';
-import { app, Menu } from 'electron';
-let electronSocket;
+import type { Socket } from "net";
+import { app, Menu } from "electron";
+
+let electronSocket: Socket;
 
 export = (socket: Socket) => {
-    electronSocket = socket;
+  electronSocket = socket;
 
-    socket.on('dock-bounce', (type) => {
-        const id = app.dock.bounce(type);
-        electronSocket.emit('dock-bounce-completed', id);
-    });
+  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-cancelBounce", (id) => {
+    app.dock.cancelBounce(id);
+  });
 
-    socket.on('dock-downloadFinished', (filePath) => {
-        app.dock.downloadFinished(filePath);
-    });
+  socket.on("dock-downloadFinished", (filePath) => {
+    app.dock.downloadFinished(filePath);
+  });
 
-    socket.on('dock-setBadge', (text) => {
-        app.dock.setBadge(text);
-    });
+  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-getBadge", () => {
+    const text = app.dock.getBadge();
+    electronSocket.emit("dock-getBadge-completed", text);
+  });
 
-    socket.on('dock-hide', () => {
-        app.dock.hide();
-    });
+  socket.on("dock-hide", () => {
+    app.dock.hide();
+  });
 
-    socket.on('dock-show', () => {
-        app.dock.show();
-    });
+  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-isVisible", () => {
+    const isVisible = app.dock.isVisible();
+    electronSocket.emit("dock-isVisible-completed", isVisible);
+  });
 
-    socket.on('dock-setMenu', (menuItems) => {
-        let menu = null;
+  socket.on("dock-setMenu", (menuItems) => {
+    let menu = null;
 
-        if (menuItems) {
-            menu = Menu.buildFromTemplate(menuItems);
+    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); };
-            }
-        });
+      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);
+        };
+      }
+    });
+  }
 };

src/ElectronNET.Host/api/globalShortcut.js

@@ -3,19 +3,19 @@ const electron_1 = require("electron");
 let electronSocket;
 module.exports = (socket) => {
     electronSocket = socket;
-    socket.on('globalShortcut-register', (accelerator) => {
+    socket.on("globalShortcut-register", (accelerator) => {
         electron_1.globalShortcut.register(accelerator, () => {
-            electronSocket.emit('globalShortcut-pressed', accelerator);
+            electronSocket.emit("globalShortcut-pressed", accelerator);
         });
     });
-    socket.on('globalShortcut-isRegistered', (accelerator) => {
+    socket.on("globalShortcut-isRegistered", (accelerator) => {
         const isRegistered = electron_1.globalShortcut.isRegistered(accelerator);
-        electronSocket.emit('globalShortcut-isRegisteredCompleted', isRegistered);
+        electronSocket.emit("globalShortcut-isRegisteredCompleted", isRegistered);
     });
-    socket.on('globalShortcut-unregister', (accelerator) => {
+    socket.on("globalShortcut-unregister", (accelerator) => {
         electron_1.globalShortcut.unregister(accelerator);
     });
-    socket.on('globalShortcut-unregisterAll', () => {
+    socket.on("globalShortcut-unregisterAll", () => {
         try {
             electron_1.globalShortcut.unregisterAll();
         }

src/ElectronNET.Host/api/globalShortcut.js.map

@@ -1 +1 @@
-{"version":3,"file":"globalShortcut.js","sourceRoot":"","sources":["globalShortcut.ts"],"names":[],"mappings":";AAAA,uCAA0C;AAE1C,IAAI,cAAc,CAAC;AAEnB,iBAAS,CAAC,MAAc,EAAE,EAAE;IACxB,cAAc,GAAG,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,CAAC,yBAAyB,EAAE,CAAC,WAAW,EAAE,EAAE;QACjD,yBAAc,CAAC,QAAQ,CAAC,WAAW,EAAE,GAAG,EAAE;YACtC,cAAc,CAAC,IAAI,CAAC,wBAAwB,EAAE,WAAW,CAAC,CAAC;QAC/D,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,6BAA6B,EAAE,CAAC,WAAW,EAAE,EAAE;QACrD,MAAM,YAAY,GAAG,yBAAc,CAAC,YAAY,CAAC,WAAW,CAAC,CAAC;QAE9D,cAAc,CAAC,IAAI,CAAC,sCAAsC,EAAE,YAAY,CAAC,CAAC;IAC9E,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,2BAA2B,EAAE,CAAC,WAAW,EAAE,EAAE;QACnD,yBAAc,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;IAC3C,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,8BAA8B,EAAE,GAAG,EAAE;QAC3C,IAAI,CAAC;YACD,yBAAc,CAAC,aAAa,EAAE,CAAC;QACnC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC,CAAC,CAAC;IACvB,CAAC,CAAC,CAAC;AACP,CAAC,CAAC"}
+{"version":3,"file":"globalShortcut.js","sourceRoot":"","sources":["globalShortcut.ts"],"names":[],"mappings":";AACA,uCAA0C;AAE1C,IAAI,cAAsB,CAAC;AAE3B,iBAAS,CAAC,MAAc,EAAE,EAAE;IAC1B,cAAc,GAAG,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,CAAC,yBAAyB,EAAE,CAAC,WAAW,EAAE,EAAE;QACnD,yBAAc,CAAC,QAAQ,CAAC,WAAW,EAAE,GAAG,EAAE;YACxC,cAAc,CAAC,IAAI,CAAC,wBAAwB,EAAE,WAAW,CAAC,CAAC;QAC7D,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,6BAA6B,EAAE,CAAC,WAAW,EAAE,EAAE;QACvD,MAAM,YAAY,GAAG,yBAAc,CAAC,YAAY,CAAC,WAAW,CAAC,CAAC;QAE9D,cAAc,CAAC,IAAI,CAAC,sCAAsC,EAAE,YAAY,CAAC,CAAC;IAC5E,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,2BAA2B,EAAE,CAAC,WAAW,EAAE,EAAE;QACrD,yBAAc,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;IACzC,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,8BAA8B,EAAE,GAAG,EAAE;QAC7C,IAAI,CAAC;YACH,yBAAc,CAAC,aAAa,EAAE,CAAC;QACjC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC,CAAA,CAAC;IACpB,CAAC,CAAC,CAAC;AACL,CAAC,CAAC"}

src/ElectronNET.Host/api/globalShortcut.ts

@@ -1,28 +1,29 @@
-import { globalShortcut } from 'electron';
-import { Socket } from 'net';
-let electronSocket;
+import type { Socket } from "net";
+import { globalShortcut } from "electron";
+
+let electronSocket: Socket;
 
 export = (socket: Socket) => {
-    electronSocket = socket;
-    socket.on('globalShortcut-register', (accelerator) => {
-        globalShortcut.register(accelerator, () => {
-            electronSocket.emit('globalShortcut-pressed', accelerator);
-        });
+  electronSocket = socket;
+  socket.on("globalShortcut-register", (accelerator) => {
+    globalShortcut.register(accelerator, () => {
+      electronSocket.emit("globalShortcut-pressed", accelerator);
     });
+  });
 
-    socket.on('globalShortcut-isRegistered', (accelerator) => {
-        const isRegistered = globalShortcut.isRegistered(accelerator);
+  socket.on("globalShortcut-isRegistered", (accelerator) => {
+    const isRegistered = globalShortcut.isRegistered(accelerator);
 
-        electronSocket.emit('globalShortcut-isRegisteredCompleted', isRegistered);
-    });
+    electronSocket.emit("globalShortcut-isRegisteredCompleted", isRegistered);
+  });
 
-    socket.on('globalShortcut-unregister', (accelerator) => {
-        globalShortcut.unregister(accelerator);
-    });
+  socket.on("globalShortcut-unregister", (accelerator) => {
+    globalShortcut.unregister(accelerator);
+  });
 
-    socket.on('globalShortcut-unregisterAll', () => {
-        try {
-            globalShortcut.unregisterAll();
-        } catch (error) { }
-    });
+  socket.on("globalShortcut-unregisterAll", () => {
+    try {
+      globalShortcut.unregisterAll();
+    } catch (error) {}
+  });
 };

src/ElectronNET.Host/api/ipc.js

@@ -3,40 +3,41 @@ const electron_1 = require("electron");
 let electronSocket;
 module.exports = (socket) => {
     electronSocket = socket;
-    socket.on('registerIpcMainChannel', (channel) => {
+    socket.on("registerIpcMainChannel", (channel) => {
         electron_1.ipcMain.on(channel, (event, args) => {
             electronSocket.emit(channel, [event.preventDefault(), args]);
         });
     });
-    socket.on('registerSyncIpcMainChannel', (channel) => {
+    socket.on("registerSyncIpcMainChannel", (channel) => {
         electron_1.ipcMain.on(channel, (event, args) => {
             const x = socket;
-            x.removeAllListeners(channel + 'Sync');
-            socket.on(channel + 'Sync', (result) => {
+            x.removeAllListeners(channel + "Sync");
+            socket.on(channel + "Sync", (result) => {
                 event.returnValue = result;
             });
             electronSocket.emit(channel, [event.preventDefault(), args]);
         });
     });
-    socket.on('registerOnceIpcMainChannel', (channel) => {
+    socket.on("registerOnceIpcMainChannel", (channel) => {
         electron_1.ipcMain.once(channel, (event, args) => {
             electronSocket.emit(channel, [event.preventDefault(), args]);
         });
     });
-    socket.on('removeAllListenersIpcMainChannel', (channel) => {
+    socket.on("removeAllListenersIpcMainChannel", (channel) => {
         electron_1.ipcMain.removeAllListeners(channel);
     });
-    socket.on('sendToIpcRenderer', (browserWindow, channel, data) => {
+    socket.on("sendToIpcRenderer", (browserWindow, channel, data) => {
         const window = electron_1.BrowserWindow.fromId(browserWindow.id);
         if (window) {
             window.webContents.send(channel, ...data);
         }
     });
-    socket.on('sendToIpcRendererBrowserView', (id, channel, data) => {
-        const browserViews = (global['browserViews'] = global['browserViews'] || []);
+    socket.on("sendToIpcRendererBrowserView", (id, channel, data) => {
+        const browserViews = (global["browserViews"] =
+            global["browserViews"] || []);
         let view = null;
         for (let i = 0; i < browserViews.length; i++) {
-            if (browserViews[i]['id'] === id) {
+            if (browserViews[i]["id"] === id) {
                 view = browserViews[i];
                 break;
             }
@@ -45,29 +46,58 @@ module.exports = (socket) => {
             view.webContents.send(channel, ...data);
         }
     });
+    socket.on("registerHandleIpcMainChannel", (channel) => {
+        electron_1.ipcMain.handle(channel, (event, args) => {
+            return new Promise((resolve, _reject) => {
+                socket.removeAllListeners(channel + "Handle");
+                socket.on(channel + "Handle", (result) => {
+                    resolve(result);
+                });
+                electronSocket.emit(channel, [event.preventDefault(), args]);
+            });
+        });
+    });
+    socket.on("registerHandleOnceIpcMainChannel", (channel) => {
+        electron_1.ipcMain.handleOnce(channel, (event, args) => {
+            return new Promise((resolve, _reject) => {
+                socket.removeAllListeners(channel + "HandleOnce");
+                socket.once(channel + "HandleOnce", (result) => {
+                    resolve(result);
+                });
+                electronSocket.emit(channel, [event.preventDefault(), args]);
+            });
+        });
+    });
+    socket.on("removeHandlerIpcMainChannel", (channel) => {
+        electron_1.ipcMain.removeHandler(channel);
+    });
     // Integration helpers: programmatically click menu items from renderer tests
-    electron_1.ipcMain.on('integration-click-application-menu', (event, id) => {
+    electron_1.ipcMain.on("integration-click-application-menu", (event, id) => {
         try {
             const menu = electron_1.Menu.getApplicationMenu();
             const mi = menu ? menu.getMenuItemById(id) : null;
-            if (mi && typeof mi.click === 'function') {
+            if (mi && typeof mi.click === "function") {
                 const bw = electron_1.BrowserWindow.fromWebContents(event.sender);
                 mi.click(undefined, bw, undefined);
             }
         }
-        catch { /* ignore */ }
+        catch {
+            /* ignore */
+        }
     });
-    electron_1.ipcMain.on('integration-click-context-menu', (event, windowId, id) => {
+    electron_1.ipcMain.on("integration-click-context-menu", (event, windowId, id) => {
         try {
-            const entries = global['contextMenuItems'] || [];
+            const entries = global["contextMenuItems"] || [];
             const entry = entries.find((x) => x.browserWindowId === windowId);
             const mi = entry?.menu?.items?.find((i) => i.id === id);
-            if (mi && typeof mi.click === 'function') {
+            if (mi && typeof mi.click === "function") {
                 const bw = electron_1.BrowserWindow.fromId(windowId);
                 mi.click(undefined, bw, undefined);
             }
         }
-        catch { /* ignore */ }
+        catch {
+            /* ignore */
+        }
     });
 };
 //# sourceMappingURL=ipc.js.map

src/ElectronNET.Host/api/ipc.js.map

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

src/ElectronNET.Host/api/ipc.ts

@@ -1,81 +1,118 @@
-import { ipcMain, BrowserWindow, BrowserView, Menu } from 'electron';
-import { Socket } from 'net';
-let electronSocket;
+import type { Socket } from "net";
+import { ipcMain, BrowserWindow, BrowserView, Menu } from "electron";
+
+let electronSocket: Socket;
 
 export = (socket: Socket) => {
-    electronSocket = socket;
-    socket.on('registerIpcMainChannel', (channel) => {
-        ipcMain.on(channel, (event, args) => {
-            electronSocket.emit(channel, [event.preventDefault(), args]);
+  electronSocket = socket;
+  socket.on("registerIpcMainChannel", (channel) => {
+    ipcMain.on(channel, (event, args) => {
+      electronSocket.emit(channel, [event.preventDefault(), args]);
+    });
+  });
+
+  socket.on("registerSyncIpcMainChannel", (channel) => {
+    ipcMain.on(channel, (event, args) => {
+      const x = <any>socket;
+      x.removeAllListeners(channel + "Sync");
+      socket.on(channel + "Sync", (result) => {
+        event.returnValue = result;
+      });
+
+      electronSocket.emit(channel, [event.preventDefault(), args]);
+    });
+  });
+
+  socket.on("registerOnceIpcMainChannel", (channel) => {
+    ipcMain.once(channel, (event, args) => {
+      electronSocket.emit(channel, [event.preventDefault(), args]);
+    });
+  });
+
+  socket.on("removeAllListenersIpcMainChannel", (channel) => {
+    ipcMain.removeAllListeners(channel);
+  });
+
+  socket.on("sendToIpcRenderer", (browserWindow, channel, data) => {
+    const window = BrowserWindow.fromId(browserWindow.id);
+
+    if (window) {
+      window.webContents.send(channel, ...data);
+    }
+  });
+
+  socket.on("sendToIpcRendererBrowserView", (id, channel, data) => {
+    const browserViews: BrowserView[] = (global["browserViews"] =
+      global["browserViews"] || []) as BrowserView[];
+    let view: BrowserView = null;
+    for (let i = 0; i < browserViews.length; i++) {
+      if (browserViews[i]["id"] === id) {
+        view = browserViews[i];
+        break;
+      }
+    }
+
+    if (view) {
+      view.webContents.send(channel, ...data);
+    }
+  });
+
+  socket.on("registerHandleIpcMainChannel", (channel) => {
+    ipcMain.handle(channel, (event, args) => {
+      return new Promise((resolve, _reject) => {
+        socket.removeAllListeners(channel + "Handle");
+        socket.on(channel + "Handle", (result) => {
+          resolve(result);
         });
+        electronSocket.emit(channel, [event.preventDefault(), args]);
+      });
     });
+  });
 
-    socket.on('registerSyncIpcMainChannel', (channel) => {
-        ipcMain.on(channel, (event, args) => {
-            const x = <any>socket;
-            x.removeAllListeners(channel + 'Sync');
-            socket.on(channel + 'Sync', (result) => {
-                event.returnValue = result;
-            });
-
-            electronSocket.emit(channel, [event.preventDefault(), args]);
+  socket.on("registerHandleOnceIpcMainChannel", (channel) => {
+    ipcMain.handleOnce(channel, (event, args) => {
+      return new Promise((resolve, _reject) => {
+        socket.removeAllListeners(channel + "HandleOnce");
+        socket.once(channel + "HandleOnce", (result) => {
+          resolve(result);
         });
+        electronSocket.emit(channel, [event.preventDefault(), args]);
+      });
     });
+  });
 
-    socket.on('registerOnceIpcMainChannel', (channel) => {
-        ipcMain.once(channel, (event, args) => {
-            electronSocket.emit(channel, [event.preventDefault(), args]);
-        });
-    });
+  socket.on("removeHandlerIpcMainChannel", (channel) => {
+    ipcMain.removeHandler(channel);
+  });
 
-    socket.on('removeAllListenersIpcMainChannel', (channel) => {
-        ipcMain.removeAllListeners(channel);
-    });
+  // Integration helpers: programmatically click menu items from renderer tests
+  ipcMain.on("integration-click-application-menu", (event, id: string) => {
+    try {
+      const menu = Menu.getApplicationMenu();
+      const mi = menu ? menu.getMenuItemById(id) : null;
+      if (mi && typeof (mi as any).click === "function") {
+        const bw = BrowserWindow.fromWebContents(event.sender);
+        (mi as any).click(undefined, bw, undefined);
+      }
+    } catch {
+      /* ignore */
+    }
+  });
 
-    socket.on('sendToIpcRenderer', (browserWindow, channel, data) => {
-        const window = BrowserWindow.fromId(browserWindow.id);
-
-        if (window) {
-            window.webContents.send(channel, ...data);
+  ipcMain.on(
+    "integration-click-context-menu",
+    (event, windowId: number, id: string) => {
+      try {
+        const entries = (global as any)["contextMenuItems"] || [];
+        const entry = entries.find((x: any) => x.browserWindowId === windowId);
+        const mi = entry?.menu?.items?.find((i: any) => i.id === id);
+        if (mi && typeof (mi as any).click === "function") {
+          const bw = BrowserWindow.fromId(windowId);
+          (mi as any).click(undefined, bw, undefined);
         }
-    });
-
-    socket.on('sendToIpcRendererBrowserView', (id, channel, data) => {
-        const browserViews: BrowserView[] = (global['browserViews'] = global['browserViews'] || []) as BrowserView[];
-        let view: BrowserView = null;
-        for (let i = 0; i < browserViews.length; i++) {
-            if (browserViews[i]['id'] === id) {
-                view = browserViews[i];
-                break;
-            }
-        }
-
-        if (view) {
-            view.webContents.send(channel, ...data);
-        }
-    });
-
-    // Integration helpers: programmatically click menu items from renderer tests
-    ipcMain.on('integration-click-application-menu', (event, id: string) => {
-        try {
-            const menu = Menu.getApplicationMenu();
-            const mi = menu ? menu.getMenuItemById(id) : null;
-            if (mi && typeof (mi as any).click === 'function') {
-                const bw = BrowserWindow.fromWebContents(event.sender);
-                (mi as any).click(undefined, bw, undefined);
-            }
-        } catch { /* ignore */ }
-    });
-
-    ipcMain.on('integration-click-context-menu', (event, windowId: number, id: string) => {
-        try {
-            const entries = (global as any)['contextMenuItems'] || [];
-            const entry = entries.find((x: any) => x.browserWindowId === windowId);
-            const mi = entry?.menu?.items?.find((i: any) => i.id === id);
-            if (mi && typeof (mi as any).click === 'function') {
-                const bw = BrowserWindow.fromId(windowId);
-                (mi as any).click(undefined, bw, undefined);
-            }
-        } catch { /* ignore */ }
-    });
+      } catch {
+        /* ignore */
+      }
+    },
+  );
 };

src/ElectronNET.Host/api/menu.js

@@ -1,18 +1,19 @@
 "use strict";
 const electron_1 = require("electron");
-const contextMenuItems = (global['contextMenuItems'] = global['contextMenuItems'] || []);
+const contextMenuItems = (global["contextMenuItems"] =
+    global["contextMenuItems"] || []);
 let electronSocket;
 module.exports = (socket) => {
     electronSocket = socket;
-    socket.on('menu-setContextMenu', (browserWindowId, menuItems) => {
+    socket.on("menu-setContextMenu", (browserWindowId, menuItems) => {
         const menu = electron_1.Menu.buildFromTemplate(menuItems);
         addContextMenuItemClickConnector(menu.items, browserWindowId, (id, windowId) => {
-            electronSocket.emit('contextMenuItemClicked', [id, windowId]);
+            electronSocket.emit("contextMenuItemClicked", [id, windowId]);
         });
-        const index = contextMenuItems.findIndex(contextMenu => contextMenu.browserWindowId === browserWindowId);
+        const index = contextMenuItems.findIndex((contextMenu) => contextMenu.browserWindowId === browserWindowId);
         const contextMenuItem = {
             menu: menu,
-            browserWindowId: browserWindowId
+            browserWindowId: browserWindowId,
         };
         if (index === -1) {
             contextMenuItems.push(contextMenuItem);
@@ -26,23 +27,25 @@ module.exports = (socket) => {
             if (item.submenu && item.submenu.items.length > 0) {
                 addContextMenuItemClickConnector(item.submenu.items, browserWindowId, callback);
             }
-            if ('id' in item && item.id) {
-                item.click = () => { callback(item.id, browserWindowId); };
+            if ("id" in item && item.id) {
+                item.click = () => {
+                    callback(item.id, browserWindowId);
+                };
             }
         });
     }
-    socket.on('menu-contextMenuPopup', (browserWindowId) => {
-        contextMenuItems.forEach(x => {
+    socket.on("menu-contextMenuPopup", (browserWindowId) => {
+        contextMenuItems.forEach((x) => {
             if (x.browserWindowId === browserWindowId) {
                 const browserWindow = electron_1.BrowserWindow.fromId(browserWindowId);
                 x.menu.popup(browserWindow);
             }
         });
     });
-    socket.on('menu-setApplicationMenu', (menuItems) => {
+    socket.on("menu-setApplicationMenu", (menuItems) => {
         const menu = electron_1.Menu.buildFromTemplate(menuItems);
         addMenuItemClickConnector(menu.items, (id) => {
-            electronSocket.emit('menuItemClicked', id);
+            electronSocket.emit("menuItemClicked", id);
         });
         electron_1.Menu.setApplicationMenu(menu);
     });
@@ -51,8 +54,10 @@ module.exports = (socket) => {
             if (item.submenu && item.submenu.items.length > 0) {
                 addMenuItemClickConnector(item.submenu.items, callback);
             }
-            if ('id' in item && item.id) {
-                item.click = () => { callback(item.id); };
+            if ("id" in item && item.id) {
+                item.click = () => {
+                    callback(item.id);
+                };
             }
         });
     }

src/ElectronNET.Host/api/menu.js.map

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

src/ElectronNET.Host/api/menu.ts

@@ -1,71 +1,92 @@
-import { Socket } from 'net';
-import { Menu, BrowserWindow } from 'electron';
-const contextMenuItems = (global['contextMenuItems'] = global['contextMenuItems'] || []);
-let electronSocket;
+import type { Socket } from "net";
+import { Menu, BrowserWindow } from "electron";
+
+const contextMenuItems = (global["contextMenuItems"] =
+  global["contextMenuItems"] || []);
+
+let electronSocket: Socket;
 
 export = (socket: Socket) => {
-    electronSocket = socket;
-    socket.on('menu-setContextMenu', (browserWindowId, menuItems) => {
-        const menu = Menu.buildFromTemplate(menuItems);
+  electronSocket = socket;
+  socket.on("menu-setContextMenu", (browserWindowId, menuItems) => {
+    const menu = Menu.buildFromTemplate(menuItems);
 
-        addContextMenuItemClickConnector(menu.items, browserWindowId, (id, windowId) => {
-            electronSocket.emit('contextMenuItemClicked', [id, windowId]);
-        });
+    addContextMenuItemClickConnector(
+      menu.items,
+      browserWindowId,
+      (id, windowId) => {
+        electronSocket.emit("contextMenuItemClicked", [id, windowId]);
+      },
+    );
 
-        const index = contextMenuItems.findIndex(contextMenu => contextMenu.browserWindowId === browserWindowId);
+    const index = contextMenuItems.findIndex(
+      (contextMenu) => contextMenu.browserWindowId === browserWindowId,
+    );
 
-        const contextMenuItem = {
-            menu: menu,
-            browserWindowId: browserWindowId
+    const contextMenuItem = {
+      menu: menu,
+      browserWindowId: browserWindowId,
+    };
+
+    if (index === -1) {
+      contextMenuItems.push(contextMenuItem);
+    } else {
+      contextMenuItems[index] = contextMenuItem;
+    }
+  });
+
+  function addContextMenuItemClickConnector(
+    menuItems,
+    browserWindowId,
+    callback,
+  ) {
+    menuItems.forEach((item) => {
+      if (item.submenu && item.submenu.items.length > 0) {
+        addContextMenuItemClickConnector(
+          item.submenu.items,
+          browserWindowId,
+          callback,
+        );
+      }
+
+      if ("id" in item && item.id) {
+        item.click = () => {
+          callback(item.id, browserWindowId);
         };
+      }
+    });
+  }
 
-        if (index === -1) {
-            contextMenuItems.push(contextMenuItem);
-        } else {
-            contextMenuItems[index] = contextMenuItem;
-        }
+  socket.on("menu-contextMenuPopup", (browserWindowId) => {
+    contextMenuItems.forEach((x) => {
+      if (x.browserWindowId === browserWindowId) {
+        const browserWindow = BrowserWindow.fromId(browserWindowId);
+        x.menu.popup(browserWindow);
+      }
+    });
+  });
+
+  socket.on("menu-setApplicationMenu", (menuItems) => {
+    const menu = Menu.buildFromTemplate(menuItems);
+
+    addMenuItemClickConnector(menu.items, (id) => {
+      electronSocket.emit("menuItemClicked", id);
     });
 
-    function addContextMenuItemClickConnector(menuItems, browserWindowId, callback) {
-        menuItems.forEach((item) => {
-            if (item.submenu && item.submenu.items.length > 0) {
-                addContextMenuItemClickConnector(item.submenu.items, browserWindowId, callback);
-            }
+    Menu.setApplicationMenu(menu);
+  });
 
-            if ('id' in item && item.id) {
-                item.click = () => { callback(item.id, browserWindowId); };
-            }
-        });
-    }
+  function addMenuItemClickConnector(menuItems, callback) {
+    menuItems.forEach((item) => {
+      if (item.submenu && item.submenu.items.length > 0) {
+        addMenuItemClickConnector(item.submenu.items, callback);
+      }
 
-    socket.on('menu-contextMenuPopup', (browserWindowId) => {
-        contextMenuItems.forEach(x => {
-            if (x.browserWindowId === browserWindowId) {
-                const browserWindow = BrowserWindow.fromId(browserWindowId);
-                x.menu.popup(browserWindow);
-            }
-        });
+      if ("id" in item && item.id) {
+        item.click = () => {
+          callback(item.id);
+        };
+      }
     });
-
-    socket.on('menu-setApplicationMenu', (menuItems) => {
-        const menu = Menu.buildFromTemplate(menuItems);
-
-        addMenuItemClickConnector(menu.items, (id) => {
-            electronSocket.emit('menuItemClicked', id);
-        });
-
-        Menu.setApplicationMenu(menu);
-    });
-
-    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); };
-            }
-        });
-    }
+  }
 };

src/ElectronNET.Host/api/nativeTheme.js

@@ -3,28 +3,28 @@ const electron_1 = require("electron");
 let electronSocket;
 module.exports = (socket) => {
     electronSocket = socket;
-    socket.on('nativeTheme-shouldUseDarkColors', () => {
+    socket.on("nativeTheme-shouldUseDarkColors", () => {
         const shouldUseDarkColors = electron_1.nativeTheme.shouldUseDarkColors;
-        electronSocket.emit('nativeTheme-shouldUseDarkColors-completed', shouldUseDarkColors);
+        electronSocket.emit("nativeTheme-shouldUseDarkColors-completed", shouldUseDarkColors);
     });
-    socket.on('nativeTheme-shouldUseHighContrastColors', () => {
+    socket.on("nativeTheme-shouldUseHighContrastColors", () => {
         const shouldUseHighContrastColors = electron_1.nativeTheme.shouldUseHighContrastColors;
-        electronSocket.emit('nativeTheme-shouldUseHighContrastColors-completed', shouldUseHighContrastColors);
+        electronSocket.emit("nativeTheme-shouldUseHighContrastColors-completed", shouldUseHighContrastColors);
     });
-    socket.on('nativeTheme-shouldUseInvertedColorScheme', () => {
+    socket.on("nativeTheme-shouldUseInvertedColorScheme", () => {
         const shouldUseInvertedColorScheme = electron_1.nativeTheme.shouldUseInvertedColorScheme;
-        electronSocket.emit('nativeTheme-shouldUseInvertedColorScheme-completed', shouldUseInvertedColorScheme);
+        electronSocket.emit("nativeTheme-shouldUseInvertedColorScheme-completed", shouldUseInvertedColorScheme);
     });
-    socket.on('nativeTheme-getThemeSource', () => {
+    socket.on("nativeTheme-getThemeSource", () => {
         const themeSource = electron_1.nativeTheme.themeSource;
-        electronSocket.emit('nativeTheme-getThemeSource-completed', themeSource);
+        electronSocket.emit("nativeTheme-getThemeSource-completed", themeSource);
     });
-    socket.on('nativeTheme-themeSource', (themeSource) => {
+    socket.on("nativeTheme-themeSource", (themeSource) => {
         electron_1.nativeTheme.themeSource = themeSource;
     });
-    socket.on('register-nativeTheme-updated', (id) => {
-        electron_1.nativeTheme.on('updated', () => {
-            electronSocket.emit('nativeTheme-updated' + id);
+    socket.on("register-nativeTheme-updated", (id) => {
+        electron_1.nativeTheme.on("updated", () => {
+            electronSocket.emit("nativeTheme-updated" + id);
         });
     });
 };

src/ElectronNET.Host/api/nativeTheme.js.map

@@ -1 +1 @@
-{"version":3,"file":"nativeTheme.js","sourceRoot":"","sources":["nativeTheme.ts"],"names":[],"mappings":";AACA,uCAAuC;AACvC,IAAI,cAAc,CAAC;AAEnB,iBAAS,CAAC,MAAc,EAAE,EAAE;IACxB,cAAc,GAAG,MAAM,CAAC;IAExB,MAAM,CAAC,EAAE,CAAC,iCAAiC,EAAE,GAAG,EAAE;QAC9C,MAAM,mBAAmB,GAAG,sBAAW,CAAC,mBAAmB,CAAC;QAE5D,cAAc,CAAC,IAAI,CAAC,2CAA2C,EAAE,mBAAmB,CAAC,CAAC;IAC1F,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,yCAAyC,EAAE,GAAG,EAAE;QACtD,MAAM,2BAA2B,GAAG,sBAAW,CAAC,2BAA2B,CAAC;QAE5E,cAAc,CAAC,IAAI,CAAC,mDAAmD,EAAE,2BAA2B,CAAC,CAAC;IAC1G,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,0CAA0C,EAAE,GAAG,EAAE;QACvD,MAAM,4BAA4B,GAAG,sBAAW,CAAC,4BAA4B,CAAC;QAE9E,cAAc,CAAC,IAAI,CAAC,oDAAoD,EAAE,4BAA4B,CAAC,CAAC;IAC5G,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,4BAA4B,EAAE,GAAG,EAAE;QACzC,MAAM,WAAW,GAAG,sBAAW,CAAC,WAAW,CAAC;QAE5C,cAAc,CAAC,IAAI,CAAC,sCAAsC,EAAE,WAAW,CAAC,CAAC;IAC7E,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,yBAAyB,EAAE,CAAC,WAAW,EAAE,EAAE;QACjD,sBAAW,CAAC,WAAW,GAAG,WAAW,CAAC;IAC1C,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,8BAA8B,EAAE,CAAC,EAAE,EAAE,EAAE;QAC7C,sBAAW,CAAC,EAAE,CAAC,SAAS,EAAE,GAAG,EAAE;YAC3B,cAAc,CAAC,IAAI,CAAC,qBAAqB,GAAG,EAAE,CAAC,CAAC;QACpD,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;AACP,CAAC,CAAC"}
+{"version":3,"file":"nativeTheme.js","sourceRoot":"","sources":["nativeTheme.ts"],"names":[],"mappings":";AACA,uCAAuC;AAEvC,IAAI,cAAsB,CAAC;AAE3B,iBAAS,CAAC,MAAc,EAAE,EAAE;IAC1B,cAAc,GAAG,MAAM,CAAC;IAExB,MAAM,CAAC,EAAE,CAAC,iCAAiC,EAAE,GAAG,EAAE;QAChD,MAAM,mBAAmB,GAAG,sBAAW,CAAC,mBAAmB,CAAC;QAE5D,cAAc,CAAC,IAAI,CACjB,2CAA2C,EAC3C,mBAAmB,CACpB,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,yCAAyC,EAAE,GAAG,EAAE;QACxD,MAAM,2BAA2B,GAAG,sBAAW,CAAC,2BAA2B,CAAC;QAE5E,cAAc,CAAC,IAAI,CACjB,mDAAmD,EACnD,2BAA2B,CAC5B,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,0CAA0C,EAAE,GAAG,EAAE;QACzD,MAAM,4BAA4B,GAChC,sBAAW,CAAC,4BAA4B,CAAC;QAE3C,cAAc,CAAC,IAAI,CACjB,oDAAoD,EACpD,4BAA4B,CAC7B,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,4BAA4B,EAAE,GAAG,EAAE;QAC3C,MAAM,WAAW,GAAG,sBAAW,CAAC,WAAW,CAAC;QAE5C,cAAc,CAAC,IAAI,CAAC,sCAAsC,EAAE,WAAW,CAAC,CAAC;IAC3E,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,yBAAyB,EAAE,CAAC,WAAW,EAAE,EAAE;QACnD,sBAAW,CAAC,WAAW,GAAG,WAAW,CAAC;IACxC,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,8BAA8B,EAAE,CAAC,EAAE,EAAE,EAAE;QAC/C,sBAAW,CAAC,EAAE,CAAC,SAAS,EAAE,GAAG,EAAE;YAC7B,cAAc,CAAC,IAAI,CAAC,qBAAqB,GAAG,EAAE,CAAC,CAAC;QAClD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC"}

src/ElectronNET.Host/api/nativeTheme.ts

@@ -1,41 +1,52 @@
-import { Socket } from 'net';
-import { nativeTheme } from 'electron';
-let electronSocket;
+import type { Socket } from "net";
+import { nativeTheme } from "electron";
+
+let electronSocket: Socket;
 
 export = (socket: Socket) => {
-    electronSocket = socket;
+  electronSocket = socket;
 
-    socket.on('nativeTheme-shouldUseDarkColors', () => {
-        const shouldUseDarkColors = nativeTheme.shouldUseDarkColors;
+  socket.on("nativeTheme-shouldUseDarkColors", () => {
+    const shouldUseDarkColors = nativeTheme.shouldUseDarkColors;
 
-        electronSocket.emit('nativeTheme-shouldUseDarkColors-completed', shouldUseDarkColors);
-    });
-
-    socket.on('nativeTheme-shouldUseHighContrastColors', () => {
-        const shouldUseHighContrastColors = nativeTheme.shouldUseHighContrastColors;
-
-        electronSocket.emit('nativeTheme-shouldUseHighContrastColors-completed', shouldUseHighContrastColors);
-    });
-
-    socket.on('nativeTheme-shouldUseInvertedColorScheme', () => {
-        const shouldUseInvertedColorScheme = nativeTheme.shouldUseInvertedColorScheme;
-
-        electronSocket.emit('nativeTheme-shouldUseInvertedColorScheme-completed', shouldUseInvertedColorScheme);
-    });
-
-    socket.on('nativeTheme-getThemeSource', () => {
-        const themeSource = nativeTheme.themeSource;
-
-        electronSocket.emit('nativeTheme-getThemeSource-completed', themeSource);
-    });
-
-    socket.on('nativeTheme-themeSource', (themeSource) => {
-        nativeTheme.themeSource = themeSource;
-    });
-
-    socket.on('register-nativeTheme-updated', (id) => {
-        nativeTheme.on('updated', () => {
-            electronSocket.emit('nativeTheme-updated' + id);
-        });
+    electronSocket.emit(
+      "nativeTheme-shouldUseDarkColors-completed",
+      shouldUseDarkColors,
+    );
+  });
+
+  socket.on("nativeTheme-shouldUseHighContrastColors", () => {
+    const shouldUseHighContrastColors = nativeTheme.shouldUseHighContrastColors;
+
+    electronSocket.emit(
+      "nativeTheme-shouldUseHighContrastColors-completed",
+      shouldUseHighContrastColors,
+    );
+  });
+
+  socket.on("nativeTheme-shouldUseInvertedColorScheme", () => {
+    const shouldUseInvertedColorScheme =
+      nativeTheme.shouldUseInvertedColorScheme;
+
+    electronSocket.emit(
+      "nativeTheme-shouldUseInvertedColorScheme-completed",
+      shouldUseInvertedColorScheme,
+    );
+  });
+
+  socket.on("nativeTheme-getThemeSource", () => {
+    const themeSource = nativeTheme.themeSource;
+
+    electronSocket.emit("nativeTheme-getThemeSource-completed", themeSource);
+  });
+
+  socket.on("nativeTheme-themeSource", (themeSource) => {
+    nativeTheme.themeSource = themeSource;
+  });
+
+  socket.on("register-nativeTheme-updated", (id) => {
+    nativeTheme.on("updated", () => {
+      electronSocket.emit("nativeTheme-updated" + id);
     });
+  });
 };

src/ElectronNET.Host/api/notification.js

@@ -1,40 +1,44 @@
 "use strict";
 const electron_1 = require("electron");
-const notifications = (global['notifications'] = global['notifications'] || []);
+const notifications = (global["notifications"] =
+    global["notifications"] || []);
 let electronSocket;
 module.exports = (socket) => {
     electronSocket = socket;
-    socket.on('createNotification', (options) => {
+    socket.on("createNotification", (options) => {
         const notification = new electron_1.Notification(options);
         let haveEvent = false;
         if (options.showID) {
             haveEvent = true;
-            notification.on('show', () => {
-                electronSocket.emit('NotificationEventShow', options.showID);
+            notification.on("show", () => {
+                electronSocket.emit("NotificationEventShow", options.showID);
             });
         }
         if (options.clickID) {
             haveEvent = true;
-            notification.on('click', () => {
-                electronSocket.emit('NotificationEventClick', options.clickID);
+            notification.on("click", () => {
+                electronSocket.emit("NotificationEventClick", options.clickID);
             });
         }
         if (options.closeID) {
             haveEvent = true;
-            notification.on('close', () => {
-                electronSocket.emit('NotificationEventClose', options.closeID);
+            notification.on("close", () => {
+                electronSocket.emit("NotificationEventClose", options.closeID);
             });
         }
         if (options.replyID) {
             haveEvent = true;
-            notification.on('reply', (event, value) => {
-                electronSocket.emit('NotificationEventReply', [options.replyID, value]);
+            notification.on("reply", (event, value) => {
+                electronSocket.emit("NotificationEventReply", [options.replyID, value]);
             });
         }
         if (options.actionID) {
             haveEvent = true;
-            notification.on('action', (event, value) => {
-                electronSocket.emit('NotificationEventAction', [options.actionID, value]);
+            notification.on("action", (event, value) => {
+                electronSocket.emit("NotificationEventAction", [
+                    options.actionID,
+                    value,
+                ]);
             });
         }
         if (haveEvent) {
@@ -42,9 +46,9 @@ module.exports = (socket) => {
         }
         notification.show();
     });
-    socket.on('notificationIsSupported', () => {
+    socket.on("notificationIsSupported", () => {
         const isSupported = electron_1.Notification.isSupported();
-        electronSocket.emit('notificationIsSupportedCompleted', isSupported);
+        electronSocket.emit("notificationIsSupportedCompleted", isSupported);
     });
 };
 //# sourceMappingURL=notification.js.map

src/ElectronNET.Host/api/notification.js.map

@@ -1 +1 @@
-{"version":3,"file":"notification.js","sourceRoot":"","sources":["notification.ts"],"names":[],"mappings":";AACA,uCAAwC;AACxC,MAAM,aAAa,GAA4B,CAAC,MAAM,CAAC,eAAe,CAAC,GAAG,MAAM,CAAC,eAAe,CAAC,IAAI,EAAE,CAA4B,CAAC;AACpI,IAAI,cAAc,CAAC;AAEnB,iBAAS,CAAC,MAAc,EAAE,EAAE;IACxB,cAAc,GAAG,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,CAAC,oBAAoB,EAAE,CAAC,OAAO,EAAE,EAAE;QACxC,MAAM,YAAY,GAAG,IAAI,uBAAY,CAAC,OAAO,CAAC,CAAC;QAC/C,IAAI,SAAS,GAAG,KAAK,CAAC;QAEtB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;YACjB,SAAS,GAAG,IAAI,CAAC;YACjB,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE;gBACzB,cAAc,CAAC,IAAI,CAAC,uBAAuB,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;YACjE,CAAC,CAAC,CAAC;QACP,CAAC;QAED,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;YAClB,SAAS,GAAG,IAAI,CAAC;YACjB,YAAY,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE;gBAC1B,cAAc,CAAC,IAAI,CAAC,wBAAwB,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;YACnE,CAAC,CAAC,CAAC;QACP,CAAC;QAED,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;YAClB,SAAS,GAAG,IAAI,CAAC;YACjB,YAAY,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE;gBAC1B,cAAc,CAAC,IAAI,CAAC,wBAAwB,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;YACnE,CAAC,CAAC,CAAC;QACP,CAAC;QAED,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;YAClB,SAAS,GAAG,IAAI,CAAC;YACjB,YAAY,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;gBACtC,cAAc,CAAC,IAAI,CAAC,wBAAwB,EAAE,CAAC,OAAO,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC;YAC5E,CAAC,CAAC,CAAC;QACP,CAAC;QAED,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;YACnB,SAAS,GAAG,IAAI,CAAC;YACjB,YAAY,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;gBACvC,cAAc,CAAC,IAAI,CAAC,yBAAyB,EAAE,CAAC,OAAO,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC,CAAC;YAC9E,CAAC,CAAC,CAAC;QACP,CAAC;QAED,IAAI,SAAS,EAAE,CAAC;YACZ,aAAa,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACrC,CAAC;QAED,YAAY,CAAC,IAAI,EAAE,CAAC;IACxB,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,yBAAyB,EAAE,GAAG,EAAE;QACtC,MAAM,WAAW,GAAG,uBAAY,CAAC,WAAW,EAAE,CAAC;QAC/C,cAAc,CAAC,IAAI,CAAC,kCAAkC,EAAE,WAAW,CAAC,CAAC;IACzE,CAAC,CAAC,CAAC;AACP,CAAC,CAAC"}
+{"version":3,"file":"notification.js","sourceRoot":"","sources":["notification.ts"],"names":[],"mappings":";AACA,uCAAwC;AAExC,MAAM,aAAa,GAA4B,CAAC,MAAM,CAAC,eAAe,CAAC;IACrE,MAAM,CAAC,eAAe,CAAC,IAAI,EAAE,CAA4B,CAAC;AAE5D,IAAI,cAAsB,CAAC;AAE3B,iBAAS,CAAC,MAAc,EAAE,EAAE;IAC1B,cAAc,GAAG,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,CAAC,oBAAoB,EAAE,CAAC,OAAO,EAAE,EAAE;QAC1C,MAAM,YAAY,GAAG,IAAI,uBAAY,CAAC,OAAO,CAAC,CAAC;QAC/C,IAAI,SAAS,GAAG,KAAK,CAAC;QAEtB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;YACnB,SAAS,GAAG,IAAI,CAAC;YACjB,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE;gBAC3B,cAAc,CAAC,IAAI,CAAC,uBAAuB,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;YAC/D,CAAC,CAAC,CAAC;QACL,CAAC;QAED,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;YACpB,SAAS,GAAG,IAAI,CAAC;YACjB,YAAY,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE;gBAC5B,cAAc,CAAC,IAAI,CAAC,wBAAwB,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;YACjE,CAAC,CAAC,CAAC;QACL,CAAC;QAED,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;YACpB,SAAS,GAAG,IAAI,CAAC;YACjB,YAAY,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE;gBAC5B,cAAc,CAAC,IAAI,CAAC,wBAAwB,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;YACjE,CAAC,CAAC,CAAC;QACL,CAAC;QAED,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;YACpB,SAAS,GAAG,IAAI,CAAC;YACjB,YAAY,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;gBACxC,cAAc,CAAC,IAAI,CAAC,wBAAwB,EAAE,CAAC,OAAO,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC;YAC1E,CAAC,CAAC,CAAC;QACL,CAAC;QAED,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;YACrB,SAAS,GAAG,IAAI,CAAC;YACjB,YAAY,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;gBACzC,cAAc,CAAC,IAAI,CAAC,yBAAyB,EAAE;oBAC7C,OAAO,CAAC,QAAQ;oBAChB,KAAK;iBACN,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;QACL,CAAC;QAED,IAAI,SAAS,EAAE,CAAC;YACd,aAAa,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACnC,CAAC;QAED,YAAY,CAAC,IAAI,EAAE,CAAC;IACtB,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,yBAAyB,EAAE,GAAG,EAAE;QACxC,MAAM,WAAW,GAAG,uBAAY,CAAC,WAAW,EAAE,CAAC;QAC/C,cAAc,CAAC,IAAI,CAAC,kCAAkC,EAAE,WAAW,CAAC,CAAC;IACvE,CAAC,CAAC,CAAC;AACL,CAAC,CAAC"}

src/ElectronNET.Host/api/notification.ts

@@ -1,58 +1,64 @@
-import { Socket } from 'net';
-import { Notification } from 'electron';
-const notifications: Electron.Notification[] = (global['notifications'] = global['notifications'] || []) as Electron.Notification[];
-let electronSocket;
+import type { Socket } from "net";
+import { Notification } from "electron";
+
+const notifications: Electron.Notification[] = (global["notifications"] =
+  global["notifications"] || []) as Electron.Notification[];
+
+let electronSocket: Socket;
 
 export = (socket: Socket) => {
-    electronSocket = socket;
-    socket.on('createNotification', (options) => {
-        const notification = new Notification(options);
-        let haveEvent = false;
+  electronSocket = socket;
+  socket.on("createNotification", (options) => {
+    const notification = new Notification(options);
+    let haveEvent = false;
 
-        if (options.showID) {
-            haveEvent = true;
-            notification.on('show', () => {
-                electronSocket.emit('NotificationEventShow', options.showID);
-            });
-        }
+    if (options.showID) {
+      haveEvent = true;
+      notification.on("show", () => {
+        electronSocket.emit("NotificationEventShow", options.showID);
+      });
+    }
 
-        if (options.clickID) {
-            haveEvent = true;
-            notification.on('click', () => {
-                electronSocket.emit('NotificationEventClick', options.clickID);
-            });
-        }
+    if (options.clickID) {
+      haveEvent = true;
+      notification.on("click", () => {
+        electronSocket.emit("NotificationEventClick", options.clickID);
+      });
+    }
 
-        if (options.closeID) {
-            haveEvent = true;
-            notification.on('close', () => {
-                electronSocket.emit('NotificationEventClose', options.closeID);
-            });
-        }
+    if (options.closeID) {
+      haveEvent = true;
+      notification.on("close", () => {
+        electronSocket.emit("NotificationEventClose", options.closeID);
+      });
+    }
 
-        if (options.replyID) {
-            haveEvent = true;
-            notification.on('reply', (event, value) => {
-                electronSocket.emit('NotificationEventReply', [options.replyID, value]);
-            });
-        }
+    if (options.replyID) {
+      haveEvent = true;
+      notification.on("reply", (event, value) => {
+        electronSocket.emit("NotificationEventReply", [options.replyID, value]);
+      });
+    }
 
-        if (options.actionID) {
-            haveEvent = true;
-            notification.on('action', (event, value) => {
-                electronSocket.emit('NotificationEventAction', [options.actionID, value]);
-            });
-        }
+    if (options.actionID) {
+      haveEvent = true;
+      notification.on("action", (event, value) => {
+        electronSocket.emit("NotificationEventAction", [
+          options.actionID,
+          value,
+        ]);
+      });
+    }
 
-        if (haveEvent) {
-            notifications.push(notification);
-        }
+    if (haveEvent) {
+      notifications.push(notification);
+    }
 
-        notification.show();
-    });
+    notification.show();
+  });
 
-    socket.on('notificationIsSupported', () => {
-        const isSupported = Notification.isSupported();
-        electronSocket.emit('notificationIsSupportedCompleted', isSupported);
-    });
+  socket.on("notificationIsSupported", () => {
+    const isSupported = Notification.isSupported();
+    electronSocket.emit("notificationIsSupportedCompleted", isSupported);
+  });
 };

src/ElectronNET.Host/api/powerMonitor.js

@@ -3,39 +3,39 @@ const electron_1 = require("electron");
 let electronSocket;
 module.exports = (socket) => {
     electronSocket = socket;
-    socket.on('register-powerMonitor-lock-screen', () => {
-        electron_1.powerMonitor.on('lock-screen', () => {
-            electronSocket.emit('powerMonitor-lock-screen');
+    socket.on("register-powerMonitor-lock-screen", () => {
+        electron_1.powerMonitor.on("lock-screen", () => {
+            electronSocket.emit("powerMonitor-lock-screen");
         });
     });
-    socket.on('register-powerMonitor-unlock-screen', () => {
-        electron_1.powerMonitor.on('unlock-screen', () => {
-            electronSocket.emit('powerMonitor-unlock-screen');
+    socket.on("register-powerMonitor-unlock-screen", () => {
+        electron_1.powerMonitor.on("unlock-screen", () => {
+            electronSocket.emit("powerMonitor-unlock-screen");
         });
     });
-    socket.on('register-powerMonitor-suspend', () => {
-        electron_1.powerMonitor.on('suspend', () => {
-            electronSocket.emit('powerMonitor-suspend');
+    socket.on("register-powerMonitor-suspend", () => {
+        electron_1.powerMonitor.on("suspend", () => {
+            electronSocket.emit("powerMonitor-suspend");
         });
     });
-    socket.on('register-powerMonitor-resume', () => {
-        electron_1.powerMonitor.on('resume', () => {
-            electronSocket.emit('powerMonitor-resume');
+    socket.on("register-powerMonitor-resume", () => {
+        electron_1.powerMonitor.on("resume", () => {
+            electronSocket.emit("powerMonitor-resume");
         });
     });
-    socket.on('register-powerMonitor-ac', () => {
-        electron_1.powerMonitor.on('on-ac', () => {
-            electronSocket.emit('powerMonitor-ac');
+    socket.on("register-powerMonitor-ac", () => {
+        electron_1.powerMonitor.on("on-ac", () => {
+            electronSocket.emit("powerMonitor-ac");
         });
     });
-    socket.on('register-powerMonitor-battery', () => {
-        electron_1.powerMonitor.on('on-battery', () => {
-            electronSocket.emit('powerMonitor-battery');
+    socket.on("register-powerMonitor-battery", () => {
+        electron_1.powerMonitor.on("on-battery", () => {
+            electronSocket.emit("powerMonitor-battery");
         });
     });
-    socket.on('register-powerMonitor-shutdown', () => {
-        electron_1.powerMonitor.on('shutdown', () => {
-            electronSocket.emit('powerMonitor-shutdown');
+    socket.on("register-powerMonitor-shutdown", () => {
+        electron_1.powerMonitor.on("shutdown", () => {
+            electronSocket.emit("powerMonitor-shutdown");
         });
     });
 };

src/ElectronNET.Host/api/powerMonitor.js.map

@@ -1 +1 @@
-{"version":3,"file":"powerMonitor.js","sourceRoot":"","sources":["powerMonitor.ts"],"names":[],"mappings":";AACA,uCAAwC;AACxC,IAAI,cAAc,CAAC;AAEnB,iBAAS,CAAC,MAAc,EAAE,EAAE;IACxB,cAAc,GAAG,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,CAAC,mCAAmC,EAAE,GAAG,EAAE;QAChD,uBAAY,CAAC,EAAE,CAAC,aAAa,EAAE,GAAG,EAAE;YAChC,cAAc,CAAC,IAAI,CAAC,0BAA0B,CAAC,CAAC;QACpD,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IACH,MAAM,CAAC,EAAE,CAAC,qCAAqC,EAAE,GAAG,EAAE;QAClD,uBAAY,CAAC,EAAE,CAAC,eAAe,EAAE,GAAG,EAAE;YAClC,cAAc,CAAC,IAAI,CAAC,4BAA4B,CAAC,CAAC;QACtD,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IACH,MAAM,CAAC,EAAE,CAAC,+BAA+B,EAAE,GAAG,EAAE;QAC5C,uBAAY,CAAC,EAAE,CAAC,SAAS,EAAE,GAAG,EAAE;YAC5B,cAAc,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC;QAChD,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IACH,MAAM,CAAC,EAAE,CAAC,8BAA8B,EAAE,GAAG,EAAE;QAC3C,uBAAY,CAAC,EAAE,CAAC,QAAQ,EAAE,GAAG,EAAE;YAC3B,cAAc,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;QAC/C,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IACH,MAAM,CAAC,EAAE,CAAC,0BAA0B,EAAE,GAAG,EAAE;QACvC,uBAAY,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE;YAC1B,cAAc,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;QAC3C,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IACH,MAAM,CAAC,EAAE,CAAC,+BAA+B,EAAE,GAAG,EAAE;QAC5C,uBAAY,CAAC,EAAE,CAAC,YAAY,EAAE,GAAG,EAAE;YAC/B,cAAc,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC;QAChD,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IACH,MAAM,CAAC,EAAE,CAAC,gCAAgC,EAAE,GAAG,EAAE;QAC7C,uBAAY,CAAC,EAAE,CAAC,UAAU,EAAE,GAAG,EAAE;YAC7B,cAAc,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC;QACjD,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;AACP,CAAC,CAAC"}
+{"version":3,"file":"powerMonitor.js","sourceRoot":"","sources":["powerMonitor.ts"],"names":[],"mappings":";AACA,uCAAwC;AAExC,IAAI,cAAsB,CAAC;AAE3B,iBAAS,CAAC,MAAc,EAAE,EAAE;IAC1B,cAAc,GAAG,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,CAAC,mCAAmC,EAAE,GAAG,EAAE;QAClD,uBAAY,CAAC,EAAE,CAAC,aAAa,EAAE,GAAG,EAAE;YAClC,cAAc,CAAC,IAAI,CAAC,0BAA0B,CAAC,CAAC;QAClD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IACH,MAAM,CAAC,EAAE,CAAC,qCAAqC,EAAE,GAAG,EAAE;QACpD,uBAAY,CAAC,EAAE,CAAC,eAAe,EAAE,GAAG,EAAE;YACpC,cAAc,CAAC,IAAI,CAAC,4BAA4B,CAAC,CAAC;QACpD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IACH,MAAM,CAAC,EAAE,CAAC,+BAA+B,EAAE,GAAG,EAAE;QAC9C,uBAAY,CAAC,EAAE,CAAC,SAAS,EAAE,GAAG,EAAE;YAC9B,cAAc,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC;QAC9C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IACH,MAAM,CAAC,EAAE,CAAC,8BAA8B,EAAE,GAAG,EAAE;QAC7C,uBAAY,CAAC,EAAE,CAAC,QAAQ,EAAE,GAAG,EAAE;YAC7B,cAAc,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;QAC7C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IACH,MAAM,CAAC,EAAE,CAAC,0BAA0B,EAAE,GAAG,EAAE;QACzC,uBAAY,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE;YAC5B,cAAc,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;QACzC,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IACH,MAAM,CAAC,EAAE,CAAC,+BAA+B,EAAE,GAAG,EAAE;QAC9C,uBAAY,CAAC,EAAE,CAAC,YAAY,EAAE,GAAG,EAAE;YACjC,cAAc,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC;QAC9C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IACH,MAAM,CAAC,EAAE,CAAC,gCAAgC,EAAE,GAAG,EAAE;QAC/C,uBAAY,CAAC,EAAE,CAAC,UAAU,EAAE,GAAG,EAAE;YAC/B,cAAc,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC;QAC/C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC"}

src/ElectronNET.Host/api/powerMonitor.ts

@@ -1,42 +1,43 @@
-import { Socket } from 'net';
-import { powerMonitor } from 'electron';
-let electronSocket;
+import type { Socket } from "net";
+import { powerMonitor } from "electron";
+
+let electronSocket: Socket;
 
 export = (socket: Socket) => {
-    electronSocket = socket;
-    socket.on('register-powerMonitor-lock-screen', () => {
-        powerMonitor.on('lock-screen', () => {
-            electronSocket.emit('powerMonitor-lock-screen');
-        });
+  electronSocket = socket;
+  socket.on("register-powerMonitor-lock-screen", () => {
+    powerMonitor.on("lock-screen", () => {
+      electronSocket.emit("powerMonitor-lock-screen");
     });
-    socket.on('register-powerMonitor-unlock-screen', () => {
-        powerMonitor.on('unlock-screen', () => {
-            electronSocket.emit('powerMonitor-unlock-screen');
-        });
+  });
+  socket.on("register-powerMonitor-unlock-screen", () => {
+    powerMonitor.on("unlock-screen", () => {
+      electronSocket.emit("powerMonitor-unlock-screen");
     });
-    socket.on('register-powerMonitor-suspend', () => {
-        powerMonitor.on('suspend', () => {
-            electronSocket.emit('powerMonitor-suspend');
-        });
+  });
+  socket.on("register-powerMonitor-suspend", () => {
+    powerMonitor.on("suspend", () => {
+      electronSocket.emit("powerMonitor-suspend");
     });
-    socket.on('register-powerMonitor-resume', () => {
-        powerMonitor.on('resume', () => {
-            electronSocket.emit('powerMonitor-resume');
-        });
+  });
+  socket.on("register-powerMonitor-resume", () => {
+    powerMonitor.on("resume", () => {
+      electronSocket.emit("powerMonitor-resume");
     });
-    socket.on('register-powerMonitor-ac', () => {
-        powerMonitor.on('on-ac', () => {
-            electronSocket.emit('powerMonitor-ac');
-        });
+  });
+  socket.on("register-powerMonitor-ac", () => {
+    powerMonitor.on("on-ac", () => {
+      electronSocket.emit("powerMonitor-ac");
     });
-    socket.on('register-powerMonitor-battery', () => {
-        powerMonitor.on('on-battery', () => {
-            electronSocket.emit('powerMonitor-battery');
-        });
+  });
+  socket.on("register-powerMonitor-battery", () => {
+    powerMonitor.on("on-battery", () => {
+      electronSocket.emit("powerMonitor-battery");
     });
-    socket.on('register-powerMonitor-shutdown', () => {
-        powerMonitor.on('shutdown', () => {
-            electronSocket.emit('powerMonitor-shutdown');
-        });
+  });
+  socket.on("register-powerMonitor-shutdown", () => {
+    powerMonitor.on("shutdown", () => {
+      electronSocket.emit("powerMonitor-shutdown");
     });
+  });
 };

src/ElectronNET.Host/api/process.js

@@ -2,61 +2,61 @@
 let electronSocket;
 module.exports = (socket) => {
     electronSocket = socket;
-    socket.on('process-execPath', () => {
+    socket.on("process-execPath", () => {
         const value = process.execPath;
-        electronSocket.emit('process-execPath-completed', value);
+        electronSocket.emit("process-execPath-completed", value);
     });
-    socket.on('process-argv', () => {
+    socket.on("process-argv", () => {
         const value = process.argv;
-        electronSocket.emit('process-argv-completed', value);
+        electronSocket.emit("process-argv-completed", value);
     });
-    socket.on('process-type', () => {
+    socket.on("process-type", () => {
         const value = process.type;
-        electronSocket.emit('process-type-completed', value);
+        electronSocket.emit("process-type-completed", value);
     });
-    socket.on('process-versions', () => {
+    socket.on("process-versions", () => {
         const value = process.versions;
-        electronSocket.emit('process-versions-completed', value);
+        electronSocket.emit("process-versions-completed", value);
     });
-    socket.on('process-defaultApp', () => {
+    socket.on("process-defaultApp", () => {
         if (process.defaultApp === undefined) {
-            electronSocket.emit('process-defaultApp-completed', false);
+            electronSocket.emit("process-defaultApp-completed", false);
             return;
         }
-        electronSocket.emit('process-defaultApp-completed', process.defaultApp);
+        electronSocket.emit("process-defaultApp-completed", process.defaultApp);
     });
-    socket.on('process-isMainFrame', () => {
+    socket.on("process-isMainFrame", () => {
         if (process.isMainFrame === undefined) {
-            electronSocket.emit('process-isMainFrame-completed', false);
+            electronSocket.emit("process-isMainFrame-completed", false);
             return;
         }
-        electronSocket.emit('process-isMainFrame-completed', process.isMainFrame);
+        electronSocket.emit("process-isMainFrame-completed", process.isMainFrame);
     });
-    socket.on('process-resourcesPath', () => {
+    socket.on("process-resourcesPath", () => {
         const value = process.resourcesPath;
-        electronSocket.emit('process-resourcesPath-completed', value);
+        electronSocket.emit("process-resourcesPath-completed", value);
     });
-    socket.on('process-upTime', () => {
+    socket.on("process-upTime", () => {
         let value = process.uptime();
         if (value === undefined) {
             value = -1;
         }
-        electronSocket.emit('process-upTime-completed', value);
+        electronSocket.emit("process-upTime-completed", value);
     });
-    socket.on('process-pid', () => {
+    socket.on("process-pid", () => {
         if (process.pid === undefined) {
-            electronSocket.emit('process-pid-completed', -1);
+            electronSocket.emit("process-pid-completed", -1);
             return;
         }
-        electronSocket.emit('process-pid-completed', process.pid);
+        electronSocket.emit("process-pid-completed", process.pid);
     });
-    socket.on('process-arch', () => {
+    socket.on("process-arch", () => {
         const value = process.arch;
-        electronSocket.emit('process-arch-completed', value);
+        electronSocket.emit("process-arch-completed", value);
     });
-    socket.on('process-platform', () => {
+    socket.on("process-platform", () => {
         const value = process.platform;
-        electronSocket.emit('process-platform-completed', value);
+        electronSocket.emit("process-platform-completed", value);
     });
 };
 //# sourceMappingURL=process.js.map

src/ElectronNET.Host/api/process.js.map

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

src/ElectronNET.Host/api/process.ts

@@ -1,73 +1,74 @@
-import { Socket } from 'net';
-let electronSocket;
+import type { Socket } from "net";
+
+let electronSocket: Socket;
 
 export = (socket: Socket) => {
-    electronSocket = socket;
+  electronSocket = socket;
 
-    socket.on('process-execPath', () => {
-        const value = process.execPath;
-        electronSocket.emit('process-execPath-completed', value);
-    });
+  socket.on("process-execPath", () => {
+    const value = process.execPath;
+    electronSocket.emit("process-execPath-completed", value);
+  });
 
-    socket.on('process-argv', () => {
-        const value = process.argv;
-        electronSocket.emit('process-argv-completed', value);
-    });
+  socket.on("process-argv", () => {
+    const value = process.argv;
+    electronSocket.emit("process-argv-completed", value);
+  });
 
-    socket.on('process-type', () => {
-        const value = process.type;
-        electronSocket.emit('process-type-completed', value);
-    });
+  socket.on("process-type", () => {
+    const value = process.type;
+    electronSocket.emit("process-type-completed", value);
+  });
 
-    socket.on('process-versions', () => {
-        const value = process.versions;
-        electronSocket.emit('process-versions-completed', value);
-    });
+  socket.on("process-versions", () => {
+    const value = process.versions;
+    electronSocket.emit("process-versions-completed", value);
+  });
 
-    socket.on('process-defaultApp', () => {
-        if (process.defaultApp === undefined) {
-            electronSocket.emit('process-defaultApp-completed', false);
-            return;
-        }
-        electronSocket.emit('process-defaultApp-completed', process.defaultApp);
-    });
+  socket.on("process-defaultApp", () => {
+    if (process.defaultApp === undefined) {
+      electronSocket.emit("process-defaultApp-completed", false);
+      return;
+    }
+    electronSocket.emit("process-defaultApp-completed", process.defaultApp);
+  });
 
-    socket.on('process-isMainFrame', () => {
-        if (process.isMainFrame === undefined) {
-            electronSocket.emit('process-isMainFrame-completed', false);
-            return;
-        }
-        electronSocket.emit('process-isMainFrame-completed', process.isMainFrame);
-    });
+  socket.on("process-isMainFrame", () => {
+    if (process.isMainFrame === undefined) {
+      electronSocket.emit("process-isMainFrame-completed", false);
+      return;
+    }
+    electronSocket.emit("process-isMainFrame-completed", process.isMainFrame);
+  });
 
-    socket.on('process-resourcesPath', () => {
-        const value = process.resourcesPath;
-        electronSocket.emit('process-resourcesPath-completed', value);
-    });
+  socket.on("process-resourcesPath", () => {
+    const value = process.resourcesPath;
+    electronSocket.emit("process-resourcesPath-completed", value);
+  });
 
-    socket.on('process-upTime', () => {
-        let value = process.uptime();
-        if (value === undefined) {
-            value = -1;
-        }
-        electronSocket.emit('process-upTime-completed', value);
-    });
+  socket.on("process-upTime", () => {
+    let value = process.uptime();
+    if (value === undefined) {
+      value = -1;
+    }
+    electronSocket.emit("process-upTime-completed", value);
+  });
 
-    socket.on('process-pid', () => {
-        if (process.pid === undefined) {
-            electronSocket.emit('process-pid-completed', -1);
-            return;
-        }
-        electronSocket.emit('process-pid-completed', process.pid);
-    });
+  socket.on("process-pid", () => {
+    if (process.pid === undefined) {
+      electronSocket.emit("process-pid-completed", -1);
+      return;
+    }
+    electronSocket.emit("process-pid-completed", process.pid);
+  });
 
-    socket.on('process-arch', () => {
-        const value = process.arch;
-        electronSocket.emit('process-arch-completed', value);
-    });
+  socket.on("process-arch", () => {
+    const value = process.arch;
+    electronSocket.emit("process-arch-completed", value);
+  });
 
-    socket.on('process-platform', () => {
-        const value = process.platform;
-        electronSocket.emit('process-platform-completed', value);
-    })
+  socket.on("process-platform", () => {
+    const value = process.platform;
+    electronSocket.emit("process-platform-completed", value);
+  });
 };

src/ElectronNET.Host/api/screen.js

@@ -3,44 +3,47 @@ const electron_1 = require("electron");
 let electronSocket;
 module.exports = (socket) => {
     electronSocket = socket;
-    socket.on('register-screen-display-added', (id) => {
-        electron_1.screen.on('display-added', (event, display) => {
-            electronSocket.emit('screen-display-added' + id, display);
+    socket.on("register-screen-display-added", (id) => {
+        electron_1.screen.on("display-added", (event, display) => {
+            electronSocket.emit("screen-display-added" + id, display);
         });
     });
-    socket.on('register-screen-display-removed', (id) => {
-        electron_1.screen.on('display-removed', (event, display) => {
-            electronSocket.emit('screen-display-removed' + id, display);
+    socket.on("register-screen-display-removed", (id) => {
+        electron_1.screen.on("display-removed", (event, display) => {
+            electronSocket.emit("screen-display-removed" + id, display);
         });
     });
-    socket.on('register-screen-display-metrics-changed', (id) => {
-        electron_1.screen.on('display-metrics-changed', (event, display, changedMetrics) => {
-            electronSocket.emit('screen-display-metrics-changed' + id, [display, changedMetrics]);
+    socket.on("register-screen-display-metrics-changed", (id) => {
+        electron_1.screen.on("display-metrics-changed", (event, display, changedMetrics) => {
+            electronSocket.emit("screen-display-metrics-changed" + id, [
+                display,
+                changedMetrics,
+            ]);
         });
     });
-    socket.on('screen-getCursorScreenPoint', () => {
+    socket.on("screen-getCursorScreenPoint", () => {
         const point = electron_1.screen.getCursorScreenPoint();
-        electronSocket.emit('screen-getCursorScreenPoint-completed', point);
+        electronSocket.emit("screen-getCursorScreenPoint-completed", point);
     });
-    socket.on('screen-getMenuBarWorkArea', () => {
+    socket.on("screen-getMenuBarWorkArea", () => {
         const height = electron_1.screen.getPrimaryDisplay().workArea;
-        electronSocket.emit('screen-getMenuBarWorkArea-completed', height);
+        electronSocket.emit("screen-getMenuBarWorkArea-completed", height);
     });
-    socket.on('screen-getPrimaryDisplay', () => {
+    socket.on("screen-getPrimaryDisplay", () => {
         const display = electron_1.screen.getPrimaryDisplay();
-        electronSocket.emit('screen-getPrimaryDisplay-completed', display);
+        electronSocket.emit("screen-getPrimaryDisplay-completed", display);
     });
-    socket.on('screen-getAllDisplays', () => {
+    socket.on("screen-getAllDisplays", () => {
         const display = electron_1.screen.getAllDisplays();
-        electronSocket.emit('screen-getAllDisplays-completed', display);
+        electronSocket.emit("screen-getAllDisplays-completed", display);
     });
-    socket.on('screen-getDisplayNearestPoint', (point) => {
+    socket.on("screen-getDisplayNearestPoint", (point) => {
         const display = electron_1.screen.getDisplayNearestPoint(point);
-        electronSocket.emit('screen-getDisplayNearestPoint-completed', display);
+        electronSocket.emit("screen-getDisplayNearestPoint-completed", display);
     });
-    socket.on('screen-getDisplayMatching', (rectangle) => {
+    socket.on("screen-getDisplayMatching", (rectangle) => {
         const display = electron_1.screen.getDisplayMatching(rectangle);
-        electronSocket.emit('screen-getDisplayMatching-completed', display);
+        electronSocket.emit("screen-getDisplayMatching-completed", display);
     });
 };
 //# sourceMappingURL=screen.js.map

src/ElectronNET.Host/api/screen.js.map

@@ -1 +1 @@
-{"version":3,"file":"screen.js","sourceRoot":"","sources":["screen.ts"],"names":[],"mappings":";AACA,uCAAkC;AAClC,IAAI,cAAc,CAAC;AAEnB,iBAAS,CAAC,MAAc,EAAE,EAAE;IACxB,cAAc,GAAG,MAAM,CAAC;IAExB,MAAM,CAAC,EAAE,CAAC,+BAA+B,EAAE,CAAC,EAAE,EAAE,EAAE;QAC9C,iBAAM,CAAC,EAAE,CAAC,eAAe,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;YAC1C,cAAc,CAAC,IAAI,CAAC,sBAAsB,GAAG,EAAE,EAAE,OAAO,CAAC,CAAC;QAC9D,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,iCAAiC,EAAE,CAAC,EAAE,EAAE,EAAE;QAChD,iBAAM,CAAC,EAAE,CAAC,iBAAiB,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;YAC5C,cAAc,CAAC,IAAI,CAAC,wBAAwB,GAAG,EAAE,EAAE,OAAO,CAAC,CAAC;QAChE,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,yCAAyC,EAAE,CAAC,EAAE,EAAE,EAAE;QACxD,iBAAM,CAAC,EAAE,CAAC,yBAAyB,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,EAAE;YACpE,cAAc,CAAC,IAAI,CAAC,gCAAgC,GAAG,EAAE,EAAE,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC;QAC1F,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,6BAA6B,EAAE,GAAG,EAAE;QAC1C,MAAM,KAAK,GAAG,iBAAM,CAAC,oBAAoB,EAAE,CAAC;QAC5C,cAAc,CAAC,IAAI,CAAC,uCAAuC,EAAE,KAAK,CAAC,CAAC;IACxE,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,2BAA2B,EAAE,GAAG,EAAE;QACxC,MAAM,MAAM,GAAG,iBAAM,CAAC,iBAAiB,EAAE,CAAC,QAAQ,CAAC;QACnD,cAAc,CAAC,IAAI,CAAC,qCAAqC,EAAE,MAAM,CAAC,CAAC;IACvE,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,0BAA0B,EAAE,GAAG,EAAE;QACvC,MAAM,OAAO,GAAG,iBAAM,CAAC,iBAAiB,EAAE,CAAC;QAC3C,cAAc,CAAC,IAAI,CAAC,oCAAoC,EAAE,OAAO,CAAC,CAAC;IACvE,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,uBAAuB,EAAE,GAAG,EAAE;QACpC,MAAM,OAAO,GAAG,iBAAM,CAAC,cAAc,EAAE,CAAC;QACxC,cAAc,CAAC,IAAI,CAAC,iCAAiC,EAAE,OAAO,CAAC,CAAC;IACpE,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,+BAA+B,EAAE,CAAC,KAAK,EAAE,EAAE;QACjD,MAAM,OAAO,GAAG,iBAAM,CAAC,sBAAsB,CAAC,KAAK,CAAC,CAAC;QACrD,cAAc,CAAC,IAAI,CAAC,yCAAyC,EAAE,OAAO,CAAC,CAAC;IAC5E,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,2BAA2B,EAAE,CAAC,SAAS,EAAE,EAAE;QACjD,MAAM,OAAO,GAAG,iBAAM,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC;QACrD,cAAc,CAAC,IAAI,CAAC,qCAAqC,EAAE,OAAO,CAAC,CAAC;IACxE,CAAC,CAAC,CAAC;AACP,CAAC,CAAC"}
+{"version":3,"file":"screen.js","sourceRoot":"","sources":["screen.ts"],"names":[],"mappings":";AACA,uCAAkC;AAElC,IAAI,cAAsB,CAAC;AAE3B,iBAAS,CAAC,MAAc,EAAE,EAAE;IAC1B,cAAc,GAAG,MAAM,CAAC;IAExB,MAAM,CAAC,EAAE,CAAC,+BAA+B,EAAE,CAAC,EAAE,EAAE,EAAE;QAChD,iBAAM,CAAC,EAAE,CAAC,eAAe,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;YAC5C,cAAc,CAAC,IAAI,CAAC,sBAAsB,GAAG,EAAE,EAAE,OAAO,CAAC,CAAC;QAC5D,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,iCAAiC,EAAE,CAAC,EAAE,EAAE,EAAE;QAClD,iBAAM,CAAC,EAAE,CAAC,iBAAiB,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;YAC9C,cAAc,CAAC,IAAI,CAAC,wBAAwB,GAAG,EAAE,EAAE,OAAO,CAAC,CAAC;QAC9D,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,yCAAyC,EAAE,CAAC,EAAE,EAAE,EAAE;QAC1D,iBAAM,CAAC,EAAE,CAAC,yBAAyB,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,EAAE;YACtE,cAAc,CAAC,IAAI,CAAC,gCAAgC,GAAG,EAAE,EAAE;gBACzD,OAAO;gBACP,cAAc;aACf,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,6BAA6B,EAAE,GAAG,EAAE;QAC5C,MAAM,KAAK,GAAG,iBAAM,CAAC,oBAAoB,EAAE,CAAC;QAC5C,cAAc,CAAC,IAAI,CAAC,uCAAuC,EAAE,KAAK,CAAC,CAAC;IACtE,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,2BAA2B,EAAE,GAAG,EAAE;QAC1C,MAAM,MAAM,GAAG,iBAAM,CAAC,iBAAiB,EAAE,CAAC,QAAQ,CAAC;QACnD,cAAc,CAAC,IAAI,CAAC,qCAAqC,EAAE,MAAM,CAAC,CAAC;IACrE,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,0BAA0B,EAAE,GAAG,EAAE;QACzC,MAAM,OAAO,GAAG,iBAAM,CAAC,iBAAiB,EAAE,CAAC;QAC3C,cAAc,CAAC,IAAI,CAAC,oCAAoC,EAAE,OAAO,CAAC,CAAC;IACrE,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,uBAAuB,EAAE,GAAG,EAAE;QACtC,MAAM,OAAO,GAAG,iBAAM,CAAC,cAAc,EAAE,CAAC;QACxC,cAAc,CAAC,IAAI,CAAC,iCAAiC,EAAE,OAAO,CAAC,CAAC;IAClE,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,+BAA+B,EAAE,CAAC,KAAK,EAAE,EAAE;QACnD,MAAM,OAAO,GAAG,iBAAM,CAAC,sBAAsB,CAAC,KAAK,CAAC,CAAC;QACrD,cAAc,CAAC,IAAI,CAAC,yCAAyC,EAAE,OAAO,CAAC,CAAC;IAC1E,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,2BAA2B,EAAE,CAAC,SAAS,EAAE,EAAE;QACnD,MAAM,OAAO,GAAG,iBAAM,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC;QACrD,cAAc,CAAC,IAAI,CAAC,qCAAqC,EAAE,OAAO,CAAC,CAAC;IACtE,CAAC,CAAC,CAAC;AACL,CAAC,CAAC"}

src/ElectronNET.Host/api/screen.ts

@@ -1,55 +1,59 @@
-import { Socket } from 'net';
-import { screen } from 'electron';
-let electronSocket;
+import type { Socket } from "net";
+import { screen } from "electron";
+
+let electronSocket: Socket;
 
 export = (socket: Socket) => {
-    electronSocket = socket;
+  electronSocket = socket;
 
-    socket.on('register-screen-display-added', (id) => {
-        screen.on('display-added', (event, display) => {
-            electronSocket.emit('screen-display-added' + id, display);
-        });
+  socket.on("register-screen-display-added", (id) => {
+    screen.on("display-added", (event, display) => {
+      electronSocket.emit("screen-display-added" + id, display);
     });
+  });
 
-    socket.on('register-screen-display-removed', (id) => {
-        screen.on('display-removed', (event, display) => {
-            electronSocket.emit('screen-display-removed' + id, display);
-        });
+  socket.on("register-screen-display-removed", (id) => {
+    screen.on("display-removed", (event, display) => {
+      electronSocket.emit("screen-display-removed" + id, display);
     });
+  });
 
-    socket.on('register-screen-display-metrics-changed', (id) => {
-        screen.on('display-metrics-changed', (event, display, changedMetrics) => {
-            electronSocket.emit('screen-display-metrics-changed' + id, [display, changedMetrics]);
-        });
+  socket.on("register-screen-display-metrics-changed", (id) => {
+    screen.on("display-metrics-changed", (event, display, changedMetrics) => {
+      electronSocket.emit("screen-display-metrics-changed" + id, [
+        display,
+        changedMetrics,
+      ]);
     });
+  });
 
-    socket.on('screen-getCursorScreenPoint', () => {
-        const point = screen.getCursorScreenPoint();
-        electronSocket.emit('screen-getCursorScreenPoint-completed', point);
-    });
+  socket.on("screen-getCursorScreenPoint", () => {
+    const point = screen.getCursorScreenPoint();
+    electronSocket.emit("screen-getCursorScreenPoint-completed", point);
+  });
 
-    socket.on('screen-getMenuBarWorkArea', () => {
-        const height = screen.getPrimaryDisplay().workArea;
-        electronSocket.emit('screen-getMenuBarWorkArea-completed', height);
-    });
+  socket.on("screen-getMenuBarWorkArea", () => {
+    const height = screen.getPrimaryDisplay().workArea;
+    electronSocket.emit("screen-getMenuBarWorkArea-completed", height);
+  });
 
-    socket.on('screen-getPrimaryDisplay', () => {
-        const display = screen.getPrimaryDisplay();
-        electronSocket.emit('screen-getPrimaryDisplay-completed', display);
-    });
+  socket.on("screen-getPrimaryDisplay", () => {
+    const display = screen.getPrimaryDisplay();
+    electronSocket.emit("screen-getPrimaryDisplay-completed", display);
+  });
 
-    socket.on('screen-getAllDisplays', () => {
-        const display = screen.getAllDisplays();
-        electronSocket.emit('screen-getAllDisplays-completed', display);
-    });
+  socket.on("screen-getAllDisplays", () => {
+    const display = screen.getAllDisplays();
+    electronSocket.emit("screen-getAllDisplays-completed", display);
+  });
 
-    socket.on('screen-getDisplayNearestPoint', (point) => {
-        const display = screen.getDisplayNearestPoint(point);
-        electronSocket.emit('screen-getDisplayNearestPoint-completed', display);
-    });
+  socket.on("screen-getDisplayNearestPoint", (point) => {
+    const display = screen.getDisplayNearestPoint(point);
+    electronSocket.emit("screen-getDisplayNearestPoint-completed", display);
+  });
 
-    socket.on('screen-getDisplayMatching', (rectangle) => {
-        const display = screen.getDisplayMatching(rectangle);
-        electronSocket.emit('screen-getDisplayMatching-completed', display);
-    });
+  socket.on("screen-getDisplayMatching", (rectangle) => {
+    const display = screen.getDisplayMatching(rectangle);
+    electronSocket.emit("screen-getDisplayMatching-completed", display);
+  });
 };

src/ElectronNET.Host/api/shell.js

@@ -3,18 +3,18 @@ const electron_1 = require("electron");
 let electronSocket;
 module.exports = (socket) => {
     electronSocket = socket;
-    socket.on('shell-showItemInFolder', (fullPath) => {
+    socket.on("shell-showItemInFolder", (fullPath) => {
         electron_1.shell.showItemInFolder(fullPath);
-        electronSocket.emit('shell-showItemInFolderCompleted');
+        electronSocket.emit("shell-showItemInFolderCompleted");
     });
-    socket.on('shell-openPath', async (path) => {
+    socket.on("shell-openPath", async (path) => {
         const errorMessage = await electron_1.shell.openPath(path);
-        electronSocket.emit('shell-openPathCompleted', errorMessage);
+        electronSocket.emit("shell-openPathCompleted", errorMessage);
     });
-    socket.on('shell-openExternal', async (url, options) => {
-        let result = '';
+    socket.on("shell-openExternal", async (url, options) => {
+        let result = "";
         if (options) {
-            await electron_1.shell.openExternal(url, options).catch(e => {
+            await electron_1.shell.openExternal(url, options).catch((e) => {
                 result = e.message;
             });
         }
@@ -23,9 +23,9 @@ module.exports = (socket) => {
                 result = e.message;
             });
         }
-        electronSocket.emit('shell-openExternalCompleted', result);
+        electronSocket.emit("shell-openExternalCompleted", result);
     });
-    socket.on('shell-trashItem', async (fullPath, deleteOnFail) => {
+    socket.on("shell-trashItem", async (fullPath, deleteOnFail) => {
         let success = false;
         try {
             await electron_1.shell.trashItem(fullPath);
@@ -34,18 +34,18 @@ module.exports = (socket) => {
         catch (error) {
             success = false;
         }
-        electronSocket.emit('shell-trashItem-completed', success);
+        electronSocket.emit("shell-trashItem-completed", success);
     });
-    socket.on('shell-beep', () => {
+    socket.on("shell-beep", () => {
         electron_1.shell.beep();
     });
-    socket.on('shell-writeShortcutLink', (shortcutPath, operation, options) => {
+    socket.on("shell-writeShortcutLink", (shortcutPath, operation, options) => {
         const success = electron_1.shell.writeShortcutLink(shortcutPath, operation, options);
-        electronSocket.emit('shell-writeShortcutLinkCompleted', success);
+        electronSocket.emit("shell-writeShortcutLinkCompleted", success);
     });
-    socket.on('shell-readShortcutLink', (shortcutPath) => {
+    socket.on("shell-readShortcutLink", (shortcutPath) => {
         const shortcutDetails = electron_1.shell.readShortcutLink(shortcutPath);
-        electronSocket.emit('shell-readShortcutLinkCompleted', shortcutDetails);
+        electronSocket.emit("shell-readShortcutLinkCompleted", shortcutDetails);
     });
 };
 //# sourceMappingURL=shell.js.map

src/ElectronNET.Host/api/shell.js.map

@@ -1 +1 @@
-{"version":3,"file":"shell.js","sourceRoot":"","sources":["shell.ts"],"names":[],"mappings":";AACA,uCAAiC;AACjC,IAAI,cAAc,CAAC;AAEnB,iBAAS,CAAC,MAAc,EAAE,EAAE;IACxB,cAAc,GAAG,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,CAAC,wBAAwB,EAAE,CAAC,QAAQ,EAAE,EAAE;QAC7C,gBAAK,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC;QAEjC,cAAc,CAAC,IAAI,CAAC,iCAAiC,CAAC,CAAC;IAC3D,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,gBAAgB,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE;QACvC,MAAM,YAAY,GAAG,MAAM,gBAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QAEhD,cAAc,CAAC,IAAI,CAAC,yBAAyB,EAAE,YAAY,CAAC,CAAC;IACjE,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,oBAAoB,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE;QACnD,IAAI,MAAM,GAAG,EAAE,CAAC;QAEhB,IAAI,OAAO,EAAE,CAAC;YACV,MAAM,gBAAK,CAAC,YAAY,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;gBAC7C,MAAM,GAAG,CAAC,CAAC,OAAO,CAAC;YACvB,CAAC,CAAC,CAAC;QACP,CAAC;aAAM,CAAC;YACJ,MAAM,gBAAK,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE;gBACtC,MAAM,GAAG,CAAC,CAAC,OAAO,CAAC;YACvB,CAAC,CAAC,CAAC;QACP,CAAC;QAED,cAAc,CAAC,IAAI,CAAC,6BAA6B,EAAE,MAAM,CAAC,CAAC;IAC/D,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,iBAAiB,EAAE,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,EAAE;QAC1D,IAAI,OAAO,GAAG,KAAK,CAAC;QAEpB,IAAI,CAAC;YACD,MAAM,gBAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;YAChC,OAAO,GAAG,IAAI,CAAC;QACnB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACb,OAAO,GAAG,KAAK,CAAC;QACpB,CAAC;QAED,cAAc,CAAC,IAAI,CAAC,2BAA2B,EAAE,OAAO,CAAC,CAAC;IAC9D,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,YAAY,EAAE,GAAG,EAAE;QACzB,gBAAK,CAAC,IAAI,EAAE,CAAC;IACjB,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,yBAAyB,EAAE,CAAC,YAAY,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE;QACtE,MAAM,OAAO,GAAG,gBAAK,CAAC,iBAAiB,CAAC,YAAY,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;QAE1E,cAAc,CAAC,IAAI,CAAC,kCAAkC,EAAE,OAAO,CAAC,CAAC;IACrE,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,wBAAwB,EAAE,CAAC,YAAY,EAAE,EAAE;QACjD,MAAM,eAAe,GAAG,gBAAK,CAAC,gBAAgB,CAAC,YAAY,CAAC,CAAC;QAE7D,cAAc,CAAC,IAAI,CAAC,iCAAiC,EAAE,eAAe,CAAC,CAAC;IAC5E,CAAC,CAAC,CAAC;AACP,CAAC,CAAC"}
+{"version":3,"file":"shell.js","sourceRoot":"","sources":["shell.ts"],"names":[],"mappings":";AACA,uCAAiC;AAEjC,IAAI,cAAsB,CAAC;AAE3B,iBAAS,CAAC,MAAc,EAAE,EAAE;IAC1B,cAAc,GAAG,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,CAAC,wBAAwB,EAAE,CAAC,QAAQ,EAAE,EAAE;QAC/C,gBAAK,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC;QAEjC,cAAc,CAAC,IAAI,CAAC,iCAAiC,CAAC,CAAC;IACzD,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,gBAAgB,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE;QACzC,MAAM,YAAY,GAAG,MAAM,gBAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QAEhD,cAAc,CAAC,IAAI,CAAC,yBAAyB,EAAE,YAAY,CAAC,CAAC;IAC/D,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,oBAAoB,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE;QACrD,IAAI,MAAM,GAAG,EAAE,CAAC;QAEhB,IAAI,OAAO,EAAE,CAAC;YACZ,MAAM,gBAAK,CAAC,YAAY,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE;gBACjD,MAAM,GAAG,CAAC,CAAC,OAAO,CAAC;YACrB,CAAC,CAAC,CAAC;QACL,CAAC;aAAM,CAAC;YACN,MAAM,gBAAK,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE;gBACxC,MAAM,GAAG,CAAC,CAAC,OAAO,CAAC;YACrB,CAAC,CAAC,CAAC;QACL,CAAC;QAED,cAAc,CAAC,IAAI,CAAC,6BAA6B,EAAE,MAAM,CAAC,CAAC;IAC7D,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,iBAAiB,EAAE,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,EAAE;QAC5D,IAAI,OAAO,GAAG,KAAK,CAAC;QAEpB,IAAI,CAAC;YACH,MAAM,gBAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;YAChC,OAAO,GAAG,IAAI,CAAC;QACjB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,GAAG,KAAK,CAAC;QAClB,CAAC;QAED,cAAc,CAAC,IAAI,CAAC,2BAA2B,EAAE,OAAO,CAAC,CAAC;IAC5D,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,YAAY,EAAE,GAAG,EAAE;QAC3B,gBAAK,CAAC,IAAI,EAAE,CAAC;IACf,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,yBAAyB,EAAE,CAAC,YAAY,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE;QACxE,MAAM,OAAO,GAAG,gBAAK,CAAC,iBAAiB,CAAC,YAAY,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;QAE1E,cAAc,CAAC,IAAI,CAAC,kCAAkC,EAAE,OAAO,CAAC,CAAC;IACnE,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,wBAAwB,EAAE,CAAC,YAAY,EAAE,EAAE;QACnD,MAAM,eAAe,GAAG,gBAAK,CAAC,gBAAgB,CAAC,YAAY,CAAC,CAAC;QAE7D,cAAc,CAAC,IAAI,CAAC,iCAAiC,EAAE,eAAe,CAAC,CAAC;IAC1E,CAAC,CAAC,CAAC;AACL,CAAC,CAAC"}

src/ElectronNET.Host/api/shell.ts

@@ -1,63 +1,64 @@
-import { Socket } from 'net';
-import { shell } from 'electron';
-let electronSocket;
+import type { Socket } from "net";
+import { shell } from "electron";
+
+let electronSocket: Socket;
 
 export = (socket: Socket) => {
-    electronSocket = socket;
-    socket.on('shell-showItemInFolder', (fullPath) => {
-        shell.showItemInFolder(fullPath);
+  electronSocket = socket;
+  socket.on("shell-showItemInFolder", (fullPath) => {
+    shell.showItemInFolder(fullPath);
 
-        electronSocket.emit('shell-showItemInFolderCompleted');
-    });
+    electronSocket.emit("shell-showItemInFolderCompleted");
+  });
 
-    socket.on('shell-openPath', async (path) => {
-        const errorMessage = await shell.openPath(path);
+  socket.on("shell-openPath", async (path) => {
+    const errorMessage = await shell.openPath(path);
 
-        electronSocket.emit('shell-openPathCompleted', errorMessage);
-    });
+    electronSocket.emit("shell-openPathCompleted", errorMessage);
+  });
 
-    socket.on('shell-openExternal', async (url, options) => {
-        let result = '';
+  socket.on("shell-openExternal", async (url, options) => {
+    let result = "";
 
-        if (options) {
-            await shell.openExternal(url, options).catch(e => {
-                result = e.message;
-            });
-        } else {
-            await shell.openExternal(url).catch((e) => {
-                result = e.message;
-            });
-        }
+    if (options) {
+      await shell.openExternal(url, options).catch((e) => {
+        result = e.message;
+      });
+    } else {
+      await shell.openExternal(url).catch((e) => {
+        result = e.message;
+      });
+    }
 
-        electronSocket.emit('shell-openExternalCompleted', result);
-    });
+    electronSocket.emit("shell-openExternalCompleted", result);
+  });
 
-    socket.on('shell-trashItem', async (fullPath, deleteOnFail) => {
-        let success = false;
+  socket.on("shell-trashItem", async (fullPath, deleteOnFail) => {
+    let success = false;
 
-        try {
-            await shell.trashItem(fullPath);
-            success = true;
-        } catch (error) {
-            success = false;
-        }
+    try {
+      await shell.trashItem(fullPath);
+      success = true;
+    } catch (error) {
+      success = false;
+    }
 
-        electronSocket.emit('shell-trashItem-completed', success);
-    });
+    electronSocket.emit("shell-trashItem-completed", success);
+  });
 
-    socket.on('shell-beep', () => {
-        shell.beep();
-    });
+  socket.on("shell-beep", () => {
+    shell.beep();
+  });
 
-    socket.on('shell-writeShortcutLink', (shortcutPath, operation, options) => {
-        const success = shell.writeShortcutLink(shortcutPath, operation, options);
+  socket.on("shell-writeShortcutLink", (shortcutPath, operation, options) => {
+    const success = shell.writeShortcutLink(shortcutPath, operation, options);
 
-        electronSocket.emit('shell-writeShortcutLinkCompleted', success);
-    });
+    electronSocket.emit("shell-writeShortcutLinkCompleted", success);
+  });
 
-    socket.on('shell-readShortcutLink', (shortcutPath) => {
-        const shortcutDetails = shell.readShortcutLink(shortcutPath);
+  socket.on("shell-readShortcutLink", (shortcutPath) => {
+    const shortcutDetails = shell.readShortcutLink(shortcutPath);
 
-        electronSocket.emit('shell-readShortcutLinkCompleted', shortcutDetails);
-    });
+    electronSocket.emit("shell-readShortcutLinkCompleted", shortcutDetails);
+  });
 };

src/ElectronNET.Host/api/tray.js

@@ -1,101 +1,112 @@
 "use strict";
 const electron_1 = require("electron");
-let tray = (global['$tray'] = global['tray'] || { value: null });
+let tray = (global["$tray"] = global["tray"] || {
+    value: null,
+});
 let electronSocket;
 module.exports = (socket) => {
     electronSocket = socket;
-    socket.on('register-tray-click', (id) => {
+    socket.on("register-tray-click", (id) => {
         if (tray.value) {
-            tray.value.on('click', (event, bounds) => {
-                electronSocket.emit('tray-click' + id, [event.__proto__, bounds]);
+            tray.value.on("click", (event, bounds) => {
+                electronSocket.emit("tray-click" + id, [
+                    event.__proto__,
+                    bounds,
+                ]);
             });
         }
     });
-    socket.on('register-tray-right-click', (id) => {
+    socket.on("register-tray-right-click", (id) => {
         if (tray.value) {
-            tray.value.on('right-click', (event, bounds) => {
-                electronSocket.emit('tray-right-click' + id, [event.__proto__, bounds]);
+            tray.value.on("right-click", (event, bounds) => {
+                electronSocket.emit("tray-right-click" + id, [
+                    event.__proto__,
+                    bounds,
+                ]);
             });
         }
     });
-    socket.on('register-tray-double-click', (id) => {
+    socket.on("register-tray-double-click", (id) => {
         if (tray.value) {
-            tray.value.on('double-click', (event, bounds) => {
-                electronSocket.emit('tray-double-click' + id, [event.__proto__, bounds]);
+            tray.value.on("double-click", (event, bounds) => {
+                electronSocket.emit("tray-double-click" + id, [
+                    event.__proto__,
+                    bounds,
+                ]);
             });
         }
     });
-    socket.on('register-tray-balloon-show', (id) => {
+    socket.on("register-tray-balloon-show", (id) => {
         if (tray.value) {
-            tray.value.on('balloon-show', () => {
-                electronSocket.emit('tray-balloon-show' + id);
+            tray.value.on("balloon-show", () => {
+                electronSocket.emit("tray-balloon-show" + id);
             });
         }
     });
-    socket.on('register-tray-balloon-click', (id) => {
+    socket.on("register-tray-balloon-click", (id) => {
         if (tray.value) {
-            tray.value.on('balloon-click', () => {
-                electronSocket.emit('tray-balloon-click' + id);
+            tray.value.on("balloon-click", () => {
+                electronSocket.emit("tray-balloon-click" + id);
             });
         }
     });
-    socket.on('register-tray-balloon-closed', (id) => {
+    socket.on("register-tray-balloon-closed", (id) => {
         if (tray.value) {
-            tray.value.on('balloon-closed', () => {
-                electronSocket.emit('tray-balloon-closed' + id);
+            tray.value.on("balloon-closed", () => {
+                electronSocket.emit("tray-balloon-closed" + id);
             });
         }
     });
-    socket.on('create-tray', (image, menuItems) => {
+    socket.on("create-tray", (image, menuItems) => {
         const trayIcon = electron_1.nativeImage.createFromPath(image);
         tray.value = new electron_1.Tray(trayIcon);
         if (menuItems) {
             applyContextMenu(menuItems);
         }
     });
-    socket.on('tray-destroy', () => {
+    socket.on("tray-destroy", () => {
         if (tray.value) {
             tray.value.destroy();
         }
     });
-    socket.on('set-contextMenu', (menuItems) => {
+    socket.on("set-contextMenu", (menuItems) => {
         if (menuItems && tray.value) {
             applyContextMenu(menuItems);
         }
     });
-    socket.on('tray-setImage', (image) => {
+    socket.on("tray-setImage", (image) => {
         if (tray.value) {
             tray.value.setImage(image);
         }
     });
-    socket.on('tray-setPressedImage', (image) => {
+    socket.on("tray-setPressedImage", (image) => {
         if (tray.value) {
             const img = electron_1.nativeImage.createFromPath(image);
             tray.value.setPressedImage(img);
         }
     });
-    socket.on('tray-setToolTip', (toolTip) => {
+    socket.on("tray-setToolTip", (toolTip) => {
         if (tray.value) {
             tray.value.setToolTip(toolTip);
         }
     });
-    socket.on('tray-setTitle', (title) => {
+    socket.on("tray-setTitle", (title) => {
         if (tray.value) {
             tray.value.setTitle(title);
         }
     });
-    socket.on('tray-displayBalloon', (options) => {
+    socket.on("tray-displayBalloon", (options) => {
         if (tray.value) {
             tray.value.displayBalloon(options);
         }
     });
-    socket.on('tray-isDestroyed', () => {
+    socket.on("tray-isDestroyed", () => {
         if (tray.value) {
             const isDestroyed = tray.value.isDestroyed();
-            electronSocket.emit('tray-isDestroyedCompleted', isDestroyed);
+            electronSocket.emit("tray-isDestroyedCompleted", isDestroyed);
         }
     });
-    socket.on('register-tray-on-event', (eventName, listenerName) => {
+    socket.on("register-tray-on-event", (eventName, listenerName) => {
         if (tray.value) {
             tray.value.on(eventName, (...args) => {
                 if (args.length > 1) {
@@ -107,7 +118,7 @@ module.exports = (socket) => {
             });
         }
     });
-    socket.on('register-tray-once-event', (eventName, listenerName) => {
+    socket.on("register-tray-once-event", (eventName, listenerName) => {
         if (tray.value) {
             tray.value.once(eventName, (...args) => {
                 if (args.length > 1) {
@@ -122,7 +133,7 @@ module.exports = (socket) => {
     function applyContextMenu(menuItems) {
         const menu = electron_1.Menu.buildFromTemplate(menuItems);
         addMenuItemClickConnector(menu.items, (id) => {
-            electronSocket.emit('trayMenuItemClicked', id);
+            electronSocket.emit("trayMenuItemClicked", id);
         });
         tray.value.setContextMenu(menu);
     }
@@ -131,8 +142,10 @@ module.exports = (socket) => {
             if (item.submenu && item.submenu.items.length > 0) {
                 addMenuItemClickConnector(item.submenu.items, callback);
             }
-            if ('id' in item && item.id) {
-                item.click = () => { callback(item.id); };
+            if ("id" in item && item.id) {
+                item.click = () => {
+                    callback(item.id);
+                };
             }
         });
     }

src/ElectronNET.Host/api/tray.ts

@@ -1,159 +1,174 @@
-import { Socket } from 'net';
-import { Menu, Tray, nativeImage } from 'electron';
-let tray: { value: Electron.Tray } = (global['$tray'] = global['tray'] || { value: null });
-let electronSocket;
+import type { Socket } from "net";
+import { Menu, Tray, nativeImage } from "electron";
+
+let tray: { value: Electron.Tray } = (global["$tray"] = global["tray"] || {
+  value: null,
+});
+
+let electronSocket: Socket;
 
 export = (socket: Socket) => {
-    electronSocket = socket;
-    socket.on('register-tray-click', (id) => {
-        if (tray.value) {
-            tray.value.on('click', (event, bounds) => {
-                electronSocket.emit('tray-click' + id, [(<any>event).__proto__, bounds]);
-            });
-        }
-    });
-
-    socket.on('register-tray-right-click', (id) => {
-        if (tray.value) {
-            tray.value.on('right-click', (event, bounds) => {
-                electronSocket.emit('tray-right-click' + id, [(<any>event).__proto__, bounds]);
-            });
-        }
-    });
-
-    socket.on('register-tray-double-click', (id) => {
-        if (tray.value) {
-            tray.value.on('double-click', (event, bounds) => {
-                electronSocket.emit('tray-double-click' + id, [(<any>event).__proto__, bounds]);
-            });
-        }
-    });
-
-    socket.on('register-tray-balloon-show', (id) => {
-        if (tray.value) {
-            tray.value.on('balloon-show', () => {
-                electronSocket.emit('tray-balloon-show' + id);
-            });
-        }
-    });
-
-    socket.on('register-tray-balloon-click', (id) => {
-        if (tray.value) {
-            tray.value.on('balloon-click', () => {
-                electronSocket.emit('tray-balloon-click' + id);
-            });
-        }
-    });
-
-    socket.on('register-tray-balloon-closed', (id) => {
-        if (tray.value) {
-            tray.value.on('balloon-closed', () => {
-                electronSocket.emit('tray-balloon-closed' + id);
-            });
-        }
-    });
-
-    socket.on('create-tray', (image, menuItems) => {
-        const trayIcon = nativeImage.createFromPath(image);
-
-        tray.value = new Tray(trayIcon);
-
-        if (menuItems) {
-            applyContextMenu(menuItems);
-        }
-    });
-
-    socket.on('tray-destroy', () => {
-        if (tray.value) {
-            tray.value.destroy();
-        }
-    });
-
-    socket.on('set-contextMenu', (menuItems) => {
-        if (menuItems && tray.value) {
-            applyContextMenu(menuItems);
-        }
-    });
-
-    socket.on('tray-setImage', (image) => {
-        if (tray.value) {
-            tray.value.setImage(image);
-        }
-    });
-
-    socket.on('tray-setPressedImage', (image) => {
-        if (tray.value) {
-            const img = nativeImage.createFromPath(image);
-            tray.value.setPressedImage(img);
-        }
-    });
-
-    socket.on('tray-setToolTip', (toolTip) => {
-        if (tray.value) {
-            tray.value.setToolTip(toolTip);
-        }
-    });
-
-    socket.on('tray-setTitle', (title) => {
-        if (tray.value) {
-            tray.value.setTitle(title);
-        }
-    });
-
-    socket.on('tray-displayBalloon', (options) => {
-        if (tray.value) {
-            tray.value.displayBalloon(options);
-        }
-    });
-
-    socket.on('tray-isDestroyed', () => {
-        if (tray.value) {
-            const isDestroyed = tray.value.isDestroyed();
-            electronSocket.emit('tray-isDestroyedCompleted', isDestroyed);
-        }
-    });
-
-    socket.on('register-tray-on-event', (eventName, listenerName) => {
-        if (tray.value){
-            tray.value.on(eventName, (...args: any[]) => {
-                if (args.length > 1) {
-                    electronSocket.emit(listenerName, args[1]);
-                } else {
-                    electronSocket.emit(listenerName);
-                }
-            });
-        }
-    });
-
-    socket.on('register-tray-once-event', (eventName, listenerName) => {
-        if (tray.value){
-            tray.value.once(eventName, (...args: any[]) => {
-                if (args.length > 1) {
-                    electronSocket.emit(listenerName, args[1]);
-                } else {
-                    electronSocket.emit(listenerName);
-                }
-            });
-        }
-    });
-
-    function applyContextMenu(menuItems) {
-        const menu = Menu.buildFromTemplate(menuItems);
-        addMenuItemClickConnector(menu.items, (id) => {
-            electronSocket.emit('trayMenuItemClicked', id);
-        });
-        tray.value.setContextMenu(menu);
+  electronSocket = socket;
+  socket.on("register-tray-click", (id) => {
+    if (tray.value) {
+      tray.value.on("click", (event, bounds) => {
+        electronSocket.emit("tray-click" + id, [
+          (<any>event).__proto__,
+          bounds,
+        ]);
+      });
     }
+  });
 
-    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); };
-            }
-        });
+  socket.on("register-tray-right-click", (id) => {
+    if (tray.value) {
+      tray.value.on("right-click", (event, bounds) => {
+        electronSocket.emit("tray-right-click" + id, [
+          (<any>event).__proto__,
+          bounds,
+        ]);
+      });
     }
+  });
+
+  socket.on("register-tray-double-click", (id) => {
+    if (tray.value) {
+      tray.value.on("double-click", (event, bounds) => {
+        electronSocket.emit("tray-double-click" + id, [
+          (<any>event).__proto__,
+          bounds,
+        ]);
+      });
+    }
+  });
+
+  socket.on("register-tray-balloon-show", (id) => {
+    if (tray.value) {
+      tray.value.on("balloon-show", () => {
+        electronSocket.emit("tray-balloon-show" + id);
+      });
+    }
+  });
+
+  socket.on("register-tray-balloon-click", (id) => {
+    if (tray.value) {
+      tray.value.on("balloon-click", () => {
+        electronSocket.emit("tray-balloon-click" + id);
+      });
+    }
+  });
+
+  socket.on("register-tray-balloon-closed", (id) => {
+    if (tray.value) {
+      tray.value.on("balloon-closed", () => {
+        electronSocket.emit("tray-balloon-closed" + id);
+      });
+    }
+  });
+
+  socket.on("create-tray", (image, menuItems) => {
+    const trayIcon = nativeImage.createFromPath(image);
+
+    tray.value = new Tray(trayIcon);
+
+    if (menuItems) {
+      applyContextMenu(menuItems);
+    }
+  });
+
+  socket.on("tray-destroy", () => {
+    if (tray.value) {
+      tray.value.destroy();
+    }
+  });
+
+  socket.on("set-contextMenu", (menuItems) => {
+    if (menuItems && tray.value) {
+      applyContextMenu(menuItems);
+    }
+  });
+
+  socket.on("tray-setImage", (image) => {
+    if (tray.value) {
+      tray.value.setImage(image);
+    }
+  });
+
+  socket.on("tray-setPressedImage", (image) => {
+    if (tray.value) {
+      const img = nativeImage.createFromPath(image);
+      tray.value.setPressedImage(img);
+    }
+  });
+
+  socket.on("tray-setToolTip", (toolTip) => {
+    if (tray.value) {
+      tray.value.setToolTip(toolTip);
+    }
+  });
+
+  socket.on("tray-setTitle", (title) => {
+    if (tray.value) {
+      tray.value.setTitle(title);
+    }
+  });
+
+  socket.on("tray-displayBalloon", (options) => {
+    if (tray.value) {
+      tray.value.displayBalloon(options);
+    }
+  });
+
+  socket.on("tray-isDestroyed", () => {
+    if (tray.value) {
+      const isDestroyed = tray.value.isDestroyed();
+      electronSocket.emit("tray-isDestroyedCompleted", isDestroyed);
+    }
+  });
+
+  socket.on("register-tray-on-event", (eventName, listenerName) => {
+    if (tray.value) {
+      tray.value.on(eventName, (...args: any[]) => {
+        if (args.length > 1) {
+          electronSocket.emit(listenerName, args[1]);
+        } else {
+          electronSocket.emit(listenerName);
+        }
+      });
+    }
+  });
+
+  socket.on("register-tray-once-event", (eventName, listenerName) => {
+    if (tray.value) {
+      tray.value.once(eventName, (...args: any[]) => {
+        if (args.length > 1) {
+          electronSocket.emit(listenerName, args[1]);
+        } else {
+          electronSocket.emit(listenerName);
+        }
+      });
+    }
+  });
+
+  function applyContextMenu(menuItems) {
+    const menu = Menu.buildFromTemplate(menuItems);
+    addMenuItemClickConnector(menu.items, (id) => {
+      electronSocket.emit("trayMenuItemClicked", id);
+    });
+    tray.value.setContextMenu(menu);
+  }
+
+  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);
+        };
+      }
+    });
+  }
 };

src/ElectronNET.Host/api/webContents.js

@@ -1,7 +1,40 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+const fs = __importStar(require("fs"));
 const electron_1 = require("electron");
 const browserView_1 = require("./browserView");
-const fs = require("fs");
 let electronSocket;
 module.exports = (socket) => {
     electronSocket = socket;
@@ -315,28 +348,28 @@ module.exports = (socket) => {
         const extension = await browserWindow.webContents.session.loadExtension(path, { allowFileAccess: allowFileAccess });
         electronSocket.emit("webContents-session-loadExtension-completed", extension);
     });
-    socket.on('webContents-getZoomFactor', (id) => {
+    socket.on("webContents-getZoomFactor", (id) => {
         const browserWindow = getWindowById(id);
         const text = browserWindow.webContents.getZoomFactor();
-        electronSocket.emit('webContents-getZoomFactor-completed', text);
+        electronSocket.emit("webContents-getZoomFactor-completed", text);
     });
-    socket.on('webContents-setZoomFactor', (id, factor) => {
+    socket.on("webContents-setZoomFactor", (id, factor) => {
         const browserWindow = getWindowById(id);
         browserWindow.webContents.setZoomFactor(factor);
     });
-    socket.on('webContents-getZoomLevel', (id) => {
+    socket.on("webContents-getZoomLevel", (id) => {
         const browserWindow = getWindowById(id);
         const content = browserWindow.webContents.getZoomLevel();
-        electronSocket.emit('webContents-getZoomLevel-completed', content);
+        electronSocket.emit("webContents-getZoomLevel-completed", content);
     });
-    socket.on('webContents-setZoomLevel', (id, level) => {
+    socket.on("webContents-setZoomLevel", (id, level) => {
         const browserWindow = getWindowById(id);
         browserWindow.webContents.setZoomLevel(level);
     });
-    socket.on('webContents-setVisualZoomLevelLimits', async (id, minimumLevel, maximumLevel) => {
+    socket.on("webContents-setVisualZoomLevelLimits", async (id, minimumLevel, maximumLevel) => {
         const browserWindow = getWindowById(id);
         await browserWindow.webContents.setVisualZoomLevelLimits(minimumLevel, maximumLevel);
-        electronSocket.emit('webContents-setVisualZoomLevelLimits-completed');
+        electronSocket.emit("webContents-setVisualZoomLevelLimits-completed");
     });
     socket.on("webContents-toggleDevTools", (id) => {
         getWindowById(id).webContents.toggleDevTools();
@@ -346,26 +379,26 @@ module.exports = (socket) => {
     });
     socket.on("webContents-isDevToolsOpened", function (id) {
         const browserWindow = getWindowById(id);
-        electronSocket.emit('webContents-isDevToolsOpened-completed', browserWindow.webContents.isDevToolsOpened());
+        electronSocket.emit("webContents-isDevToolsOpened-completed", browserWindow.webContents.isDevToolsOpened());
     });
     socket.on("webContents-isDevToolsFocused", function (id) {
         const browserWindow = getWindowById(id);
-        electronSocket.emit('webContents-isDevToolsFocused-completed', browserWindow.webContents.isDevToolsFocused());
+        electronSocket.emit("webContents-isDevToolsFocused-completed", browserWindow.webContents.isDevToolsFocused());
     });
     socket.on("webContents-setAudioMuted", (id, muted) => {
         getWindowById(id).webContents.setAudioMuted(muted);
     });
     socket.on("webContents-isAudioMuted", function (id) {
         const browserWindow = getWindowById(id);
-        electronSocket.emit('webContents-isAudioMuted-completed', browserWindow.webContents.isAudioMuted());
+        electronSocket.emit("webContents-isAudioMuted-completed", browserWindow.webContents.isAudioMuted());
     });
     socket.on("webContents-isCurrentlyAudible", function (id) {
         const browserWindow = getWindowById(id);
-        electronSocket.emit('webContents-isCurrentlyAudible-completed', browserWindow.webContents.isCurrentlyAudible());
+        electronSocket.emit("webContents-isCurrentlyAudible-completed", browserWindow.webContents.isCurrentlyAudible());
     });
     socket.on("webContents-getUserAgent", function (id) {
         const browserWindow = getWindowById(id);
-        electronSocket.emit('webContents-getUserAgent-completed', browserWindow.webContents.getUserAgent());
+        electronSocket.emit("webContents-getUserAgent-completed", browserWindow.webContents.getUserAgent());
     });
     socket.on("webContents-setUserAgent", (id, userAgent) => {
         getWindowById(id).webContents.setUserAgent(userAgent);

src/ElectronNET.Host/api/webContents.ts

@@ -1,8 +1,10 @@
-import { Socket } from "net";
-import {BrowserWindow, BrowserView} from "electron";
+import * as fs from "fs";
+import type { Socket } from "net";
+import { BrowserWindow, BrowserView } from "electron";
+
 import { browserViewMediateService } from "./browserView";
-const fs = require("fs");
-let electronSocket;
+
+let electronSocket: Socket;
 
 export = (socket: Socket) => {
   electronSocket = socket;
@@ -68,7 +70,7 @@ export = (socket: Socket) => {
           errorCode,
           validatedUrl,
         });
-      }
+      },
     );
   });
 
@@ -136,17 +138,17 @@ export = (socket: Socket) => {
     async (id, code, userGesture = false) => {
       const result = await getWindowById(id).webContents.executeJavaScript(
         code,
-        userGesture
+        userGesture,
       );
       electronSocket.emit("webContents-executeJavaScript-completed", result);
-    }
+    },
   );
 
   socket.on("webContents-getUrl", function (id) {
     const browserWindow = getWindowById(id);
     electronSocket.emit(
       "webContents-getUrl" + id,
-      browserWindow.webContents.getURL()
+      browserWindow.webContents.getURL(),
     );
   });
 
@@ -155,7 +157,7 @@ export = (socket: Socket) => {
     (id, domains) => {
       const browserWindow = getWindowById(id);
       browserWindow.webContents.session.allowNTLMCredentialsForDomains(domains);
-    }
+    },
   );
 
   socket.on("webContents-session-clearAuthCache", async (...args) => {
@@ -194,7 +196,7 @@ export = (socket: Socket) => {
     await browserWindow.webContents.session.clearHostResolverCache();
 
     electronSocket.emit(
-      "webContents-session-clearHostResolverCache-completed" + guid
+      "webContents-session-clearHostResolverCache-completed" + guid,
     );
   });
 
@@ -203,7 +205,7 @@ export = (socket: Socket) => {
     await browserWindow.webContents.session.clearStorageData({});
 
     electronSocket.emit(
-      "webContents-session-clearStorageData-completed" + guid
+      "webContents-session-clearStorageData-completed" + guid,
     );
   });
 
@@ -214,9 +216,9 @@ export = (socket: Socket) => {
       await browserWindow.webContents.session.clearStorageData(options);
 
       electronSocket.emit(
-        "webContents-session-clearStorageData-options-completed" + guid
+        "webContents-session-clearStorageData-options-completed" + guid,
       );
-    }
+    },
   );
 
   socket.on("webContents-session-createInterruptedDownload", (id, options) => {
@@ -241,13 +243,12 @@ export = (socket: Socket) => {
 
   socket.on("webContents-session-getBlobData", async (id, identifier, guid) => {
     const browserWindow = getWindowById(id);
-    const buffer = await browserWindow.webContents.session.getBlobData(
-      identifier
-    );
+    const buffer =
+      await browserWindow.webContents.session.getBlobData(identifier);
 
     electronSocket.emit(
       "webContents-session-getBlobData-completed" + guid,
-      buffer.buffer
+      buffer.buffer,
     );
   });
 
@@ -257,7 +258,7 @@ export = (socket: Socket) => {
 
     electronSocket.emit(
       "webContents-session-getCacheSize-completed" + guid,
-      size
+      size,
     );
   });
 
@@ -267,7 +268,7 @@ export = (socket: Socket) => {
 
     electronSocket.emit(
       "webContents-session-getPreloads-completed" + guid,
-      preloads
+      preloads,
     );
   });
 
@@ -277,7 +278,7 @@ export = (socket: Socket) => {
 
     electronSocket.emit(
       "webContents-session-getUserAgent-completed" + guid,
-      userAgent
+      userAgent,
     );
   });
 
@@ -287,7 +288,7 @@ export = (socket: Socket) => {
 
     electronSocket.emit(
       "webContents-session-resolveProxy-completed" + guid,
-      proxy
+      proxy,
     );
   });
 
@@ -314,9 +315,9 @@ export = (socket: Socket) => {
       const browserWindow = getWindowById(id);
       browserWindow.webContents.session.setUserAgent(
         userAgent,
-        acceptLanguages
+        acceptLanguages,
       );
-    }
+    },
   );
 
   socket.on(
@@ -328,17 +329,17 @@ export = (socket: Socket) => {
       session.webRequest.onBeforeRequest(filter, (details, callback) => {
         socket.emit(
           `webContents-session-webRequest-onBeforeRequest${id}`,
-          details
+          details,
         );
         // Listen for a response from C# to continue the request
         electronSocket.once(
           `webContents-session-webRequest-onBeforeRequest-response${id}`,
           (response) => {
             callback(response);
-          }
+          },
         );
       });
-    }
+    },
   );
 
   socket.on("register-webContents-session-cookies-changed", (id) => {
@@ -353,7 +354,7 @@ export = (socket: Socket) => {
           cause,
           removed,
         ]);
-      }
+      },
     );
   });
 
@@ -363,7 +364,7 @@ export = (socket: Socket) => {
 
     electronSocket.emit(
       "webContents-session-cookies-get-completed" + guid,
-      cookies
+      cookies,
     );
   });
 
@@ -381,9 +382,9 @@ export = (socket: Socket) => {
       await browserWindow.webContents.session.cookies.remove(url, name);
 
       electronSocket.emit(
-        "webContents-session-cookies-remove-completed" + guid
+        "webContents-session-cookies-remove-completed" + guid,
       );
-    }
+    },
   );
 
   socket.on("webContents-session-cookies-flushStore", async (id, guid) => {
@@ -391,7 +392,7 @@ export = (socket: Socket) => {
     await browserWindow.webContents.session.cookies.flushStore();
 
     electronSocket.emit(
-      "webContents-session-cookies-flushStore-completed" + guid
+      "webContents-session-cookies-flushStore-completed" + guid,
     );
   });
 
@@ -441,7 +442,7 @@ export = (socket: Socket) => {
 
     electronSocket.emit(
       "webContents-session-getAllExtensions-completed",
-      chromeExtensionInfo
+      chromeExtensionInfo,
     );
   });
 
@@ -456,87 +457,108 @@ export = (socket: Socket) => {
       const browserWindow = getWindowById(id);
       const extension = await browserWindow.webContents.session.loadExtension(
         path,
-        { allowFileAccess: allowFileAccess }
+        { allowFileAccess: allowFileAccess },
       );
 
       electronSocket.emit(
         "webContents-session-loadExtension-completed",
-        extension
+        extension,
       );
-    }
+    },
   );
 
-    socket.on('webContents-getZoomFactor', (id) => {
-        const browserWindow = getWindowById(id);
-        const text = browserWindow.webContents.getZoomFactor();
-        electronSocket.emit('webContents-getZoomFactor-completed', text);
-    });
+  socket.on("webContents-getZoomFactor", (id) => {
+    const browserWindow = getWindowById(id);
+    const text = browserWindow.webContents.getZoomFactor();
+    electronSocket.emit("webContents-getZoomFactor-completed", text);
+  });
 
-    socket.on('webContents-setZoomFactor', (id, factor) => {
-        const browserWindow = getWindowById(id);
-        browserWindow.webContents.setZoomFactor(factor);
-    });
+  socket.on("webContents-setZoomFactor", (id, factor) => {
+    const browserWindow = getWindowById(id);
+    browserWindow.webContents.setZoomFactor(factor);
+  });
 
-    socket.on('webContents-getZoomLevel', (id) => {
-        const browserWindow = getWindowById(id);
-        const content = browserWindow.webContents.getZoomLevel();
-        electronSocket.emit('webContents-getZoomLevel-completed', content);
-    });
+  socket.on("webContents-getZoomLevel", (id) => {
+    const browserWindow = getWindowById(id);
+    const content = browserWindow.webContents.getZoomLevel();
+    electronSocket.emit("webContents-getZoomLevel-completed", content);
+  });
 
-    socket.on('webContents-setZoomLevel', (id, level) => {
-        const browserWindow = getWindowById(id);
-        browserWindow.webContents.setZoomLevel(level);
-    });
+  socket.on("webContents-setZoomLevel", (id, level) => {
+    const browserWindow = getWindowById(id);
+    browserWindow.webContents.setZoomLevel(level);
+  });
 
-    socket.on('webContents-setVisualZoomLevelLimits', async (id, minimumLevel, maximumLevel) => {
-        const browserWindow = getWindowById(id);
-        await browserWindow.webContents.setVisualZoomLevelLimits(minimumLevel, maximumLevel);
-        electronSocket.emit('webContents-setVisualZoomLevelLimits-completed');
-    });
+  socket.on(
+    "webContents-setVisualZoomLevelLimits",
+    async (id, minimumLevel, maximumLevel) => {
+      const browserWindow = getWindowById(id);
+      await browserWindow.webContents.setVisualZoomLevelLimits(
+        minimumLevel,
+        maximumLevel,
+      );
+      electronSocket.emit("webContents-setVisualZoomLevelLimits-completed");
+    },
+  );
 
-    socket.on("webContents-toggleDevTools", (id) => {
-        getWindowById(id).webContents.toggleDevTools();
-    });
+  socket.on("webContents-toggleDevTools", (id) => {
+    getWindowById(id).webContents.toggleDevTools();
+  });
 
-    socket.on("webContents-closeDevTools", (id) => {
-        getWindowById(id).webContents.closeDevTools();
-    });
+  socket.on("webContents-closeDevTools", (id) => {
+    getWindowById(id).webContents.closeDevTools();
+  });
 
-    socket.on("webContents-isDevToolsOpened", function (id) {
-        const browserWindow = getWindowById(id);
-        electronSocket.emit('webContents-isDevToolsOpened-completed', browserWindow.webContents.isDevToolsOpened());
-    });
+  socket.on("webContents-isDevToolsOpened", function (id) {
+    const browserWindow = getWindowById(id);
+    electronSocket.emit(
+      "webContents-isDevToolsOpened-completed",
+      browserWindow.webContents.isDevToolsOpened(),
+    );
+  });
 
-    socket.on("webContents-isDevToolsFocused", function (id) {
-        const browserWindow = getWindowById(id);
-        electronSocket.emit('webContents-isDevToolsFocused-completed', browserWindow.webContents.isDevToolsFocused());
-    });
+  socket.on("webContents-isDevToolsFocused", function (id) {
+    const browserWindow = getWindowById(id);
+    electronSocket.emit(
+      "webContents-isDevToolsFocused-completed",
+      browserWindow.webContents.isDevToolsFocused(),
+    );
+  });
 
-    socket.on("webContents-setAudioMuted", (id, muted) => {
-        getWindowById(id).webContents.setAudioMuted(muted);
-    });
+  socket.on("webContents-setAudioMuted", (id, muted) => {
+    getWindowById(id).webContents.setAudioMuted(muted);
+  });
 
-    socket.on("webContents-isAudioMuted", function (id) {
-        const browserWindow = getWindowById(id);
-        electronSocket.emit('webContents-isAudioMuted-completed', browserWindow.webContents.isAudioMuted());
-    });
+  socket.on("webContents-isAudioMuted", function (id) {
+    const browserWindow = getWindowById(id);
+    electronSocket.emit(
+      "webContents-isAudioMuted-completed",
+      browserWindow.webContents.isAudioMuted(),
+    );
+  });
 
-    socket.on("webContents-isCurrentlyAudible", function (id) {
-        const browserWindow = getWindowById(id);
-        electronSocket.emit('webContents-isCurrentlyAudible-completed', browserWindow.webContents.isCurrentlyAudible());
-    });
+  socket.on("webContents-isCurrentlyAudible", function (id) {
+    const browserWindow = getWindowById(id);
+    electronSocket.emit(
+      "webContents-isCurrentlyAudible-completed",
+      browserWindow.webContents.isCurrentlyAudible(),
+    );
+  });
 
-    socket.on("webContents-getUserAgent", function (id) {
-        const browserWindow = getWindowById(id);
-        electronSocket.emit('webContents-getUserAgent-completed', browserWindow.webContents.getUserAgent());
-    });
+  socket.on("webContents-getUserAgent", function (id) {
+    const browserWindow = getWindowById(id);
+    electronSocket.emit(
+      "webContents-getUserAgent-completed",
+      browserWindow.webContents.getUserAgent(),
+    );
+  });
 
-    socket.on("webContents-setUserAgent", (id, userAgent) => {
-        getWindowById(id).webContents.setUserAgent(userAgent);
-    });
+  socket.on("webContents-setUserAgent", (id, userAgent) => {
+    getWindowById(id).webContents.setUserAgent(userAgent);
+  });
 
-    function getWindowById(
-    id: number
+  function getWindowById(
+    id: number,
   ): Electron.BrowserWindow | Electron.BrowserView {
     if (id >= 1000) {
       return browserViewMediateService(id - 1000);

src/ElectronNET.Host/main.js

@@ -1,10 +1,14 @@
 const { app } = require('electron');
 const { BrowserWindow } = require('electron');
-const { protocol } = require('electron');
+const { createServer } = require('http');
+const { randomUUID } = require('crypto');
+const { Server } = require('socket.io');
+const { platform } = require('os');
 const path = require('path');
+const fs = require('fs');
 const cProcess = require('child_process').spawn;
-const portscanner = require('portscanner');
 const { imageSize } = require('image-size');
+
 let io, server, browserWindows, ipc, apiProcess, loadURL;
 let appApi, menu, dialogApi, notification, tray, webContents;
 let globalShortcut, shellApi, screen, clipboard, autoUpdater;
@@ -16,20 +20,19 @@ let nativeTheme;
 let dock;
 let launchFile;
 let launchUrl;
-let processApi;
 
 let manifestJsonFileName = 'package.json';
 let unpackedelectron = false;
 let unpackeddotnet = false;
 let dotnetpacked = false;
 let electronforcedport;
+let electronUrl;
+let authToken = randomUUID().split('-').join('');
 
 if (app.commandLine.hasSwitch('manifest')) {
     manifestJsonFileName = app.commandLine.getSwitchValue('manifest');
 }
 
-console.log('Entry!!!:  ');
-
 if (app.commandLine.hasSwitch('unpackedelectron')) {
     unpackedelectron = true;
 }
@@ -41,13 +44,19 @@ else if (app.commandLine.hasSwitch('dotnetpacked')) {
 }
 
 if (app.commandLine.hasSwitch('electronforcedport')) {
-    electronforcedport = app.commandLine.getSwitchValue('electronforcedport');
+    electronforcedport = +app.commandLine.getSwitchValue('electronforcedport');
+}
+
+// Store in global for access by browser windows
+global.authToken = authToken;
+
+if (app.commandLine.hasSwitch('electronurl')) {
+    electronUrl = app.commandLine.getSwitchValue('electronurl');
 }
 
 // Custom startup hook: look for custom_main.js and invoke its onStartup(host) if present.
 // If the hook returns false, abort Electron startup.
 try {
-    const fs = require('fs');
     const customMainPath = path.join(__dirname, 'custom_main.js');
     if (fs.existsSync(customMainPath)) {
         const customMain = require(customMainPath);
@@ -73,7 +82,7 @@ let manifestJsonFilePath = path.join(currentPath, manifestJsonFileName);
 
 // if running unpackedelectron, lets change the path
 if (unpackedelectron || unpackeddotnet) {
-    console.log('unpackedelectron! dir: ' + currentPath);
+    console.debug('Running in unpacked mode, dir: ' + currentPath);
 
     manifestJsonFilePath = path.join(currentPath, manifestJsonFileName);
     currentBinPath = path.join(currentPath, '../'); // go to project directory
@@ -93,7 +102,7 @@ app.on('will-finish-launching', () => {
 
 const manifestJsonFile = require(manifestJsonFilePath);
 
-if (manifestJsonFile.singleInstance === "yes") {
+if (manifestJsonFile.singleInstance) {
     const mainInstance = app.requestSingleInstanceLock();
     app.on('second-instance', (events, args = []) => {
         args.forEach((parameter) => {
@@ -140,7 +149,7 @@ function getForwardedArgs() {
 
 const forwardedArgs = getForwardedArgs();
 
-app.on('ready', () => {
+app.on('ready', () => {    
     // Fix ERR_UNKNOWN_URL_SCHEME using file protocol
     // https://github.com/electron/electron/issues/23757
     ////protocol.registerFileProtocol('file', (request, callback) => {
@@ -153,44 +162,41 @@ app.on('ready', () => {
     }
 
     if (electronforcedport) {
-        console.log('Electron Socket IO (forced) Port: ' + electronforcedport);
+        console.info('Electron Socket IO (forced) Port: ' + electronforcedport);
         startSocketApiBridge(electronforcedport);
-        return;
+    } else {
+        console.info('Electron Socket dynamic IO Port');
+        startSocketApiBridge(0);
     }
-
-    // Added default port as configurable for port restricted environments.
-    let defaultElectronPort = 8000;
-    if (manifestJsonFile.electronPort) {
-        defaultElectronPort = manifestJsonFile.electronPort;
-    }
-
-    // hostname needs to be localhost, otherwise Windows Firewall will be triggered.
-    portscanner.findAPortNotInUse(defaultElectronPort, 65535, 'localhost', function (error, port) {
-        console.log('Electron Socket IO Port: ' + port);
-        startSocketApiBridge(port);
-    });
 });
 
 app.on('quit', async (event, exitCode) => {
-    try {
-        server.close();
-        server.closeAllConnections();
-    } catch (e) {
-        console.error(e);
-    }
-
-    try {
-        apiProcess?.kill();
-    } catch (e) {
-        console.error(e);
-    }
-
-    try {
-        if (io && typeof io.close === 'function') {
-            io.close();
+    // Clean up Socket.IO resources (legacy mode only)
+    if (server) {
+        try {
+            server.close();
+            server.closeAllConnections();
+        } catch (e) {
+            console.error('Error closing Socket.IO server:', e);
+        }
+    }
+
+    // Clean up API process (Socket.IO mode only)
+    if (typeof apiProcess !== 'undefined' && apiProcess) {
+        try {
+            apiProcess.kill();
+        } catch (e) {
+            console.error('Error killing API process:', e);
+        }
+    }
+
+    // Clean up Socket.IO connection
+    if (typeof io !== 'undefined' && io && typeof io.close === 'function') {
+        try {
+            io.close();
+        } catch (e) {
+            console.error('Error closing Socket.IO connection:', e);
         }
-    } catch (e) {
-        console.error(e);
     }
 });
 
@@ -246,9 +252,7 @@ function startSplashScreen() {
     // it's an image, so we can compute the desired splash screen size
     imageSize(imageFile, (error, dimensions) => {
         if (error) {
-            console.log(`load splashscreen error:`);
-            console.error(error);
-
+            console.error(`load splashscreen error:`, error);
             throw new Error(error.message);
         }
 
@@ -259,9 +263,9 @@ function startSplashScreen() {
 function startSocketApiBridge(port) {
     // instead of 'require('socket.io')(port);' we need to use this workaround
     // otherwise the Windows Firewall will be triggered
-    console.log('Electron Socket: starting...');
-    server = require('http').createServer();
-    const { Server } = require('socket.io');
+    console.debug('Electron Socket: starting...');
+    server = createServer();
+    const host = !port ? '127.0.0.1' : 'localhost';
     let hostHook;
     io = new Server({
         pingTimeout: 60000, // in ms, default is 5000
@@ -269,14 +273,16 @@ function startSocketApiBridge(port) {
     });
     io.attach(server);
 
-    server.listen(port, 'localhost');
+    server.listen(port, host);
     server.on('listening', function () {
-        console.log('Electron Socket: listening on port %s at %s', server.address().port, server.address().address);
+        const addr = server.address();
+        console.info(`Electron Socket: listening on port ${addr.port} at ${addr.address} using ${authToken}`);
+
         // Now that socket connection is established, we can guarantee port will not be open for portscanner
         if (unpackedelectron) {
-            startAspCoreBackendUnpackaged(port);
+            startAspCoreBackendUnpackaged(addr.port);
         } else if (!unpackeddotnet && !dotnetpacked) {
-            startAspCoreBackend(port);
+            startAspCoreBackend(addr.port);
         }
     });
 
@@ -286,9 +292,16 @@ function startSocketApiBridge(port) {
 
     // @ts-ignore
     io.on('connection', (socket) => {
-        console.log('Electron Socket: connected!');
+        console.info('Electron Socket: connected!');
+
+        if (authToken && socket.request.headers.authorization !== authToken) {
+            console.warn('Electron Socket authentication failed!');
+            socket.disconnect(true);
+            return;
+        }
+
         socket.on('disconnect', function (reason) {
-            console.log('Got disconnect! Reason: ' + reason);
+            console.debug('Got disconnect! Reason: ' + reason);
             try {
                 ////console.log('requireCache');
                 ////console.log(require.cache['electron-host-hook']);
@@ -308,7 +321,7 @@ function startSocketApiBridge(port) {
             global['electronsocket'].setMaxListeners(0);
         }
 
-        console.log('Electron Socket: loading components...');
+        console.debug('Electron Socket: loading components...');
 
         if (appApi === undefined) appApi = require('./api/app')(socket, app);
         if (browserWindows === undefined) browserWindows = require('./api/browserWindows')(socket, app);
@@ -369,7 +382,7 @@ function startSocketApiBridge(port) {
             console.error(error.message);
         }
 
-        console.log('Electron Socket: startup complete.');
+        console.info('Electron Socket: startup complete.');
     });
 }
 
@@ -383,23 +396,23 @@ function startAspCoreBackend(electronPort) {
             envParam,
             `/electronPort=${electronPort}`,
             `/electronPID=${process.pid}`,
+            `/electronAuthToken=${authToken}`,
             // forward user supplied args (avoid duplicate environment)
             ...forwardedArgs.filter(a => !(envParam && a.startsWith('--environment=')))
         ].filter(p => p);
         let binaryFile = manifestJsonFile.executable;
 
-        const os = require('os');
-        if (os.platform() === 'win32') {
+        if (platform() === 'win32') {
             binaryFile = binaryFile + '.exe';
         }
 
         let binFilePath = path.join(currentBinPath, binaryFile);
         var options = { cwd: currentBinPath };
-        console.log('Starting backend with parameters:', parameters.join(' '));
+        console.debug('Starting backend with parameters:', parameters.join(' '));
         apiProcess = cProcess(binFilePath, parameters, options);
 
         apiProcess.stdout.on('data', (data) => {
-            console.log(`stdout: ${data.toString()}`);
+            console.debug(`stdout: ${data.toString()}`);
         });
     }
 }
@@ -414,22 +427,22 @@ function startAspCoreBackendUnpackaged(electronPort) {
             envParam,
             `/electronPort=${electronPort}`,
             `/electronPID=${process.pid}`,
+            `/electronAuthToken=${authToken}`,
             ...forwardedArgs.filter(a => !(envParam && a.startsWith('--environment=')))
         ].filter(p => p);
         let binaryFile = manifestJsonFile.executable;
 
-        const os = require('os');
-        if (os.platform() === 'win32') {
+        if (platform() === 'win32') {
             binaryFile = binaryFile + '.exe';
         }
 
         let binFilePath = path.join(currentBinPath, binaryFile);
         var options = { cwd: currentBinPath };
-        console.log('Starting backend (unpackaged) with parameters:', parameters.join(' '));
+        console.debug('Starting backend (unpackaged) with parameters:', parameters.join(' '));
         apiProcess = cProcess(binFilePath, parameters, options);
 
         apiProcess.stdout.on('data', (data) => {
-            console.log(`stdout: ${data.toString()}`);
+            console.debug(`stdout: ${data.toString()}`);
         });
     }
 }

src/ElectronNET.Host/package-lock.json

@@ -9,6 +9,7 @@
       "version": "1.0.0",
       "license": "MIT",
       "dependencies": {
+        "@microsoft/signalr": "^8.0.7",
         "dasherize": "^2.0.0",
         "electron-host-hook": "file:./ElectronHostHook",
         "electron-updater": "^6.6.2",
@@ -57,9 +58,9 @@
       }
     },
     "node_modules/@eslint-community/eslint-utils": {
-      "version": "4.9.0",
-      "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.9.0.tgz",
-      "integrity": "sha512-ayVFHdtZ+hsq1t2Dy24wCmGXGe4q9Gu3smhLYALJrr473ZH27MsnSL+LKUlimp4BWJqMDMLmPpx/Q9R3OAlL4g==",
+      "version": "4.9.1",
+      "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.9.1.tgz",
+      "integrity": "sha512-phrYmNiYppR7znFEdqgfWHXR6NCkZEK7hwWDHZUjit/2/U0r6XvkDl0SYnoM51Hq7FhCGdLDT6zxCCOY1hexsQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -140,20 +141,20 @@
       }
     },
     "node_modules/@eslint/eslintrc": {
-      "version": "3.3.1",
-      "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.3.1.tgz",
-      "integrity": "sha512-gtF186CXhIl1p4pJNGZw8Yc6RlshoePRvE0X91oPGb3vZ8pM3qOS9W9NGPat9LziaBV7XrJWGylNQXkGcnM3IQ==",
+      "version": "3.3.4",
+      "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.3.4.tgz",
+      "integrity": "sha512-4h4MVF8pmBsncB60r0wSJiIeUKTSD4m7FmTFThG8RHlsg9ajqckLm9OraguFGZE4vVdpiI1Q4+hFnisopmG6gQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "ajv": "^6.12.4",
+        "ajv": "^6.14.0",
         "debug": "^4.3.2",
         "espree": "^10.0.1",
         "globals": "^14.0.0",
         "ignore": "^5.2.0",
         "import-fresh": "^3.2.1",
-        "js-yaml": "^4.1.0",
-        "minimatch": "^3.1.2",
+        "js-yaml": "^4.1.1",
+        "minimatch": "^3.1.3",
         "strip-json-comments": "^3.1.1"
       },
       "engines": {
@@ -164,9 +165,9 @@
       }
     },
     "node_modules/@eslint/js": {
-      "version": "9.39.1",
-      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.39.1.tgz",
-      "integrity": "sha512-S26Stp4zCy88tH94QbBv3XCuzRQiZ9yXofEILmglYTh/Ug/a9/umqvgFtYBAo3Lp0nsI/5/qH1CCrbdK3AP1Tw==",
+      "version": "9.39.3",
+      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.39.3.tgz",
+      "integrity": "sha512-1B1VkCq6FuUNlQvlBYb+1jDu/gV297TIs/OeiaSR9l1H27SVW55ONE1e1Vp16NqP683+xEGzxYtv4XCiDPaQiw==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -252,6 +253,40 @@
         "url": "https://github.com/sponsors/nzakas"
       }
     },
+    "node_modules/@microsoft/signalr": {
+      "version": "8.0.17",
+      "resolved": "https://registry.npmjs.org/@microsoft/signalr/-/signalr-8.0.17.tgz",
+      "integrity": "sha512-5pM6xPtKZNJLO0Tq5nQasVyPFwi/WBY3QB5uc/v3dIPTpS1JXQbaXAQAPxFoQ5rTBFE094w8bbqkp17F9ReQvA==",
+      "license": "MIT",
+      "dependencies": {
+        "abort-controller": "^3.0.0",
+        "eventsource": "^2.0.2",
+        "fetch-cookie": "^2.0.3",
+        "node-fetch": "^2.6.7",
+        "ws": "^7.5.10"
+      }
+    },
+    "node_modules/@microsoft/signalr/node_modules/ws": {
+      "version": "7.5.10",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-7.5.10.tgz",
+      "integrity": "sha512-+dbF1tHwZpXcbOJdVOkzLDxZP1ailvSxM6ZweXTegylPny803bFhA+vqBYw4s31NSAk4S2Qz+AKXK9a4wkdjcQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8.3.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": "^5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/@sindresorhus/is": {
       "version": "4.6.0",
       "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-4.6.0.tgz",
@@ -314,9 +349,9 @@
       "license": "MIT"
     },
     "node_modules/@types/http-cache-semantics": {
-      "version": "4.0.4",
-      "resolved": "https://registry.npmjs.org/@types/http-cache-semantics/-/http-cache-semantics-4.0.4.tgz",
-      "integrity": "sha512-1m0bIFVc7eJWyve9S0RnuRgcQqF/Xd5QsUZAZeQFr1Q3/p9JWoQQEqmVy+DPTNpGXwhgIetAoYF8JSc33q29QA==",
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/@types/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz",
+      "integrity": "sha512-L3LgimLHXtGkWikKnsPg0/VFx9OGZaC+eN1u4r+OB1XRqH3meBIAVC2zr1WdMH+RHmnRkqliQAOHNJ/E0j/e0Q==",
       "dev": true,
       "license": "MIT"
     },
@@ -338,9 +373,9 @@
       }
     },
     "node_modules/@types/node": {
-      "version": "22.19.1",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.19.1.tgz",
-      "integrity": "sha512-LCCV0HdSZZZb34qifBsyWlUmok6W7ouER+oQIGBScS8EsZsQbrtFTUrDX4hOl+CS6p7cnNC4td+qrSVGSCTUfQ==",
+      "version": "22.19.11",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.19.11.tgz",
+      "integrity": "sha512-BH7YwL6rA93ReqeQS1c4bsPpcfOmJasG+Fkr6Y59q83f9M1WcBRHR2vM+P9eOisYRcN3ujQoiZY8uk5W+1WL8w==",
       "license": "MIT",
       "dependencies": {
         "undici-types": "~6.21.0"
@@ -367,6 +402,18 @@
         "@types/node": "*"
       }
     },
+    "node_modules/abort-controller": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/abort-controller/-/abort-controller-3.0.0.tgz",
+      "integrity": "sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==",
+      "license": "MIT",
+      "dependencies": {
+        "event-target-shim": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=6.5"
+      }
+    },
     "node_modules/accepts": {
       "version": "1.3.8",
       "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz",
@@ -381,9 +428,9 @@
       }
     },
     "node_modules/acorn": {
-      "version": "8.15.0",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
-      "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
+      "version": "8.16.0",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.16.0.tgz",
+      "integrity": "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==",
       "dev": true,
       "license": "MIT",
       "bin": {
@@ -404,9 +451,9 @@
       }
     },
     "node_modules/ajv": {
-      "version": "6.12.6",
-      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
-      "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
+      "version": "6.14.0",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.14.0.tgz",
+      "integrity": "sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -498,9 +545,9 @@
       }
     },
     "node_modules/builder-util-runtime": {
-      "version": "9.3.1",
-      "resolved": "https://registry.npmjs.org/builder-util-runtime/-/builder-util-runtime-9.3.1.tgz",
-      "integrity": "sha512-2/egrNDDnRaxVwK3A+cJq6UOlqOdedGA7JPqCeJjN2Zjk1/QB/6QUi3b714ScIGS7HafFXTyzJEOr5b44I3kvQ==",
+      "version": "9.5.1",
+      "resolved": "https://registry.npmjs.org/builder-util-runtime/-/builder-util-runtime-9.5.1.tgz",
+      "integrity": "sha512-qt41tMfgHTllhResqM5DcnHyDIWNgzHvuY2jDcYP9iaGpkWxTUzV6GQjDeLnlR1/DtdlcsWQbA7sByMpmJFTLQ==",
       "license": "MIT",
       "dependencies": {
         "debug": "^4.3.4",
@@ -616,9 +663,9 @@
       }
     },
     "node_modules/cors": {
-      "version": "2.8.5",
-      "resolved": "https://registry.npmjs.org/cors/-/cors-2.8.5.tgz",
-      "integrity": "sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==",
+      "version": "2.8.6",
+      "resolved": "https://registry.npmjs.org/cors/-/cors-2.8.6.tgz",
+      "integrity": "sha512-tJtZBBHA6vjIAaF6EnIaq6laBBP9aq/Y3ouVJjEfoHbRBcHBAHYcMh/w8LDrk2PvIMMq8gmopa5D4V8RmbrxGw==",
       "license": "MIT",
       "dependencies": {
         "object-assign": "^4",
@@ -626,6 +673,10 @@
       },
       "engines": {
         "node": ">= 0.10"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
       }
     },
     "node_modules/cross-spawn": {
@@ -782,18 +833,18 @@
       "link": true
     },
     "node_modules/electron-updater": {
-      "version": "6.6.2",
-      "resolved": "https://registry.npmjs.org/electron-updater/-/electron-updater-6.6.2.tgz",
-      "integrity": "sha512-Cr4GDOkbAUqRHP5/oeOmH/L2Bn6+FQPxVLZtPbcmKZC63a1F3uu5EefYOssgZXG3u/zBlubbJ5PJdITdMVggbw==",
+      "version": "6.8.3",
+      "resolved": "https://registry.npmjs.org/electron-updater/-/electron-updater-6.8.3.tgz",
+      "integrity": "sha512-Z6sgw3jgbikWKXei1ENdqFOxBP0WlXg3TtKfz0rgw2vIZFJUyI4pD7ZN7jrkm7EoMK+tcm/qTnPUdqfZukBlBQ==",
       "license": "MIT",
       "dependencies": {
-        "builder-util-runtime": "9.3.1",
+        "builder-util-runtime": "9.5.1",
         "fs-extra": "^10.1.0",
         "js-yaml": "^4.1.0",
         "lazy-val": "^1.0.5",
         "lodash.escaperegexp": "^4.1.2",
         "lodash.isequal": "^4.5.0",
-        "semver": "^7.6.3",
+        "semver": "~7.7.3",
         "tiny-typed-emitter": "^2.1.0"
       }
     },
@@ -824,9 +875,9 @@
       }
     },
     "node_modules/electron-updater/node_modules/semver": {
-      "version": "7.7.3",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.3.tgz",
-      "integrity": "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==",
+      "version": "7.7.4",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
+      "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
       "license": "ISC",
       "bin": {
         "semver": "bin/semver.js"
@@ -845,9 +896,9 @@
       }
     },
     "node_modules/electron/node_modules/@types/node": {
-      "version": "20.19.25",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.25.tgz",
-      "integrity": "sha512-ZsJzA5thDQMSQO788d7IocwwQbI8B5OPzmqNvpf3NY/+MHDAS759Wo0gd2WQeXYt5AAAQjzcrTVC6SKCuYgoCQ==",
+      "version": "20.19.33",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.33.tgz",
+      "integrity": "sha512-Rs1bVAIdBs5gbTIKza/tgpMuG1k3U/UMJLWecIMxNdJFDMzcM5LOiLVRYh3PilWEYDIeUDv7bpiHPLPsbydGcw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -865,9 +916,9 @@
       }
     },
     "node_modules/engine.io": {
-      "version": "6.6.4",
-      "resolved": "https://registry.npmjs.org/engine.io/-/engine.io-6.6.4.tgz",
-      "integrity": "sha512-ZCkIjSYNDyGn0R6ewHDtXgns/Zre/NT6Agvq1/WobF7JXgFff4SeDroKiCO3fNJreU9YG429Sc81o4w5ok/W5g==",
+      "version": "6.6.5",
+      "resolved": "https://registry.npmjs.org/engine.io/-/engine.io-6.6.5.tgz",
+      "integrity": "sha512-2RZdgEbXmp5+dVbRm0P7HQUImZpICccJy7rN7Tv+SFa55pH+lxnuw6/K1ZxxBfHoYpSkHLAO92oa8O4SwFXA2A==",
       "license": "MIT",
       "dependencies": {
         "@types/cors": "^2.8.12",
@@ -876,9 +927,9 @@
         "base64id": "2.0.0",
         "cookie": "~0.7.2",
         "cors": "~2.8.5",
-        "debug": "~4.3.1",
+        "debug": "~4.4.1",
         "engine.io-parser": "~5.2.1",
-        "ws": "~8.17.1"
+        "ws": "~8.18.3"
       },
       "engines": {
         "node": ">=10.2.0"
@@ -893,23 +944,6 @@
         "node": ">=10.0.0"
       }
     },
-    "node_modules/engine.io/node_modules/debug": {
-      "version": "4.3.7",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.7.tgz",
-      "integrity": "sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ==",
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
     "node_modules/env-paths": {
       "version": "2.2.1",
       "resolved": "https://registry.npmjs.org/env-paths/-/env-paths-2.2.1.tgz",
@@ -964,9 +998,9 @@
       }
     },
     "node_modules/eslint": {
-      "version": "9.39.1",
-      "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.39.1.tgz",
-      "integrity": "sha512-BhHmn2yNOFA9H9JmmIVKJmd288g9hrVRDkdoIgRCRuSySRUHH7r/DI6aAXW9T1WwUuY3DFgrcaqB+deURBLR5g==",
+      "version": "9.39.3",
+      "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.39.3.tgz",
+      "integrity": "sha512-VmQ+sifHUbI/IcSopBCF/HO3YiHQx/AVd3UVyYL6weuwW+HvON9VYn5l6Zl1WZzPWXPNZrSQpxwkkZ/VuvJZzg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -976,7 +1010,7 @@
         "@eslint/config-helpers": "^0.4.2",
         "@eslint/core": "^0.17.0",
         "@eslint/eslintrc": "^3.3.1",
-        "@eslint/js": "9.39.1",
+        "@eslint/js": "9.39.3",
         "@eslint/plugin-kit": "^0.4.1",
         "@humanfs/node": "^0.16.6",
         "@humanwhocodes/module-importer": "^1.0.1",
@@ -1072,9 +1106,9 @@
       }
     },
     "node_modules/esquery": {
-      "version": "1.6.0",
-      "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.6.0.tgz",
-      "integrity": "sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==",
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.7.0.tgz",
+      "integrity": "sha512-Ap6G0WQwcU/LHsvLwON1fAQX9Zp0A2Y6Y/cJBl9r/JbW90Zyg4/zbG6zzKa2OTALELarYHmKu0GhpM5EO+7T0g==",
       "dev": true,
       "license": "BSD-3-Clause",
       "dependencies": {
@@ -1117,6 +1151,24 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/event-target-shim": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/event-target-shim/-/event-target-shim-5.0.1.tgz",
+      "integrity": "sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/eventsource": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/eventsource/-/eventsource-2.0.2.tgz",
+      "integrity": "sha512-IzUmBGPR3+oUG9dUeXynyNmf91/3zUSJg1lCktzKw47OXuhco54U3r9B7O4XX+Rb1Itm9OZ2b0RkTs10bICOxA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
     "node_modules/extract-zip": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/extract-zip/-/extract-zip-2.0.1.tgz",
@@ -1169,6 +1221,16 @@
         "pend": "~1.2.0"
       }
     },
+    "node_modules/fetch-cookie": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/fetch-cookie/-/fetch-cookie-2.2.0.tgz",
+      "integrity": "sha512-h9AgfjURuCgA2+2ISl8GbavpUdR+WGAM2McW/ovn4tVccegp8ZqCKWSBR8uRdM8dDNlx5WdKRWxBYUwteLDCNQ==",
+      "license": "Unlicense",
+      "dependencies": {
+        "set-cookie-parser": "^2.4.8",
+        "tough-cookie": "^4.0.0"
+      }
+    },
     "node_modules/file-entry-cache": {
       "version": "8.0.0",
       "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz",
@@ -1284,9 +1346,9 @@
       }
     },
     "node_modules/global-agent/node_modules/semver": {
-      "version": "7.7.3",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.3.tgz",
-      "integrity": "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==",
+      "version": "7.7.4",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
+      "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
       "dev": true,
       "license": "ISC",
       "optional": true,
@@ -1614,9 +1676,9 @@
       }
     },
     "node_modules/lodash": {
-      "version": "4.17.21",
-      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
-      "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==",
+      "version": "4.17.23",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.23.tgz",
+      "integrity": "sha512-LgVTMpQtIopCi79SJeDiP0TfWi5CNEc/L/aRdTh3yIvmZXTnheWpKjSZhnvMl8iXbC1tFg9gdHHDMLoV7CnG+w==",
       "license": "MIT"
     },
     "node_modules/lodash.escaperegexp": {
@@ -1701,9 +1763,9 @@
       }
     },
     "node_modules/minimatch": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+      "version": "3.1.4",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.4.tgz",
+      "integrity": "sha512-twmL+S8+7yIsE9wsqgzU3E8/LumN3M3QELrBZ20OdmQ9jB2JvW5oZtBEmft84k/Gs5CG9mqtWc6Y9vW+JEzGxw==",
       "dev": true,
       "license": "ISC",
       "dependencies": {
@@ -1735,6 +1797,26 @@
         "node": ">= 0.6"
       }
     },
+    "node_modules/node-fetch": {
+      "version": "2.7.0",
+      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz",
+      "integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==",
+      "license": "MIT",
+      "dependencies": {
+        "whatwg-url": "^5.0.0"
+      },
+      "engines": {
+        "node": "4.x || >=6.0.0"
+      },
+      "peerDependencies": {
+        "encoding": "^0.1.0"
+      },
+      "peerDependenciesMeta": {
+        "encoding": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/normalize-url": {
       "version": "6.1.0",
       "resolved": "https://registry.npmjs.org/normalize-url/-/normalize-url-6.1.0.tgz",
@@ -1912,6 +1994,18 @@
         "node": ">=0.4.0"
       }
     },
+    "node_modules/psl": {
+      "version": "1.15.0",
+      "resolved": "https://registry.npmjs.org/psl/-/psl-1.15.0.tgz",
+      "integrity": "sha512-JZd3gMVBAVQkSs6HdNZo9Sdo0LNcQeMNP3CozBJb3JYC/QUYZTnKxP+f8oWRX4rHP5EurWxqAHTSwUCjlNKa1w==",
+      "license": "MIT",
+      "dependencies": {
+        "punycode": "^2.3.1"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/lupomontero"
+      }
+    },
     "node_modules/pump": {
       "version": "3.0.3",
       "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.3.tgz",
@@ -1927,12 +2021,17 @@
       "version": "2.3.1",
       "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
       "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=6"
       }
     },
+    "node_modules/querystringify": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/querystringify/-/querystringify-2.2.0.tgz",
+      "integrity": "sha512-FIqgj2EUvTa7R50u0rGsyTftzjYmv/a3hO345bZNrqabNqjtgiDMgmo4mkUjd+nzU5oF3dClKqFIPUKybUyqoQ==",
+      "license": "MIT"
+    },
     "node_modules/queue": {
       "version": "6.0.2",
       "resolved": "https://registry.npmjs.org/queue/-/queue-6.0.2.tgz",
@@ -1955,6 +2054,12 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/requires-port": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/requires-port/-/requires-port-1.0.0.tgz",
+      "integrity": "sha512-KigOCHcocU3XODJxsu8i/j8T9tzT4adHiecwORRQ0ZZFcp7ahwXuRU1m+yuO90C5ZUyGeGfocHDI14M3L3yDAQ==",
+      "license": "MIT"
+    },
     "node_modules/resolve-alpn": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/resolve-alpn/-/resolve-alpn-1.2.1.tgz",
@@ -2005,10 +2110,13 @@
       }
     },
     "node_modules/sax": {
-      "version": "1.4.3",
-      "resolved": "https://registry.npmjs.org/sax/-/sax-1.4.3.tgz",
-      "integrity": "sha512-yqYn1JhPczigF94DMS+shiDMjDowYO6y9+wB/4WgO0Y19jWYk0lQ4tuG5KI7kj4FTp1wxPj5IFfcrz/s1c3jjQ==",
-      "license": "BlueOak-1.0.0"
+      "version": "1.4.4",
+      "resolved": "https://registry.npmjs.org/sax/-/sax-1.4.4.tgz",
+      "integrity": "sha512-1n3r/tGXO6b6VXMdFT54SHzT9ytu9yr7TaELowdYpMqY/Ao7EnlQGmAQ1+RatX7Tkkdm6hONI2owqNx2aZj5Sw==",
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": ">=11.0.0"
+      }
     },
     "node_modules/semver": {
       "version": "6.3.1",
@@ -2045,6 +2153,12 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/set-cookie-parser": {
+      "version": "2.7.2",
+      "resolved": "https://registry.npmjs.org/set-cookie-parser/-/set-cookie-parser-2.7.2.tgz",
+      "integrity": "sha512-oeM1lpU/UvhTxw+g3cIfxXHyJRc/uidd3yK1P242gzHds0udQBYzs3y8j4gCCW+ZJ7ad0yctld8RYO+bdurlvw==",
+      "license": "MIT"
+    },
     "node_modules/shebang-command": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
@@ -2069,15 +2183,15 @@
       }
     },
     "node_modules/socket.io": {
-      "version": "4.8.1",
-      "resolved": "https://registry.npmjs.org/socket.io/-/socket.io-4.8.1.tgz",
-      "integrity": "sha512-oZ7iUCxph8WYRHHcjBEc9unw3adt5CmSNlppj/5Q4k2RIrhl8Z5yY2Xr4j9zj0+wzVZ0bxmYoGSzKJnRl6A4yg==",
+      "version": "4.8.3",
+      "resolved": "https://registry.npmjs.org/socket.io/-/socket.io-4.8.3.tgz",
+      "integrity": "sha512-2Dd78bqzzjE6KPkD5fHZmDAKRNe3J15q+YHDrIsy9WEkqttc7GY+kT9OBLSMaPbQaEd0x1BjcmtMtXkfpc+T5A==",
       "license": "MIT",
       "dependencies": {
         "accepts": "~1.3.4",
         "base64id": "~2.0.0",
         "cors": "~2.8.5",
-        "debug": "~4.3.2",
+        "debug": "~4.4.1",
         "engine.io": "~6.6.0",
         "socket.io-adapter": "~2.5.2",
         "socket.io-parser": "~4.2.4"
@@ -2087,79 +2201,28 @@
       }
     },
     "node_modules/socket.io-adapter": {
-      "version": "2.5.5",
-      "resolved": "https://registry.npmjs.org/socket.io-adapter/-/socket.io-adapter-2.5.5.tgz",
-      "integrity": "sha512-eLDQas5dzPgOWCk9GuuJC2lBqItuhKI4uxGgo9aIV7MYbk2h9Q6uULEh8WBzThoI7l+qU9Ast9fVUmkqPP9wYg==",
+      "version": "2.5.6",
+      "resolved": "https://registry.npmjs.org/socket.io-adapter/-/socket.io-adapter-2.5.6.tgz",
+      "integrity": "sha512-DkkO/dz7MGln0dHn5bmN3pPy+JmywNICWrJqVWiVOyvXjWQFIv9c2h24JrQLLFJ2aQVQf/Cvl1vblnd4r2apLQ==",
       "license": "MIT",
       "dependencies": {
-        "debug": "~4.3.4",
-        "ws": "~8.17.1"
-      }
-    },
-    "node_modules/socket.io-adapter/node_modules/debug": {
-      "version": "4.3.7",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.7.tgz",
-      "integrity": "sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ==",
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
+        "debug": "~4.4.1",
+        "ws": "~8.18.3"
       }
     },
     "node_modules/socket.io-parser": {
-      "version": "4.2.4",
-      "resolved": "https://registry.npmjs.org/socket.io-parser/-/socket.io-parser-4.2.4.tgz",
-      "integrity": "sha512-/GbIKmo8ioc+NIWIhwdecY0ge+qVBSMdgxGygevmdHj24bsfgtCmcUUcQ5ZzcylGFHsN3k4HB4Cgkl96KVnuew==",
+      "version": "4.2.5",
+      "resolved": "https://registry.npmjs.org/socket.io-parser/-/socket.io-parser-4.2.5.tgz",
+      "integrity": "sha512-bPMmpy/5WWKHea5Y/jYAP6k74A+hvmRCQaJuJB6I/ML5JZq/KfNieUVo/3Mh7SAqn7TyFdIo6wqYHInG1MU1bQ==",
       "license": "MIT",
       "dependencies": {
         "@socket.io/component-emitter": "~3.1.0",
-        "debug": "~4.3.1"
+        "debug": "~4.4.1"
       },
       "engines": {
         "node": ">=10.0.0"
       }
     },
-    "node_modules/socket.io-parser/node_modules/debug": {
-      "version": "4.3.7",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.7.tgz",
-      "integrity": "sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ==",
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/socket.io/node_modules/debug": {
-      "version": "4.3.7",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.7.tgz",
-      "integrity": "sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ==",
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
     "node_modules/sprintf-js": {
       "version": "1.1.3",
       "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.1.3.tgz",
@@ -2213,6 +2276,36 @@
       "integrity": "sha512-qVtvMxeXbVej0cQWKqVSSAHmKZEHAvxdF8HEUBFWts8h+xEo5m/lEiPakuyZ3BnCBjOD8i24kzNOiOLLgsSxhA==",
       "license": "MIT"
     },
+    "node_modules/tough-cookie": {
+      "version": "4.1.4",
+      "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-4.1.4.tgz",
+      "integrity": "sha512-Loo5UUvLD9ScZ6jh8beX1T6sO1w2/MpCRpEP7V280GKMVUQ0Jzar2U3UJPsrdbziLEMMhu3Ujnq//rhiFuIeag==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "psl": "^1.1.33",
+        "punycode": "^2.1.1",
+        "universalify": "^0.2.0",
+        "url-parse": "^1.5.3"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/tough-cookie/node_modules/universalify": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/universalify/-/universalify-0.2.0.tgz",
+      "integrity": "sha512-CJ1QgKmNg3CwvAv/kOFmtnEN05f0D/cn9QntgNOQlQF9dgvVTHj3t+8JPdjqawCHk7V/KA+fbUqzZ9XWhcqPUg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 4.0.0"
+      }
+    },
+    "node_modules/tr46": {
+      "version": "0.0.3",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",
+      "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==",
+      "license": "MIT"
+    },
     "node_modules/type-check": {
       "version": "0.4.0",
       "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
@@ -2280,6 +2373,16 @@
         "punycode": "^2.1.0"
       }
     },
+    "node_modules/url-parse": {
+      "version": "1.5.10",
+      "resolved": "https://registry.npmjs.org/url-parse/-/url-parse-1.5.10.tgz",
+      "integrity": "sha512-WypcfiRhfeUP9vvF0j6rw0J3hrWrw6iZv3+22h6iRMJ/8z1Tj6XfLP4DsUix5MhMPnXpiHDoKyoZ/bdCkwBCiQ==",
+      "license": "MIT",
+      "dependencies": {
+        "querystringify": "^2.1.1",
+        "requires-port": "^1.0.0"
+      }
+    },
     "node_modules/vary": {
       "version": "1.1.2",
       "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
@@ -2289,6 +2392,22 @@
         "node": ">= 0.8"
       }
     },
+    "node_modules/webidl-conversions": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",
+      "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==",
+      "license": "BSD-2-Clause"
+    },
+    "node_modules/whatwg-url": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
+      "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==",
+      "license": "MIT",
+      "dependencies": {
+        "tr46": "~0.0.3",
+        "webidl-conversions": "^3.0.0"
+      }
+    },
     "node_modules/which": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
@@ -2323,9 +2442,9 @@
       "license": "ISC"
     },
     "node_modules/ws": {
-      "version": "8.17.1",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-8.17.1.tgz",
-      "integrity": "sha512-6XQFvXTkbfUOZOKKILFG1PDK2NDQs4azKQl26T0YS5CxqWLgXajbPZ+h4gZekJyRqFU8pvnbAbbs/3TgRPy+GQ==",
+      "version": "8.18.3",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz",
+      "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==",
       "license": "MIT",
       "engines": {
         "node": ">=10.0.0"

src/ElectronNET.Host/package.json

@@ -19,7 +19,6 @@
     "dasherize": "^2.0.0",
     "electron-host-hook": "file:./ElectronHostHook",
     "image-size": "^1.2.1",
-    "portscanner": "^2.2.0",
     "electron-updater": "^6.6.2",
     "socket.io": "^4.8.1"
   },

src/ElectronNET.IntegrationTests/Tests/BrowserWindowTests.cs

@@ -257,5 +257,59 @@ namespace ElectronNET.IntegrationTests.Tests
 
             win.SetDocumentEdited(false);
         }
+
+        [IntegrationFact]
+        public async Task BoundsChanged_event_fires_with_updated_bounds()
+        {
+            BrowserWindow window = null;
+
+            try
+            {
+                window = await Electron.WindowManager.CreateWindowAsync(
+                    new BrowserWindowOptions { Show = true, Width = 300, Height = 200 },
+                    "about:blank");
+
+                await Task.Delay(5.seconds());
+
+                var tcs = new TaskCompletionSource<Rectangle>(TaskCreationOptions.RunContinuationsAsynchronously);
+                window.OnBoundsChanged += bounds => tcs.TrySetResult(bounds);
+
+                await Task.Delay(500.ms());
+
+                var target = new Rectangle { X = 25, Y = 35, Width = 420, Height = 310 };
+                window.SetBounds(target);
+
+                var completed = await Task.WhenAny(tcs.Task, Task.Delay(3.seconds()));
+                completed.Should().Be(tcs.Task);
+
+                var observed = await tcs.Task;
+
+                observed.Width.Should().Be(target.Width);
+                observed.Height.Should().Be(target.Height);
+            }
+            finally
+            {
+                window?.Destroy();
+            }
+        }
+
+        [IntegrationFact]
+        public async Task BoundsChanged_event_can_fire_on_resize_of_existing_window()
+        {
+            var win = this.MainWindow;
+
+            var tcs = new TaskCompletionSource<Rectangle>(TaskCreationOptions.RunContinuationsAsynchronously);
+            win.OnBoundsChanged += bounds => tcs.TrySetResult(bounds);
+
+            await Task.Delay(500.ms());
+            win.SetBounds(new Rectangle { X = 10, Y = 10, Width = 560, Height = 440 });
+
+            var completed = await Task.WhenAny(tcs.Task, Task.Delay(3.seconds()));
+            completed.Should().Be(tcs.Task);
+
+            var boundsObserved = await tcs.Task;
+            boundsObserved.Width.Should().Be(560);
+            boundsObserved.Height.Should().Be(440);
+        }
     }
 }