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
@@ -260,3 +260,10 @@ paket-files/
 # Python Tools for Visual Studio (PTVS)
 __pycache__/
 *.pyc
+
+# 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.0
-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,206 +1,104 @@
-# Not released
-
-# 7.30.3
-
-# Released
-
-# 7.30.2
-
-ElectronNET.CLI:
-
-* 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`.
-
-* 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,505 +0,0 @@
-using ElectronNET.API.Entities;
-using Newtonsoft.Json.Linq;
-using System;
-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>
-        /// Get the update channel. Not applicable for GitHub. 
-        /// Doesn’t return channel from the update configuration, only if was previously set.
-        /// </summary>
-        public string Channel
-        {
-            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;
-                }).Result;
-            }
-        }
-
-        /// <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) =>
-            {
-                BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesComplete" + guid);
-                taskCompletionSource.SetResult(JObject.Parse(updateCheckResult.ToString()).ToObject<UpdateCheckResult>());
-            });
-
-            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) =>
-            {
-                BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesAndNotifyComplete" + guid);
-                taskCompletionSource.SetResult(JObject.Parse(updateCheckResult.ToString()).ToObject<UpdateCheckResult>());
-            });
-
-            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;
-        }
-    }
-}

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/Electron.cs

@@ -1,77 +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; } }
-    }
-}

ElectronNET.API/ElectronNET.API.csproj

@@ -1,46 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFramework>netcoreapp3.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-beta2-19367-01">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
-    </PackageReference>
-    <PackageReference Include="SocketIoClientDotNet" Version="1.0.5" />
-  </ItemGroup>
-
-</Project>

ElectronNET.API/Entities/AboutPanelOptions.cs

@@ -1,33 +0,0 @@
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public class AboutPanelOptions
-    {
-        /// <summary>
-        /// The app's name.
-        /// </summary>
-        public string ApplicationName { get; set; }
-
-        /// <summary>
-        /// The app's version.
-        /// </summary>
-        public string ApplicationVersion { get; set; }
-
-        /// <summary>
-        /// Copyright information.
-        /// </summary>
-        public string Copyright { get; set; }
-
-        /// <summary>
-        /// Credit information.
-        /// </summary>
-        public string Credits { get; set; }
-
-        /// <summary>
-        /// The app's build version number.
-        /// </summary>
-        public string Version { get; set; }
-    }
-}

ElectronNET.API/Entities/CPUUsage.cs

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

ElectronNET.API/Entities/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/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/DockBounceType.cs

@@ -1,18 +0,0 @@
-namespace ElectronNET.API
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public enum DockBounceType
-    {
-        /// <summary>
-        /// The critical
-        /// </summary>
-        critical,
-
-        /// <summary>
-        /// The informational
-        /// </summary>
-        informational
-    }
-}

ElectronNET.API/Entities/Error.cs

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

ElectronNET.API/Entities/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/JumpListCategory.cs

@@ -1,28 +0,0 @@
-using ElectronNET.API.Entities;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Converters;
-
-namespace ElectronNET.API
-{
-    /// <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/JumpListSettings.cs

@@ -1,18 +0,0 @@
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public class JumpListSettings
-    {
-        /// <summary>
-        /// The minimum number of items that will be shown in the Jump List (for a more detailed description of this value see the MSDN docs).
-        /// </summary>
-        public int MinItems { get; set; } = 0;
-
-        /// <summary>
-        /// Array of JumpListItem objects that correspond to items that the user has explicitly removed from custom categories in the Jump List. These items must not be re-added to the Jump List in the next call to app.setJumpList(), Windows will not display any custom category that contains any of the removed items.
-        /// </summary>
-        public JumpListItem[] RemovedItems { get; set; } = new JumpListItem[0];
-    }
-}

ElectronNET.API/Entities/LoadURLOptions.cs

@@ -1,30 +0,0 @@
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public class LoadURLOptions
-    {
-        /// <summary>
-        /// A HTTP Referrer url.
-        /// </summary>
-        public string HttpReferrer { get; set; }
-
-        /// <summary>
-        /// A user agent originating the request.
-        /// </summary>
-        public string UserAgent { get; set; }
-
-        /// <summary>
-        /// Base url (with trailing path separator) for files to be loaded by the data url.
-        /// This is needed only if the specified url is a data url and needs to load other
-        /// files.
-        /// </summary>
-        public string BaseURLForDataURL { get; set; }
-
-        /// <summary>
-        /// Extra headers for the request.
-        /// </summary>
-        public string ExtraHeaders { get; set; }
-    }
-}

ElectronNET.API/Entities/LoginItemSettings.cs

@@ -1,39 +0,0 @@
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public class LoginItemSettings
-    {
-        /// <summary>
-        /// true if the app is set to open at login.
-        /// </summary>
-        public bool OpenAtLogin { get; set; }
-
-        /// <summary>
-        /// true if the app is set to open as hidden at login. This setting is only 
-        /// supported on macOS.
-        /// </summary>
-        public bool OpenAsHidden { get; set; }
-
-        /// <summary>
-        /// true if the app was opened at login automatically. This setting is only 
-        /// supported on macOS.
-        /// </summary>
-        public bool WasOpenedAtLogin { get; set; }
-
-        /// <summary>
-        /// true if the app was opened as a hidden login item. This indicates that the app 
-        /// should not open any windows at startup.This setting is only supported on macOS.
-        /// </summary>
-        public bool WasOpenedAsHidden { get; set; }
-
-        /// <summary>
-        /// true if the app was opened as a login item that should restore the state from
-        /// the previous session.This indicates that the app should restore the windows
-        /// that were open the last time the app was closed.This setting is only supported
-        /// on macOS.
-        /// </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,33 +0,0 @@
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public class LoginSettings
-    {
-        /// <summary>
-        /// true to open the app at login, false to remove the app as a login item. Defaults
-        /// to false.
-        /// </summary>
-        public bool OpenAtLogin { get; set; }
-
-        /// <summary>
-        /// true to open the app as hidden. Defaults to false. The user can edit this
-        /// setting from the System Preferences so
-        /// app.getLoginItemStatus().wasOpenedAsHidden should be checked when the app is
-        /// opened to know the current value.This setting is only supported on macOS.
-        /// </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,36 +0,0 @@
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public class MemoryInfo
-    {
-        /// <summary>
-        /// The maximum amount of memory that has ever been pinned to actual physical RAM. 
-        /// On macOS its value will always be 0.
-        /// </summary>
-        public int PeakWorkingSetSize { get; set; }
-
-        /// <summary>
-        /// Process id of the process.
-        /// </summary>
-        public int Pid { get; set; }
-
-        /// <summary>
-        /// The amount of memory not shared by other processes, such as JS heap or HTML
-        /// content.
-        /// </summary>
-        public int PrivateBytes { get; set; }
-
-        /// <summary>
-        /// The amount of memory shared between processes, typically memory consumed by the 
-        /// Electron code itself
-        /// </summary>
-        public int SharedBytes { get; set; }
-
-        /// <summary>
-        /// The amount of memory currently pinned to actual physical RAM.
-        /// </summary>
-        public int WorkingSetSize {get; set; }
-    }
-}

ElectronNET.API/Entities/MenuItem.cs

@@ -1,105 +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>
-        [DefaultValue(true)]
-        public bool Enabled { get; set; } = true;
-
-        /// <summary>
-        /// If false, the menu item will be entirely hidden.
-        /// </summary>
-        [DefaultValue(true)]
-        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/NativeImage.cs

@@ -1,109 +0,0 @@
-namespace ElectronNET.API.Entities
-{
-    // TODO: Need some of real code :)
-    /// <summary>
-    /// 
-    /// </summary>
-    public class NativeImage
-    {
-        //        public static NativeImage CreateEmpty()
-        //        {
-        //            throw new NotImplementedException();
-        //        }
-
-        //        public static NativeImage CreateFromBuffer(byte[] buffer)
-        //        {
-        //            throw new NotImplementedException();
-        //        }
-
-        //        public static NativeImage CreateFromBuffer(byte[] buffer, CreateFromBufferOptions options)
-        //        {
-        //            throw new NotImplementedException();
-        //        }
-
-        //        public static NativeImage CreateFromDataURL(string dataURL)
-        //        {
-        //            throw new NotImplementedException();
-        //        }
-
-        //        public static NativeImage CreateFromPath(string path)
-        //        {
-        //            throw new NotImplementedException();
-        //        }
-
-        //        public void AddRepresentation(AddRepresentationOptions options)
-        //        {
-        //            throw new NotImplementedException();
-        //        }
-
-        //        public NativeImage Crop(Rectangle rect)
-        //        {
-        //            throw new NotImplementedException();
-        //        }
-
-        //        public int GetAspectRatio()
-        //        {
-        //            throw new NotImplementedException();
-        //        }
-
-        //        public byte[] GetBitmap()
-        //        {
-        //            throw new NotImplementedException();
-        //        }
-
-        //        public byte[] GetBitmap(BitmapOptions options)
-        //        {
-        //            throw new NotImplementedException();
-        //        }
-
-        //        public byte[] GetNativeHandle()
-        //        {
-        //            throw new NotImplementedException();
-        //        }
-
-        //        public Size GetSize()
-        //        {
-        //            throw new NotImplementedException();
-        //        }
-
-        //        public bool IsEmpty()
-        //        {
-        //            throw new NotImplementedException();
-        //        }
-
-        //        public bool IsTemplateImage()
-        //        {
-        //            throw new NotImplementedException();
-        //        }
-
-        //        public NativeImage Resize(ResizeOptions options)
-        //        {
-        //            throw new NotImplementedException();
-        //        }
-
-        //        public void SetTemplateImage(bool option)
-        //        {
-        //            throw new NotImplementedException();
-        //        }
-
-        //        public byte[] ToBitmap(ToBitmapOptions options)
-        //        {
-        //            throw new NotImplementedException();
-        //        }
-
-        //        public string ToDataURL(ToDataURLOptions options)
-        //        {
-        //            throw new NotImplementedException();
-        //        }
-
-        //        public byte[] ToJPEG(int quality)
-        //        {
-        //            throw new NotImplementedException();
-        //        }
-
-        //        public byte[] ToPNG(ToPNGOptions options)
-        //        {
-        //            throw new NotImplementedException();
-        //        }
-    }
-}

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,16 +0,0 @@
-using System.ComponentModel;
-
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public class OpenExternalOptions
-    {
-        /// <summary>
-        /// true to bring the opened application to the foreground. The default is true.
-        /// </summary>
-        [DefaultValue(true)]
-        public bool Activate { get; set; } = true;
-    }
-}

ElectronNET.API/Entities/PathName.cs

@@ -1,79 +0,0 @@
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public enum PathName
-    {
-        /// <summary>
-        /// User’s home directory.
-        /// </summary>
-        home,
-
-        /// <summary>
-        /// Per-user application data directory.
-        /// </summary>
-        appData,
-
-        /// <summary>
-        /// The directory for storing your app’s configuration files, 
-        /// which by default it is the appData directory appended with your app’s name.
-        /// </summary>
-        userData,
-
-        /// <summary>
-        /// Temporary directory.
-        /// </summary>
-        temp,
-
-        /// <summary>
-        /// The current executable file.
-        /// </summary>
-        exe,
-
-        /// <summary>
-        /// The libchromiumcontent library.
-        /// </summary>
-        module,
-
-        /// <summary>
-        /// The current user’s Desktop directory.
-        /// </summary>
-        desktop,
-
-        /// <summary>
-        /// Directory for a user’s “My Documents”.
-        /// </summary>
-        documents,
-
-        /// <summary>
-        /// Directory for a user’s downloads.
-        /// </summary>
-        downloads,
-
-        /// <summary>
-        /// Directory for a user’s music.
-        /// </summary>
-        music,
-
-        /// <summary>
-        /// Directory for a user’s pictures.
-        /// </summary>
-        pictures,
-
-        /// <summary>
-        /// Directory for a user’s videos.
-        /// </summary>
-        videos,
-
-        /// <summary>
-        /// The logs
-        /// </summary>
-        logs,
-
-        /// <summary>
-        /// Full path to the system version of the Pepper Flash plugin.
-        /// </summary>
-        pepperFlashSystemPlugin
-    }
-}

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/ProcessMetric.cs

@@ -1,28 +0,0 @@
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public class ProcessMetric
-    {
-      /// <summary>
-      /// CPU usage of the process.
-      /// </summary>
-      public CPUUsage Cpu { get; set; }
-
-      /// <summary>
-      /// Memory information for the process.
-      /// </summary>
-      public MemoryInfo Memory {get; set;}
-
-      /// <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; }
-    }
-}

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/RemoveClientCertificate.cs

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

ElectronNET.API/Entities/ShortcutDetails.cs

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

ElectronNET.API/Entities/Vibrancy.cs

@@ -1,63 +0,0 @@
-using Newtonsoft.Json;
-
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public enum Vibrancy
-    {
-        /// <summary>
-        /// The appearance based
-        /// </summary>
-        [JsonProperty("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>
-        [JsonProperty("medium-light")]
-        mediumLight,
-
-        /// <summary>
-        /// The ultra dark
-        /// </summary>
-        [JsonProperty("ultra-dark")]
-        ultraDark
-    }
-}

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,189 +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);
-            }
-        }
-
-        private JsonSerializer _jsonSerializer = new JsonSerializer()
-        {
-            ContractResolver = new CamelCasePropertyNamesContractResolver(),
-            NullValueHandling = NullValueHandling.Ignore,
-            DefaultValueHandling = DefaultValueHandling.Ignore
-        };
-    }
-}

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/Shell.cs

@@ -1,251 +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>
-    /// Manage files and URLs using their default applications.
-    /// </summary>
-    public sealed class Shell
-    {
-        private static Shell _shell;
-        private static object _syncRoot = new object();
-
-        internal Shell() { }
-
-        internal static Shell Instance
-        {
-            get
-            {
-                if (_shell == null)
-                {
-                    lock (_syncRoot)
-                    {
-                        if (_shell == null)
-                        {
-                            _shell = new Shell();
-                        }
-                    }
-                }
-
-                return _shell;
-            }
-        }
-
-        /// <summary>
-        /// Show the given file in a file manager. If possible, select the file.
-        /// </summary>
-        /// <param name="fullPath"></param>
-        /// <returns>Whether the item was successfully shown.</returns>
-        public Task<bool> ShowItemInFolderAsync(string fullPath)
-        {
-            var taskCompletionSource = new TaskCompletionSource<bool>();
-
-            BridgeConnector.Socket.On("shell-showItemInFolderCompleted", (success) =>
-            {
-                BridgeConnector.Socket.Off("shell-showItemInFolderCompleted");
-
-                taskCompletionSource.SetResult((bool)success);
-            });
-
-            BridgeConnector.Socket.Emit("shell-showItemInFolder", fullPath);
-
-            return taskCompletionSource.Task;
-        }
-
-        /// <summary>
-        /// Open the given file in the desktop’s default manner.
-        /// </summary>
-        /// <param name="fullPath"></param>
-        /// <returns>Whether the item was successfully opened.</returns>
-        public Task<bool> OpenItemAsync(string fullPath)
-        {
-            var taskCompletionSource = new TaskCompletionSource<bool>();
-
-            BridgeConnector.Socket.On("shell-openItemCompleted", (success) =>
-            {
-                BridgeConnector.Socket.Off("shell-openItemCompleted");
-
-                taskCompletionSource.SetResult((bool)success);
-            });
-
-            BridgeConnector.Socket.Emit("shell-openItem", fullPath);
-
-            return taskCompletionSource.Task;
-        }
-
-        /// <summary>
-        /// Open the given external protocol URL in the desktop’s default manner. 
-        /// (For example, mailto: URLs in the user’s default mail agent).
-        /// </summary>
-        /// <param name="url"></param>
-        /// <returns>Whether an application was available to open the URL. 
-        /// If callback is specified, always returns true.</returns>
-        public Task<bool> OpenExternalAsync(string url)
-        {
-            var taskCompletionSource = new TaskCompletionSource<bool>();
-
-            BridgeConnector.Socket.On("shell-openExternalCompleted", (success) =>
-            {
-                BridgeConnector.Socket.Off("shell-openExternalCompleted");
-
-                taskCompletionSource.SetResult((bool)success);
-            });
-
-            BridgeConnector.Socket.Emit("shell-openExternal", url);
-
-            return taskCompletionSource.Task;
-        }
-
-        /// <summary>
-        /// Open the given external protocol URL in the desktop’s default manner. 
-        /// (For example, mailto: URLs in the user’s default mail agent).
-        /// </summary>
-        /// <param name="url"></param>
-        /// <param name="options">macOS only</param>
-        /// <returns>Whether an application was available to open the URL. 
-        /// If callback is specified, always returns true.</returns>
-        public Task<bool> OpenExternalAsync(string url, OpenExternalOptions options)
-        {
-            var taskCompletionSource = new TaskCompletionSource<bool>();
-
-            BridgeConnector.Socket.On("shell-openExternalCompleted", (success) =>
-            {
-                BridgeConnector.Socket.Off("shell-openExternalCompleted");
-
-                taskCompletionSource.SetResult((bool)success);
-            });
-
-            BridgeConnector.Socket.Emit("shell-openExternal", url, JObject.FromObject(options, _jsonSerializer));
-
-            return taskCompletionSource.Task;
-        }
-
-        /// <summary>
-        /// Open the given external protocol URL in the desktop’s default manner. 
-        /// (For example, mailto: URLs in the user’s default mail agent).
-        /// </summary>
-        /// <param name="url"></param>
-        /// <param name="options">macOS only</param>
-        /// <param name="errorAction">Action to get the error message.</param>
-        /// <returns>Whether an application was available to open the URL. 
-        /// If callback is specified, always returns true.</returns>
-        public Task<bool> OpenExternalAsync(string url, OpenExternalOptions options, Action<Error> errorAction)
-        {
-            var taskCompletionSource = new TaskCompletionSource<bool>();
-
-            BridgeConnector.Socket.On("shell-openExternalCompleted", (success) =>
-            {
-                BridgeConnector.Socket.Off("shell-openExternalCompleted");
-
-                taskCompletionSource.SetResult((bool)success);
-            });
-
-            BridgeConnector.Socket.Off("shell-openExternalCallback");
-            BridgeConnector.Socket.On("shell-openExternalCallback", (args) => {
-                var urlKey = ((JArray)args).First.ToString();
-                var error = ((JArray)args).Last.ToObject<Error>();
-
-                if(_openExternalCallbacks.ContainsKey(urlKey))
-                {
-                    _openExternalCallbacks[urlKey](error);
-                }
-            });
-
-            _openExternalCallbacks.Add(url, errorAction);
-
-            BridgeConnector.Socket.Emit("shell-openExternal", url, JObject.FromObject(options, _jsonSerializer), true);
-
-            return taskCompletionSource.Task;
-        }
-
-        private Dictionary<string, Action<Error>> _openExternalCallbacks = new Dictionary<string, Action<Error>>();
-
-        /// <summary>
-        /// Move the given file to trash and returns a boolean status for the operation.
-        /// </summary>
-        /// <param name="fullPath"></param>
-        /// <returns> Whether the item was successfully moved to the trash.</returns>
-        public Task<bool> MoveItemToTrashAsync(string fullPath)
-        {
-            var taskCompletionSource = new TaskCompletionSource<bool>();
-
-            BridgeConnector.Socket.On("shell-moveItemToTrashCompleted", (success) =>
-            {
-                BridgeConnector.Socket.Off("shell-moveItemToTrashCompleted");
-
-                taskCompletionSource.SetResult((bool)success);
-            });
-
-            BridgeConnector.Socket.Emit("shell-moveItemToTrash", fullPath);
-
-            return taskCompletionSource.Task;
-        }
-
-        /// <summary>
-        /// Play the beep sound.
-        /// </summary>
-        public void Beep()
-        {
-            BridgeConnector.Socket.Emit("shell-beep");
-        }
-
-        /// <summary>
-        /// Creates or updates a shortcut link at shortcutPath.
-        /// </summary>
-        /// <param name="shortcutPath"></param>
-        /// <param name="operation"></param>
-        /// <param name="options"></param>
-        /// <returns>Whether the shortcut was created successfully.</returns>
-        public Task<bool> WriteShortcutLinkAsync(string shortcutPath, ShortcutLinkOperation operation, ShortcutDetails options)
-        {
-            var taskCompletionSource = new TaskCompletionSource<bool>();
-
-            BridgeConnector.Socket.On("shell-writeShortcutLinkCompleted", (success) =>
-            {
-                BridgeConnector.Socket.Off("shell-writeShortcutLinkCompleted");
-
-                taskCompletionSource.SetResult((bool)success);
-            });
-
-            BridgeConnector.Socket.Emit("shell-writeShortcutLink", shortcutPath, operation.ToString(), JObject.FromObject(options, _jsonSerializer));
-
-            return taskCompletionSource.Task;
-        }
-
-        /// <summary>
-        /// Resolves the shortcut link at shortcutPath.
-        /// 
-        /// An exception will be thrown when any error happens.
-        /// </summary>
-        /// <param name="shortcutPath"></param>
-        /// <returns></returns>
-        public Task<ShortcutDetails> ReadShortcutLinkAsync(string shortcutPath)
-        {
-            var taskCompletionSource = new TaskCompletionSource<ShortcutDetails>();
-
-            BridgeConnector.Socket.On("shell-readShortcutLinkCompleted", (shortcutDetails) =>
-            {
-                BridgeConnector.Socket.Off("shell-readShortcutLinkCompleted");
-
-                taskCompletionSource.SetResult((ShortcutDetails)shortcutDetails);
-            });
-
-            BridgeConnector.Socket.Emit("shell-readShortcutLink", shortcutPath);
-
-            return taskCompletionSource.Task;
-        }
-
-        private JsonSerializer _jsonSerializer = new JsonSerializer()
-        {
-            ContractResolver = new CamelCasePropertyNamesContractResolver(),
-            NullValueHandling = NullValueHandling.Ignore,
-            DefaultValueHandling = DefaultValueHandling.Ignore
-        };
-    }
-}

ElectronNET.API/Tray.cs

@@ -1,346 +0,0 @@
-using ElectronNET.API.Entities;
-using ElectronNET.API.Extensions;
-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>
-    /// Add icons and context menus to the system's notification area.
-    /// </summary>
-    public sealed class Tray
-    {
-        /// <summary>
-        /// Emitted when the tray icon is clicked.
-        /// </summary>
-        public event Action<TrayClickEventArgs, Rectangle> OnClick
-        {
-            add
-            {
-                if (_click == null)
-                {
-                    BridgeConnector.Socket.On("tray-click-event" + GetHashCode(), (result) =>
-                    {
-                        var args = ((JArray)result).ToObject<object[]>();
-                        var trayClickEventArgs = ((JObject)args[0]).ToObject<TrayClickEventArgs>();
-                        var bounds = ((JObject)args[1]).ToObject<Rectangle>();
-                        _click(trayClickEventArgs, bounds);
-                    });
-
-                    BridgeConnector.Socket.Emit("register-tray-click", GetHashCode());
-                }
-                _click += value;
-            }
-            remove
-            {
-                _click -= value;
-
-                if (_click == null)
-                    BridgeConnector.Socket.Off("tray-click-event" + GetHashCode());
-            }
-        }
-
-        private event Action<TrayClickEventArgs, Rectangle> _click;
-
-        /// <summary>
-        /// macOS, Windows: Emitted when the tray icon is right clicked.
-        /// </summary>
-        public event Action<TrayClickEventArgs, Rectangle> OnRightClick
-        {
-            add
-            {
-                if (_rightClick == null)
-                {
-                    BridgeConnector.Socket.On("tray-right-click-event" + GetHashCode(), (result) =>
-                    {
-                        var args = ((JArray)result).ToObject<object[]>();
-                        var trayClickEventArgs = ((JObject)args[0]).ToObject<TrayClickEventArgs>();
-                        var bounds = ((JObject)args[1]).ToObject<Rectangle>();
-                        _rightClick(trayClickEventArgs, bounds);
-                    });
-
-                    BridgeConnector.Socket.Emit("register-tray-right-click", GetHashCode());
-                }
-                _rightClick += value;
-            }
-            remove
-            {
-                _rightClick -= value;
-
-                if (_rightClick == null)
-                    BridgeConnector.Socket.Off("tray-right-click-event" + GetHashCode());
-            }
-        }
-
-        private event Action<TrayClickEventArgs, Rectangle> _rightClick;
-
-        /// <summary>
-        /// macOS, Windows: Emitted when the tray icon is double clicked.
-        /// </summary>
-        public event Action<TrayClickEventArgs, Rectangle> OnDoubleClick
-        {
-            add
-            {
-                if (_doubleClick == null)
-                {
-                    BridgeConnector.Socket.On("tray-double-click-event" + GetHashCode(), (result) =>
-                    {
-                        var args = ((JArray)result).ToObject<object[]>();
-                        var trayClickEventArgs = ((JObject)args[0]).ToObject<TrayClickEventArgs>();
-                        var bounds = ((JObject)args[1]).ToObject<Rectangle>();
-                        _doubleClick(trayClickEventArgs, bounds);
-                    });
-
-                    BridgeConnector.Socket.Emit("register-tray-double-click", GetHashCode());
-                }
-                _doubleClick += value;
-            }
-            remove
-            {
-                _doubleClick -= value;
-
-                if (_doubleClick == null)
-                    BridgeConnector.Socket.Off("tray-double-click-event" + GetHashCode());
-            }
-        }
-
-        private event Action<TrayClickEventArgs, Rectangle> _doubleClick;
-
-        /// <summary>
-        /// Windows: Emitted when the tray balloon shows.
-        /// </summary>
-        public event Action OnBalloonShow
-        {
-            add
-            {
-                if (_balloonShow == null)
-                {
-                    BridgeConnector.Socket.On("tray-balloon-show-event" + GetHashCode(), () =>
-                    {
-                        _balloonShow();
-                    });
-
-                    BridgeConnector.Socket.Emit("register-tray-balloon-show", GetHashCode());
-                }
-                _balloonShow += value;
-            }
-            remove
-            {
-                _balloonShow -= value;
-
-                if (_balloonShow == null)
-                    BridgeConnector.Socket.Off("tray-balloon-show-event" + GetHashCode());
-            }
-        }
-
-        private event Action _balloonShow;
-
-        /// <summary>
-        /// Windows: Emitted when the tray balloon is clicked.
-        /// </summary>
-        public event Action OnBalloonClick
-        {
-            add
-            {
-                if (_balloonClick == null)
-                {
-                    BridgeConnector.Socket.On("tray-balloon-click-event" + GetHashCode(), () =>
-                    {
-                        _balloonClick();
-                    });
-
-                    BridgeConnector.Socket.Emit("register-tray-balloon-click", GetHashCode());
-                }
-                _balloonClick += value;
-            }
-            remove
-            {
-                _balloonClick -= value;
-
-                if (_balloonClick == null)
-                    BridgeConnector.Socket.Off("tray-balloon-click-event" + GetHashCode());
-            }
-        }
-
-        private event Action _balloonClick;
-
-        /// <summary>
-        /// Windows: Emitted when the tray balloon is closed 
-        /// because of timeout or user manually closes it.
-        /// </summary>
-        public event Action OnBalloonClosed
-        {
-            add
-            {
-                if (_balloonClosed == null)
-                {
-                    BridgeConnector.Socket.On("tray-balloon-closed-event" + GetHashCode(), () =>
-                    {
-                        _balloonClosed();
-                    });
-
-                    BridgeConnector.Socket.Emit("register-tray-balloon-closed", GetHashCode());
-                }
-                _balloonClosed += value;
-            }
-            remove
-            {
-                _balloonClosed -= value;
-
-                if (_balloonClosed == null)
-                    BridgeConnector.Socket.Off("tray-balloon-closed-event" + GetHashCode());
-            }
-        }
-
-        private event Action _balloonClosed;
-
-        // TODO: Implement macOS Events
-
-        private static Tray _tray;
-        private static object _syncRoot = new object();
-
-        internal Tray() { }
-
-        internal static Tray Instance
-        {
-            get
-            {
-                if (_tray == null)
-                {
-                    lock (_syncRoot)
-                    {
-                        if (_tray == null)
-                        {
-                            _tray = new Tray();
-                        }
-                    }
-                }
-
-                return _tray;
-            }
-        }
-
-        /// <summary>
-        /// Gets the menu items.
-        /// </summary>
-        /// <value>
-        /// The menu items.
-        /// </value>
-        public IReadOnlyCollection<MenuItem> MenuItems { get { return _items.AsReadOnly(); } }
-        private List<MenuItem> _items = new List<MenuItem>();
-
-        /// <summary>
-        /// Shows the Traybar.
-        /// </summary>
-        /// <param name="image">The image.</param>
-        /// <param name="menuItem">The menu item.</param>
-        public void Show(string image, MenuItem menuItem)
-        {
-            Show(image, new MenuItem[] { menuItem });
-        }
-
-        /// <summary>
-        /// Shows the Traybar.
-        /// </summary>
-        /// <param name="image">The image.</param>
-        /// <param name="menuItems">The menu items.</param>
-        public void Show(string image, MenuItem[] menuItems)
-        {
-            menuItems.AddMenuItemsId();
-            BridgeConnector.Socket.Emit("create-tray", image, JArray.FromObject(menuItems, _jsonSerializer));
-            _items.AddRange(menuItems);
-
-            BridgeConnector.Socket.Off("trayMenuItemClicked");
-            BridgeConnector.Socket.On("trayMenuItemClicked", (id) =>
-            {
-                MenuItem menuItem = _items.GetMenuItem(id.ToString());
-                menuItem?.Click();
-            });
-        }
-
-        /// <summary>
-        /// Destroys the tray icon immediately.
-        /// </summary>
-        public void Destroy()
-        {
-            BridgeConnector.Socket.Emit("tray-destroy");
-            _items.Clear();
-        }
-
-        /// <summary>
-        /// Sets the image associated with this tray icon.
-        /// </summary>
-        /// <param name="image"></param>
-        public void SetImage(string image)
-        {
-            BridgeConnector.Socket.Emit("tray-setImage", image);
-        }
-
-        /// <summary>
-        /// Sets the image associated with this tray icon when pressed on macOS.
-        /// </summary>
-        /// <param name="image"></param>
-        public void SetPressedImage(string image)
-        {
-            BridgeConnector.Socket.Emit("tray-setPressedImage", image);
-        }
-
-        /// <summary>
-        /// Sets the hover text for this tray icon.
-        /// </summary>
-        /// <param name="toolTip"></param>
-        public void SetToolTip(string toolTip)
-        {
-            BridgeConnector.Socket.Emit("tray-setToolTip", toolTip);
-        }
-
-        /// <summary>
-        /// macOS: Sets the title displayed aside of the tray icon in the status bar.
-        /// </summary>
-        /// <param name="title"></param>
-        public void SetTitle(string title)
-        {
-            BridgeConnector.Socket.Emit("tray-setTitle", title);
-        }
-
-        /// <summary>
-        /// Windows: Displays a tray balloon.
-        /// </summary>
-        /// <param name="options"></param>
-        public void DisplayBalloon(DisplayBalloonOptions options)
-        {
-            BridgeConnector.Socket.Emit("tray-displayBalloon", JObject.FromObject(options, _jsonSerializer));
-        }
-
-        /// <summary>
-        /// Whether the tray icon is destroyed.
-        /// </summary>
-        /// <returns></returns>
-        public Task<bool> IsDestroyedAsync()
-        {
-            var taskCompletionSource = new TaskCompletionSource<bool>();
-
-            BridgeConnector.Socket.On("tray-isDestroyedCompleted", (isDestroyed) =>
-            {
-                BridgeConnector.Socket.Off("tray-isDestroyedCompleted");
-
-                taskCompletionSource.SetResult((bool)isDestroyed);
-            });
-
-            BridgeConnector.Socket.Emit("tray-isDestroyed");
-
-            return taskCompletionSource.Task;
-        }
-
-        private JsonSerializer _jsonSerializer = new JsonSerializer()
-        {
-            ContractResolver = new CamelCasePropertyNamesContractResolver(),
-            NullValueHandling = NullValueHandling.Ignore,
-            DefaultValueHandling = DefaultValueHandling.Ignore
-        };
-    }
-}

ElectronNET.API/WebContents.cs

@@ -1,169 +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>
-        /// 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;
-        }
-        
-        private JsonSerializer _jsonSerializer = new JsonSerializer()
-        {
-            ContractResolver = new CamelCasePropertyNamesContractResolver(),
-            NullValueHandling = NullValueHandling.Ignore,
-            DefaultValueHandling = DefaultValueHandling.Ignore
-        };
-    }
-}

ElectronNET.API/WebHostBuilderExtensions.cs

@@ -1,40 +0,0 @@
-using Microsoft.AspNetCore.Hosting;
-using System;
-
-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.UseContentRoot(AppDomain.CurrentDomain.BaseDirectory)
-                    .UseUrls("http://127.0.0.1:" + BridgeSettings.WebPort);
-            }
-
-            return builder;
-        }
-    }
-}

ElectronNET.API/WindowManager.cs

@@ -1,165 +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.Linq;
-using System.Runtime.InteropServices;
-using System.Threading.Tasks;
-
-namespace ElectronNET.API
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public sealed class WindowManager
-    {
-        private static WindowManager _windowManager;
-        private static object _syncRoot = new object();
-
-        internal WindowManager() { }
-
-        internal static WindowManager Instance
-        {
-            get
-            {
-                if (_windowManager == null)
-                {
-                    lock (_syncRoot)
-                    {
-                        if (_windowManager == null)
-                        {
-                            _windowManager = new WindowManager();
-                        }
-                    }
-                }
-
-                return _windowManager;
-            }
-        }
-
-        /// <summary>
-        /// Quit when all windows are closed. (Default is true)
-        /// </summary>
-        /// <value>
-        ///   <c>true</c> if [quit window all closed]; otherwise, <c>false</c>.
-        /// </value>
-        public bool IsQuitOnWindowAllClosed
-        {
-            get { return _isQuitOnWindowAllClosed; }
-            set
-            {
-                BridgeConnector.Socket.Emit("quit-app-window-all-closed-event", value);
-                _isQuitOnWindowAllClosed = value;
-            }
-        }
-        private bool _isQuitOnWindowAllClosed = true;
-
-        /// <summary>
-        /// Gets the browser windows.
-        /// </summary>
-        /// <value>
-        /// The browser windows.
-        /// </value>
-        public IReadOnlyCollection<BrowserWindow> BrowserWindows { get { return _browserWindows.AsReadOnly(); } }
-        private List<BrowserWindow> _browserWindows = new List<BrowserWindow>();
-
-        /// <summary>
-        /// Creates the window asynchronous.
-        /// </summary>
-        /// <param name="loadUrl">The load URL.</param>
-        /// <returns></returns>
-        public async Task<BrowserWindow> CreateWindowAsync(string loadUrl = "http://localhost")
-        {
-            return await CreateWindowAsync(new BrowserWindowOptions(), loadUrl);
-        }
-
-        /// <summary>
-        /// Creates the window asynchronous.
-        /// </summary>
-        /// <param name="options">The options.</param>
-        /// <param name="loadUrl">The load URL.</param>
-        /// <returns></returns>
-        public Task<BrowserWindow> CreateWindowAsync(BrowserWindowOptions options, string loadUrl = "http://localhost")
-        {
-            var taskCompletionSource = new TaskCompletionSource<BrowserWindow>();
-
-            BridgeConnector.Socket.On("BrowserWindowCreated", (id) =>
-            {
-                BridgeConnector.Socket.Off("BrowserWindowCreated");
-
-                string windowId = id.ToString();
-                BrowserWindow browserWindow = new BrowserWindow(int.Parse(windowId));
-                _browserWindows.Add(browserWindow);
-
-                taskCompletionSource.SetResult(browserWindow);
-            });
-
-            BridgeConnector.Socket.Off("BrowserWindowClosed");
-            BridgeConnector.Socket.On("BrowserWindowClosed", (ids) =>
-            {
-                var browserWindowIds = ((JArray)ids).ToObject<int[]>();
-
-                for (int index = 0; index < _browserWindows.Count; index++)
-                {
-                    if (!browserWindowIds.Contains(_browserWindows[index].Id))
-                    {
-                        _browserWindows.RemoveAt(index);
-                    }
-                }
-            });
-
-            if (loadUrl.ToUpper() == "HTTP://LOCALHOST")
-            {
-                loadUrl = $"{loadUrl}:{BridgeSettings.WebPort}";
-            }
-
-            // Workaround Windows 10 / Electron Bug
-            // https://github.com/electron/electron/issues/4045
-            if (isWindows10())
-            {
-                options.Width = options.Width + 14;
-                options.Height = options.Height + 7;
-            }
-
-            if (options.X == -1 && options.Y == -1)
-            {
-                options.X = 0;
-                options.Y = 0;
-
-                BridgeConnector.Socket.Emit("createBrowserWindow", JObject.FromObject(options, _jsonSerializer), loadUrl);
-            }
-            else
-            {
-                // Workaround Windows 10 / Electron Bug
-                // https://github.com/electron/electron/issues/4045
-                if (isWindows10())
-                {
-                    options.X = options.X - 7;
-                }
-
-                var ownjsonSerializer = new JsonSerializer()
-                {
-                    ContractResolver = new CamelCasePropertyNamesContractResolver(),
-                    NullValueHandling = NullValueHandling.Ignore
-                };
-                BridgeConnector.Socket.Emit("createBrowserWindow", JObject.FromObject(options, ownjsonSerializer), loadUrl);
-            }
-
-            return taskCompletionSource.Task;
-        }
-
-        private bool isWindows10()
-        {
-            return RuntimeInformation.OSDescription.Contains("Windows 10");
-        }
-
-        private JsonSerializer _jsonSerializer = new JsonSerializer()
-        {
-            ContractResolver = new CamelCasePropertyNamesContractResolver(),
-            NullValueHandling = NullValueHandling.Ignore,
-            DefaultValueHandling = DefaultValueHandling.Ignore
-        };
-    }
-}

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,41 +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, "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.");
-
-            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,136 +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
-                Console.WriteLine($"Search your .csproj to add configure CopyToPublishDirectory to 'Never'");
-                var projectFile = Directory.EnumerateFiles(currentDirectory, "*.csproj", SearchOption.TopDirectoryOnly).FirstOrDefault();
-
-                Console.WriteLine($"Found your .csproj: {projectFile} - check for existing CopyToPublishDirectory setting or update it.");
-
-                if (!EditCsProj(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 EditCsProj(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!");
-            return true;
-        }
-
-    }
-}

ElectronNET.CLI/Commands/BuildCommand.cs

@@ -1,187 +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 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;win32\"'" + 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 +                                 
-                                                 "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";
-
-        public Task<bool> ExecuteAsync()
-        {
-            return Task.Run(() =>
-            {
-                Console.WriteLine("Build Electron Application...");
-
-                SimpleCommandLineParser parser = new SimpleCommandLineParser();
-                parser.Parse(_args);
-
-                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 resultCode = ProcessHelper.CmdExecute($"dotnet publish -r {platformInfo.NetCorePublishRid} -c {configuration} --output \"{tempBinPath}\"", 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($"node build-helper.js " + manifestFileName, 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=7.1.2 {electronParams}", tempPath);
-
-                Console.WriteLine("... done");
-
-                return true;
-            });
-        }
-    }
-}

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,211 +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
-                Console.WriteLine($"Search your .csproj to add the needed {ConfigName}...");
-                var projectFile = Directory.EnumerateFiles(currentDirectory, "*.csproj", SearchOption.TopDirectoryOnly).FirstOrDefault();
-
-                // update config file with the name of the csproj
-                // ToDo: If the csproj name != application name, this will fail
-                string text = File.ReadAllText(targetFilePath);
-                text = text.Replace("{{executable}}", Path.GetFileNameWithoutExtension(projectFile));
-                File.WriteAllText(targetFilePath, text);
-
-                Console.WriteLine($"Found your .csproj: {projectFile} - check for existing config or update it.");
-
-                if (!EditCsProj(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 EditCsProj(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.");
-                    return false;
-                }
-
-                Console.WriteLine($"{ConfigName} will be added to csproj.");
-
-                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!");
-            return true;
-        }
-    }
-}

ElectronNET.CLI/Commands/StartElectronCommand.cs

@@ -1,127 +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";
-
-        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);
-                }
-
-                var platformInfo = GetTargetPlatformInformation.Do(string.Empty, string.Empty);
-
-                string tempBinPath = Path.Combine(tempPath, "bin");
-                var resultCode = ProcessHelper.CmdExecute($"dotnet publish -r {platformInfo.NetCorePublishRid} --output \"{tempBinPath}\"", 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();
-                }
-
-                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,82 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-
-    <TargetFramework>netcoreapp3.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>
-  </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\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" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0-beta2-19367-01">
-      <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,97 +0,0 @@
-using System;
-using System.Diagnostics;
-using System.Runtime.InteropServices;
-using System.Text.RegularExpressions;
-
-namespace ElectronNET.CLI
-{
-    public class ProcessHelper
-    {
-        private readonly static Regex ErrorRegex = new Regex(@"\berror\b", RegexOptions.IgnoreCase | RegexOptions.Compiled);
-
-        public static int CmdExecute(string command, string workingDirectoryPath, bool output = true, bool waitForExit = true)
-        {
-            using (Process cmd = new Process())
-            {
-                bool isWindows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
-
-                if (isWindows)
-                {
-                    cmd.StartInfo.FileName = "cmd.exe";
-                }
-                else
-                {
-                    // works for OSX and Linux (at least on Ubuntu)
-                    cmd.StartInfo.FileName = "bash";
-                }
-
-                cmd.StartInfo.RedirectStandardInput = true;
-                cmd.StartInfo.RedirectStandardOutput = true;
-                cmd.StartInfo.RedirectStandardError = true;
-                cmd.StartInfo.CreateNoWindow = true;
-                cmd.StartInfo.UseShellExecute = false;
-                cmd.StartInfo.WorkingDirectory = workingDirectoryPath;
-
-                int returnCode = 0;
-
-                if (output)
-                {
-                    cmd.OutputDataReceived += (s, e) =>
-                    {
-                        // (sometimes error messages are only visbile here)
-                        // poor mans solution, we just seek for the term 'error'
-
-                        // we can't just use cmd.ExitCode, because
-                        // we delegate it to cmd.exe, which runs fine
-                        // but we can catch any error here and return
-                        // 1 if something fails
-                        if (e != null && string.IsNullOrWhiteSpace(e.Data) == false)
-                        {
-                            if (ErrorRegex.IsMatch(e.Data))
-                            {
-                                returnCode = 1;
-                            }
-
-                            Console.WriteLine(e.Data);
-                        }
-
-                    };
-                    cmd.ErrorDataReceived += (s, e) =>
-                    {
-                        // poor mans solution, we just seek for the term 'error'
-
-                        // we can't just use cmd.ExitCode, because
-                        // we delegate it to cmd.exe, which runs fine
-                        // but we can catch any error here and return
-                        // 1 if something fails
-                        if (e != null && string.IsNullOrWhiteSpace(e.Data) == false)
-                        {
-                            if (ErrorRegex.IsMatch(e.Data))
-                            {
-                                returnCode = 1;
-                            }
-
-                            Console.WriteLine(e.Data);
-                        }
-
-                    };
-                }
-
-                cmd.Start();
-                cmd.BeginOutputReadLine();
-                cmd.BeginErrorReadLine();
-
-                cmd.StandardInput.WriteLine(command);
-                cmd.StandardInput.Flush();
-                cmd.StandardInput.Close();
-
-                if (waitForExit)
-                {
-                    cmd.WaitForExit();
-                }
-
-                return returnCode;
-            }
-        }
-    }
-}

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": "build \"C:\\Users\\Gregor\\Documents\\Visual Studio 2017\\Projects\\ElectronNET\\ElectronNET.WebApp\""
-    }
-  }
-}

ElectronNET.CLI/SimpleCommandLineParser.cs

@@ -1,38 +0,0 @@
-using System.Collections.Generic;
-
-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();
-        }
-        public bool Contains(string name)
-        {
-            return Arguments.ContainsKey(name);
-        }
-    }
-}

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

@@ -1,112 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-const electron_updater_1 = require("electron-updater");
-const path = require('path');
-let electronSocket;
-module.exports = (socket) => {
-    electronSocket = socket;
-    // Events ********
-    socket.on('register-autoUpdater-error-event', (id) => {
-        electron_updater_1.autoUpdater.on('error', (error) => {
-            electronSocket.emit('autoUpdater-error' + id, error.message);
-        });
-    });
-    socket.on('register-autoUpdater-checking-for-update-event', (id) => {
-        electron_updater_1.autoUpdater.on('checking-for-update', () => {
-            electronSocket.emit('autoUpdater-checking-for-update' + id);
-        });
-    });
-    socket.on('register-autoUpdater-update-available-event', (id) => {
-        electron_updater_1.autoUpdater.on('update-available', (updateInfo) => {
-            electronSocket.emit('autoUpdater-update-available' + id, updateInfo);
-        });
-    });
-    socket.on('register-autoUpdater-update-not-available-event', (id) => {
-        electron_updater_1.autoUpdater.on('update-not-available', (updateInfo) => {
-            electronSocket.emit('autoUpdater-update-not-available' + id, updateInfo);
-        });
-    });
-    socket.on('register-autoUpdater-download-progress-event', (id) => {
-        electron_updater_1.autoUpdater.on('download-progress', (progressInfo) => {
-            electronSocket.emit('autoUpdater-download-progress' + id, progressInfo);
-        });
-    });
-    socket.on('register-autoUpdater-update-downloaded-event', (id) => {
-        electron_updater_1.autoUpdater.on('update-downloaded', (updateInfo) => {
-            electronSocket.emit('autoUpdater-update-downloaded' + id, updateInfo);
-        });
-    });
-    // Properties *****
-    socket.on('autoUpdater-autoDownload-get', () => {
-        electronSocket.emit('autoUpdater-autoDownload-get-reply', electron_updater_1.autoUpdater.autoDownload);
-    });
-    socket.on('autoUpdater-autoDownload-set', (value) => {
-        electron_updater_1.autoUpdater.autoDownload = value;
-    });
-    socket.on('autoUpdater-autoInstallOnAppQuit-get', () => {
-        electronSocket.emit('autoUpdater-autoInstallOnAppQuit-get-reply', electron_updater_1.autoUpdater.autoInstallOnAppQuit);
-    });
-    socket.on('autoUpdater-autoInstallOnAppQuit-set', (value) => {
-        electron_updater_1.autoUpdater.autoInstallOnAppQuit = value;
-    });
-    socket.on('autoUpdater-allowPrerelease-get', () => {
-        electronSocket.emit('autoUpdater-allowPrerelease-get-reply', electron_updater_1.autoUpdater.allowPrerelease);
-    });
-    socket.on('autoUpdater-allowPrerelease-set', (value) => {
-        electron_updater_1.autoUpdater.allowPrerelease = value;
-    });
-    socket.on('autoUpdater-fullChangelog-get', () => {
-        electronSocket.emit('autoUpdater-fullChangelog-get-reply', electron_updater_1.autoUpdater.fullChangelog);
-    });
-    socket.on('autoUpdater-fullChangelog-set', (value) => {
-        electron_updater_1.autoUpdater.fullChangelog = value;
-    });
-    socket.on('autoUpdater-allowDowngrade-get', () => {
-        electronSocket.emit('autoUpdater-allowDowngrade-get-reply', electron_updater_1.autoUpdater.allowDowngrade);
-    });
-    socket.on('autoUpdater-allowDowngrade-set', (value) => {
-        electron_updater_1.autoUpdater.allowDowngrade = value;
-    });
-    socket.on('autoUpdater-updateConfigPath-get', () => {
-        electronSocket.emit('autoUpdater-updateConfigPath-get-reply', electron_updater_1.autoUpdater.updateConfigPath || '');
-    });
-    socket.on('autoUpdater-updateConfigPath-set', (value) => {
-        electron_updater_1.autoUpdater.updateConfigPath = value;
-    });
-    socket.on('autoUpdater-channel-get', () => {
-        electronSocket.emit('autoUpdater-channel-get-reply', electron_updater_1.autoUpdater.channel || '');
-    });
-    socket.on('autoUpdater-channel-set', (value) => {
-        electron_updater_1.autoUpdater.channel = value;
-    });
-    // Methods ********
-    socket.on('autoUpdaterCheckForUpdatesAndNotify', (guid) => __awaiter(void 0, void 0, void 0, function* () {
-        const updateCheckResult = yield electron_updater_1.autoUpdater.checkForUpdatesAndNotify();
-        electronSocket.emit('autoUpdaterCheckForUpdatesAndNotifyComplete' + guid, updateCheckResult);
-    }));
-    socket.on('autoUpdaterCheckForUpdates', (guid) => __awaiter(void 0, void 0, void 0, function* () {
-        // autoUpdater.updateConfigPath = path.join(__dirname, 'dev-app-update.yml');
-        const updateCheckResult = yield electron_updater_1.autoUpdater.checkForUpdates();
-        electronSocket.emit('autoUpdaterCheckForUpdatesComplete' + guid, updateCheckResult);
-    }));
-    socket.on('autoUpdaterQuitAndInstall', (isSilent, isForceRunAfter) => __awaiter(void 0, void 0, void 0, function* () {
-        electron_updater_1.autoUpdater.quitAndInstall(isSilent, isForceRunAfter);
-    }));
-    socket.on('autoUpdaterDownloadUpdate', (guid) => __awaiter(void 0, void 0, void 0, function* () {
-        const downloadedPath = yield electron_updater_1.autoUpdater.downloadUpdate();
-        electronSocket.emit('autoUpdaterDownloadUpdateComplete' + guid, downloadedPath);
-    }));
-    socket.on('autoUpdaterGetFeedURL', (guid) => __awaiter(void 0, void 0, void 0, function* () {
-        const feedUrl = yield electron_updater_1.autoUpdater.getFeedURL();
-        electronSocket.emit('autoUpdaterGetFeedURLComplete' + guid, feedUrl || '');
-    }));
-};
-//# sourceMappingURL=autoUpdater.js.map

ElectronNET.Host/api/autoUpdater.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"autoUpdater.js","sourceRoot":"","sources":["autoUpdater.ts"],"names":[],"mappings":";;;;;;;;;;AAAA,uDAA+C;AAC/C,MAAM,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;AAC7B,IAAI,cAAc,CAAC;AAEnB,iBAAS,CAAC,MAAuB,EAAE,EAAE;IACjC,cAAc,GAAG,MAAM,CAAC;IAExB,kBAAkB;IAElB,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,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,mBAAmB;IAEnB,MAAM,CAAC,EAAE,CAAC,qCAAqC,EAAE,CAAO,IAAI,EAAE,EAAE;QAC5D,MAAM,iBAAiB,GAAG,MAAM,8BAAW,CAAC,wBAAwB,EAAE,CAAC;QACvE,cAAc,CAAC,IAAI,CAAC,6CAA6C,GAAG,IAAI,EAAE,iBAAiB,CAAC,CAAC;IACjG,CAAC,CAAA,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,4BAA4B,EAAE,CAAO,IAAI,EAAE,EAAE;QACnD,6EAA6E;QAC7E,MAAM,iBAAiB,GAAG,MAAM,8BAAW,CAAC,eAAe,EAAE,CAAC;QAC9D,cAAc,CAAC,IAAI,CAAC,oCAAoC,GAAG,IAAI,EAAE,iBAAiB,CAAC,CAAC;IACxF,CAAC,CAAA,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,2BAA2B,EAAE,CAAO,QAAQ,EAAE,eAAe,EAAE,EAAE;QACvE,8BAAW,CAAC,cAAc,CAAC,QAAQ,EAAE,eAAe,CAAC,CAAC;IAC1D,CAAC,CAAA,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,2BAA2B,EAAE,CAAO,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,CAAA,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,uBAAuB,EAAE,CAAO,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,CAAA,CAAC,CAAC;AACP,CAAC,CAAC"}

ElectronNET.Host/api/autoUpdater.ts

@@ -1,130 +0,0 @@
-import { autoUpdater } from 'electron-updater';
-const path = require('path');
-let electronSocket;
-
-export = (socket: SocketIO.Socket) => {
-    electronSocket = socket;
-
-    // Events ********
-
-    socket.on('register-autoUpdater-error-event', (id) => {
-        autoUpdater.on('error', (error) => {
-            electronSocket.emit('autoUpdater-error' + id, error.message);
-        });
-    });
-
-    socket.on('register-autoUpdater-checking-for-update-event', (id) => {
-        autoUpdater.on('checking-for-update', () => {
-            electronSocket.emit('autoUpdater-checking-for-update' + id);
-        });
-    });
-
-    socket.on('register-autoUpdater-update-available-event', (id) => {
-        autoUpdater.on('update-available', (updateInfo) => {
-            electronSocket.emit('autoUpdater-update-available' + id, updateInfo);
-        });
-    });
-
-    socket.on('register-autoUpdater-update-not-available-event', (id) => {
-        autoUpdater.on('update-not-available', (updateInfo) => {
-            electronSocket.emit('autoUpdater-update-not-available' + id, updateInfo);
-        });
-    });
-
-    socket.on('register-autoUpdater-download-progress-event', (id) => {
-        autoUpdater.on('download-progress', (progressInfo) => {
-            electronSocket.emit('autoUpdater-download-progress' + id, progressInfo);
-        });
-    });
-
-    socket.on('register-autoUpdater-update-downloaded-event', (id) => {
-        autoUpdater.on('update-downloaded', (updateInfo) => {
-            electronSocket.emit('autoUpdater-update-downloaded' + id, updateInfo);
-        });
-    });
-
-    // Properties *****
-
-    socket.on('autoUpdater-autoDownload-get', () => {
-        electronSocket.emit('autoUpdater-autoDownload-get-reply', autoUpdater.autoDownload);
-    });
-
-    socket.on('autoUpdater-autoDownload-set', (value) => {
-        autoUpdater.autoDownload = value;
-    });
-
-    socket.on('autoUpdater-autoInstallOnAppQuit-get', () => {
-        electronSocket.emit('autoUpdater-autoInstallOnAppQuit-get-reply', autoUpdater.autoInstallOnAppQuit);
-    });
-
-    socket.on('autoUpdater-autoInstallOnAppQuit-set', (value) => {
-        autoUpdater.autoInstallOnAppQuit = value;
-    });
-
-    socket.on('autoUpdater-allowPrerelease-get', () => {
-        electronSocket.emit('autoUpdater-allowPrerelease-get-reply', autoUpdater.allowPrerelease);
-    });
-
-    socket.on('autoUpdater-allowPrerelease-set', (value) => {
-        autoUpdater.allowPrerelease = value;
-    });
-
-    socket.on('autoUpdater-fullChangelog-get', () => {
-        electronSocket.emit('autoUpdater-fullChangelog-get-reply', autoUpdater.fullChangelog);
-    });
-
-    socket.on('autoUpdater-fullChangelog-set', (value) => {
-        autoUpdater.fullChangelog = value;
-    });
-
-    socket.on('autoUpdater-allowDowngrade-get', () => {
-        electronSocket.emit('autoUpdater-allowDowngrade-get-reply', autoUpdater.allowDowngrade);
-    });
-
-    socket.on('autoUpdater-allowDowngrade-set', (value) => {
-        autoUpdater.allowDowngrade = value;
-    });
-
-    socket.on('autoUpdater-updateConfigPath-get', () => {
-        electronSocket.emit('autoUpdater-updateConfigPath-get-reply', autoUpdater.updateConfigPath || '');
-    });
-
-    socket.on('autoUpdater-updateConfigPath-set', (value) => {
-        autoUpdater.updateConfigPath = value;
-    });
-
-    socket.on('autoUpdater-channel-get', () => {
-        electronSocket.emit('autoUpdater-channel-get-reply', autoUpdater.channel || '');
-    });
-
-    socket.on('autoUpdater-channel-set', (value) => {
-        autoUpdater.channel = value;
-    });
-
-    // Methods ********
-
-    socket.on('autoUpdaterCheckForUpdatesAndNotify', async (guid) => {
-        const updateCheckResult = await autoUpdater.checkForUpdatesAndNotify();
-        electronSocket.emit('autoUpdaterCheckForUpdatesAndNotifyComplete' + guid, updateCheckResult);
-    });
-
-    socket.on('autoUpdaterCheckForUpdates', async (guid) => {
-        // autoUpdater.updateConfigPath = path.join(__dirname, 'dev-app-update.yml');
-        const updateCheckResult = await autoUpdater.checkForUpdates();
-        electronSocket.emit('autoUpdaterCheckForUpdatesComplete' + guid, updateCheckResult);
-    });
-
-    socket.on('autoUpdaterQuitAndInstall', async (isSilent, isForceRunAfter) => {
-        autoUpdater.quitAndInstall(isSilent, isForceRunAfter);
-    });
-
-    socket.on('autoUpdaterDownloadUpdate', async (guid) => {
-        const downloadedPath = await autoUpdater.downloadUpdate();
-        electronSocket.emit('autoUpdaterDownloadUpdateComplete' + guid, downloadedPath);
-    });
-
-    socket.on('autoUpdaterGetFeedURL', async (guid) => {
-        const feedUrl = await autoUpdater.getFeedURL();
-        electronSocket.emit('autoUpdaterGetFeedURLComplete' + guid, feedUrl || '');
-    });
-};

ElectronNET.Host/api/browserWindows.js

@@ -1,565 +0,0 @@
-"use strict";
-const electron_1 = require("electron");
-const path = require('path');
-const windows = [];
-let window, lastOptions, electronSocket;
-module.exports = (socket, app) => {
-    electronSocket = socket;
-    socket.on('register-browserWindow-ready-to-show', (id) => {
-        getWindowById(id).on('ready-to-show', () => {
-            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);
-        });
-    });
-    function hasOwnChildreen(obj, ...childNames) {
-        for (let i = 0; i < childNames.length; i++) {
-            if (!obj || !obj.hasOwnProperty(childNames[i])) {
-                return false;
-            }
-            obj = obj[childNames[i]];
-        }
-        return true;
-    }
-    socket.on('createBrowserWindow', (options, loadUrl) => {
-        if (!hasOwnChildreen(options, 'webPreferences', 'nodeIntegration')) {
-            options = Object.assign(Object.assign({}, options), { webPreferences: { nodeIntegration: true } });
-        }
-        window = new electron_1.BrowserWindow(options);
-        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);
-        }
-        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('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('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('browserWindowAddExtension', (path) => {
-        const extensionName = electron_1.BrowserWindow.addExtension(path);
-        electronSocket.emit('browserWindow-addExtension-completed', extensionName);
-    });
-    socket.on('browserWindowRemoveExtension', (name) => {
-        electron_1.BrowserWindow.removeExtension(name);
-    });
-    socket.on('browserWindowGetExtensions', () => {
-        const extensionsList = electron_1.BrowserWindow.getExtensions();
-        const chromeExtensionInfo = [];
-        Object.keys(extensionsList).forEach(key => {
-            chromeExtensionInfo.push(extensionsList[key]);
-        });
-        electronSocket.emit('browserWindow-getExtensions-completed', chromeExtensionInfo);
-    });
-    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,738 +0,0 @@
-import { BrowserWindow, Menu, nativeImage } from 'electron';
-const path = require('path');
-const windows: Electron.BrowserWindow[] = [];
-let window, lastOptions, electronSocket;
-
-export = (socket: SocketIO.Socket, app: Electron.App) => {
-    electronSocket = socket;
-    socket.on('register-browserWindow-ready-to-show', (id) => {
-        getWindowById(id).on('ready-to-show', () => {
-            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);
-        });
-    });
-
-    function hasOwnChildreen(obj, ...childNames) {
-        for (let i = 0; i < childNames.length; i++) {
-            if (!obj || !obj.hasOwnProperty(childNames[i])) {
-                return false;
-            }
-            obj = obj[childNames[i]];
-        }
-
-        return true;
-    }
-
-    socket.on('createBrowserWindow', (options, loadUrl) => {
-        if (!hasOwnChildreen(options, 'webPreferences', 'nodeIntegration')) {
-            options = { ...options, webPreferences: { nodeIntegration: true } };
-        }
-
-        window = new BrowserWindow(options);
-        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);
-        }
-
-        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('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('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('browserWindowAddExtension', (path) => {
-        const extensionName = BrowserWindow.addExtension(path);
-
-        electronSocket.emit('browserWindow-addExtension-completed', extensionName);
-    });
-
-    socket.on('browserWindowRemoveExtension', (name) => {
-        BrowserWindow.removeExtension(name);
-    });
-
-    socket.on('browserWindowGetExtensions', () => {
-        const extensionsList = BrowserWindow.getExtensions();
-        const chromeExtensionInfo = [];
-
-        Object.keys(extensionsList).forEach(key => {
-            chromeExtensionInfo.push(extensionsList[key]);
-        });
-
-        electronSocket.emit('browserWindow-getExtensions-completed', chromeExtensionInfo);
-    });
-
-    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/clipboard.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"clipboard.js","sourceRoot":"","sources":["clipboard.ts"],"names":[],"mappings":";AAAA,uCAAqC;AACrC,IAAI,cAAc,CAAC;AAEnB,iBAAS,CAAC,MAAuB,EAAE,EAAE;IACjC,cAAc,GAAG,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,CAAC,oBAAoB,EAAE,CAAC,IAAI,EAAE,EAAE;QACrC,MAAM,IAAI,GAAG,oBAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QACtC,cAAc,CAAC,IAAI,CAAC,8BAA8B,EAAE,IAAI,CAAC,CAAC;IAC9D,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,qBAAqB,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE;QAC5C,oBAAS,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IACpC,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,oBAAoB,EAAE,CAAC,IAAI,EAAE,EAAE;QACrC,MAAM,OAAO,GAAG,oBAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QACzC,cAAc,CAAC,IAAI,CAAC,8BAA8B,EAAE,OAAO,CAAC,CAAC;IACjE,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,qBAAqB,EAAE,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE;QAC9C,oBAAS,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IACtC,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,mBAAmB,EAAE,CAAC,IAAI,EAAE,EAAE;QACpC,MAAM,OAAO,GAAG,oBAAS,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACxC,cAAc,CAAC,IAAI,CAAC,6BAA6B,EAAE,OAAO,CAAC,CAAC;IAChE,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,oBAAoB,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE;QAC3C,oBAAS,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IACpC,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,wBAAwB,EAAE,GAAG,EAAE;QACrC,MAAM,QAAQ,GAAG,oBAAS,CAAC,YAAY,EAAE,CAAC;QAC1C,cAAc,CAAC,IAAI,CAAC,kCAAkC,EAAE,QAAQ,CAAC,CAAC;IACtE,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,yBAAyB,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE;QACtD,oBAAS,CAAC,aAAa,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;IAC9C,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,wBAAwB,EAAE,GAAG,EAAE;QACrC,MAAM,OAAO,GAAG,oBAAS,CAAC,YAAY,EAAE,CAAC;QACzC,cAAc,CAAC,IAAI,CAAC,kCAAkC,EAAE,OAAO,CAAC,CAAC;IACrE,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,yBAAyB,EAAE,CAAC,IAAI,EAAE,EAAE;QAC1C,oBAAS,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;IAClC,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,iBAAiB,EAAE,CAAC,IAAI,EAAE,EAAE;QAClC,oBAAS,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC1B,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,4BAA4B,EAAE,CAAC,IAAI,EAAE,EAAE;QAC7C,MAAM,OAAO,GAAG,oBAAS,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;QACjD,cAAc,CAAC,IAAI,CAAC,sCAAsC,EAAE,OAAO,CAAC,CAAC;IACzE,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,iBAAiB,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE;QACxC,oBAAS,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IAChC,CAAC,CAAC,CAAC;AACP,CAAC,CAAC"}

ElectronNET.Host/api/commandLine.js.map

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

ElectronNET.Host/api/dialog.js

@@ -1,46 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-const electron_1 = require("electron");
-let electronSocket;
-module.exports = (socket) => {
-    electronSocket = socket;
-    socket.on('showMessageBox', (browserWindow, options, guid) => __awaiter(void 0, void 0, void 0, function* () {
-        if ('id' in browserWindow) {
-            const window = electron_1.BrowserWindow.fromId(browserWindow.id);
-            const messageBoxReturnValue = yield electron_1.dialog.showMessageBox(window, options);
-            electronSocket.emit('showMessageBoxComplete' + guid, [messageBoxReturnValue.response, messageBoxReturnValue.checkboxChecked]);
-        }
-        else {
-            const id = guid || options;
-            const messageBoxReturnValue = yield electron_1.dialog.showMessageBox(browserWindow);
-            electronSocket.emit('showMessageBoxComplete' + id, [messageBoxReturnValue.response, messageBoxReturnValue.checkboxChecked]);
-        }
-    }));
-    socket.on('showOpenDialog', (browserWindow, options, guid) => __awaiter(void 0, void 0, void 0, function* () {
-        const window = electron_1.BrowserWindow.fromId(browserWindow.id);
-        const openDialogReturnValue = yield electron_1.dialog.showOpenDialog(window, options);
-        electronSocket.emit('showOpenDialogComplete' + guid, openDialogReturnValue.filePaths || []);
-    }));
-    socket.on('showSaveDialog', (browserWindow, options, guid) => __awaiter(void 0, void 0, void 0, function* () {
-        const window = electron_1.BrowserWindow.fromId(browserWindow.id);
-        const saveDialogReturnValue = yield electron_1.dialog.showSaveDialog(window, options);
-        electronSocket.emit('showSaveDialogComplete' + guid, saveDialogReturnValue.filePath || '');
-    }));
-    socket.on('showErrorBox', (title, content) => {
-        electron_1.dialog.showErrorBox(title, content);
-    });
-    socket.on('showCertificateTrustDialog', (browserWindow, options, guid) => __awaiter(void 0, void 0, void 0, function* () {
-        const window = electron_1.BrowserWindow.fromId(browserWindow.id);
-        yield electron_1.dialog.showCertificateTrustDialog(window, options);
-        electronSocket.emit('showCertificateTrustDialogComplete' + guid);
-    }));
-};
-//# sourceMappingURL=dialog.js.map

ElectronNET.Host/api/dialog.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"dialog.js","sourceRoot":"","sources":["dialog.ts"],"names":[],"mappings":";;;;;;;;;;AAAA,uCAAiD;AACjD,IAAI,cAAc,CAAC;AAEnB,iBAAS,CAAC,MAAuB,EAAE,EAAE;IACjC,cAAc,GAAG,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,CAAC,gBAAgB,EAAE,CAAO,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,CAAA,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,gBAAgB,EAAE,CAAO,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,CAAA,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,gBAAgB,EAAE,CAAO,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,CAAA,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,CAAO,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,CAAA,CAAC,CAAC;AACP,CAAC,CAAC"}

ElectronNET.Host/api/globalShortcut.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"globalShortcut.js","sourceRoot":"","sources":["globalShortcut.ts"],"names":[],"mappings":";AAAA,uCAA0C;AAC1C,IAAI,cAAc,CAAC;AAEnB,iBAAS,CAAC,MAAuB,EAAE,EAAE;IACjC,cAAc,GAAG,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,CAAC,yBAAyB,EAAE,CAAC,WAAW,EAAE,EAAE;QACjD,yBAAc,CAAC,QAAQ,CAAC,WAAW,EAAE,GAAG,EAAE;YACtC,cAAc,CAAC,IAAI,CAAC,wBAAwB,EAAE,WAAW,CAAC,CAAC;QAC/D,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,6BAA6B,EAAE,CAAC,WAAW,EAAE,EAAE;QACrD,MAAM,YAAY,GAAG,yBAAc,CAAC,YAAY,CAAC,WAAW,CAAC,CAAC;QAE9D,cAAc,CAAC,IAAI,CAAC,sCAAsC,EAAE,YAAY,CAAC,CAAC;IAC9E,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,2BAA2B,EAAE,CAAC,WAAW,EAAE,EAAE;QACnD,yBAAc,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;IAC3C,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,8BAA8B,EAAE,GAAG,EAAE;QAC3C,IAAI;YACA,yBAAc,CAAC,aAAa,EAAE,CAAC;SAClC;QAAC,OAAO,KAAK,EAAE,GAAG;IACvB,CAAC,CAAC,CAAC;AACP,CAAC,CAAC"}

ElectronNET.Host/api/ipc.js

@@ -1,36 +0,0 @@
-"use strict";
-const electron_1 = require("electron");
-let electronSocket;
-module.exports = (socket) => {
-    electronSocket = socket;
-    socket.on('registerIpcMainChannel', (channel) => {
-        electron_1.ipcMain.on(channel, (event, args) => {
-            electronSocket.emit(channel, [event.preventDefault(), args]);
-        });
-    });
-    socket.on('registerSyncIpcMainChannel', (channel) => {
-        electron_1.ipcMain.on(channel, (event, args) => {
-            const x = socket;
-            x.removeAllListeners(channel + 'Sync');
-            socket.on(channel + 'Sync', (result) => {
-                event.returnValue = result;
-            });
-            electronSocket.emit(channel, [event.preventDefault(), args]);
-        });
-    });
-    socket.on('registerOnceIpcMainChannel', (channel) => {
-        electron_1.ipcMain.once(channel, (event, args) => {
-            electronSocket.emit(channel, [event.preventDefault(), args]);
-        });
-    });
-    socket.on('removeAllListenersIpcMainChannel', (channel) => {
-        electron_1.ipcMain.removeAllListeners(channel);
-    });
-    socket.on('sendToIpcRenderer', (browserWindow, channel, ...data) => {
-        const window = electron_1.BrowserWindow.fromId(browserWindow.id);
-        if (window) {
-            window.webContents.send(channel, ...data);
-        }
-    });
-};
-//# sourceMappingURL=ipc.js.map

ElectronNET.Host/api/ipc.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ipc.js","sourceRoot":"","sources":["ipc.ts"],"names":[],"mappings":";AAAA,uCAAkD;AAClD,IAAI,cAAc,CAAC;AAEnB,iBAAS,CAAC,MAAuB,EAAE,EAAE;IACjC,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;AACP,CAAC,CAAC"}

ElectronNET.Host/api/ipc.ts

@@ -1,41 +0,0 @@
-import { ipcMain, BrowserWindow } from 'electron';
-let electronSocket;
-
-export = (socket: SocketIO.Socket) => {
-    electronSocket = socket;
-    socket.on('registerIpcMainChannel', (channel) => {
-        ipcMain.on(channel, (event, args) => {
-            electronSocket.emit(channel, [event.preventDefault(), args]);
-        });
-    });
-
-    socket.on('registerSyncIpcMainChannel', (channel) => {
-        ipcMain.on(channel, (event, args) => {
-            const x = <any>socket;
-            x.removeAllListeners(channel + 'Sync');
-            socket.on(channel + 'Sync', (result) => {
-                event.returnValue = result;
-            });
-
-            electronSocket.emit(channel, [event.preventDefault(), args]);
-        });
-    });
-
-    socket.on('registerOnceIpcMainChannel', (channel) => {
-        ipcMain.once(channel, (event, args) => {
-            electronSocket.emit(channel, [event.preventDefault(), args]);
-        });
-    });
-
-    socket.on('removeAllListenersIpcMainChannel', (channel) => {
-        ipcMain.removeAllListeners(channel);
-    });
-
-    socket.on('sendToIpcRenderer', (browserWindow, channel, ...data) => {
-        const window = BrowserWindow.fromId(browserWindow.id);
-
-        if (window) {
-            window.webContents.send(channel, ...data);
-        }
-    });
-};