Compare commits
2
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Felix Rieseberg
|
ebf421ebed | ||
|
Felix Rieseberg
|
41409f578e |
@@ -1,31 +0,0 @@
|
||||
const { Octokit } = require('@octokit/action')
|
||||
|
||||
const octokit = new Octokit()
|
||||
|
||||
const [owner, repo] = process.env.GITHUB_REPOSITORY.split('/')
|
||||
|
||||
async function main () {
|
||||
const prs = await octokit.pulls.list({
|
||||
owner,
|
||||
repo,
|
||||
state: 'open',
|
||||
head: `${owner}:update-releases`
|
||||
})
|
||||
|
||||
if (prs.data.length === 0) {
|
||||
const pr = await octokit.pulls.create({
|
||||
owner,
|
||||
repo,
|
||||
title: 'build: update Electron releases JSON',
|
||||
base: 'master',
|
||||
head: 'update-releases',
|
||||
body: 'Auto-update from GitHub Actions.',
|
||||
maintainer_can_modify: true
|
||||
})
|
||||
console.log('Pull request created:', pr.html_url)
|
||||
} else {
|
||||
console.log('Pull request updated:', prs.data[0].html_url)
|
||||
}
|
||||
}
|
||||
|
||||
main()
|
||||
@@ -1,51 +0,0 @@
|
||||
name: Auto-update Releases JSON file
|
||||
on:
|
||||
schedule:
|
||||
- cron: '0 0 * * 1'
|
||||
jobs:
|
||||
autoupdate:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v2
|
||||
- name: Fetch git branches
|
||||
run: git fetch --no-tags --prune --depth=1 origin +refs/heads/*:refs/remotes/origin/*
|
||||
- uses: actions/setup-node@v1
|
||||
with:
|
||||
node-version: '12.x'
|
||||
- name: Get npm cache directory
|
||||
id: npm-cache
|
||||
run: |
|
||||
echo "::set-output name=dir::$(npm config get cache)"
|
||||
- uses: actions/cache@v1
|
||||
with:
|
||||
path: ${{ steps.npm-cache.outputs.dir }}
|
||||
key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
|
||||
restore-keys: |
|
||||
${{ runner.os }}-node-
|
||||
- run: npm ci
|
||||
- name: Switch to release update branch
|
||||
run: |
|
||||
if git branch --remotes | grep -q origin/update-releases; then
|
||||
git checkout update-releases
|
||||
else
|
||||
git checkout -b update-releases
|
||||
fi
|
||||
- name: Update Releases JSON
|
||||
run: npm run electron-releases
|
||||
- name: Commit Changes to Releases JSON
|
||||
env:
|
||||
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
run: |
|
||||
echo "machine github.com login $GITHUB_ACTOR password $GITHUB_TOKEN" > ~/.netrc
|
||||
chmod 600 ~/.netrc
|
||||
git add static/releases.json tests/fixtures/releases-metadata.json
|
||||
if test -n "$(git status -s)"; then
|
||||
git config user.name "$GITHUB_ACTOR"
|
||||
git config user.email "electron-bot@users.noreply.github.com"
|
||||
git diff --cached
|
||||
git commit -m "build: update Electron releases JSON"
|
||||
git push origin update-releases
|
||||
node --unhandled-rejections=strict .github/actions/create_releases_pr.js
|
||||
else
|
||||
echo No update needed
|
||||
fi
|
||||
@@ -31,9 +31,6 @@ yarn-error.log
|
||||
# Coverage
|
||||
coverage
|
||||
|
||||
# Test report
|
||||
report.json
|
||||
|
||||
# npm package
|
||||
/npm/dist
|
||||
/npm/path.txt
|
||||
|
||||
+4
-3
@@ -3,12 +3,13 @@ node_js: "12"
|
||||
os:
|
||||
- linux
|
||||
- osx
|
||||
dist: bionic
|
||||
dist: trusty
|
||||
osx_image: xcode10
|
||||
sudo: false
|
||||
|
||||
cache:
|
||||
npm: true
|
||||
directories:
|
||||
- node_modules
|
||||
- $HOME/.cache/electron
|
||||
|
||||
addons:
|
||||
@@ -23,7 +24,7 @@ branches:
|
||||
- /^v\d+\.\d+\.\d+/
|
||||
|
||||
install:
|
||||
- npm ci
|
||||
- npm install
|
||||
- |
|
||||
if [[ "$TRAVIS_OS_NAME" == "osx" && "$TRAVIS_SECURE_ENV_VARS" == "true" ]]; then
|
||||
export CERTIFICATE_P12=cert.p12;
|
||||
|
||||
@@ -1,57 +0,0 @@
|
||||
# Contributing to Electron Fiddle
|
||||
|
||||
Electron Fiddle is a community-driven project, overseen by the [Electron Ecosystem Working
|
||||
Group](https://github.com/electron/governance/tree/master/wg-ecosystem#readme). As such, we welcome
|
||||
and encourage all sorts of contributions. They include, but are not limited to:
|
||||
|
||||
- Constructive feedback
|
||||
- Bug reports / technical issues
|
||||
- Documentation changes
|
||||
- Feature requests
|
||||
- [Pull requests](#filing-pull-requests)
|
||||
|
||||
We strongly suggest that before filing an issue, you search through the existing issues to see
|
||||
if it has already been filed by someone else.
|
||||
|
||||
This project is a part of the Electron ecosystem. As such, all contributions to this project follow
|
||||
[Electron's code of conduct](https://github.com/electron/electron/blob/master/CODE_OF_CONDUCT.md)
|
||||
where appropriate.
|
||||
|
||||
## Contribution Suggestions
|
||||
|
||||
We use the label [`good first issue`](https://github.com/electron/fiddle/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22) in the issue tracker to denote fairly-well-scoped-out bugs or feature requests that the community can pick up and work on. If any of those labeled issues do not have enough information, please feel free to ask constructive questions. (This applies to any open issue.)
|
||||
|
||||
## Filing Pull Requests
|
||||
|
||||
Here are some things to keep in mind as you file pull requests to fix bugs, add new features, etc.:
|
||||
|
||||
* If you're unfamiliar with forking, branching, and pull requests, please see [GitHub's extensive
|
||||
documentation](https://help.github.com/en/github/collaborating-with-issues-and-pull-requests).
|
||||
* Travis CI and AppVeyor are used to make sure that any new or changed code meets the project's
|
||||
style guidelines, and that the project's testsuite passes for each new commit.
|
||||
* Unless it's impractical, please write tests for your changes. This will help us so that we can
|
||||
spot regressions much easier.
|
||||
* When creating commit messages and pull request titles, please adhere to the [conventional
|
||||
commits](https://www.conventionalcommits.org/en/v1.0.0/) standard.
|
||||
* Please **do not** bump the version number in your pull requests, the maintainers will do that.
|
||||
Feel free to indicate whether the changes require a major, minor, or patch version bump, as
|
||||
prescribed by the [semantic versioning specification](http://semver.org/).
|
||||
|
||||
### Running Fiddle From Source
|
||||
|
||||
```sh
|
||||
git clone https://github.com/electron/fiddle
|
||||
cd fiddle
|
||||
npm install
|
||||
npm start
|
||||
```
|
||||
|
||||
### Running Tests
|
||||
|
||||
```sh
|
||||
npm test
|
||||
```
|
||||
|
||||
## Release Process
|
||||
|
||||
<!-- TODO @felix add your release process here 😁 -->
|
||||
+2
-2
@@ -1,4 +1,4 @@
|
||||
Copyright (c) 2013-2020 GitHub Inc.
|
||||
Copyright (c) 2013-2018 GitHub Inc.
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining
|
||||
a copy of this software and associated documentation files (the
|
||||
@@ -17,4 +17,4 @@ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
@@ -106,21 +106,11 @@ function notarizeMaybe() {
|
||||
return;
|
||||
}
|
||||
|
||||
if (process.env.npm_lifecycle_event !== 'publish') {
|
||||
console.log(`Not in "publish" mode, skipping notarization`);
|
||||
return;
|
||||
}
|
||||
|
||||
if (!process.env.CI) {
|
||||
console.log(`Not in CI, skipping notarization`);
|
||||
return;
|
||||
}
|
||||
|
||||
if (!process.env.TRAVIS_TAG && !process.env.NOTARIZE_WITHOUT_TAG) {
|
||||
console.log(`Not a tag, not notarizing`);
|
||||
return;
|
||||
}
|
||||
|
||||
if (!process.env.APPLE_ID || !process.env.APPLE_ID_PASSWORD) {
|
||||
console.warn('Should be notarizing, but environment variables APPLE_ID or APPLE_ID_PASSWORD are missing!');
|
||||
return;
|
||||
|
||||
@@ -1,15 +1,12 @@
|
||||
{
|
||||
"transform": {
|
||||
"\\.(js|jsx|ts|tsx)$": "ts-jest"
|
||||
".(js|jsx|ts|tsx)": "ts-jest"
|
||||
},
|
||||
"testURL": "http://localhost",
|
||||
"testRegex": "(-spec)\\.(ts|tsx)$",
|
||||
"resetMocks": true,
|
||||
"bail": true,
|
||||
"resetMocks": true,
|
||||
"resetModules": true,
|
||||
"snapshotSerializers": [
|
||||
"enzyme-to-json/serializer"
|
||||
],
|
||||
"setupFilesAfterEnv": [
|
||||
"<rootDir>/tests/setup.js"
|
||||
],
|
||||
|
||||
Generated
+2666
-6073
File diff suppressed because it is too large
Load Diff
+54
-55
@@ -1,30 +1,29 @@
|
||||
{
|
||||
"name": "electron-fiddle",
|
||||
"productName": "Electron Fiddle",
|
||||
"version": "0.13.1",
|
||||
"version": "0.11.1",
|
||||
"description": "The easiest way to get started with Electron",
|
||||
"repository": "https://github.com/electron/fiddle",
|
||||
"main": "./dist/src/main/main",
|
||||
"scripts": {
|
||||
"contributors": "node ./tools/contributors.js",
|
||||
"less": "node ./tools/lessc.js",
|
||||
"lint:style": "stylelint \"./src/less/*.less\" --fix",
|
||||
"lint:style": "stylelint ./src/less/*.less --fix",
|
||||
"lint:ts": "tslint -c tslint.json -p tsconfig.json -e \"node_modules/**/*.ts\" --fix",
|
||||
"lint:tests": "tslint \"./tests/**/*.ts{,x}\" -c tslint.json --fix",
|
||||
"lint:templates": "standard \"./static/show-me/**/*.js\"",
|
||||
"lint": "npm-run-all \"lint:*\"",
|
||||
"lint:tests": "tslint ./tests/**/*.ts{,x} -c tslint.json --fix",
|
||||
"lint:templates": "standard ./static/show-me/**/*.js",
|
||||
"lint": "npm-run-all lint:*",
|
||||
"make": "electron-forge make",
|
||||
"package": "electron-forge package",
|
||||
"parcel:build": "node ./tools/parcel-build.js",
|
||||
"parcel:watch": "node ./tools/parcel-watch.js",
|
||||
"publish": "electron-forge publish",
|
||||
"start": "rimraf ./dist && electron-forge start",
|
||||
"test": "jest --config=jest.json",
|
||||
"test": "jest --config=jest.json --coverage",
|
||||
"test:ci": "jest --config=jest.json --coverage --runInBand",
|
||||
"test:coverage": "cat ./coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js",
|
||||
"test:report": "jest --config=jest.json --json --bail=false --outputFile=report.json | true",
|
||||
"tsc": "tsc --noEmit -p .",
|
||||
"electron-releases": "node --unhandled-rejections=strict ./tools/fetch-releases.js"
|
||||
"tsc": "node ./tools/tsc.js",
|
||||
"electron-releases": "node ./tools/fetch-releases.js"
|
||||
},
|
||||
"keywords": [
|
||||
"Electron",
|
||||
@@ -37,73 +36,73 @@
|
||||
"forge": "./forge.config.js"
|
||||
},
|
||||
"dependencies": {
|
||||
"@blueprintjs/core": "^3.24.0",
|
||||
"@blueprintjs/select": "^3.12.0",
|
||||
"@electron/get": "^1.9.0",
|
||||
"@octokit/rest": "^16.43.1",
|
||||
"@sentry/electron": "^1.2.1",
|
||||
"@blueprintjs/core": "^3.19.1",
|
||||
"@blueprintjs/select": "^3.11.1",
|
||||
"@octokit/rest": "^16.34.0",
|
||||
"builtin-modules": "^3.1.0",
|
||||
"classnames": "^2.2.6",
|
||||
"electron-default-menu": "^1.0.1",
|
||||
"electron-devtools-installer": "^2.2.4",
|
||||
"electron-download": "^4.1.1",
|
||||
"electron-squirrel-startup": "^1.0.0",
|
||||
"extract-zip": "^1.6.7",
|
||||
"fix-path": "^3.0.0",
|
||||
"fix-path": "^2.1.0",
|
||||
"fs-extra": "^8.1.0",
|
||||
"mobx": "^5.15.4",
|
||||
"mobx-react": "^6.1.8",
|
||||
"monaco-editor": "^0.20.0",
|
||||
"mobx": "^5.14.2",
|
||||
"mobx-react": "^6.1.4",
|
||||
"monaco-editor": "^0.18.1",
|
||||
"monaco-loader": "1.0.0",
|
||||
"namor": "^2.0.2",
|
||||
"react": "^16.13.0",
|
||||
"react-dom": "^16.13.0",
|
||||
"namor": "^1.1.3",
|
||||
"react": "^16.11.0",
|
||||
"react-dom": "^16.11.0",
|
||||
"react-mosaic-component": "^3.2.0",
|
||||
"semver": "^7.1.3",
|
||||
"semver": "^6.3.0",
|
||||
"tmp": "0.1.0",
|
||||
"tslib": "^1.11.1",
|
||||
"tslib": "^1.10.0",
|
||||
"update-electron-app": "^1.5.0"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@babel/core": "^7.8.6",
|
||||
"@electron-forge/cli": "^6.0.0-beta.50",
|
||||
"@electron-forge/maker-deb": "^6.0.0-beta.50",
|
||||
"@electron-forge/maker-rpm": "^6.0.0-beta.50",
|
||||
"@electron-forge/maker-squirrel": "^6.0.0-beta.50",
|
||||
"@electron-forge/maker-zip": "^6.0.0-beta.50",
|
||||
"@electron-forge/publisher-github": "^6.0.0-beta.50",
|
||||
"@octokit/action": "^2.0.0",
|
||||
"@babel/core": "^7.6.4",
|
||||
"@electron-forge/cli": "^6.0.0-beta.46",
|
||||
"@electron-forge/maker-deb": "^6.0.0-beta.46",
|
||||
"@electron-forge/maker-rpm": "^6.0.0-beta.46",
|
||||
"@electron-forge/maker-squirrel": "^6.0.0-beta.46",
|
||||
"@electron-forge/maker-zip": "^6.0.0-beta.46",
|
||||
"@electron-forge/publisher-github": "^6.0.0-beta.46",
|
||||
"@types/builtin-modules": "^3.1.1",
|
||||
"@types/classnames": "^2.2.9",
|
||||
"@types/enzyme": "^3.10.5",
|
||||
"@types/fs-extra": "^8.1.0",
|
||||
"@types/jest": "^25.1.3",
|
||||
"@types/enzyme": "^3.10.3",
|
||||
"@types/fs-extra": "^8.0.1",
|
||||
"@types/jest": "^24.0.19",
|
||||
"@types/log-symbols": "^3.0.0",
|
||||
"@types/node": "^13.7.6",
|
||||
"@types/react": "^16.9.23",
|
||||
"@types/react-dom": "^16.9.5",
|
||||
"@types/semver": "^7.1.0",
|
||||
"@types/node": "^12.11.7",
|
||||
"@types/react": "^16.9.11",
|
||||
"@types/react-dom": "^16.9.3",
|
||||
"@types/semver": "^6.0.2",
|
||||
"@types/tmp": "0.1.0",
|
||||
"chokidar": "^3.3.1",
|
||||
"coveralls": "^3.0.9",
|
||||
"electron": "8.0.2",
|
||||
"enzyme": "^3.11.0",
|
||||
"enzyme-adapter-react-16": "^1.15.2",
|
||||
"enzyme-to-json": "^3.4.4",
|
||||
"fetch-mock-jest": "^1.1.0-beta.3",
|
||||
"jest": "^25.1.0",
|
||||
"less": "^3.11.1",
|
||||
"chokidar": "^3.2.2",
|
||||
"coveralls": "^3.0.7",
|
||||
"electron": "7.1.3",
|
||||
"enzyme": "^3.10.0",
|
||||
"enzyme-adapter-react-16": "^1.15.1",
|
||||
"enzyme-to-json": "^3.4.3",
|
||||
"jest": "^24.9.0",
|
||||
"jest-fetch-mock": "^2.1.2",
|
||||
"less": "^3.10.3",
|
||||
"log-symbols": "^3.0.0",
|
||||
"node-abi": "^2.15.0",
|
||||
"node-abi": "^2.12.0",
|
||||
"node-fetch": "^2.6.0",
|
||||
"npm-run-all": "^4.1.5",
|
||||
"parcel-bundler": "^1.12.4",
|
||||
"react-test-renderer": "^16.13.0",
|
||||
"react-test-renderer": "^16.11.0",
|
||||
"rimraf": "^3.0.0",
|
||||
"standard": "^14.3.1",
|
||||
"stylelint": "^13.2.0",
|
||||
"stylelint-config-standard": "^20.0.0",
|
||||
"ts-jest": "^25.2.1",
|
||||
"tslint": "^6.0.0",
|
||||
"stylelint": "^11.1.1",
|
||||
"stylelint-config-standard": "^19.0.0",
|
||||
"ts-jest": "^24.1.0",
|
||||
"tslint": "^5.20.0",
|
||||
"tslint-microsoft-contrib": "^6.2.0",
|
||||
"tslint-react": "^4.2.0",
|
||||
"typescript": "^3.8.2"
|
||||
"tslint-react": "^4.1.0",
|
||||
"typescript": "^3.6.4"
|
||||
}
|
||||
}
|
||||
|
||||
@@ -3,7 +3,6 @@ export const html = `<!DOCTYPE html>
|
||||
<head>
|
||||
<meta charset="UTF-8">
|
||||
<title>Hello World!</title>
|
||||
<link rel="stylesheet" type="text/css" href="./styles.css">
|
||||
</head>
|
||||
<body>
|
||||
<h1>Hello World!</h1>
|
||||
|
||||
@@ -3,9 +3,13 @@ const {app, BrowserWindow} = require('electron')
|
||||
const path = require('path')
|
||||
const url = require('url')
|
||||
|
||||
// Keep a global reference of the window object, if you don't, the window will
|
||||
// be closed automatically when the JavaScript object is garbage collected.
|
||||
let mainWindow
|
||||
|
||||
function createWindow () {
|
||||
// Create the browser window.
|
||||
const mainWindow = new BrowserWindow({width: 800, height: 600})
|
||||
mainWindow = new BrowserWindow({width: 800, height: 600})
|
||||
|
||||
// and load the index.html of the app.
|
||||
mainWindow.loadURL(url.format({
|
||||
@@ -16,6 +20,14 @@ function createWindow () {
|
||||
|
||||
// Open the DevTools.
|
||||
// mainWindow.webContents.openDevTools()
|
||||
|
||||
// Emitted when the window is closed.
|
||||
mainWindow.on('closed', function () {
|
||||
// Dereference the window object, usually you would store windows
|
||||
// in an array if your app supports multi windows, this is the time
|
||||
// when you should delete the corresponding element.
|
||||
mainWindow = null
|
||||
})
|
||||
}
|
||||
|
||||
// This method will be called when Electron has finished
|
||||
@@ -35,7 +47,7 @@ app.on('window-all-closed', function () {
|
||||
app.on('activate', function () {
|
||||
// On OS X 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 (BrowserWindow.getAllWindows().length === 0) {
|
||||
if (mainWindow === null) {
|
||||
createWindow()
|
||||
}
|
||||
})
|
||||
|
||||
+14
-2
@@ -1,9 +1,13 @@
|
||||
export const main = `// Modules to control application life and create native browser window
|
||||
const {app, BrowserWindow} = require('electron')
|
||||
|
||||
// Keep a global reference of the window object, if you don't, the window will
|
||||
// be closed automatically when the JavaScript object is garbage collected.
|
||||
let mainWindow
|
||||
|
||||
function createWindow () {
|
||||
// Create the browser window.
|
||||
const mainWindow = new BrowserWindow({
|
||||
mainWindow = new BrowserWindow({
|
||||
width: 800,
|
||||
height: 600,
|
||||
webPreferences: {
|
||||
@@ -16,6 +20,14 @@ function createWindow () {
|
||||
|
||||
// Open the DevTools.
|
||||
// mainWindow.webContents.openDevTools()
|
||||
|
||||
// Emitted when the window is closed.
|
||||
mainWindow.on('closed', function () {
|
||||
// Dereference the window object, usually you would store windows
|
||||
// in an array if your app supports multi windows, this is the time
|
||||
// when you should delete the corresponding element.
|
||||
mainWindow = null
|
||||
})
|
||||
}
|
||||
|
||||
// This method will be called when Electron has finished
|
||||
@@ -35,7 +47,7 @@ app.on('window-all-closed', function () {
|
||||
app.on('activate', function () {
|
||||
// On OS X 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 (BrowserWindow.getAllWindows().length === 0) {
|
||||
if (mainWindow === null) {
|
||||
createWindow()
|
||||
}
|
||||
})
|
||||
|
||||
+16
-19
@@ -7,33 +7,38 @@ export type FileTransform = (files: Files) => Promise<Files>;
|
||||
export enum VersionState {
|
||||
ready = 'ready',
|
||||
downloading = 'downloading',
|
||||
unzipping = 'unzipping',
|
||||
unknown = 'unknown'
|
||||
}
|
||||
|
||||
export enum VersionSource {
|
||||
export enum ElectronVersionSource {
|
||||
remote = 'remote',
|
||||
local = 'local'
|
||||
}
|
||||
|
||||
export interface Version {
|
||||
version: string;
|
||||
}
|
||||
|
||||
export interface NpmVersion extends Version {
|
||||
name?: string;
|
||||
localPath?: string;
|
||||
}
|
||||
|
||||
export interface NodeVersion extends Version {
|
||||
state: VersionState;
|
||||
}
|
||||
|
||||
export interface EditorValues {
|
||||
main: string;
|
||||
renderer: string;
|
||||
html: string;
|
||||
preload: string;
|
||||
css: string;
|
||||
package?: string;
|
||||
}
|
||||
|
||||
export interface RunnableVersion extends Version {
|
||||
export interface ElectronVersion extends NpmVersion {
|
||||
state: VersionState;
|
||||
source: VersionSource;
|
||||
downloadProgress?: number;
|
||||
source: ElectronVersionSource;
|
||||
}
|
||||
|
||||
export interface SetFiddleOptions {
|
||||
@@ -53,8 +58,7 @@ export interface OutputOptions {
|
||||
isNotPre?: boolean;
|
||||
}
|
||||
|
||||
export interface GenericDialogOptions {
|
||||
type: GenericDialogType;
|
||||
export interface WarningDialogTexts {
|
||||
ok?: string;
|
||||
cancel?: string;
|
||||
label: string;
|
||||
@@ -64,19 +68,12 @@ export interface Templates {
|
||||
[index: string]: string | Templates;
|
||||
}
|
||||
|
||||
export const enum GenericDialogType {
|
||||
'confirm' = 'confirm',
|
||||
'warning' = 'warning',
|
||||
'success' = 'success',
|
||||
}
|
||||
|
||||
// Editors
|
||||
export const enum EditorId {
|
||||
'main' = 'main',
|
||||
'renderer' = 'renderer',
|
||||
'html' = 'html',
|
||||
'preload' = 'preload',
|
||||
'css' = 'css'
|
||||
'preload' = 'preload'
|
||||
}
|
||||
|
||||
// Panels that can show up as a mosaic
|
||||
@@ -86,9 +83,9 @@ export const enum PanelId {
|
||||
|
||||
export type MosaicId = EditorId | PanelId;
|
||||
|
||||
export const ALL_EDITORS = [EditorId.main, EditorId.renderer, EditorId.preload, EditorId.html, EditorId.css];
|
||||
export const ALL_PANELS = [PanelId.docsDemo];
|
||||
export const ALL_MOSAICS = [...ALL_EDITORS, ...ALL_PANELS];
|
||||
export const ALL_EDITORS = [ EditorId.main, EditorId.renderer, EditorId.preload, EditorId.html ];
|
||||
export const ALL_PANELS = [ PanelId.docsDemo ];
|
||||
export const ALL_MOSAICS = [ ...ALL_EDITORS, ...ALL_PANELS ];
|
||||
|
||||
export type ArrowPosition = 'top' | 'left' | 'bottom' | 'right';
|
||||
|
||||
|
||||
+1
-3
@@ -23,7 +23,6 @@ export enum IpcEvents {
|
||||
LOAD_LOCAL_VERSION_FOLDER = 'LOAD_LOCAL_VERSION_FOLDER',
|
||||
SHOW_LOCAL_VERSION_FOLDER_DIALOG = 'SHOW_LOCAL_VERSION_FOLDER_DIALOG',
|
||||
BISECT_COMMANDS_TOGGLE = 'BISECT_COMMANDS_TOGGLE',
|
||||
SHOW_INACTIVE = 'SHOW_INACTIVE'
|
||||
}
|
||||
|
||||
export const ipcMainEvents = [
|
||||
@@ -31,8 +30,7 @@ export const ipcMainEvents = [
|
||||
IpcEvents.FS_SAVE_FIDDLE,
|
||||
IpcEvents.SHOW_WARNING_DIALOG,
|
||||
IpcEvents.SHOW_CONFIRMATION_DIALOG,
|
||||
IpcEvents.SHOW_LOCAL_VERSION_FOLDER_DIALOG,
|
||||
IpcEvents.SHOW_INACTIVE
|
||||
IpcEvents.SHOW_LOCAL_VERSION_FOLDER_DIALOG
|
||||
];
|
||||
|
||||
export const ipcRendererEvents = [
|
||||
|
||||
@@ -24,21 +24,6 @@
|
||||
}
|
||||
}
|
||||
|
||||
// update if list of Editor ID changes
|
||||
@editor-ids: main, renderer, html, preload;
|
||||
|
||||
// takes each editor ID and increase its z-index if the parent Mosiac root
|
||||
// has focused__id class for that specific id.
|
||||
each(@editor-ids, {
|
||||
.focused__@{value}.mosaic .mosaic-window.@{value} {
|
||||
z-index: 2;
|
||||
}
|
||||
});
|
||||
|
||||
.mosaic-window {
|
||||
z-index: 1;
|
||||
}
|
||||
|
||||
@keyframes fadein {
|
||||
from { opacity: 0; }
|
||||
to { opacity: 1; }
|
||||
|
||||
@@ -52,10 +52,6 @@
|
||||
.action {
|
||||
text-align: right;
|
||||
}
|
||||
|
||||
.bp3-progress-bar {
|
||||
margin-top: 8px;
|
||||
}
|
||||
}
|
||||
|
||||
.settings-content {
|
||||
|
||||
@@ -1,5 +0,0 @@
|
||||
.bp3-fill {
|
||||
.version-chooser {
|
||||
width: 100%;
|
||||
}
|
||||
}
|
||||
@@ -17,4 +17,3 @@
|
||||
@import "components/editors.less";
|
||||
@import "components/tour.less";
|
||||
@import "components/show-me.less";
|
||||
@import "components/version-select.less";
|
||||
|
||||
@@ -20,7 +20,6 @@ export class IpcMainManager extends EventEmitter {
|
||||
super();
|
||||
|
||||
ipcMainEvents.forEach((name) => {
|
||||
ipcMain.removeAllListeners(name);
|
||||
ipcMain.on(name, (...args: Array<any>) => this.emit(name, ...args));
|
||||
});
|
||||
|
||||
|
||||
@@ -1,6 +1,3 @@
|
||||
import { initSentry } from '../sentry';
|
||||
initSentry();
|
||||
|
||||
import { app } from 'electron';
|
||||
|
||||
import { isDevMode } from '../utils/devmode';
|
||||
|
||||
+1
-3
@@ -247,9 +247,7 @@ export function setupMenu() {
|
||||
|
||||
// Tweak "View" menu
|
||||
if (label === 'View' && isSubmenu(item.submenu)) {
|
||||
// remove "Reload" (has weird behaviour) and "Toggle Developer Tools"
|
||||
item.submenu = item.submenu
|
||||
.filter((subItem) => subItem.label !== 'Toggle Developer Tools' && subItem.label !== 'Reload');
|
||||
item.submenu = item.submenu.filter((subItem) => subItem.label !== 'Toggle Developer Tools'); // Remove "Toggle Developer Tools"
|
||||
item.submenu.push({ type: 'separator' }, { role: 'resetZoom' }, { role: 'zoomIn' }, { role: 'zoomOut' }); // Add zooming actions
|
||||
item.submenu.push({ type: 'separator' }, {
|
||||
label: 'Toggle Soft Wrap',
|
||||
|
||||
@@ -76,7 +76,6 @@ export const listenForProtocolHandler = () => {
|
||||
const gotTheLock = app.requestSingleInstanceLock();
|
||||
if (!gotTheLock) app.quit();
|
||||
|
||||
app.removeAllListeners('open-url');
|
||||
app.on('open-url', (_, url) => {
|
||||
if (url.startsWith(`${PROTOCOL}://`)) {
|
||||
handlePotentialProtocolLaunch(url);
|
||||
|
||||
@@ -1,7 +1,5 @@
|
||||
import { BrowserWindow, shell } from 'electron';
|
||||
import { IpcEvents } from '../ipc-events';
|
||||
import { createContextMenu } from './context-menu';
|
||||
import { ipcMainManager } from './ipc';
|
||||
|
||||
// Keep a global reference of the window objects, if we don't, the window will
|
||||
// be closed automatically when the JavaScript object is garbage collected.
|
||||
@@ -63,10 +61,6 @@ export function createMainWindow(): Electron.BrowserWindow {
|
||||
shell.openExternal(url);
|
||||
});
|
||||
|
||||
ipcMainManager.on(IpcEvents.SHOW_INACTIVE, () => {
|
||||
browserWindow.showInactive();
|
||||
});
|
||||
|
||||
browserWindows.push(browserWindow);
|
||||
|
||||
return browserWindow;
|
||||
|
||||
+32
-22
@@ -1,6 +1,3 @@
|
||||
import { initSentry } from '../sentry';
|
||||
initSentry();
|
||||
|
||||
import { when } from 'mobx';
|
||||
import * as MonacoType from 'monaco-editor';
|
||||
|
||||
@@ -9,7 +6,6 @@ import {
|
||||
ALL_EDITORS,
|
||||
EditorId,
|
||||
EditorValues,
|
||||
GenericDialogType,
|
||||
SetFiddleOptions
|
||||
} from '../interfaces';
|
||||
import { WEBCONTENTS_READY_FOR_IPC_SIGNAL } from '../ipc-events';
|
||||
@@ -55,15 +51,14 @@ export class App {
|
||||
) {
|
||||
// if unsaved, prompt user to make sure they're okay with overwriting and changing directory
|
||||
if (this.state.isUnsaved) {
|
||||
this.state.setGenericDialogOptions({
|
||||
type: GenericDialogType.warning,
|
||||
this.state.setWarningDialogTexts({
|
||||
label: `Opening this Fiddle will replace your unsaved changes. Do you want to proceed?`,
|
||||
ok: 'Yes'
|
||||
});
|
||||
this.state.isGenericDialogShowing = true;
|
||||
await when(() => !this.state.isGenericDialogShowing);
|
||||
this.state.isWarningDialogShowing = true;
|
||||
await when(() => !this.state.isWarningDialogShowing);
|
||||
|
||||
if (!this.state.genericDialogLastResult) {
|
||||
if (!this.state.warningDialogLastResult) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@@ -78,14 +73,16 @@ export class App {
|
||||
|
||||
// once loaded, we have a "saved" state
|
||||
this.state.isUnsaved = false;
|
||||
this.setupUnsavedOnChangeListener();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the contents of all editor panes.
|
||||
* Sets the values on all three editors.
|
||||
*
|
||||
* @param {EditorValues} values
|
||||
* @param {warn} warn - Should we warn before overwriting unsaved data?
|
||||
*/
|
||||
public async setEditorValues(values: Partial<EditorValues>): Promise<void> {
|
||||
const { ElectronFiddle: fiddle } = window;
|
||||
@@ -99,16 +96,9 @@ export class App {
|
||||
const backup = this.state.closedPanels[name];
|
||||
|
||||
if (typeof values[name] !== 'undefined') {
|
||||
if (isEditorBackup(backup)) {
|
||||
// The editor does not exist, attempt to set it on the backup.
|
||||
// If there's a model, we'll do it on the model. Else, we'll
|
||||
// set the value.
|
||||
|
||||
if (backup.model) {
|
||||
backup.model.setValue(values[name]!);
|
||||
} else {
|
||||
backup.value = values[name]!;
|
||||
}
|
||||
if (isEditorBackup(backup) && backup.model) {
|
||||
// The editor does not exist, attempt to set it on the backup
|
||||
backup.model.setValue(values[name]!);
|
||||
} else if (editor && editor.setValue) {
|
||||
// The editor exists, set the value directly
|
||||
editor.setValue(values[name]!);
|
||||
@@ -118,7 +108,7 @@ export class App {
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieves the contents of all editor panes.
|
||||
* Gets the values on all three editors.
|
||||
*
|
||||
* @returns {EditorValues}
|
||||
*/
|
||||
@@ -132,7 +122,6 @@ export class App {
|
||||
}
|
||||
|
||||
const values: EditorValues = {
|
||||
css: getEditorValue(EditorId.css),
|
||||
html: getEditorValue(EditorId.html),
|
||||
main: getEditorValue(EditorId.main),
|
||||
preload: getEditorValue(EditorId.preload),
|
||||
@@ -176,9 +165,30 @@ export class App {
|
||||
|
||||
ipcRenderer.send(WEBCONTENTS_READY_FOR_IPC_SIGNAL);
|
||||
|
||||
// TODO: A timer here is terrible. Let's fix this
|
||||
// and ensure we actually do it once Editors have mounted.
|
||||
setTimeout(() => {
|
||||
this.setupUnsavedOnChangeListener();
|
||||
}, 1500);
|
||||
|
||||
return rendered;
|
||||
}
|
||||
|
||||
/**
|
||||
* If the editor is changed for the first time, we'll
|
||||
* set `isUnsaved` to true. That way, the app can warn you
|
||||
* if you're about to throw things away.
|
||||
*/
|
||||
public setupUnsavedOnChangeListener() {
|
||||
Object.keys(window.ElectronFiddle.editors).forEach((key) => {
|
||||
const editor = window.ElectronFiddle.editors[key];
|
||||
const disposable = editor.onDidChangeModelContent(() => {
|
||||
this.state.isUnsaved = true;
|
||||
disposable.dispose();
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Loads theme CSS into the HTML document.
|
||||
*
|
||||
|
||||
+216
-239
@@ -1,259 +1,236 @@
|
||||
import * as fsType from 'fs-extra';
|
||||
import * as path from 'path';
|
||||
|
||||
import { VersionState } from '../interfaces';
|
||||
import { fancyImport } from '../utils/import';
|
||||
import { normalizeVersion } from '../utils/normalize-version';
|
||||
import { USER_DATA_PATH } from './constants';
|
||||
import { removeTypeDefsForVersion } from './fetch-types';
|
||||
import { AppState } from './state';
|
||||
import { getOfflineTypeDefinitionPath } from './fetch-types';
|
||||
|
||||
/**
|
||||
* General setup, called with a version. Is called during construction
|
||||
* to ensure that we always have or download at least one version.
|
||||
* The binary manager takes care of downloading Electron versions
|
||||
*
|
||||
* @param {string} iVersion
|
||||
* @returns {Promise<void>}
|
||||
* @export
|
||||
* @class BinaryManager
|
||||
*/
|
||||
export async function setupBinary(appState: AppState, iVersion: string): Promise<void> {
|
||||
const version = normalizeVersion(iVersion);
|
||||
const fs = await fancyImport<typeof fsType>('fs-extra');
|
||||
export class BinaryManager {
|
||||
public state: Record<string, 'ready' | 'downloading'> = {};
|
||||
|
||||
await fs.mkdirp(getDownloadPath(version));
|
||||
/**
|
||||
* Remove a version from disk. Does not update state. We'll try up to
|
||||
* four times before giving up if an error occurs.
|
||||
*
|
||||
* @param {string} iVersion
|
||||
* @returns {Promise<void>}
|
||||
*/
|
||||
public async remove(iVersion: string): Promise<void> {
|
||||
const version = normalizeVersion(iVersion);
|
||||
const fs = await fancyImport<typeof fsType>('fs-extra');
|
||||
let isDeleted = false;
|
||||
|
||||
const { state } = appState.versions[version];
|
||||
if (state === VersionState.downloading || state === VersionState.unzipping) {
|
||||
console.log(`Binary: Electron ${version} already downloading.`);
|
||||
return;
|
||||
}
|
||||
|
||||
if (await getIsDownloaded(version)) {
|
||||
console.log(`Binary: Electron ${version} already downloaded.`);
|
||||
appState.versions[version].state = VersionState.ready;
|
||||
return;
|
||||
}
|
||||
|
||||
console.log(`Binary: Electron ${version} not present, downloading`);
|
||||
appState.versions[version].state = VersionState.downloading;
|
||||
|
||||
const zipPath = await download(appState, version);
|
||||
const extractPath = getDownloadPath(version);
|
||||
console.log(`Binary: Electron ${version} downloaded, now unpacking to ${extractPath}`);
|
||||
|
||||
try {
|
||||
appState.versions[version].state = VersionState.unzipping;
|
||||
|
||||
// Ensure the target path is empty
|
||||
await fs.emptyDir(extractPath);
|
||||
|
||||
const electronFiles = await unzip(zipPath, extractPath);
|
||||
console.log(`Unzipped ${version}`, electronFiles);
|
||||
} catch (error) {
|
||||
console.warn(`Failure while unzipping ${version}`, error);
|
||||
appState.versions[version].state = VersionState.unknown;
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
appState.versions[version].state = VersionState.ready;
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove a version from disk. Does not update state. We'll try up to
|
||||
* four times before giving up if an error occurs.
|
||||
*
|
||||
* @param {string} iVersion
|
||||
* @returns {Promise<void>}
|
||||
*/
|
||||
export async function removeBinary(iVersion: string) {
|
||||
const version = normalizeVersion(iVersion);
|
||||
const fs = await fancyImport<typeof fsType>('fs-extra');
|
||||
let isDeleted = false;
|
||||
|
||||
// utility to re-run removal functions upon failure
|
||||
// due to windows filesystem lockfile jank
|
||||
const rerunner = async (func: () => Promise<void>, counter: number = 1) => {
|
||||
try {
|
||||
await func();
|
||||
} catch (error) {
|
||||
console.warn(`Binary Manager: failed to run ${func.name} for ${version}, but failed`, error);
|
||||
if (counter < 4) {
|
||||
console.log(`Binary Manager: Trying again to run ${func.name}`);
|
||||
await rerunner(func, counter + 1);
|
||||
// utility to re-run removal functions upon failure
|
||||
// due to windows filesystem lockfile jank
|
||||
const rerunner = async (func: () => Promise<void>, counter: number = 1) => {
|
||||
try {
|
||||
await func();
|
||||
} catch (error) {
|
||||
console.warn(`Binary Manager: failed to run ${func.name} for ${version}, but failed`, error);
|
||||
if (counter < 4) {
|
||||
console.log(`Binary Manager: Trying again to run ${func.name}`);
|
||||
await rerunner(func, counter + 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
const binaryCleaner = async () => {
|
||||
if (await getIsDownloaded(version)) {
|
||||
// This is necessary since we're messing with .asar files inside
|
||||
// the Electron binaries. Electron, powering Fiddle, will try to
|
||||
// "correct" our calls, but we don't want that right here.
|
||||
process.noAsar = true;
|
||||
await fs.remove(getDownloadPath(version));
|
||||
process.noAsar = false;
|
||||
|
||||
isDeleted = true;
|
||||
}
|
||||
};
|
||||
|
||||
const typeDefsCleaner = async () => {
|
||||
await removeTypeDefsForVersion(version);
|
||||
};
|
||||
|
||||
await rerunner(binaryCleaner);
|
||||
|
||||
if (isDeleted) {
|
||||
await rerunner(typeDefsCleaner);
|
||||
}
|
||||
}
|
||||
|
||||
/* Did we already download a given version?
|
||||
*
|
||||
* @param {string} version
|
||||
* @param {string} dir
|
||||
* @returns {boolean}
|
||||
*/
|
||||
export async function getIsDownloaded(version: string, dir?: string): Promise<boolean> {
|
||||
const expectedPath = getElectronBinaryPath(version, dir);
|
||||
const fs = await fancyImport<typeof fsType>('fs-extra');
|
||||
|
||||
return fs.existsSync(expectedPath);
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the expected path for the binary of a given Electron version
|
||||
*
|
||||
* @param {string} version
|
||||
* @param {string} dir
|
||||
* @returns {string}
|
||||
*/
|
||||
export function getElectronBinaryPath(
|
||||
version: string,
|
||||
dir: string = getDownloadPath(version),
|
||||
): string {
|
||||
switch (process.platform) {
|
||||
case 'darwin':
|
||||
return path.join(dir, 'Electron.app/Contents/MacOS/Electron');
|
||||
case 'freebsd':
|
||||
case 'linux':
|
||||
return path.join(dir, 'electron');
|
||||
case 'win32':
|
||||
return path.join(dir, 'electron.exe');
|
||||
default:
|
||||
throw new Error(`Electron builds are not available for ${process.platform}`);
|
||||
}
|
||||
}
|
||||
|
||||
export function getDownloadingVersions(appState: AppState) {
|
||||
return Object.entries(appState.versions)
|
||||
.filter(([_, { state }]) => state === 'downloading')
|
||||
.map(([version, _]) => version);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns an array of all versions downloaded to disk
|
||||
*
|
||||
* @returns {Promise<Array<string>>}
|
||||
*/
|
||||
export async function getDownloadedVersions(): Promise<Array<string>> {
|
||||
const fs = await fancyImport<typeof fsType>('fs-extra');
|
||||
const downloadPath = path.join(USER_DATA_PATH, 'electron-bin');
|
||||
console.log(`Binary: Checking for downloaded versions`);
|
||||
|
||||
try {
|
||||
const directories = await fs.readdir(downloadPath);
|
||||
const knownVersions: Array<string> = [];
|
||||
|
||||
for (const directory of directories) {
|
||||
if (await getIsDownloaded(directory)) {
|
||||
knownVersions.push(directory);
|
||||
}
|
||||
}
|
||||
|
||||
return knownVersions;
|
||||
} catch (error) {
|
||||
console.warn(`Could not read known Electron versions`);
|
||||
return [];
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Download an Electron version.
|
||||
*
|
||||
* @param {AppState} appState
|
||||
* @param {string} version
|
||||
* @returns {Promise<string>}
|
||||
*/
|
||||
async function download(appState: AppState, version: string): Promise<string> {
|
||||
const { download: electronDownload } = await import('@electron/get');
|
||||
const getProgressCallback = (progress: Progress) => {
|
||||
const roundedProgress = Math.round(progress.percent * 100) / 100;
|
||||
|
||||
if (roundedProgress !== appState.versions[version].downloadProgress) {
|
||||
console.debug(`Binary: Version ${version} download progress: ${progress.percent}`);
|
||||
appState.versions[version].downloadProgress = roundedProgress;
|
||||
}
|
||||
};
|
||||
|
||||
if (!appState.versions[version]) {
|
||||
throw new Error(`Version ${version} does not exist in state, cannot download`);
|
||||
}
|
||||
|
||||
const zipFilePath = await electronDownload(version, {
|
||||
downloadOptions: {
|
||||
quiet: true,
|
||||
getProgressCallback
|
||||
}
|
||||
});
|
||||
|
||||
return zipFilePath;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the expected path for a given Electron version
|
||||
*
|
||||
* @param {string} version
|
||||
* @returns {string}
|
||||
*/
|
||||
function getDownloadPath(version: string): string {
|
||||
return path.join(USER_DATA_PATH, 'electron-bin', version);
|
||||
}
|
||||
|
||||
/**
|
||||
* Unzips an electron package so that we can actually use it.
|
||||
*
|
||||
* @param {string} zipPath
|
||||
* @param {string} extractPath
|
||||
* @returns {Promise<void>}
|
||||
*/
|
||||
function unzip(zipPath: string, extractPath: string): Promise<void> {
|
||||
return new Promise(async (resolve, reject) => {
|
||||
const extract = (await fancyImport<any>('extract-zip')).default;
|
||||
|
||||
process.noAsar = true;
|
||||
|
||||
const options = {
|
||||
dir: extractPath,
|
||||
};
|
||||
|
||||
extract(zipPath, options, (error: Error) => {
|
||||
if (error) {
|
||||
reject(error);
|
||||
return;
|
||||
const binaryCleaner = async () => {
|
||||
if (await this.getIsDownloaded(version)) {
|
||||
// This is necessary since we're messing with .asar files inside
|
||||
// the Electron binaries. Electron, powering Fiddle, will try to
|
||||
// "correct" our calls, but we don't want that right here.
|
||||
process.noAsar = true;
|
||||
await fs.remove(this.getDownloadPath(version));
|
||||
process.noAsar = false;
|
||||
|
||||
isDeleted = true;
|
||||
}
|
||||
};
|
||||
|
||||
const typeDefsCleaner = async () => {
|
||||
await this.removeTypeDefsForVersion(version);
|
||||
};
|
||||
|
||||
await rerunner(binaryCleaner);
|
||||
|
||||
if (isDeleted) {
|
||||
await rerunner(typeDefsCleaner);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* General setup, called with a version. Is called during construction
|
||||
* to ensure that we always have or download at least one version.
|
||||
*
|
||||
* @param {string} iVersion
|
||||
* @returns {Promise<void>}
|
||||
*/
|
||||
public async setup(iVersion: string): Promise<void> {
|
||||
const version = normalizeVersion(iVersion);
|
||||
const fs = await fancyImport<typeof fsType>('fs-extra');
|
||||
const { promisify } = await import('util');
|
||||
const eDownload = promisify(require('electron-download'));
|
||||
|
||||
await fs.mkdirp(this.getDownloadPath(version));
|
||||
|
||||
if (this.state[version] === 'downloading') {
|
||||
console.log(`BinaryManager: Electron ${version} already downloading.`);
|
||||
return;
|
||||
}
|
||||
|
||||
if (await this.getIsDownloaded(version)) {
|
||||
console.log(`BinaryManager: Electron ${version} already downloaded.`);
|
||||
this.state[version] = 'ready';
|
||||
return;
|
||||
}
|
||||
|
||||
console.log(`BinaryManager: Electron ${version} not present, downloading`);
|
||||
this.state[version] = 'downloading';
|
||||
|
||||
const zipPath = await eDownload({ version });
|
||||
const extractPath = this.getDownloadPath(version);
|
||||
console.log(`BinaryManager: Electron ${version} downloaded, now unpacking to ${extractPath}`);
|
||||
|
||||
try {
|
||||
// Ensure the target path is empty
|
||||
await fs.emptyDir(extractPath);
|
||||
|
||||
const electronFiles = await this.unzip(zipPath, extractPath);
|
||||
console.log(`Unzipped ${version}`, electronFiles);
|
||||
} catch (error) {
|
||||
console.warn(`Failure while unzipping ${version}`, error);
|
||||
|
||||
// TODO: Handle this case
|
||||
}
|
||||
|
||||
this.state[version] = 'ready';
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the expected path for the binary of a given Electron version
|
||||
*
|
||||
* @param {string} version
|
||||
* @param {string} dir
|
||||
* @returns {string}
|
||||
*/
|
||||
public getElectronBinaryPath(
|
||||
version: string,
|
||||
dir: string = this.getDownloadPath(version),
|
||||
): string {
|
||||
switch (process.platform) {
|
||||
case 'darwin':
|
||||
return path.join(dir, 'Electron.app/Contents/MacOS/Electron');
|
||||
case 'freebsd':
|
||||
case 'linux':
|
||||
return path.join(dir, 'electron');
|
||||
case 'win32':
|
||||
return path.join(dir, 'electron.exe');
|
||||
default:
|
||||
throw new Error(`Electron builds are not available for ${process.platform}`);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns an array of all versions downloaded to disk
|
||||
*
|
||||
* @returns {Promise<Array<string>>}
|
||||
*/
|
||||
public async getDownloadedVersions(): Promise<Array<string>> {
|
||||
const fs = await fancyImport<typeof fsType>('fs-extra');
|
||||
const downloadPath = path.join(USER_DATA_PATH, 'electron-bin');
|
||||
console.log(`BinaryManager: Checking for downloaded versions`);
|
||||
|
||||
try {
|
||||
const directories = await fs.readdir(downloadPath);
|
||||
const knownVersions: Array<string> = [];
|
||||
|
||||
for (const directory of directories) {
|
||||
if (await this.getIsDownloaded(directory)) {
|
||||
knownVersions.push(directory);
|
||||
}
|
||||
}
|
||||
|
||||
console.log(`Binary: Unpacked!`);
|
||||
process.noAsar = false;
|
||||
return knownVersions;
|
||||
} catch (error) {
|
||||
console.warn(`Could not read known Electron versions`);
|
||||
return [];
|
||||
}
|
||||
}
|
||||
|
||||
resolve();
|
||||
/**
|
||||
* Did we already download a given version?
|
||||
*
|
||||
* @param {string} version
|
||||
* @param {string} dir
|
||||
* @returns {boolean}
|
||||
*/
|
||||
public async getIsDownloaded(version: string, dir?: string): Promise<boolean> {
|
||||
const expectedPath = this.getElectronBinaryPath(version, dir);
|
||||
const fs = await fancyImport<typeof fsType>('fs-extra');
|
||||
|
||||
return fs.existsSync(expectedPath);
|
||||
}
|
||||
|
||||
public async removeTypeDefsForVersion(version: string) {
|
||||
const fs = await fancyImport<typeof fsType>('fs-extra');
|
||||
const _version = normalizeVersion(version);
|
||||
const typeDefsDir = path.dirname(getOfflineTypeDefinitionPath(_version));
|
||||
|
||||
if (fs.existsSync(typeDefsDir)) {
|
||||
try {
|
||||
await fs.remove(typeDefsDir);
|
||||
} catch (error) {
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the expected path for a given Electron version
|
||||
*
|
||||
* @param {string} version
|
||||
* @returns {string}
|
||||
*/
|
||||
private getDownloadPath(version: string): string {
|
||||
return path.join(USER_DATA_PATH, 'electron-bin', version);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Unzips an electron package so that we can actually use it.
|
||||
*
|
||||
* @param {string} zipPath
|
||||
* @param {string} extractPath
|
||||
* @returns {Promise<void>}
|
||||
*/
|
||||
private unzip(zipPath: string, extractPath: string): Promise<void> {
|
||||
return new Promise(async (resolve, reject) => {
|
||||
const extract = (await fancyImport<any>('extract-zip')).default;
|
||||
|
||||
process.noAsar = true;
|
||||
|
||||
const options = {
|
||||
dir: extractPath,
|
||||
};
|
||||
|
||||
extract(zipPath, options, (error: Error) => {
|
||||
if (error) {
|
||||
reject(error);
|
||||
return;
|
||||
}
|
||||
|
||||
console.log(`BinaryManager: Unpacked!`);
|
||||
process.noAsar = false;
|
||||
|
||||
resolve();
|
||||
});
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
interface Progress {
|
||||
percent: number;
|
||||
transferred: number;
|
||||
total: number;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,12 +1,12 @@
|
||||
import { RunnableVersion } from '../interfaces';
|
||||
import { ElectronVersion } from '../interfaces';
|
||||
|
||||
export class Bisector {
|
||||
public revList: Array<RunnableVersion>;
|
||||
public revList: Array<ElectronVersion>;
|
||||
public minRev: number;
|
||||
public maxRev: number;
|
||||
private pivot: number;
|
||||
|
||||
constructor(revList: Array<RunnableVersion>) {
|
||||
constructor(revList: Array<ElectronVersion>) {
|
||||
this.getCurrentVersion = this.getCurrentVersion.bind(this);
|
||||
this.continue = this.continue.bind(this);
|
||||
this.calculatePivot = this.calculatePivot.bind(this);
|
||||
|
||||
@@ -2,7 +2,6 @@ import { Button } from '@blueprintjs/core';
|
||||
import { observer } from 'mobx-react';
|
||||
import * as React from 'react';
|
||||
|
||||
import { GenericDialogType, VersionState } from '../../../src/interfaces';
|
||||
import { AppState } from '../state';
|
||||
|
||||
interface BisectHandlerProps {
|
||||
@@ -19,25 +18,12 @@ export class BisectHandler extends React.Component<BisectHandlerProps> {
|
||||
}
|
||||
|
||||
public continueBisect(isGood: boolean) {
|
||||
window.ElectronFiddle.app.runner.stop();
|
||||
|
||||
const { appState } = this.props;
|
||||
const response = appState.Bisector!.continue(isGood);
|
||||
|
||||
if (Array.isArray(response)) {
|
||||
this.terminateBisect();
|
||||
|
||||
const [minRev, maxRev] = response;
|
||||
const [minVer, maxVer] = [minRev.version, maxRev.version];
|
||||
const message = `Check between versions ${minVer} and ${maxVer}.`;
|
||||
|
||||
appState.pushOutput(`[BISECT] Complete: ${message}`);
|
||||
appState.setGenericDialogOptions({
|
||||
type: GenericDialogType.success,
|
||||
label: `Bisect complete. ${message}`,
|
||||
cancel: undefined
|
||||
});
|
||||
appState.isGenericDialogShowing = true;
|
||||
appState.pushOutput(`[BISECT] Complete: Check between versions ${minRev.version} and ${maxRev.version}.`);
|
||||
} else {
|
||||
appState.setVersion(response.version);
|
||||
}
|
||||
@@ -51,18 +37,15 @@ export class BisectHandler extends React.Component<BisectHandlerProps> {
|
||||
public render() {
|
||||
const { appState } = this.props;
|
||||
if (!!appState.Bisector) {
|
||||
const isDownloading = appState.currentElectronVersion.state === VersionState.downloading;
|
||||
return (
|
||||
<>
|
||||
<Button
|
||||
icon={'thumbs-up'}
|
||||
onClick={() => this.continueBisect(true)}
|
||||
disabled={isDownloading}
|
||||
/>
|
||||
<Button
|
||||
icon={'thumbs-down'}
|
||||
onClick={() => this.continueBisect(false)}
|
||||
disabled={isDownloading}
|
||||
/>
|
||||
<Button
|
||||
icon={'cross'}
|
||||
|
||||
@@ -77,7 +77,6 @@ export class EditorDropdown extends React.Component<EditorDropdownProps, EditorD
|
||||
text={TITLE_MAP[id]}
|
||||
id={id}
|
||||
onClick={this.onItemClick}
|
||||
disabled={appState.mosaicArrangement === id} // can't hide last editor panel
|
||||
/>
|
||||
);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,172 @@
|
||||
import { Button, ButtonGroup, MenuItem } from '@blueprintjs/core';
|
||||
import { ItemPredicate, ItemRenderer, Select } from '@blueprintjs/select';
|
||||
import { observer } from 'mobx-react';
|
||||
import * as React from 'react';
|
||||
|
||||
import { ElectronVersion, ElectronVersionSource, VersionState } from '../../interfaces';
|
||||
import { highlightText } from '../../utils/highlight-text';
|
||||
import { sortedElectronMap } from '../../utils/sorted-map';
|
||||
import { AppState } from '../state';
|
||||
import { getReleaseChannel } from '../versions';
|
||||
|
||||
const ElectronVersionSelect = Select.ofType<ElectronVersion>();
|
||||
|
||||
/**
|
||||
* Helper method: Returns the <Select /> label for an Electron
|
||||
* version.
|
||||
*
|
||||
* @param {ElectronVersion} { source, state }
|
||||
* @returns {string}
|
||||
*/
|
||||
export function getItemLabel({ source, state, name }: ElectronVersion): string {
|
||||
let label = '';
|
||||
|
||||
if (source === ElectronVersionSource.local) {
|
||||
label = name || 'Local';
|
||||
} else {
|
||||
if (state === VersionState.unknown) {
|
||||
label = `Not downloaded`;
|
||||
} else if (state === VersionState.ready) {
|
||||
label = `Downloaded`;
|
||||
} else if (state === VersionState.downloading) {
|
||||
label = `Downloading`;
|
||||
}
|
||||
}
|
||||
|
||||
return label;
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper method: Returns the <Select /> icon for an Electron
|
||||
* version.
|
||||
*
|
||||
* @param {ElectronVersion} { state }
|
||||
* @returns
|
||||
*/
|
||||
export function getItemIcon({ state }: ElectronVersion) {
|
||||
return state === 'ready'
|
||||
? 'saved'
|
||||
: state === 'downloading' ? 'cloud-download' : 'cloud';
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper method: Returns the <Select /> predicate for an Electron
|
||||
* version.
|
||||
*
|
||||
* @param {string} query
|
||||
* @param {ElectronVersion} { version }
|
||||
* @returns
|
||||
*/
|
||||
export const filterItem: ItemPredicate<ElectronVersion> = (query, { version }) => {
|
||||
return version.toLowerCase().includes(query.toLowerCase());
|
||||
};
|
||||
|
||||
/**
|
||||
* Helper method: Returns the <Select /> <MenuItem /> for Electron
|
||||
* versions.
|
||||
*
|
||||
* @param {ElectronVersion} item
|
||||
* @param {IItemRendererProps} { handleClick, modifiers, query }
|
||||
* @returns
|
||||
*/
|
||||
export const renderItem: ItemRenderer<ElectronVersion> = (item, { handleClick, modifiers, query }) => {
|
||||
if (!modifiers.matchesPredicate) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return (
|
||||
<MenuItem
|
||||
active={modifiers.active}
|
||||
disabled={modifiers.disabled}
|
||||
text={highlightText(item.version, query)}
|
||||
key={item.version}
|
||||
onClick={handleClick}
|
||||
label={getItemLabel(item)}
|
||||
icon={getItemIcon(item)}
|
||||
/>
|
||||
);
|
||||
};
|
||||
|
||||
export interface VersionChooserState {
|
||||
value: string;
|
||||
}
|
||||
|
||||
export interface VersionChooserProps {
|
||||
appState: AppState;
|
||||
}
|
||||
|
||||
|
||||
export const getVersionsFromAppState = (appState: AppState) => {
|
||||
const { versions, versionsToShow, statesToShow } = appState;
|
||||
|
||||
return sortedElectronMap<ElectronVersion>(versions, (_key, item) => item)
|
||||
.filter((item) => {
|
||||
if (!item) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Check if we want to show the version
|
||||
if (!versionsToShow.includes(getReleaseChannel(item))) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Check if we want to show the state
|
||||
if (!statesToShow.includes(item.state)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
});
|
||||
};
|
||||
|
||||
/**
|
||||
* A dropdown allowing the selection of Electron versions. The actual
|
||||
* download is managed in the state.
|
||||
*
|
||||
* @class VersionChooser
|
||||
* @extends {React.Component<VersionChooserProps, VersionChooserState>}
|
||||
*/
|
||||
@observer
|
||||
export class ElectronVersionChooser extends React.Component<VersionChooserProps, VersionChooserState> {
|
||||
constructor(props: VersionChooserProps) {
|
||||
super(props);
|
||||
|
||||
this.onItemSelect = this.onItemSelect.bind(this);
|
||||
}
|
||||
|
||||
/**
|
||||
* Handle change, which usually means that we'd like update
|
||||
* the selection version.
|
||||
*
|
||||
* @param {React.ChangeEvent<HTMLSelectElement>} event
|
||||
*/
|
||||
public onItemSelect({ version }: ElectronVersion) {
|
||||
this.props.appState.setVersion(version);
|
||||
}
|
||||
|
||||
public render() {
|
||||
const { currentElectronVersion, Bisector } = this.props.appState;
|
||||
const { version } = currentElectronVersion;
|
||||
|
||||
return (
|
||||
<ButtonGroup>
|
||||
<ElectronVersionSelect
|
||||
filterable={true}
|
||||
items={getVersionsFromAppState(this.props.appState)}
|
||||
itemRenderer={renderItem}
|
||||
itemPredicate={filterItem}
|
||||
onItemSelect={this.onItemSelect}
|
||||
noResults={<MenuItem disabled={true} text='No results.' />}
|
||||
disabled={!!Bisector}
|
||||
>
|
||||
<Button
|
||||
className='version-chooser'
|
||||
text={`Electron v${version}`}
|
||||
icon={getItemIcon(currentElectronVersion)}
|
||||
disabled={!!Bisector}
|
||||
/>
|
||||
</ElectronVersionSelect>
|
||||
</ButtonGroup>
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,151 @@
|
||||
import { Button, ButtonGroup, MenuItem } from '@blueprintjs/core';
|
||||
import { ItemPredicate, ItemRenderer, Select } from '@blueprintjs/select';
|
||||
import { observer } from 'mobx-react';
|
||||
import * as React from 'react';
|
||||
|
||||
import { ElectronVersion, NodeVersion, VersionState } from '../../interfaces';
|
||||
import { highlightText } from '../../utils/highlight-text';
|
||||
import { sortedNodeMap } from '../../utils/sorted-map';
|
||||
import { AppState } from '../state';
|
||||
|
||||
const ElectronVersionSelect = Select.ofType<NodeVersion>();
|
||||
|
||||
/**
|
||||
* Helper method: Returns the <Select /> label for an Electron
|
||||
* version.
|
||||
*
|
||||
* @param {ElectronVersion} { source, state }
|
||||
* @returns {string}
|
||||
*/
|
||||
export function getItemLabel({ state }: NodeVersion): string {
|
||||
let label = '';
|
||||
|
||||
if (state === VersionState.unknown) {
|
||||
label = `Not downloaded`;
|
||||
} else if (state === VersionState.ready) {
|
||||
label = `Downloaded`;
|
||||
} else if (state === VersionState.downloading) {
|
||||
label = `Downloading`;
|
||||
}
|
||||
|
||||
return label;
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper method: Returns the <Select /> icon for an Electron
|
||||
* version.
|
||||
*
|
||||
* @param {ElectronVersion} { state }
|
||||
* @returns
|
||||
*/
|
||||
export function getItemIcon({ state }: NodeVersion) {
|
||||
return state === 'ready'
|
||||
? 'saved'
|
||||
: state === 'downloading' ? 'cloud-download' : 'cloud';
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper method: Returns the <Select /> predicate for an Electron
|
||||
* version.
|
||||
*
|
||||
* @param {string} query
|
||||
* @param {ElectronVersion} { version }
|
||||
* @returns
|
||||
*/
|
||||
export const filterItem: ItemPredicate<NodeVersion> = (query, { version }) => {
|
||||
return version.toLowerCase().includes(query.toLowerCase());
|
||||
};
|
||||
|
||||
/**
|
||||
* Helper method: Returns the <Select /> <MenuItem /> for Electron
|
||||
* versions.
|
||||
*
|
||||
* @param {ElectronVersion} item
|
||||
* @param {IItemRendererProps} { handleClick, modifiers, query }
|
||||
* @returns
|
||||
*/
|
||||
export const renderItem: ItemRenderer<NodeVersion> = (item, { handleClick, modifiers, query }) => {
|
||||
if (!modifiers.matchesPredicate) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return (
|
||||
<MenuItem
|
||||
active={modifiers.active}
|
||||
disabled={modifiers.disabled}
|
||||
text={highlightText(item.version, query)}
|
||||
key={item.version}
|
||||
onClick={handleClick}
|
||||
label={getItemLabel(item)}
|
||||
icon={getItemIcon(item)}
|
||||
/>
|
||||
);
|
||||
};
|
||||
|
||||
export interface VersionChooserState {
|
||||
value: string;
|
||||
}
|
||||
|
||||
export interface VersionChooserProps {
|
||||
appState: AppState;
|
||||
}
|
||||
|
||||
|
||||
export const getVersionsFromAppState = (appState: AppState) => {
|
||||
const { nodeVersions } = appState;
|
||||
|
||||
return sortedNodeMap<NodeVersion>(nodeVersions, (_key, item) => item)
|
||||
.filter((item) => !!item);
|
||||
};
|
||||
|
||||
/**
|
||||
* A dropdown allowing the selection of Electron versions. The actual
|
||||
* download is managed in the state.
|
||||
*
|
||||
* @class VersionChooser
|
||||
* @extends {React.Component<VersionChooserProps, VersionChooserState>}
|
||||
*/
|
||||
@observer
|
||||
export class NodeVersionChooser extends React.Component<VersionChooserProps, VersionChooserState> {
|
||||
constructor(props: VersionChooserProps) {
|
||||
super(props);
|
||||
|
||||
this.onItemSelect = this.onItemSelect.bind(this);
|
||||
}
|
||||
|
||||
/**
|
||||
* Handle change, which usually means that we'd like update
|
||||
* the selection version.
|
||||
*
|
||||
* @param {React.ChangeEvent<HTMLSelectElement>} event
|
||||
*/
|
||||
public onItemSelect({ version }: ElectronVersion) {
|
||||
this.props.appState.setNodeVersion(version);
|
||||
}
|
||||
|
||||
public render() {
|
||||
const { currentNodeVersion, Bisector } = this.props.appState;
|
||||
const { version } = currentNodeVersion;
|
||||
|
||||
return (
|
||||
<ButtonGroup>
|
||||
<ElectronVersionSelect
|
||||
filterable={true}
|
||||
items={getVersionsFromAppState(this.props.appState)}
|
||||
itemRenderer={renderItem}
|
||||
itemPredicate={filterItem}
|
||||
onItemSelect={this.onItemSelect}
|
||||
noResults={<MenuItem disabled={true} text='No results.' />}
|
||||
disabled={!!Bisector}
|
||||
>
|
||||
<Button
|
||||
className='version-chooser'
|
||||
text={`Node v${version}`}
|
||||
icon={getItemIcon(currentNodeVersion)}
|
||||
disabled={!!Bisector}
|
||||
/>
|
||||
</ElectronVersionSelect>
|
||||
</ButtonGroup>
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -4,7 +4,7 @@ import * as React from 'react';
|
||||
|
||||
import { when } from 'mobx';
|
||||
import { IpcEvents } from '../../ipc-events';
|
||||
import { INDEX_HTML_NAME, MAIN_JS_NAME, PRELOAD_JS_NAME, RENDERER_JS_NAME, STYLES_CSS_NAME } from '../../shared-constants';
|
||||
import { INDEX_HTML_NAME, MAIN_JS_NAME, RENDERER_JS_NAME } from '../../shared-constants';
|
||||
import { getOctokit } from '../../utils/octokit';
|
||||
import { ipcRendererManager } from '../ipc';
|
||||
import { AppState } from '../state';
|
||||
@@ -34,10 +34,6 @@ export class PublishButton extends React.Component<PublishButtonProps> {
|
||||
ipcRendererManager.on(IpcEvents.FS_SAVE_FIDDLE_GIST, this.handleClick);
|
||||
}
|
||||
|
||||
public componentWillUnmount() {
|
||||
ipcRendererManager.off(IpcEvents.FS_SAVE_FIDDLE_GIST, this.handleClick);
|
||||
}
|
||||
|
||||
/**
|
||||
* When the user clicks the publish button, we either show the
|
||||
* authentication dialog or publish right away.
|
||||
@@ -91,12 +87,6 @@ export class PublishButton extends React.Component<PublishButtonProps> {
|
||||
[RENDERER_JS_NAME]: {
|
||||
content: values.renderer || '// Empty',
|
||||
},
|
||||
[PRELOAD_JS_NAME]: {
|
||||
content: values.preload || '// Empty',
|
||||
},
|
||||
[STYLES_CSS_NAME]: {
|
||||
content: values.css || '/* Empty */',
|
||||
},
|
||||
},
|
||||
} as any); // Note: GitHub messed up, GistsCreateParamsFiles is an incorrect interface
|
||||
|
||||
|
||||
@@ -25,17 +25,13 @@ export class Runner extends React.Component<RunnerProps, RunnerState> {
|
||||
const { isRunning, currentElectronVersion } = this.props.appState;
|
||||
|
||||
const state = currentElectronVersion && currentElectronVersion.state;
|
||||
const props: IButtonProps = { className: 'button-run', disabled: true };
|
||||
const props: IButtonProps = { className: 'button-run' };
|
||||
|
||||
if (state === VersionState.downloading) {
|
||||
props.text = 'Downloading';
|
||||
props.icon = <Spinner size={16} value={currentElectronVersion?.downloadProgress} />;
|
||||
} else if (state === VersionState.unzipping) {
|
||||
props.text = 'Unzipping';
|
||||
props.disabled = true;
|
||||
props.icon = <Spinner size={16} />;
|
||||
} else if (state === VersionState.ready) {
|
||||
props.disabled = false;
|
||||
|
||||
if (isRunning) {
|
||||
props.active = true;
|
||||
props.text = 'Stop';
|
||||
@@ -48,6 +44,7 @@ export class Runner extends React.Component<RunnerProps, RunnerState> {
|
||||
}
|
||||
} else {
|
||||
props.text = 'Checking status';
|
||||
props.disabled = true;
|
||||
props.icon = <Spinner size={16} />;
|
||||
}
|
||||
|
||||
|
||||
@@ -1,29 +0,0 @@
|
||||
import { ButtonGroup } from '@blueprintjs/core';
|
||||
import { observer } from 'mobx-react';
|
||||
import * as React from 'react';
|
||||
|
||||
import { AppState } from '../state';
|
||||
import { VersionSelect } from './version-select';
|
||||
|
||||
export interface VersionChooserProps {
|
||||
appState: AppState;
|
||||
}
|
||||
|
||||
/**
|
||||
* A dropdown allowing the selection of Electron versions. The actual
|
||||
* download is managed in the state.
|
||||
*/
|
||||
export const VersionChooser = observer((props: VersionChooserProps) => {
|
||||
const { currentElectronVersion, Bisector, setVersion } = props.appState;
|
||||
|
||||
return (
|
||||
<ButtonGroup>
|
||||
<VersionSelect
|
||||
appState={props.appState}
|
||||
onVersionSelect={({ version }) => setVersion(version)}
|
||||
currentVersion={currentElectronVersion}
|
||||
disabled={!!Bisector}
|
||||
/>
|
||||
</ButtonGroup>
|
||||
);
|
||||
});
|
||||
@@ -6,9 +6,10 @@ import { AppState } from '../state';
|
||||
import { AddressBar } from './commands-address-bar';
|
||||
import { BisectHandler } from './commands-bisect';
|
||||
import { EditorDropdown } from './commands-editors';
|
||||
import { ElectronVersionChooser } from './commands-electron-chooser';
|
||||
import { NodeVersionChooser } from './commands-node-chooser';
|
||||
import { PublishButton } from './commands-publish-button';
|
||||
import { Runner } from './commands-runner';
|
||||
import { VersionChooser } from './commands-version-chooser';
|
||||
|
||||
export interface CommandsProps {
|
||||
appState: AppState;
|
||||
@@ -35,7 +36,7 @@ export class Commands extends React.Component<CommandsProps, {}> {
|
||||
<div className='commands'>
|
||||
<div>
|
||||
<ControlGroup fill={true} vertical={false}>
|
||||
<VersionChooser appState={appState} />
|
||||
{this.getVersionChooser()}
|
||||
<Runner appState={appState} />
|
||||
</ControlGroup>
|
||||
{
|
||||
@@ -54,6 +55,12 @@ export class Commands extends React.Component<CommandsProps, {}> {
|
||||
text='Console'
|
||||
onClick={appState.toggleConsole}
|
||||
/>
|
||||
<Button
|
||||
active={appState.isNodeMode}
|
||||
icon='ninja'
|
||||
text='Node.js Mode'
|
||||
onClick={appState.toggleNodeMode}
|
||||
/>
|
||||
<EditorDropdown appState={appState} />
|
||||
</ControlGroup>
|
||||
</div>
|
||||
@@ -64,4 +71,14 @@ export class Commands extends React.Component<CommandsProps, {}> {
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
public getVersionChooser() {
|
||||
const { appState } = this.props;
|
||||
|
||||
if (appState.isNodeMode) {
|
||||
return <NodeVersionChooser appState={appState} />;
|
||||
} else {
|
||||
return <ElectronVersionChooser appState={appState} />;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -7,7 +7,6 @@ import * as path from 'path';
|
||||
import * as React from 'react';
|
||||
import { getTheme, THEMES_PATH } from '../themes';
|
||||
|
||||
import { GenericDialogType } from '../../../src/interfaces';
|
||||
import { AppState } from '../state';
|
||||
import { defaultDark, LoadedFiddleTheme } from '../themes-defaults';
|
||||
|
||||
@@ -69,11 +68,8 @@ export class AddThemeDialog extends React.Component<AddThemeDialogProps, AddThem
|
||||
const name = editor.name ? editor.name : file.name;
|
||||
await this.createNewThemeFromMonaco(name, newTheme);
|
||||
} catch (error) {
|
||||
this.props.appState.setGenericDialogOptions({
|
||||
type: GenericDialogType.warning,
|
||||
label: `Error: ${error}, please pick a different file.`
|
||||
});
|
||||
this.props.appState.isGenericDialogShowing = true;
|
||||
this.props.appState.setWarningDialogTexts({label: `Error: ${error}, please pick a different file.`});
|
||||
this.props.appState.isWarningDialogShowing = true;
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
@@ -5,10 +5,9 @@ import * as path from 'path';
|
||||
import * as React from 'react';
|
||||
import * as semver from 'semver';
|
||||
|
||||
import { Version } from '../../interfaces';
|
||||
import { NpmVersion } from '../../interfaces';
|
||||
import { IpcEvents } from '../../ipc-events';
|
||||
import { getElectronNameForPlatform } from '../../utils/electron-name';
|
||||
import { getIsDownloaded } from '../binary';
|
||||
import { ipcRendererManager } from '../ipc';
|
||||
import { AppState } from '../state';
|
||||
|
||||
@@ -59,7 +58,8 @@ export class AddVersionDialog extends React.Component<AddVersionDialogProps, Add
|
||||
* @param {React.ChangeEvent<HTMLInputElement>} event
|
||||
*/
|
||||
public async setFolderPath(folderPath: string) {
|
||||
const isValidElectron = !!await getIsDownloaded('custom', folderPath);
|
||||
const { binaryManager } = this.props.appState;
|
||||
const isValidElectron = !!await binaryManager.getIsDownloaded('custom', folderPath);
|
||||
|
||||
this.setState({ folderPath, isValidElectron });
|
||||
}
|
||||
@@ -90,7 +90,7 @@ export class AddVersionDialog extends React.Component<AddVersionDialogProps, Add
|
||||
.slice(1)
|
||||
.join(path.sep);
|
||||
|
||||
const toAdd: Version = {
|
||||
const toAdd: NpmVersion = {
|
||||
localPath: folderPath,
|
||||
version,
|
||||
name
|
||||
|
||||
@@ -1,27 +1,29 @@
|
||||
import { Button, ButtonGroup, Callout, Dialog, Label } from '@blueprintjs/core';
|
||||
import { Button, Dialog, Label, MenuItem } from '@blueprintjs/core';
|
||||
import { Select } from '@blueprintjs/select';
|
||||
import { observer } from 'mobx-react';
|
||||
import * as React from 'react';
|
||||
|
||||
import { RunnableVersion } from '../../interfaces';
|
||||
import { ElectronVersion } from '../../interfaces';
|
||||
import { Bisector } from '../bisect';
|
||||
import { AppState } from '../state';
|
||||
import { VersionSelect } from './version-select';
|
||||
import { filterItem, getItemIcon, getVersionsFromAppState, renderItem } from './commands-electron-chooser';
|
||||
|
||||
const ElectronVersionSelect = Select.ofType<ElectronVersion>();
|
||||
|
||||
export interface BisectDialogProps {
|
||||
appState: AppState;
|
||||
}
|
||||
|
||||
export interface BisectDialogState {
|
||||
startIndex: number;
|
||||
endIndex: number;
|
||||
allVersions: Array<RunnableVersion>;
|
||||
showHelp?: boolean;
|
||||
startIndex?: number;
|
||||
endIndex?: number;
|
||||
allVersions: Array<ElectronVersion>;
|
||||
}
|
||||
|
||||
/**
|
||||
* The "add version" dialog allows users to add custom builds of Electron.
|
||||
*
|
||||
* @class BisectDialog
|
||||
* @class AddVersionDialog
|
||||
* @extends {React.Component<BisectDialogProps, BisectDialogState>}
|
||||
*/
|
||||
@observer
|
||||
@@ -33,22 +35,16 @@ export class BisectDialog extends React.Component<BisectDialogProps, BisectDialo
|
||||
this.onClose = this.onClose.bind(this);
|
||||
this.onBeginSelect = this.onBeginSelect.bind(this);
|
||||
this.onEndSelect = this.onEndSelect.bind(this);
|
||||
this.showHelp = this.showHelp.bind(this);
|
||||
this.isEarliestItemDisabled = this.isEarliestItemDisabled.bind(this);
|
||||
this.isLatestItemDisabled = this.isLatestItemDisabled.bind(this);
|
||||
|
||||
this.state = {
|
||||
allVersions: this.props.appState.versionsToShow,
|
||||
startIndex: 10,
|
||||
endIndex: 0
|
||||
};
|
||||
const allVersions = getVersionsFromAppState(this.props.appState);
|
||||
this.state = { allVersions };
|
||||
}
|
||||
|
||||
public onBeginSelect(version: RunnableVersion) {
|
||||
public onBeginSelect(version: ElectronVersion) {
|
||||
this.setState({ startIndex: this.state.allVersions.indexOf(version) });
|
||||
}
|
||||
|
||||
public onEndSelect(version: RunnableVersion) {
|
||||
public onEndSelect(version: ElectronVersion) {
|
||||
this.setState({ endIndex: this.state.allVersions.indexOf(version) });
|
||||
}
|
||||
|
||||
@@ -66,7 +62,8 @@ export class BisectDialog extends React.Component<BisectDialogProps, BisectDialo
|
||||
}
|
||||
|
||||
const bisectRange = allVersions
|
||||
.slice(endIndex, startIndex + 1);
|
||||
.slice(endIndex, startIndex + 1)
|
||||
.reverse();
|
||||
|
||||
appState.Bisector = new Bisector(bisectRange);
|
||||
const initialBisectPivot = appState.Bisector.getCurrentVersion().version;
|
||||
@@ -81,30 +78,18 @@ export class BisectDialog extends React.Component<BisectDialogProps, BisectDialo
|
||||
this.props.appState.isBisectDialogShowing = false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Shows the additional help
|
||||
*/
|
||||
public showHelp() {
|
||||
this.setState({ showHelp: true });
|
||||
}
|
||||
|
||||
/**
|
||||
* Can we get this show on the road?
|
||||
*/
|
||||
get canSubmit(): boolean {
|
||||
return this.state.startIndex > this.state.endIndex;
|
||||
}
|
||||
|
||||
/**
|
||||
* Renders the buttons
|
||||
*/
|
||||
get buttons() {
|
||||
const canSubmit =
|
||||
!!this.state.startIndex &&
|
||||
!!this.state.endIndex &&
|
||||
this.state.startIndex > this.state.endIndex;
|
||||
|
||||
return [
|
||||
(
|
||||
<Button
|
||||
icon='play'
|
||||
key='submit'
|
||||
disabled={!this.canSubmit}
|
||||
disabled={!canSubmit}
|
||||
onClick={this.onSubmit}
|
||||
text='Begin'
|
||||
/>
|
||||
@@ -119,47 +104,6 @@ export class BisectDialog extends React.Component<BisectDialogProps, BisectDialo
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Renders the help
|
||||
*/
|
||||
get help() {
|
||||
let moreHelp = (
|
||||
<Button
|
||||
icon='help'
|
||||
text='Show help'
|
||||
onClick={this.showHelp}
|
||||
/>
|
||||
);
|
||||
|
||||
if (this.state.showHelp) {
|
||||
moreHelp = (
|
||||
<>
|
||||
<p>
|
||||
First, write a fiddle that reproduces a bug or an issue. Then, select the earliest version to
|
||||
start your search with. Typically, that's the "last known good" version that did not have the bug.
|
||||
Then, select that latest version to end the search with, usually the "first known bad" version.
|
||||
</p>
|
||||
<p>
|
||||
Once you begin your bisect, Fiddle will run your fiddle with a number of Electron versions, closing
|
||||
in on the version that introduced the bug. Once completed, you will know which Electron version
|
||||
introduced your issue.
|
||||
</p>
|
||||
</>
|
||||
);
|
||||
}
|
||||
|
||||
return (
|
||||
<Callout style={{ marginTop: 0, marginBottom: '1rem' }}>
|
||||
<p>
|
||||
A "bisect" is a popular method <a href='https://git-scm.com/docs/git-bisect' target='_blank'>
|
||||
borrowed from <code>git</code></a> for learning which version of Electron introduced a bug. This
|
||||
tool helps you perform a bisect.
|
||||
</p>
|
||||
{moreHelp}
|
||||
</Callout>
|
||||
);
|
||||
}
|
||||
|
||||
public render() {
|
||||
const { isBisectDialogShowing } = this.props.appState;
|
||||
const { startIndex, endIndex, allVersions } = this.state;
|
||||
@@ -172,28 +116,41 @@ export class BisectDialog extends React.Component<BisectDialogProps, BisectDialo
|
||||
className='dialog-add-version'
|
||||
>
|
||||
<div className='bp3-dialog-body'>
|
||||
{this.help}
|
||||
<Label>
|
||||
Earliest Version (Last "known good" version)
|
||||
<ButtonGroup fill={true}>
|
||||
<VersionSelect
|
||||
currentVersion={allVersions[startIndex]}
|
||||
appState={this.props.appState}
|
||||
onVersionSelect={this.onBeginSelect}
|
||||
itemDisabled={this.isEarliestItemDisabled}
|
||||
Earliest Version
|
||||
<ElectronVersionSelect
|
||||
filterable={true}
|
||||
items={allVersions}
|
||||
itemRenderer={renderItem}
|
||||
itemPredicate={filterItem}
|
||||
onItemSelect={this.onBeginSelect}
|
||||
noResults={<MenuItem disabled={true} text='No results.' />}
|
||||
>
|
||||
<Button
|
||||
text={startIndex ? `v${allVersions[startIndex].version}` : ``}
|
||||
icon={startIndex ? getItemIcon(allVersions[startIndex]) : 'small-minus'}
|
||||
fill={true}
|
||||
/>
|
||||
</ButtonGroup>
|
||||
</ElectronVersionSelect>
|
||||
</Label>
|
||||
<Label>
|
||||
Latest Version (First "known bad" version)
|
||||
<ButtonGroup fill={true}>
|
||||
<VersionSelect
|
||||
currentVersion={allVersions[endIndex]}
|
||||
appState={this.props.appState}
|
||||
onVersionSelect={this.onEndSelect}
|
||||
itemDisabled={this.isLatestItemDisabled}
|
||||
Latest Version
|
||||
<ElectronVersionSelect
|
||||
filterable={true}
|
||||
items={allVersions.slice(0, startIndex!)}
|
||||
itemRenderer={renderItem}
|
||||
itemPredicate={filterItem}
|
||||
onItemSelect={this.onEndSelect}
|
||||
noResults={<MenuItem disabled={true} text='No results.' />}
|
||||
disabled={!startIndex}
|
||||
>
|
||||
<Button
|
||||
text={endIndex ? `v${allVersions[endIndex].version}` : ``}
|
||||
icon={endIndex ? getItemIcon(allVersions[endIndex]) : 'small-minus'}
|
||||
fill={true}
|
||||
disabled={!startIndex}
|
||||
/>
|
||||
</ButtonGroup>
|
||||
</ElectronVersionSelect>
|
||||
</Label>
|
||||
</div>
|
||||
<div className='bp3-dialog-footer'>
|
||||
@@ -204,33 +161,4 @@ export class BisectDialog extends React.Component<BisectDialogProps, BisectDialo
|
||||
</Dialog>
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Should an item in the "earliest version" dropdown be disabled?
|
||||
*
|
||||
* @param {RunnableVersion} version
|
||||
* @returns {boolean}
|
||||
*/
|
||||
public isEarliestItemDisabled(version: RunnableVersion): boolean {
|
||||
const { allVersions, endIndex } = this.state;
|
||||
|
||||
// In the array, "newer" versions will have a lower index.
|
||||
// 0: 5.0.0
|
||||
// 1: 4.0.0
|
||||
// 2: 3.0.0
|
||||
// ...
|
||||
return allVersions.indexOf(version) < endIndex + 1;
|
||||
}
|
||||
|
||||
/**
|
||||
* Should an item in the "latest version" dropdown be disabled?
|
||||
*
|
||||
* @param {RunnableVersion} version
|
||||
* @returns {boolean}
|
||||
*/
|
||||
public isLatestItemDisabled(version: RunnableVersion): boolean {
|
||||
const { allVersions, startIndex } = this.state;
|
||||
|
||||
return allVersions.indexOf(version) > startIndex - 1;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,51 @@
|
||||
|
||||
import { Alert, Intent } from '@blueprintjs/core';
|
||||
import { observer } from 'mobx-react';
|
||||
import * as React from 'react';
|
||||
|
||||
import { AppState } from '../state';
|
||||
|
||||
export interface ConfirmDialogProps {
|
||||
appState: AppState;
|
||||
}
|
||||
|
||||
export interface ConfirmDialogState {
|
||||
}
|
||||
|
||||
/**
|
||||
* The token dialog prompts the user to either continue or cancel the operation.
|
||||
*
|
||||
* @export
|
||||
* @class ConfirmDialog
|
||||
* @extends {React.Component<ConfirmDialogProps, ConfirmDialogState>}
|
||||
*/
|
||||
@observer
|
||||
export class ConfirmDialog extends React.Component<ConfirmDialogProps, ConfirmDialogState> {
|
||||
constructor(props: ConfirmDialogProps) {
|
||||
super(props);
|
||||
|
||||
this.onClose = this.onClose.bind(this);
|
||||
}
|
||||
|
||||
public onClose(result: boolean) {
|
||||
this.props.appState.confirmationPromptLastResult = result;
|
||||
this.props.appState.toggleConfirmationPromptDialog();
|
||||
}
|
||||
|
||||
public render() {
|
||||
const { isConfirmationPromptShowing, confirmationDialogTexts } = this.props.appState;
|
||||
|
||||
return (
|
||||
<Alert
|
||||
isOpen={isConfirmationPromptShowing}
|
||||
onClose={this.onClose}
|
||||
icon='help'
|
||||
confirmButtonText={confirmationDialogTexts.ok}
|
||||
cancelButtonText={confirmationDialogTexts.cancel}
|
||||
intent={Intent.PRIMARY}
|
||||
>
|
||||
<p>{confirmationDialogTexts.label}</p>
|
||||
</Alert>
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -1,73 +0,0 @@
|
||||
|
||||
import { Alert, IconName, Intent} from '@blueprintjs/core';
|
||||
import { observer } from 'mobx-react';
|
||||
import * as React from 'react';
|
||||
|
||||
import { GenericDialogType } from '../../../src/interfaces';
|
||||
import { AppState } from '../state';
|
||||
|
||||
export interface GenericDialogProps {
|
||||
appState: AppState;
|
||||
}
|
||||
|
||||
export interface GenericDialogState {
|
||||
}
|
||||
|
||||
/**
|
||||
* The token dialog prompts the user to either continue or cancel the operation.
|
||||
*
|
||||
* @export
|
||||
* @class GenericDialog
|
||||
* @extends {React.Component<GenericDialogProps, GenericDialogState>}
|
||||
*/
|
||||
@observer
|
||||
export class GenericDialog extends React.Component<GenericDialogProps, GenericDialogState> {
|
||||
constructor(props: GenericDialogProps) {
|
||||
super(props);
|
||||
|
||||
this.onClose = this.onClose.bind(this);
|
||||
}
|
||||
|
||||
public onClose(result: boolean) {
|
||||
this.props.appState.genericDialogLastResult = result;
|
||||
this.props.appState.toggleGenericDialog();
|
||||
}
|
||||
|
||||
public render() {
|
||||
const { isGenericDialogShowing, genericDialogOptions } = this.props.appState;
|
||||
const {type, ok, cancel, label} = genericDialogOptions;
|
||||
|
||||
let intent: Intent;
|
||||
let icon: IconName;
|
||||
switch (type) {
|
||||
case GenericDialogType.warning:
|
||||
intent = Intent.DANGER;
|
||||
icon = 'warning-sign';
|
||||
break;
|
||||
case GenericDialogType.confirm:
|
||||
intent = Intent.PRIMARY;
|
||||
icon = 'help';
|
||||
break;
|
||||
case GenericDialogType.success:
|
||||
intent = Intent.SUCCESS;
|
||||
icon = 'info-sign';
|
||||
break;
|
||||
default:
|
||||
intent = Intent.NONE;
|
||||
icon = 'help';
|
||||
break;
|
||||
}
|
||||
return (
|
||||
<Alert
|
||||
isOpen={isGenericDialogShowing}
|
||||
onClose={this.onClose}
|
||||
icon={icon}
|
||||
confirmButtonText={ok}
|
||||
cancelButtonText={cancel}
|
||||
intent={intent}
|
||||
>
|
||||
<p>{label}</p>
|
||||
</Alert>
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
|
||||
import { Alert, Intent } from '@blueprintjs/core';
|
||||
import { observer } from 'mobx-react';
|
||||
import * as React from 'react';
|
||||
|
||||
import { AppState } from '../state';
|
||||
|
||||
export interface WarningDialogProps {
|
||||
appState: AppState;
|
||||
}
|
||||
|
||||
export interface WarningDialogState {
|
||||
}
|
||||
|
||||
/**
|
||||
* The token dialog prompts the user to either continue or cancel the operation.
|
||||
*
|
||||
* @export
|
||||
* @class WarningDialog
|
||||
* @extends {React.Component<WarningDialogProps, WarningDialogState>}
|
||||
*/
|
||||
@observer
|
||||
export class WarningDialog extends React.Component<WarningDialogProps, WarningDialogState> {
|
||||
constructor(props: WarningDialogProps) {
|
||||
super(props);
|
||||
|
||||
this.onClose = this.onClose.bind(this);
|
||||
}
|
||||
|
||||
public onClose(result: boolean) {
|
||||
this.props.appState.warningDialogLastResult = result;
|
||||
this.props.appState.toggleWarningDialog();
|
||||
}
|
||||
|
||||
public render() {
|
||||
const { isWarningDialogShowing, warningDialogTexts } = this.props.appState;
|
||||
return (
|
||||
<Alert
|
||||
isOpen={isWarningDialogShowing}
|
||||
onClose={this.onClose}
|
||||
icon='warning-sign'
|
||||
confirmButtonText={warningDialogTexts.ok}
|
||||
cancelButtonText={warningDialogTexts.cancel}
|
||||
intent={Intent.DANGER}
|
||||
>
|
||||
<p>{warningDialogTexts.label}</p>
|
||||
</Alert>
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -5,8 +5,9 @@ import { AppState } from '../state';
|
||||
import { AddThemeDialog } from './dialog-add-theme';
|
||||
import { AddVersionDialog } from './dialog-add-version';
|
||||
import { BisectDialog } from './dialog-bisect';
|
||||
import { GenericDialog } from './dialog-generic';
|
||||
import { ConfirmDialog } from './dialog-confirm';
|
||||
import { TokenDialog } from './dialog-token';
|
||||
import { WarningDialog } from './dialog-warning';
|
||||
import { Settings } from './settings';
|
||||
|
||||
export interface DialogsProps {
|
||||
@@ -28,8 +29,7 @@ export class Dialogs extends React.Component<DialogsProps, {}> {
|
||||
isSettingsShowing,
|
||||
isAddVersionDialogShowing,
|
||||
isThemeDialogShowing,
|
||||
isBisectDialogShowing,
|
||||
isGenericDialogShowing
|
||||
isBisectDialogShowing
|
||||
} = appState;
|
||||
const maybeToken = isTokenDialogShowing
|
||||
? <TokenDialog key='dialogs' appState={appState} />
|
||||
@@ -45,9 +45,9 @@ export class Dialogs extends React.Component<DialogsProps, {}> {
|
||||
const maybeBisect = isBisectDialogShowing
|
||||
? <BisectDialog key='bisect-dialog' appState={appState} />
|
||||
: null;
|
||||
const genericDialog = isGenericDialogShowing
|
||||
? <GenericDialog appState={appState} />
|
||||
: null;
|
||||
const eitherWarningOrPrompt = appState.isWarningDialogShowing
|
||||
? <WarningDialog appState={appState} />
|
||||
: <ConfirmDialog appState={appState} />;
|
||||
|
||||
return (
|
||||
<div key='dialogs' className='dialogs'>
|
||||
@@ -56,7 +56,7 @@ export class Dialogs extends React.Component<DialogsProps, {}> {
|
||||
{maybeAddLocalVersion}
|
||||
{maybeMonaco}
|
||||
{maybeBisect}
|
||||
{genericDialog}
|
||||
{eitherWarningOrPrompt}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
@@ -16,7 +16,6 @@ export interface EditorProps {
|
||||
options?: Partial<MonacoType.editor.IEditorConstructionOptions>;
|
||||
editorDidMount?: (editor: MonacoType.editor.IStandaloneCodeEditor) => void;
|
||||
onChange?: (value: string, event: MonacoType.editor.IModelContentChangedEvent) => void;
|
||||
setFocused: (id: EditorId) => void;
|
||||
}
|
||||
|
||||
export class Editor extends React.Component<EditorProps> {
|
||||
@@ -29,16 +28,7 @@ export class Editor extends React.Component<EditorProps> {
|
||||
constructor(props: EditorProps) {
|
||||
super(props);
|
||||
|
||||
switch (props.id) {
|
||||
case 'html':
|
||||
this.language = 'html';
|
||||
break;
|
||||
case 'css':
|
||||
this.language = 'css';
|
||||
break;
|
||||
default:
|
||||
this.language = 'javascript';
|
||||
}
|
||||
this.language = props.id === 'html' ? 'html' : 'javascript';
|
||||
}
|
||||
|
||||
public shouldComponentUpdate() {
|
||||
@@ -90,12 +80,6 @@ export class Editor extends React.Component<EditorProps> {
|
||||
...monacoOptions
|
||||
});
|
||||
|
||||
// mark this editor as focused whenever it is
|
||||
this.editor.onDidFocusEditorText(() => {
|
||||
const { id, setFocused } = this.props;
|
||||
setFocused(id);
|
||||
});
|
||||
|
||||
await this.editorDidMount(this.editor);
|
||||
}
|
||||
}
|
||||
@@ -114,23 +98,6 @@ export class Editor extends React.Component<EditorProps> {
|
||||
return <div className='editorContainer' ref={this.containerRef} />;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a model and attach it to the editor
|
||||
*
|
||||
* @private
|
||||
* @param {string} value
|
||||
*/
|
||||
private async createModel(value: string) {
|
||||
const { monaco } = this.props;
|
||||
|
||||
const model = monaco.editor.createModel(value, this.language);
|
||||
model.updateOptions({
|
||||
tabSize: 2
|
||||
});
|
||||
|
||||
this.editor.setModel(model);
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the content on the editor, including the model and the view state.
|
||||
*
|
||||
@@ -138,27 +105,27 @@ export class Editor extends React.Component<EditorProps> {
|
||||
* @memberof Editor
|
||||
*/
|
||||
private async setContent() {
|
||||
const { appState, id } = this.props;
|
||||
const { appState, id, monaco } = this.props;
|
||||
const { version } = appState;
|
||||
|
||||
const backup = appState.getAndRemoveEditorValueBackup(id);
|
||||
|
||||
if (backup) {
|
||||
if (backup && backup.model) {
|
||||
console.log(`Editor: Backup found, restoring state`);
|
||||
|
||||
if (backup.viewState) {
|
||||
this.editor.restoreViewState(backup.viewState);
|
||||
}
|
||||
|
||||
// If there's a model, use the model. No model? Use the value
|
||||
if (backup.model) {
|
||||
this.editor.setModel(backup.model);
|
||||
} else {
|
||||
this.createModel(backup.value ?? '');
|
||||
}
|
||||
this.editor.setModel(backup.model);
|
||||
} else {
|
||||
const value = await getContent(id, version);
|
||||
await this.createModel(value);
|
||||
const model = monaco.editor.createModel(value, this.language);
|
||||
model.updateOptions({
|
||||
tabSize: 2
|
||||
});
|
||||
|
||||
this.editor.setModel(model);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -32,7 +32,6 @@ export const TITLE_MAP: Record<MosaicId, string> = {
|
||||
renderer: 'Renderer Process (renderer.js)',
|
||||
preload: 'Preload (preload.js)',
|
||||
html: 'HTML (index.html)',
|
||||
css: 'Stylesheet (styles.css)',
|
||||
docsDemo: 'Docs & Demos',
|
||||
};
|
||||
|
||||
@@ -44,7 +43,6 @@ export interface EditorsState {
|
||||
monaco?: typeof MonacoType;
|
||||
isMounted?: boolean;
|
||||
monacoOptions: MonacoType.editor.IEditorOptions;
|
||||
focused?: EditorId;
|
||||
}
|
||||
|
||||
@observer
|
||||
@@ -63,9 +61,10 @@ export class Editors extends React.Component<EditorsProps, EditorsState> {
|
||||
this.renderEditor = this.renderEditor.bind(this);
|
||||
this.renderTile = this.renderTile.bind(this);
|
||||
this.renderGenericPanel = this.renderGenericPanel.bind(this);
|
||||
this.setFocused = this.setFocused.bind(this);
|
||||
|
||||
this.state = { monacoOptions: defaultMonacoOptions };
|
||||
|
||||
this.loadMonaco();
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -73,7 +72,7 @@ export class Editors extends React.Component<EditorsProps, EditorsState> {
|
||||
*
|
||||
* @memberof Editors
|
||||
*/
|
||||
public async componentDidMount() {
|
||||
public componentDidMount() {
|
||||
ipcRendererManager.on(IpcEvents.MONACO_EXECUTE_COMMAND, (_event, cmd: string) => {
|
||||
this.executeCommand(cmd);
|
||||
});
|
||||
@@ -93,16 +92,10 @@ export class Editors extends React.Component<EditorsProps, EditorsState> {
|
||||
});
|
||||
|
||||
this.setState({ isMounted: true });
|
||||
await this.loadMonaco();
|
||||
this.props.appState.isUnsaved = false;
|
||||
}
|
||||
|
||||
public componentWillUnmount() {
|
||||
this.disposeLayoutAutorun();
|
||||
|
||||
ipcRendererManager.removeAllListeners(IpcEvents.MONACO_EXECUTE_COMMAND);
|
||||
ipcRendererManager.removeAllListeners(IpcEvents.FS_NEW_FIDDLE);
|
||||
ipcRendererManager.removeAllListeners(IpcEvents.MONACO_TOGGLE_OPTION);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -167,22 +160,10 @@ export class Editors extends React.Component<EditorsProps, EditorsState> {
|
||||
public renderToolbar(
|
||||
{ title }: MosaicWindowProps<MosaicId>, id: MosaicId
|
||||
): JSX.Element {
|
||||
const { appState } = this.props;
|
||||
const docsDemoGoHomeMaybe = id === PanelId.docsDemo
|
||||
? <DocsDemoGoHomeButton id={id} appState={appState} />
|
||||
? <DocsDemoGoHomeButton id={id} appState={this.props.appState} />
|
||||
: null;
|
||||
|
||||
// only show toolbar controls if we have more than 1 visible editor
|
||||
// Mosaic arrangement is type string if 1 editor, object otherwise
|
||||
const toolbarControlsMaybe =
|
||||
(typeof appState.mosaicArrangement !== 'string') &&
|
||||
(
|
||||
<>
|
||||
<MaximizeButton id={id} appState={appState} />
|
||||
<RemoveButton id={id} appState={appState} />
|
||||
</>
|
||||
);
|
||||
|
||||
return (
|
||||
<div>
|
||||
{/* Left */}
|
||||
@@ -196,7 +177,8 @@ export class Editors extends React.Component<EditorsProps, EditorsState> {
|
||||
{/* Right */}
|
||||
<div className='mosaic-controls'>
|
||||
{docsDemoGoHomeMaybe}
|
||||
{toolbarControlsMaybe}
|
||||
<MaximizeButton id={id} appState={this.props.appState} />
|
||||
<RemoveButton id={id} appState={this.props.appState} />
|
||||
</div>
|
||||
</div>
|
||||
);
|
||||
@@ -255,7 +237,6 @@ export class Editors extends React.Component<EditorsProps, EditorsState> {
|
||||
monaco={monaco!}
|
||||
appState={appState}
|
||||
monacoOptions={defaultMonacoOptions}
|
||||
setFocused={this.setFocused}
|
||||
/>
|
||||
);
|
||||
}
|
||||
@@ -268,7 +249,6 @@ export class Editors extends React.Component<EditorsProps, EditorsState> {
|
||||
|
||||
return (
|
||||
<Mosaic<EditorId | PanelId>
|
||||
className={`focused__${this.state.focused}`}
|
||||
onChange={this.onChange}
|
||||
value={appState.mosaicArrangement}
|
||||
zeroStateView={renderNonIdealState(appState)}
|
||||
@@ -291,7 +271,7 @@ export class Editors extends React.Component<EditorsProps, EditorsState> {
|
||||
* We're doing things a bit roundabout to ensure that we're not overloading the
|
||||
* mobx state with a gigantic Monaco tree.
|
||||
*/
|
||||
public async loadMonaco() {
|
||||
public async loadMonaco(): Promise<void> {
|
||||
const { app } = window.ElectronFiddle;
|
||||
const loader = require('monaco-loader');
|
||||
const monaco = app.monaco || await loader();
|
||||
@@ -309,16 +289,6 @@ export class Editors extends React.Component<EditorsProps, EditorsState> {
|
||||
this.setState({ monaco });
|
||||
}
|
||||
|
||||
await activateTheme(monaco, undefined, this.props.appState.theme);
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the currently-focused editor. This will impact the editor's
|
||||
* z-index, ensuring that its intellisense menus don't get clipped
|
||||
* by the other editor windows.
|
||||
* @param id Editor ID
|
||||
*/
|
||||
public setFocused(id: EditorId): void {
|
||||
this.setState({ focused: id });
|
||||
activateTheme(monaco, undefined, this.props.appState.theme);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -7,16 +7,14 @@ import {
|
||||
HTMLTable,
|
||||
IButtonProps,
|
||||
Icon,
|
||||
IconName,
|
||||
Tooltip,
|
||||
ProgressBar
|
||||
IconName
|
||||
} from '@blueprintjs/core';
|
||||
import { observer } from 'mobx-react';
|
||||
import * as React from 'react';
|
||||
|
||||
import { RunnableVersion, VersionSource, VersionState } from '../../interfaces';
|
||||
import { ElectronVersion, ElectronVersionSource, VersionState } from '../../interfaces';
|
||||
import { normalizeVersion } from '../../utils/normalize-version';
|
||||
import { sortedElectronMap } from '../../utils/sorted-electron-map';
|
||||
import { sortedElectronMap } from '../../utils/sorted-map';
|
||||
import { AppState } from '../state';
|
||||
import { ElectronReleaseChannel, getReleaseChannel } from '../versions';
|
||||
|
||||
@@ -87,9 +85,9 @@ export class ElectronSettings extends React.Component<ElectronSettingsProps, Ele
|
||||
const { appState } = this.props;
|
||||
|
||||
if (!checked) {
|
||||
appState.channelsToShow = appState.channelsToShow.filter((c) => c !== id);
|
||||
appState.versionsToShow = appState.versionsToShow.filter((c) => c !== id);
|
||||
} else {
|
||||
appState.channelsToShow.push(id as ElectronReleaseChannel);
|
||||
appState.versionsToShow.push(id as ElectronReleaseChannel);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -212,20 +210,6 @@ export class ElectronSettings extends React.Component<ElectronSettingsProps, Ele
|
||||
<FormGroup
|
||||
label='Include Electron versions that are:'
|
||||
>
|
||||
<Tooltip
|
||||
content='Always enabled'
|
||||
position='bottom'
|
||||
intent='primary'
|
||||
>
|
||||
<Checkbox
|
||||
checked={getIsChecked(VersionState.ready)}
|
||||
label='Ready'
|
||||
id='ready'
|
||||
onChange={this.handleStateChange}
|
||||
inline={true}
|
||||
disabled={true}
|
||||
/>
|
||||
</Tooltip>
|
||||
<Checkbox
|
||||
checked={getIsChecked(VersionState.downloading)}
|
||||
label='Downloading'
|
||||
@@ -233,6 +217,13 @@ export class ElectronSettings extends React.Component<ElectronSettingsProps, Ele
|
||||
onChange={this.handleStateChange}
|
||||
inline={true}
|
||||
/>
|
||||
<Checkbox
|
||||
checked={getIsChecked(VersionState.ready)}
|
||||
label='Downloaded'
|
||||
id='ready'
|
||||
onChange={this.handleStateChange}
|
||||
inline={true}
|
||||
/>
|
||||
<Checkbox
|
||||
checked={getIsChecked(VersionState.unknown)}
|
||||
label='Not Downloaded'
|
||||
@@ -252,47 +243,42 @@ export class ElectronSettings extends React.Component<ElectronSettingsProps, Ele
|
||||
*/
|
||||
private renderVersionChannelOptions(): JSX.Element {
|
||||
const { appState } = this.props;
|
||||
|
||||
const getIsChecked = (channel: ElectronReleaseChannel) => {
|
||||
return appState.channelsToShow.includes(channel);
|
||||
};
|
||||
|
||||
const getIsCurrentVersionReleaseChannel = (channel: ElectronReleaseChannel) => {
|
||||
return getReleaseChannel(appState.version) === channel;
|
||||
};
|
||||
|
||||
const channels = {
|
||||
stable: ElectronReleaseChannel.stable,
|
||||
beta: ElectronReleaseChannel.beta,
|
||||
nightly: ElectronReleaseChannel.nightly,
|
||||
unsupported: ElectronReleaseChannel.unsupported
|
||||
return appState.versionsToShow.includes(channel);
|
||||
};
|
||||
|
||||
return (
|
||||
<FormGroup
|
||||
label='Include Electron versions from these release channels:'
|
||||
>
|
||||
{
|
||||
// tslint:disable-next-line:jsx-no-multiline-js
|
||||
Object.entries(channels).map(([_, channel]) => (
|
||||
<Tooltip
|
||||
content={`Can't disable channel of selected version (${appState.version})`}
|
||||
disabled={!getIsCurrentVersionReleaseChannel(channel)}
|
||||
position='bottom'
|
||||
intent='primary'
|
||||
key={channel}
|
||||
>
|
||||
<Checkbox
|
||||
checked={getIsChecked(channel)}
|
||||
label={channel}
|
||||
id={channel}
|
||||
onChange={this.handleChannelChange}
|
||||
disabled={getIsCurrentVersionReleaseChannel(channel)}
|
||||
inline={true}
|
||||
/>
|
||||
</Tooltip>
|
||||
))
|
||||
}
|
||||
<Checkbox
|
||||
checked={getIsChecked(ElectronReleaseChannel.stable)}
|
||||
label='Stable'
|
||||
id='Stable'
|
||||
onChange={this.handleChannelChange}
|
||||
inline={true}
|
||||
/>
|
||||
<Checkbox
|
||||
checked={getIsChecked(ElectronReleaseChannel.beta)}
|
||||
label='Beta'
|
||||
id='Beta'
|
||||
onChange={this.handleChannelChange}
|
||||
inline={true}
|
||||
/>
|
||||
<Checkbox
|
||||
checked={getIsChecked(ElectronReleaseChannel.nightly)}
|
||||
label='Nightly'
|
||||
id='Nightly'
|
||||
onChange={this.handleChannelChange}
|
||||
inline={true}
|
||||
/>
|
||||
<Checkbox
|
||||
checked={getIsChecked(ElectronReleaseChannel.unsupported)}
|
||||
label='Unsupported'
|
||||
id='Unsupported'
|
||||
onChange={this.handleChannelChange}
|
||||
inline={true}
|
||||
/>
|
||||
</FormGroup>
|
||||
);
|
||||
}
|
||||
@@ -330,11 +316,11 @@ export class ElectronSettings extends React.Component<ElectronSettingsProps, Ele
|
||||
* @returns {Array<JSX.Element>}
|
||||
*/
|
||||
private renderTableRows(): Array<JSX.Element | null> {
|
||||
const { versions, channelsToShow, statesToShow } = this.props.appState;
|
||||
const { versions, versionsToShow, statesToShow } = this.props.appState;
|
||||
|
||||
return sortedElectronMap<JSX.Element | null>(versions, (key, item) => {
|
||||
// Check if we want to show the version
|
||||
if (!channelsToShow.includes(getReleaseChannel(item))) {
|
||||
if (!versionsToShow.includes(getReleaseChannel(item))) {
|
||||
return null;
|
||||
}
|
||||
|
||||
@@ -356,25 +342,25 @@ export class ElectronSettings extends React.Component<ElectronSettingsProps, Ele
|
||||
/**
|
||||
* Returns a human-readable state indicator for an Electron version
|
||||
*
|
||||
* @param {RunnableVersion} item
|
||||
* @param {ElectronVersion} item
|
||||
* @returns {JSX.Element}
|
||||
*/
|
||||
private renderHumanState(item: RunnableVersion): JSX.Element {
|
||||
private renderHumanState(item: ElectronVersion): JSX.Element {
|
||||
const { state } = item;
|
||||
|
||||
if (state === VersionState.downloading || state === VersionState.unzipping) {
|
||||
return <ProgressBar value={item.downloadProgress} />;
|
||||
}
|
||||
|
||||
let icon: IconName = 'box';
|
||||
let humanState = 'Downloaded';
|
||||
|
||||
if (state === VersionState.unknown) {
|
||||
if (state === VersionState.downloading) {
|
||||
icon = 'cloud-download';
|
||||
humanState = 'Downloading';
|
||||
} else if (state === VersionState.unknown) {
|
||||
icon = 'cloud';
|
||||
humanState = 'Not downloaded';
|
||||
}
|
||||
|
||||
return (
|
||||
<span>
|
||||
{humanState}
|
||||
<Icon icon={icon} /> {humanState}
|
||||
</span>
|
||||
);
|
||||
}
|
||||
@@ -384,10 +370,10 @@ export class ElectronSettings extends React.Component<ElectronSettingsProps, Ele
|
||||
*
|
||||
* @private
|
||||
* @param {string} key
|
||||
* @param {RunnableVersion} item
|
||||
* @param {ElectronVersion} item
|
||||
* @returns {JSX.Element}
|
||||
*/
|
||||
private renderAction(key: string, item: RunnableVersion): JSX.Element {
|
||||
private renderAction(key: string, item: ElectronVersion): JSX.Element {
|
||||
const { state, source } = item;
|
||||
const { appState } = this.props;
|
||||
const buttonProps: IButtonProps = {
|
||||
@@ -396,23 +382,17 @@ export class ElectronSettings extends React.Component<ElectronSettingsProps, Ele
|
||||
};
|
||||
|
||||
// Already downloaded
|
||||
if (state === VersionState.ready) {
|
||||
buttonProps.disabled = false;
|
||||
if (state === 'ready') {
|
||||
buttonProps.onClick = () => appState.removeVersion(key);
|
||||
buttonProps.icon = 'trash';
|
||||
buttonProps.text = source === VersionSource.local
|
||||
buttonProps.text = source === ElectronVersionSource.local
|
||||
? 'Remove'
|
||||
: 'Delete';
|
||||
} else if (state === VersionState.downloading) {
|
||||
} else if (state === 'downloading') {
|
||||
buttonProps.disabled = true;
|
||||
buttonProps.loading = true;
|
||||
buttonProps.text = 'Downloading';
|
||||
buttonProps.icon = 'cloud-download';
|
||||
} else if (state === VersionState.unzipping) {
|
||||
buttonProps.disabled = true;
|
||||
buttonProps.loading = true;
|
||||
buttonProps.text = 'Unzipping';
|
||||
buttonProps.icon = 'cloud-download';
|
||||
} else {
|
||||
buttonProps.disabled = false;
|
||||
buttonProps.loading = false;
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
import { Callout, Checkbox, FormGroup, InputGroup } from '@blueprintjs/core';
|
||||
import { Callout, Checkbox, FormGroup } from '@blueprintjs/core';
|
||||
import { observer } from 'mobx-react';
|
||||
import * as React from 'react';
|
||||
|
||||
@@ -21,7 +21,6 @@ export class ExecutionSettings extends React.Component<ExecutionSettingsProps, {
|
||||
|
||||
this.handleDeleteDataChange = this.handleDeleteDataChange.bind(this);
|
||||
this.handleElectronLoggingChange = this.handleElectronLoggingChange.bind(this);
|
||||
this.handleExecutionFlagChange = this.handleExecutionFlagChange.bind(this);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -49,25 +48,8 @@ export class ExecutionSettings extends React.Component<ExecutionSettingsProps, {
|
||||
this.props.appState.isEnablingElectronLogging = checked;
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles a change in the execution flags run with the Electron executable
|
||||
*
|
||||
* @param {React.ChangeEvent<HTMLInputElement>} event
|
||||
*/
|
||||
public handleExecutionFlagChange(
|
||||
event: React.FormEvent<HTMLInputElement>
|
||||
) {
|
||||
const { value } = event.currentTarget;
|
||||
const flags = value.split('|');
|
||||
this.props.appState.executionFlags = flags;
|
||||
}
|
||||
|
||||
public render() {
|
||||
const {
|
||||
isKeepingUserDataDirs,
|
||||
isEnablingElectronLogging,
|
||||
executionFlags = []
|
||||
} = this.props.appState;
|
||||
const { isKeepingUserDataDirs, isEnablingElectronLogging } = this.props.appState;
|
||||
|
||||
const deleteUserDirLabel = `
|
||||
Whenever Electron runs, it creates a user data directory for cookies, the cache,
|
||||
@@ -105,26 +87,6 @@ export class ExecutionSettings extends React.Component<ExecutionSettingsProps, {
|
||||
/>
|
||||
</FormGroup>
|
||||
</Callout>
|
||||
<br />
|
||||
<Callout>
|
||||
<FormGroup>
|
||||
<p>
|
||||
Electron allows starting the executable with <a
|
||||
href='https://electronjs.org/docs/api/chrome-command-line-switches'
|
||||
>
|
||||
user-provided flags
|
||||
</a>
|
||||
, such as '--js-flags=--expose-gc'. Those can be added here as bar-separated (|)
|
||||
flags to run when you start your Fiddles.
|
||||
</p>
|
||||
<br />
|
||||
<InputGroup
|
||||
placeholder='--js-flags=--expose-gc|--lang=es'
|
||||
value={executionFlags.join('|')}
|
||||
onChange={this.handleExecutionFlagChange}
|
||||
/>
|
||||
</FormGroup>
|
||||
</Callout>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
@@ -19,7 +19,7 @@ const ThemeSelect = Select.ofType<LoadedFiddleTheme>();
|
||||
* version.
|
||||
*
|
||||
* @param {string} query
|
||||
* @param {RunnableVersion} { version }
|
||||
* @param {ElectronVersion} { version }
|
||||
* @returns
|
||||
*/
|
||||
export const filterItem: ItemPredicate<LoadedFiddleTheme> = (query, { name }) => {
|
||||
@@ -31,7 +31,7 @@ export const filterItem: ItemPredicate<LoadedFiddleTheme> = (query, { name }) =>
|
||||
* Helper method: Returns the <Select /> <MenuItem /> for Electron
|
||||
* versions.
|
||||
*
|
||||
* @param {RunnableVersion} item
|
||||
* @param {ElectronVersion} item
|
||||
* @param {IItemRendererProps} { handleClick, modifiers, query }
|
||||
* @returns
|
||||
*/
|
||||
|
||||
@@ -29,8 +29,8 @@ export function getWelcomeTour(): Set<TourScriptStep> {
|
||||
<>
|
||||
<p>
|
||||
Electron Fiddle allows you to build little experiments and mini-apps with
|
||||
Electron. Each Fiddle has at least three of these files: A main script, a
|
||||
renderer script, a preload script, and an HTML file.
|
||||
Electron. Each Fiddle has three files: A main script, a renderer script,
|
||||
and an HTML file.
|
||||
</p>
|
||||
<p>
|
||||
If you <code>require()</code> a module, Fiddle will install
|
||||
|
||||
@@ -1,134 +0,0 @@
|
||||
import { Button, IButtonGroupProps, MenuItem } from '@blueprintjs/core';
|
||||
import { ItemPredicate, ItemRenderer, Select } from '@blueprintjs/select';
|
||||
import { observer } from 'mobx-react';
|
||||
import * as React from 'react';
|
||||
|
||||
import { RunnableVersion, VersionSource, VersionState } from '../../interfaces';
|
||||
import { highlightText } from '../../utils/highlight-text';
|
||||
import { AppState } from '../state';
|
||||
|
||||
const ElectronVersionSelect = Select.ofType<RunnableVersion>();
|
||||
|
||||
/**
|
||||
* Helper method: Returns the <Select /> label for an Electron
|
||||
* version.
|
||||
*
|
||||
* @param {RunnableVersion} { source, state }
|
||||
* @returns {string}
|
||||
*/
|
||||
export function getItemLabel({ source, state, name }: RunnableVersion): string {
|
||||
let label = '';
|
||||
|
||||
if (source === VersionSource.local) {
|
||||
label = name || 'Local';
|
||||
} else {
|
||||
if (state === VersionState.unknown) {
|
||||
label = `Not downloaded`;
|
||||
} else if (state === VersionState.ready) {
|
||||
label = `Downloaded`;
|
||||
} else if (state === VersionState.downloading) {
|
||||
label = `Downloading`;
|
||||
}
|
||||
}
|
||||
|
||||
return label;
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper method: Returns the <Select /> icon for an Electron
|
||||
* version.
|
||||
*
|
||||
* @param {RunnableVersion} { state }
|
||||
* @returns
|
||||
*/
|
||||
export function getItemIcon({ state }: RunnableVersion) {
|
||||
return state === 'ready'
|
||||
? 'saved'
|
||||
: state === 'downloading' ? 'cloud-download' : 'cloud';
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper method: Returns the <Select /> predicate for an Electron
|
||||
* version.
|
||||
*
|
||||
* @param {string} query
|
||||
* @param {RunnableVersion} { version }
|
||||
* @returns
|
||||
*/
|
||||
export const filterItem: ItemPredicate<RunnableVersion> = (query, { version }) => {
|
||||
return version.toLowerCase().includes(query.toLowerCase());
|
||||
};
|
||||
|
||||
/**
|
||||
* Helper method: Returns the <Select /> <MenuItem /> for Electron
|
||||
* versions.
|
||||
*
|
||||
* @param {RunnableVersion} item
|
||||
* @param {IItemRendererProps} { handleClick, modifiers, query }
|
||||
* @returns
|
||||
*/
|
||||
export const renderItem: ItemRenderer<RunnableVersion> = (item, { handleClick, modifiers, query }) => {
|
||||
if (!modifiers.matchesPredicate) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return (
|
||||
<MenuItem
|
||||
active={modifiers.active}
|
||||
disabled={modifiers.disabled}
|
||||
text={highlightText(item.version, query)}
|
||||
key={item.version}
|
||||
onClick={handleClick}
|
||||
label={getItemLabel(item)}
|
||||
icon={getItemIcon(item)}
|
||||
/>
|
||||
);
|
||||
};
|
||||
|
||||
export interface VersionSelectState {
|
||||
value: string;
|
||||
}
|
||||
|
||||
export interface VersionSelectProps {
|
||||
appState: AppState;
|
||||
disabled?: boolean;
|
||||
currentVersion: RunnableVersion;
|
||||
onVersionSelect: (version: RunnableVersion) => void;
|
||||
buttonGroupProps?: IButtonGroupProps;
|
||||
itemDisabled?: keyof RunnableVersion | ((item: RunnableVersion, index: number) => boolean);
|
||||
}
|
||||
|
||||
/**
|
||||
* A dropdown allowing the selection of Electron versions. The actual
|
||||
* download is managed in the state.
|
||||
*
|
||||
* @class VersionSelect
|
||||
* @extends {React.Component<VersionSelectProps, VersionSelectState>}
|
||||
*/
|
||||
@observer
|
||||
export class VersionSelect extends React.Component<VersionSelectProps, VersionSelectState> {
|
||||
public render() {
|
||||
const { currentVersion, itemDisabled } = this.props;
|
||||
const { version } = currentVersion;
|
||||
|
||||
return (
|
||||
<ElectronVersionSelect
|
||||
filterable={true}
|
||||
items={this.props.appState.versionsToShow}
|
||||
itemRenderer={renderItem}
|
||||
itemPredicate={filterItem}
|
||||
itemDisabled={itemDisabled}
|
||||
onItemSelect={this.props.onVersionSelect}
|
||||
noResults={<MenuItem disabled={true} text='No results.' />}
|
||||
disabled={!!this.props.disabled}
|
||||
>
|
||||
<Button
|
||||
className='version-chooser'
|
||||
text={`Electron v${version}`}
|
||||
icon={getItemIcon(currentVersion)}
|
||||
disabled={!!this.props.disabled}
|
||||
/>
|
||||
</ElectronVersionSelect>
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -3,7 +3,6 @@ import * as path from 'path';
|
||||
import { MosaicNode } from 'react-mosaic-component';
|
||||
|
||||
import { EditorId, MosaicId } from '../interfaces';
|
||||
import { EditorBackup } from '../utils/editor-backup';
|
||||
|
||||
// Reminder: When testing, this file is mocked in tests/setup.js
|
||||
|
||||
@@ -20,9 +19,5 @@ export const DEFAULT_MOSAIC_ARRANGEMENT: MosaicNode<MosaicId> = {
|
||||
}
|
||||
};
|
||||
|
||||
export const DEFAULT_CLOSED_PANELS: Partial<Record<MosaicId, EditorBackup | true>> = {
|
||||
docsDemo: true
|
||||
};
|
||||
|
||||
export const ELECTRON_ORG = 'electron';
|
||||
export const ELECTRON_REPO = 'electron';
|
||||
|
||||
@@ -2,10 +2,9 @@ import * as fsType from 'fs-extra';
|
||||
import * as MonacoType from 'monaco-editor';
|
||||
import * as path from 'path';
|
||||
|
||||
import { RunnableVersion, VersionSource } from '../interfaces';
|
||||
import { ElectronVersion, ElectronVersionSource } from '../interfaces';
|
||||
import { callIn } from '../utils/call-in';
|
||||
import { fancyImport } from '../utils/import';
|
||||
import { normalizeVersion } from '../utils/normalize-version';
|
||||
import { USER_DATA_PATH } from './constants';
|
||||
|
||||
const definitionPath = path.join(USER_DATA_PATH, 'electron-typedef');
|
||||
@@ -37,26 +36,6 @@ export async function fetchTypeDefinitions(version: string): Promise<string> {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Removes the type definition for a given version
|
||||
*
|
||||
* @param version
|
||||
*/
|
||||
export async function removeTypeDefsForVersion(version: string) {
|
||||
const fs = await fancyImport<typeof fsType>('fs-extra');
|
||||
const _version = normalizeVersion(version);
|
||||
const typeDefsDir = path.dirname(getOfflineTypeDefinitionPath(_version));
|
||||
|
||||
if (fs.existsSync(typeDefsDir)) {
|
||||
try {
|
||||
await fs.remove(typeDefsDir);
|
||||
} catch (error) {
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Get the path for offline TypeScript definitions
|
||||
*
|
||||
@@ -85,7 +64,7 @@ export async function getOfflineTypeDefinitions(version: string): Promise<boolea
|
||||
* @param {string} version
|
||||
* @returns {void}
|
||||
*/
|
||||
export async function getDownloadedVersionTypeDefs(version: RunnableVersion): Promise<string | null> {
|
||||
export async function getDownloadedVersionTypeDefs(version: ElectronVersion): Promise<string | null> {
|
||||
const fs = await fancyImport<typeof fsType>('fs-extra');
|
||||
await fs.mkdirp(definitionPath);
|
||||
const offlinePath = getOfflineTypeDefinitionPath(version.version);
|
||||
@@ -112,8 +91,8 @@ export async function getDownloadedVersionTypeDefs(version: RunnableVersion): Pr
|
||||
}
|
||||
}
|
||||
|
||||
export async function getLocalVersionTypeDefs(version: RunnableVersion) {
|
||||
if (version.source === VersionSource.local && !!version.localPath) {
|
||||
export async function getLocalVersionTypeDefs(version: ElectronVersion) {
|
||||
if (version.source === ElectronVersionSource.local && !!version.localPath) {
|
||||
const fs = await fancyImport<typeof fsType>('fs-extra');
|
||||
const typesPath = getLocalTypePathForVersion(version);
|
||||
if (!!typesPath && fs.existsSync(typesPath)) {
|
||||
@@ -128,7 +107,7 @@ export async function getLocalVersionTypeDefs(version: RunnableVersion) {
|
||||
*
|
||||
* @param {string} version
|
||||
*/
|
||||
export async function updateEditorTypeDefinitions(version: RunnableVersion, i: number = 0): Promise<void> {
|
||||
export async function updateEditorTypeDefinitions(version: ElectronVersion, i: number = 0): Promise<void> {
|
||||
const defer = async (): Promise<void> => {
|
||||
if (i > 10) {
|
||||
console.warn(`Fetch Types: Failed, dependencies do not exist`);
|
||||
@@ -146,7 +125,7 @@ export async function updateEditorTypeDefinitions(version: RunnableVersion, i: n
|
||||
const monaco: typeof MonacoType = app.monaco!;
|
||||
const typeDefDisposable: MonacoType.IDisposable = app.typeDefDisposable!;
|
||||
|
||||
const getTypeDefs = (version.source === VersionSource.local) ?
|
||||
const getTypeDefs = (version.source === ElectronVersionSource.local) ?
|
||||
getLocalVersionTypeDefs : getDownloadedVersionTypeDefs;
|
||||
|
||||
const typeDefs = await getTypeDefs(version);
|
||||
@@ -164,7 +143,7 @@ export async function updateEditorTypeDefinitions(version: RunnableVersion, i: n
|
||||
}
|
||||
}
|
||||
|
||||
export function getLocalTypePathForVersion(version: RunnableVersion) {
|
||||
export function getLocalTypePathForVersion(version: ElectronVersion) {
|
||||
if (version.localPath) {
|
||||
return path.join(
|
||||
version.localPath,
|
||||
|
||||
@@ -3,7 +3,7 @@ import * as path from 'path';
|
||||
|
||||
import { EditorValues, Files, FileTransform } from '../interfaces';
|
||||
import { IpcEvents } from '../ipc-events';
|
||||
import { INDEX_HTML_NAME, MAIN_JS_NAME, PACKAGE_NAME, PRELOAD_JS_NAME, RENDERER_JS_NAME, STYLES_CSS_NAME } from '../shared-constants';
|
||||
import { INDEX_HTML_NAME, MAIN_JS_NAME, PACKAGE_NAME, PRELOAD_JS_NAME, RENDERER_JS_NAME } from '../shared-constants';
|
||||
import { DEFAULT_OPTIONS, PackageJsonOptions } from '../utils/get-package';
|
||||
import { fancyImport } from '../utils/import';
|
||||
import { ipcRendererManager } from './ipc';
|
||||
@@ -17,11 +17,6 @@ export class FileManager {
|
||||
this.openFiddle = this.openFiddle.bind(this);
|
||||
this.saveFiddle = this.saveFiddle.bind(this);
|
||||
|
||||
ipcRendererManager.removeAllListeners(IpcEvents.FS_OPEN_FIDDLE);
|
||||
ipcRendererManager.removeAllListeners(IpcEvents.FS_OPEN_TEMPLATE);
|
||||
ipcRendererManager.removeAllListeners(IpcEvents.FS_SAVE_FIDDLE);
|
||||
ipcRendererManager.removeAllListeners(IpcEvents.FS_SAVE_FIDDLE_FORGE);
|
||||
|
||||
ipcRendererManager.on(IpcEvents.FS_OPEN_FIDDLE, (_event, filePath) => {
|
||||
this.openFiddle(filePath);
|
||||
});
|
||||
@@ -68,7 +63,6 @@ export class FileManager {
|
||||
main: await this.readFile(path.join(filePath, MAIN_JS_NAME)),
|
||||
renderer: await this.readFile(path.join(filePath, RENDERER_JS_NAME)),
|
||||
preload: await this.readFile(path.join(filePath, PRELOAD_JS_NAME)),
|
||||
css: await this.readFile(path.join(filePath, STYLES_CSS_NAME))
|
||||
};
|
||||
|
||||
|
||||
@@ -110,6 +104,7 @@ export class FileManager {
|
||||
}
|
||||
|
||||
this.appState.isUnsaved = false;
|
||||
window.ElectronFiddle.app.setupUnsavedOnChangeListener();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -131,7 +126,6 @@ export class FileManager {
|
||||
output.set(MAIN_JS_NAME, values.main);
|
||||
output.set(INDEX_HTML_NAME, values.html);
|
||||
output.set(PRELOAD_JS_NAME, values.preload);
|
||||
output.set(STYLES_CSS_NAME, values.css);
|
||||
output.set(PACKAGE_NAME, values.package!);
|
||||
|
||||
for (const transform of transforms) {
|
||||
|
||||
@@ -15,7 +15,6 @@ export class IpcRendererManager extends EventEmitter {
|
||||
super();
|
||||
|
||||
ipcRendererEvents.forEach((name) => {
|
||||
ipcRenderer.removeAllListeners(name);
|
||||
ipcRenderer.on(name, (...args: Array<any>) => this.emit(name, ...args));
|
||||
});
|
||||
}
|
||||
|
||||
+2
-4
@@ -1,8 +1,6 @@
|
||||
import { EditorValues } from '../interfaces';
|
||||
import { exec } from '../utils/exec';
|
||||
|
||||
const { builtinModules } = require('module');
|
||||
|
||||
export interface NpmOperationOptions {
|
||||
dir: string;
|
||||
}
|
||||
@@ -13,8 +11,8 @@ export let isInstalled: boolean | null = null;
|
||||
/* perhaps we can expose this to the settings module?*/
|
||||
const ignoredModules: Array<string> = [
|
||||
'electron',
|
||||
'original-fs',
|
||||
...builtinModules
|
||||
// tslint:disable-next-line:no-submodule-imports
|
||||
...require('builtin-modules/static')
|
||||
];
|
||||
|
||||
/* regular expression to both match and extract module names */
|
||||
|
||||
@@ -1,9 +1,9 @@
|
||||
import { Octokit } from '@octokit/rest';
|
||||
import * as Octokit from '@octokit/rest';
|
||||
import { when } from 'mobx';
|
||||
import { EditorId, EditorValues, GenericDialogType } from '../interfaces';
|
||||
import { INDEX_HTML_NAME, MAIN_JS_NAME, PRELOAD_JS_NAME, RENDERER_JS_NAME, STYLES_CSS_NAME } from '../shared-constants';
|
||||
import { EditorId, EditorValues } from '../interfaces';
|
||||
import { INDEX_HTML_NAME, MAIN_JS_NAME, PRELOAD_JS_NAME, RENDERER_JS_NAME } from '../shared-constants';
|
||||
import { getOctokit } from '../utils/octokit';
|
||||
import { sortedElectronMap } from '../utils/sorted-electron-map';
|
||||
import { sortedElectronMap } from '../utils/sorted-map';
|
||||
import { ELECTRON_ORG, ELECTRON_REPO } from './constants';
|
||||
import { getContent } from './content';
|
||||
import { AppState } from './state';
|
||||
@@ -25,20 +25,17 @@ export class RemoteLoader {
|
||||
|
||||
public async loadFiddleFromElectronExample(_: any, exampleInfo: { path: string; ref: string }) {
|
||||
console.log(`Loading fiddle from Electron example`, _, exampleInfo);
|
||||
const { path, ref } = exampleInfo;
|
||||
const prettyName = path.replace('docs/fiddles/', '');
|
||||
const ok = await this.verifyRemoteLoad(`'${prettyName}' example from the Electron docs for version ${ref}`);
|
||||
const ok = await this.verifyRemoteLoad('example from the Electron docs', exampleInfo.ref);
|
||||
if (!ok) return;
|
||||
|
||||
this.fetchExampleAndLoad(ref, path);
|
||||
this.fetchExampleAndLoad(exampleInfo.ref, exampleInfo.path);
|
||||
}
|
||||
|
||||
public async loadFiddleFromGist(_: any, gistInfo: { id: string }) {
|
||||
const { id } = gistInfo;
|
||||
const ok = await this.verifyRemoteLoad(`gist`);
|
||||
const ok = await this.verifyRemoteLoad('gist');
|
||||
if (!ok) return;
|
||||
|
||||
this.fetchGistAndLoad(id);
|
||||
this.fetchGistAndLoad(gistInfo.id);
|
||||
}
|
||||
|
||||
public async fetchExampleAndLoad(ref: string, path: string): Promise<boolean> {
|
||||
@@ -60,7 +57,6 @@ export class RemoteLoader {
|
||||
renderer: await getContent(EditorId.renderer, this.appState.version),
|
||||
main: await getContent(EditorId.main, this.appState.version),
|
||||
preload: await getContent(EditorId.preload, this.appState.version),
|
||||
css: await getContent(EditorId.css, this.appState.version)
|
||||
};
|
||||
|
||||
const loaders: Array<Promise<void>> = [];
|
||||
@@ -99,11 +95,6 @@ export class RemoteLoader {
|
||||
.then((r) => r.text()).then((t) => { values.preload = t; })
|
||||
);
|
||||
|
||||
case STYLES_CSS_NAME:
|
||||
loaders.push(fetch(child.download_url)
|
||||
.then((r) => r.text()).then((t) => { values.css = t; })
|
||||
);
|
||||
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
@@ -149,8 +140,7 @@ export class RemoteLoader {
|
||||
html: this.getContentOrEmpty(gist, INDEX_HTML_NAME),
|
||||
main: this.getContentOrEmpty(gist, MAIN_JS_NAME),
|
||||
renderer: this.getContentOrEmpty(gist, RENDERER_JS_NAME),
|
||||
preload: this.getContentOrEmpty(gist, PRELOAD_JS_NAME),
|
||||
css: this.getContentOrEmpty(gist, STYLES_CSS_NAME)
|
||||
preload: this.getContentOrEmpty(gist, PRELOAD_JS_NAME)
|
||||
}, gistId);
|
||||
} catch (error) {
|
||||
return this.handleLoadingFailed(error);
|
||||
@@ -169,11 +159,11 @@ export class RemoteLoader {
|
||||
// check if version is part of release channel
|
||||
const versionReleaseChannel: ElectronReleaseChannel = getReleaseChannel(version);
|
||||
|
||||
if (!this.appState.channelsToShow.includes(versionReleaseChannel)) {
|
||||
if (!this.appState.versionsToShow.includes(versionReleaseChannel)) {
|
||||
const ok = await this.verifyReleaseChannelEnabled(versionReleaseChannel);
|
||||
if (!ok) return false;
|
||||
|
||||
this.appState.channelsToShow.push(versionReleaseChannel);
|
||||
this.appState.versionsToShow.push(versionReleaseChannel);
|
||||
}
|
||||
|
||||
this.appState.setVersion(version);
|
||||
@@ -207,28 +197,26 @@ export class RemoteLoader {
|
||||
*
|
||||
* @param what What are we loading from (gist, example, etc.)
|
||||
*/
|
||||
public async verifyRemoteLoad(what: string): Promise<boolean> {
|
||||
this.appState.setGenericDialogOptions({
|
||||
type: GenericDialogType.confirm,
|
||||
label: `Are you sure you want to load this ${what}? Only load and run it if you trust the source.`
|
||||
public async verifyRemoteLoad(what: string, fiddlePath?: string): Promise<boolean> {
|
||||
this.appState.setConfirmationPromptTexts({
|
||||
label: `Are you sure you sure you want to load this '${what}' from fiddle path '${fiddlePath}'? Only load and run it if you trust the source.`
|
||||
});
|
||||
this.appState.isGenericDialogShowing = true;
|
||||
await when(() => !this.appState.isGenericDialogShowing);
|
||||
this.appState.isConfirmationPromptShowing = true;
|
||||
await when(() => !this.appState.isConfirmationPromptShowing);
|
||||
|
||||
return !!this.appState.genericDialogLastResult;
|
||||
return !!this.appState.confirmationPromptLastResult;
|
||||
}
|
||||
|
||||
public async verifyReleaseChannelEnabled(channel: string): Promise<boolean> {
|
||||
this.appState.setGenericDialogOptions({
|
||||
type: GenericDialogType.warning,
|
||||
this.appState.setWarningDialogTexts({
|
||||
label: `You're loading an example with a version of Electron with an unincluded release
|
||||
channel (${channel}). Do you want to enable the release channel to load the
|
||||
version of Electron from the example?`
|
||||
});
|
||||
this.appState.isGenericDialogShowing = true;
|
||||
await when(() => !this.appState.isGenericDialogShowing);
|
||||
this.appState.isWarningDialogShowing = true;
|
||||
await when(() => !this.appState.isWarningDialogShowing);
|
||||
|
||||
return !!this.appState.genericDialogLastResult;
|
||||
return !!this.appState.warningDialogLastResult;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -239,7 +227,7 @@ export class RemoteLoader {
|
||||
* @returns {boolean}
|
||||
*/
|
||||
private async handleLoadingSuccess(values: Partial<EditorValues>, gistId: string): Promise<boolean> {
|
||||
await window.ElectronFiddle.app.replaceFiddle(values, { gistId });
|
||||
await window.ElectronFiddle.app.replaceFiddle(values, {gistId});
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -252,20 +240,18 @@ export class RemoteLoader {
|
||||
*/
|
||||
private handleLoadingFailed(error: Error): false {
|
||||
if (navigator.onLine) {
|
||||
this.appState.setGenericDialogOptions({
|
||||
type: GenericDialogType.warning,
|
||||
this.appState.setWarningDialogTexts({
|
||||
label: `Loading the fiddle failed: ${error}`,
|
||||
cancel: undefined
|
||||
});
|
||||
} else {
|
||||
this.appState.setGenericDialogOptions({
|
||||
type: GenericDialogType.warning,
|
||||
this.appState.setWarningDialogTexts({
|
||||
label: `Loading the fiddle failed. Your computer seems to be offline. Error: ${error}`,
|
||||
cancel: undefined
|
||||
});
|
||||
}
|
||||
|
||||
this.appState.toggleGenericDialog();
|
||||
this.appState.toggleWarningDialog();
|
||||
|
||||
console.warn(`Loading Fiddle failed`, error);
|
||||
return false;
|
||||
|
||||
+8
-14
@@ -6,7 +6,6 @@ import { IpcEvents } from '../ipc-events';
|
||||
import { getAppDataDir } from '../utils/app-data-dir';
|
||||
import { PackageJsonOptions } from '../utils/get-package';
|
||||
import { maybePlural } from '../utils/plural-maybe';
|
||||
import { getElectronBinaryPath, getIsDownloaded } from './binary';
|
||||
import { ipcRendererManager } from './ipc';
|
||||
import { findModulesInEditors, getIsNpmInstalled, installModules, npmRun } from './npm';
|
||||
import { AppState } from './state';
|
||||
@@ -23,11 +22,6 @@ export class Runner {
|
||||
this.run = this.run.bind(this);
|
||||
this.stop = this.stop.bind(this);
|
||||
|
||||
ipcRendererManager.removeAllListeners(IpcEvents.FIDDLE_RUN);
|
||||
ipcRendererManager.removeAllListeners(IpcEvents.FIDDLE_PACKAGE);
|
||||
ipcRendererManager.removeAllListeners(IpcEvents.FIDDLE_MAKE);
|
||||
|
||||
|
||||
ipcRendererManager.on(IpcEvents.FIDDLE_RUN, this.run);
|
||||
ipcRendererManager.on(IpcEvents.FIDDLE_PACKAGE, () => {
|
||||
this.performForgeOperation(ForgeCommands.PACKAGE);
|
||||
@@ -45,7 +39,7 @@ export class Runner {
|
||||
public async run(): Promise<boolean> {
|
||||
const { fileManager, getEditorValues } = window.ElectronFiddle.app;
|
||||
const options = { includeDependencies: false, includeElectron: false };
|
||||
const { currentElectronVersion } = this.appState;
|
||||
const { binaryManager, currentElectronVersion } = this.appState;
|
||||
const { version, localPath } = currentElectronVersion;
|
||||
|
||||
if (this.appState.isClearingConsoleOnRun) {
|
||||
@@ -66,7 +60,7 @@ export class Runner {
|
||||
return false;
|
||||
}
|
||||
|
||||
const isReady = await getIsDownloaded(version, localPath);
|
||||
const isReady = await binaryManager.getIsDownloaded(version, localPath);
|
||||
|
||||
if (!isReady) {
|
||||
console.warn(`Runner: Binary ${version} not ready`);
|
||||
@@ -185,9 +179,9 @@ export class Runner {
|
||||
* @memberof Runner
|
||||
*/
|
||||
public async execute(dir: string): Promise<void> {
|
||||
const { currentElectronVersion, pushOutput } = this.appState;
|
||||
const { currentElectronVersion, pushOutput, binaryManager } = this.appState;
|
||||
const { version, localPath } = currentElectronVersion;
|
||||
const binaryPath = getElectronBinaryPath(version, localPath);
|
||||
const binaryPath = binaryManager.getElectronBinaryPath(version, localPath);
|
||||
console.log(`Runner: Binary ${binaryPath} ready, launching`);
|
||||
|
||||
const env = { ...process.env };
|
||||
@@ -199,10 +193,10 @@ export class Runner {
|
||||
delete env.ELECTRON_ENABLE_STACK_DUMPING;
|
||||
}
|
||||
|
||||
// Add user-specified cli flags if any have been set.
|
||||
const options = [ dir, '--inspect' ].concat(this.appState.executionFlags);
|
||||
|
||||
this.child = spawn(binaryPath, options, { cwd: dir, env });
|
||||
this.child = spawn(binaryPath, [ dir, '--inspect' ], {
|
||||
cwd: dir,
|
||||
env,
|
||||
});
|
||||
this.appState.isRunning = true;
|
||||
pushOutput(`Electron v${version} started.`);
|
||||
|
||||
|
||||
+121
-97
@@ -6,15 +6,15 @@ import {
|
||||
ALL_MOSAICS,
|
||||
DocsDemoPage,
|
||||
EditorId,
|
||||
GenericDialogOptions,
|
||||
GenericDialogType,
|
||||
ElectronVersion,
|
||||
ElectronVersionSource,
|
||||
MosaicId,
|
||||
NodeVersion,
|
||||
NpmVersion,
|
||||
OutputEntry,
|
||||
OutputOptions,
|
||||
RunnableVersion,
|
||||
Version,
|
||||
VersionSource,
|
||||
VersionState
|
||||
VersionState,
|
||||
WarningDialogTexts
|
||||
} from '../interfaces';
|
||||
import { IpcEvents } from '../ipc-events';
|
||||
import { arrayToStringMap } from '../utils/array-to-stringmap';
|
||||
@@ -24,27 +24,27 @@ import { getName } from '../utils/get-title';
|
||||
import { fancyImport } from '../utils/import';
|
||||
import { normalizeVersion } from '../utils/normalize-version';
|
||||
import { isEditorBackup, isEditorId, isPanelId } from '../utils/type-checks';
|
||||
import { getDownloadedVersions, getDownloadingVersions, removeBinary, setupBinary } from './binary';
|
||||
import { BinaryManager } from './binary';
|
||||
import { Bisector } from './bisect';
|
||||
import { DEFAULT_CLOSED_PANELS, DEFAULT_MOSAIC_ARRANGEMENT } from './constants';
|
||||
import { DEFAULT_MOSAIC_ARRANGEMENT } from './constants';
|
||||
import { getContent, isContentUnchanged } from './content';
|
||||
import { getLocalTypePathForVersion, updateEditorTypeDefinitions } from './fetch-types';
|
||||
import { ipcRendererManager } from './ipc';
|
||||
import { activateTheme } from './themes';
|
||||
|
||||
import { sortedElectronMap } from '../utils/sorted-electron-map';
|
||||
import {
|
||||
addLocalVersion,
|
||||
ElectronReleaseChannel,
|
||||
getAllElectronVersions,
|
||||
getDefaultVersion,
|
||||
getElectronVersions,
|
||||
getReleaseChannel,
|
||||
getUpdatedElectronVersions,
|
||||
getUpdatedNodeVersions,
|
||||
saveLocalVersions
|
||||
} from './versions';
|
||||
|
||||
const knownVersions = getElectronVersions();
|
||||
const knownVersions = getAllElectronVersions();
|
||||
const defaultVersion = getDefaultVersion(knownVersions);
|
||||
const defaultNodeVersion = '12.0.0';
|
||||
|
||||
/**
|
||||
* Editors exist outside of React's world. To make things *a lot*
|
||||
@@ -69,14 +69,15 @@ window.ElectronFiddle = window.ElectronFiddle || {
|
||||
export class AppState {
|
||||
// -- Persisted settings ------------------
|
||||
@observable public version: string = defaultVersion;
|
||||
@observable public nodeVersion: string = defaultNodeVersion;
|
||||
@observable public theme: string | null = localStorage.getItem('theme');
|
||||
@observable public gitHubAvatarUrl: string | null = localStorage.getItem('gitHubAvatarUrl');
|
||||
@observable public gitHubName: string | null = localStorage.getItem('gitHubName');
|
||||
@observable public gitHubLogin: string | null = localStorage.getItem('gitHubLogin');
|
||||
@observable public gitHubToken: string | null = localStorage.getItem('gitHubToken') || null;
|
||||
@observable public gitHubPublishAsPublic: boolean = !!this.retrieve('gitHubPublishAsPublic');
|
||||
@observable public channelsToShow: Array<ElectronReleaseChannel> =
|
||||
this.retrieve('channelsToShow') as Array<ElectronReleaseChannel>
|
||||
@observable public versionsToShow: Array<ElectronReleaseChannel> =
|
||||
this.retrieve('versionsToShow') as Array<ElectronReleaseChannel>
|
||||
|| [ElectronReleaseChannel.stable, ElectronReleaseChannel.beta];
|
||||
@observable public statesToShow: Array<VersionState> =
|
||||
this.retrieve('statesToShow') as Array<VersionState>
|
||||
@@ -84,41 +85,46 @@ export class AppState {
|
||||
@observable public isKeepingUserDataDirs: boolean = !!this.retrieve('isKeepingUserDataDirs');
|
||||
@observable public isEnablingElectronLogging: boolean = !!this.retrieve('isEnablingElectronLogging');
|
||||
@observable public isClearingConsoleOnRun: boolean = !!this.retrieve('isClearingConsoleOnRun');
|
||||
@observable public executionFlags: Array<string> =
|
||||
this.retrieve('executionFlags') as Array<string> === null ?
|
||||
[] : this.retrieve('executionFlags') as Array<string>;
|
||||
|
||||
// -- Various session-only state ------------------
|
||||
@observable public gistId: string = '';
|
||||
@observable public versions: Record<string, RunnableVersion> = arrayToStringMap(knownVersions);
|
||||
@observable public versions: Record<string, ElectronVersion> = arrayToStringMap(knownVersions);
|
||||
@observable public nodeVersions: Record<string, NodeVersion> = arrayToStringMap([] as Array<NodeVersion>);
|
||||
@observable public output: Array<OutputEntry> = [];
|
||||
@observable public localPath: string | undefined;
|
||||
@observable public genericDialogOptions = { type: GenericDialogType.warning, label: '', ok: 'Okay', cancel: 'Cancel' };
|
||||
@observable public genericDialogLastResult: boolean | null = null;
|
||||
@observable public warningDialogTexts = { label: '', ok: 'Okay', cancel: 'Cancel' };
|
||||
@observable public confirmationDialogTexts = { label: '', ok: 'Okay', cancel: 'Cancel' };
|
||||
@observable public warningDialogLastResult: boolean | null = null;
|
||||
@observable public confirmationPromptLastResult: boolean | null = null;
|
||||
@observable public mosaicArrangement: MosaicNode<MosaicId> | null = DEFAULT_MOSAIC_ARRANGEMENT;
|
||||
@observable public templateName: string | undefined;
|
||||
@observable public currentDocsDemoPage: DocsDemoPage = DocsDemoPage.DEFAULT;
|
||||
@observable public localTypeWatcher: fsType.FSWatcher | undefined;
|
||||
@observable public binaryManager: BinaryManager = new BinaryManager();
|
||||
@observable public Bisector: Bisector | undefined;
|
||||
|
||||
@observable public isPublishing: boolean = false;
|
||||
@observable public isRunning: boolean = false;
|
||||
@observable public isUnsaved: boolean;
|
||||
@observable public isUnsaved: boolean = false;
|
||||
@observable public isUpdatingElectronVersions: boolean = false;
|
||||
|
||||
// -- Various "isShowing" settings ------------------
|
||||
@observable public isBisectCommandShowing: boolean;
|
||||
@observable public isConsoleShowing: boolean = false;
|
||||
@observable public isTokenDialogShowing: boolean = false;
|
||||
@observable public isGenericDialogShowing: boolean = false;
|
||||
@observable public isWarningDialogShowing: boolean = false;
|
||||
@observable public isConfirmationPromptShowing: boolean = false;
|
||||
@observable public isSettingsShowing: boolean = false;
|
||||
@observable public isBisectDialogShowing: boolean = false;
|
||||
@observable public isAddVersionDialogShowing: boolean = false;
|
||||
@observable public isThemeDialogShowing: boolean = false;
|
||||
@observable public isNodeMode: boolean = false;
|
||||
@observable public isTourShowing: boolean = !localStorage.getItem('hasShownTour');
|
||||
|
||||
// -- Editor Values stored when we close the editor ------------------
|
||||
@observable public closedPanels: Partial<Record<MosaicId, EditorBackup | true>> = DEFAULT_CLOSED_PANELS;
|
||||
@observable public closedPanels: Partial<Record<MosaicId, EditorBackup | true>> = {
|
||||
docsDemo: true // Closed by default
|
||||
};
|
||||
|
||||
private outputBuffer: string = '';
|
||||
private name: string;
|
||||
@@ -130,21 +136,18 @@ export class AppState {
|
||||
this.pushOutput = this.pushOutput.bind(this);
|
||||
this.removeVersion = this.removeVersion.bind(this);
|
||||
this.setVersion = this.setVersion.bind(this);
|
||||
this.setNodeVersion = this.setNodeVersion.bind(this);
|
||||
this.showTour = this.showTour.bind(this);
|
||||
this.signOutGitHub = this.signOutGitHub.bind(this);
|
||||
this.toggleBisectCommands = this.toggleBisectCommands.bind(this);
|
||||
this.toggleAuthDialog = this.toggleAuthDialog.bind(this);
|
||||
this.toggleConsole = this.toggleConsole.bind(this);
|
||||
this.toggleNodeMode = this.toggleNodeMode.bind(this);
|
||||
this.clearConsole = this.clearConsole.bind(this);
|
||||
this.toggleSettings = this.toggleSettings.bind(this);
|
||||
this.toggleBisectDialog = this.toggleBisectDialog.bind(this);
|
||||
this.updateElectronVersions = this.updateElectronVersions.bind(this);
|
||||
|
||||
ipcRendererManager.removeAllListeners(IpcEvents.OPEN_SETTINGS);
|
||||
ipcRendererManager.removeAllListeners(IpcEvents.SHOW_WELCOME_TOUR);
|
||||
ipcRendererManager.removeAllListeners(IpcEvents.CLEAR_CONSOLE);
|
||||
ipcRendererManager.removeAllListeners(IpcEvents.BISECT_COMMANDS_TOGGLE);
|
||||
|
||||
ipcRendererManager.on(IpcEvents.OPEN_SETTINGS, this.toggleSettings);
|
||||
ipcRendererManager.on(IpcEvents.SHOW_WELCOME_TOUR, this.showTour);
|
||||
ipcRendererManager.on(IpcEvents.CLEAR_CONSOLE, this.clearConsole);
|
||||
@@ -160,29 +163,24 @@ export class AppState {
|
||||
autorun(() => this.save('gitHubPublishAsPublic', this.gitHubPublishAsPublic));
|
||||
autorun(() => this.save('isKeepingUserDataDirs', this.isKeepingUserDataDirs));
|
||||
autorun(() => this.save('isEnablingElectronLogging', this.isEnablingElectronLogging));
|
||||
autorun(() => this.save('executionFlags', this.executionFlags));
|
||||
autorun(() => this.save('version', this.version));
|
||||
autorun(() => this.save('channelsToShow', this.channelsToShow));
|
||||
autorun(() => this.save('versionsToShow', this.versionsToShow));
|
||||
autorun(() => this.save('statesToShow', this.statesToShow));
|
||||
|
||||
autorun(() => {
|
||||
if (typeof this.isUnsaved === 'undefined') return;
|
||||
|
||||
if (!!this.isUnsaved) {
|
||||
if (this.isUnsaved) {
|
||||
window.onbeforeunload = () => {
|
||||
ipcRendererManager.send(IpcEvents.SHOW_INACTIVE);
|
||||
this.setGenericDialogOptions({
|
||||
type: GenericDialogType.warning,
|
||||
this.setWarningDialogTexts({
|
||||
label: `The current Fiddle is unsaved. Do you want to exit anyway?`,
|
||||
ok: 'Quit'
|
||||
});
|
||||
|
||||
this.isGenericDialogShowing = true;
|
||||
this.isWarningDialogShowing = true;
|
||||
|
||||
// We'll wait until the warning dialog was closed
|
||||
when(() => !this.isGenericDialogShowing).then(() => {
|
||||
when(() => !this.isWarningDialogShowing).then(() => {
|
||||
// The user confirmed, let's close for real.
|
||||
if (this.genericDialogLastResult) {
|
||||
if (this.warningDialogLastResult) {
|
||||
window.onbeforeunload = null;
|
||||
|
||||
// Should we just close or quit?
|
||||
@@ -201,30 +199,22 @@ export class AppState {
|
||||
};
|
||||
} else {
|
||||
window.onbeforeunload = null;
|
||||
|
||||
// set up editor listeners to verify if unsaved
|
||||
Object.keys(window.ElectronFiddle.editors).forEach((key) => {
|
||||
const editor = window.ElectronFiddle.editors[key];
|
||||
const disposable = editor.onDidChangeModelContent(() => {
|
||||
this.isUnsaved = true;
|
||||
disposable.dispose();
|
||||
});
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
// Update our known versions
|
||||
this.updateElectronVersions();
|
||||
this.updateNodeVersions();
|
||||
|
||||
// Make sure the console isn't all empty and sad
|
||||
this.pushOutput('Console ready 🔬');
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the current RunnableVersion or the first
|
||||
* Returns the current ElectronVersion or the first
|
||||
* one that can be found.
|
||||
*/
|
||||
@computed get currentElectronVersion(): RunnableVersion {
|
||||
@computed get currentElectronVersion(): ElectronVersion {
|
||||
if (this.versions[this.version]) {
|
||||
return this.versions[this.version];
|
||||
} else {
|
||||
@@ -233,28 +223,15 @@ export class AppState {
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns an array of Electron versions to show given the
|
||||
* current settings for states and channels to display
|
||||
* Returns the current NodeVersion or the first
|
||||
* one that can be found.
|
||||
*/
|
||||
@computed get versionsToShow(): Array<RunnableVersion> {
|
||||
return sortedElectronMap<RunnableVersion>(this.versions, (_key, item) => item)
|
||||
.filter((item) => {
|
||||
if (!item) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Check if we want to show the version
|
||||
if (!this.channelsToShow.includes(getReleaseChannel(item))) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Check if we want to show the state
|
||||
if (!this.statesToShow.includes(item.state)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
});
|
||||
@computed get currentNodeVersion(): NodeVersion {
|
||||
if (this.nodeVersions[this.nodeVersion]) {
|
||||
return this.nodeVersions[this.nodeVersion];
|
||||
} else {
|
||||
return this.nodeVersions[defaultNodeVersion];
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -277,6 +254,21 @@ export class AppState {
|
||||
this.isUpdatingElectronVersions = false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Update the Node versions: First, fetch them from Node.js,
|
||||
* then update their respective downloaded state.
|
||||
*
|
||||
* Fails silently.
|
||||
*/
|
||||
@action public async updateNodeVersions() {
|
||||
try {
|
||||
const nodeVersions = await getUpdatedNodeVersions();
|
||||
this.nodeVersions = arrayToStringMap(nodeVersions);
|
||||
} catch (error) {
|
||||
console.warn(`State: Could not update Node.js versions`, error);
|
||||
}
|
||||
}
|
||||
|
||||
@action public async getName() {
|
||||
if (!this.name) {
|
||||
this.name = await getName(this);
|
||||
@@ -289,6 +281,10 @@ export class AppState {
|
||||
this.isConsoleShowing = !this.isConsoleShowing;
|
||||
}
|
||||
|
||||
@action public toggleNodeMode() {
|
||||
this.isNodeMode = !this.isNodeMode;
|
||||
}
|
||||
|
||||
@action public clearConsole() {
|
||||
this.output = [];
|
||||
}
|
||||
@@ -312,11 +308,11 @@ export class AppState {
|
||||
this.isTokenDialogShowing = !this.isTokenDialogShowing;
|
||||
}
|
||||
|
||||
@action public toggleGenericDialog() {
|
||||
this.isGenericDialogShowing = !this.isGenericDialogShowing;
|
||||
@action public toggleWarningDialog() {
|
||||
this.isWarningDialogShowing = !this.isWarningDialogShowing;
|
||||
|
||||
if (this.isGenericDialogShowing) {
|
||||
this.genericDialogLastResult = null;
|
||||
if (this.isWarningDialogShowing) {
|
||||
this.warningDialogLastResult = null;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -324,6 +320,14 @@ export class AppState {
|
||||
this.isBisectDialogShowing = !this.isBisectDialogShowing;
|
||||
}
|
||||
|
||||
@action public toggleConfirmationPromptDialog() {
|
||||
this.isConfirmationPromptShowing = !this.isConfirmationPromptShowing;
|
||||
|
||||
if (this.isConfirmationPromptShowing) {
|
||||
this.confirmationPromptLastResult = null;
|
||||
}
|
||||
}
|
||||
|
||||
@action public toggleSettings() {
|
||||
// We usually don't lose editor focus,
|
||||
// so you can still type. Let's force-blur.
|
||||
@@ -349,19 +353,26 @@ export class AppState {
|
||||
window.ElectronFiddle.app.setupTheme();
|
||||
}
|
||||
|
||||
@action public setGenericDialogOptions(opts: GenericDialogOptions) {
|
||||
this.genericDialogOptions = {
|
||||
type: GenericDialogType.warning,
|
||||
@action public setWarningDialogTexts(input: WarningDialogTexts) {
|
||||
this.warningDialogTexts = {
|
||||
ok: 'Okay',
|
||||
cancel: 'Cancel',
|
||||
...opts
|
||||
...input
|
||||
};
|
||||
}
|
||||
|
||||
@action public addLocalVersion(input: Version) {
|
||||
@action public setConfirmationPromptTexts(input: WarningDialogTexts) {
|
||||
this.confirmationDialogTexts = {
|
||||
ok: 'Okay',
|
||||
cancel: 'Cancel',
|
||||
...input
|
||||
};
|
||||
}
|
||||
|
||||
@action public addLocalVersion(input: NpmVersion) {
|
||||
addLocalVersion(input);
|
||||
|
||||
this.versions = arrayToStringMap(getElectronVersions());
|
||||
this.versions = arrayToStringMap(getAllElectronVersions());
|
||||
this.updateDownloadedVersionState();
|
||||
}
|
||||
|
||||
@@ -387,7 +398,7 @@ export class AppState {
|
||||
const updatedVersions = { ...this.versions };
|
||||
|
||||
// Actually remove
|
||||
if (release && release.source === VersionSource.local) {
|
||||
if (release && release.source === ElectronVersionSource.local) {
|
||||
delete updatedVersions[version];
|
||||
|
||||
const versionsAsArray = Object
|
||||
@@ -396,7 +407,7 @@ export class AppState {
|
||||
|
||||
saveLocalVersions(versionsAsArray);
|
||||
} else {
|
||||
await removeBinary(version);
|
||||
await this.binaryManager.remove(version);
|
||||
updatedVersions[version].state = VersionState.unknown;
|
||||
}
|
||||
|
||||
@@ -415,23 +426,45 @@ export class AppState {
|
||||
console.log(`State: Downloading Electron ${version}`);
|
||||
|
||||
const release = this.versions[version] || { state: '', source: '' };
|
||||
const isLocal = release.source === VersionSource.local;
|
||||
const isLocal = release.source === ElectronVersionSource.local;
|
||||
const isReady = release.state === 'ready';
|
||||
|
||||
// Fetch new binaries, maybe?
|
||||
if (!isLocal && !isReady) {
|
||||
console.log(`State: Fetching v${version}`);
|
||||
console.log(`State: Instructing BinaryManager to fetch v${version}`);
|
||||
const updatedVersions = { ...this.versions };
|
||||
updatedVersions[version] = updatedVersions[version] || {};
|
||||
updatedVersions[version].state = VersionState.downloading;
|
||||
this.versions = updatedVersions;
|
||||
|
||||
await setupBinary(this, version);
|
||||
await this.binaryManager.setup(version);
|
||||
this.updateDownloadedVersionState();
|
||||
} else {
|
||||
console.log(`State: Version ${version} already downloaded, doing nothing.`);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Select a version of Node.js (and download fi necessary)
|
||||
*
|
||||
* @param {string} input
|
||||
* @returns {Promise<void>}
|
||||
*/
|
||||
@action public async setNodeVersion(input: string) {
|
||||
const version = normalizeVersion(input);
|
||||
|
||||
if (!this.nodeVersions[version]) {
|
||||
console.warn(`State: Called setNodeVersion() with ${version}, which does not exist.`);
|
||||
this.setVersion(this.nodeVersions[0].version);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
console.log(`State: Switching to Node ${version}`);
|
||||
|
||||
this.nodeVersion = version;
|
||||
}
|
||||
|
||||
/**
|
||||
* Select a version of Electron (and download it if necessary).
|
||||
*
|
||||
@@ -461,7 +494,7 @@ export class AppState {
|
||||
// Update TypeScript definitions
|
||||
const versionObject = this.versions[version];
|
||||
|
||||
if (versionObject.source === VersionSource.local) {
|
||||
if (versionObject.source === ElectronVersionSource.local) {
|
||||
const fs = await fancyImport<typeof fsType>('fs-extra');
|
||||
const typePath = getLocalTypePathForVersion(versionObject);
|
||||
console.info(`TypeDefs: Watching file for local version ${version} at path ${typePath}`);
|
||||
@@ -488,23 +521,14 @@ export class AppState {
|
||||
* @returns {Promise<void>}
|
||||
*/
|
||||
@action public async updateDownloadedVersionState(): Promise<void> {
|
||||
const downloadedVersions = await this.binaryManager.getDownloadedVersions();
|
||||
const updatedVersions = { ...this.versions };
|
||||
|
||||
// Keep state of currently downloading binaries first
|
||||
const downloadingVersions = getDownloadingVersions(this);
|
||||
(downloadingVersions || []).forEach((version) => {
|
||||
if (updatedVersions[version]) {
|
||||
updatedVersions[version].state = VersionState.downloading;
|
||||
}
|
||||
});
|
||||
|
||||
const downloadedVersions = await getDownloadedVersions();
|
||||
(downloadedVersions || []).forEach((version) => {
|
||||
if (updatedVersions[version]) {
|
||||
updatedVersions[version].state = VersionState.ready;
|
||||
}
|
||||
});
|
||||
|
||||
console.log(`State: Updated version state`, updatedVersions);
|
||||
|
||||
this.versions = updatedVersions;
|
||||
|
||||
@@ -2,7 +2,7 @@ import * as fsExtraType from 'fs-extra';
|
||||
import * as pathType from 'path';
|
||||
|
||||
import { EditorValues } from '../interfaces';
|
||||
import { INDEX_HTML_NAME, MAIN_JS_NAME, PRELOAD_JS_NAME, RENDERER_JS_NAME, STYLES_CSS_NAME } from '../shared-constants';
|
||||
import { INDEX_HTML_NAME, MAIN_JS_NAME, PRELOAD_JS_NAME, RENDERER_JS_NAME } from '../shared-constants';
|
||||
import { fancyImport } from '../utils/import';
|
||||
|
||||
/**
|
||||
@@ -41,7 +41,6 @@ export async function getTemplateValues(name: string): Promise<EditorValues> {
|
||||
renderer: await getFile(RENDERER_JS_NAME),
|
||||
main: await getFile(MAIN_JS_NAME),
|
||||
html: await getFile(INDEX_HTML_NAME),
|
||||
preload: await getFile(PRELOAD_JS_NAME),
|
||||
css: await getFile(STYLES_CSS_NAME)
|
||||
preload: await getFile(PRELOAD_JS_NAME)
|
||||
};
|
||||
}
|
||||
|
||||
@@ -5,9 +5,9 @@ import {
|
||||
} from 'electron';
|
||||
import { autorun } from 'mobx';
|
||||
|
||||
import { RunnableVersion, VersionState } from '../interfaces';
|
||||
import { ElectronVersion, VersionState } from '../interfaces';
|
||||
import { getNiceGreeting } from '../utils/nice-greeting';
|
||||
import { sortedElectronMap } from '../utils/sorted-electron-map';
|
||||
import { sortedElectronMap } from '../utils/sorted-map';
|
||||
import { AppState } from './state';
|
||||
|
||||
const { TouchBar } = remote;
|
||||
@@ -22,11 +22,11 @@ const {
|
||||
* Helper method: Returns an icon (emoji, lol) for an Electron
|
||||
* version.
|
||||
*
|
||||
* @param {Partial<RunnableVersion>} { state }
|
||||
* @param {Partial<ElectronVersion>} { state }
|
||||
* @returns {string}
|
||||
*/
|
||||
export function getItemIcon(
|
||||
{ state }: Partial<RunnableVersion> = { state: VersionState.unknown }
|
||||
{ state }: Partial<ElectronVersion> = { state: VersionState.unknown }
|
||||
) {
|
||||
return state === 'ready'
|
||||
? '💾'
|
||||
|
||||
+107
-59
@@ -1,5 +1,4 @@
|
||||
import semver from 'semver';
|
||||
import { RunnableVersion, Version, VersionSource, VersionState } from '../interfaces';
|
||||
import { ElectronVersion, ElectronVersionSource, NodeVersion, NpmVersion, VersionState } from '../interfaces';
|
||||
import { normalizeVersion } from '../utils/normalize-version';
|
||||
|
||||
export const enum ElectronReleaseChannel {
|
||||
@@ -12,11 +11,11 @@ export const enum ElectronReleaseChannel {
|
||||
/**
|
||||
* Returns a sensible default version string.
|
||||
*
|
||||
* @param {Array<RunnableVersion>} knownVersions
|
||||
* @param {Array<ElectronVersion>} knownVersions
|
||||
* @returns {string}
|
||||
*/
|
||||
export function getDefaultVersion(
|
||||
knownVersions: Array<RunnableVersion> = []
|
||||
knownVersions: Array<ElectronVersion> = []
|
||||
): string {
|
||||
const ls = localStorage.getItem('version');
|
||||
|
||||
@@ -46,12 +45,13 @@ export function getDefaultVersion(
|
||||
* Return the release channel for a given input
|
||||
* version.
|
||||
*
|
||||
* @param {Version | string} input
|
||||
* @param {NpmVersion | string} input
|
||||
* @returns {ElectronReleaseChannel}
|
||||
*/
|
||||
export function getReleaseChannel(
|
||||
input: Version | string
|
||||
input: NpmVersion | string
|
||||
): ElectronReleaseChannel {
|
||||
|
||||
const tag = (typeof input === 'string') ? input : (input.version || '');
|
||||
|
||||
if (tag.includes('beta')) {
|
||||
@@ -79,17 +79,17 @@ export const enum VersionKeys {
|
||||
* Retrieve Electron versions from localStorage.
|
||||
*
|
||||
* @param {VersionKeys} key
|
||||
* @param {() => Array<Version>} fallbackMethod
|
||||
* @returns {Array<Version>}
|
||||
* @param {() => Array<NpmVersion>} fallbackMethod
|
||||
* @returns {Array<NpmVersion>}
|
||||
*/
|
||||
function getVersions(
|
||||
key: VersionKeys, fallbackMethod: () => Array<Version>
|
||||
): Array<Version> {
|
||||
function getElectronVersions(
|
||||
key: VersionKeys, fallbackMethod: () => Array<NpmVersion>
|
||||
): Array<NpmVersion> {
|
||||
const fromLs = window.localStorage.getItem(key);
|
||||
|
||||
if (fromLs) {
|
||||
try {
|
||||
let result: Array<Version> = JSON.parse(fromLs);
|
||||
let result: Array<NpmVersion> = JSON.parse(fromLs);
|
||||
|
||||
if (!isExpectedFormat(result)) {
|
||||
// Known versions can just be downloaded again.
|
||||
@@ -115,9 +115,9 @@ function getVersions(
|
||||
* Save an array of GitHubVersions to localStorage.
|
||||
*
|
||||
* @param {VersionKeys} key
|
||||
* @param {Array<Version} versions
|
||||
* @param {Array<NpmVersion} versions
|
||||
*/
|
||||
function saveVersions(key: VersionKeys, versions: Array<Version>) {
|
||||
function saveElectronVersions(key: VersionKeys, versions: Array<NpmVersion>) {
|
||||
const stringified = JSON.stringify(versions);
|
||||
window.localStorage.setItem(key, stringified);
|
||||
}
|
||||
@@ -125,21 +125,21 @@ function saveVersions(key: VersionKeys, versions: Array<Version>) {
|
||||
/**
|
||||
* Return both known as well as local versions.
|
||||
*
|
||||
* @returns {Array<Version>}
|
||||
* @returns {Array<NpmVersion>}
|
||||
*/
|
||||
export function getElectronVersions(): Array<RunnableVersion> {
|
||||
const known: Array<RunnableVersion> = getKnownVersions().map((version) => {
|
||||
export function getAllElectronVersions(): Array<ElectronVersion> {
|
||||
const known: Array<ElectronVersion> = getKnownVersions().map((version) => {
|
||||
return {
|
||||
...version,
|
||||
source: VersionSource.remote,
|
||||
source: ElectronVersionSource.remote,
|
||||
state: VersionState.unknown
|
||||
};
|
||||
});
|
||||
|
||||
const local: Array<RunnableVersion> = getLocalVersions().map((version) => {
|
||||
const local: Array<ElectronVersion> = getLocalVersions().map((version) => {
|
||||
return {
|
||||
...version,
|
||||
source: VersionSource.local,
|
||||
source: ElectronVersionSource.local,
|
||||
state: VersionState.ready
|
||||
};
|
||||
});
|
||||
@@ -150,10 +150,10 @@ export function getElectronVersions(): Array<RunnableVersion> {
|
||||
/**
|
||||
* Add a version to the local versions
|
||||
*
|
||||
* @param {Version} input
|
||||
* @returns {Array<Version>}
|
||||
* @param {NpmVersion} input
|
||||
* @returns {Array<NpmVersion>}
|
||||
*/
|
||||
export function addLocalVersion(input: Version): Array<Version> {
|
||||
export function addLocalVersion(input: NpmVersion): Array<NpmVersion> {
|
||||
const versions = getLocalVersions();
|
||||
|
||||
if (!versions.find((v) => v.localPath === input.localPath)) {
|
||||
@@ -168,10 +168,10 @@ export function addLocalVersion(input: Version): Array<Version> {
|
||||
/**
|
||||
* Retrieves local Electron versions, configured by the user.
|
||||
*
|
||||
* @returns {Array<Version>}
|
||||
* @returns {Array<NpmVersion>}
|
||||
*/
|
||||
export function getLocalVersions(): Array<Version> {
|
||||
const versions = getVersions(VersionKeys.local, () => []);
|
||||
export function getLocalVersions(): Array<NpmVersion> {
|
||||
const versions = getElectronVersions(VersionKeys.local, () => []);
|
||||
|
||||
return versions;
|
||||
}
|
||||
@@ -179,37 +179,37 @@ export function getLocalVersions(): Array<Version> {
|
||||
/**
|
||||
* Saves local versions to localStorage.
|
||||
*
|
||||
* @param {Array<Version>} versions
|
||||
* @param {Array<NpmVersion>} versions
|
||||
*/
|
||||
export function saveLocalVersions(versions: Array<Version | RunnableVersion>) {
|
||||
export function saveLocalVersions(versions: Array<NpmVersion | ElectronVersion>) {
|
||||
const filteredVersions = versions.filter((v) => {
|
||||
if (isElectronVersion(v)) {
|
||||
return v.source === VersionSource.local;
|
||||
return v.source === ElectronVersionSource.local;
|
||||
}
|
||||
|
||||
return true;
|
||||
});
|
||||
|
||||
return saveVersions(VersionKeys.local, filteredVersions);
|
||||
return saveElectronVersions(VersionKeys.local, filteredVersions);
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieves our best guess regarding the latest Electron versions. Tries to
|
||||
* fetch them from localStorage, then from a static releases.json file.
|
||||
*
|
||||
* @returns {Array<Version>}
|
||||
* @returns {Array<NpmVersion>}
|
||||
*/
|
||||
export function getKnownVersions(): Array<Version> {
|
||||
return getVersions(VersionKeys.known, () => require('../../static/releases.json'));
|
||||
export function getKnownVersions(): Array<NpmVersion> {
|
||||
return getElectronVersions(VersionKeys.known, () => require('../../static/releases.json'));
|
||||
}
|
||||
|
||||
/**
|
||||
* Saves known versions to localStorage.
|
||||
*
|
||||
* @param {Array<Version>} versions
|
||||
* @param {Array<NpmVersion>} versions
|
||||
*/
|
||||
export function saveKnownVersions(versions: Array<Version>) {
|
||||
return saveVersions(VersionKeys.known, versions);
|
||||
export function saveKnownVersions(versions: Array<NpmVersion>) {
|
||||
return saveElectronVersions(VersionKeys.known, versions);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -217,37 +217,85 @@ export function saveKnownVersions(versions: Array<Version>) {
|
||||
* saved after.
|
||||
*
|
||||
* @export
|
||||
* @returns {Promise<Array<RunnableVersion>>}
|
||||
* @returns {Promise<Array<ElectronVersion>>}
|
||||
*/
|
||||
export async function getUpdatedElectronVersions(
|
||||
): Promise<Array<RunnableVersion>> {
|
||||
): Promise<Array<ElectronVersion>> {
|
||||
try {
|
||||
await fetchVersions();
|
||||
await fetchElectronVersions();
|
||||
} catch (error) {
|
||||
console.warn(`Versions: Failed to fetch versions`, { error });
|
||||
console.warn(`Versions: Failed to fetch Electron versions`, { error });
|
||||
}
|
||||
|
||||
return getElectronVersions();
|
||||
return getAllElectronVersions();
|
||||
}
|
||||
|
||||
export async function getUpdatedNodeVersions(): Promise<Array<NodeVersion>> {
|
||||
try {
|
||||
return await fetchNodeVersions();
|
||||
} catch (error) {
|
||||
console.warn(`Versions: Failed to fetch Node.js versions`, { error });
|
||||
}
|
||||
|
||||
return [];
|
||||
}
|
||||
|
||||
/**
|
||||
* Fetch the latest known versions directly from npm.
|
||||
* Fetch the latest known Node.js versions directly from Node.js.
|
||||
*
|
||||
* @returns {Promise<Array<Version>>}
|
||||
* @returns {Promise<Array<NpmVersion>>}
|
||||
*
|
||||
* let entry = {
|
||||
* "headers": 1,
|
||||
* "linux-arm64": 2,
|
||||
* "linux-x64": 6,
|
||||
* "osx-x64-tar": 8,
|
||||
* "win-x64-zip": 14,
|
||||
* "win-x86-zip": 18
|
||||
* }
|
||||
*
|
||||
* nodejs.org/dist/${version}/node-${version}-${files[entry]}.file-ext
|
||||
* ^ for windows, take the plat and extend with the file extension in the identifier above
|
||||
*/
|
||||
export async function fetchVersions() {
|
||||
const response = await window.fetch('https://unpkg.com/electron-releases/lite.json');
|
||||
const data = await response.json();
|
||||
export async function fetchNodeVersions() {
|
||||
const channels = [
|
||||
`https://nodejs.org/dist/index.json`
|
||||
];
|
||||
|
||||
// pre-0.24.0 versions were technically 'atom-shell' and cannot
|
||||
// be downloaded with @electron/get
|
||||
const MIN_DOWNLOAD_VERSION = '0.24.0';
|
||||
let output: Array<NodeVersion> = [];
|
||||
|
||||
const output = data
|
||||
.map(({ version }: any) => ({ version }))
|
||||
.filter(({ version }: any) => semver.gte(version, MIN_DOWNLOAD_VERSION));
|
||||
for (const channelUrl of channels) {
|
||||
const response = await window.fetch(channelUrl);
|
||||
const versions = await response.json();
|
||||
|
||||
if (output?.length > 0 && isExpectedFormat(output)) {
|
||||
output = versions.map((input: any) => ({
|
||||
version: normalizeVersion(input.version)
|
||||
}));
|
||||
}
|
||||
|
||||
return output;
|
||||
}
|
||||
|
||||
/**
|
||||
* Fetch the latest known Electron versions directly from npm.
|
||||
*
|
||||
* @returns {Promise<Array<NpmVersion>>}
|
||||
*/
|
||||
export async function fetchElectronVersions() {
|
||||
const channels = [
|
||||
`https://registry.npmjs.org/electron`, // stable, beta
|
||||
`https://registry.npmjs.org/electron-nightly` // nightly
|
||||
];
|
||||
|
||||
const output: Array<NpmVersion> = [];
|
||||
for (const channelUrl of channels) {
|
||||
const response = await window.fetch(channelUrl);
|
||||
const data = await response.json();
|
||||
const versions: Record<string, any> = data.versions;
|
||||
output.push(...Object.keys(versions).map((version) => ({ version })));
|
||||
}
|
||||
|
||||
if (output && output.length > 0 && isExpectedFormat(output)) {
|
||||
console.log(`Fetched new Electron versions (Count: ${output.length})`);
|
||||
saveKnownVersions(output);
|
||||
}
|
||||
@@ -269,9 +317,9 @@ export function isExpectedFormat(input: Array<any>): boolean {
|
||||
* Migrates old versions, if necessary
|
||||
*
|
||||
* @param {Array<any>} input
|
||||
* @returns {Array<Version>}
|
||||
* @returns {Array<NpmVersion>}
|
||||
*/
|
||||
export function migrateVersions(input: Array<any> = []): Array<Version> {
|
||||
export function migrateVersions(input: Array<any> = []): Array<NpmVersion> {
|
||||
return input
|
||||
.filter((item) => !!item)
|
||||
.map((item) => {
|
||||
@@ -285,11 +333,11 @@ export function migrateVersions(input: Array<any> = []): Array<Version> {
|
||||
localPath: url
|
||||
};
|
||||
})
|
||||
.filter((item) => !!item) as Array<Version>;
|
||||
.filter((item) => !!item) as Array<NpmVersion>;
|
||||
}
|
||||
|
||||
export function isElectronVersion(
|
||||
input: Version | RunnableVersion
|
||||
): input is RunnableVersion {
|
||||
return (input as RunnableVersion).source !== undefined;
|
||||
input: NpmVersion | ElectronVersion
|
||||
): input is ElectronVersion {
|
||||
return (input as ElectronVersion).source !== undefined;
|
||||
}
|
||||
|
||||
@@ -1,7 +0,0 @@
|
||||
import * as Sentry from '@sentry/electron';
|
||||
|
||||
export function initSentry() {
|
||||
if (!(global as any).__JEST__) {
|
||||
Sentry.init({dsn: 'https://966a5b01ac8d4941b81e4ebd0ab4c991@sentry.io/1882540'});
|
||||
}
|
||||
}
|
||||
@@ -2,5 +2,4 @@ export const INDEX_HTML_NAME = 'index.html';
|
||||
export const MAIN_JS_NAME = 'main.js';
|
||||
export const RENDERER_JS_NAME = 'renderer.js';
|
||||
export const PRELOAD_JS_NAME = 'preload.js';
|
||||
export const STYLES_CSS_NAME = 'styles.css';
|
||||
export const PACKAGE_NAME = 'package.json';
|
||||
|
||||
@@ -1,16 +1,16 @@
|
||||
import { RunnableVersion } from '../interfaces';
|
||||
import { Version } from '../interfaces';
|
||||
import { normalizeVersion } from './normalize-version';
|
||||
|
||||
/**
|
||||
* Takes an array of GitHub releases and returns a StringMap of
|
||||
* Electron releases.
|
||||
*
|
||||
* @param {Array<RunnableVersion>} input
|
||||
* @returns {Record<string, RunnableVersion>}
|
||||
* @param {Array<ElectronVersion>} input
|
||||
* @returns {Record<string, ElectronVersion>}
|
||||
*/
|
||||
export function arrayToStringMap(
|
||||
input: Array<RunnableVersion>
|
||||
): Record<string, RunnableVersion> {
|
||||
export function arrayToStringMap<T extends Version>(
|
||||
input: Array<T>
|
||||
): Record<string, T> {
|
||||
const output = {};
|
||||
|
||||
input.forEach((version) => {
|
||||
|
||||
@@ -6,9 +6,9 @@ import { getEditorValue } from './editor-value';
|
||||
import { getEditorViewState } from './editor-viewstate';
|
||||
|
||||
export interface EditorBackup {
|
||||
value?: string;
|
||||
model?: editor.ITextModel | null;
|
||||
viewState?: editor.ICodeEditorViewState | null;
|
||||
value: string;
|
||||
model: editor.ITextModel | null;
|
||||
viewState: editor.ICodeEditorViewState | null;
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
import { Octokit } from '@octokit/rest';
|
||||
import * as GitHubType from '@octokit/rest';
|
||||
import { AppState } from '../renderer/state';
|
||||
|
||||
let _Octokit: typeof Octokit;
|
||||
let _octo: Octokit;
|
||||
let _Octokit: typeof GitHubType;
|
||||
let _octo: GitHubType;
|
||||
|
||||
/**
|
||||
* Returns a loaded Octokit. If state is passed and authentication
|
||||
@@ -13,7 +13,7 @@ let _octo: Octokit;
|
||||
*/
|
||||
export async function getOctokit(
|
||||
appState?: AppState
|
||||
): Promise<Octokit> {
|
||||
): Promise<GitHubType> {
|
||||
_Octokit = _Octokit || (await import('@octokit/rest') as any).default;
|
||||
_octo = _octo || new _Octokit();
|
||||
|
||||
|
||||
@@ -1,34 +0,0 @@
|
||||
import * as semver from 'semver';
|
||||
|
||||
import { RunnableVersion } from '../interfaces';
|
||||
|
||||
/**
|
||||
* Sorts Electron versions and returns the result of a
|
||||
* map function.
|
||||
*
|
||||
* @param {Record<string, RunnableVersion>} versions
|
||||
* @param {(key: string, version: RunnableVersion) => void} mapFn
|
||||
* @returns {Array<T>}
|
||||
*/
|
||||
export function sortedElectronMap<T>(
|
||||
versions: Record<string, RunnableVersion>,
|
||||
mapFn: (key: string, version: RunnableVersion) => T
|
||||
) {
|
||||
return Object.keys(versions)
|
||||
.sort((a, b) => {
|
||||
if (!semver.valid(a) && !semver.valid(b)) {
|
||||
return a.localeCompare(b);
|
||||
}
|
||||
|
||||
if (!semver.valid(a)) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (!semver.valid(b)) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
return semver.gt(a, b, true) ? -1 : 1;
|
||||
})
|
||||
.map((key) => mapFn(key, versions[key])) as Array<T>;
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
import * as semver from 'semver';
|
||||
|
||||
import { ElectronVersion, NodeVersion } from '../interfaces';
|
||||
|
||||
/**
|
||||
* Sorts Electron versions and returns the result of a
|
||||
* map function.
|
||||
*
|
||||
* @param {Record<string, ElectronVersion>} versions
|
||||
* @param {(key: string, version: ElectronVersion) => void} mapFn
|
||||
* @returns {Array<T>}
|
||||
*/
|
||||
export function sortedElectronMap<T>(
|
||||
versions: Record<string, ElectronVersion>,
|
||||
mapFn: (key: string, version: ElectronVersion) => T
|
||||
) {
|
||||
return sortedMap<ElectronVersion, T>(versions, mapFn);
|
||||
}
|
||||
|
||||
/**
|
||||
* Sorts Node versions and returns the result of a
|
||||
* map function.
|
||||
*
|
||||
* @param {Record<string, NodeVersion>} versions
|
||||
* @param {(key: string, version: NodeVersion) => void} mapFn
|
||||
* @returns {Array<T>}
|
||||
*/
|
||||
export function sortedNodeMap<T>(
|
||||
versions: Record<string, NodeVersion>,
|
||||
mapFn: (key: string, version: NodeVersion) => T
|
||||
) {
|
||||
return sortedMap<NodeVersion, T>(versions, mapFn);
|
||||
}
|
||||
|
||||
function sortedMap<T1, T2>(
|
||||
versions: Record<string, T1>,
|
||||
mapFn: (key: string, version: T1) => T2
|
||||
) {
|
||||
return Object.keys(versions)
|
||||
.sort((a, b) => {
|
||||
if (!semver.valid(a) && !semver.valid(b)) {
|
||||
return a.localeCompare(b);
|
||||
}
|
||||
|
||||
if (!semver.valid(a)) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (!semver.valid(b)) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
return semver.gt(a, b, true) ? -1 : 1;
|
||||
})
|
||||
.map((key) => mapFn(key, versions[key])) as Array<T2>;
|
||||
}
|
||||
File diff suppressed because one or more lines are too long
@@ -25,6 +25,10 @@ app.on('ready', () => {
|
||||
console.log('The autoUpdater is checking for an update')
|
||||
})
|
||||
|
||||
autoUpdater.on('update-available', () => {
|
||||
console.log('The autoUpdater has found an update!')
|
||||
})
|
||||
|
||||
autoUpdater.on('update-available', () => {
|
||||
console.log('The autoUpdater has found an update and is now downloading it!')
|
||||
})
|
||||
|
||||
@@ -5,8 +5,10 @@
|
||||
|
||||
const { app, BrowserWindow } = require('electron')
|
||||
|
||||
let mainWindow = null
|
||||
|
||||
app.on('ready', () => {
|
||||
const mainWindow = new BrowserWindow({
|
||||
mainWindow = new BrowserWindow({
|
||||
height: 600,
|
||||
width: 600,
|
||||
webPreferences: {
|
||||
|
||||
@@ -5,8 +5,10 @@
|
||||
|
||||
const { app, BrowserWindow, session } = require('electron')
|
||||
|
||||
let mainWindow = null
|
||||
|
||||
app.on('ready', () => {
|
||||
const mainWindow = new BrowserWindow({
|
||||
mainWindow = new BrowserWindow({
|
||||
height: 600,
|
||||
width: 600,
|
||||
webPreferences: {
|
||||
|
||||
@@ -5,8 +5,10 @@
|
||||
|
||||
const { app, BrowserWindow } = require('electron')
|
||||
|
||||
let mainWindow = null
|
||||
|
||||
app.on('ready', () => {
|
||||
const mainWindow = new BrowserWindow({
|
||||
mainWindow = new BrowserWindow({
|
||||
height: 600,
|
||||
width: 600,
|
||||
webPreferences: {
|
||||
|
||||
@@ -8,8 +8,10 @@
|
||||
|
||||
const { app, BrowserWindow } = require('electron')
|
||||
|
||||
let mainWindow = null
|
||||
|
||||
app.on('ready', () => {
|
||||
const mainWindow = new BrowserWindow({ height: 600, width: 600 })
|
||||
mainWindow = new BrowserWindow({ height: 600, width: 600 })
|
||||
|
||||
mainWindow.loadFile('index.html')
|
||||
|
||||
|
||||
@@ -6,8 +6,10 @@
|
||||
|
||||
const { app, BrowserWindow } = require('electron')
|
||||
|
||||
let mainWindow = null
|
||||
|
||||
app.on('ready', () => {
|
||||
const mainWindow = new BrowserWindow({
|
||||
mainWindow = new BrowserWindow({
|
||||
height: 600,
|
||||
width: 600,
|
||||
webPreferences: {
|
||||
|
||||
@@ -5,8 +5,10 @@
|
||||
|
||||
const { app, BrowserWindow, dialog } = require('electron')
|
||||
|
||||
let mainWindow = null
|
||||
|
||||
app.on('ready', () => {
|
||||
const mainWindow = new BrowserWindow({ height: 600, width: 600 })
|
||||
mainWindow = new BrowserWindow({ height: 600, width: 600 })
|
||||
|
||||
// Show an "Open File" dialog and attempt to open
|
||||
// the chosen file in our window.
|
||||
|
||||
@@ -7,8 +7,10 @@
|
||||
|
||||
const { app, BrowserWindow, ipcMain } = require('electron')
|
||||
|
||||
let mainWindow = null
|
||||
|
||||
app.on('ready', () => {
|
||||
const mainWindow = new BrowserWindow({
|
||||
mainWindow = new BrowserWindow({
|
||||
height: 600,
|
||||
width: 600,
|
||||
webPreferences: {
|
||||
|
||||
@@ -4,6 +4,6 @@ const { ipcRenderer } = require('electron')
|
||||
console.log(ipcRenderer.sendSync('synchronous-message', 'ping'))
|
||||
|
||||
// prints "pong"
|
||||
ipcRenderer.on('asynchronous-reply', (_, ...args) => console.log(...args))
|
||||
ipcRenderer.on('asynchronous-reply', (...args) => console.log(args))
|
||||
|
||||
ipcRenderer.send('asynchronous-message', 'ping')
|
||||
|
||||
@@ -5,8 +5,10 @@
|
||||
|
||||
const { app, BrowserWindow, Menu } = require('electron')
|
||||
|
||||
let mainWindow = null
|
||||
|
||||
app.on('ready', () => {
|
||||
const mainWindow = new BrowserWindow({ height: 600, width: 600 })
|
||||
mainWindow = new BrowserWindow({ height: 600, width: 600 })
|
||||
mainWindow.loadFile('index.html')
|
||||
|
||||
const template = [
|
||||
|
||||
@@ -6,8 +6,10 @@
|
||||
|
||||
const { app, BrowserWindow, Notification } = require('electron')
|
||||
|
||||
let mainWindow = null
|
||||
|
||||
app.on('ready', () => {
|
||||
const mainWindow = new BrowserWindow({
|
||||
mainWindow = new BrowserWindow({
|
||||
height: 600,
|
||||
width: 600,
|
||||
webPreferences: {
|
||||
|
||||
@@ -5,8 +5,10 @@
|
||||
|
||||
const { app, BrowserWindow } = require('electron')
|
||||
|
||||
let mainWindow = null
|
||||
|
||||
app.on('ready', () => {
|
||||
const mainWindow = new BrowserWindow({
|
||||
mainWindow = new BrowserWindow({
|
||||
height: 600,
|
||||
width: 600,
|
||||
webPreferences: {
|
||||
|
||||
@@ -5,6 +5,8 @@
|
||||
|
||||
const { app, BrowserWindow } = require('electron')
|
||||
|
||||
let mainWindow = null
|
||||
|
||||
app.on('ready', () => {
|
||||
// We cannot require the screen module until the
|
||||
// app is ready
|
||||
@@ -15,7 +17,7 @@ app.on('ready', () => {
|
||||
const primaryDisplay = screen.getPrimaryDisplay()
|
||||
const { width, height } = primaryDisplay.workAreaSize
|
||||
|
||||
const mainWindow = new BrowserWindow({
|
||||
mainWindow = new BrowserWindow({
|
||||
width,
|
||||
height,
|
||||
webPreferences: {
|
||||
|
||||
@@ -5,8 +5,10 @@
|
||||
|
||||
const { app, BrowserWindow } = require('electron')
|
||||
|
||||
let mainWindow = null
|
||||
|
||||
app.on('ready', () => {
|
||||
const mainWindow = new BrowserWindow({
|
||||
mainWindow = new BrowserWindow({
|
||||
width: 600,
|
||||
height: 600,
|
||||
webPreferences: {
|
||||
|
||||
@@ -6,8 +6,10 @@
|
||||
const { app, BrowserWindow, TouchBar } = require('electron')
|
||||
const { TouchBarLabel, TouchBarButton, TouchBarSpacer } = TouchBar
|
||||
|
||||
let mainWindow = null
|
||||
|
||||
app.on('ready', () => {
|
||||
const mainWindow = new BrowserWindow({ height: 600, width: 600 })
|
||||
mainWindow = new BrowserWindow({ height: 600, width: 600 })
|
||||
mainWindow.loadFile('index.html')
|
||||
|
||||
// This API only works on macOS devices with a TouchBar.
|
||||
|
||||
@@ -5,8 +5,10 @@
|
||||
|
||||
const { app, BrowserWindow, webContents } = require('electron')
|
||||
|
||||
let mainWindow
|
||||
|
||||
app.on('ready', () => {
|
||||
const mainWindow = new BrowserWindow({ height: 600, width: 600 })
|
||||
mainWindow = new BrowserWindow({ height: 600, width: 600 })
|
||||
mainWindow.loadFile('index.html')
|
||||
|
||||
setTimeout(() => {
|
||||
|
||||
@@ -5,8 +5,10 @@
|
||||
|
||||
const { app, BrowserWindow } = require('electron')
|
||||
|
||||
let mainWindow = null
|
||||
|
||||
app.on('ready', () => {
|
||||
const mainWindow = new BrowserWindow({
|
||||
mainWindow = new BrowserWindow({
|
||||
width: 600,
|
||||
height: 600,
|
||||
webPreferences: {
|
||||
|
||||
Vendored
-12
@@ -1,12 +0,0 @@
|
||||
import { EditorId } from '../../src/interfaces';
|
||||
import { App as AppType } from '../../src/renderer/app';
|
||||
import { EditorMock } from './mocks/editors';
|
||||
|
||||
declare global {
|
||||
interface Window {
|
||||
ElectronFiddle: {
|
||||
app: AppType;
|
||||
editors: Record<EditorId, EditorMock>;
|
||||
};
|
||||
}
|
||||
}
|
||||
-4
@@ -1,4 +0,0 @@
|
||||
{
|
||||
"expectedVersionCount": 325,
|
||||
"lastElectronVersion": "9.0.0-beta.9"
|
||||
}
|
||||
Vendored
-7
@@ -10,10 +10,3 @@ declare global {
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
interface Window {
|
||||
ElectronFiddle: {
|
||||
app: AppType;
|
||||
editors: Record<EditorId, EditorMock>;
|
||||
};
|
||||
}
|
||||
|
||||
@@ -1,7 +1,3 @@
|
||||
/**
|
||||
* @jest-environment node
|
||||
*/
|
||||
|
||||
import { createContextMenu, getInspectItems, getMonacoItems, getRunItems } from '../../src/main/context-menu';
|
||||
import { ipcMainManager } from '../../src/main/ipc';
|
||||
import { isDevMode } from '../../src/utils/devmode';
|
||||
|
||||
@@ -1,10 +1,5 @@
|
||||
/**
|
||||
* @jest-environment node
|
||||
*/
|
||||
|
||||
import { setupDevTools } from '../../src/main/devtools';
|
||||
import { isDevMode } from '../../src/utils/devmode';
|
||||
|
||||
jest.mock('../../src/utils/devmode');
|
||||
|
||||
jest.mock('electron-devtools-installer', () => ({
|
||||
|
||||
@@ -1,7 +1,3 @@
|
||||
/**
|
||||
* @jest-environment node
|
||||
*/
|
||||
|
||||
import { IpcEvents } from '../../src/ipc-events';
|
||||
import { setupDialogs } from '../../src/main/dialogs';
|
||||
import { ipcMainManager } from '../../src/main/ipc';
|
||||
|
||||
@@ -1,7 +1,3 @@
|
||||
/**
|
||||
* @jest-environment node
|
||||
*/
|
||||
|
||||
import { IpcEvents } from '../../src/ipc-events';
|
||||
import {
|
||||
setupFileListeners,
|
||||
|
||||
@@ -1,7 +1,3 @@
|
||||
/**
|
||||
* @jest-environment node
|
||||
*/
|
||||
|
||||
import { app, dialog } from 'electron';
|
||||
|
||||
import { onFirstRunMaybe } from '../../src/main/first-run';
|
||||
|
||||
@@ -1,7 +1,3 @@
|
||||
/**
|
||||
* @jest-environment node
|
||||
*/
|
||||
|
||||
import * as electron from 'electron';
|
||||
import { IpcEvents } from '../../src/ipc-events';
|
||||
import { ipcMainManager } from '../../src/main/ipc';
|
||||
|
||||
@@ -1,7 +1,3 @@
|
||||
/**
|
||||
* @jest-environment node
|
||||
*/
|
||||
|
||||
import { app } from 'electron';
|
||||
|
||||
import { main, onBeforeQuit, onReady, onWindowsAllClosed } from '../../src/main/main';
|
||||
|
||||
@@ -1,7 +1,3 @@
|
||||
/**
|
||||
* @jest-environment node
|
||||
*/
|
||||
|
||||
import * as electron from 'electron';
|
||||
|
||||
import { IpcEvents } from '../../src/ipc-events';
|
||||
|
||||
@@ -1,7 +1,3 @@
|
||||
/**
|
||||
* @jest-environment node
|
||||
*/
|
||||
|
||||
import { app } from 'electron';
|
||||
import * as fs from 'fs';
|
||||
|
||||
|
||||
@@ -1,7 +1,3 @@
|
||||
/**
|
||||
* @jest-environment node
|
||||
*/
|
||||
|
||||
import { shouldQuit } from '../../src/main/squirrel';
|
||||
|
||||
jest.mock('electron-squirrel-startup', () => ({ mock: true }));
|
||||
|
||||
@@ -1,7 +1,3 @@
|
||||
/**
|
||||
* @jest-environment node
|
||||
*/
|
||||
|
||||
jest.useFakeTimers();
|
||||
|
||||
const mockUpdateApp = jest.fn();
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user