Merge pull request #966 from softworkz/submit_migrationchecks

Add migration checks

.github/FUNDING.yml

@@ -1,6 +1,6 @@
 # These are supported funding model platforms
 
-github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+github: [GregorBiswanger, FlorianRappl]
 patreon: # Replace with a single Patreon username
 open_collective: # Replace with a single Open Collective username
 ko_fi: # Replace with a single Ko-fi username

.github/workflows/ci.yml

@@ -0,0 +1,51 @@
+name: CI
+
+on: [push, pull_request]
+
+env:
+  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+  NUGET_API_KEY: ${{ secrets.NUGET_API_KEY }}
+
+jobs:
+  # linux:
+  #   runs-on: ubuntu-latest
+  #   timeout-minutes: 10
+
+  #   steps:
+  #   - uses: actions/checkout@v4
+
+  #   - name: Setup dotnet
+  #     uses: actions/setup-dotnet@v4
+  #     with:
+  #       dotnet-version: |
+  #         6.0.x
+  #         8.0.x
+  #         10.0.x
+
+  #   - name: Build
+  #     run: ./build.sh
+
+  windows:
+    runs-on: windows-latest
+    timeout-minutes: 10
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Setup dotnet
+      uses: actions/setup-dotnet@v4
+      with:
+        dotnet-version: |
+          6.0.x
+          8.0.x
+          10.0.x
+
+    - name: Build
+      run: |
+        if ($env:GITHUB_REF -eq "refs/heads/main") {
+          .\build.ps1 -Target Publish
+        } elseif ($env:GITHUB_REF -eq "refs/heads/develop") {
+          .\build.ps1 -Target PrePublish
+        } else {
+          .\build.ps1
+        }

.github/workflows/integration-tests.yml

@@ -0,0 +1,216 @@
+name: Tests
+
+on:
+  push:
+    branches: [ develop, main ]
+  pull_request:
+    branches: [ develop, main ]
+
+concurrency:
+  group: integration-tests-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  tests:
+    name: Integration Tests (${{ matrix.os }} / Electron ${{ matrix.electronVersion }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-22.04, ubuntu-24.04, windows-2022, windows-2025, macos-14, macos-15-intel, macos-26]
+        electronVersion: ['30.4.0', '38.2.2']
+        include:
+          - os: ubuntu-22.04
+            rid: linux-x64
+          - os: ubuntu-24.04
+            rid: linux-x64
+          - os: windows-2022
+            rid: win-x64
+          - os: windows-2025
+            rid: win-x64
+          - os: macos-14
+            rid: osx-arm64
+          - os: macos-15-intel
+            rid: osx-x64
+          - os: macos-26
+            rid: osx-arm64
+
+    env:
+      DOTNET_SKIP_FIRST_TIME_EXPERIENCE: 1
+      DOTNET_NOLOGO: 1
+      CI: true
+      ELECTRON_ENABLE_LOGGING: 1
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: '10.0.x'
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+
+      - name: Restore
+        run: dotnet restore -r ${{ matrix.rid }} -p:RuntimeIdentifier=${{ matrix.rid }} -p:ElectronVersion=${{ matrix.electronVersion }} src/ElectronNET.IntegrationTests/ElectronNET.IntegrationTests.csproj
+
+      - name: Build
+        run: dotnet build --no-restore -c Release -r ${{ matrix.rid }} -p:RuntimeIdentifier=${{ matrix.rid }} -p:ElectronVersion=${{ matrix.electronVersion }} src/ElectronNET.IntegrationTests/ElectronNET.IntegrationTests.csproj
+
+      - name: Install Linux GUI dependencies
+        if: runner.os == 'Linux'
+        run: |
+          set -e
+          sudo apt-get update
+          . /etc/os-release
+          if [ "$VERSION_ID" = "24.04" ]; then ALSA_PKG=libasound2t64; else ALSA_PKG=libasound2; fi
+          echo "Using ALSA package: $ALSA_PKG"
+          sudo apt-get install -y xvfb \
+            libgtk-3-0 libnss3 libgdk-pixbuf-2.0-0 libdrm2 libgbm1 libxss1 libxtst6 libatk-bridge2.0-0 libatk1.0-0 libatspi2.0-0 libx11-xcb1 "$ALSA_PKG"
+
+      - name: Run tests (Linux)
+        if: runner.os == 'Linux'
+        continue-on-error: true
+        run: |
+          mkdir -p test-results
+          xvfb-run -a dotnet test src/ElectronNET.IntegrationTests/ElectronNET.IntegrationTests.csproj \
+            -c Release --no-build -r ${{ matrix.rid }} -p:RuntimeIdentifier=${{ matrix.rid }} -p:ElectronVersion=${{ matrix.electronVersion }} \
+            --logger "trx;LogFileName=${{ matrix.os }}-electron-${{ matrix.electronVersion }}.trx" \
+            --logger "console;verbosity=detailed" \
+            --results-directory test-results
+
+      - name: Run tests (Windows)
+        if: runner.os == 'Windows'
+        continue-on-error: true
+        run: |
+          New-Item -ItemType Directory -Force -Path test-results | Out-Null
+          dotnet test src/ElectronNET.IntegrationTests/ElectronNET.IntegrationTests.csproj -c Release --no-build -r ${{ matrix.rid }} -p:RuntimeIdentifier=${{ matrix.rid }} -p:ElectronVersion=${{ matrix.electronVersion }} --logger "trx;LogFileName=${{ matrix.os }}-electron-${{ matrix.electronVersion }}.trx" --logger "console;verbosity=detailed" --results-directory test-results
+
+      - name: Run tests (macOS)
+        if: runner.os == 'macOS'
+        continue-on-error: true
+        run: |
+          mkdir -p test-results
+          dotnet test src/ElectronNET.IntegrationTests/ElectronNET.IntegrationTests.csproj -c Release --no-build -r ${{ matrix.rid }} -p:RuntimeIdentifier=${{ matrix.rid }} -p:ElectronVersion=${{ matrix.electronVersion }} --logger "trx;LogFileName=${{ matrix.os }}-electron-${{ matrix.electronVersion }}.trx" --logger "console;verbosity=detailed" --results-directory test-results
+
+      - name: Upload raw test results
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: test-results-${{ matrix.os }}-electron-${{ matrix.electronVersion }}
+          path: test-results/*.trx
+          retention-days: 7
+
+  summary:
+    name: Test Results
+    runs-on: ubuntu-24.04
+    if: always()
+    needs: [tests]
+
+    permissions:
+      actions: read
+      contents: read
+      checks: write
+      pull-requests: write
+
+    steps:
+      - name: Download all test results
+        uses: actions/download-artifact@v4
+        with:
+          path: test-results
+
+      - name: Setup .NET (for CTRF conversion)
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: '10.0.x'
+
+      - name: Install CTRF TRX→CTRF converter (dotnet tool)
+        run: |
+          dotnet new tool-manifest
+          dotnet tool install DotnetCtrfJsonReporter --local
+
+      - name: Convert TRX → CTRF and clean names (filePath=OS|Electron X.Y.Z)
+        shell: bash
+        run: |
+          set -euo pipefail
+          mkdir -p ctrf
+          shopt -s globstar nullglob
+          conv=0
+          for trx in test-results/**/*.trx; do
+            base="$(basename "$trx" .trx)"  # e.g. ubuntu-22.04-electron-30.4.0
+            os="${base%%-electron-*}"
+            electron="${base#*-electron-}"
+            label="$os|Electron $electron"
+            outdir="ctrf/${label}"
+            mkdir -p "$outdir"
+            out="${outdir}/ctrf-report.json"
+
+            dotnet tool run DotnetCtrfJsonReporter -p "$trx" -d "$outdir" -f "ctrf-report.json"
+
+            jq --arg fp "$label" '.results.tests |= map(.filePath = $fp)' "$out" > "${out}.tmp" && mv "${out}.tmp" "$out"
+
+            echo "Converted & normalized $trx -> $out"
+            conv=$((conv+1))
+          done
+          echo "Processed $conv TRX file(s)"
+
+      - name: Publish Test Report
+        if: always()
+        uses: ctrf-io/github-test-reporter@v1
+        with:
+          report-path: 'ctrf/**/*.json'
+          summary: true
+          pull-request: false
+          status-check: false
+          status-check-name: 'Integration Tests'
+          use-suite-name: true
+          update-comment: true
+          always-group-by: true
+          overwrite-comment: true
+          exit-on-fail: true
+          group-by: 'suite'
+          upload-artifact: true
+          fetch-previous-results: true
+          summary-report: false
+          summary-delta-report: true
+          github-report: true
+          test-report: false
+          test-list-report: false
+          failed-report: true
+          failed-folded-report: false
+          skipped-report: true
+          suite-folded-report: true
+          suite-list-report: false
+          file-report: true
+          previous-results-report: true
+          insights-report: true
+          flaky-report: true
+          flaky-rate-report: true
+          fail-rate-report: false
+          slowest-report: false
+          report-order: 'summary-delta-report,failed-report,skipped-report,suite-folded-report,file-report,previous-results-report,github-report'
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+
+      - name: Save PR Number
+        if: github.event_name == 'pull_request'
+        run: echo "PR_NUMBER=${{ github.event.pull_request.number }}" >> $GITHUB_ENV
+
+      - name: Write PR Number to File
+        if: github.event_name == 'pull_request'
+        run: echo "$PR_NUMBER" > pr_number.txt
+        shell: bash
+
+      - name: Upload PR Number Artifact
+        if: github.event_name == 'pull_request'
+        uses: actions/upload-artifact@v4
+        with:
+          name: pr_number
+          path: pr_number.txt
+
+      - name: Summary
+        run: echo "All matrix test jobs completed."

.github/workflows/pr-comment.yml

@@ -0,0 +1,81 @@
+name: Create PR Comments
+
+on:
+  workflow_run:
+    workflows: ["Tests"]
+    types: [completed]
+
+permissions:
+  contents: read
+  actions: read
+  pull-requests: write
+
+jobs:
+  pr-comment:
+    name: Post Test Result as PR comment
+    runs-on: ubuntu-24.04
+    if: github.event.workflow_run.event == 'pull_request'
+
+    steps:
+      - name: Download CTRF artifact
+        uses: dawidd6/action-download-artifact@v8
+        with:
+          github_token: ${{ github.token }}
+          run_id: ${{ github.event.workflow_run.id }}
+          name: ctrf-report
+          path: ctrf
+
+      - name: Download PR Number Artifact
+        uses: dawidd6/action-download-artifact@v8
+        with:
+          github_token: ${{ github.token }}
+          run_id: ${{ github.event.workflow_run.id }}
+          name: pr_number
+          path: pr_number
+
+      - name: Read PR Number
+        run: |
+          set -Eeuo pipefail
+          FILE='pr_number/pr_number.txt'
+
+          # Ensure file exists
+          if [ ! -f "$FILE" ] || [ -L "$FILE" ]; then
+            echo "Error: $FILE is missing or is not a regular file." >&2
+            exit 1
+          fi
+
+          # Chec file size
+          if [ "$(wc -c < "$FILE" | tr -d ' ')" -gt 200 ]; then
+            echo "Error: $FILE is too large." >&2
+            exit 1
+          fi
+
+          # Read first line
+          PR_NUMBER=""
+          IFS= read -r PR_NUMBER < "$FILE" || true
+
+          # Validate whether it's a number
+          if ! [[ "$PR_NUMBER" =~ ^[0-9]{1,10}$ ]]; then
+            echo "Error: PR_NUMBER is not a valid integer on the first line." >&2
+            exit 1
+          fi
+
+          printf 'PR_NUMBER=%s\n' "$PR_NUMBER" >> "$GITHUB_ENV"
+
+      - name: Post PR Comment
+        uses: ctrf-io/github-test-reporter@v1
+        with:
+          report-path: 'ctrf/**/*.json'
+          issue: ${{ env.PR_NUMBER }}
+
+          summary: true
+          pull-request: true
+          use-suite-name: true
+          update-comment: true
+          always-group-by: true
+          overwrite-comment: true
+          upload-artifact: false
+
+          pull-request-report: true
+        env:
+          GITHUB_TOKEN: ${{ github.token }}

.github/workflows/publish-wiki.yml

@@ -0,0 +1,59 @@
+name: Publish wiki
+on:
+  push:
+    branches: [electronnet_core, main]
+  workflow_dispatch:
+concurrency:
+  group: publish-wiki
+  cancel-in-progress: true
+permissions:
+  contents: write
+jobs:
+  publish-wiki:
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Remove level 1 headings from Markdown files
+        shell: bash
+        run: |
+          find docs/ -name '*.md' -exec sed -i '1d' {} \;
+      - name: Move all files to root folder
+        shell: bash
+        run: |
+          mv docs/*/* docs/
+      - name: Delete unwanted files
+        shell: bash
+        run: |
+          # rm docs/*.xlsm
+          # rm docs/*.pptx
+          rm docs/*.shproj
+      - name: Stripping file extensions....
+        uses: softworkz/strip-markdown-extensions-from-links-action@main
+        with:
+          path: ./docs/
+      - name: Copy Changelog
+        shell: bash
+        run: |
+          cp Changelog.md docs/RelInfo/ 2>/dev/null || true
+      - name: Copy images to wiki/wiki folder
+        shell: bash
+        run: |
+          mkdir docs/wiki
+          cp docs/*.svg docs/wiki/ 2>/dev/null || true
+          cp docs/*.png docs/wiki/ 2>/dev/null || true
+          cp docs/*.jpg docs/wiki/ 2>/dev/null || true
+          cp docs/*.gif docs/wiki/ 2>/dev/null || true
+          cp docs/*.mp4 docs/wiki/ 2>/dev/null || true
+      - name: Commit and push changes
+        run: |
+          git config --global user.name "GitHub Action"
+          git config --global user.email "action@github.com"
+          git add -A
+          git commit -m "Automatically update Markdown files" || echo "No changes to commit"
+      - uses: Andrew-Chen-Wang/github-wiki-action@v4.4.0
+        with:
+          path: docs/
+          ignore: |
+            '**/*.xlsm'
+            '**/*.pptx'
+            '**/*.shproj'

.github/workflows/trailing-whitespace-check.yml

@@ -0,0 +1,85 @@
+name: Trailing Whitespace Check
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+
+jobs:
+  check-trailing-whitespace:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+
+    - name: Check for trailing whitespace
+      run: |
+        echo "Checking for trailing whitespace in changed files..."
+
+        # Get the base branch
+        BASE_SHA="${{ github.event.pull_request.base.sha }}"
+        HEAD_SHA="${{ github.event.pull_request.head.sha }}"
+
+        # Get list of changed files (excluding deleted files)
+        CHANGED_FILES=$(git diff --name-only --diff-filter=d "$BASE_SHA" "$HEAD_SHA")
+
+        if [ -z "$CHANGED_FILES" ]; then
+          echo "No files to check."
+          exit 0
+        fi
+
+        # File patterns to check (text files)
+        PATTERNS="\.cs$|\.csproj$|\.sln$|\.ts$|\.html$|\.css$|\.scss$"
+
+        # Directories and file patterns to exclude
+        EXCLUDE_PATTERNS="(^|\/)(\.|node_modules|bin|obj|artifacts|packages|\.vs|\.nuke\/temp)($|\/)"
+
+        ERRORS_FOUND=0
+        TEMP_FILE=$(mktemp)
+
+        while IFS= read -r file; do
+          # Skip if file doesn't exist (shouldn't happen with --diff-filter=d, but just in case)
+          if [ ! -f "$file" ]; then
+            continue
+          fi
+
+          # Check if file matches patterns to check
+          if ! echo "$file" | grep -qE "$PATTERNS"; then
+            continue
+          fi
+
+          # Check if file should be excluded
+          if echo "$file" | grep -qE "$EXCLUDE_PATTERNS"; then
+            continue
+          fi
+
+          # Find trailing whitespace lines, excluding XML doc placeholder lines that are exactly "/// " (one space)
+          MATCHES=$(grep -n '[[:space:]]$' "$file" | grep -vE '^[0-9]+:[[:space:]]*/// $' || true)
+
+          if [ -n "$MATCHES" ]; then
+            echo "❌ Trailing whitespace found in: $file"
+            echo "$MATCHES" | head -10
+            TOTAL=$(echo "$MATCHES" | wc -l)
+            if [ "$TOTAL" -gt 10 ]; then
+              echo "   ... and $(($TOTAL - 10)) more lines"
+            fi
+            echo "1" >> "$TEMP_FILE"
+          fi
+        done <<< "$CHANGED_FILES"
+
+        ERRORS_FOUND=$(wc -l < "$TEMP_FILE" 2>/dev/null || echo "0")
+        rm -f "$TEMP_FILE"
+
+        if [ "$ERRORS_FOUND" -gt 0 ]; then
+          echo ""
+          echo "❌ Found trailing whitespace in $ERRORS_FOUND file(s)."
+          echo "Please remove trailing whitespace from the files listed above."
+          exit 1
+        else
+          echo "✅ No trailing whitespace found in changed files."
+          exit 0
+        fi

.gitignore

@@ -44,7 +44,7 @@ dlldata.c
 project.lock.json
 project.fragment.lock.json
 artifacts/
-!/artifacts/readme.md
+!/artifacts/.gitkeep
 
 *_i.c
 *_p.c
@@ -263,3 +263,7 @@ __pycache__/
 
 # Mac Only settings file
 .DS_Store
+
+# Nuke build tool
+.nuke/temp
+/publish.cmd

.nuke/build.schema.json

@@ -0,0 +1,137 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "definitions": {
+    "Host": {
+      "type": "string",
+      "enum": [
+        "AppVeyor",
+        "AzurePipelines",
+        "Bamboo",
+        "Bitbucket",
+        "Bitrise",
+        "GitHubActions",
+        "GitLab",
+        "Jenkins",
+        "Rider",
+        "SpaceAutomation",
+        "TeamCity",
+        "Terminal",
+        "TravisCI",
+        "VisualStudio",
+        "VSCode"
+      ]
+    },
+    "ExecutableTarget": {
+      "type": "string",
+      "enum": [
+        "Clean",
+        "Compile",
+        "Default",
+        "Package",
+        "PrePublish",
+        "Publish",
+        "PublishPackages",
+        "PublishPreRelease",
+        "PublishRelease",
+        "Restore",
+        "RunUnitTests"
+      ]
+    },
+    "Verbosity": {
+      "type": "string",
+      "description": "",
+      "enum": [
+        "Verbose",
+        "Normal",
+        "Minimal",
+        "Quiet"
+      ]
+    },
+    "NukeBuild": {
+      "properties": {
+        "Continue": {
+          "type": "boolean",
+          "description": "Indicates to continue a previously failed build attempt"
+        },
+        "Help": {
+          "type": "boolean",
+          "description": "Shows the help text for this build assembly"
+        },
+        "Host": {
+          "description": "Host for execution. Default is 'automatic'",
+          "$ref": "#/definitions/Host"
+        },
+        "NoLogo": {
+          "type": "boolean",
+          "description": "Disables displaying the NUKE logo"
+        },
+        "Partition": {
+          "type": "string",
+          "description": "Partition to use on CI"
+        },
+        "Plan": {
+          "type": "boolean",
+          "description": "Shows the execution plan (HTML)"
+        },
+        "Profile": {
+          "type": "array",
+          "description": "Defines the profiles to load",
+          "items": {
+            "type": "string"
+          }
+        },
+        "Root": {
+          "type": "string",
+          "description": "Root directory during build execution"
+        },
+        "Skip": {
+          "type": "array",
+          "description": "List of targets to be skipped. Empty list skips all dependencies",
+          "items": {
+            "$ref": "#/definitions/ExecutableTarget"
+          }
+        },
+        "Target": {
+          "type": "array",
+          "description": "List of targets to be invoked. Default is '{default_target}'",
+          "items": {
+            "$ref": "#/definitions/ExecutableTarget"
+          }
+        },
+        "Verbosity": {
+          "description": "Logging verbosity during build execution. Default is 'Normal'",
+          "$ref": "#/definitions/Verbosity"
+        }
+      }
+    }
+  },
+  "allOf": [
+    {
+      "properties": {
+        "CommonPropsFilePath": {
+          "type": "string",
+          "description": "common.props file path - to determine the configured version"
+        },
+        "Configuration": {
+          "type": "string",
+          "description": "Configuration to build - Default is 'Debug' (local) or 'Release' (server)",
+          "enum": [
+            "Debug",
+            "Release"
+          ]
+        },
+        "ReleaseNotesFilePath": {
+          "type": "string",
+          "description": "ReleaseNotesFilePath - To determine the lates changelog version"
+        },
+        "Solution": {
+          "type": "string",
+          "description": "Path to a solution file that is automatically loaded"
+        }
+      }
+    },
+    {
+      "$ref": "#/definitions/NukeBuild"
+    }
+  ]
+}

.nuke/parameters.json

@@ -0,0 +1,4 @@
+{
+  "$schema": "./build.schema.json",
+  "Solution": "src/ElectronNET.Lean.sln"
+}

.travis.yml

@@ -1,8 +0,0 @@
-language: csharp
-mono: none
-dist: xenial
-dotnet: 3.1
-before_script:
-  - export PATH="$PATH:/home/travis/.dotnet/tools"
-script:
-  - ./buildAll.sh

.vscode/launch.json

@@ -10,9 +10,9 @@
             "request": "launch",
             "preLaunchTask": "build",
             // If you have changed target frameworks, make sure to update the program path.
-            "program": "${workspaceRoot}/ElectronNET.CLI/bin/Debug/netcoreapp2.0/dotnet-electronize.dll",
+            "program": "${workspaceRoot}/src/ElectronNET.CLI/bin/Debug/net8.0/dotnet-electronize.dll",
             "args": [],
-            "cwd": "${workspaceRoot}/ElectronNET.CLI",
+            "cwd": "${workspaceRoot}/src/ElectronNET.CLI",
             // For more information about the 'console' field, see https://github.com/OmniSharp/omnisharp-vscode/blob/master/debugger-launchjson.md#console-terminal-window
             "console": "internalConsole",
             "stopAtEntry": false,

.vscode/tasks.json

@@ -1,16 +1,18 @@
 {
-    "version": "0.1.0",
-    "command": "dotnet",
-    "isShellCommand": true,
-    "args": [],
-    "tasks": [
-        {
-            "taskName": "build",
-            "args": [
-                "${workspaceRoot}/ElectronNET.CLI/ElectronNET.CLI.csproj"
-            ],
-            "isBuildCommand": true,
-            "problemMatcher": "$msCompile"
-        }
-    ]
-}
+  "version": "2.0.0",
+  "command": "dotnet",
+  "args": [],
+  "tasks": [
+    {
+      "label": "build",
+      "type": "shell",
+      "command": "dotnet",
+      "args": ["build", "${workspaceRoot}/src/ElectronNET.CLI/ElectronNET.CLI.csproj"],
+      "problemMatcher": "$msCompile",
+      "group": {
+        "_id": "build",
+        "isDefault": false
+      }
+    }
+  ]
+}

Changelog.md

@@ -1,353 +1,104 @@
-# Not released
-
-# 13.5.1
-
-ElectronNET.CLI:
-
-* New Feature: Using exit code instead of seek for the term 'error' (thanks [TSrgy](https://github.com/TSrgy)) [\#562](https://github.com/ElectronNET/Electron.NET/pull/562)  
-* Fixed bug: Allow for property overrides to be passed in (thanks [danatcofo](https://github.com/danatcofo)) [\#531](https://github.com/ElectronNET/Electron.NET/pull/531)  
-Use `/p:propertyName=value` or `/property:propertyName=value` to pass in property overrides. This is equivalent to the `-p:` option documented here: [https://docs.microsoft.com/en-us/dotnet/core/tools/dotnet-publish](https://docs.microsoft.com/en-us/dotnet/core/tools/dotnet-publish)  
-* Fixed bug: Add ability to pass an argument for "Version" for both the "dotnet publish" and "electron-builder" commands (thanks [tub5](https://github.com/tub5)) [\#546](https://github.com/ElectronNET/Electron.NET/pull/546)  
-* Fixed bug: Version flag not persisting with the referenced executable (thanks [tub5](https://github.com/tub5)) [\#585](https://github.com/ElectronNET/Electron.NET/pull/585)  
-* Fixed bug: Changes PublishSingleFile default to false for NET5 compatibility (thanks [cristiangiagante](https://github.com/cristiangiagante)) [\#570](https://github.com/ElectronNET/Electron.NET/pull/570)  
-  
-ElectronNET.API:  
-  
-* New Feature: Native Electron 13.1.5 support, but not all new features (we search contributors)   
-* Breaking API Changes (from native Electron 13.1.5): 
-   - `Shell.MoveItemToTrashAsync` renamed with `Shell.TrashItemAsync`  
-   - The deprecated extension APIs have been removed: `BrowserWindow.GetAllExtensionsAsync()`, `BrowserWindow.RemoveExtension()`, `BrowserWindow.AddExtensionAsync()`. Use the session APIs instead: `Session.GetAllExtensionsAsync()`, `Session.RemoveExtension()`, `Session.LoadExtensionAsync()`.  
-* New Feature: singleInstance handle command line arguments [\#520](https://github.com/ElectronNET/Electron.NET/issues/520)  
-* New Feature: Add WebContents [insertCSS](https://www.electronjs.org/docs/api/web-contents#contentsinsertcsscss-options) functionality (thanks [nfichter](https://github.com/nfichter)) [\#559](https://github.com/ElectronNET/Electron.NET/pull/559)  
-* New Feature: Allow IpcMain to send IPC messages to BrowserViews (thanks [nfichter](https://github.com/nfichter)) [\#560](https://github.com/ElectronNET/Electron.NET/pull/560)  
-* New Feature: Add support for proxies that require basic username/password authentication (thanks [nfichter](https://github.com/nfichter)) [\#561](https://github.com/ElectronNET/Electron.NET/pull/561)  
-* New Feature: Add PostData to LoadURLOptions to allow http-posts in LoadURL calls (thanks [Funkrusha](https://github.com/Funkrusha)) [\#547](https://github.com/ElectronNET/Electron.NET/pull/547)  
-* Fixed bug: Fix splash screen interaction causing crashes, ghost dragging, and resizable behavior #540 (thanks [MiniguyBrendan](https://github.com/MiniguyBrendan)) [\#540](https://github.com/ElectronNET/Electron.NET/pull/540)  
-* Fixed bug: Vibrancy serialization fix (thanks [tantumalice](https://github.com/tantumalice)) [\#573](https://github.com/ElectronNET/Electron.NET/pull/573)  
-
-
-# Released
-
-# 11.5.1
-
-ElectronNET.CLI:
-
-* New Feature: Added new build and start commandline options for single exe (thanks [nathanwienand](https://github.com/nathanwienand)) [\#506](https://github.com/ElectronNET/Electron.NET/pull/506)
-* New Feature: Set a description of the app in `electron.manifest.json` (thanks [BurtsevC](https://github.com/BurtsevC)) [\#433](https://github.com/ElectronNET/Electron.NET/pull/433)
-* New Feature: Set a target for the start command (thanks [gabecook](https://github.com/gabecook)) [\#463](https://github.com/ElectronNET/Electron.NET/pull/463)
-* New Feature: `electronize init` support for F# projects (thanks [kojo12228](https://github.com/kojo12228)) [\#457](https://github.com/ElectronNET/Electron.NET/pull/457)
-* New Feature: Linux support for the buildAll.sh (thanks [duncanawoods](https://github.com/duncanawoods)) [\#465](https://github.com/ElectronNET/Electron.NET/pull/465)
-* Fixed bug: ERR_UNKNOWN_URL_SCHEME by intercepting file:// protocol (thanks [duncanawoods](https://github.com/duncanawoods)) [\#467](https://github.com/ElectronNET/Electron.NET/pull/467)
-
-ElectronNET.API:
-
-* New Feature: Native Electron 11.1.1 support, but not all new features (we search contributors)
-* Breaking API Changes (from native Electron 11.0): - Removed: BrowserView.{destroy, fromId, fromWebContents, getAllViews} and id property of BrowserView
-* New Feature: Upgrade to .NET 5 (thanks [scottkuhl](https://github.com/scottkuhl)) [\#509](https://github.com/ElectronNET/Electron.NET/pull/509)
-* New Feature: Extension Method for adding the Electron static class members to the standard MS DI Containers, this is a QOL issue only. `services.AddElectron()` (thanks [danatcofo](https://github.com/danatcofo )) [\#528](https://github.com/ElectronNET/Electron.NET/pull/528)
-* New Feature: SetMenu completed for the Dock (MacOS) (thanks [danatcofo](https://github.com/danatcofo )) [\#528](https://github.com/ElectronNET/Electron.NET/pull/528)
-
-Example for the Dock Menu
-
-`Electron.Dock.SetMenu(new [] {
-   new MenuItem {
-      Label = "Dock Menu Item",
-      Click = () => {
-         // do something
-      }
-   },
-});`
-
-Example for consuming the activate event (MacOs only)
-
-`Electron.App.On("activate", obj => {
-   var hasWindows = (bool)obj;
-   // do something
-});`
-
-* New Feature: On and Once implementations for the App and Tray to cover the plethora of events that are not mapped explicitly in those two modules. (thanks [danatcofo](https://github.com/danatcofo )) [\#528](https://github.com/ElectronNET/Electron.NET/pull/528)
-* New Feature: Adding the `EnableRemoteModule` property to the WebPreferences object. As of Electron 10, this property defaulted to false and without it exposed you can't use the remote module within a window. (thanks [danatcofo](https://github.com/danatcofo )) [\#528](https://github.com/ElectronNET/Electron.NET/pull/528)
-* New Feature: Adding a configurable default electron port. (thanks [aarong-av](https://github.com/aarong-av)) [\#505](https://github.com/ElectronNET/Electron.NET/pull/505)
-* New Feature: Added support for launching the application with a file on MacOS (thanks [dlitty](https://github.com/dlitty)) [\#478](https://github.com/ElectronNET/Electron.NET/pull/478)
-* Improved: Avoid Blocking Calls in App and AutoUpdater (thanks [freosc](https://github.com/freosc)) [\#474](https://github.com/ElectronNET/Electron.NET/pull/474)
-* Fixed bug: Maintain references between socket.io connection events (thanks [danatcofo](https://github.com/danatcofo )) [\#468](https://github.com/ElectronNET/Electron.NET/pull/486)
-* Fixed bug: Set default WebPreferences.DefaultFontSize (thanks [duncanawoods](https://github.com/duncanawoods)) [\#468](https://github.com/ElectronNET/Electron.NET/pull/468)
-
-# 9.31.2
-
-* Electron-Builder fixed for Windows builds.
-
-# 9.31.1
-
-ElectronNET.CLI:
-
-* New Feature: Added config parameter (thanks [konstantingross](https://github.com/konstantingross)) [\#409](https://github.com/ElectronNET/Electron.NET/pull/409)
-* New Feature: Set the configuration environment with the electron.manifest.json file.
-* Fixed bug: Custom user path removed and replaced by the correct directory with VS macro (When ElectronNET.CLI is the Startup Project, press F5 (Debug) and the ElectronNET.WebApp starts correctly without error!) (thanks [konstantingross](https://github.com/konstantingross)) [\#409](https://github.com/ElectronNET/Electron.NET/pull/409)
-
-ElectronNET.API:
-
-* New Feature: Native Electron 9.0.3 support, but not all new features (we search contributors)
-* New Feature: PowerMonitor API Support (thanks [gustavo-lara-molina](https://github.com/gustavo-lara-molina)) [\#399](https://github.com/ElectronNET/Electron.NET/pull/399) [\#423](https://github.com/ElectronNET/Electron.NET/pull/423)
-* New Feature: NativeTheme API Support (thanks [konstantingross](https://github.com/konstantingross)) [\#402](https://github.com/ElectronNET/Electron.NET/pull/402)
-* New Feature: Cookie API Support (thanks [freosc](https://github.com/freosc)) [\#413](https://github.com/ElectronNET/Electron.NET/pull/413)
-* Changed Feature: Removed dock methods from App API and moved to Dock API (thanks [konstantingross](https://github.com/konstantingross)) [\#422](https://github.com/ElectronNET/Electron.NET/pull/422)
-* App-Api Enhancement: MenuItems with Submenus need an submenu type workaround [\#412](https://github.com/ElectronNET/Electron.NET/issues/412)
-* App-Api Enhancement: Added UserAgentFallback (thanks [Mandrakia](https://github.com/Mandrakia)) [\#406](https://github.com/ElectronNET/Electron.NET/pull/406)
-* App-Api Enhancement: Summaries rewritten, new App.IsReady / App.HasSingleInstanceLock property, App.Ready event, App.Focus with force parameter method, many parameters changes (thanks [konstantingross](https://github.com/konstantingross)) [\#415](https://github.com/ElectronNET/Electron.NET/pull/415) [\#422](https://github.com/ElectronNET/Electron.NET/pull/422)
-* App-Api Enhancement: New App.IsReady property and App.Ready event (thanks [konstantingross](https://github.com/konstantingross)) [\#415](https://github.com/ElectronNET/Electron.NET/pull/415)
-* Shell-Api Enhancement: API fixes for Electron 9.0.0 / Added missing parameters / Summaries rewritten (thanks [konstantingross](https://github.com/konstantingross)) [\#417](https://github.com/ElectronNET/Electron.NET/pull/417) [\#418](https://github.com/ElectronNET/Electron.NET/pull/418)
-* Notification-Api Enhancement: Added missing properties in Notifications (thanks [konstantingross](https://github.com/konstantingross)) [\#410](https://github.com/ElectronNET/Electron.NET/pull/410)
-* BrowserWindows-Api Enhancement: Add missing API call for SetProgressBar options (thanks [konstantingross](https://github.com/konstantingross)) [\#416](https://github.com/ElectronNET/Electron.NET/pull/416)
-* BrowserWindow Enhancement: Add BrowserWindow.GetNativeWindowHandle() (thanks [kdlslyv](https://github.com/kdlslyv)) [\#429](https://github.com/ElectronNET/Electron.NET/pull/429)
-* HostHook-Api Enhancement: HostHook.CallAsync should use TaskCompletionSource.SetException instead of throwing exception (thanks [Fre V](https://github.com/freosc)) [\#430](https://github.com/ElectronNET/Electron.NET/pull/430)
-* MacOS Enhancement: Application exit logic (thanks [dafergu2](https://github.com/dafergu2)) [\#405](https://github.com/ElectronNET/Electron.NET/pull/405)
-* Fixed bug: ElectronNET.API.Entities.WebPreferences.ContextIsolation [DefaultValue(true)] [\#411](https://github.com/ElectronNET/Electron.NET/issues/411)
-
-ElectronNET.WebApp (internal use):
-* Improvement debugging and testing new API calls (without install ElectronNET.CLI) (thanks [konstantingross](https://github.com/konstantingross)) [\#425](https://github.com/ElectronNET/Electron.NET/pull/425)
-* Fixed bug: Cannot find modules in ElectronHostHook (thanks [konstantingross](https://github.com/konstantingross)) [\#425](https://github.com/ElectronNET/Electron.NET/pull/425)
-
-Thank you for donation [Phil Seeman](https://github.com/mpnow) ❤
-
-# 8.31.2
-
-ElectronNET.CLI:
-* New Feature: Deactivate PublishReadyToRun for build or start [\#395](https://github.com/ElectronNET/Electron.NET/issues/395)
-  
-   `electronize build /target win /PublishReadyToRun false`  
-   `electronize start /PublishReadyToRun false`   
-* Fixed bug: Application window doesn't open after packaging  [\#387](https://github.com/ElectronNET/Electron.NET/issues/387)
-
-ElectronNET.API:
-
-* New Feature: NativeImage Support (thanks [ThrDev](https://github.com/ThrDev)) [\#394](https://github.com/ElectronNET/Electron.NET/pull/394)  
-* New Feature: Update menu items for context menu and system tray on-the-fly. [\#270](https://github.com/ElectronNET/Electron.NET/pull/270)  
-
-
-# 8.31.1
-
-ElectronNET.CLI:
-* New Feature: Set a name and author of the app in `electron.manifest.json` [\#348](https://github.com/ElectronNET/Electron.NET/issues/348#issuecomment-615977950) [\#310](https://github.com/ElectronNET/Electron.NET/issues/310#issuecomment-617361086)
-* New Feature: Live reload (thanks [syedadeel2](https://github.com/syedadeel2)) [\#390](https://github.com/ElectronNET/Electron.NET/pull/390)  
-`electronize start /watch`
-* New Feature: Every new window will created with an clear cache [\#273](https://github.com/ElectronNET/Electron.NET/issues/273)  
-`electronize start /clear-cache`
-
-ElectronNET.API:
-
-* New Feature: Native Electron 8.2.3 support, but not all new features (we search contributors)
-* New Feature: We incease the startup time for ~25-36% [\#356](https://github.com/ElectronNET/Electron.NET/issues/356)
-* New Feature: Added print capability (thanks [x-xx-o](https://github.com/x-xx-o)) [\#355](https://github.com/ElectronNET/Electron.NET/pull/355)
-* New Feature: BrowserView API [\#371](https://github.com/ElectronNET/Electron.NET/issues/371)
-* Changed App.GetNameAsync and App.SetNameAsync to the App.Name Property [\#350](https://github.com/ElectronNET/Electron.NET/issues/350)
-* Fixed bug: Splash Screen disappearing on click [\#357](https://github.com/ElectronNET/Electron.NET/issues/357)
-* Fixed bug: Start MenuRole enum at 1 (thanks [jjuback](https://github.com/jjuback)) [\#369](https://github.com/ElectronNET/Electron.NET/pull/369)
-* Fixed bug: BridgeConnector not connected (spam console) [\#347](https://github.com/ElectronNET/Electron.NET/issues/347)
-* Fixed bug: BrowserWindowOptions is not setting Width and Height properly [\#373](https://github.com/ElectronNET/Electron.NET/issues/373)
-* Fixed bug: IpcMain.Once(string) is not one time use, is not removing listener [\#366](https://github.com/ElectronNET/Electron.NET/issues/366)
-* Fixed bug: IpcMain.RemoveAllListeners(string) is not removing the listeners [\#365](https://github.com/ElectronNET/Electron.NET/issues/365)
-* Fixed bug: GetLoginItemSettingsAsync does not work [\#352](https://github.com/ElectronNET/Electron.NET/issues/352)
-* Fixed bug: Using OnReadyToShow to display the main window in Blazor does not seem to work with Show set to false [\#361](https://github.com/ElectronNET/Electron.NET/issues/361)
-* Fixed bug: Unable to disable WebSecurity along with NodeIntegration enabled [\#389](https://github.com/ElectronNET/Electron.NET/issues/389)
-
-# 7.30.2
-
-ElectronNET.CLI:
-
-* New Feature: Different manifest file support [\#340](https://github.com/ElectronNET/Electron.NET/issues/340)
-  * Create a additional manifest file: `electronize init /manifest test`
-  * Start the app with your additional manifest file: `electronize start /manifest electron.manifest.test.json`
-  * Build the app with your additional manifest file: `electronize build /target win /manifest electron.manifest.test.json`.
-
-* New Feature: Command Line support [\#337](https://github.com/ElectronNET/Electron.NET/issues/337)
-  * You can start the app with: `electronize start /args --dog=woof --test=true`
-  * Or as binary: `myapp.exe /args --dog=woof --test=true`
-* Fixed bug: Start process with listen port 8000 error. [\#308](https://github.com/ElectronNET/Electron.NET/issues/308) (thanks [thecodejedi](https://github.com/thecodejedi))
-* Fixed bug: `electronize build` with no arguments would throw a `KeyNotFoundException`. (thanks [jamiebrynes7](https://github.com/jamiebrynes7))
-
-ElectronNET.API:
-
-* New Feature: Electron 7.1.2 support, but not all new features (we search contributors) [\#341](https://github.com/ElectronNET/Electron.NET/issues/341)
-* New Feature: Electron.App.CommandLine API [\#337](https://github.com/ElectronNET/Electron.NET/issues/337)
-* New Feature: Support of BrowserWindow.AddExtension, BrowserWindow.RemoveExtension, BrowserWindow.GetExtensions (thanks [Daddoon](https://github.com/Daddoon))
-
-Thank you for donation [robertmclaws](https://github.com/robertmclaws) ❤
-
-# 5.30.1
-
-ElectronNET.CLI:
-
-* Move to .NET Core 3.0
-* Use npm npx instead of global installations (thanks [jimbuck](https://github.com/jimbuck))
-
-ElectronNET.API:
-
-* Move to .NET Core 3.0
-* New Feature: Add BrowserWindow.RemoveMenu() (thanks [hack2root](https://github.com/hack2root))
-
-Thanks to [MaherJendoubi](https://github.com/MaherJendoubi), [kant2002](https://github.com/kant2002), [raz-canva](https://github.com/raz-canva) and [Daddoon](https://github.com/Daddoon) to give .NET Core 3.0 feedback!
-# 5.22.14
-
-ElectronNET.CLI:
-
-* Fixed bug: Build fails with latest electron-builder version [\#288](https://github.com/ElectronNET/Electron.NET/issues/288)
-
-ElectronNET.API:
-
-* New Feature: Full support for Auto Updater [(Based on electron-updater - Version 4.0.6)](https://www.electron.build/auto-update)
-* New Feature: Support for set a custom static Port to ASP.NET Backend [\#155](https://github.com/ElectronNET/Electron.NET/issues/155)
-* Fixed bug: Electron tray icon TypeError ([Electron original issue](https://github.com/electron/electron/issues/7657)) (thanks [Tum4ik](https://github.com/Tum4ik))
-* Fixed bug: Wrong tray icon path in the application built via `electronize build` command (thanks [Tum4ik](https://github.com/Tum4ik))
-* Fixed bug: fix async issue where same port is considered open [\#261](https://github.com/ElectronNET/Electron.NET/issues/261) (thanks [netpoetica](https://github.com/netpoetica))
-
-ElectronNET.WebApp:
-
-* Fixed usage of the `Electron.Tray.Show` according fixed bugs in the ElectronNET.CLI (thanks [Tum4ik](https://github.com/Tum4ik))
-
-# 5.22.13
-
-ElectronNET.API:
-
-* Fixed bug: Menu Item visibility [\#257](https://github.com/ElectronNET/Electron.NET/issues/257)
-* Fixed bug: electron.manifest.json - singleInstance not working [\#258](https://github.com/ElectronNET/Electron.NET/issues/258)
-* Fixed security issue: ASP.NET Core process is now bound to 127.0.0.1 instead of the broader localhost [\#258](https://github.com/ElectronNET/Electron.NET/pull/266)  
-
-# 5.22.12
-
-ElectronNET.CLI:
-
-* New Feature: Changed from **electron packager** to [**electron builder**](https://www.electron.build/)
-* New Feature: 'add hosthook' command for add a ElectronHostHook-Directory
-* Fixed bug: 'Unexpected firewall warnings' [\#181](https://github.com/ElectronNET/Electron.NET/issues/181)
-* Fixed bug: 'found 8 vulnerabilities (1 low, 5 moderate, 2 high)' [\#199](https://github.com/ElectronNET/Electron.NET/pull/199)
-* Merged pull request: Call electronize from the Path instead of via dotnet in launchSettings.json [\#243](https://github.com/ElectronNET/Electron.NET/pull/243) (thanks [grbd](https://github.com/grbd))
-
-ElectronNET.API:
-
-* New Feature: Electron 5.0.1 support, but not all new features
-* New Feature: Auto Updater [(Based on electron-updater)](https://www.electron.build/auto-update)
-* New Feature: Splashscreen-Support
-* New Feature: HostHook-API for execute own TypeScript/JavaScript code on native Electron Main-Process
-* New Feature: Session-API functions
-* Fixed bug: Node process running after stopping app [\#96](https://github.com/ElectronNET/Electron.NET/issues/96)
-* Fixed bug: 'X and Y options to not work on Windows 10' [\#193](https://github.com/ElectronNET/Electron.NET/issues/193)
-* Fixed bug: Unable to clear cache [\#66](https://github.com/ElectronNET/Electron.NET/issues/66)
-* Merged pull request: Fix BrowserWindow::SetMenu [\#231](https://github.com/ElectronNET/Electron.NET/pull/231) thanks (thanks [CodeKenpachi](https://github.com/CodeKenpachi))
-* Merged pull request: FIX application hangs after socket reconnect [\#233](https://github.com/ElectronNET/Electron.NET/pull/233) (thanks [pedromrpinto](https://github.com/pedromrpinto))
-* Merged pull request: Reduce chance of detecting false positives when scanning subprocesses for errors. [\#236](https://github.com/ElectronNET/Electron.NET/pull/236) (thanks [BorisTheBrave](https://github.com/BorisTheBrave))
-* Merged pull request: Updates the C# API to accept floating point as in JS. [\#240](https://github.com/ElectronNET/Electron.NET/pull/240) (thanks [BorisTheBrave](https://github.com/BorisTheBrave))
-* Merged pull request: buildReleaseNuGetPackages should leave you in the same directory you …  [\#241](https://github.com/ElectronNET/Electron.NET/pull/241) (thanks [BorisTheBrave](https://github.com/BorisTheBrave))
-
-ElectronNET.WebApp:
-
-* Implemented a sample for the new HostHook-API
-* Fixed bug: 'Electron.NET API Demo: unable to copy code?' [\#247](https://github.com/ElectronNET/Electron.NET/issues/247)
-
-# 0.0.11
-
-ElectronNET.CLI:
-
-* Invoke 'npm install' without --prod flag to install needed devDependencies as well.
-* Enable SourceLink
-* NuGet Package License Information updated (deprecation of licenseUrl)
-
-ElectronNET.API:
-
-* Documentation added for WebContents.GetUrl()
-* Enable SourceLink
-* NuGet Package License Information updated (deprecation of licenseUrl)
-
-# 0.0.10
-
-ElectronNET.API:
-
-* manifestJsonFilePath fixed (thanks @smack0007)
-* Use Electron release 3.0.0 and updated packages (thanks @deinok)
-* fixes for Socket interaction (thanks @mojinxun)
-* Fixing SingleInstances (thanks @yaofeng)
-* Enhance WebContent.GetUrl (thanks @ru-sh)
-
-ElectronNET.CLI:
-
-* Show Resultcode for better debugging when using Build/Start Command
-* ElectronNET.CLI is now a global dotnet tool
-
-# 0.0.9
-
-ElectronNET.API:
-
-* Better Async handling - thanks @danielmarbach
-
-ElectronNET.CLI:
-
-* More options on the 'build' command, e.g. for a 32bit debug build with electron prune: build /target custom win7-x86;win32 /dotnet-configuration Debug /electron-arch ia32  /electron-params "--prune=true "
-* .NET Core project is now built with Release configuration but can be adjusted with the new params.
-* Be aware: "Breaking" (but because of the alpha status of this project, we won't use SemVer)
-
-# 0.0.8
-
-This version was skipped because we unfortunately  released a pre-version of this on NuGet.
-
-# 0.0.7
-
-ElectronNET.CLI:
-
-* Fixed electronize start for macos/linux - thanks @yamachu
-* Skip NPM install on start when node_modules directory already exists
-
-# 0.0.6
-
-ElectronNET.CLI:
-
-* nuget packages are now release bits and have the correct assembly version
-* Version command 
-* better devCleanup.cmd
-* Better Platform Support Issue - thanks to @Petermarcu
-* Start Command should now work on OSX/Linux - thanks to @r105m
-
-ElectronNET.API:
-
-* Thread-Safe methods - thanks to @yeskunall
-
-# 0.0.5
-
-ElectronNET.API:
-
-* The last nuget package didn't contain the actual webpreferences settings with defaults - hopefully now.
-
-# 0.0.4
-
-ElectronNET.CLI:
-
-* dotnet electronize start fixed
-
-ElectronNET.API:
-
-* WebPreferences settings with default values
-
-# 0.0.3
-
-ElectronNET.CLI:
-* Init with Debug profile
-* Build for all platforms (well... for newest OSX/Linux/Windows)
-
-ElectronNET.API:
-* Moar XML documentation 
-* Hybrid support (e.g. running as normal website and electron app)
-* Event bugfixing
-
-# 0.0.2
-
-ElectronNET.CLI:
-* Added Init to Help page
-* Added XML documentation to NuGet output
-* Maybe fixed for https://github.com/GregorBiswanger/Electron.NET/issues/2
-
-ElectronNET.API:
-* Add XML documentation to NuGet output
-* Implemented Notification-, Dialog- & Tray-API
-
-# 0.0.1
-
-* init everything and basic functionality
+# 0.3.0
+
+## ElectronNET.Core
+
+- Updated infrastructure (#937, #939) @softworkz
+- Fixed output path for `electron-builder` (#942) @softworkz
+- Fixed previous API break using exposed `JsonElement` objects (#938) @softworkz
+
+# 0.2.0
+
+## ElectronNET.Core
+
+- Updated dependencies (#930) @softworkz
+- Updated integration tests (#931) @softworkz
+- Updated `ElectronNET.Host` (#935) @softworkz
+- Removed transition period specific build configuration (#928) @softworkz
+- Added `IsRunningBlazor` option to `BrowserWindowOptions` (#926)
+- Added platform support attributes (#929) @softworkz
+
+# 0.1.0
+
+## ElectronNET.Core
+
+- Updated `PrintToPDFOptions` to also allow specifying the `PageSize` with an object (#769)
+- Updated splashscreen image to have 0 margin (#622)
+- Updated the IPC API w.r.t. naming and consistency (#905) @agracio
+- Updated the IPC bridge w.r.t. synchronization and thread-safety (#918) @agracio
+- Updated serialization to use `System.Text.Json` replacing `Newtonsoft.Json` (#917) @Denny09310
+- Fixed parameter handling for the `sendToIpcRenderer` function (#922) @softworkz
+- Fixed synchronization on removing event handlers (#921) @softworkz
+- Fixed creation of windows with `contextIsolation` enabled (#906) @NimbusFox
+- Fixed single instance behavior using the `ElectronSingleInstance` property (#901)
+- Fixed potential race conditions (#908) @softworkz
+- Added option to use `ElectronSplashScreen` with an HTML file (#799)
+- Added option to provide floating point value as aspect ratios with `SetAspectRatio` (#793)
+- Added option to provide `TitleBarOverlay` as an object (#911) @Denny09310
+- Added `TitleBarOverlay` property to `BrowserWindowOptions` (#909)
+- Added `RoundedCorners` property to `BrowserWindowOptions`
+- Added integration tests and robustness checks (#913) @softworkz
+- Added .NET 10 as an explicit target
+
+# 0.0.18
+
+## ElectronNET.Core
+
+### Highlights
+
+- **Complete MSBuild Integration**: Eliminated CLI tool dependency, moved all build processes to MSBuild with deep Visual Studio integration
+- **Modernized Architecture**: Restructured process lifecycle with .NET launching first and running Electron as child process for better control and reliability
+- **Cross-Platform Development**: Build and debug Linux applications directly from Windows Visual Studio via WSL integration
+- **Flexible Electron Versioning**: Removed version lock-in, users can now select any Electron version with build-time validation
+- **Enhanced Debugging Experience**: ASP.NET-first debugging with Hot Reload support and improved process termination handling
+- **Console App Support**: No longer requires ASP.NET - now works with simple console applications for file system or remote server HTML/JS
+
+### Build System & Project Structure
+
+- Eliminated electron.manifest.json configuration file, replaced with MSBuild project properties
+- Introduced new package structure: ElectronNET.Core (main package), ElectronNET.Core.Api (API definitions), ElectronNET.Core.AspNet (ASP.NET integration)
+- Added Runtime Identifier (RID) selection as part of project configuration
+- Restructured build folder layout to use standard .NET format (bin\net8.0\win-x64) instead of bin\Desktop
+- Implemented incremental build support for Electron assets to improve build performance
+- Added custom MSBuild tasks for Electron-specific build operations
+
+### Development Experience
+
+- Implemented unpackaged run-mode for development using regular .NET builds with unpackaged Electron configuration
+- Added support for building Linux packages on Windows via WSL integration
+- Enabled running and debugging Linux application outputs on Windows through WSL
+- Integrated TypeScript compilation with ASP.NET tooling for consistent builds
+- Added process orchestration supporting 8 different launch scenarios (packaged/unpackaged × console/ASP.NET × dotnet-first/electron-first)
+
+### Debugging & Runtime
+
+- Dramatically improved debugging experience with ASP.NET-first launch mode
+- Added Hot Reload support for ASP.NET code during development
+- Implemented proper process termination handling for all exit scenarios
+- Minimized startup times through optimized build and launch procedures
+
+### Technical Improvements
+
+- Enhanced splash screen handling with automatic path resolution
+- Improved ElectronHostHook integration as proper npm package dependency
+- Updated to latest TypeScript version with ESLint configuration
+- Added support for custom main.js files in projects
+- Implemented version management through common.props file
+- Added build-time Electron version compatibility validation
+
+### Package & Distribution
+
+- Integrated MSBuild publishing mechanisms for creating Electron packages
+- Added folder publishing support with improved parameter handling
+- Implemented automated package.json generation from MSBuild properties
+- Added GitHub release automation with proper versioning
+- Reduced package sizes by eliminating unnecessary TypeScript dependencies
+
+### Migration & Compatibility
+
+- Maintained backward compatibility for existing ElectronHostHook implementations
+- Removed ASP.NET requirement: Now works with simple console applications for file system or remote server HTML/JS scenarios
+- Added support for both console and ASP.NET Core application types
+- Preserved all existing Electron API functionality while modernizing architecture
+- Added migration path for existing projects through updated package structure
+
+This represents a comprehensive modernization of Electron.NET, addressing the major pain points around debugging, build complexity, and platform limitations while maintaining full API compatibility.

ElectronNET.API/AutoUpdater.cs

@@ -1,621 +0,0 @@
-using ElectronNET.API.Entities;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
-using Newtonsoft.Json.Serialization;
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-
-namespace ElectronNET.API
-{
-    /// <summary>
-    /// Enable apps to automatically update themselves. Based on electron-updater.
-    /// </summary>
-    public sealed class AutoUpdater
-    {
-        /// <summary>
-        /// Whether to automatically download an update when it is found. (Default is true)
-        /// </summary>
-        public bool AutoDownload
-        {
-            get
-            {
-                return Task.Run<bool>(() =>
-                {
-                    var taskCompletionSource = new TaskCompletionSource<bool>();
-
-                    BridgeConnector.Socket.On("autoUpdater-autoDownload-get-reply", (result) =>
-                    {
-                        BridgeConnector.Socket.Off("autoUpdater-autoDownload-get-reply");
-                        taskCompletionSource.SetResult((bool)result);
-                    });
-
-                    BridgeConnector.Socket.Emit("autoUpdater-autoDownload-get");
-
-                    return taskCompletionSource.Task;
-                }).Result;
-            }
-            set
-            {
-                BridgeConnector.Socket.Emit("autoUpdater-autoDownload-set", value);
-            }
-        }
-
-        /// <summary>
-        /// Whether to automatically install a downloaded update on app quit (if `QuitAndInstall` was not called before).
-        /// 
-        /// Applicable only on Windows and Linux.
-        /// </summary>
-        public bool AutoInstallOnAppQuit
-        {
-            get
-            {
-                return Task.Run<bool>(() =>
-                {
-                    var taskCompletionSource = new TaskCompletionSource<bool>();
-
-                    BridgeConnector.Socket.On("autoUpdater-autoInstallOnAppQuit-get-reply", (result) =>
-                    {
-                        BridgeConnector.Socket.Off("autoUpdater-autoInstallOnAppQuit-get-reply");
-                        taskCompletionSource.SetResult((bool)result);
-                    });
-
-                    BridgeConnector.Socket.Emit("autoUpdater-autoInstallOnAppQuit-get");
-
-                    return taskCompletionSource.Task;
-                }).Result;
-            }
-            set
-            {
-                BridgeConnector.Socket.Emit("autoUpdater-autoInstallOnAppQuit-set", value);
-            }
-        }
-
-        /// <summary>
-        /// *GitHub provider only.* Whether to allow update to pre-release versions. 
-        /// Defaults to "true" if application version contains prerelease components (e.g. "0.12.1-alpha.1", here "alpha" is a prerelease component), otherwise "false".
-        /// 
-        /// If "true", downgrade will be allowed("allowDowngrade" will be set to "true").
-        /// </summary>
-        public bool AllowPrerelease
-        {
-            get
-            {
-                return Task.Run<bool>(() =>
-                {
-                    var taskCompletionSource = new TaskCompletionSource<bool>();
-
-                    BridgeConnector.Socket.On("autoUpdater-allowPrerelease-get-reply", (result) =>
-                    {
-                        BridgeConnector.Socket.Off("autoUpdater-allowPrerelease-get-reply");
-                        taskCompletionSource.SetResult((bool)result);
-                    });
-
-                    BridgeConnector.Socket.Emit("autoUpdater-allowPrerelease-get");
-
-                    return taskCompletionSource.Task;
-                }).Result;
-            }
-            set
-            {
-                BridgeConnector.Socket.Emit("autoUpdater-allowPrerelease-set", value);
-            }
-        }
-
-        /// <summary>
-        /// *GitHub provider only.* 
-        /// Get all release notes (from current version to latest), not just the latest (Default is false).
-        /// </summary>
-        public bool FullChangelog
-        {
-            get
-            {
-                return Task.Run<bool>(() =>
-                {
-                    var taskCompletionSource = new TaskCompletionSource<bool>();
-
-                    BridgeConnector.Socket.On("autoUpdater-fullChangelog-get-reply", (result) =>
-                    {
-                        BridgeConnector.Socket.Off("autoUpdater-fullChangelog-get-reply");
-                        taskCompletionSource.SetResult((bool)result);
-                    });
-
-                    BridgeConnector.Socket.Emit("autoUpdater-fullChangelog-get");
-
-                    return taskCompletionSource.Task;
-                }).Result;
-            }
-            set
-            {
-                BridgeConnector.Socket.Emit("autoUpdater-fullChangelog-set", value);
-            }
-        }
-
-        /// <summary>
-        /// Whether to allow version downgrade (when a user from the beta channel wants to go back to the stable channel).
-        /// Taken in account only if channel differs (pre-release version component in terms of semantic versioning).
-        /// Default is false.
-        /// </summary>
-        public bool AllowDowngrade
-        {
-            get
-            {
-                return Task.Run<bool>(() =>
-                {
-                    var taskCompletionSource = new TaskCompletionSource<bool>();
-
-                    BridgeConnector.Socket.On("autoUpdater-allowDowngrade-get-reply", (result) =>
-                    {
-                        BridgeConnector.Socket.Off("autoUpdater-allowDowngrade-get-reply");
-                        taskCompletionSource.SetResult((bool)result);
-                    });
-
-                    BridgeConnector.Socket.Emit("autoUpdater-allowDowngrade-get");
-
-                    return taskCompletionSource.Task;
-                }).Result;
-            }
-            set
-            {
-                BridgeConnector.Socket.Emit("autoUpdater-allowDowngrade-set", value);
-            }
-        }
-
-        /// <summary>
-        /// For test only.
-        /// </summary>
-        public string UpdateConfigPath
-        {
-            get
-            {
-                return Task.Run<string>(() =>
-                {
-                    var taskCompletionSource = new TaskCompletionSource<string>();
-
-                    BridgeConnector.Socket.On("autoUpdater-updateConfigPath-get-reply", (result) =>
-                    {
-                        BridgeConnector.Socket.Off("autoUpdater-updateConfigPath-get-reply");
-                        taskCompletionSource.SetResult(result.ToString());
-                    });
-
-                    BridgeConnector.Socket.Emit("autoUpdater-updateConfigPath-get");
-
-                    return taskCompletionSource.Task;
-                }).Result;
-            }
-        }
-
-        /// <summary>
-        /// The current application version
-        /// </summary>
-        public Task<SemVer> CurrentVersionAsync
-        {
-            get
-            {
-                return Task.Run<SemVer>(() =>
-                {
-                    var taskCompletionSource = new TaskCompletionSource<SemVer>();
-
-                    BridgeConnector.Socket.On("autoUpdater-currentVersion-get-reply", (result) =>
-                    {
-                        BridgeConnector.Socket.Off("autoUpdater-currentVersion-get-reply");
-                        SemVer version = ((JObject)result).ToObject<SemVer>();
-                        taskCompletionSource.SetResult(version);
-                    });
-                    BridgeConnector.Socket.Emit("autoUpdater-currentVersion-get");
-
-                    return taskCompletionSource.Task;
-                });
-            }
-        }
-
-        /// <summary>
-        /// Get the update channel. Not applicable for GitHub. 
-        /// Doesn’t return channel from the update configuration, only if was previously set.
-        /// </summary>
-        [Obsolete("Use the asynchronous version ChannelAsync instead")]
-        public string Channel
-        {
-            get
-            {
-                return ChannelAsync.Result;
-            }
-        }
-
-        /// <summary>
-        /// Get the update channel. Not applicable for GitHub. 
-        /// Doesn’t return channel from the update configuration, only if was previously set.
-        /// </summary>
-        public Task<string> ChannelAsync
-        {
-            get
-            {
-                return Task.Run<string>(() =>
-                {
-                    var taskCompletionSource = new TaskCompletionSource<string>();
-
-                    BridgeConnector.Socket.On("autoUpdater-channel-get-reply", (result) =>
-                    {
-                        BridgeConnector.Socket.Off("autoUpdater-channel-get-reply");
-                        taskCompletionSource.SetResult(result.ToString());
-                    });
-                    BridgeConnector.Socket.Emit("autoUpdater-channel-get");
-
-                    return taskCompletionSource.Task;
-                });
-            }
-        }
-
-
-
-        /// <summary>
-        /// The request headers.
-        /// </summary>
-        public Task<Dictionary<string, string>> RequestHeadersAsync
-        {
-            get
-            {
-                return Task.Run(() =>
-                {
-                    var taskCompletionSource = new TaskCompletionSource<Dictionary<string, string>>();
-                    BridgeConnector.Socket.On("autoUpdater-requestHeaders-get-reply", (headers) =>
-                    {
-                        BridgeConnector.Socket.Off("autoUpdater-requestHeaders-get-reply");
-                        Dictionary<string, string> result = ((JObject)headers).ToObject<Dictionary<string, string>>();
-                        taskCompletionSource.SetResult(result);
-                    });
-                    BridgeConnector.Socket.Emit("autoUpdater-requestHeaders-get");
-                    return taskCompletionSource.Task;
-                });
-            }
-        }
-
-        /// <summary>
-        /// The request headers.
-        /// </summary>
-        public Dictionary<string, string> RequestHeaders
-        {
-            set
-            {
-                BridgeConnector.Socket.Emit("autoUpdater-requestHeaders-set", JObject.FromObject(value, _jsonSerializer));
-            }
-        }
-
-        /// <summary>
-        /// Emitted when there is an error while updating.
-        /// </summary>
-        public event Action<string> OnError
-        {
-            add
-            {
-                if (_error == null)
-                {
-                    BridgeConnector.Socket.On("autoUpdater-error" + GetHashCode(), (message) =>
-                    {
-                        _error(message.ToString());
-                    });
-
-                    BridgeConnector.Socket.Emit("register-autoUpdater-error-event", GetHashCode());
-                }
-                _error += value;
-            }
-            remove
-            {
-                _error -= value;
-
-                if (_error == null)
-                    BridgeConnector.Socket.Off("autoUpdater-error" + GetHashCode());
-            }
-        }
-
-        private event Action<string> _error;
-
-        /// <summary>
-        /// Emitted when checking if an update has started.
-        /// </summary>
-        public event Action OnCheckingForUpdate
-        {
-            add
-            {
-                if (_checkingForUpdate == null)
-                {
-                    BridgeConnector.Socket.On("autoUpdater-checking-for-update" + GetHashCode(), () =>
-                    {
-                        _checkingForUpdate();
-                    });
-
-                    BridgeConnector.Socket.Emit("register-autoUpdater-checking-for-update-event", GetHashCode());
-                }
-                _checkingForUpdate += value;
-            }
-            remove
-            {
-                _checkingForUpdate -= value;
-
-                if (_checkingForUpdate == null)
-                    BridgeConnector.Socket.Off("autoUpdater-checking-for-update" + GetHashCode());
-            }
-        }
-
-        private event Action _checkingForUpdate;
-
-        /// <summary>
-        /// Emitted when there is an available update. 
-        /// The update is downloaded automatically if AutoDownload is true.
-        /// </summary>
-        public event Action<UpdateInfo> OnUpdateAvailable
-        {
-            add
-            {
-                if (_updateAvailable == null)
-                {
-                    BridgeConnector.Socket.On("autoUpdater-update-available" + GetHashCode(), (updateInfo) =>
-                    {
-                        _updateAvailable(JObject.Parse(updateInfo.ToString()).ToObject<UpdateInfo>());
-                    });
-
-                    BridgeConnector.Socket.Emit("register-autoUpdater-update-available-event", GetHashCode());
-                }
-                _updateAvailable += value;
-            }
-            remove
-            {
-                _updateAvailable -= value;
-
-                if (_updateAvailable == null)
-                    BridgeConnector.Socket.Off("autoUpdater-update-available" + GetHashCode());
-            }
-        }
-
-        private event Action<UpdateInfo> _updateAvailable;
-
-        /// <summary>
-        /// Emitted when there is no available update.
-        /// </summary>
-        public event Action<UpdateInfo> OnUpdateNotAvailable
-        {
-            add
-            {
-                if (_updateNotAvailable == null)
-                {
-                    BridgeConnector.Socket.On("autoUpdater-update-not-available" + GetHashCode(), (updateInfo) =>
-                    {
-                        _updateNotAvailable(JObject.Parse(updateInfo.ToString()).ToObject<UpdateInfo>());
-                    });
-
-                    BridgeConnector.Socket.Emit("register-autoUpdater-update-not-available-event", GetHashCode());
-                }
-                _updateNotAvailable += value;
-            }
-            remove
-            {
-                _updateNotAvailable -= value;
-
-                if (_updateNotAvailable == null)
-                    BridgeConnector.Socket.Off("autoUpdater-update-not-available" + GetHashCode());
-            }
-        }
-
-        private event Action<UpdateInfo> _updateNotAvailable;
-
-        /// <summary>
-        /// Emitted on download progress.
-        /// </summary>
-        public event Action<ProgressInfo> OnDownloadProgress
-        {
-            add
-            {
-                if (_downloadProgress == null)
-                {
-                    BridgeConnector.Socket.On("autoUpdater-download-progress" + GetHashCode(), (progressInfo) =>
-                    {
-                        _downloadProgress(JObject.Parse(progressInfo.ToString()).ToObject<ProgressInfo>());
-                    });
-
-                    BridgeConnector.Socket.Emit("register-autoUpdater-download-progress-event", GetHashCode());
-                }
-                _downloadProgress += value;
-            }
-            remove
-            {
-                _downloadProgress -= value;
-
-                if (_downloadProgress == null)
-                    BridgeConnector.Socket.Off("autoUpdater-download-progress" + GetHashCode());
-            }
-        }
-
-        private event Action<ProgressInfo> _downloadProgress;
-
-        /// <summary>
-        /// Emitted on download complete.
-        /// </summary>
-        public event Action<UpdateInfo> OnUpdateDownloaded
-        {
-            add
-            {
-                if (_updateDownloaded == null)
-                {
-                    BridgeConnector.Socket.On("autoUpdater-update-downloaded" + GetHashCode(), (updateInfo) =>
-                    {
-                        _updateDownloaded(JObject.Parse(updateInfo.ToString()).ToObject<UpdateInfo>());
-                    });
-
-                    BridgeConnector.Socket.Emit("register-autoUpdater-update-downloaded-event", GetHashCode());
-                }
-                _updateDownloaded += value;
-            }
-            remove
-            {
-                _updateDownloaded -= value;
-
-                if (_updateDownloaded == null)
-                    BridgeConnector.Socket.Off("autoUpdater-update-downloaded" + GetHashCode());
-            }
-        }
-
-        private event Action<UpdateInfo> _updateDownloaded;
-
-        private static AutoUpdater _autoUpdater;
-        private static object _syncRoot = new object();
-
-        internal AutoUpdater() { }
-
-        internal static AutoUpdater Instance
-        {
-            get
-            {
-                if (_autoUpdater == null)
-                {
-                    lock (_syncRoot)
-                    {
-                        if (_autoUpdater == null)
-                        {
-                            _autoUpdater = new AutoUpdater();
-                        }
-                    }
-                }
-
-                return _autoUpdater;
-            }
-        }
-
-        /// <summary>
-        /// Asks the server whether there is an update.
-        /// </summary>
-        /// <returns></returns>
-        public Task<UpdateCheckResult> CheckForUpdatesAsync()
-        {
-            var taskCompletionSource = new TaskCompletionSource<UpdateCheckResult>();
-            string guid = Guid.NewGuid().ToString();
-
-            BridgeConnector.Socket.On("autoUpdaterCheckForUpdatesComplete" + guid, (updateCheckResult) =>
-            {
-                try
-                {
-                    BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesComplete" + guid);
-                    BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesError" + guid);
-                    taskCompletionSource.SetResult(JObject.Parse(updateCheckResult.ToString()).ToObject<UpdateCheckResult>());
-                }
-                catch (Exception ex)
-                {
-                    taskCompletionSource.SetException(ex);
-                }
-            });
-            BridgeConnector.Socket.On("autoUpdaterCheckForUpdatesError" + guid, (error) =>
-            {
-                BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesComplete" + guid);
-                BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesError" + guid);
-                string message = "An error occurred in CheckForUpdatesAsync";
-                if (error != null && !string.IsNullOrEmpty(error.ToString()))
-                    message = JsonConvert.SerializeObject(error);
-                taskCompletionSource.SetException(new Exception(message));
-            });
-
-            BridgeConnector.Socket.Emit("autoUpdaterCheckForUpdates", guid);
-
-            return taskCompletionSource.Task;
-        }
-
-        /// <summary>
-        /// Asks the server whether there is an update.
-        /// 
-        /// This will immediately download an update, then install when the app quits.
-        /// </summary>
-        /// <returns></returns>
-        public Task<UpdateCheckResult> CheckForUpdatesAndNotifyAsync()
-        {
-            var taskCompletionSource = new TaskCompletionSource<UpdateCheckResult>();
-            string guid = Guid.NewGuid().ToString();
-
-            BridgeConnector.Socket.On("autoUpdaterCheckForUpdatesAndNotifyComplete" + guid, (updateCheckResult) =>
-            {
-                try
-                {
-                    BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesAndNotifyComplete" + guid);
-                    BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesAndNotifyError" + guid);
-                    if (updateCheckResult == null)
-                        taskCompletionSource.SetResult(null);
-                    else
-                        taskCompletionSource.SetResult(JObject.Parse(updateCheckResult.ToString()).ToObject<UpdateCheckResult>());
-                }
-                catch (Exception ex)
-                {
-                    taskCompletionSource.SetException(ex);
-                }
-            });
-            BridgeConnector.Socket.On("autoUpdaterCheckForUpdatesAndNotifyError" + guid, (error) =>
-            {
-                BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesAndNotifyComplete" + guid);
-                BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesAndNotifyError" + guid);
-                string message = "An error occurred in autoUpdaterCheckForUpdatesAndNotify";
-                if (error != null)
-                    message = JsonConvert.SerializeObject(error);
-                taskCompletionSource.SetException(new Exception(message));
-            });
-
-            BridgeConnector.Socket.Emit("autoUpdaterCheckForUpdatesAndNotify", guid);
-
-            return taskCompletionSource.Task;
-        }
-
-        /// <summary>
-        ///  Restarts the app and installs the update after it has been downloaded.
-        ///  It should only be called after `update-downloaded` has been emitted.
-        ///  
-        ///  Note: QuitAndInstall() will close all application windows first and only emit `before-quit` event on `app` after that.
-        ///  This is different from the normal quit event sequence.
-        /// </summary>
-        /// <param name="isSilent">*windows-only* Runs the installer in silent mode. Defaults to `false`.</param>
-        /// <param name="isForceRunAfter">Run the app after finish even on silent install. Not applicable for macOS. Ignored if `isSilent` is set to `false`.</param>
-        public void QuitAndInstall(bool isSilent = false, bool isForceRunAfter = false)
-        {
-            BridgeConnector.Socket.Emit("autoUpdaterQuitAndInstall", isSilent, isForceRunAfter);
-        }
-
-        /// <summary>
-        /// Start downloading update manually. You can use this method if "AutoDownload" option is set to "false".
-        /// </summary>
-        /// <returns>Path to downloaded file.</returns>
-        public Task<string> DownloadUpdateAsync()
-        {
-            var taskCompletionSource = new TaskCompletionSource<string>();
-            string guid = Guid.NewGuid().ToString();
-
-            BridgeConnector.Socket.On("autoUpdaterDownloadUpdateComplete" + guid, (downloadedPath) =>
-            {
-                BridgeConnector.Socket.Off("autoUpdaterDownloadUpdateComplete" + guid);
-                taskCompletionSource.SetResult(downloadedPath.ToString());
-            });
-
-            BridgeConnector.Socket.Emit("autoUpdaterDownloadUpdate", guid);
-
-            return taskCompletionSource.Task;
-        }
-
-        /// <summary>
-        /// Feed URL.
-        /// </summary>
-        /// <returns>Feed URL.</returns>
-        public Task<string> GetFeedURLAsync()
-        {
-            var taskCompletionSource = new TaskCompletionSource<string>();
-            string guid = Guid.NewGuid().ToString();
-
-            BridgeConnector.Socket.On("autoUpdaterGetFeedURLComplete" + guid, (downloadedPath) =>
-            {
-                BridgeConnector.Socket.Off("autoUpdaterGetFeedURLComplete" + guid);
-                taskCompletionSource.SetResult(downloadedPath.ToString());
-            });
-
-            BridgeConnector.Socket.Emit("autoUpdaterGetFeedURL", guid);
-
-            return taskCompletionSource.Task;
-        }
-
-        private readonly JsonSerializer _jsonSerializer = new JsonSerializer()
-        {
-            ContractResolver = new CamelCasePropertyNamesContractResolver()
-        };
-    }
-}

ElectronNET.API/BridgeConnector.cs

@@ -1,44 +0,0 @@
-using Quobject.SocketIoClientDotNet.Client;
-using System;
-
-namespace ElectronNET.API
-{
-    internal static class BridgeConnector
-    {
-        private static Socket _socket;
-        private static object _syncRoot = new object();
-
-        public static Socket Socket
-        {
-            get
-            {
-                if(_socket == null && HybridSupport.IsElectronActive)
-                {
-                    lock (_syncRoot)
-                    {
-                        if (_socket == null && HybridSupport.IsElectronActive)
-                        {
-                            _socket = IO.Socket("http://localhost:" + BridgeSettings.SocketPort);
-                            _socket.On(Socket.EVENT_CONNECT, () =>
-                            {
-                                Console.WriteLine("BridgeConnector connected!");
-                            });
-                        }
-                    }
-                }
-                else if(_socket == null && !HybridSupport.IsElectronActive)
-                {
-                    lock (_syncRoot)
-                    {
-                        if (_socket == null && !HybridSupport.IsElectronActive)
-                        {
-                            _socket = IO.Socket(new Uri("http://localhost"), new IO.Options { AutoConnect = false });
-                        }
-                    }
-                }
-
-                return _socket;
-            }
-        }
-    }
-}

ElectronNET.API/BridgeSettings.cs

@@ -1,24 +0,0 @@
-namespace ElectronNET.API
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public static class BridgeSettings
-    {
-        /// <summary>
-        /// Gets the socket port.
-        /// </summary>
-        /// <value>
-        /// The socket port.
-        /// </value>
-        public static string SocketPort { get; internal set; }
-
-        /// <summary>
-        /// Gets the web port.
-        /// </summary>
-        /// <value>
-        /// The web port.
-        /// </value>
-        public static string WebPort { get; internal set; }
-    }
-}

ElectronNET.API/Cookies.cs

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

ElectronNET.API/Electron.cs

@@ -1,92 +0,0 @@
-namespace ElectronNET.API
-{
-    /// <summary>
-    /// The Electron.NET API
-    /// </summary>
-    public static class Electron
-    {
-        /// <summary>
-        /// Communicate asynchronously from the main process to renderer processes.
-        /// </summary>
-        public static IpcMain IpcMain { get { return IpcMain.Instance; } }
-
-        /// <summary>
-        /// Control your application's event lifecycle.
-        /// </summary>
-        public static App App { get { return App.Instance; } }
-
-        /// <summary>
-        /// Enable apps to automatically update themselves. Based on electron-updater.
-        /// </summary>
-        public static AutoUpdater AutoUpdater { get { return AutoUpdater.Instance; } }
-
-        /// <summary>
-        /// Control your windows.
-        /// </summary>
-        public static WindowManager WindowManager { get { return WindowManager.Instance; } }
-
-        /// <summary>
-        /// Create native application menus and context menus.
-        /// </summary>
-        public static Menu Menu { get { return Menu.Instance; } }
-
-        /// <summary>
-        /// Display native system dialogs for opening and saving files, alerting, etc.
-        /// </summary>
-        public static Dialog Dialog { get { return Dialog.Instance; } }
-
-        /// <summary>
-        /// Create OS desktop notifications
-        /// </summary>
-        public static Notification Notification { get { return Notification.Instance; } }
-
-        /// <summary>
-        /// Add icons and context menus to the system’s notification area.
-        /// </summary>
-        public static Tray Tray { get { return Tray.Instance; } }
-
-        /// <summary>
-        /// Detect keyboard events when the application does not have keyboard focus.
-        /// </summary>
-        public static GlobalShortcut GlobalShortcut { get { return GlobalShortcut.Instance; } }
-
-        /// <summary>
-        /// Manage files and URLs using their default applications.
-        /// </summary>
-        public static Shell Shell { get { return Shell.Instance; } }
-
-        /// <summary>
-        /// Retrieve information about screen size, displays, cursor position, etc.
-        /// </summary>
-        public static Screen Screen { get { return Screen.Instance; } }
-
-        /// <summary>
-        /// Perform copy and paste operations on the system clipboard.
-        /// </summary>
-        public static Clipboard Clipboard { get { return Clipboard.Instance; } }
-
-        /// <summary>
-        /// Allows you to execute native JavaScript/TypeScript code from the host process.
-        /// 
-        /// It is only possible if the Electron.NET CLI has previously added an 
-        /// ElectronHostHook directory:
-        /// <c>electronize add HostHook</c>
-        /// </summary>
-        public static HostHook HostHook { get { return HostHook.Instance; } }
-
-        /// <summary>
-        /// Allows you to execute native Lock and Unlock process.       
-        /// </summary>
-        public static PowerMonitor PowerMonitor { get { return PowerMonitor.Instance; } }
-
-        /// <summary>
-        /// Read and respond to changes in Chromium's native color theme.
-        /// </summary>
-        public static NativeTheme NativeTheme { get { return NativeTheme.Instance; } }
-
-        /// <summary>
-        /// Control your app in the macOS dock.
-        /// </summary>
-        public static Dock Dock { get { return Dock.Instance; } }
-    }
-}

ElectronNET.API/ElectronNET.API.csproj

@@ -1,47 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFramework>net5.0</TargetFramework>
-    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
-    <PackageOutputPath>..\artifacts</PackageOutputPath>
-    <PackageId>ElectronNET.API</PackageId>
-    <Authors>Gregor Biswanger, Robert Muehsig</Authors>
-    <Company />
-    <Product>Electron.NET</Product>
-    <PackageLicenseExpression>MIT</PackageLicenseExpression>
-    <PackageProjectUrl>https://github.com/ElectronNET/Electron.NET/</PackageProjectUrl>
-    <Description>Building cross platform electron based desktop apps with .NET Core and ASP.NET Core.
-This package contains the API to access the "native" electron API.</Description>
-    <RepositoryUrl>https://github.com/ElectronNET/Electron.NET/</RepositoryUrl>
-    <RepositoryType>git</RepositoryType>
-    <PublishRepositoryUrl>true</PublishRepositoryUrl>
-    <PackageTags>electron aspnetcore</PackageTags>
-    <PackageReleaseNotes>Changelog: https://github.com/ElectronNET/Electron.NET/blob/master/Changelog.md</PackageReleaseNotes>
-    <PackageIcon>PackageIcon.png</PackageIcon>
-    <Version>99.0.0.0</Version>
-    <GenerateDocumentationFile>true</GenerateDocumentationFile>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <None Include="PackageIcon.png" Pack="true" PackagePath="\" />
-  </ItemGroup>
-
-  <Target Name="PostBuild" AfterTargets="PostBuildEvent" Condition="'$(OS)' == 'Windows_NT'">
-    <Exec Command="$(ProjectDir)devCleanup.cmd" IgnoreExitCode="true" />
-  </Target>
-  <Target Name="PostBuild" AfterTargets="PostBuildEvent" Condition="'$(OS)' != 'Windows_NT'">
-    <Exec Command="$(ProjectDir)devCleanup.sh" IgnoreExitCode="true" />
-  </Target>
-  <ItemGroup>
-   <FrameworkReference Include="Microsoft.AspNetCore.App" />
-</ItemGroup>
-  <ItemGroup>
-    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
-    </PackageReference>
-    <PackageReference Include="SocketIoClientDotNet" Version="1.0.5" />
-    <PackageReference Include="System.Drawing.Common" Version="5.0.0" />
-  </ItemGroup>
-
-</Project>

ElectronNET.API/Entities/AddRepresentationOptions.cs

@@ -1,33 +0,0 @@
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public class AddRepresentationOptions
-    {
-        /// <summary>
-        /// Gets or sets the width
-        /// </summary>
-        public int? Width { get; set; }
-
-        /// <summary>
-        /// Gets or sets the height
-        /// </summary>
-        public int? Height { get; set; }
-
-        /// <summary>
-        /// Gets or sets the scalefactor
-        /// </summary>
-        public float ScaleFactor { get; set; } = 1.0f;
-
-        /// <summary>
-        /// Gets or sets the buffer
-        /// </summary>
-        public byte[] Buffer { get; set; }
-
-        /// <summary>
-        /// Gets or sets the dataURL
-        /// </summary>
-        public string DataUrl { get; set; } 
-    }
-}

ElectronNET.API/Entities/CPUUsage.cs

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

ElectronNET.API/Entities/ClearStorageDataOptions.cs

@@ -1,24 +0,0 @@
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public class ClearStorageDataOptions
-    {
-        /// <summary>
-        /// Should follow window.location.origin’s representation scheme://host:port.
-        /// </summary>
-        public string Origin { get; set; }
-
-        /// <summary>
-        /// The types of storages to clear, can contain: appcache, cookies, filesystem,
-        /// indexdb, localstorage, shadercache, websql, serviceworkers, cachestorage.
-        /// </summary>
-        public string[] Storages { get; set; }
-
-        /// <summary>
-        /// The types of quotas to clear, can contain: temporary, persistent, syncable.
-        /// </summary>
-        public string[] Quotas { get; set; }
-    }
-}

ElectronNET.API/Entities/Cookie.cs

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

ElectronNET.API/Entities/CookieChangedCause.cs

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

ElectronNET.API/Entities/CookieDetails.cs

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

ElectronNET.API/Entities/Display.cs

@@ -1,60 +0,0 @@
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public class Display
-    {
-        /// <summary>
-        /// Gets or sets the bounds.
-        /// </summary>
-        /// <value>
-        /// The bounds.
-        /// </value>
-        public Rectangle Bounds { get; set; }
-
-        /// <summary>
-        /// Unique identifier associated with the display.
-        /// </summary>
-        public string Id { get; set; }
-
-        /// <summary>
-        /// Can be 0, 90, 180, 270, represents screen rotation in clock-wise degrees.
-        /// </summary>
-        public int Rotation { get; set; }
-
-        /// <summary>
-        /// Output device's pixel scale factor.
-        /// </summary>
-        public int ScaleFactor { get; set; }
-
-        /// <summary>
-        /// Gets or sets the size.
-        /// </summary>
-        /// <value>
-        /// The size.
-        /// </value>
-        public Size Size { get; set; }
-
-        /// <summary>
-        /// Can be available, unavailable, unknown.
-        /// </summary>
-        public string TouchSupport { get; set; }
-
-        /// <summary>
-        /// Gets or sets the work area.
-        /// </summary>
-        /// <value>
-        /// The work area.
-        /// </value>
-        public Rectangle WorkArea { get; set; }
-
-        /// <summary>
-        /// Gets or sets the size of the work area.
-        /// </summary>
-        /// <value>
-        /// The size of the work area.
-        /// </value>
-        public Size WorkAreaSize { get; set; }
-    }
-}

ElectronNET.API/Entities/DisplayBalloonOptions.cs

@@ -1,32 +0,0 @@
-namespace ElectronNET.API
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public class DisplayBalloonOptions
-    {
-        /// <summary>
-        /// Gets or sets the icon.
-        /// </summary>
-        /// <value>
-        /// The icon.
-        /// </value>
-        public string Icon { get; set; }
-
-        /// <summary>
-        /// Gets or sets the title.
-        /// </summary>
-        /// <value>
-        /// The title.
-        /// </value>
-        public string Title { get; set; }
-
-        /// <summary>
-        /// Gets or sets the content.
-        /// </summary>
-        /// <value>
-        /// The content.
-        /// </value>
-        public string Content { get; set; }
-    }
-}

ElectronNET.API/Entities/FileIconSize.cs

@@ -1,23 +0,0 @@
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public enum FileIconSize
-    {
-        /// <summary>
-        /// The small
-        /// </summary>
-        small,
-
-        /// <summary>
-        /// The normal
-        /// </summary>
-        normal,
-
-        /// <summary>
-        /// The large
-        /// </summary>
-        large
-    }
-}

ElectronNET.API/Entities/GPUFeatureStatus.cs

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

ElectronNET.API/Entities/IPostData.cs

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

ElectronNET.API/Entities/JumpListCategory.cs

@@ -1,27 +0,0 @@
-using Newtonsoft.Json;
-using Newtonsoft.Json.Converters;
-
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public class JumpListCategory
-    {
-        /// <summary>
-        /// Must be set if type is custom, otherwise it should be omitted.
-        /// </summary>
-        public string Name { get; set; }
-
-        /// <summary>
-        /// Array of objects if type is tasks or custom, otherwise it should be omitted.
-        /// </summary>
-        public JumpListItem[] Items { get; set; }
-
-        /// <summary>
-        /// One of the following: "tasks" | "frequent" | "recent" | "custom"
-        /// </summary>
-        [JsonConverter(typeof(StringEnumConverter))]
-        public JumpListCategoryType Type { get; set; }
-    }
-}

ElectronNET.API/Entities/JumpListItem.cs

@@ -1,58 +0,0 @@
-using Newtonsoft.Json;
-using Newtonsoft.Json.Converters;
-
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public class JumpListItem
-    {
-        /// <summary>
-        /// The command line arguments when program is executed. Should only be set if type is task.
-        /// </summary>
-        public string Args { get; set; }
-
-        /// <summary>
-        /// Description of the task (displayed in a tooltip). Should only be set if type is task.
-        /// </summary>
-        public string Description { get; set; }
-
-        /// <summary>
-        /// The index of the icon in the resource file. If a resource file contains multiple
-        /// icons this value can be used to specify the zero-based index of the icon that
-        /// should be displayed for this task.If a resource file contains only one icon,
-        /// this property should be set to zero.
-        /// </summary>
-        public int IconIndex { get; set; }
-
-        /// <summary>
-        /// The absolute path to an icon to be displayed in a Jump List, which can be an
-        /// arbitrary resource file that contains an icon(e.g. .ico, .exe, .dll). You can
-        /// usually specify process.execPath to show the program icon.
-        /// </summary>
-        public string IconPath { get; set; }
-
-        /// <summary>
-        /// Path of the file to open, should only be set if type is file.
-        /// </summary>
-        public string Path { get; set; }
-
-        /// <summary>
-        /// Path of the program to execute, usually you should specify process.execPath
-        /// which opens the current program.Should only be set if type is task.
-        /// </summary>
-        public string Program { get; set; }
-
-        /// <summary>
-        /// The text to be displayed for the item in the Jump List. Should only be set if type is task.
-        /// </summary>
-        public string Title { get; set; }
-
-        /// <summary>
-        /// One of the following: "task" | "separator" | "file"
-        /// </summary>
-        [JsonConverter(typeof(StringEnumConverter))]
-        public JumpListItemType Type { get; set; }
-    }
-}

ElectronNET.API/Entities/LoginItemSettings.cs

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

ElectronNET.API/Entities/LoginItemSettingsOptions.cs

@@ -1,18 +0,0 @@
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public class LoginItemSettingsOptions
-    {
-        /// <summary>
-        /// The executable path to compare against. Defaults to process.execPath.
-        /// </summary>
-        public string Path { get; set; }
-
-        /// <summary>
-        /// The command-line arguments to compare against. Defaults to an empty array.
-        /// </summary>
-        public string[] Args { get; set; }
-    }
-}

ElectronNET.API/Entities/LoginSettings.cs

@@ -1,32 +0,0 @@
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public class LoginSettings
-    {
-        /// <summary>
-        /// <see langword="true"/> to open the app at login, <see langword="false"/> to remove the app as a login item.
-        /// Defaults to <see langword="false"/>.
-        /// </summary>
-        public bool OpenAtLogin { get; set; }
-
-        /// <summary>
-        /// <see langword="true"/> to open the app as hidden. Defaults to <see langword="false"/>. The user can edit this
-        /// setting from the System Preferences so app.getLoginItemSettings().wasOpenedAsHidden should be checked when the app is
-        /// opened to know the current value. This setting is not available on <see href="https://www.electronjs.org/docs/tutorial/mac-app-store-submission-guide">MAS builds</see>.
-        /// </summary>
-        public bool OpenAsHidden { get; set; }
-
-        /// <summary>
-        /// The executable to launch at login. Defaults to process.execPath.
-        /// </summary>
-        public string Path { get; set; }
-
-        /// <summary>
-        /// The command-line arguments to pass to the executable. Defaults to an empty
-        /// array.Take care to wrap paths in quotes.
-        /// </summary>
-        public string[] Args { get; set; }
-    }
-}

ElectronNET.API/Entities/MemoryInfo.cs

@@ -1,24 +0,0 @@
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public class MemoryInfo
-    {
-        /// <summary>
-        /// The amount of memory currently pinned to actual physical RAM.
-        /// </summary>
-        public int WorkingSetSize { get; set; }
-
-        /// <summary>
-        /// The maximum amount of memory that has ever been pinned to actual physical RAM. 
-        /// </summary>
-        public int PeakWorkingSetSize { get; set; }
-
-        /// <summary>
-        /// The amount of memory not shared by other processes, such as JS heap or HTML
-        /// content.
-        /// </summary>
-        public int PrivateBytes { get; set; }
-    }
-}

ElectronNET.API/Entities/MenuItem.cs

@@ -1,103 +0,0 @@
-using Newtonsoft.Json;
-using Newtonsoft.Json.Converters;
-using System;
-using System.ComponentModel;
-
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public class MenuItem
-    {
-        /// <summary>
-        /// Will be called with click(menuItem, browserWindow, event) when the menu item is 
-        /// clicked.
-        /// </summary>
-        [JsonIgnore]
-        public Action Click { get; set; }
-
-        /// <summary>
-        /// Define the action of the menu item, when specified the click property will be
-        /// ignored.
-        /// </summary>
-        [JsonConverter(typeof(StringEnumConverter))]
-        public MenuRole Role { get; set; }
-
-        /// <summary>
-        /// Can be normal, separator, submenu, checkbox or radio.
-        /// </summary>
-        [JsonConverter(typeof(StringEnumConverter))]
-        public MenuType Type { get; set; }
-
-
-        /// <summary>
-        /// Gets or sets the label.
-        /// </summary>
-        /// <value>
-        /// The label.
-        /// </value>
-        public string Label { get; set; }
-
-
-        /// <summary>
-        /// Gets or sets the sublabel.
-        /// </summary>
-        /// <value>
-        /// The sublabel.
-        /// </value>
-        public string Sublabel { get; set; }
-
-
-        /// <summary>
-        /// Gets or sets the accelerator.
-        /// </summary>
-        /// <value>
-        /// The accelerator.
-        /// </value>
-        public string Accelerator { get; set; }
-
-
-        /// <summary>
-        /// Gets or sets the icon.
-        /// </summary>
-        /// <value>
-        /// The icon.
-        /// </value>
-        public string Icon { get; set; }
-
-        /// <summary>
-        /// If false, the menu item will be greyed out and unclickable.
-        /// </summary>
-        public bool Enabled { get; set; } = true;
-
-        /// <summary>
-        /// If false, the menu item will be entirely hidden.
-        /// </summary>
-        public bool Visible { get; set; } = true;
-
-        /// <summary>
-        /// Should only be specified for checkbox or radio type menu items.
-        /// </summary>
-        public bool Checked { get; set; }
-
-        /// <summary>
-        /// Should be specified for submenu type menu items. If submenu is specified, the
-        /// type: 'submenu' can be omitted.If the value is not a Menu then it will be
-        /// automatically converted to one using Menu.buildFromTemplate.
-        /// </summary>
-        public MenuItem[] Submenu { get; set; }
-
-        /// <summary>
-        /// Unique within a single menu. If defined then it can be used as a reference to
-        /// this item by the position attribute.
-        /// </summary>
-        public string Id { get; internal set; }
-
-        /// <summary>
-        /// This field allows fine-grained definition of the specific location within a
-        /// given menu.
-        /// </summary>
-        public string Position { get; set; }
-    }
-}

ElectronNET.API/Entities/MenuType.cs

@@ -1,33 +0,0 @@
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public enum MenuType
-    {
-        /// <summary>
-        /// The normal
-        /// </summary>
-        normal,
-
-        /// <summary>
-        /// The separator
-        /// </summary>
-        separator,
-
-        /// <summary>
-        /// The submenu
-        /// </summary>
-        submenu,
-
-        /// <summary>
-        /// The checkbox
-        /// </summary>
-        checkbox,
-
-        /// <summary>
-        /// The radio
-        /// </summary>
-        radio
-    }
-}

ElectronNET.API/Entities/MessageBoxOptions.cs

@@ -1,101 +0,0 @@
-using Newtonsoft.Json;
-using Newtonsoft.Json.Converters;
-
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public class MessageBoxOptions
-    {
-        /// <summary>
-        ///  Can be "none", "info", "error", "question" or "warning". On Windows, "question"
-        ///  displays the same icon as "info", unless you set an icon using the "icon"
-        ///  option. On macOS, both "warning" and "error" display the same warning icon.
-        /// </summary>
-        [JsonConverter(typeof(StringEnumConverter))]
-        public MessageBoxType Type { get; set; }
-
-        /// <summary>
-        /// Array of texts for buttons. On Windows, an empty array will result in one button
-        /// labeled "OK".
-        /// </summary>
-        public string[] Buttons { get; set; }
-
-        /// <summary>
-        /// Index of the button in the buttons array which will be selected by default when
-        /// the message box opens.
-        /// </summary>
-        public int DefaultId { get; set; }
-
-        /// <summary>
-        /// Title of the message box, some platforms will not show it.
-        /// </summary>
-        public string Title { get; set; }
-
-        /// <summary>
-        /// Content of the message box.
-        /// </summary>
-        public string Message { get; set; }
-
-        /// <summary>
-        /// Extra information of the message.
-        /// </summary>
-        public string Detail { get; set; }
-
-        /// <summary>
-        /// If provided, the message box will include a checkbox with the given label. The
-        /// checkbox state can be inspected only when using callback.
-        /// </summary>
-        public string CheckboxLabel { get; set; }
-
-        /// <summary>
-        /// Initial checked state of the checkbox. false by default.
-        /// </summary>
-        public bool CheckboxChecked { get; set; }
-
-        /// <summary>
-        /// Gets or sets the icon.
-        /// </summary>
-        /// <value>
-        /// The icon.
-        /// </value>
-        public string Icon { get; set; }
-
-        /// <summary>
-        /// The index of the button to be used to cancel the dialog, via the Esc key. By
-        /// default this is assigned to the first button with "cancel" or "no" as the label.
-        /// If no such labeled buttons exist and this option is not set, 0 will be used as
-        /// the return value or callback response. This option is ignored on Windows.
-        /// </summary>
-        public int CancelId { get; set; }
-
-        /// <summary>
-        /// On Windows Electron will try to figure out which one of the buttons are common
-        /// buttons(like "Cancel" or "Yes"), and show the others as command links in the
-        /// dialog.This can make the dialog appear in the style of modern Windows apps. If
-        /// you don't like this behavior, you can set noLink to true.
-        /// </summary>
-        public bool NoLink { get; set; }
-
-        /// <summary>
-        /// Normalize the keyboard access keys across platforms. Default is false. Enabling
-        /// this assumes AND character is used in the button labels for the placement of the keyboard
-        /// shortcut access key and labels will be converted so they work correctly on each
-        /// platform, AND characters are removed on macOS, converted to _ on Linux, and left
-        /// untouched on Windows.For example, a button label of VieANDw will be converted to
-        /// Vie_w on Linux and View on macOS and can be selected via Alt-W on Windows and
-        /// Linux.
-        /// </summary>
-        public bool NormalizeAccessKeys { get; set; }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="MessageBoxOptions"/> class.
-        /// </summary>
-        /// <param name="message">The message.</param>
-        public MessageBoxOptions(string message)
-        {
-            Message = message;
-        }
-    }
-}

ElectronNET.API/Entities/NativeImageJsonConverter.cs

@@ -1,34 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Drawing;
-using System.IO;
-using Newtonsoft.Json;
-
-namespace ElectronNET.API.Entities
-{
-    internal class NativeImageJsonConverter : JsonConverter
-    {
-        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
-        {
-            if (value is NativeImage nativeImage)
-            {
-                var scaledImages = nativeImage.GetAllScaledImages();
-                serializer.Serialize(writer, scaledImages);
-            }
-        }
-
-        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
-        {
-            var dict = serializer.Deserialize<Dictionary<float, string>>(reader);
-            var newDictionary = new Dictionary<float, Image>();
-            foreach (var item in dict)
-            {
-                var bytes = Convert.FromBase64String(item.Value);
-                newDictionary.Add(item.Key, Image.FromStream(new MemoryStream(bytes)));
-            }
-            return new NativeImage(newDictionary);
-        }
-
-        public override bool CanConvert(Type objectType) => objectType == typeof(NativeImage);
-    }
-}

ElectronNET.API/Entities/NotificationAction.cs

@@ -1,18 +0,0 @@
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public class NotificationAction
-    {
-        /// <summary>
-        /// The label for the given action.
-        /// </summary>
-        public string Text { get; set; }
-
-        /// <summary>
-        /// The type of action, can be button.
-        /// </summary>
-        public string Type { get; set; }
-    }
-}

ElectronNET.API/Entities/OpenDevToolsOptions.cs

@@ -1,19 +0,0 @@
-using Newtonsoft.Json;
-using Newtonsoft.Json.Converters;
-
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public class OpenDevToolsOptions
-    {
-        /// <summary>
-        /// Opens the devtools with specified dock state, can be right, bottom, undocked,
-        /// detach.Defaults to last used dock state.In undocked mode it's possible to dock
-        /// back.In detach mode it's not.
-        /// </summary>
-        [JsonConverter(typeof(StringEnumConverter))]
-        public DevToolsMode Mode { get; set; }
-    }
-}

ElectronNET.API/Entities/OpenExternalOptions.cs

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

ElectronNET.API/Entities/PathName.cs

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

ElectronNET.API/Entities/PrintOptions.cs

@@ -1,107 +0,0 @@
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// Print dpi
-    /// </summary>
-    public class PrintDpi
-    {
-        /// <summary>
-        /// The horizontal dpi
-        /// </summary>
-        public float Horizontal { get; set; }
-
-        /// <summary>
-        /// The vertical dpi
-        /// </summary>
-        public float Vertical { get; set; }
-    }
-
-    /// <summary>
-    /// The page range to print
-    /// </summary>
-    public class PrintPageRange
-    {
-        /// <summary>
-        /// From
-        /// </summary>
-        public int From { get; set; }
-
-        /// <summary>
-        /// To
-        /// </summary>
-        public int To { get; set; }
-    }
-
-    /// <summary>
-    /// Print options
-    /// </summary>
-    public class PrintOptions
-    {
-        /// <summary>
-        /// Don't ask user for print settings
-        /// </summary>
-        public bool Silent { get; set; }
-
-        /// <summary>
-        /// Prints the background color and image of the web page
-        /// </summary>
-        public bool PrintBackground { get; set; }
-
-        /// <summary>
-        /// Set the printer device name to use
-        /// </summary>
-        public string DeviceName { get; set; }
-
-        /// <summary>
-        /// Set whether the printed web page will be in color or grayscale
-        /// </summary>
-        public bool Color { get; set; }
-
-        /// <summary>
-        /// Specifies the type of margins to use. Uses 0 for default margin, 1 for no
-        /// margin, and 2 for minimum margin.
-        /// </summary>
-        public int MarginsType { get; set; }
-
-        /// <summary>
-        /// true for landscape, false for portrait.
-        /// </summary>
-        public bool Landscape { get; set; }
-        
-        /// <summary>
-        /// The scale factor of the web page
-        /// </summary>
-        public float ScaleFactor { get; set; }
-
-        /// <summary>
-        /// The number of pages to print per page sheet
-        /// </summary>
-        public int PagesPerSheet { get; set; }
-
-        /// <summary>
-        /// The number of copies of the web page to print
-        /// </summary>
-        public bool Copies { get; set; }
-
-        /// <summary>
-        /// Whether the web page should be collated
-        /// </summary>
-        public bool Collate { get; set; }
-
-        /// <summary>
-        /// The page range to print
-        /// </summary>
-        public PrintPageRange PageRanges { get; set; }
-
-        /// <summary>
-        /// Set the duplex mode of the printed web page. Can be simplex, shortEdge, or longEdge.
-        /// </summary>
-        public string DuplexMode { get; set; }
-
-        /// <summary>
-        /// Dpi
-        /// </summary>
-        public PrintDpi Dpi { get; set; }
-
-    }
-}

ElectronNET.API/Entities/PrintToPDFOptions.cs

@@ -1,35 +0,0 @@
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public class PrintToPDFOptions
-    {
-        /// <summary>
-        /// Specifies the type of margins to use. Uses 0 for default margin, 1 for no
-        /// margin, and 2 for minimum margin.
-        /// </summary>
-        public int MarginsType { get; set; }
-
-        /// <summary>
-        /// Specify page size of the generated PDF. Can be A3, A4, A5, Legal, Letter,
-        /// Tabloid or an Object containing height and width in microns.
-        /// </summary>
-        public string PageSize { get; set; }
-
-        /// <summary>
-        /// Whether to print CSS backgrounds.
-        /// </summary>
-        public bool PrintBackground { get; set; }
-
-        /// <summary>
-        /// Whether to print selection only.
-        /// </summary>
-        public bool PrintSelectionOnly { get; set; }
-
-        /// <summary>
-        /// true for landscape, false for portrait.
-        /// </summary>
-        public bool Landscape { get; set; }
-    }
-}

ElectronNET.API/Entities/PrinterInfo.cs

@@ -1,29 +0,0 @@
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// Printer info
-    /// </summary>
-    public class PrinterInfo
-    {
-        /// <summary>
-        /// Name
-        /// </summary>
-        public string Name { get; set; }
-
-        /// <summary>
-        /// Name
-        /// </summary>
-        public string Description { get; set; }
-        
-        /// <summary>
-        /// Status
-        /// </summary>
-        public int Status { get; set; }
-
-        /// <summary>
-        /// Is default
-        /// </summary>
-        public bool IsDefault { get; set; }
-
-    }
-}

ElectronNET.API/Entities/ProcessMetric.cs

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

ElectronNET.API/Entities/ProgressBarOptions.cs

@@ -1,17 +0,0 @@
-using Newtonsoft.Json;
-using Newtonsoft.Json.Converters;
-
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public class ProgressBarOptions
-    {
-        /// <summary>
-        /// Mode for the progress bar. Can be 'none' | 'normal' | 'indeterminate' | 'error' | 'paused'.
-        /// </summary>
-        [JsonConverter(typeof(StringEnumConverter))]
-        public ProgressBarMode Mode { get; set; }
-    }
-}

ElectronNET.API/Entities/ProgressInfo.cs

@@ -1,37 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public class ProgressInfo
-    {
-        /// <summary>
-        /// 
-        /// </summary>
-        public string Progress { get; set; }
-
-        /// <summary>
-        /// 
-        /// </summary>
-        public string BytesPerSecond { get; set; }
-
-        /// <summary>
-        /// 
-        /// </summary>
-        public string Percent { get; set; }
-
-        /// <summary>
-        /// 
-        /// </summary>
-        public string Total { get; set; }
-
-        /// <summary>
-        /// 
-        /// </summary>
-        public string Transferred { get; set; }
-    }
-}

ElectronNET.API/Entities/ToBitmapOptions.cs

@@ -1,13 +0,0 @@
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public class ToBitmapOptions
-    {
-        /// <summary>
-        /// Gets or sets the scalefactor
-        /// </summary>
-        public float ScaleFactor { get; set; } = 1.0f;
-    }
-}

ElectronNET.API/Entities/Vibrancy.cs

@@ -1,63 +0,0 @@
-using System.Runtime.Serialization;
-
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public enum Vibrancy
-    {
-        /// <summary>
-        /// The appearance based
-        /// </summary>
-        [EnumMember(Value = "appearance-based")]
-        appearanceBased,
-
-        /// <summary>
-        /// The light
-        /// </summary>
-        light,
-
-        /// <summary>
-        /// The dark
-        /// </summary>
-        dark,
-
-        /// <summary>
-        /// The titlebar
-        /// </summary>
-        titlebar,
-
-        /// <summary>
-        /// The selection
-        /// </summary>
-        selection,
-
-        /// <summary>
-        /// The menu
-        /// </summary>
-        menu,
-
-        /// <summary>
-        /// The popover
-        /// </summary>
-        popover,
-
-        /// <summary>
-        /// The sidebar
-        /// </summary>
-        sidebar,
-
-        /// <summary>
-        /// The medium light
-        /// </summary>
-        [EnumMember(Value = "medium-light")]
-        mediumLight,
-
-        /// <summary>
-        /// The ultra dark
-        /// </summary>
-        [EnumMember(Value = "ultra-dark")]
-        ultraDark
-    }
-}

ElectronNET.API/Events.cs

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

ElectronNET.API/Extensions/EnumExtensions.cs

@@ -1,34 +0,0 @@
-using System;
-using System.ComponentModel;
-using System.Reflection;
-
-namespace ElectronNET.API.Extensions
-{
-    internal static class EnumExtensions
-    {
-        public static string GetDescription<T>(this T enumerationValue) where T : struct
-        {
-            Type type = enumerationValue.GetType();
-            if (!type.IsEnum)
-            {
-                throw new ArgumentException("EnumerationValue must be of Enum type", "enumerationValue");
-            }
-
-            //Tries to find a DescriptionAttribute for a potential friendly name
-            //for the enum
-            MemberInfo[] memberInfo = type.GetMember(enumerationValue.ToString());
-            if (memberInfo != null && memberInfo.Length > 0)
-            {
-                object[] attrs = memberInfo[0].GetCustomAttributes(typeof(DescriptionAttribute), false);
-
-                if (attrs != null && attrs.Length > 0)
-                {
-                    //Pull out the description value
-                    return ((DescriptionAttribute)attrs[0]).Description;
-                }
-            }
-            //If we have no description attribute, just return the ToString of the enum
-            return enumerationValue.ToString();
-        }
-    }
-}

ElectronNET.API/IpcMain.cs

@@ -1,228 +0,0 @@
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
-using Newtonsoft.Json.Serialization;
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace ElectronNET.API
-{
-    /// <summary>
-    /// Communicate asynchronously from the main process to renderer processes.
-    /// </summary>
-    public sealed class IpcMain
-    {
-        private static IpcMain _ipcMain;
-        private static object _syncRoot = new object();
-
-        internal IpcMain() { }
-
-        internal static IpcMain Instance
-        {
-            get
-            {
-                if(_ipcMain == null)
-                {
-                    lock (_syncRoot)
-                    {
-                        if(_ipcMain == null)
-                        {
-                            _ipcMain = new IpcMain();
-                        }
-                    }
-                }
-
-                return _ipcMain;
-            }
-        }
-
-        /// <summary>
-        ///  Listens to channel, when a new message arrives listener would be called with 
-        ///  listener(event, args...).
-        /// </summary>
-        /// <param name="channel">Channelname.</param>
-        /// <param name="listener">Callback Method.</param>
-        public void On(string channel, Action<object> listener)
-        {
-            BridgeConnector.Socket.Emit("registerIpcMainChannel", channel);
-            BridgeConnector.Socket.Off(channel);
-            BridgeConnector.Socket.On(channel, (args) => 
-            {
-                List<object> objectArray = FormatArguments(args);
-
-                if(objectArray.Count == 1)
-                {
-                    listener(objectArray.First());
-                }
-                else
-                {
-                    listener(objectArray);
-                }
-            });
-        }
-
-        private List<object> FormatArguments(object args)
-        {
-            List<object> objectArray = ((JArray)args).ToObject<object[]>().ToList();
-
-            for (int index = 0; index < objectArray.Count; index++)
-            {
-                var item = objectArray[index];
-                if (item == null)
-                {
-                    objectArray.Remove(item);
-                }
-            }
-
-            return objectArray;
-        }
-
-        /// <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, object> listener)
-        {
-            BridgeConnector.Socket.Emit("registerSyncIpcMainChannel", channel);
-            BridgeConnector.Socket.On(channel, (args) => {
-                List<object> objectArray = FormatArguments(args);
-                object parameter;
-                if (objectArray.Count == 1)
-                {
-                    parameter = objectArray.First();
-                }
-                else
-                {
-                    parameter = objectArray;
-                }
-
-                var result = listener(parameter);
-                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.
-        /// </summary>
-        /// <param name="channel">Channelname.</param>
-        /// <param name="listener">Callback Method.</param>
-        public void Once(string channel, Action<object> listener)
-        {
-            BridgeConnector.Socket.Emit("registerOnceIpcMainChannel", channel);
-            BridgeConnector.Socket.On(channel, (args) =>
-            {
-                List<object> objectArray = FormatArguments(args);
-
-                if (objectArray.Count == 1)
-                {
-                    listener(objectArray.First());
-                }
-                else
-                {
-                    listener(objectArray);
-                }
-            });
-        }
-
-        /// <summary>
-        /// Removes listeners of the specified channel.
-        /// </summary>
-        /// <param name="channel">Channelname.</param>
-        public void RemoveAllListeners(string channel)
-        {
-            BridgeConnector.Socket.Emit("removeAllListenersIpcMainChannel", channel);
-        }
-
-        /// <summary>
-        /// Send a message to the renderer process asynchronously via channel, you can also send
-        /// arbitrary arguments. Arguments will be serialized in JSON internally and hence
-        /// no functions or prototype chain will be included. The renderer process handles it by
-        /// listening for channel with ipcRenderer module.
-        /// </summary>
-        /// <param name="browserWindow">BrowserWindow with channel.</param>
-        /// <param name="channel">Channelname.</param>
-        /// <param name="data">Arguments data.</param>
-        public void Send(BrowserWindow browserWindow, string channel, params object[] data)
-        {
-            List<JObject> jobjects = new List<JObject>();
-            List<JArray> jarrays = new List<JArray>();
-            List<object> objects = new List<object>();
-
-            foreach (var parameterObject in data)
-            {
-                if(parameterObject.GetType().IsArray || parameterObject.GetType().IsGenericType && parameterObject is IEnumerable)
-                {
-                    jarrays.Add(JArray.FromObject(parameterObject, _jsonSerializer));
-                } else if(parameterObject.GetType().IsClass && !parameterObject.GetType().IsPrimitive && !(parameterObject is string))
-                {
-                    jobjects.Add(JObject.FromObject(parameterObject, _jsonSerializer));
-                } else if(parameterObject.GetType().IsPrimitive || (parameterObject is string))
-                {
-                    objects.Add(parameterObject);
-                }
-            }
-
-            if(jobjects.Count > 0 || jarrays.Count > 0)
-            {
-                BridgeConnector.Socket.Emit("sendToIpcRenderer", JObject.FromObject(browserWindow, _jsonSerializer), channel, jarrays.ToArray(), jobjects.ToArray(), objects.ToArray());
-            }
-            else
-            {
-                BridgeConnector.Socket.Emit("sendToIpcRenderer", JObject.FromObject(browserWindow, _jsonSerializer), channel, data);
-            }
-        }
-
-        /// <summary>
-        /// Send a message to the BrowserView renderer process asynchronously via channel, you can also send
-        /// arbitrary arguments. Arguments will be serialized in JSON internally and hence
-        /// no functions or prototype chain will be included. The renderer process handles it by
-        /// listening for channel with ipcRenderer module.
-        /// </summary>
-        /// <param name="browserView">BrowserView with channel.</param>
-        /// <param name="channel">Channelname.</param>
-        /// <param name="data">Arguments data.</param>
-        public void Send(BrowserView browserView, string channel, params object[] data)
-        {
-            List<JObject> jobjects = new List<JObject>();
-            List<JArray> jarrays = new List<JArray>();
-            List<object> objects = new List<object>();
-
-            foreach (var parameterObject in data)
-            {
-                if(parameterObject.GetType().IsArray || parameterObject.GetType().IsGenericType && parameterObject is IEnumerable)
-                {
-                    jarrays.Add(JArray.FromObject(parameterObject, _jsonSerializer));
-                } else if(parameterObject.GetType().IsClass && !parameterObject.GetType().IsPrimitive && !(parameterObject is string))
-                {
-                    jobjects.Add(JObject.FromObject(parameterObject, _jsonSerializer));
-                } else if(parameterObject.GetType().IsPrimitive || (parameterObject is string))
-                {
-                    objects.Add(parameterObject);
-                }
-            }
-
-            if(jobjects.Count > 0 || jarrays.Count > 0)
-            {
-                BridgeConnector.Socket.Emit("sendToIpcRendererBrowserView", browserView.Id, channel, jarrays.ToArray(), jobjects.ToArray(), objects.ToArray());
-            }
-            else
-            {
-                BridgeConnector.Socket.Emit("sendToIpcRendererBrowserView", browserView.Id, channel, data);
-            }
-        }
-
-        private JsonSerializer _jsonSerializer = new JsonSerializer()
-        {
-            ContractResolver = new CamelCasePropertyNamesContractResolver(),
-            NullValueHandling = NullValueHandling.Ignore,
-            DefaultValueHandling = DefaultValueHandling.Ignore
-        };
-    }
-}

ElectronNET.API/LifetimeServiceHost.cs

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

ElectronNET.API/PowerMonitor.cs

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

ElectronNET.API/Screen.cs

@@ -1,259 +0,0 @@
-using ElectronNET.API.Entities;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
-using Newtonsoft.Json.Serialization;
-using System;
-using System.Threading.Tasks;
-
-namespace ElectronNET.API
-{
-    /// <summary>
-    /// Retrieve information about screen size, displays, cursor position, etc.
-    /// </summary>
-    public sealed class Screen
-    {
-        /// <summary>
-        /// Emitted when an new Display has been added.
-        /// </summary>
-        public event Action<Display> OnDisplayAdded
-        {
-            add
-            {
-                if (_onDisplayAdded == null)
-                {
-                    BridgeConnector.Socket.On("screen-display-added-event" + GetHashCode(), (display) =>
-                    {
-                        _onDisplayAdded(((JObject)display).ToObject<Display>());
-                    });
-
-                    BridgeConnector.Socket.Emit("register-screen-display-added", GetHashCode());
-                }
-                _onDisplayAdded += value;
-            }
-            remove
-            {
-                _onDisplayAdded -= value;
-
-                if (_onDisplayAdded == null)
-                    BridgeConnector.Socket.Off("screen-display-added-event" + GetHashCode());
-            }
-        }
-
-        private event Action<Display> _onDisplayAdded;
-
-        /// <summary>
-        /// Emitted when oldDisplay has been removed.
-        /// </summary>
-        public event Action<Display> OnDisplayRemoved
-        {
-            add
-            {
-                if (_onDisplayRemoved == null)
-                {
-                    BridgeConnector.Socket.On("screen-display-removed-event" + GetHashCode(), (display) =>
-                    {
-                        _onDisplayRemoved(((JObject)display).ToObject<Display>());
-                    });
-
-                    BridgeConnector.Socket.Emit("register-screen-display-removed", GetHashCode());
-                }
-                _onDisplayRemoved += value;
-            }
-            remove
-            {
-                _onDisplayRemoved -= value;
-
-                if (_onDisplayRemoved == null)
-                    BridgeConnector.Socket.Off("screen-display-removed-event" + GetHashCode());
-            }
-        }
-
-        private event Action<Display> _onDisplayRemoved;
-
-        /// <summary>
-        /// Emitted when one or more metrics change in a display. 
-        /// The changedMetrics is an array of strings that describe the changes. 
-        /// Possible changes are bounds, workArea, scaleFactor and rotation.
-        /// </summary>
-        public event Action<Display, string[]> OnDisplayMetricsChanged
-        {
-            add
-            {
-                if (_onDisplayMetricsChanged == null)
-                {
-                    BridgeConnector.Socket.On("screen-display-metrics-changed-event" + GetHashCode(), (args) =>
-                    {
-                        var display = ((JArray)args).First.ToObject<Display>();
-                        var metrics = ((JArray)args).Last.ToObject<string[]>();
-
-                        _onDisplayMetricsChanged(display, metrics);
-                    });
-
-                    BridgeConnector.Socket.Emit("register-screen-display-metrics-changed", GetHashCode());
-                }
-                _onDisplayMetricsChanged += value;
-            }
-            remove
-            {
-                _onDisplayMetricsChanged -= value;
-
-                if (_onDisplayMetricsChanged == null)
-                    BridgeConnector.Socket.Off("screen-display-metrics-changed-event" + GetHashCode());
-            }
-        }
-
-        private event Action<Display, string[]> _onDisplayMetricsChanged;
-
-        private static Screen _screen;
-        private static object _syncRoot = new object();
-
-        internal Screen() { }
-
-        internal static Screen Instance
-        {
-            get
-            {
-                if (_screen == null)
-                {
-                    lock (_syncRoot)
-                    {
-                        if (_screen == null)
-                        {
-                            _screen = new Screen();
-                        }
-                    }
-                }
-
-                return _screen;
-            }
-        }
-
-        /// <summary>
-        /// The current absolute position of the mouse pointer.
-        /// </summary>
-        /// <returns></returns>
-        public Task<Point> GetCursorScreenPointAsync() 
-        {
-            var taskCompletionSource = new TaskCompletionSource<Point>();
-
-            BridgeConnector.Socket.On("screen-getCursorScreenPointCompleted", (point) =>
-            {
-                BridgeConnector.Socket.Off("screen-getCursorScreenPointCompleted");
-
-                taskCompletionSource.SetResult(((JObject)point).ToObject<Point>());
-            });
-
-            BridgeConnector.Socket.Emit("screen-getCursorScreenPoint");
-
-            return taskCompletionSource.Task;
-        }
-
-        /// <summary>
-        /// macOS: The height of the menu bar in pixels.
-        /// </summary>
-        /// <returns>The height of the menu bar in pixels.</returns>
-        public Task<int> GetMenuBarHeightAsync()
-        {
-            var taskCompletionSource = new TaskCompletionSource<int>();
-
-            BridgeConnector.Socket.On("screen-getMenuBarHeightCompleted", (height) =>
-            {
-                BridgeConnector.Socket.Off("screen-getMenuBarHeightCompleted");
-
-                taskCompletionSource.SetResult(int.Parse(height.ToString()));
-            });
-
-            BridgeConnector.Socket.Emit("screen-getMenuBarHeight");
-
-            return taskCompletionSource.Task;
-        }
-
-        /// <summary>
-        /// The primary display.
-        /// </summary>
-        /// <returns></returns>
-        public Task<Display> GetPrimaryDisplayAsync()
-        {
-            var taskCompletionSource = new TaskCompletionSource<Display>();
-
-            BridgeConnector.Socket.On("screen-getPrimaryDisplayCompleted", (display) =>
-            {
-                BridgeConnector.Socket.Off("screen-getPrimaryDisplayCompleted");
-
-                taskCompletionSource.SetResult(((JObject)display).ToObject<Display>());
-            });
-
-            BridgeConnector.Socket.Emit("screen-getPrimaryDisplay");
-
-            return taskCompletionSource.Task;
-        }
-
-        /// <summary>
-        /// An array of displays that are currently available.
-        /// </summary>
-        /// <returns>An array of displays that are currently available.</returns>
-        public Task<Display[]> GetAllDisplaysAsync()
-        {
-            var taskCompletionSource = new TaskCompletionSource<Display[]>();
-
-            BridgeConnector.Socket.On("screen-getAllDisplaysCompleted", (displays) =>
-            {
-                BridgeConnector.Socket.Off("screen-getAllDisplaysCompleted");
-
-                taskCompletionSource.SetResult(((JArray)displays).ToObject<Display[]>());
-            });
-
-            BridgeConnector.Socket.Emit("screen-getAllDisplays");
-
-            return taskCompletionSource.Task;
-        }
-
-        /// <summary>
-        /// The display nearest the specified point.
-        /// </summary>
-        /// <returns>The display nearest the specified point.</returns>
-        public Task<Display> GetDisplayNearestPointAsync(Point point)
-        {
-            var taskCompletionSource = new TaskCompletionSource<Display>();
-
-            BridgeConnector.Socket.On("screen-getDisplayNearestPointCompleted", (display) =>
-            {
-                BridgeConnector.Socket.Off("screen-getDisplayNearestPointCompleted");
-
-                taskCompletionSource.SetResult(((JObject)display).ToObject<Display>());
-            });
-
-            BridgeConnector.Socket.Emit("screen-getDisplayNearestPoint", JObject.FromObject(point, _jsonSerializer));
-
-            return taskCompletionSource.Task;
-        }
-
-        /// <summary>
-        /// The display that most closely intersects the provided bounds.
-        /// </summary>
-        /// <param name="rectangle"></param>
-        /// <returns>The display that most closely intersects the provided bounds.</returns>
-        public Task<Display> GetDisplayMatchingAsync(Rectangle rectangle)
-        {
-            var taskCompletionSource = new TaskCompletionSource<Display>();
-
-            BridgeConnector.Socket.On("screen-getDisplayMatching", (display) =>
-            {
-                BridgeConnector.Socket.Off("screen-getDisplayMatching");
-
-                taskCompletionSource.SetResult(((JObject)display).ToObject<Display>());
-            });
-
-            BridgeConnector.Socket.Emit("screen-getDisplayMatching", JObject.FromObject(rectangle, _jsonSerializer));
-
-            return taskCompletionSource.Task;
-        }
-
-        private JsonSerializer _jsonSerializer = new JsonSerializer()
-        {
-            ContractResolver = new CamelCasePropertyNamesContractResolver(),
-            NullValueHandling = NullValueHandling.Ignore,
-            DefaultValueHandling = DefaultValueHandling.Ignore
-        };
-    }
-}

ElectronNET.API/ServiceCollectionExtensions.cs

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

ElectronNET.API/WebContents.cs

@@ -1,280 +0,0 @@
-using ElectronNET.API.Entities;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
-using Newtonsoft.Json.Serialization;
-using System;
-using System.Threading.Tasks;
-
-namespace ElectronNET.API
-{
-    /// <summary>
-    /// Render and control web pages.
-    /// </summary>
-    public class WebContents
-    {
-        /// <summary>
-        /// Gets the identifier.
-        /// </summary>
-        /// <value>
-        /// The identifier.
-        /// </value>
-        public int Id { get; private set; }
-
-        /// <summary>
-        /// Manage browser sessions, cookies, cache, proxy settings, etc.
-        /// </summary>
-        public Session Session { get; internal set; }
-
-        /// <summary>
-        /// Emitted when the renderer process crashes or is killed.
-        /// </summary>
-        public event Action<bool> OnCrashed
-        {
-            add
-            {
-                if (_crashed == null)
-                {
-                    BridgeConnector.Socket.On("webContents-crashed" + Id, (killed) =>
-                    {
-                        _crashed((bool)killed);
-                    });
-
-                    BridgeConnector.Socket.Emit("register-webContents-crashed", Id);
-                }
-                _crashed += value;
-            }
-            remove
-            {
-                _crashed -= value;
-
-                if (_crashed == null)
-                    BridgeConnector.Socket.Off("webContents-crashed" + Id);
-            }
-        }
-
-        private event Action<bool> _crashed;
-
-        /// <summary>
-        /// Emitted when the navigation is done, i.e. the spinner of the tab has
-        /// stopped spinning, and the onload event was dispatched.
-        /// </summary>
-        public event Action OnDidFinishLoad
-        {
-            add
-            {
-                if (_didFinishLoad == null)
-                {
-                    BridgeConnector.Socket.On("webContents-didFinishLoad" + Id, () =>
-                    {
-                        _didFinishLoad();
-                    });
-
-                    BridgeConnector.Socket.Emit("register-webContents-didFinishLoad", Id);
-                }
-                _didFinishLoad += value;
-            }
-            remove
-            {
-                _didFinishLoad -= value;
-
-                if (_didFinishLoad == null)
-                    BridgeConnector.Socket.Off("webContents-didFinishLoad" + Id);
-            }
-        }
-
-        private event Action _didFinishLoad;
-
-        internal WebContents(int id)
-        {
-            Id = id;
-            Session = new Session(id);
-        }
-
-        /// <summary>
-        /// Opens the devtools.
-        /// </summary>
-        public void OpenDevTools()
-        {
-            BridgeConnector.Socket.Emit("webContentsOpenDevTools", Id);
-        }
-
-        /// <summary>
-        /// Opens the devtools.
-        /// </summary>
-        /// <param name="openDevToolsOptions"></param>
-        public void OpenDevTools(OpenDevToolsOptions openDevToolsOptions)
-        {
-            BridgeConnector.Socket.Emit("webContentsOpenDevTools", Id, JObject.FromObject(openDevToolsOptions, _jsonSerializer));
-        }
-
-        /// <summary>
-        /// Get system printers.
-        /// </summary>
-        /// <returns>printers</returns>
-        public Task<PrinterInfo[]> GetPrintersAsync()
-        {
-            var taskCompletionSource = new TaskCompletionSource<PrinterInfo[]>();
-
-            BridgeConnector.Socket.On("webContents-getPrinters-completed", (printers) =>
-            {
-                BridgeConnector.Socket.Off("webContents-getPrinters-completed");
-
-                taskCompletionSource.SetResult(((Newtonsoft.Json.Linq.JArray)printers).ToObject<PrinterInfo[]>());
-            });
-
-            BridgeConnector.Socket.Emit("webContents-getPrinters", Id);
-
-            return taskCompletionSource.Task;
-        }
-
-        /// <summary>
-        /// Prints window's web page.
-        /// </summary>
-        /// <param name="options"></param>
-        /// <returns>success</returns>
-        public Task<bool> PrintAsync(PrintOptions options = null)
-        {
-            var taskCompletionSource = new TaskCompletionSource<bool>();
-
-            BridgeConnector.Socket.On("webContents-print-completed", (success) =>
-            {
-                BridgeConnector.Socket.Off("webContents-print-completed");
-                taskCompletionSource.SetResult((bool)success);
-            });
-
-            if(options == null)
-            {
-                BridgeConnector.Socket.Emit("webContents-print", Id, "");
-            }
-            else
-            {
-                BridgeConnector.Socket.Emit("webContents-print", Id, JObject.FromObject(options, _jsonSerializer));
-            }
-
-            return taskCompletionSource.Task;
-        }
-
-        /// <summary>
-        /// Prints window's web page as PDF with Chromium's preview printing custom
-        /// settings.The landscape will be ignored if @page CSS at-rule is used in the web page. 
-        /// By default, an empty options will be regarded as: Use page-break-before: always; 
-        /// CSS style to force to print to a new page.
-        /// </summary>
-        /// <param name="path"></param>
-        /// <param name="options"></param>
-        /// <returns>success</returns>
-        public Task<bool> PrintToPDFAsync(string path, PrintToPDFOptions options = null)
-        {
-            var taskCompletionSource = new TaskCompletionSource<bool>();
-
-            BridgeConnector.Socket.On("webContents-printToPDF-completed", (success) =>
-            {
-                BridgeConnector.Socket.Off("webContents-printToPDF-completed");
-                taskCompletionSource.SetResult((bool)success);
-            });
-
-            if(options == null)
-            {
-                BridgeConnector.Socket.Emit("webContents-printToPDF", Id, "", path);
-            }
-            else
-            {
-                BridgeConnector.Socket.Emit("webContents-printToPDF", Id, JObject.FromObject(options, _jsonSerializer), path);
-            }
-
-            return taskCompletionSource.Task;
-        }
-
-        /// <summary>
-        /// Is used to get the Url of the loaded page.
-        /// It's usefull if a web-server redirects you and you need to know where it redirects. For instance, It's useful in case of Implicit Authorization.
-        /// </summary>
-        /// <returns>URL of the loaded page</returns>
-        public Task<string> GetUrl()
-        {
-            var taskCompletionSource = new TaskCompletionSource<string>();
-
-            var eventString = "webContents-getUrl" + Id;
-            BridgeConnector.Socket.On(eventString, (url) =>
-            {
-                BridgeConnector.Socket.Off(eventString);
-                taskCompletionSource.SetResult((string)url);
-            });
-
-            BridgeConnector.Socket.Emit("webContents-getUrl", Id);
-
-            return taskCompletionSource.Task;
-        }
-
-        /// <summary>
-        /// The async method will resolve when the page has finished loading, 
-        /// and rejects if the page fails to load.
-        /// 
-        /// A noop rejection handler is already attached, which avoids unhandled rejection
-        /// errors.
-        ///
-        /// Loads the `url` in the window. The `url` must contain the protocol prefix, e.g.
-        /// the `http://` or `file://`. If the load should bypass http cache then use the
-        /// `pragma` header to achieve it.
-        /// </summary>
-        /// <param name="url"></param>
-        public Task LoadURLAsync(string url)
-        {
-            return LoadURLAsync(url, new LoadURLOptions());
-        }
-
-        /// <summary>
-        /// The async method will resolve when the page has finished loading, 
-        /// and rejects if the page fails to load.
-        /// 
-        /// A noop rejection handler is already attached, which avoids unhandled rejection
-        /// errors.
-        ///
-        /// Loads the `url` in the window. The `url` must contain the protocol prefix, e.g.
-        /// the `http://` or `file://`. If the load should bypass http cache then use the
-        /// `pragma` header to achieve it.
-        /// </summary>
-        /// <param name="url"></param>
-        /// <param name="options"></param>
-        public Task LoadURLAsync(string url, LoadURLOptions options)
-        {
-            var taskCompletionSource = new TaskCompletionSource<object>();
-
-            BridgeConnector.Socket.On("webContents-loadURL-complete" + Id, () =>
-            {
-                BridgeConnector.Socket.Off("webContents-loadURL-complete" + Id);
-                BridgeConnector.Socket.Off("webContents-loadURL-error" + Id);
-                taskCompletionSource.SetResult(null);
-            });
-
-            BridgeConnector.Socket.On("webContents-loadURL-error" + Id, (error) =>
-            {
-                BridgeConnector.Socket.Off("webContents-loadURL-error" + Id);
-                taskCompletionSource.SetException(new InvalidOperationException(error.ToString()));
-            });
-
-            BridgeConnector.Socket.Emit("webContents-loadURL", Id, url, JObject.FromObject(options, _jsonSerializer));
-
-            return taskCompletionSource.Task;
-        }
-
-        /// <summary>
-        /// Inserts CSS into the web page.
-        /// See: https://www.electronjs.org/docs/api/web-contents#contentsinsertcsscss-options
-        /// Works for both BrowserWindows and BrowserViews.
-        /// </summary>
-        /// <param name="isBrowserWindow">Whether the webContents belong to a BrowserWindow or not (the other option is a BrowserView)</param>
-        /// <param name="path">Absolute path to the CSS file location</param>
-        public void InsertCSS(bool isBrowserWindow, string path)
-        {
-            BridgeConnector.Socket.Emit("webContents-insertCSS", Id, isBrowserWindow, path);
-        }
-
-        private JsonSerializer _jsonSerializer = new JsonSerializer()
-        {
-            ContractResolver = new CamelCasePropertyNamesContractResolver(),
-            NullValueHandling = NullValueHandling.Ignore,
-            DefaultValueHandling = DefaultValueHandling.Ignore
-        };
-    }
-}

ElectronNET.API/WebHostBuilderExtensions.cs

@@ -1,58 +0,0 @@
-using Microsoft.AspNetCore.Hosting;
-using System;
-using System.IO;
-using Microsoft.Extensions.DependencyInjection;
-
-namespace ElectronNET.API
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public static class WebHostBuilderExtensions
-    {
-        /// <summary>
-        /// Use a Electron support for this .NET Core Project.
-        /// </summary>
-        /// <param name="builder">The builder.</param>
-        /// <param name="args">The arguments.</param>
-        /// <returns></returns>
-        public static IWebHostBuilder UseElectron(this IWebHostBuilder builder, string[] args)
-        {
-            foreach (string argument in args)
-            {
-                if (argument.ToUpper().Contains("ELECTRONPORT"))
-                {
-                    BridgeSettings.SocketPort = argument.ToUpper().Replace("/ELECTRONPORT=", "");
-                    Console.WriteLine("Use Electron Port: " + BridgeSettings.SocketPort);
-                }
-                else if (argument.ToUpper().Contains("ELECTRONWEBPORT"))
-                {
-                    BridgeSettings.WebPort = argument.ToUpper().Replace("/ELECTRONWEBPORT=", "");
-                }
-            }
-
-            if (HybridSupport.IsElectronActive)
-            {
-                builder.ConfigureServices(services =>
-                {
-                    services.AddHostedService<LifetimeServiceHost>();
-                });
-
-                // check for the content folder if its exists in base director otherwise no need to include
-                // It was used before because we are publishing the project which copies everything to bin folder and contentroot wwwroot was folder there.
-                // now we have implemented the live reload if app is run using /watch then we need to use the default project path.
-                if (Directory.Exists($"{AppDomain.CurrentDomain.BaseDirectory}\\wwwroot"))
-                {
-                    builder.UseContentRoot(AppDomain.CurrentDomain.BaseDirectory)
-                        .UseUrls("http://localhost:" + BridgeSettings.WebPort);
-                }
-                else
-                {
-                    builder.UseUrls("http://localhost:" + BridgeSettings.WebPort);
-                }
-            }
-
-            return builder;
-        }
-    }
-}

ElectronNET.API/devCleanup.cmd

@@ -1 +0,0 @@
-rd /s /q %userprofile%\.nuget\packages\electronnet.api 2>nul

ElectronNET.API/devCleanup.sh

@@ -1 +0,0 @@
-rm -rf ~/.nuget/packages/electronnet.api

ElectronNET.CLI/Commands/Actions/DeployEmbeddedElectronFiles.cs

@@ -1,45 +0,0 @@
-using System.IO;
-
-namespace ElectronNET.CLI.Commands.Actions
-{
-    public static class DeployEmbeddedElectronFiles
-    {
-        public static void Do(string tempPath)
-        {
-            EmbeddedFileHelper.DeployEmbeddedFile(tempPath, "main.js");
-            EmbeddedFileHelper.DeployEmbeddedFile(tempPath, "package.json");
-            EmbeddedFileHelper.DeployEmbeddedFile(tempPath, "build-helper.js");
-
-            string hostApiFolder = Path.Combine(tempPath, "api");
-            if (Directory.Exists(hostApiFolder) == false)
-            {
-                Directory.CreateDirectory(hostApiFolder);
-            }
-            EmbeddedFileHelper.DeployEmbeddedFile(hostApiFolder, "ipc.js", "api.");
-            EmbeddedFileHelper.DeployEmbeddedFile(hostApiFolder, "app.js", "api.");
-            EmbeddedFileHelper.DeployEmbeddedFile(hostApiFolder, "browserWindows.js", "api.");
-            EmbeddedFileHelper.DeployEmbeddedFile(hostApiFolder, "commandLine.js", "api.");
-            EmbeddedFileHelper.DeployEmbeddedFile(hostApiFolder, "dialog.js", "api.");
-            EmbeddedFileHelper.DeployEmbeddedFile(hostApiFolder, "dock.js", "api.");
-            EmbeddedFileHelper.DeployEmbeddedFile(hostApiFolder, "menu.js", "api.");
-            EmbeddedFileHelper.DeployEmbeddedFile(hostApiFolder, "notification.js", "api.");
-            EmbeddedFileHelper.DeployEmbeddedFile(hostApiFolder, "tray.js", "api.");
-            EmbeddedFileHelper.DeployEmbeddedFile(hostApiFolder, "webContents.js", "api.");
-            EmbeddedFileHelper.DeployEmbeddedFile(hostApiFolder, "globalShortcut.js", "api.");
-            EmbeddedFileHelper.DeployEmbeddedFile(hostApiFolder, "shell.js", "api.");
-            EmbeddedFileHelper.DeployEmbeddedFile(hostApiFolder, "screen.js", "api.");
-            EmbeddedFileHelper.DeployEmbeddedFile(hostApiFolder, "clipboard.js", "api.");
-            EmbeddedFileHelper.DeployEmbeddedFile(hostApiFolder, "autoUpdater.js", "api.");
-            EmbeddedFileHelper.DeployEmbeddedFile(hostApiFolder, "browserView.js", "api.");
-            EmbeddedFileHelper.DeployEmbeddedFile(hostApiFolder, "powerMonitor.js", "api.");
-            EmbeddedFileHelper.DeployEmbeddedFile(hostApiFolder, "nativeTheme.js", "api.");
-
-            string splashscreenFolder = Path.Combine(tempPath, "splashscreen");
-            if (Directory.Exists(splashscreenFolder) == false)
-            {
-                Directory.CreateDirectory(splashscreenFolder);
-            }
-            EmbeddedFileHelper.DeployEmbeddedFile(splashscreenFolder, "index.html", "splashscreen.");
-        }
-    }
-}

ElectronNET.CLI/Commands/Actions/DirectoryCopy.cs

@@ -1,67 +0,0 @@
-using System.Collections.Generic;
-using System.IO;
-
-namespace ElectronNET.CLI.Commands.Actions
-{
-    public static class DirectoryCopy
-    {
-        public static void Do(string sourceDirName, string destDirName, bool copySubDirs, List<string> ignoredSubDirs)
-        {
-            // Get the subdirectories for the specified directory.
-            DirectoryInfo dir = new DirectoryInfo(sourceDirName);
-
-            if (!dir.Exists)
-            {
-                throw new DirectoryNotFoundException(
-                    "Source directory does not exist or could not be found: "
-                    + sourceDirName);
-            }
-
-            DirectoryInfo[] dirs = dir.GetDirectories();
-            // If the destination directory doesn't exist, create it.
-            if (!Directory.Exists(destDirName))
-            {
-                Directory.CreateDirectory(destDirName);
-            }
-            else
-            {
-                DirectoryInfo targetDir = new DirectoryInfo(destDirName);
-                
-                foreach (FileInfo fileDel in targetDir.EnumerateFiles())
-                {
-                    fileDel.Delete();
-                }
-                foreach (DirectoryInfo dirDel in targetDir.EnumerateDirectories())
-                {
-                    dirDel.Delete(true);
-                }
-            }
-
-
-
-
-            // Get the files in the directory and copy them to the new location.
-            FileInfo[] files = dir.GetFiles();
-            foreach (FileInfo file in files)
-            {
-                string temppath = Path.Combine(destDirName, file.Name);
-                file.CopyTo(temppath, false);
-            }
-
-            // If copying subdirectories, copy them and their contents to new location.
-            if (copySubDirs)
-            {
-                foreach (DirectoryInfo subdir in dirs)
-                {
-                    if (ignoredSubDirs.Contains(subdir.Name))
-                    {
-                        continue;
-                    }
-
-                    string temppath = Path.Combine(destDirName, subdir.Name);
-                    Do(subdir.FullName, temppath, copySubDirs, ignoredSubDirs);
-                }
-            }
-        }
-    }
-}

ElectronNET.CLI/Commands/Actions/GetTargetPlatformInformation.cs

@@ -1,70 +0,0 @@
-using System;
-using System.Runtime.InteropServices;
-
-namespace ElectronNET.CLI.Commands.Actions
-{
-    public static class GetTargetPlatformInformation
-    {
-        public struct GetTargetPlatformInformationResult
-        {
-            public string NetCorePublishRid { get; set; }
-            public string ElectronPackerPlatform { get; set; }
-
-        }
-
-        public static GetTargetPlatformInformationResult Do(string desiredPlatform, string specifiedPlatfromFromCustom)
-        {
-            string netCorePublishRid = string.Empty;
-            string electronPackerPlatform = string.Empty;
-
-            switch (desiredPlatform)
-            {
-                case "win":
-                    netCorePublishRid = "win-x64";
-                    electronPackerPlatform = "win";
-                    break;
-                case "osx":
-                    netCorePublishRid = "osx-x64";
-                    electronPackerPlatform = "mac";
-                    break;
-                case "linux":
-                    netCorePublishRid = "linux-x64";
-                    electronPackerPlatform = "linux";
-                    break;
-                case "linux-arm":
-                    netCorePublishRid = "linux-arm";
-                    electronPackerPlatform = "linux";
-                    break;
-                case "custom":
-                    var splittedSpecified = specifiedPlatfromFromCustom.Split(';');
-                    netCorePublishRid = splittedSpecified[0];
-                    electronPackerPlatform = splittedSpecified[1];
-                    break;
-                default:
-                    if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-                    {
-                        netCorePublishRid = $"win-x{(Environment.Is64BitOperatingSystem ? "64" : "86")}";
-                        electronPackerPlatform = "win";
-                    }
-                    if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
-                    {
-                        netCorePublishRid = "osx-x64";
-                        electronPackerPlatform = "mac";
-                    }
-                    if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
-                    {
-                        netCorePublishRid = "linux-x64";
-                        electronPackerPlatform = "linux";
-                    }
-
-                    break;
-            }
-
-            return new GetTargetPlatformInformationResult()
-            {
-                ElectronPackerPlatform = electronPackerPlatform,
-                NetCorePublishRid = netCorePublishRid
-            };
-        }
-    }
-}

ElectronNET.CLI/Commands/AddCommand.cs

@@ -1,139 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading.Tasks;
-using System.Xml;
-using System.Xml.Linq;
-
-namespace ElectronNET.CLI.Commands
-{
-    public class AddCommand : ICommand
-    {
-        public const string COMMAND_NAME = "add";
-        public const string COMMAND_DESCRIPTION = "The add command needs to be invoked via 'add hosthook'. This creates a special folder for your custom npm package installation.";
-        public const string COMMAND_ARGUMENTS = "hosthook";
-        public static IList<CommandOption> CommandOptions { get; set; } = new List<CommandOption>();
-
-
-        private string[] _args;
-
-        public AddCommand(string[] args)
-        {
-            _args = args;
-        }
-
-        private static string ElectronHostHookFolderName = "ElectronHostHook";
-
-        public Task<bool> ExecuteAsync()
-        {
-            return Task.Run(() =>
-            {
-                if(_args.Length == 0)
-                {
-                    Console.WriteLine("Specify 'hosthook' to add custom npm packages.");
-                    return false;
-                }
-
-                if(_args[0].ToLowerInvariant() != "hosthook")
-                {
-                    Console.WriteLine("Specify 'hosthook' to add custom npm packages.");
-                    return false;
-                }
-
-                string aspCoreProjectPath = "";
-
-                // Maybe ToDo: Adding the possiblity to specify a path (like we did in the InitCommand, but this would require a better command args parser)
-                aspCoreProjectPath = Directory.GetCurrentDirectory();
-
-                var currentDirectory = aspCoreProjectPath;
-
-                var targetFilePath = Path.Combine(currentDirectory, ElectronHostHookFolderName);
-
-                if(Directory.Exists(targetFilePath))
-                {
-                    Console.WriteLine("ElectronHostHook directory already in place. If you want to start over, delete the folder and invoke this command again.");
-                    return false;
-                }
-
-                Console.WriteLine("Adding the ElectronHostHook folder to your project...");
-
-                Directory.CreateDirectory(targetFilePath);
-
-                // Deploy related files
-                EmbeddedFileHelper.DeployEmbeddedFile(targetFilePath, "index.ts", "ElectronHostHook.");
-                EmbeddedFileHelper.DeployEmbeddedFile(targetFilePath, "connector.ts", "ElectronHostHook.");
-                EmbeddedFileHelper.DeployEmbeddedFile(targetFilePath, "package.json", "ElectronHostHook.");
-                EmbeddedFileHelper.DeployEmbeddedFile(targetFilePath, "tsconfig.json", "ElectronHostHook.");
-                EmbeddedFileHelper.DeployEmbeddedFile(targetFilePath, ".gitignore", "ElectronHostHook.");
-
-                // npm for typescript compiler etc.
-                Console.WriteLine("Start npm install...");
-                ProcessHelper.CmdExecute("npm install", targetFilePath);
-
-                // run typescript compiler
-                // ToDo: Not sure if this runs under linux/macos
-                ProcessHelper.CmdExecute(@"npx tsc -p ../../", targetFilePath);
-
-                // search .csproj or .fsproj (.csproj has higher precedence)
-                Console.WriteLine($"Search your .csproj/.fsproj to add configure CopyToPublishDirectory to 'Never'");
-                var projectFile = Directory.EnumerateFiles(currentDirectory, "*.csproj", SearchOption.TopDirectoryOnly)
-                    .Union(Directory.EnumerateFiles(currentDirectory, "*.fsproj", SearchOption.TopDirectoryOnly))
-                    .FirstOrDefault();
-
-                var extension = Path.GetExtension(projectFile);
-                Console.WriteLine($"Found your {extension}: {projectFile} - check for existing CopyToPublishDirectory setting or update it.");
-
-                if (!EditProjectFile(projectFile)) return false;
-
-                Console.WriteLine($"Everything done - happy electronizing with your custom npm packages!");
-
-                return true;
-            });
-        }
-
-        // ToDo: Cleanup this copy/past code.
-        private static bool EditProjectFile(string projectFile)
-        {
-            using (var stream = File.Open(projectFile, FileMode.OpenOrCreate, FileAccess.ReadWrite))
-            {
-                var xmlDocument = XDocument.Load(stream);
-
-                var projectElement = xmlDocument.Descendants("Project").FirstOrDefault();
-                if (projectElement == null || projectElement.Attribute("Sdk")?.Value != "Microsoft.NET.Sdk.Web")
-                {
-                    Console.WriteLine(
-                        $"Project file is not a compatible type of 'Microsoft.NET.Sdk.Web'. Your project: {projectElement?.Attribute("Sdk")?.Value}");
-                    return false;
-                }
-
-                string itemGroupXmlString = "<ItemGroup>" +
-                                                "<Content Update=\"ElectronHostHook\\**\\*.*\">" +
-                                                    "<CopyToPublishDirectory>Never</CopyToPublishDirectory>" +
-                                                "</Content>" +
-                                            "</ItemGroup>";
-
-                var newItemGroupForConfig = XElement.Parse(itemGroupXmlString);
-                xmlDocument.Root.Add(newItemGroupForConfig);
-
-                stream.SetLength(0);
-                stream.Position = 0;
-
-                var xws = new XmlWriterSettings
-                {
-                    OmitXmlDeclaration = true,
-                    Indent = true
-                };
-                using (XmlWriter xw = XmlWriter.Create(stream, xws))
-                {
-                    xmlDocument.Save(xw);
-                }
-
-            }
-
-            Console.WriteLine($"Publish setting added in csproj/fsproj!");
-            return true;
-        }
-
-    }
-}

ElectronNET.CLI/Commands/BuildCommand.cs

@@ -1,255 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading.Tasks;
-using ElectronNET.CLI.Commands.Actions;
-
-namespace ElectronNET.CLI.Commands
-{
-    public class BuildCommand : ICommand
-    {
-        public const string COMMAND_NAME = "build";
-        public const string COMMAND_DESCRIPTION = "Build your Electron Application.";
-        public static string COMMAND_ARGUMENTS = "Needed: '/target' with params 'win/osx/linux' to build for a typical app or use 'custom' and specify .NET Core build config & electron build config" + Environment.NewLine +
-                                                 " for custom target, check .NET Core RID Catalog and Electron build target/" + Environment.NewLine +
-                                                 " e.g. '/target win' or '/target custom \"win7-x86;win\"'" + Environment.NewLine +
-                                                 "Optional: '/dotnet-configuration' with the desired .NET Core build config e.g. release or debug. Default = Release" + Environment.NewLine +
-                                                 "Optional: '/electron-arch' to specify the resulting electron processor architecture (e.g. ia86 for x86 builds). Be aware to use the '/target custom' param as well!" + Environment.NewLine +
-                                                 "Optional: '/electron-params' specify any other valid parameter, which will be routed to the electron-packager." + Environment.NewLine +
-                                                 "Optional: '/relative-path' to specify output a subdirectory for output." + Environment.NewLine +
-                                                 "Optional: '/absolute-path to specify and absolute path for output." + Environment.NewLine +
-                                                 "Optional: '/package-json' to specify a custom package.json file." + Environment.NewLine +
-                                                 "Optional: '/install-modules' to force node module install. Implied by '/package-json'" + Environment.NewLine +
-                                                 "Optional: '/Version' to specify the version that should be applied to both the `dotnet publish` and `electron-builder` commands. Implied by '/Version'" + Environment.NewLine +
-                                                 "Optional: '/p:[property]' or '/property:[property]' to pass in dotnet publish properties.  Example: '/property:Version=1.0.0' to override the FileVersion" + Environment.NewLine +
-                                                 "Full example for a 32bit debug build with electron prune: build /target custom win7-x86;win32 /dotnet-configuration Debug /electron-arch ia32  /electron-params \"--prune=true \"";
-
-        public static IList<CommandOption> CommandOptions { get; set; } = new List<CommandOption>();
-
-        private string[] _args;
-
-        public BuildCommand(string[] args)
-        {
-            _args = args;
-        }
-
-        private string _paramTarget = "target";
-        private string _paramDotNetConfig = "dotnet-configuration";
-        private string _paramElectronArch = "electron-arch";
-        private string _paramElectronParams = "electron-params";
-        private string _paramOutputDirectory = "relative-path";
-        private string _paramAbsoluteOutput = "absolute-path";
-        private string _paramPackageJson = "package-json";
-        private string _paramForceNodeInstall = "install-modules";
-        private string _manifest = "manifest";
-        private string _paramPublishReadyToRun = "PublishReadyToRun";
-        private string _paramPublishSingleFile = "PublishSingleFile";
-        private string _paramVersion = "Version";
-
-        public Task<bool> ExecuteAsync()
-        {
-            return Task.Run(() =>
-            {
-                Console.WriteLine("Build Electron Application...");
-
-                SimpleCommandLineParser parser = new SimpleCommandLineParser();
-                parser.Parse(_args);
-
-                //This version will be shared between the dotnet publish and electron-builder commands
-                string version = null;
-                if (parser.Arguments.ContainsKey(_paramVersion))
-                    version = parser.Arguments[_paramVersion][0];
-
-                if (!parser.Arguments.ContainsKey(_paramTarget))
-                {
-                    Console.WriteLine($"Error: missing '{_paramTarget}' argument.");
-                    Console.WriteLine(COMMAND_ARGUMENTS);
-                    return false;
-                }
-
-                var desiredPlatform = parser.Arguments[_paramTarget][0];
-                string specifiedFromCustom = string.Empty;
-                if (desiredPlatform == "custom" && parser.Arguments[_paramTarget].Length > 1)
-                {
-                    specifiedFromCustom = parser.Arguments[_paramTarget][1];
-                }
-
-                string configuration = "Release";
-                if (parser.Arguments.ContainsKey(_paramDotNetConfig))
-                {
-                    configuration = parser.Arguments[_paramDotNetConfig][0];
-                }
-
-                var platformInfo = GetTargetPlatformInformation.Do(desiredPlatform, specifiedFromCustom);
-
-                Console.WriteLine($"Build ASP.NET Core App for {platformInfo.NetCorePublishRid}...");
-
-                string tempPath = Path.Combine(Directory.GetCurrentDirectory(), "obj", "desktop", desiredPlatform);
-
-                if (Directory.Exists(tempPath) == false)
-                {
-                    Directory.CreateDirectory(tempPath);
-                }
-                else
-                {
-                    Directory.Delete(tempPath, true);
-                    Directory.CreateDirectory(tempPath);
-                }
-
-
-                Console.WriteLine("Executing dotnet publish in this directory: " + tempPath);
-
-                string tempBinPath = Path.Combine(tempPath, "bin");
-
-                Console.WriteLine($"Build ASP.NET Core App for {platformInfo.NetCorePublishRid} under {configuration}-Configuration...");
-                
-                var dotNetPublishFlags = GetDotNetPublishFlags(parser);
-
-                var command =
-                    $"dotnet publish -r {platformInfo.NetCorePublishRid} -c \"{configuration}\" --output \"{tempBinPath}\" {string.Join(' ', dotNetPublishFlags.Select(kvp => $"{kvp.Key}={kvp.Value}"))} --self-contained";
-                
-                // output the command 
-                Console.ForegroundColor = ConsoleColor.Green;
-                Console.WriteLine(command);
-                Console.ResetColor();
-
-                var resultCode = ProcessHelper.CmdExecute(command, Directory.GetCurrentDirectory());
-
-                if (resultCode != 0)
-                {
-                    Console.WriteLine("Error occurred during dotnet publish: " + resultCode);
-                    return false;
-                }
-
-                DeployEmbeddedElectronFiles.Do(tempPath);
-                var nodeModulesDirPath = Path.Combine(tempPath, "node_modules");
-
-                if (parser.Arguments.ContainsKey(_paramPackageJson))
-                {
-                    Console.WriteLine("Copying custom package.json.");
-
-                    File.Copy(parser.Arguments[_paramPackageJson][0], Path.Combine(tempPath, "package.json"), true);
-                }
-
-                var checkForNodeModulesDirPath = Path.Combine(tempPath, "node_modules");
-
-                if (Directory.Exists(checkForNodeModulesDirPath) == false || parser.Contains(_paramForceNodeInstall) || parser.Contains(_paramPackageJson))
-
-                    Console.WriteLine("Start npm install...");
-                ProcessHelper.CmdExecute("npm install --production", tempPath);
-
-                Console.WriteLine("ElectronHostHook handling started...");
-
-                string electronhosthookDir = Path.Combine(Directory.GetCurrentDirectory(), "ElectronHostHook");
-
-                if (Directory.Exists(electronhosthookDir))
-                {
-                    string hosthookDir = Path.Combine(tempPath, "ElectronHostHook");
-                    DirectoryCopy.Do(electronhosthookDir, hosthookDir, true, new List<string>() { "node_modules" });
-
-                    Console.WriteLine("Start npm install for hosthooks...");
-                    ProcessHelper.CmdExecute("npm install", hosthookDir);
-
-                    // ToDo: Not sure if this runs under linux/macos
-                    ProcessHelper.CmdExecute(@"npx tsc -p . --sourceMap false", hosthookDir);
-                }
-
-                Console.WriteLine("Build Electron Desktop Application...");
-
-                // Specifying an absolute path supercedes a relative path
-                string buildPath = Path.Combine(Directory.GetCurrentDirectory(), "bin", "desktop");
-                if (parser.Arguments.ContainsKey(_paramAbsoluteOutput))
-                {
-                    buildPath = parser.Arguments[_paramAbsoluteOutput][0];
-                }
-                else if (parser.Arguments.ContainsKey(_paramOutputDirectory))
-                {
-                    buildPath = Path.Combine(Directory.GetCurrentDirectory(), parser.Arguments[_paramOutputDirectory][0]);
-                }
-
-                Console.WriteLine("Executing electron magic in this directory: " + buildPath);
-
-                string electronArch = "x64";
-                if (parser.Arguments.ContainsKey(_paramElectronArch))
-                {
-                    electronArch = parser.Arguments[_paramElectronArch][0];
-                }
-
-                string electronParams = "";
-                if (parser.Arguments.ContainsKey(_paramElectronParams))
-                {
-                    electronParams = parser.Arguments[_paramElectronParams][0];
-                }
-
-                // ToDo: Make the same thing easer with native c# - we can save a tmp file in production code :)
-                Console.WriteLine("Create electron-builder configuration file...");
-
-                string manifestFileName = "electron.manifest.json";
-
-                if (parser.Arguments.ContainsKey(_manifest))
-                {
-                    manifestFileName = parser.Arguments[_manifest].First();
-                }
-
-                ProcessHelper.CmdExecute(
-                    string.IsNullOrWhiteSpace(version)
-                        ? $"node build-helper.js {manifestFileName}"
-                        : $"node build-helper.js {manifestFileName} {version}", tempPath);
-
-                Console.WriteLine($"Package Electron App for Platform {platformInfo.ElectronPackerPlatform}...");
-                ProcessHelper.CmdExecute($"npx electron-builder --config=./bin/electron-builder.json --{platformInfo.ElectronPackerPlatform} --{electronArch} -c.electronVersion=13.1.5 {electronParams}", tempPath);
-
-                Console.WriteLine("... done");
-
-                return true;
-            });
-        }
-
-        private Dictionary<string, string> GetDotNetPublishFlags(SimpleCommandLineParser parser)
-        {
-            var dotNetPublishFlags = new Dictionary<string, string>
-            {
-                {"/p:PublishReadyToRun", parser.TryGet(_paramPublishReadyToRun, out var rtr) ? rtr[0] : "true"},
-                {"/p:PublishSingleFile", parser.TryGet(_paramPublishSingleFile, out var psf) ? psf[0] : "true"},
-            };
-
-            if (parser.Arguments.ContainsKey(_paramVersion))
-            {
-                if(parser.Arguments.Keys.All(key => !key.StartsWith("p:Version=") && !key.StartsWith("property:Version=")))
-                    dotNetPublishFlags.Add("/p:Version", parser.Arguments[_paramVersion][0]);
-                if(parser.Arguments.Keys.All(key => !key.StartsWith("p:ProductVersion=") && !key.StartsWith("property:ProductVersion=")))
-                    dotNetPublishFlags.Add("/p:ProductVersion", parser.Arguments[_paramVersion][0]);
-            }
-
-            foreach (var parm in parser.Arguments.Keys.Where(key => key.StartsWith("p:") || key.StartsWith("property:")))
-            {
-                var split = parm.IndexOf('=');
-                if (split < 0)
-                {
-                    continue;
-                }
-
-                var key = $"/{parm.Substring(0, split)}";
-                // normalize the key
-                if (key.StartsWith("/property:"))
-                {
-                    key = key.Replace("/property:", "/p:");
-                }
-
-                var value = parm.Substring(split + 1);
-
-                if (dotNetPublishFlags.ContainsKey(key))
-                {
-                    dotNetPublishFlags[key] = value;
-                }
-                else
-                {
-                    dotNetPublishFlags.Add(key, value);
-                }
-            }
-
-            return dotNetPublishFlags;
-        }
-    }
-}

ElectronNET.CLI/Commands/CommandOption.cs

@@ -1,53 +0,0 @@
-namespace ElectronNET.CLI.Commands
-{
-    /// <summary>
-    /// The definitionn of an option for a command.
-    /// </summary>
-    public class CommandOption
-    {
-        /// <summary>
-        /// An enum for the possible values for an option
-        /// </summary>
-        public enum CommandOptionValueType { NoValue, StringValue, BoolValue, IntValue, CommaDelimitedList, KeyValuePairs }
-
-        /// <summary>
-        /// The name of the option.
-        /// </summary>
-        public string Name { get; set; }
-
-        /// <summary>
-        /// The short form of the command line switch. This will start with just one dash e.g. -f for framework
-        /// </summary>
-        public string ShortSwitch { get; set; }
-
-        /// <summary>
-        /// The full form of the command line switch. This will start with two dashes e.g. --framework
-        /// </summary>
-        public string Switch { get; set; }
-
-        /// <summary>
-        /// The description of the option
-        /// </summary>
-        public string Description { get; set; }
-
-        /// <summary>
-        /// The type of value that is expected with this command option
-        /// </summary>
-        public CommandOptionValueType ValueType { get; set; }
-
-        /// <summary>
-        /// The JSON key used in configuration file.`
-        /// </summary>
-        public string ConfigFileKey
-        {
-            get
-            {
-                var key = this.Switch;
-                if (key.StartsWith("--"))
-                    key = key.Substring(2);
-
-                return key;
-            }
-        }
-    }
-}

ElectronNET.CLI/Commands/ICommand.cs

@@ -1,12 +0,0 @@
-using System.Threading.Tasks;
-
-namespace ElectronNET.CLI.Commands
-{
-    /// <summary>
-    /// Interface for commands to implement.
-    /// </summary>
-    public interface ICommand
-    {
-        Task<bool> ExecuteAsync();
-    }
-}

ElectronNET.CLI/Commands/InitCommand.cs

@@ -1,214 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using System.Xml;
-using System.Xml.Linq;
-
-namespace ElectronNET.CLI.Commands
-{
-    public class InitCommand : ICommand
-    {
-        public const string COMMAND_NAME = "init";
-        public const string COMMAND_DESCRIPTION = "Creates the needed Electron.NET config for your Electron Application.";
-        public const string COMMAND_ARGUMENTS = "<Path> from ASP.NET Core Project.";
-        public static IList<CommandOption> CommandOptions { get; set; } = new List<CommandOption>();
-
-        private static SimpleCommandLineParser _parser = new SimpleCommandLineParser();
-        private static string ConfigName = "electron.manifest.json";
-        private const string DefaultConfigFileName = "electron.manifest.json";
-
-        public InitCommand(string[] args)
-        {
-            _parser.Parse(args);
-        }
-
-        private static string _aspCoreProjectPath = "project-path";
-        private static string _manifest = "manifest";
-
-        public Task<bool> ExecuteAsync()
-        {
-            return Task.Run(() =>
-            {
-                string aspCoreProjectPath = "";
-
-                if (_parser.Arguments.ContainsKey(_aspCoreProjectPath))
-                {
-                    string projectPath = _parser.Arguments[_aspCoreProjectPath].First();
-                    if (Directory.Exists(projectPath))
-                    {
-                        aspCoreProjectPath = projectPath;
-                    }
-                }
-                else
-                {
-                    aspCoreProjectPath = Directory.GetCurrentDirectory();
-                }
-
-                var currentDirectory = aspCoreProjectPath;
-
-                if(_parser.Arguments.ContainsKey(_manifest))
-                {
-                    ConfigName = "electron.manifest." + _parser.Arguments[_manifest].First() + ".json";
-                    Console.WriteLine($"Adding your custom {ConfigName} config file to your project...");
-                }
-                else
-                {
-                    Console.WriteLine("Adding our config file to your project...");
-                }
-
-                var targetFilePath = Path.Combine(currentDirectory, ConfigName);
-
-                if (File.Exists(targetFilePath))
-                {
-                    Console.WriteLine("Config file already in your project.");
-                    return false;
-                }
-
-                // Deploy config file
-                EmbeddedFileHelper.DeployEmbeddedFileToTargetFile(currentDirectory, DefaultConfigFileName, ConfigName);
-
-                // search .csproj/.fsproj (.csproj has higher precedence)
-                Console.WriteLine($"Search your .csproj/fsproj to add the needed {ConfigName}...");
-                var projectFile = Directory.EnumerateFiles(currentDirectory, "*.csproj", SearchOption.TopDirectoryOnly)
-                    .Union(Directory.EnumerateFiles(currentDirectory, "*.fsproj", SearchOption.TopDirectoryOnly))
-                    .FirstOrDefault();
-
-                // update config file with the name of the csproj/fsproj
-                // ToDo: If the csproj/fsproj name != application name, this will fail
-                string text = File.ReadAllText(targetFilePath);
-                text = text.Replace("{{executable}}", Path.GetFileNameWithoutExtension(projectFile));
-                File.WriteAllText(targetFilePath, text);
-
-                var extension = Path.GetExtension(projectFile);
-                Console.WriteLine($"Found your {extension}: {projectFile} - check for existing config or update it.");
-
-                if (!EditProjectFile(projectFile)) return false;
-
-                // search launchSettings.json
-                Console.WriteLine($"Search your .launchSettings to add our electron debug profile...");
-
-                EditLaunchSettings(currentDirectory);
-
-                Console.WriteLine($"Everything done - happy electronizing!");
-
-                return true;
-            });
-        }
-
-        private static void EditLaunchSettings(string currentDirectory)
-        {
-            // super stupid implementation, but because there is no nativ way to parse json
-            // and cli extensions and other nuget packages are buggy 
-            // this is should solve the problem for 80% of the users
-            // for the other 20% we might fail... 
-            var launchSettingFile = Path.Combine(currentDirectory, "Properties", "launchSettings.json");
-
-            if (File.Exists(launchSettingFile) == false)
-            {
-                Console.WriteLine("launchSettings.json not found - do nothing.");
-                return;
-            }
-
-            string launchSettingText = File.ReadAllText(launchSettingFile);
-
-            if(_parser.Arguments.ContainsKey(_manifest))
-            {
-                string manifestName = _parser.Arguments[_manifest].First();
-
-                if(launchSettingText.Contains("start /manifest " + ConfigName) == false)
-                {
-                    StringBuilder debugProfileBuilder = new StringBuilder();
-                    debugProfileBuilder.AppendLine("profiles\": {");
-                    debugProfileBuilder.AppendLine("    \"Electron.NET App - " + manifestName + "\": {");
-                    debugProfileBuilder.AppendLine("      \"commandName\": \"Executable\",");
-                    debugProfileBuilder.AppendLine("      \"executablePath\": \"electronize\",");
-                    debugProfileBuilder.AppendLine("      \"commandLineArgs\": \"start /manifest " + ConfigName + "\",");
-                    debugProfileBuilder.AppendLine("      \"workingDirectory\": \".\"");
-                    debugProfileBuilder.AppendLine("    },");
-
-                    launchSettingText = launchSettingText.Replace("profiles\": {", debugProfileBuilder.ToString());
-                    File.WriteAllText(launchSettingFile, launchSettingText);
-
-                    Console.WriteLine($"Debug profile added!");
-                }
-                else
-                {
-                    Console.WriteLine($"Debug profile already existing");
-                }
-            } 
-            else if (launchSettingText.Contains("\"executablePath\": \"electronize\"") == false)
-            {
-                StringBuilder debugProfileBuilder = new StringBuilder();
-                debugProfileBuilder.AppendLine("profiles\": {");
-                debugProfileBuilder.AppendLine("    \"Electron.NET App\": {");
-                debugProfileBuilder.AppendLine("      \"commandName\": \"Executable\",");
-                debugProfileBuilder.AppendLine("      \"executablePath\": \"electronize\",");
-                debugProfileBuilder.AppendLine("      \"commandLineArgs\": \"start\",");
-                debugProfileBuilder.AppendLine("      \"workingDirectory\": \".\"");
-                debugProfileBuilder.AppendLine("    },");
-
-                launchSettingText = launchSettingText.Replace("profiles\": {", debugProfileBuilder.ToString());
-                File.WriteAllText(launchSettingFile, launchSettingText);
-
-                Console.WriteLine($"Debug profile added!");
-            }
-            else
-            {
-                Console.WriteLine($"Debug profile already existing");
-            }
-        }
-
-        private static bool EditProjectFile(string projectFile)
-        {
-            using (var stream = File.Open(projectFile, FileMode.OpenOrCreate, FileAccess.ReadWrite))
-            {
-                var xmlDocument = XDocument.Load(stream);
-
-                var projectElement = xmlDocument.Descendants("Project").FirstOrDefault();
-                if (projectElement == null || projectElement.Attribute("Sdk")?.Value != "Microsoft.NET.Sdk.Web")
-                {
-                    Console.WriteLine(
-                        $"Project file is not a compatible type of 'Microsoft.NET.Sdk.Web'. Your project: {projectElement?.Attribute("Sdk")?.Value}");
-                    return false;
-                }
-
-                if (xmlDocument.ToString().Contains($"Content Update=\"{ConfigName}\""))
-                {
-                    Console.WriteLine($"{ConfigName} already in csproj/fsproj.");
-                    return false;
-                }
-
-                Console.WriteLine($"{ConfigName} will be added to csproj/fsproj.");
-
-                string itemGroupXmlString = "<ItemGroup>" +
-                                            "<Content Update=\"" + ConfigName + "\">" +
-                                            "<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>" +
-                                            "</Content>" +
-                                            "</ItemGroup>";
-
-                var newItemGroupForConfig = XElement.Parse(itemGroupXmlString);
-                xmlDocument.Root.Add(newItemGroupForConfig);
-
-                stream.SetLength(0);
-                stream.Position = 0;
-
-                var xws = new XmlWriterSettings
-                {
-                    OmitXmlDeclaration = true,
-                    Indent = true
-                };
-                using (XmlWriter xw = XmlWriter.Create(stream, xws))
-                {
-                    xmlDocument.Save(xw);
-                }
-
-            }
-
-            Console.WriteLine($"{ConfigName} added in csproj/fsproj!");
-            return true;
-        }
-    }
-}

ElectronNET.CLI/Commands/StartElectronCommand.cs

@@ -1,185 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Runtime.InteropServices;
-using System.Threading.Tasks;
-using ElectronNET.CLI.Commands.Actions;
-
-namespace ElectronNET.CLI.Commands
-{
-    public class StartElectronCommand : ICommand
-    {
-        public const string COMMAND_NAME = "start";
-        public const string COMMAND_DESCRIPTION = "Start your ASP.NET Core Application with Electron, without package it as a single exe. Faster for development.";
-        public const string COMMAND_ARGUMENTS = "<Path> from ASP.NET Core Project.";
-        public static IList<CommandOption> CommandOptions { get; set; } = new List<CommandOption>();
-
-        private string[] _args;
-
-        public StartElectronCommand(string[] args)
-        {
-            _args = args;
-        }
-
-        private string _aspCoreProjectPath = "project-path";
-        private string _arguments = "args";
-        private string _manifest = "manifest";
-        private string _clearCache = "clear-cache";
-        private string _paramPublishReadyToRun = "PublishReadyToRun";
-        private string _paramPublishSingleFile = "PublishSingleFile";
-        private string _paramDotNetConfig = "dotnet-configuration";
-        private string _paramTarget = "target";
-
-        public Task<bool> ExecuteAsync()
-        {
-            return Task.Run(() =>
-            {
-                Console.WriteLine("Start Electron Desktop Application...");
-
-                SimpleCommandLineParser parser = new SimpleCommandLineParser();
-                parser.Parse(_args);
-
-                string aspCoreProjectPath = "";
-
-                if (parser.Arguments.ContainsKey(_aspCoreProjectPath))
-                {
-                    string projectPath = parser.Arguments[_aspCoreProjectPath].First();
-                    if (Directory.Exists(projectPath))
-                    {
-                        aspCoreProjectPath = projectPath;
-                    }
-                }
-                else
-                {
-                    aspCoreProjectPath = Directory.GetCurrentDirectory();
-                }
-
-                string tempPath = Path.Combine(aspCoreProjectPath, "obj", "Host");
-                if (Directory.Exists(tempPath) == false)
-                {
-                    Directory.CreateDirectory(tempPath);
-                }
-
-                string tempBinPath = Path.Combine(tempPath, "bin");
-                var resultCode = 0;
-
-                string publishReadyToRun = "/p:PublishReadyToRun=";
-                if (parser.Arguments.ContainsKey(_paramPublishReadyToRun))
-                {
-                    publishReadyToRun += parser.Arguments[_paramPublishReadyToRun][0];
-                }
-                else
-                {
-                    publishReadyToRun += "true";
-                }
-
-                string publishSingleFile = "/p:PublishSingleFile=";
-                if (parser.Arguments.ContainsKey(_paramPublishSingleFile))
-                {
-                    publishSingleFile += parser.Arguments[_paramPublishSingleFile][0];
-                }
-                else
-                {
-                    publishSingleFile += "true";
-                }
-
-                // If target is specified as a command line argument, use it.
-                // Format is the same as the build command.
-                // If target is not specified, autodetect it.
-                var platformInfo = GetTargetPlatformInformation.Do(string.Empty, string.Empty);
-                if (parser.Arguments.ContainsKey(_paramTarget))
-                {
-                    var desiredPlatform = parser.Arguments[_paramTarget][0];
-                    string specifiedFromCustom = string.Empty;
-                    if (desiredPlatform == "custom" && parser.Arguments[_paramTarget].Length > 1)
-                    {
-                        specifiedFromCustom = parser.Arguments[_paramTarget][1];
-                    }
-                    platformInfo = GetTargetPlatformInformation.Do(desiredPlatform, specifiedFromCustom);
-                }
-
-                string configuration = "Debug";
-                if (parser.Arguments.ContainsKey(_paramDotNetConfig))
-                {
-                    configuration = parser.Arguments[_paramDotNetConfig][0];
-                }
-
-                if (parser != null && !parser.Arguments.ContainsKey("watch"))
-                {
-                    resultCode = ProcessHelper.CmdExecute($"dotnet publish -r {platformInfo.NetCorePublishRid} -c \"{configuration}\" --output \"{tempBinPath}\" {publishReadyToRun} {publishSingleFile} --no-self-contained", aspCoreProjectPath);
-                }
-
-                if (resultCode != 0)
-                {
-                    Console.WriteLine("Error occurred during dotnet publish: " + resultCode);
-                    return false;
-                }
-
-                DeployEmbeddedElectronFiles.Do(tempPath);
-
-                var nodeModulesDirPath = Path.Combine(tempPath, "node_modules");
-
-                Console.WriteLine("node_modules missing in: " + nodeModulesDirPath);
-
-                Console.WriteLine("Start npm install...");
-                ProcessHelper.CmdExecute("npm install", tempPath);
-
-                Console.WriteLine("ElectronHostHook handling started...");
-
-                string electronhosthookDir = Path.Combine(Directory.GetCurrentDirectory(), "ElectronHostHook");
-
-                if (Directory.Exists(electronhosthookDir))
-                {
-                    string hosthookDir = Path.Combine(tempPath, "ElectronHostHook");
-                    DirectoryCopy.Do(electronhosthookDir, hosthookDir, true, new List<string>() { "node_modules" });
-
-                    Console.WriteLine("Start npm install for typescript & hosthooks...");
-                    ProcessHelper.CmdExecute("npm install", hosthookDir);
-
-                    // ToDo: Not sure if this runs under linux/macos
-                    ProcessHelper.CmdExecute(@"npx tsc -p ../../ElectronHostHook", tempPath);
-                }
-
-                string arguments = "";
-
-                if (parser.Arguments.ContainsKey(_arguments))
-                {
-                    arguments = string.Join(' ', parser.Arguments[_arguments]);
-                }
-
-                if (parser.Arguments.ContainsKey(_manifest))
-                {
-                    arguments += " --manifest=" + parser.Arguments[_manifest].First();
-                }
-
-                if (parser.Arguments.ContainsKey(_clearCache))
-                {
-                    arguments += " --clear-cache=true";
-                }
-
-                if (parser.Arguments.ContainsKey("watch"))
-                {
-                    arguments += " --watch=true";
-                }
-
-                string path = Path.Combine(tempPath, "node_modules", ".bin");
-                bool isWindows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
-
-                if (isWindows)
-                {
-                    Console.WriteLine("Invoke electron.cmd - in dir: " + path);
-                    ProcessHelper.CmdExecute(@"electron.cmd ""..\..\main.js"" " + arguments, path);
-
-                }
-                else
-                {
-                    Console.WriteLine("Invoke electron - in dir: " + path);
-                    ProcessHelper.CmdExecute(@"./electron ""../../main.js"" " + arguments, path);
-                }
-
-                return true;
-            });
-        }
-    }
-}

ElectronNET.CLI/Commands/VersionCommand.cs

@@ -1,35 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Reflection;
-using System.Threading.Tasks;
-
-namespace ElectronNET.CLI.Commands
-{
-    public class VersionCommand : ICommand
-    {
-        public const string COMMAND_NAME = "version";
-        public const string COMMAND_DESCRIPTION = "Displays the ElectronNET.CLI version";
-        public const string COMMAND_ARGUMENTS = "";
-        public static IList<CommandOption> CommandOptions { get; set; } = new List<CommandOption>();
-
-        public VersionCommand(string[] args)
-        {
-        }
-
-        public Task<bool> ExecuteAsync()
-        {
-            return Task.Run(() =>
-            {
-                var runtimeVersion = typeof(VersionCommand)
-                    .GetTypeInfo()
-                    .Assembly
-                    .GetCustomAttribute<AssemblyFileVersionAttribute>();
-
-                Console.WriteLine($"ElectronNET.CLI Version: " + runtimeVersion.Version);
-
-                return true;
-            });
-        }
-
-    }
-}

ElectronNET.CLI/ElectronNET.CLI.csproj

@@ -1,91 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-
-    <TargetFramework>net5.0</TargetFramework>
-    <AssemblyName>dotnet-electronize</AssemblyName>
-    <ToolCommandName>electronize</ToolCommandName>
-
-    <PackageType>DotnetCliTool</PackageType>
-    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
-    <PackageOutputPath>..\artifacts</PackageOutputPath>
-    <PackageId>ElectronNET.CLI</PackageId>
-    <!-- Version 99 is just set for local development stuff to avoid a conflict with "real" packages on NuGet.org -->
-    <Version>99.0.0.0</Version>
-    <Authors>Gregor Biswanger, Robert Muehsig</Authors>
-    <Product>Electron.NET</Product>
-    <Company />
-    <Description>
-      Building cross platform electron based desktop apps with .NET Core and ASP.NET Core.
-      This package contains the dotnet tooling to electronize your application.
-    </Description>
-    <PackageLicenseExpression>MIT</PackageLicenseExpression>
-    <PackageProjectUrl>https://github.com/ElectronNET/Electron.NET/</PackageProjectUrl>
-    <RepositoryUrl>https://github.com/ElectronNET/Electron.NET/</RepositoryUrl>
-    <RepositoryType>git</RepositoryType>
-    <PublishRepositoryUrl>true</PublishRepositoryUrl>
-    <PackageTags>electron aspnetcore</PackageTags>
-    <PackageReleaseNotes>Changelog: https://github.com/ElectronNET/Electron.NET/blob/master/Changelog.md</PackageReleaseNotes>
-    <PackageIcon>PackageIcon.png</PackageIcon>
-    <PackAsTool>true</PackAsTool>
-    <StartupObject></StartupObject>
-  </PropertyGroup>
-
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
-    <PlatformTarget>AnyCPU</PlatformTarget>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <None Remove="ElectronHost\package-lock.json" />
-    <None Remove="ElectronHost\package.json" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <None Include="PackageIcon.png" Pack="true" PackagePath="\" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <EmbeddedResource Include="..\ElectronNET.Host\electron.manifest.json" Link="ElectronHost\electron.manifest.json" />
-    <EmbeddedResource Include="..\ElectronNET.Host\package.json" Link="ElectronHost\package.json" />
-    <EmbeddedResource Include="..\ElectronNET.Host\main.js" Link="ElectronHost\main.js" />
-    <EmbeddedResource Include="..\ElectronNET.Host\build-helper.js" Link="ElectronHost\build-helper.js" />
-    <EmbeddedResource Include="..\ElectronNET.Host\api\ipc.js" Link="ElectronHost\api\ipc.js" />
-    <EmbeddedResource Include="..\ElectronNET.Host\ElectronHostHook\index.ts" Link="ElectronHost\ElectronHostHook\index.ts" />
-    <EmbeddedResource Include="..\ElectronNET.Host\ElectronHostHook\connector.ts" Link="ElectronHost\ElectronHostHook\connector.ts" />
-    <EmbeddedResource Include="..\ElectronNET.Host\ElectronHostHook\tsconfig.json" Link="ElectronHost\ElectronHostHook\tsconfig.json" />
-    <EmbeddedResource Include="..\ElectronNET.Host\ElectronHostHook\package.json" Link="ElectronHost\ElectronHostHook\package.json" />
-    <EmbeddedResource Include="..\ElectronNET.Host\ElectronHostHook\.gitignore" Link="ElectronHost\ElectronHostHook\.gitignore" />
-    <EmbeddedResource Include="..\ElectronNET.Host\splashscreen\index.html" Link="ElectronHost\splashscreen\index.html" />
-    <EmbeddedResource Include="..\ElectronNET.Host\api\app.js" Link="ElectronHost\api\app.js" />
-    <EmbeddedResource Include="..\ElectronNET.Host\api\browserWindows.js" Link="ElectronHost\api\browserWindows.js" />
-    <EmbeddedResource Include="..\ElectronNET.Host\api\commandLine.js" Link="ElectronHost\api\commandLine.js" />
-    <EmbeddedResource Include="..\ElectronNET.Host\api\dialog.js" Link="ElectronHost\api\dialog.js" />
-    <EmbeddedResource Include="..\ElectronNET.Host\api\dock.js" Link="ElectronHost\api\dock.js" />
-    <EmbeddedResource Include="..\ElectronNET.Host\api\menu.js" Link="ElectronHost\api\menu.js" />
-    <EmbeddedResource Include="..\ElectronNET.Host\api\notification.js" Link="ElectronHost\api\notification.js" />
-    <EmbeddedResource Include="..\ElectronNET.Host\api\tray.js" Link="ElectronHost\api\tray.js" />
-    <EmbeddedResource Include="..\ElectronNET.Host\api\globalShortcut.js" Link="ElectronHost\api\globalShortcut.js" />
-    <EmbeddedResource Include="..\ElectronNET.Host\api\screen.js" Link="ElectronHost\api\screen.js" />
-    <EmbeddedResource Include="..\ElectronNET.Host\api\shell.js" Link="ElectronHost\api\shell.js" />
-    <EmbeddedResource Include="..\ElectronNET.Host\api\webContents.js" Link="ElectronHost\api\webContents.js" />
-    <EmbeddedResource Include="..\ElectronNET.Host\api\clipboard.js" Link="ElectronHost\api\clipboard.js" />
-    <EmbeddedResource Include="..\ElectronNET.Host\api\autoUpdater.js" Link="ElectronHost\api\autoUpdater.js" />
-    <EmbeddedResource Include="..\ElectronNET.Host\api\browserView.js" Link="ElectronHost\api\browserView.js" />
-    <EmbeddedResource Include="..\ElectronNET.Host\api\powerMonitor.js" Link="ElectronHost\api\powerMonitor.js" />
-    <EmbeddedResource Include="..\ElectronNET.Host\api\nativeTheme.js" Link="ElectronHost\api\nativeTheme.js" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
-    </PackageReference>
-  </ItemGroup>
-  <Target Name="PostBuild" AfterTargets="PostBuildEvent" Condition="'$(OS)' == 'Windows_NT'">
-    <Exec Command="$(ProjectDir)devCleanup.cmd" IgnoreExitCode="true" />
-  </Target>
-  <Target Name="PostBuild" AfterTargets="PostBuildEvent" Condition="'$(OS)' != 'Windows_NT'">
-    <Exec Command="$(ProjectDir)devCleanup.sh" IgnoreExitCode="true" />
-  </Target>
-</Project>

ElectronNET.CLI/EmbeddedFileHelper.cs

@@ -1,47 +0,0 @@
-using System;
-using System.IO;
-using System.Reflection;
-
-namespace ElectronNET.CLI
-{
-    public static class EmbeddedFileHelper
-    {
-        private const string ResourcePath = "ElectronNET.CLI.{0}";
-
-        private static Stream GetTestResourceFileStream(string folderAndFileInProjectPath)
-        {
-            var asm = Assembly.GetExecutingAssembly();
-            var resource = string.Format(ResourcePath, folderAndFileInProjectPath);
-
-            return asm.GetManifestResourceStream(resource);
-        }
-
-        public static void DeployEmbeddedFile(string targetPath, string file, string namespacePath = "")
-        {
-            using (var fileStream = File.Create(Path.Combine(targetPath, file)))
-            {
-                var streamFromEmbeddedFile = GetTestResourceFileStream("ElectronHost." + namespacePath + file);
-                if (streamFromEmbeddedFile == null)
-                {
-                    Console.WriteLine("Error: Couldn't find embedded file: " + file);
-                }
-
-                streamFromEmbeddedFile.CopyTo(fileStream);
-            }
-        }
-
-        public static void DeployEmbeddedFileToTargetFile(string targetPath, string embeddedFile, string targetFile, string namespacePath = "")
-        {
-            using (var fileStream = File.Create(Path.Combine(targetPath, targetFile)))
-            {
-                var streamFromEmbeddedFile = GetTestResourceFileStream("ElectronHost." + namespacePath + embeddedFile);
-                if (streamFromEmbeddedFile == null)
-                {
-                    Console.WriteLine("Error: Couldn't find embedded file: " + embeddedFile);
-                }
-
-                streamFromEmbeddedFile.CopyTo(fileStream);
-            }
-        }
-    }
-}

ElectronNET.CLI/ProcessHelper.cs

@@ -1,53 +0,0 @@
-using System;
-using System.Diagnostics;
-using System.Runtime.InteropServices;
-
-namespace ElectronNET.CLI
-{
-    public class ProcessHelper
-    {
-        public static int CmdExecute(string command, string workingDirectoryPath, bool output = true, bool waitForExit = true)
-        {
-            using (Process cmd = new Process())
-            {
-                bool isWindows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
-
-                if (isWindows)
-                {
-                    cmd.StartInfo = new ProcessStartInfo("cmd.exe", "/c " + command);
-                }
-                else
-                {
-                    // works for OSX and Linux (at least on Ubuntu)
-                    var escapedArgs = command.Replace("\"", "\\\"");
-                    cmd.StartInfo = new ProcessStartInfo("bash", $"-c \"{escapedArgs}\"");
-                }
-
-                cmd.StartInfo.RedirectStandardInput = true;
-                cmd.StartInfo.RedirectStandardOutput = true;
-                cmd.StartInfo.RedirectStandardError = true;
-                cmd.StartInfo.CreateNoWindow = true;
-                cmd.StartInfo.UseShellExecute = false;
-                cmd.StartInfo.WorkingDirectory = workingDirectoryPath;
-
-                if (output)
-                {
-                    cmd.OutputDataReceived += (s, e) => Console.WriteLine(e.Data);
-                    cmd.ErrorDataReceived += (s, e) => Console.WriteLine(e.Data);
-                }
-
-                Console.WriteLine(command);
-                cmd.Start();
-                cmd.BeginOutputReadLine();
-                cmd.BeginErrorReadLine();
-
-                if (waitForExit)
-                {
-                    cmd.WaitForExit();
-                }
-
-                return cmd.ExitCode;
-            }
-        }
-    }
-}

ElectronNET.CLI/Program.cs

@@ -1,201 +0,0 @@
-using ElectronNET.CLI.Commands;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-using System.Text;
-
-namespace ElectronNET.CLI
-{
-    class Program
-    {
-        static void Main(string[] args)
-        {
-            if (args.Length == 0)
-            {
-                PrintUsageHeader();
-                PrintUsage();
-                Environment.Exit(-1);
-            }
-
-            ICommand command = null;
-
-            switch (args[0])
-            {
-                case StartElectronCommand.COMMAND_NAME:
-                    command = new StartElectronCommand(args.Skip(1).ToArray());
-                    break;
-                case BuildCommand.COMMAND_NAME:
-                    command = new BuildCommand(args.Skip(1).ToArray());
-                    break;
-                case InitCommand.COMMAND_NAME:
-                    command = new InitCommand(args.Skip(1).ToArray());
-                    break;
-                case AddCommand.COMMAND_NAME:
-                    command = new AddCommand(args.Skip(1).ToArray());
-                    break;
-                case VersionCommand.COMMAND_NAME:
-                    command = new VersionCommand(args.Skip(1).ToArray());
-                    break;
-                case "--help":
-                case "--h":
-                case "help":
-                    PrintUsageHeader();
-
-                    if (args.Length > 1)
-                        PrintUsage(args[1]);
-                    else
-                        PrintUsage();
-                    break;
-                default:
-                    Console.Error.WriteLine($"Unknown command {args[0]}");
-                    PrintUsage();
-                    Environment.Exit(-1);
-                    break;
-            }
-
-            if (command != null)
-            {
-                var success = command.ExecuteAsync().Result;
-                if (!success)
-                {
-                    Environment.Exit(-1);
-                }
-            }
-        }
-
-        private static void PrintUsageHeader()
-        {
-            var sb = new StringBuilder("Electron.NET Tools");
-            var version = Version;
-            if (!string.IsNullOrEmpty(version))
-            {
-                sb.Append($" ({version})");
-            }
-            Console.WriteLine(sb.ToString());
-            Console.WriteLine("Project Home: https://github.com/ElectronNET/Electron.NET");
-            Console.WriteLine("\t");
-        }
-
-        private static void PrintUsage()
-        {
-            const int NAME_WIDTH = 23;
-            Console.WriteLine("\t");
-            Console.WriteLine("Commands to start the Electron Application:");
-            Console.WriteLine("\t");
-            Console.WriteLine($"\t{StartElectronCommand.COMMAND_NAME.PadRight(NAME_WIDTH)} {StartElectronCommand.COMMAND_DESCRIPTION}");
-
-            Console.WriteLine("\t");
-            Console.WriteLine("Command to build the Electron Application:");
-            Console.WriteLine("\t");
-            Console.WriteLine($"\t{BuildCommand.COMMAND_NAME.PadRight(NAME_WIDTH)} {BuildCommand.COMMAND_DESCRIPTION}");
-
-            Console.WriteLine("\t");
-            Console.WriteLine("Command to init the Electron Application:");
-            Console.WriteLine("\t");
-            Console.WriteLine($"\t{InitCommand.COMMAND_NAME.PadRight(NAME_WIDTH)} {InitCommand.COMMAND_DESCRIPTION}");
-
-            Console.WriteLine("\t");
-            Console.WriteLine("Command to add a custom npm packages to the Electron Application:");
-            Console.WriteLine("\t");
-            Console.WriteLine($"\t{AddCommand.COMMAND_NAME.PadRight(NAME_WIDTH)} {AddCommand.COMMAND_DESCRIPTION}");
-
-            Console.WriteLine("\t");
-            Console.WriteLine("Commands to see the current ElectronNET version number:");
-            Console.WriteLine("\t");
-            Console.WriteLine($"\t{VersionCommand.COMMAND_NAME.PadRight(NAME_WIDTH)} {VersionCommand.COMMAND_DESCRIPTION}");
-
-            Console.WriteLine("\t");
-            Console.WriteLine("\t");
-            Console.WriteLine("To get help on individual commands execute:");
-            Console.WriteLine("\tdotnet electronize help <command>");
-        }
-
-        private static void PrintUsage(string command)
-        {
-            switch (command)
-            {
-                case StartElectronCommand.COMMAND_NAME:
-                    PrintUsage(StartElectronCommand.COMMAND_NAME, StartElectronCommand.COMMAND_DESCRIPTION, StartElectronCommand.CommandOptions, StartElectronCommand.COMMAND_ARGUMENTS);
-                    break;
-                case BuildCommand.COMMAND_NAME:
-                    PrintUsage(BuildCommand.COMMAND_NAME, BuildCommand.COMMAND_DESCRIPTION, BuildCommand.CommandOptions, BuildCommand.COMMAND_ARGUMENTS);
-                    break;
-                case InitCommand.COMMAND_NAME:
-                    PrintUsage(InitCommand.COMMAND_NAME, InitCommand.COMMAND_DESCRIPTION, InitCommand.CommandOptions, InitCommand.COMMAND_ARGUMENTS);
-                    break;
-                case AddCommand.COMMAND_NAME:
-                    PrintUsage(AddCommand.COMMAND_NAME, AddCommand.COMMAND_DESCRIPTION, AddCommand.CommandOptions, AddCommand.COMMAND_ARGUMENTS);
-                    break;
-                case VersionCommand.COMMAND_NAME:
-                    PrintUsage(VersionCommand.COMMAND_NAME, VersionCommand.COMMAND_DESCRIPTION, VersionCommand.CommandOptions, VersionCommand.COMMAND_ARGUMENTS);
-                    break;
-                default:
-                    Console.Error.WriteLine($"Unknown command {command}");
-                    PrintUsage();
-                    break;
-            }
-        }
-
-        private static void PrintUsage(string command, string description, IList<CommandOption> options, string arguments)
-        {
-            const int INDENT = 3;
-
-            Console.WriteLine($"{command}: ");
-            Console.WriteLine($"{new string(' ', INDENT)}{description}");
-            Console.WriteLine("\t");
-
-
-            if (!string.IsNullOrEmpty(arguments))
-            {
-                Console.WriteLine($"{new string(' ', INDENT)}dotnet electronize {command} [arguments] [options]");
-                Console.WriteLine($"{new string(' ', INDENT)}Arguments:");
-                Console.WriteLine($"{new string(' ', INDENT * 2)}{arguments}");
-            }
-            else
-            {
-                Console.WriteLine($"{new string(' ', INDENT)}dotnet electronize {command} [options]");
-            }
-
-            const int SWITCH_COLUMN_WIDTH = 40;
-
-            Console.WriteLine($"{new string(' ', INDENT)}Options:");
-            foreach (var option in options)
-            {
-                StringBuilder stringBuilder = new StringBuilder();
-                if (option.ShortSwitch != null)
-                {
-                    stringBuilder.Append($"{option.ShortSwitch.PadRight(6)} | ");
-                }
-
-                stringBuilder.Append($"{option.Switch}");
-                if (stringBuilder.Length < SWITCH_COLUMN_WIDTH)
-                {
-                    stringBuilder.Append(new string(' ', SWITCH_COLUMN_WIDTH - stringBuilder.Length));
-                }
-
-                stringBuilder.Append(option.Description);
-
-
-                Console.WriteLine($"{new string(' ', INDENT * 2)}{stringBuilder.ToString()}");
-            }
-        }
-
-        private static string Version
-        {
-            get
-            {
-                AssemblyInformationalVersionAttribute attribute = null;
-                try
-                {
-                    attribute = Assembly.GetEntryAssembly().GetCustomAttribute<AssemblyInformationalVersionAttribute>();
-                }
-                catch (AmbiguousMatchException)
-                {
-                    // Catch exception and continue if multiple attributes are found.
-                }
-                return attribute?.InformationalVersion;
-            }
-        }
-    }
-}

ElectronNET.CLI/Properties/launchSettings.json

@@ -1,8 +0,0 @@
-{
-  "profiles": {
-    "ElectronNET.CLI": {
-      "commandName": "Project",
-      "commandLineArgs": "start /project-path \"$(SolutionDir)ElectronNET.WebApp\" /watch"
-    }
-  }
-}

ElectronNET.CLI/SimpleCommandLineParser.cs

@@ -1,54 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace ElectronNET.CLI
-{
-    public class SimpleCommandLineParser
-    {
-        public SimpleCommandLineParser()
-        {
-            Arguments = new Dictionary<string, string[]>();
-        }
-        public IDictionary<string, string[]> Arguments { get; private set; }
-        public void Parse(string[] args)
-        {
-            var currentName = "";
-            var values = new List<string>();
-            foreach (var arg in args)
-            {
-                if (arg.StartsWith("/"))
-                {
-                    if (currentName != "")
-                        Arguments[currentName] = values.ToArray();
-                    values.Clear();
-                    currentName = arg.Substring(1);
-                }
-                else if (currentName == "")
-                    Arguments[arg] = new string[0];
-                else
-                    values.Add(arg);
-            }
-            if (currentName != "")
-                Arguments[currentName] = values.ToArray();
-
-            Console.ForegroundColor = ConsoleColor.Green;
-            Console.WriteLine($"Arguments: \n\t{string.Join("\n\t",Arguments.Keys.Select(i => $"{i} = {string.Join(" ", Arguments[i])}"))}");
-            Console.ResetColor();
-        }
-        public bool Contains(string name)
-        {
-            return Arguments.ContainsKey(name);
-        }
-
-        internal bool TryGet(string key, out string[] value)
-        {
-            value = null;
-            if (!Contains(key)) {
-                return false;
-            }
-            value = Arguments[key];
-            return true;
-        }
-    }
-}

ElectronNET.CLI/devCleanup.cmd

@@ -1,3 +0,0 @@
-rd /s /q %userprofile%\.nuget\packages\.tools\electronnet.cli 
-rd /s /q %userprofile%\.nuget\packages\electronnet.cli 
-del ..\artifacts\ElectronNET.CLI.1.0.0.nupkg

ElectronNET.CLI/devCleanup.sh

@@ -1 +0,0 @@
-rm -rf ~/.nuget/packages/electronnet.cli

ElectronNET.Host/.vscode/launch.json

@@ -1,32 +0,0 @@
-{
-    // Use IntelliSense to learn about possible attributes.
-    // Hover to view descriptions of existing attributes.
-    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "type": "node",
-            "request": "launch",
-            "name": "Launch Electron App",
-            "runtimeExecutable": "${workspaceFolder}/node_modules/.bin/electron",
-            "program": "${workspaceFolder}/main.js",
-            "sourceMaps": true,
-            "args": [
-                "--test=true",
-                "--blub=wuhuu"
-            ]
-        },
-        {
-            "type": "node",
-            "request": "launch",
-            "name": "Launch build-helper",
-            "program": "${workspaceFolder}/build-helper.js",
-            "skipFiles": [
-                "<node_internals>/**"
-            ],
-            "args": [
-                "electron.manifest.json"
-            ]
-        }
-    ]
-}

ElectronNET.Host/ElectronHostHook/connector.js.map

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

ElectronNET.Host/ElectronHostHook/index.js.map

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

ElectronNET.Host/ElectronHostHook/tsconfig.json

@@ -1,11 +0,0 @@
-{
-    "compilerOptions": {
-        "module": "commonjs",
-        "sourceMap": true,
-        "skipLibCheck": true,
-        "target": "es2015"
-    },
-    "exclude": [
-        "node_modules"
-    ]
-}

ElectronNET.Host/api/autoUpdater.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"autoUpdater.js","sourceRoot":"","sources":["autoUpdater.ts"],"names":[],"mappings":";AACA,uDAA+C;AAC/C,IAAI,cAAc,CAAC;AAEnB,iBAAS,CAAC,MAAc,EAAE,EAAE;IACxB,cAAc,GAAG,MAAM,CAAC;IAExB,MAAM,CAAC,EAAE,CAAC,kCAAkC,EAAE,CAAC,EAAE,EAAE,EAAE;QACjD,8BAAW,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,EAAE;YAC9B,cAAc,CAAC,IAAI,CAAC,mBAAmB,GAAG,EAAE,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;QACjE,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,gDAAgD,EAAE,CAAC,EAAE,EAAE,EAAE;QAC/D,8BAAW,CAAC,EAAE,CAAC,qBAAqB,EAAE,GAAG,EAAE;YACvC,cAAc,CAAC,IAAI,CAAC,iCAAiC,GAAG,EAAE,CAAC,CAAC;QAChE,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,6CAA6C,EAAE,CAAC,EAAE,EAAE,EAAE;QAC5D,8BAAW,CAAC,EAAE,CAAC,kBAAkB,EAAE,CAAC,UAAU,EAAE,EAAE;YAC9C,cAAc,CAAC,IAAI,CAAC,8BAA8B,GAAG,EAAE,EAAE,UAAU,CAAC,CAAC;QACzE,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,iDAAiD,EAAE,CAAC,EAAE,EAAE,EAAE;QAChE,8BAAW,CAAC,EAAE,CAAC,sBAAsB,EAAE,CAAC,UAAU,EAAE,EAAE;YAClD,cAAc,CAAC,IAAI,CAAC,kCAAkC,GAAG,EAAE,EAAE,UAAU,CAAC,CAAC;QAC7E,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,8CAA8C,EAAE,CAAC,EAAE,EAAE,EAAE;QAC7D,8BAAW,CAAC,EAAE,CAAC,mBAAmB,EAAE,CAAC,YAAY,EAAE,EAAE;YACjD,cAAc,CAAC,IAAI,CAAC,+BAA+B,GAAG,EAAE,EAAE,YAAY,CAAC,CAAC;QAC5E,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,8CAA8C,EAAE,CAAC,EAAE,EAAE,EAAE;QAC7D,8BAAW,CAAC,EAAE,CAAC,mBAAmB,EAAE,CAAC,UAAU,EAAE,EAAE;YAC/C,cAAc,CAAC,IAAI,CAAC,+BAA+B,GAAG,EAAE,EAAE,UAAU,CAAC,CAAC;QAC1E,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IAEH,mBAAmB;IAEnB,MAAM,CAAC,EAAE,CAAC,8BAA8B,EAAE,GAAG,EAAE;QAC3C,cAAc,CAAC,IAAI,CAAC,oCAAoC,EAAE,8BAAW,CAAC,YAAY,CAAC,CAAC;IACxF,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,8BAA8B,EAAE,CAAC,KAAK,EAAE,EAAE;QAChD,8BAAW,CAAC,YAAY,GAAG,KAAK,CAAC;IACrC,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,sCAAsC,EAAE,GAAG,EAAE;QACnD,cAAc,CAAC,IAAI,CAAC,4CAA4C,EAAE,8BAAW,CAAC,oBAAoB,CAAC,CAAC;IACxG,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,sCAAsC,EAAE,CAAC,KAAK,EAAE,EAAE;QACxD,8BAAW,CAAC,oBAAoB,GAAG,KAAK,CAAC;IAC7C,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,iCAAiC,EAAE,GAAG,EAAE;QAC9C,cAAc,CAAC,IAAI,CAAC,uCAAuC,EAAE,8BAAW,CAAC,eAAe,CAAC,CAAC;IAC9F,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,iCAAiC,EAAE,CAAC,KAAK,EAAE,EAAE;QACnD,8BAAW,CAAC,eAAe,GAAG,KAAK,CAAC;IACxC,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,+BAA+B,EAAE,GAAG,EAAE;QAC5C,cAAc,CAAC,IAAI,CAAC,qCAAqC,EAAE,8BAAW,CAAC,aAAa,CAAC,CAAC;IAC1F,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,+BAA+B,EAAE,CAAC,KAAK,EAAE,EAAE;QACjD,8BAAW,CAAC,aAAa,GAAG,KAAK,CAAC;IACtC,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,gCAAgC,EAAE,GAAG,EAAE;QAC7C,cAAc,CAAC,IAAI,CAAC,sCAAsC,EAAE,8BAAW,CAAC,cAAc,CAAC,CAAC;IAC5F,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,gCAAgC,EAAE,CAAC,KAAK,EAAE,EAAE;QAClD,8BAAW,CAAC,cAAc,GAAG,KAAK,CAAC;IACvC,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,kCAAkC,EAAE,GAAG,EAAE;QAC/C,cAAc,CAAC,IAAI,CAAC,wCAAwC,EAAE,8BAAW,CAAC,gBAAgB,IAAI,EAAE,CAAC,CAAC;IACtG,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,kCAAkC,EAAE,CAAC,KAAK,EAAE,EAAE;QACpD,8BAAW,CAAC,gBAAgB,GAAG,KAAK,CAAC;IACzC,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,gCAAgC,EAAE,GAAG,EAAE;QAC7C,cAAc,CAAC,IAAI,CAAC,sCAAsC,EAAE,8BAAW,CAAC,cAAc,CAAC,CAAC;IAC5F,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,yBAAyB,EAAE,GAAG,EAAE;QACtC,cAAc,CAAC,IAAI,CAAC,+BAA+B,EAAE,8BAAW,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC;IACpF,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,yBAAyB,EAAE,CAAC,KAAK,EAAE,EAAE;QAC3C,8BAAW,CAAC,OAAO,GAAG,KAAK,CAAC;IAChC,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,gCAAgC,EAAE,GAAG,EAAE;QAC7C,cAAc,CAAC,IAAI,CAAC,sCAAsC,EAAE,8BAAW,CAAC,cAAc,CAAC,CAAC;IAC5F,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,gCAAgC,EAAE,CAAC,KAAK,EAAE,EAAE;QAClD,8BAAW,CAAC,cAAc,GAAG,KAAK,CAAC;IACvC,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,qCAAqC,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE;QAC5D,8BAAW,CAAC,wBAAwB,EAAE,CAAC,IAAI,CAAC,CAAC,iBAAiB,EAAE,EAAE;YAC9D,cAAc,CAAC,IAAI,CAAC,6CAA6C,GAAG,IAAI,EAAE,iBAAiB,CAAC,CAAC;QACjG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;YACf,cAAc,CAAC,IAAI,CAAC,0CAA0C,GAAG,IAAI,EAAE,KAAK,CAAC,CAAC;QAClF,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,4BAA4B,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE;QACnD,8BAAW,CAAC,eAAe,EAAE,CAAC,IAAI,CAAC,CAAC,iBAAiB,EAAE,EAAE;YACrD,cAAc,CAAC,IAAI,CAAC,oCAAoC,GAAG,IAAI,EAAE,iBAAiB,CAAC,CAAC;QACxF,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;YACf,cAAc,CAAC,IAAI,CAAC,iCAAiC,GAAG,IAAI,EAAE,KAAK,CAAC,CAAC;QACzE,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,2BAA2B,EAAE,KAAK,EAAE,QAAQ,EAAE,eAAe,EAAE,EAAE;QACvE,8BAAW,CAAC,cAAc,CAAC,QAAQ,EAAE,eAAe,CAAC,CAAC;IAC1D,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,2BAA2B,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE;QAClD,MAAM,cAAc,GAAG,MAAM,8BAAW,CAAC,cAAc,EAAE,CAAC;QAC1D,cAAc,CAAC,IAAI,CAAC,mCAAmC,GAAG,IAAI,EAAE,cAAc,CAAC,CAAC;IACpF,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,uBAAuB,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE;QAC9C,MAAM,OAAO,GAAG,MAAM,8BAAW,CAAC,UAAU,EAAE,CAAC;QAC/C,cAAc,CAAC,IAAI,CAAC,+BAA+B,GAAG,IAAI,EAAE,OAAO,IAAI,EAAE,CAAC,CAAC;IAC/E,CAAC,CAAC,CAAC;AACP,CAAC,CAAC"}

ElectronNET.Host/api/browserView.js.map

@@ -1 +0,0 @@
-{"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;YAChE,OAAO,GAAG,EAAE,GAAG,OAAO,EAAE,cAAc,EAAE,EAAE,eAAe,EAAE,IAAI,EAAE,gBAAgB,EAAE,KAAK,EAAE,EAAE,CAAC;SAChG;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;YACf,WAAW,CAAC,WAAW,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAC,UAAU,EAAE,OAAO,CAAC,KAAK,EAAC,CAAC,CAAC;SACzE;QAED,IAAI,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,gBAAgB,EAAE;YAC3C,qBAAqB,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,gBAAgB,CAAC;SACnE;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,uBAAuB,EAAE,CAAC,EAAE,EAAE,EAAE;QACtC,MAAM,MAAM,GAAG,kBAAkB,CAAC,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC;QAElD,cAAc,CAAC,IAAI,CAAC,6BAA6B,EAAE,MAAM,CAAC,CAAC;IAC/D,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,uBAAuB,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE;QAC9C,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;YACxC,IAAI,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE;gBAC5C,OAAO,KAAK,CAAC;aAChB;YACD,GAAG,GAAG,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;SAC5B;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;QACtD,MAAM,eAAe,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC;QAC5C,IAAI,eAAe,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE;YAC9B,OAAO,eAAe,CAAC;SAC1B;KACJ;AACL,CAAC"}

ElectronNET.Host/api/browserWindows.js

@@ -1,610 +0,0 @@
-"use strict";
-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;
-const proxyToCredentialsMap = (global['proxyToCredentialsMap'] = global['proxyToCredentialsMap'] || []);
-module.exports = (socket, app) => {
-    electronSocket = socket;
-    app.on('login', (event, webContents, request, authInfo, callback) => {
-        if (authInfo.isProxy) {
-            let proxy = `${authInfo.host}:${authInfo.port}`;
-            if (proxy in proxyToCredentialsMap && proxyToCredentialsMap[proxy].split(':').length === 2) {
-                event.preventDefault();
-                let user = proxyToCredentialsMap[proxy].split(':')[0];
-                let pass = proxyToCredentialsMap[proxy].split(':')[1];
-                callback(user, pass);
-            }
-        }
-    });
-    socket.on('register-browserWindow-ready-to-show', (id) => {
-        if (readyToShowWindowsIds.includes(id)) {
-            readyToShowWindowsIds = readyToShowWindowsIds.filter(value => value !== id);
-            electronSocket.emit('browserWindow-ready-to-show' + id);
-        }
-        getWindowById(id).on('ready-to-show', () => {
-            readyToShowWindowsIds.push(id);
-            electronSocket.emit('browserWindow-ready-to-show' + id);
-        });
-    });
-    socket.on('register-browserWindow-page-title-updated', (id) => {
-        getWindowById(id).on('page-title-updated', (event, title) => {
-            electronSocket.emit('browserWindow-page-title-updated' + id, title);
-        });
-    });
-    socket.on('register-browserWindow-close', (id) => {
-        getWindowById(id).on('close', () => {
-            electronSocket.emit('browserWindow-close' + id);
-        });
-    });
-    socket.on('register-browserWindow-closed', (id) => {
-        getWindowById(id).on('closed', () => {
-            electronSocket.emit('browserWindow-closed' + id);
-        });
-    });
-    socket.on('register-browserWindow-session-end', (id) => {
-        getWindowById(id).on('session-end', () => {
-            electronSocket.emit('browserWindow-session-end' + id);
-        });
-    });
-    socket.on('register-browserWindow-unresponsive', (id) => {
-        getWindowById(id).on('unresponsive', () => {
-            electronSocket.emit('browserWindow-unresponsive' + id);
-        });
-    });
-    socket.on('register-browserWindow-responsive', (id) => {
-        getWindowById(id).on('responsive', () => {
-            electronSocket.emit('browserWindow-responsive' + id);
-        });
-    });
-    socket.on('register-browserWindow-blur', (id) => {
-        getWindowById(id).on('blur', () => {
-            electronSocket.emit('browserWindow-blur' + id);
-        });
-    });
-    socket.on('register-browserWindow-focus', (id) => {
-        getWindowById(id).on('focus', () => {
-            electronSocket.emit('browserWindow-focus' + id);
-        });
-    });
-    socket.on('register-browserWindow-show', (id) => {
-        getWindowById(id).on('show', () => {
-            electronSocket.emit('browserWindow-show' + id);
-        });
-    });
-    socket.on('register-browserWindow-hide', (id) => {
-        getWindowById(id).on('hide', () => {
-            electronSocket.emit('browserWindow-hide' + id);
-        });
-    });
-    socket.on('register-browserWindow-maximize', (id) => {
-        getWindowById(id).on('maximize', () => {
-            electronSocket.emit('browserWindow-maximize' + id);
-        });
-    });
-    socket.on('register-browserWindow-unmaximize', (id) => {
-        getWindowById(id).on('unmaximize', () => {
-            electronSocket.emit('browserWindow-unmaximize' + id);
-        });
-    });
-    socket.on('register-browserWindow-minimize', (id) => {
-        getWindowById(id).on('minimize', () => {
-            electronSocket.emit('browserWindow-minimize' + id);
-        });
-    });
-    socket.on('register-browserWindow-restore', (id) => {
-        getWindowById(id).on('restore', () => {
-            electronSocket.emit('browserWindow-restore' + id);
-        });
-    });
-    socket.on('register-browserWindow-resize', (id) => {
-        getWindowById(id).on('resize', () => {
-            electronSocket.emit('browserWindow-resize' + id);
-        });
-    });
-    socket.on('register-browserWindow-move', (id) => {
-        getWindowById(id).on('move', () => {
-            electronSocket.emit('browserWindow-move' + id);
-        });
-    });
-    socket.on('register-browserWindow-moved', (id) => {
-        getWindowById(id).on('moved', () => {
-            electronSocket.emit('browserWindow-moved' + id);
-        });
-    });
-    socket.on('register-browserWindow-enter-full-screen', (id) => {
-        getWindowById(id).on('enter-full-screen', () => {
-            electronSocket.emit('browserWindow-enter-full-screen' + id);
-        });
-    });
-    socket.on('register-browserWindow-leave-full-screen', (id) => {
-        getWindowById(id).on('leave-full-screen', () => {
-            electronSocket.emit('browserWindow-leave-full-screen' + id);
-        });
-    });
-    socket.on('register-browserWindow-enter-html-full-screen', (id) => {
-        getWindowById(id).on('enter-html-full-screen', () => {
-            electronSocket.emit('browserWindow-enter-html-full-screen' + id);
-        });
-    });
-    socket.on('register-browserWindow-leave-html-full-screen', (id) => {
-        getWindowById(id).on('leave-html-full-screen', () => {
-            electronSocket.emit('browserWindow-leave-html-full-screen' + id);
-        });
-    });
-    socket.on('register-browserWindow-app-command', (id) => {
-        getWindowById(id).on('app-command', (event, command) => {
-            electronSocket.emit('browserWindow-app-command' + id, command);
-        });
-    });
-    socket.on('register-browserWindow-scroll-touch-begin', (id) => {
-        getWindowById(id).on('scroll-touch-begin', () => {
-            electronSocket.emit('browserWindow-scroll-touch-begin' + id);
-        });
-    });
-    socket.on('register-browserWindow-scroll-touch-end', (id) => {
-        getWindowById(id).on('scroll-touch-end', () => {
-            electronSocket.emit('browserWindow-scroll-touch-end' + id);
-        });
-    });
-    socket.on('register-browserWindow-scroll-touch-edge', (id) => {
-        getWindowById(id).on('scroll-touch-edge', () => {
-            electronSocket.emit('browserWindow-scroll-touch-edge' + id);
-        });
-    });
-    socket.on('register-browserWindow-swipe', (id) => {
-        getWindowById(id).on('swipe', (event, direction) => {
-            electronSocket.emit('browserWindow-swipe' + id, direction);
-        });
-    });
-    socket.on('register-browserWindow-sheet-begin', (id) => {
-        getWindowById(id).on('sheet-begin', () => {
-            electronSocket.emit('browserWindow-sheet-begin' + id);
-        });
-    });
-    socket.on('register-browserWindow-sheet-end', (id) => {
-        getWindowById(id).on('sheet-end', () => {
-            electronSocket.emit('browserWindow-sheet-end' + id);
-        });
-    });
-    socket.on('register-browserWindow-new-window-for-tab', (id) => {
-        getWindowById(id).on('new-window-for-tab', () => {
-            electronSocket.emit('browserWindow-new-window-for-tab' + id);
-        });
-    });
-    socket.on('createBrowserWindow', (options, loadUrl) => {
-        if (options.webPreferences && !('nodeIntegration' in options.webPreferences)) {
-            options = { ...options, webPreferences: { ...options.webPreferences, nodeIntegration: true, contextIsolation: false } };
-        }
-        else if (!options.webPreferences) {
-            options = { ...options, webPreferences: { nodeIntegration: true, contextIsolation: false } };
-        }
-        // we dont want to recreate the window when watch is ready.
-        if (app.commandLine.hasSwitch('watch') && app['mainWindowURL'] === loadUrl) {
-            window = app['mainWindow'];
-            if (window) {
-                window.reload();
-                windows.push(window);
-                electronSocket.emit('BrowserWindowCreated', window.id);
-                return;
-            }
-        }
-        else {
-            window = new electron_1.BrowserWindow(options);
-        }
-        if (options.proxy) {
-            window.webContents.session.setProxy({ proxyRules: options.proxy });
-        }
-        if (options.proxy && options.proxyCredentials) {
-            proxyToCredentialsMap[options.proxy] = options.proxyCredentials;
-        }
-        window.on('ready-to-show', () => {
-            if (readyToShowWindowsIds.includes(window.id)) {
-                readyToShowWindowsIds = readyToShowWindowsIds.filter(value => value !== window.id);
-            }
-            else {
-                readyToShowWindowsIds.push(window.id);
-            }
-        });
-        lastOptions = options;
-        window.on('closed', (sender) => {
-            for (let index = 0; index < windows.length; index++) {
-                const windowItem = windows[index];
-                try {
-                    windowItem.id;
-                }
-                catch (error) {
-                    if (error.message === 'Object has been destroyed') {
-                        windows.splice(index, 1);
-                        const ids = [];
-                        windows.forEach(x => ids.push(x.id));
-                        electronSocket.emit('BrowserWindowClosed', ids);
-                    }
-                }
-            }
-        });
-        app.on('activate', () => {
-            // On macOS it's common to re-create a window in the app when the
-            // dock icon is clicked and there are no other windows open.
-            if (window === null && lastOptions) {
-                window = new electron_1.BrowserWindow(lastOptions);
-            }
-        });
-        if (loadUrl) {
-            window.loadURL(loadUrl);
-        }
-        if (app.commandLine.hasSwitch('clear-cache') &&
-            app.commandLine.getSwitchValue('clear-cache')) {
-            window.webContents.session.clearCache();
-            console.log('auto clear-cache active for new window.');
-        }
-        // set main window url
-        if (app['mainWindowURL'] == undefined || app['mainWindowURL'] == "") {
-            app['mainWindowURL'] = loadUrl;
-            app['mainWindow'] = window;
-        }
-        windows.push(window);
-        electronSocket.emit('BrowserWindowCreated', window.id);
-    });
-    socket.on('browserWindowDestroy', (id) => {
-        getWindowById(id).destroy();
-    });
-    socket.on('browserWindowClose', (id) => {
-        getWindowById(id).close();
-    });
-    socket.on('browserWindowFocus', (id) => {
-        getWindowById(id).focus();
-    });
-    socket.on('browserWindowBlur', (id) => {
-        getWindowById(id).blur();
-    });
-    socket.on('browserWindowIsFocused', (id) => {
-        const isFocused = getWindowById(id).isFocused();
-        electronSocket.emit('browserWindow-isFocused-completed', isFocused);
-    });
-    socket.on('browserWindowIsDestroyed', (id) => {
-        const isDestroyed = getWindowById(id).isDestroyed();
-        electronSocket.emit('browserWindow-isDestroyed-completed', isDestroyed);
-    });
-    socket.on('browserWindowShow', (id) => {
-        getWindowById(id).show();
-    });
-    socket.on('browserWindowShowInactive', (id) => {
-        getWindowById(id).showInactive();
-    });
-    socket.on('browserWindowHide', (id) => {
-        getWindowById(id).hide();
-    });
-    socket.on('browserWindowIsVisible', (id) => {
-        const isVisible = getWindowById(id).isVisible();
-        electronSocket.emit('browserWindow-isVisible-completed', isVisible);
-    });
-    socket.on('browserWindowIsModal', (id) => {
-        const isModal = getWindowById(id).isModal();
-        electronSocket.emit('browserWindow-isModal-completed', isModal);
-    });
-    socket.on('browserWindowMaximize', (id) => {
-        getWindowById(id).maximize();
-    });
-    socket.on('browserWindowUnmaximize', (id) => {
-        getWindowById(id).unmaximize();
-    });
-    socket.on('browserWindowIsMaximized', (id) => {
-        const isMaximized = getWindowById(id).isMaximized();
-        electronSocket.emit('browserWindow-isMaximized-completed', isMaximized);
-    });
-    socket.on('browserWindowMinimize', (id) => {
-        getWindowById(id).minimize();
-    });
-    socket.on('browserWindowRestore', (id) => {
-        getWindowById(id).restore();
-    });
-    socket.on('browserWindowIsMinimized', (id) => {
-        const isMinimized = getWindowById(id).isMinimized();
-        electronSocket.emit('browserWindow-isMinimized-completed', isMinimized);
-    });
-    socket.on('browserWindowSetFullScreen', (id, fullscreen) => {
-        getWindowById(id).setFullScreen(fullscreen);
-    });
-    socket.on('browserWindowIsFullScreen', (id) => {
-        const isFullScreen = getWindowById(id).isFullScreen();
-        electronSocket.emit('browserWindow-isFullScreen-completed', isFullScreen);
-    });
-    socket.on('browserWindowSetAspectRatio', (id, aspectRatio, extraSize) => {
-        getWindowById(id).setAspectRatio(aspectRatio, extraSize);
-    });
-    socket.on('browserWindowPreviewFile', (id, path, displayname) => {
-        getWindowById(id).previewFile(path, displayname);
-    });
-    socket.on('browserWindowCloseFilePreview', (id) => {
-        getWindowById(id).closeFilePreview();
-    });
-    socket.on('browserWindowSetBounds', (id, bounds, animate) => {
-        getWindowById(id).setBounds(bounds, animate);
-    });
-    socket.on('browserWindowGetBounds', (id) => {
-        const rectangle = getWindowById(id).getBounds();
-        electronSocket.emit('browserWindow-getBounds-completed', rectangle);
-    });
-    socket.on('browserWindowSetContentBounds', (id, bounds, animate) => {
-        getWindowById(id).setContentBounds(bounds, animate);
-    });
-    socket.on('browserWindowGetContentBounds', (id) => {
-        const rectangle = getWindowById(id).getContentBounds();
-        electronSocket.emit('browserWindow-getContentBounds-completed', rectangle);
-    });
-    socket.on('browserWindowSetSize', (id, width, height, animate) => {
-        getWindowById(id).setSize(width, height, animate);
-    });
-    socket.on('browserWindowGetSize', (id) => {
-        const size = getWindowById(id).getSize();
-        electronSocket.emit('browserWindow-getSize-completed', size);
-    });
-    socket.on('browserWindowSetContentSize', (id, width, height, animate) => {
-        getWindowById(id).setContentSize(width, height, animate);
-    });
-    socket.on('browserWindowGetContentSize', (id) => {
-        const size = getWindowById(id).getContentSize();
-        electronSocket.emit('browserWindow-getContentSize-completed', size);
-    });
-    socket.on('browserWindowSetMinimumSize', (id, width, height) => {
-        getWindowById(id).setMinimumSize(width, height);
-    });
-    socket.on('browserWindowGetMinimumSize', (id) => {
-        const size = getWindowById(id).getMinimumSize();
-        electronSocket.emit('browserWindow-getMinimumSize-completed', size);
-    });
-    socket.on('browserWindowSetMaximumSize', (id, width, height) => {
-        getWindowById(id).setMaximumSize(width, height);
-    });
-    socket.on('browserWindowGetMaximumSize', (id) => {
-        const size = getWindowById(id).getMaximumSize();
-        electronSocket.emit('browserWindow-getMaximumSize-completed', size);
-    });
-    socket.on('browserWindowSetResizable', (id, resizable) => {
-        getWindowById(id).setResizable(resizable);
-    });
-    socket.on('browserWindowIsResizable', (id) => {
-        const resizable = getWindowById(id).isResizable();
-        electronSocket.emit('browserWindow-isResizable-completed', resizable);
-    });
-    socket.on('browserWindowSetMovable', (id, movable) => {
-        getWindowById(id).setMovable(movable);
-    });
-    socket.on('browserWindowIsMovable', (id) => {
-        const movable = getWindowById(id).isMovable();
-        electronSocket.emit('browserWindow-isMovable-completed', movable);
-    });
-    socket.on('browserWindowSetMinimizable', (id, minimizable) => {
-        getWindowById(id).setMinimizable(minimizable);
-    });
-    socket.on('browserWindowIsMinimizable', (id) => {
-        const minimizable = getWindowById(id).isMinimizable();
-        electronSocket.emit('browserWindow-isMinimizable-completed', minimizable);
-    });
-    socket.on('browserWindowSetMaximizable', (id, maximizable) => {
-        getWindowById(id).setMaximizable(maximizable);
-    });
-    socket.on('browserWindowIsMaximizable', (id) => {
-        const maximizable = getWindowById(id).isMaximizable();
-        electronSocket.emit('browserWindow-isMaximizable-completed', maximizable);
-    });
-    socket.on('browserWindowSetFullScreenable', (id, fullscreenable) => {
-        getWindowById(id).setFullScreenable(fullscreenable);
-    });
-    socket.on('browserWindowIsFullScreenable', (id) => {
-        const fullscreenable = getWindowById(id).isFullScreenable();
-        electronSocket.emit('browserWindow-isFullScreenable-completed', fullscreenable);
-    });
-    socket.on('browserWindowSetClosable', (id, closable) => {
-        getWindowById(id).setClosable(closable);
-    });
-    socket.on('browserWindowIsClosable', (id) => {
-        const closable = getWindowById(id).isClosable();
-        electronSocket.emit('browserWindow-isClosable-completed', closable);
-    });
-    socket.on('browserWindowSetAlwaysOnTop', (id, flag, level, relativeLevel) => {
-        getWindowById(id).setAlwaysOnTop(flag, level, relativeLevel);
-    });
-    socket.on('browserWindowIsAlwaysOnTop', (id) => {
-        const isAlwaysOnTop = getWindowById(id).isAlwaysOnTop();
-        electronSocket.emit('browserWindow-isAlwaysOnTop-completed', isAlwaysOnTop);
-    });
-    socket.on('browserWindowCenter', (id) => {
-        getWindowById(id).center();
-    });
-    socket.on('browserWindowSetPosition', (id, x, y, animate) => {
-        getWindowById(id).setPosition(x, y, animate);
-    });
-    socket.on('browserWindowGetPosition', (id) => {
-        const position = getWindowById(id).getPosition();
-        electronSocket.emit('browserWindow-getPosition-completed', position);
-    });
-    socket.on('browserWindowSetTitle', (id, title) => {
-        getWindowById(id).setTitle(title);
-    });
-    socket.on('browserWindowGetTitle', (id) => {
-        const title = getWindowById(id).getTitle();
-        electronSocket.emit('browserWindow-getTitle-completed', title);
-    });
-    socket.on('browserWindowSetTitle', (id, title) => {
-        getWindowById(id).setTitle(title);
-    });
-    socket.on('browserWindowSetSheetOffset', (id, offsetY, offsetX) => {
-        if (offsetX) {
-            getWindowById(id).setSheetOffset(offsetY, offsetX);
-        }
-        else {
-            getWindowById(id).setSheetOffset(offsetY);
-        }
-    });
-    socket.on('browserWindowFlashFrame', (id, flag) => {
-        getWindowById(id).flashFrame(flag);
-    });
-    socket.on('browserWindowSetSkipTaskbar', (id, skip) => {
-        getWindowById(id).setSkipTaskbar(skip);
-    });
-    socket.on('browserWindowSetKiosk', (id, flag) => {
-        getWindowById(id).setKiosk(flag);
-    });
-    socket.on('browserWindowIsKiosk', (id) => {
-        const isKiosk = getWindowById(id).isKiosk();
-        electronSocket.emit('browserWindow-isKiosk-completed', isKiosk);
-    });
-    socket.on('browserWindowGetNativeWindowHandle', (id) => {
-        const nativeWindowHandle = getWindowById(id).getNativeWindowHandle().readInt32LE(0).toString(16);
-        electronSocket.emit('browserWindow-getNativeWindowHandle-completed', nativeWindowHandle);
-    });
-    socket.on('browserWindowSetRepresentedFilename', (id, filename) => {
-        getWindowById(id).setRepresentedFilename(filename);
-    });
-    socket.on('browserWindowGetRepresentedFilename', (id) => {
-        const pathname = getWindowById(id).getRepresentedFilename();
-        electronSocket.emit('browserWindow-getRepresentedFilename-completed', pathname);
-    });
-    socket.on('browserWindowSetDocumentEdited', (id, edited) => {
-        getWindowById(id).setDocumentEdited(edited);
-    });
-    socket.on('browserWindowIsDocumentEdited', (id) => {
-        const edited = getWindowById(id).isDocumentEdited();
-        electronSocket.emit('browserWindow-isDocumentEdited-completed', edited);
-    });
-    socket.on('browserWindowFocusOnWebView', (id) => {
-        getWindowById(id).focusOnWebView();
-    });
-    socket.on('browserWindowBlurWebView', (id) => {
-        getWindowById(id).blurWebView();
-    });
-    socket.on('browserWindowLoadURL', (id, url, options) => {
-        getWindowById(id).loadURL(url, options);
-    });
-    socket.on('browserWindowReload', (id) => {
-        getWindowById(id).reload();
-    });
-    socket.on('browserWindowSetMenu', (id, menuItems) => {
-        let menu = null;
-        if (menuItems) {
-            menu = electron_1.Menu.buildFromTemplate(menuItems);
-            addMenuItemClickConnector(menu.items, (id) => {
-                electronSocket.emit('windowMenuItemClicked', id);
-            });
-        }
-        getWindowById(id).setMenu(menu);
-    });
-    socket.on('browserWindowRemoveMenu', (id) => {
-        getWindowById(id).removeMenu();
-    });
-    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('browserWindowSetProgressBar', (id, progress) => {
-        getWindowById(id).setProgressBar(progress);
-    });
-    socket.on('browserWindowSetProgressBar', (id, progress, options) => {
-        getWindowById(id).setProgressBar(progress, options);
-    });
-    socket.on('browserWindowSetHasShadow', (id, hasShadow) => {
-        getWindowById(id).setHasShadow(hasShadow);
-    });
-    socket.on('browserWindowHasShadow', (id) => {
-        const hasShadow = getWindowById(id).hasShadow();
-        electronSocket.emit('browserWindow-hasShadow-completed', hasShadow);
-    });
-    socket.on('browserWindowSetThumbarButtons', (id, thumbarButtons) => {
-        thumbarButtons.forEach(thumbarButton => {
-            const imagePath = path.join(__dirname.replace('api', ''), 'bin', thumbarButton.icon.toString());
-            thumbarButton.icon = electron_1.nativeImage.createFromPath(imagePath);
-            thumbarButton.click = () => {
-                electronSocket.emit('thumbarButtonClicked', thumbarButton['id']);
-            };
-        });
-        const success = getWindowById(id).setThumbarButtons(thumbarButtons);
-        electronSocket.emit('browserWindowSetThumbarButtons-completed', success);
-    });
-    socket.on('browserWindowSetThumbnailClip', (id, rectangle) => {
-        getWindowById(id).setThumbnailClip(rectangle);
-    });
-    socket.on('browserWindowSetThumbnailToolTip', (id, toolTip) => {
-        getWindowById(id).setThumbnailToolTip(toolTip);
-    });
-    socket.on('browserWindowSetAppDetails', (id, options) => {
-        getWindowById(id).setAppDetails(options);
-    });
-    socket.on('browserWindowShowDefinitionForSelection', (id) => {
-        getWindowById(id).showDefinitionForSelection();
-    });
-    socket.on('browserWindowSetAutoHideMenuBar', (id, hide) => {
-        getWindowById(id).setAutoHideMenuBar(hide);
-    });
-    socket.on('browserWindowIsMenuBarAutoHide', (id) => {
-        const isMenuBarAutoHide = getWindowById(id).isMenuBarAutoHide();
-        electronSocket.emit('browserWindow-isMenuBarAutoHide-completed', isMenuBarAutoHide);
-    });
-    socket.on('browserWindowSetMenuBarVisibility', (id, visible) => {
-        getWindowById(id).setMenuBarVisibility(visible);
-    });
-    socket.on('browserWindowIsMenuBarVisible', (id) => {
-        const isMenuBarVisible = getWindowById(id).isMenuBarVisible();
-        electronSocket.emit('browserWindow-isMenuBarVisible-completed', isMenuBarVisible);
-    });
-    socket.on('browserWindowSetVisibleOnAllWorkspaces', (id, visible) => {
-        getWindowById(id).setVisibleOnAllWorkspaces(visible);
-    });
-    socket.on('browserWindowIsVisibleOnAllWorkspaces', (id) => {
-        const isVisibleOnAllWorkspaces = getWindowById(id).isVisibleOnAllWorkspaces();
-        electronSocket.emit('browserWindow-isVisibleOnAllWorkspaces-completed', isVisibleOnAllWorkspaces);
-    });
-    socket.on('browserWindowSetIgnoreMouseEvents', (id, ignore) => {
-        getWindowById(id).setIgnoreMouseEvents(ignore);
-    });
-    socket.on('browserWindowSetContentProtection', (id, enable) => {
-        getWindowById(id).setContentProtection(enable);
-    });
-    socket.on('browserWindowSetFocusable', (id, focusable) => {
-        getWindowById(id).setFocusable(focusable);
-    });
-    socket.on('browserWindowSetParentWindow', (id, parent) => {
-        const browserWindow = electron_1.BrowserWindow.fromId(parent.id);
-        getWindowById(id).setParentWindow(browserWindow);
-    });
-    socket.on('browserWindowGetParentWindow', (id) => {
-        const browserWindow = getWindowById(id).getParentWindow();
-        electronSocket.emit('browserWindow-getParentWindow-completed', browserWindow.id);
-    });
-    socket.on('browserWindowGetChildWindows', (id) => {
-        const browserWindows = getWindowById(id).getChildWindows();
-        const ids = [];
-        browserWindows.forEach(x => {
-            ids.push(x.id);
-        });
-        electronSocket.emit('browserWindow-getChildWindows-completed', ids);
-    });
-    socket.on('browserWindowSetAutoHideCursor', (id, autoHide) => {
-        getWindowById(id).setAutoHideCursor(autoHide);
-    });
-    socket.on('browserWindowSetVibrancy', (id, type) => {
-        getWindowById(id).setVibrancy(type);
-    });
-    socket.on('browserWindow-setBrowserView', (id, browserViewId) => {
-        getWindowById(id).setBrowserView(browserView_1.browserViewMediateService(browserViewId));
-    });
-    function getWindowById(id) {
-        for (let index = 0; index < windows.length; index++) {
-            const element = windows[index];
-            if (element.id === id) {
-                return element;
-            }
-        }
-    }
-};
-//# sourceMappingURL=browserWindows.js.map

ElectronNET.Host/api/browserWindows.ts

@@ -1,785 +0,0 @@
-import { Socket } from 'net';
-import { BrowserWindow, Menu, nativeImage } 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;
-const proxyToCredentialsMap: { [proxy: string]: string } = (global['proxyToCredentialsMap'] = global['proxyToCredentialsMap'] || []) as { [proxy: string]: string };
-
-export = (socket: Socket, app: Electron.App) => {
-    electronSocket = socket;
-
-    app.on('login', (event, webContents, request, authInfo, callback) => {
-        if (authInfo.isProxy) {
-            let proxy = `${authInfo.host}:${authInfo.port}`
-            if (proxy in proxyToCredentialsMap && proxyToCredentialsMap[proxy].split(':').length === 2) {
-                event.preventDefault()
-                let user = proxyToCredentialsMap[proxy].split(':')[0]
-                let pass = proxyToCredentialsMap[proxy].split(':')[1]
-                callback(user, pass)
-            }
-        }
-    })
-
-    socket.on('register-browserWindow-ready-to-show', (id) => {
-        if (readyToShowWindowsIds.includes(id)) {
-            readyToShowWindowsIds = readyToShowWindowsIds.filter(value => value !== id);
-            electronSocket.emit('browserWindow-ready-to-show' + id);
-        }
-
-        getWindowById(id).on('ready-to-show', () => {
-            readyToShowWindowsIds.push(id);
-            electronSocket.emit('browserWindow-ready-to-show' + id);
-        });
-    });
-
-    socket.on('register-browserWindow-page-title-updated', (id) => {
-        getWindowById(id).on('page-title-updated', (event, title) => {
-            electronSocket.emit('browserWindow-page-title-updated' + id, title);
-        });
-    });
-
-    socket.on('register-browserWindow-close', (id) => {
-        getWindowById(id).on('close', () => {
-            electronSocket.emit('browserWindow-close' + id);
-        });
-    });
-
-    socket.on('register-browserWindow-closed', (id) => {
-        getWindowById(id).on('closed', () => {
-            electronSocket.emit('browserWindow-closed' + id);
-        });
-    });
-
-    socket.on('register-browserWindow-session-end', (id) => {
-        getWindowById(id).on('session-end', () => {
-            electronSocket.emit('browserWindow-session-end' + id);
-        });
-    });
-
-    socket.on('register-browserWindow-unresponsive', (id) => {
-        getWindowById(id).on('unresponsive', () => {
-            electronSocket.emit('browserWindow-unresponsive' + id);
-        });
-    });
-
-    socket.on('register-browserWindow-responsive', (id) => {
-        getWindowById(id).on('responsive', () => {
-            electronSocket.emit('browserWindow-responsive' + id);
-        });
-    });
-
-    socket.on('register-browserWindow-blur', (id) => {
-        getWindowById(id).on('blur', () => {
-            electronSocket.emit('browserWindow-blur' + id);
-        });
-    });
-
-    socket.on('register-browserWindow-focus', (id) => {
-        getWindowById(id).on('focus', () => {
-            electronSocket.emit('browserWindow-focus' + id);
-        });
-    });
-
-    socket.on('register-browserWindow-show', (id) => {
-        getWindowById(id).on('show', () => {
-            electronSocket.emit('browserWindow-show' + id);
-        });
-    });
-
-    socket.on('register-browserWindow-hide', (id) => {
-        getWindowById(id).on('hide', () => {
-            electronSocket.emit('browserWindow-hide' + id);
-        });
-    });
-
-    socket.on('register-browserWindow-maximize', (id) => {
-        getWindowById(id).on('maximize', () => {
-            electronSocket.emit('browserWindow-maximize' + id);
-        });
-    });
-
-    socket.on('register-browserWindow-unmaximize', (id) => {
-        getWindowById(id).on('unmaximize', () => {
-            electronSocket.emit('browserWindow-unmaximize' + id);
-        });
-    });
-
-    socket.on('register-browserWindow-minimize', (id) => {
-        getWindowById(id).on('minimize', () => {
-            electronSocket.emit('browserWindow-minimize' + id);
-        });
-    });
-
-    socket.on('register-browserWindow-restore', (id) => {
-        getWindowById(id).on('restore', () => {
-            electronSocket.emit('browserWindow-restore' + id);
-        });
-    });
-
-    socket.on('register-browserWindow-resize', (id) => {
-        getWindowById(id).on('resize', () => {
-            electronSocket.emit('browserWindow-resize' + id);
-        });
-    });
-
-    socket.on('register-browserWindow-move', (id) => {
-        getWindowById(id).on('move', () => {
-            electronSocket.emit('browserWindow-move' + id);
-        });
-    });
-
-    socket.on('register-browserWindow-moved', (id) => {
-        getWindowById(id).on('moved', () => {
-            electronSocket.emit('browserWindow-moved' + id);
-        });
-    });
-
-    socket.on('register-browserWindow-enter-full-screen', (id) => {
-        getWindowById(id).on('enter-full-screen', () => {
-            electronSocket.emit('browserWindow-enter-full-screen' + id);
-        });
-    });
-
-    socket.on('register-browserWindow-leave-full-screen', (id) => {
-        getWindowById(id).on('leave-full-screen', () => {
-            electronSocket.emit('browserWindow-leave-full-screen' + id);
-        });
-    });
-
-    socket.on('register-browserWindow-enter-html-full-screen', (id) => {
-        getWindowById(id).on('enter-html-full-screen', () => {
-            electronSocket.emit('browserWindow-enter-html-full-screen' + id);
-        });
-    });
-
-    socket.on('register-browserWindow-leave-html-full-screen', (id) => {
-        getWindowById(id).on('leave-html-full-screen', () => {
-            electronSocket.emit('browserWindow-leave-html-full-screen' + id);
-        });
-    });
-
-    socket.on('register-browserWindow-app-command', (id) => {
-        getWindowById(id).on('app-command', (event, command) => {
-            electronSocket.emit('browserWindow-app-command' + id, command);
-        });
-    });
-
-    socket.on('register-browserWindow-scroll-touch-begin', (id) => {
-        getWindowById(id).on('scroll-touch-begin', () => {
-            electronSocket.emit('browserWindow-scroll-touch-begin' + id);
-        });
-    });
-
-    socket.on('register-browserWindow-scroll-touch-end', (id) => {
-        getWindowById(id).on('scroll-touch-end', () => {
-            electronSocket.emit('browserWindow-scroll-touch-end' + id);
-        });
-    });
-
-    socket.on('register-browserWindow-scroll-touch-edge', (id) => {
-        getWindowById(id).on('scroll-touch-edge', () => {
-            electronSocket.emit('browserWindow-scroll-touch-edge' + id);
-        });
-    });
-
-    socket.on('register-browserWindow-swipe', (id) => {
-        getWindowById(id).on('swipe', (event, direction) => {
-            electronSocket.emit('browserWindow-swipe' + id, direction);
-        });
-    });
-
-    socket.on('register-browserWindow-sheet-begin', (id) => {
-        getWindowById(id).on('sheet-begin', () => {
-            electronSocket.emit('browserWindow-sheet-begin' + id);
-        });
-    });
-
-    socket.on('register-browserWindow-sheet-end', (id) => {
-        getWindowById(id).on('sheet-end', () => {
-            electronSocket.emit('browserWindow-sheet-end' + id);
-        });
-    });
-
-    socket.on('register-browserWindow-new-window-for-tab', (id) => {
-        getWindowById(id).on('new-window-for-tab', () => {
-            electronSocket.emit('browserWindow-new-window-for-tab' + id);
-        });
-    });
-
-    socket.on('createBrowserWindow', (options, loadUrl) => {
-        if (options.webPreferences && !('nodeIntegration' in options.webPreferences)) {
-            options = { ...options, webPreferences: { ...options.webPreferences, nodeIntegration: true, contextIsolation: false } };
-        } else if (!options.webPreferences) {
-            options = { ...options, webPreferences: { nodeIntegration: true, contextIsolation: false } };
-        }
-
-        // we dont want to recreate the window when watch is ready.
-        if (app.commandLine.hasSwitch('watch') && app['mainWindowURL'] === loadUrl) {
-            window = app['mainWindow'];
-            if (window) {
-                window.reload();
-                windows.push(window);
-                electronSocket.emit('BrowserWindowCreated', window.id);
-                return;
-            }
-        } else {
-            window = new BrowserWindow(options);
-        }
-
-        if (options.proxy) {
-            window.webContents.session.setProxy({proxyRules: options.proxy});
-        }
-
-        if (options.proxy && options.proxyCredentials) {
-            proxyToCredentialsMap[options.proxy] = options.proxyCredentials;
-        }
-
-        window.on('ready-to-show', () => {
-            if (readyToShowWindowsIds.includes(window.id)) {
-                readyToShowWindowsIds = readyToShowWindowsIds.filter(value => value !== window.id);
-            } else {
-                readyToShowWindowsIds.push(window.id);
-            }
-        });
-
-        lastOptions = options;
-
-        window.on('closed', (sender) => {
-            for (let index = 0; index < windows.length; index++) {
-                const windowItem = windows[index];
-                try {
-                    windowItem.id;
-                } catch (error) {
-                    if (error.message === 'Object has been destroyed') {
-                        windows.splice(index, 1);
-
-                        const ids = [];
-                        windows.forEach(x => ids.push(x.id));
-                        electronSocket.emit('BrowserWindowClosed', ids);
-                    }
-                }
-            }
-        });
-
-        app.on('activate', () => {
-            // On macOS it's common to re-create a window in the app when the
-            // dock icon is clicked and there are no other windows open.
-            if (window === null && lastOptions) {
-                window = new BrowserWindow(lastOptions);
-            }
-        });
-
-        if (loadUrl) {
-            window.loadURL(loadUrl);
-        }
-
-        if (app.commandLine.hasSwitch('clear-cache') &&
-            app.commandLine.getSwitchValue('clear-cache')) {
-            window.webContents.session.clearCache();
-            console.log('auto clear-cache active for new window.');
-        }
-
-        // set main window url
-        if (app['mainWindowURL'] == undefined || app['mainWindowURL'] == "") {
-            app['mainWindowURL'] = loadUrl;
-            app['mainWindow'] = window;
-        }
-
-        windows.push(window);
-        electronSocket.emit('BrowserWindowCreated', window.id);
-    });
-
-    socket.on('browserWindowDestroy', (id) => {
-        getWindowById(id).destroy();
-    });
-
-    socket.on('browserWindowClose', (id) => {
-        getWindowById(id).close();
-    });
-
-    socket.on('browserWindowFocus', (id) => {
-        getWindowById(id).focus();
-    });
-
-    socket.on('browserWindowBlur', (id) => {
-        getWindowById(id).blur();
-    });
-
-    socket.on('browserWindowIsFocused', (id) => {
-        const isFocused = getWindowById(id).isFocused();
-
-        electronSocket.emit('browserWindow-isFocused-completed', isFocused);
-    });
-
-    socket.on('browserWindowIsDestroyed', (id) => {
-        const isDestroyed = getWindowById(id).isDestroyed();
-
-        electronSocket.emit('browserWindow-isDestroyed-completed', isDestroyed);
-    });
-
-    socket.on('browserWindowShow', (id) => {
-        getWindowById(id).show();
-    });
-
-    socket.on('browserWindowShowInactive', (id) => {
-        getWindowById(id).showInactive();
-    });
-
-    socket.on('browserWindowHide', (id) => {
-        getWindowById(id).hide();
-    });
-
-    socket.on('browserWindowIsVisible', (id) => {
-        const isVisible = getWindowById(id).isVisible();
-
-        electronSocket.emit('browserWindow-isVisible-completed', isVisible);
-    });
-
-    socket.on('browserWindowIsModal', (id) => {
-        const isModal = getWindowById(id).isModal();
-
-        electronSocket.emit('browserWindow-isModal-completed', isModal);
-    });
-
-    socket.on('browserWindowMaximize', (id) => {
-        getWindowById(id).maximize();
-    });
-
-    socket.on('browserWindowUnmaximize', (id) => {
-        getWindowById(id).unmaximize();
-    });
-
-    socket.on('browserWindowIsMaximized', (id) => {
-        const isMaximized = getWindowById(id).isMaximized();
-
-        electronSocket.emit('browserWindow-isMaximized-completed', isMaximized);
-    });
-
-    socket.on('browserWindowMinimize', (id) => {
-        getWindowById(id).minimize();
-    });
-
-    socket.on('browserWindowRestore', (id) => {
-        getWindowById(id).restore();
-    });
-
-    socket.on('browserWindowIsMinimized', (id) => {
-        const isMinimized = getWindowById(id).isMinimized();
-
-        electronSocket.emit('browserWindow-isMinimized-completed', isMinimized);
-    });
-
-    socket.on('browserWindowSetFullScreen', (id, fullscreen) => {
-        getWindowById(id).setFullScreen(fullscreen);
-    });
-
-    socket.on('browserWindowIsFullScreen', (id) => {
-        const isFullScreen = getWindowById(id).isFullScreen();
-
-        electronSocket.emit('browserWindow-isFullScreen-completed', isFullScreen);
-    });
-
-    socket.on('browserWindowSetAspectRatio', (id, aspectRatio, extraSize) => {
-        getWindowById(id).setAspectRatio(aspectRatio, extraSize);
-    });
-
-    socket.on('browserWindowPreviewFile', (id, path, displayname) => {
-        getWindowById(id).previewFile(path, displayname);
-    });
-
-    socket.on('browserWindowCloseFilePreview', (id) => {
-        getWindowById(id).closeFilePreview();
-    });
-
-    socket.on('browserWindowSetBounds', (id, bounds, animate) => {
-        getWindowById(id).setBounds(bounds, animate);
-    });
-
-    socket.on('browserWindowGetBounds', (id) => {
-        const rectangle = getWindowById(id).getBounds();
-
-        electronSocket.emit('browserWindow-getBounds-completed', rectangle);
-    });
-
-    socket.on('browserWindowSetContentBounds', (id, bounds, animate) => {
-        getWindowById(id).setContentBounds(bounds, animate);
-    });
-
-    socket.on('browserWindowGetContentBounds', (id) => {
-        const rectangle = getWindowById(id).getContentBounds();
-
-        electronSocket.emit('browserWindow-getContentBounds-completed', rectangle);
-    });
-
-    socket.on('browserWindowSetSize', (id, width, height, animate) => {
-        getWindowById(id).setSize(width, height, animate);
-    });
-
-    socket.on('browserWindowGetSize', (id) => {
-        const size = getWindowById(id).getSize();
-
-        electronSocket.emit('browserWindow-getSize-completed', size);
-    });
-
-    socket.on('browserWindowSetContentSize', (id, width, height, animate) => {
-        getWindowById(id).setContentSize(width, height, animate);
-    });
-
-    socket.on('browserWindowGetContentSize', (id) => {
-        const size = getWindowById(id).getContentSize();
-
-        electronSocket.emit('browserWindow-getContentSize-completed', size);
-    });
-
-    socket.on('browserWindowSetMinimumSize', (id, width, height) => {
-        getWindowById(id).setMinimumSize(width, height);
-    });
-
-    socket.on('browserWindowGetMinimumSize', (id) => {
-        const size = getWindowById(id).getMinimumSize();
-
-        electronSocket.emit('browserWindow-getMinimumSize-completed', size);
-    });
-
-    socket.on('browserWindowSetMaximumSize', (id, width, height) => {
-        getWindowById(id).setMaximumSize(width, height);
-    });
-
-    socket.on('browserWindowGetMaximumSize', (id) => {
-        const size = getWindowById(id).getMaximumSize();
-
-        electronSocket.emit('browserWindow-getMaximumSize-completed', size);
-    });
-
-    socket.on('browserWindowSetResizable', (id, resizable) => {
-        getWindowById(id).setResizable(resizable);
-    });
-
-    socket.on('browserWindowIsResizable', (id) => {
-        const resizable = getWindowById(id).isResizable();
-
-        electronSocket.emit('browserWindow-isResizable-completed', resizable);
-    });
-
-    socket.on('browserWindowSetMovable', (id, movable) => {
-        getWindowById(id).setMovable(movable);
-    });
-
-    socket.on('browserWindowIsMovable', (id) => {
-        const movable = getWindowById(id).isMovable();
-
-        electronSocket.emit('browserWindow-isMovable-completed', movable);
-    });
-
-    socket.on('browserWindowSetMinimizable', (id, minimizable) => {
-        getWindowById(id).setMinimizable(minimizable);
-    });
-
-    socket.on('browserWindowIsMinimizable', (id) => {
-        const minimizable = getWindowById(id).isMinimizable();
-
-        electronSocket.emit('browserWindow-isMinimizable-completed', minimizable);
-    });
-
-    socket.on('browserWindowSetMaximizable', (id, maximizable) => {
-        getWindowById(id).setMaximizable(maximizable);
-    });
-
-    socket.on('browserWindowIsMaximizable', (id) => {
-        const maximizable = getWindowById(id).isMaximizable();
-
-        electronSocket.emit('browserWindow-isMaximizable-completed', maximizable);
-    });
-
-    socket.on('browserWindowSetFullScreenable', (id, fullscreenable) => {
-        getWindowById(id).setFullScreenable(fullscreenable);
-    });
-
-    socket.on('browserWindowIsFullScreenable', (id) => {
-        const fullscreenable = getWindowById(id).isFullScreenable();
-
-        electronSocket.emit('browserWindow-isFullScreenable-completed', fullscreenable);
-    });
-
-    socket.on('browserWindowSetClosable', (id, closable) => {
-        getWindowById(id).setClosable(closable);
-    });
-
-    socket.on('browserWindowIsClosable', (id) => {
-        const closable = getWindowById(id).isClosable();
-
-        electronSocket.emit('browserWindow-isClosable-completed', closable);
-    });
-
-    socket.on('browserWindowSetAlwaysOnTop', (id, flag, level, relativeLevel) => {
-        getWindowById(id).setAlwaysOnTop(flag, level, relativeLevel);
-    });
-
-    socket.on('browserWindowIsAlwaysOnTop', (id) => {
-        const isAlwaysOnTop = getWindowById(id).isAlwaysOnTop();
-
-        electronSocket.emit('browserWindow-isAlwaysOnTop-completed', isAlwaysOnTop);
-    });
-
-    socket.on('browserWindowCenter', (id) => {
-        getWindowById(id).center();
-    });
-
-    socket.on('browserWindowSetPosition', (id, x, y, animate) => {
-        getWindowById(id).setPosition(x, y, animate);
-    });
-
-    socket.on('browserWindowGetPosition', (id) => {
-        const position = getWindowById(id).getPosition();
-
-        electronSocket.emit('browserWindow-getPosition-completed', position);
-    });
-
-    socket.on('browserWindowSetTitle', (id, title) => {
-        getWindowById(id).setTitle(title);
-    });
-
-    socket.on('browserWindowGetTitle', (id) => {
-        const title = getWindowById(id).getTitle();
-
-        electronSocket.emit('browserWindow-getTitle-completed', title);
-    });
-
-    socket.on('browserWindowSetTitle', (id, title) => {
-        getWindowById(id).setTitle(title);
-    });
-
-    socket.on('browserWindowSetSheetOffset', (id, offsetY, offsetX) => {
-        if (offsetX) {
-            getWindowById(id).setSheetOffset(offsetY, offsetX);
-        } else {
-            getWindowById(id).setSheetOffset(offsetY);
-        }
-    });
-
-    socket.on('browserWindowFlashFrame', (id, flag) => {
-        getWindowById(id).flashFrame(flag);
-    });
-
-    socket.on('browserWindowSetSkipTaskbar', (id, skip) => {
-        getWindowById(id).setSkipTaskbar(skip);
-    });
-
-    socket.on('browserWindowSetKiosk', (id, flag) => {
-        getWindowById(id).setKiosk(flag);
-    });
-
-    socket.on('browserWindowIsKiosk', (id) => {
-        const isKiosk = getWindowById(id).isKiosk();
-
-        electronSocket.emit('browserWindow-isKiosk-completed', isKiosk);
-    });
-
-    socket.on('browserWindowGetNativeWindowHandle', (id) => {
-        const nativeWindowHandle = getWindowById(id).getNativeWindowHandle().readInt32LE(0).toString(16);
-        electronSocket.emit('browserWindow-getNativeWindowHandle-completed', nativeWindowHandle);
-    });
-
-    socket.on('browserWindowSetRepresentedFilename', (id, filename) => {
-        getWindowById(id).setRepresentedFilename(filename);
-    });
-
-    socket.on('browserWindowGetRepresentedFilename', (id) => {
-        const pathname = getWindowById(id).getRepresentedFilename();
-
-        electronSocket.emit('browserWindow-getRepresentedFilename-completed', pathname);
-    });
-
-    socket.on('browserWindowSetDocumentEdited', (id, edited) => {
-        getWindowById(id).setDocumentEdited(edited);
-    });
-
-    socket.on('browserWindowIsDocumentEdited', (id) => {
-        const edited = getWindowById(id).isDocumentEdited();
-
-        electronSocket.emit('browserWindow-isDocumentEdited-completed', edited);
-    });
-
-    socket.on('browserWindowFocusOnWebView', (id) => {
-        getWindowById(id).focusOnWebView();
-    });
-
-    socket.on('browserWindowBlurWebView', (id) => {
-        getWindowById(id).blurWebView();
-    });
-
-    socket.on('browserWindowLoadURL', (id, url, options) => {
-        getWindowById(id).loadURL(url, options);
-    });
-
-    socket.on('browserWindowReload', (id) => {
-        getWindowById(id).reload();
-    });
-
-    socket.on('browserWindowSetMenu', (id, menuItems) => {
-        let menu = null;
-
-        if (menuItems) {
-            menu = Menu.buildFromTemplate(menuItems);
-
-            addMenuItemClickConnector(menu.items, (id) => {
-                electronSocket.emit('windowMenuItemClicked', id);
-            });
-        }
-
-        getWindowById(id).setMenu(menu);
-    });
-
-    socket.on('browserWindowRemoveMenu', (id) => {
-        getWindowById(id).removeMenu();
-    });
-
-    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('browserWindowSetProgressBar', (id, progress) => {
-        getWindowById(id).setProgressBar(progress);
-    });
-
-    socket.on('browserWindowSetProgressBar', (id, progress, options) => {
-        getWindowById(id).setProgressBar(progress, options);
-    });
-
-    socket.on('browserWindowSetHasShadow', (id, hasShadow) => {
-        getWindowById(id).setHasShadow(hasShadow);
-    });
-
-    socket.on('browserWindowHasShadow', (id) => {
-        const hasShadow = getWindowById(id).hasShadow();
-
-        electronSocket.emit('browserWindow-hasShadow-completed', hasShadow);
-    });
-
-    socket.on('browserWindowSetThumbarButtons', (id, thumbarButtons: Electron.ThumbarButton[]) => {
-        thumbarButtons.forEach(thumbarButton => {
-            const imagePath = path.join(__dirname.replace('api', ''), 'bin', thumbarButton.icon.toString());
-            thumbarButton.icon = nativeImage.createFromPath(imagePath);
-            thumbarButton.click = () => {
-                electronSocket.emit('thumbarButtonClicked', thumbarButton['id']);
-            };
-        });
-
-        const success = getWindowById(id).setThumbarButtons(thumbarButtons);
-        electronSocket.emit('browserWindowSetThumbarButtons-completed', success);
-    });
-
-    socket.on('browserWindowSetThumbnailClip', (id, rectangle) => {
-        getWindowById(id).setThumbnailClip(rectangle);
-    });
-
-    socket.on('browserWindowSetThumbnailToolTip', (id, toolTip) => {
-        getWindowById(id).setThumbnailToolTip(toolTip);
-    });
-
-    socket.on('browserWindowSetAppDetails', (id, options) => {
-        getWindowById(id).setAppDetails(options);
-    });
-
-    socket.on('browserWindowShowDefinitionForSelection', (id) => {
-        getWindowById(id).showDefinitionForSelection();
-    });
-
-    socket.on('browserWindowSetAutoHideMenuBar', (id, hide) => {
-        getWindowById(id).setAutoHideMenuBar(hide);
-    });
-
-    socket.on('browserWindowIsMenuBarAutoHide', (id) => {
-        const isMenuBarAutoHide = getWindowById(id).isMenuBarAutoHide();
-
-        electronSocket.emit('browserWindow-isMenuBarAutoHide-completed', isMenuBarAutoHide);
-    });
-
-    socket.on('browserWindowSetMenuBarVisibility', (id, visible) => {
-        getWindowById(id).setMenuBarVisibility(visible);
-    });
-
-    socket.on('browserWindowIsMenuBarVisible', (id) => {
-        const isMenuBarVisible = getWindowById(id).isMenuBarVisible();
-
-        electronSocket.emit('browserWindow-isMenuBarVisible-completed', isMenuBarVisible);
-    });
-
-    socket.on('browserWindowSetVisibleOnAllWorkspaces', (id, visible) => {
-        getWindowById(id).setVisibleOnAllWorkspaces(visible);
-    });
-
-    socket.on('browserWindowIsVisibleOnAllWorkspaces', (id) => {
-        const isVisibleOnAllWorkspaces = getWindowById(id).isVisibleOnAllWorkspaces();
-
-        electronSocket.emit('browserWindow-isVisibleOnAllWorkspaces-completed', isVisibleOnAllWorkspaces);
-    });
-
-    socket.on('browserWindowSetIgnoreMouseEvents', (id, ignore) => {
-        getWindowById(id).setIgnoreMouseEvents(ignore);
-    });
-
-    socket.on('browserWindowSetContentProtection', (id, enable) => {
-        getWindowById(id).setContentProtection(enable);
-    });
-
-    socket.on('browserWindowSetFocusable', (id, focusable) => {
-        getWindowById(id).setFocusable(focusable);
-    });
-
-    socket.on('browserWindowSetParentWindow', (id, parent) => {
-        const browserWindow = BrowserWindow.fromId(parent.id);
-
-        getWindowById(id).setParentWindow(browserWindow);
-    });
-
-    socket.on('browserWindowGetParentWindow', (id) => {
-        const browserWindow = getWindowById(id).getParentWindow();
-
-        electronSocket.emit('browserWindow-getParentWindow-completed', browserWindow.id);
-    });
-
-    socket.on('browserWindowGetChildWindows', (id) => {
-        const browserWindows = getWindowById(id).getChildWindows();
-
-        const ids = [];
-
-        browserWindows.forEach(x => {
-            ids.push(x.id);
-        });
-
-        electronSocket.emit('browserWindow-getChildWindows-completed', ids);
-    });
-
-    socket.on('browserWindowSetAutoHideCursor', (id, autoHide) => {
-        getWindowById(id).setAutoHideCursor(autoHide);
-    });
-
-    socket.on('browserWindowSetVibrancy', (id, type) => {
-        getWindowById(id).setVibrancy(type);
-    });
-
-    socket.on('browserWindow-setBrowserView', (id, browserViewId) => {
-        getWindowById(id).setBrowserView(browserViewMediateService(browserViewId));
-    });
-
-    function getWindowById(id: number): Electron.BrowserWindow {
-        for (let index = 0; index < windows.length; index++) {
-            const element = windows[index];
-            if (element.id === id) {
-                return element;
-            }
-        }
-    }
-};

ElectronNET.Host/api/dialog.js.map

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

ElectronNET.Host/api/ipc.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ipc.js","sourceRoot":"","sources":["ipc.ts"],"names":[],"mappings":";AAAA,uCAA+D;AAE/D,IAAI,cAAc,CAAC;AAEnB,iBAAS,CAAC,MAAc,EAAE,EAAE;IACxB,cAAc,GAAG,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,CAAC,wBAAwB,EAAE,CAAC,OAAO,EAAE,EAAE;QAC5C,kBAAO,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE;YAChC,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,cAAc,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC;QACjE,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,4BAA4B,EAAE,CAAC,OAAO,EAAE,EAAE;QAChD,kBAAO,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE;YAChC,MAAM,CAAC,GAAQ,MAAM,CAAC;YACtB,CAAC,CAAC,kBAAkB,CAAC,OAAO,GAAG,MAAM,CAAC,CAAC;YACvC,MAAM,CAAC,EAAE,CAAC,OAAO,GAAG,MAAM,EAAE,CAAC,MAAM,EAAE,EAAE;gBACnC,KAAK,CAAC,WAAW,GAAG,MAAM,CAAC;YAC/B,CAAC,CAAC,CAAC;YAEH,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,cAAc,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC;QACjE,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,4BAA4B,EAAE,CAAC,OAAO,EAAE,EAAE;QAChD,kBAAO,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE;YAClC,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,cAAc,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC;QACjE,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,kCAAkC,EAAE,CAAC,OAAO,EAAE,EAAE;QACtD,kBAAO,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC;IACxC,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,mBAAmB,EAAE,CAAC,aAAa,EAAE,OAAO,EAAE,GAAG,IAAI,EAAE,EAAE;QAC/D,MAAM,MAAM,GAAG,wBAAa,CAAC,MAAM,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC;QAEtD,IAAI,MAAM,EAAE;YACR,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,CAAC;SAC7C;IACL,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,8BAA8B,EAAE,CAAC,EAAE,EAAE,OAAO,EAAE,GAAG,IAAI,EAAE,EAAE;QAC/D,MAAM,YAAY,GAAkB,CAAC,MAAM,CAAC,cAAc,CAAC,GAAG,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,CAAkB,CAAC;QAC7G,IAAI,IAAI,GAAgB,IAAI,CAAC;QAC7B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAC1C,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE;gBAC9B,IAAI,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;gBACvB,MAAM;aACT;SACJ;QAED,IAAI,IAAI,EAAE;YACN,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,CAAC;SAC3C;IACL,CAAC,CAAC,CAAC;AACP,CAAC,CAAC"}

ElectronNET.Host/api/menu.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"menu.js","sourceRoot":"","sources":["menu.ts"],"names":[],"mappings":";AACA,uCAA+C;AAC/C,MAAM,gBAAgB,GAAG,CAAC,MAAM,CAAC,kBAAkB,CAAC,GAAG,MAAM,CAAC,kBAAkB,CAAC,IAAI,EAAE,CAAC,CAAC;AACzF,IAAI,cAAc,CAAC;AAEnB,iBAAS,CAAC,MAAc,EAAE,EAAE;IACxB,cAAc,GAAG,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,CAAC,qBAAqB,EAAE,CAAC,eAAe,EAAE,SAAS,EAAE,EAAE;QAC5D,MAAM,IAAI,GAAG,eAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;QAE/C,gCAAgC,CAAC,IAAI,CAAC,KAAK,EAAE,eAAe,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,EAAE;YAC3E,cAAc,CAAC,IAAI,CAAC,wBAAwB,EAAE,CAAC,EAAE,EAAE,QAAQ,CAAC,CAAC,CAAC;QAClE,CAAC,CAAC,CAAC;QAEH,MAAM,KAAK,GAAG,gBAAgB,CAAC,SAAS,CAAC,WAAW,CAAC,EAAE,CAAC,WAAW,CAAC,eAAe,KAAK,eAAe,CAAC,CAAC;QAEzG,MAAM,eAAe,GAAG;YACpB,IAAI,EAAE,IAAI;YACV,eAAe,EAAE,eAAe;SACnC,CAAC;QAEF,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE;YACd,gBAAgB,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;SAC1C;aAAM;YACH,gBAAgB,CAAC,KAAK,CAAC,GAAG,eAAe,CAAC;SAC7C;IACL,CAAC,CAAC,CAAC;IAEH,SAAS,gCAAgC,CAAC,SAAS,EAAE,eAAe,EAAE,QAAQ;QAC1E,SAAS,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;YACvB,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE;gBAC/C,gCAAgC,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,eAAe,EAAE,QAAQ,CAAC,CAAC;aACnF;YAED,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,CAAC,EAAE,EAAE;gBACzB,IAAI,CAAC,KAAK,GAAG,GAAG,EAAE,GAAG,QAAQ,CAAC,IAAI,CAAC,EAAE,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;aAC9D;QACL,CAAC,CAAC,CAAC;IACP,CAAC;IAED,MAAM,CAAC,EAAE,CAAC,uBAAuB,EAAE,CAAC,eAAe,EAAE,EAAE;QACnD,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE;YACzB,IAAI,CAAC,CAAC,eAAe,KAAK,eAAe,EAAE;gBACvC,MAAM,aAAa,GAAG,wBAAa,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;gBAC5D,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;aAC/B;QACL,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,yBAAyB,EAAE,CAAC,SAAS,EAAE,EAAE;QAC/C,MAAM,IAAI,GAAG,eAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;QAE/C,yBAAyB,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE;YACzC,cAAc,CAAC,IAAI,CAAC,iBAAiB,EAAE,EAAE,CAAC,CAAC;QAC/C,CAAC,CAAC,CAAC;QAEH,eAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;IAClC,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;gBAC/C,yBAAyB,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;aAC3D;YAED,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,CAAC,EAAE,EAAE;gBACzB,IAAI,CAAC,KAAK,GAAG,GAAG,EAAE,GAAG,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;aAC7C;QACL,CAAC,CAAC,CAAC;IACP,CAAC;AACL,CAAC,CAAC"}

ElectronNET.Host/api/notification.js.map

@@ -1 +0,0 @@
-{"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;YAChB,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;SACN;QAED,IAAI,OAAO,CAAC,OAAO,EAAE;YACjB,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;SACN;QAED,IAAI,OAAO,CAAC,OAAO,EAAE;YACjB,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;SACN;QAED,IAAI,OAAO,CAAC,OAAO,EAAE;YACjB,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;SACN;QAED,IAAI,OAAO,CAAC,QAAQ,EAAE;YAClB,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;SACN;QAED,IAAI,SAAS,EAAE;YACX,aAAa,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;SACpC;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,CAAC;QAC7C,cAAc,CAAC,IAAI,CAAC,iCAAiC,EAAE,WAAW,CAAC,CAAC;IACxE,CAAC,CAAC,CAAC;AACP,CAAC,CAAC"}

ElectronNET.Host/api/powerMonitor.js

@@ -1,42 +0,0 @@
-"use strict";
-const electron_1 = require("electron");
-let electronSocket;
-module.exports = (socket) => {
-    electronSocket = socket;
-    socket.on('register-pm-lock-screen', () => {
-        electron_1.powerMonitor.on('lock-screen', () => {
-            electronSocket.emit('pm-lock-screen');
-        });
-    });
-    socket.on('register-pm-unlock-screen', () => {
-        electron_1.powerMonitor.on('unlock-screen', () => {
-            electronSocket.emit('pm-unlock-screen');
-        });
-    });
-    socket.on('register-pm-suspend', () => {
-        electron_1.powerMonitor.on('suspend', () => {
-            electronSocket.emit('pm-suspend');
-        });
-    });
-    socket.on('register-pm-resume', () => {
-        electron_1.powerMonitor.on('resume', () => {
-            electronSocket.emit('pm-resume');
-        });
-    });
-    socket.on('register-pm-on-ac', () => {
-        electron_1.powerMonitor.on('on-ac', () => {
-            electronSocket.emit('pm-on-ac');
-        });
-    });
-    socket.on('register-pm-on-battery', () => {
-        electron_1.powerMonitor.on('on-battery', () => {
-            electronSocket.emit('pm-on-battery');
-        });
-    });
-    socket.on('register-pm-shutdown', () => {
-        electron_1.powerMonitor.on('shutdown', () => {
-            electronSocket.emit('pm-shutdown');
-        });
-    });
-};
-//# sourceMappingURL=powerMonitor.js.map

ElectronNET.Host/api/powerMonitor.js.map

@@ -1 +0,0 @@
-{"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,yBAAyB,EAAE,GAAG,EAAE;QACtC,uBAAY,CAAC,EAAE,CAAC,aAAa,EAAE,GAAG,EAAE;YAChC,cAAc,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;QAC1C,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IACH,MAAM,CAAC,EAAE,CAAC,2BAA2B,EAAE,GAAG,EAAE;QACxC,uBAAY,CAAC,EAAE,CAAC,eAAe,EAAE,GAAG,EAAE;YAClC,cAAc,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;QAC5C,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IACH,MAAM,CAAC,EAAE,CAAC,qBAAqB,EAAE,GAAG,EAAE;QAClC,uBAAY,CAAC,EAAE,CAAC,SAAS,EAAE,GAAG,EAAE;YAC5B,cAAc,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACtC,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IACH,MAAM,CAAC,EAAE,CAAC,oBAAoB,EAAE,GAAG,EAAE;QACjC,uBAAY,CAAC,EAAE,CAAC,QAAQ,EAAE,GAAG,EAAE;YAC3B,cAAc,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QACrC,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IACH,MAAM,CAAC,EAAE,CAAC,mBAAmB,EAAE,GAAG,EAAE;QAChC,uBAAY,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE;YAC1B,cAAc,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QACpC,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IACH,MAAM,CAAC,EAAE,CAAC,wBAAwB,EAAE,GAAG,EAAE;QACrC,uBAAY,CAAC,EAAE,CAAC,YAAY,EAAE,GAAG,EAAE;YAC/B,cAAc,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QACzC,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IACH,MAAM,CAAC,EAAE,CAAC,sBAAsB,EAAE,GAAG,EAAE;QACnC,uBAAY,CAAC,EAAE,CAAC,UAAU,EAAE,GAAG,EAAE;YAC7B,cAAc,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QACvC,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;AACP,CAAC,CAAC"}

ElectronNET.Host/api/powerMonitor.ts

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