+
The Advanced REST Client is an open source project and everyone can use it or part of it. However, depending on your project type the license vary.
+
For open source and free software you can use this software on Apache 2.0 license.
+
For commercial or non open source projects you can use this software on CC-BY 4.0 license.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+
+
+ CodeMirror
+
+
+Copyright (C) 2013 by Marijn Haverbeke <marijnh@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the
+"Software"), to deal
+in the Software without restriction, including without limitation
+the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be
+included in
+all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 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.
+Please note that some subdirectories of the CodeMirror distribution
+include their own LICENSE files, and are released under different
+licences.
+
+
+
+
+ LitElement
+
+
+BSD 3-Clause License
+
+Copyright (c) 2017, The Polymer Authors. All rights reserved.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+* Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+* Neither the name of the copyright holder nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+
+
+ LitElement
+
+
+MIT LICENSE
+
+Copyright (c) 2012 Lea Verou
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 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.
+
+
+
+
+ Electron
+
+
+Copyright (c) 2013-2020 GitHub Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+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.
+
+
+
+
+
{}>(base: T): T & FileDropMixinConstructor;
+interface FileDropMixinConstructor {
+ new(...args: any[]): FileDropMixin;
+}
+
+/**
+ * Adds methods to accept files via drag and drop.
+ * The mixin register the dnd events on the body element. When an object is dragged over the window it adds
+ * this `drop-target` class to the `body` element.
+ *
+ * The mixin also assumes that when the `drop-target` is set then the `drop-info` overlay is rendered.
+ * However, it does not change the logic if the element is not in the DOM.
+ * Use the provided `dropTargetTemplate()` function to generate template for the drag info.
+ *
+ * The class implementing this mixin should override the `processDroppedFiles(files)` method
+ * to process the incoming files.
+ *
+ * @mixin
+ */
+declare interface FileDropMixin {
+ /**
+ * Processes dropped to the page files
+ * @param files The list of dropped files
+ */
+ processDroppedFiles(files: FileList): Promise;
+ /**
+ * @return The template for the drop file message
+ */
+ dropTargetTemplate(): TemplateResult;
+
+ [dragEnterHandler](e: DragEvent): void;
+
+ [dragLeaveHandler](e: DragEvent): void;
+
+ [dragOverHandler](e: DragEvent): void;
+
+ [dropHandler](e: DragEvent): void;
+}
+
+export {FileDropMixinConstructor};
+export {FileDropMixin};
\ No newline at end of file
diff --git a/src/app/mixins/FileDropMixin.js b/src/app/mixins/FileDropMixin.js
new file mode 100644
index 00000000..7eb2a974
--- /dev/null
+++ b/src/app/mixins/FileDropMixin.js
@@ -0,0 +1,136 @@
+/* eslint-disable class-methods-use-this */
+import { dedupeMixin } from '../../../web_modules/@open-wc/dedupe-mixin/index.js';
+import { html } from '../../../web_modules/lit-html/lit-html.js';
+import '../../../web_modules/@advanced-rest-client/arc-icons/arc-icon.js';
+
+/** @typedef {import('lit-html').TemplateResult} TemplateResult */
+
+export const dragEnterHandler = Symbol('dragEnterHandler');
+export const dragLeaveHandler = Symbol('dragLeaveHandler');
+export const dragOverHandler = Symbol('dragOverHandler');
+export const dropHandler = Symbol('dropHandler');
+
+/**
+ * @param {new (...args: any[]) => any} base
+ */
+const mxFunction = (base) => {
+ class FileDropMixinImpl extends base {
+ constructor() {
+ super();
+ this[dragEnterHandler] = this[dragEnterHandler].bind(this);
+ this[dragLeaveHandler] = this[dragLeaveHandler].bind(this);
+ this[dragOverHandler] = this[dragOverHandler].bind(this);
+ this[dropHandler] = this[dropHandler].bind(this);
+
+ this.dropTargetActive = false;
+
+ document.body.addEventListener('dragenter', this[dragEnterHandler]);
+ document.body.addEventListener('dragleave', this[dragLeaveHandler]);
+ document.body.addEventListener('dragover', this[dragOverHandler]);
+ document.body.addEventListener('drop', this[dropHandler]);
+ }
+
+ /**
+ * Processes dropped to the page files
+ * @param {FileList} files The list of dropped files
+ * @abstract This is to be implemented by the platform bindings
+ */
+ // eslint-disable-next-line no-unused-vars
+ async processDroppedFiles(files) {
+ // ...
+ }
+
+ /**
+ * @return {TemplateResult} The template for the drop file message
+ */
+ dropTargetTemplate() {
+ return html`
+
+ `;
+ }
+
+ /**
+ * @param {DragEvent} e
+ */
+ [dragEnterHandler](e) {
+ if (![...e.dataTransfer.types].includes('Files')) {
+ return;
+ }
+ e.preventDefault();
+ document.body.classList.add('drop-target');
+ this.dropTargetActive = true;
+ e.dataTransfer.effectAllowed = 'copy';
+ }
+
+ /**
+ * @param {DragEvent} e
+ */
+ [dragLeaveHandler](e) {
+ if (![...e.dataTransfer.types].includes('Files')) {
+ return;
+ }
+ const node = /** @type HTMLElement */ (e.target);
+ if (node.nodeType !== Node.ELEMENT_NODE) {
+ return;
+ }
+ if (node !== document.body && !node.classList.contains('drop-info')) {
+ return;
+ }
+ e.preventDefault();
+ document.body.classList.remove('drop-target');
+ this.dropTargetActive = false;
+ }
+
+ /**
+ * @param {DragEvent} e
+ */
+ [dragOverHandler](e) {
+ if (![...e.dataTransfer.types].includes('Files')) {
+ return;
+ }
+ const node = /** @type HTMLElement */ (e.target);
+ if (node.nodeType !== Node.ELEMENT_NODE) {
+ return;
+ }
+ if (node !== document.body && !node.classList.contains('drop-info')) {
+ return;
+ }
+ e.preventDefault();
+ document.body.classList.add('drop-target');
+ this.dropTargetActive = true;
+ }
+
+ /**
+ * @param {DragEvent} e
+ */
+ [dropHandler](e) {
+ if (![...e.dataTransfer.types].includes('Files')) {
+ return;
+ }
+ e.preventDefault();
+ document.body.classList.remove('drop-target');
+ this.dropTargetActive = false;
+ this.processDroppedFiles(e.dataTransfer.files);
+ }
+ }
+ return FileDropMixinImpl;
+}
+
+/**
+ * Adds methods to accept files via drag and drop.
+ * The mixin register the dnd events on the body element. When an object is dragged over the window it adds
+ * this `drop-target` class to the `body` element. Additionally it sets the `dropTargetActive` property.
+ *
+ * The mixin also assumes that when the `drop-target` is set then the `drop-info` overlay is rendered.
+ * However, it does not change the logic if the element is not in the DOM.
+ * Use the provided `dropTargetTemplate()` function to generate template for the drag info.
+ *
+ * The class implementing this mixin should override the `processDroppedFiles(files)` method
+ * to process the incoming files.
+ *
+ * @mixin
+ */
+export const FileDropMixin = dedupeMixin(mxFunction);
diff --git a/src/app/mixins/ReactiveMixin.d.ts b/src/app/mixins/ReactiveMixin.d.ts
new file mode 100644
index 00000000..65bc73d3
--- /dev/null
+++ b/src/app/mixins/ReactiveMixin.d.ts
@@ -0,0 +1,47 @@
+export declare const setObservableProperty: unique symbol;
+
+declare function ReactiveMixin {}>(base: T): T & ReactiveMixinConstructor;
+interface ReactiveMixinConstructor {
+ new(...args: any[]): ReactiveMixin;
+}
+
+/**
+ * Adds methods to register reactive properties, the properties
+ * that trigger the `render()` function once changed.
+ *
+ * Use the `initObservableProperties()` function that accepts a list
+ * of properties set on the base class that once set triggers the render function. The setter checks
+ * whether the a value actually changed. It works well for primitives but it won't work as expected
+ * for complex types.
+ *
+ * ## Example
+ *
+ * ```javascript
+ * constructor() {
+ * super();
+ * this.initObservableProperties('prop1', 'prop2', 'prop3');
+ * this.prop1 = 'test'; // <- this triggers the render() function
+ * }
+ * ```
+ *
+ * @mixin
+ */
+declare interface ReactiveMixin {
+ /**
+ * Creates setters and getters to properties defined in the passed list of properties.
+ * Property setter will trigger render function.
+ *
+ * @param props List of properties to initialize.
+ */
+ initObservableProperties(...props: string[]): void;
+
+ [setObservableProperty](prop: string, value: any): void;
+
+ /**
+ * The main render function. This is to be implemented by the mixin consumer.
+ */
+ render(): void;
+}
+
+export {ReactiveMixinConstructor};
+export {ReactiveMixin};
\ No newline at end of file
diff --git a/src/app/mixins/ReactiveMixin.js b/src/app/mixins/ReactiveMixin.js
new file mode 100644
index 00000000..0e2f81dd
--- /dev/null
+++ b/src/app/mixins/ReactiveMixin.js
@@ -0,0 +1,85 @@
+import { dedupeMixin } from '../../../web_modules/@open-wc/dedupe-mixin/index.js';
+
+export const setObservableProperty = Symbol('setObservableProperty');
+
+const valuesMap = new WeakMap();
+
+/**
+ * @param {new (...args: any[]) => any} base
+ */
+const mxFunction = (base) => {
+ class ReactiveMixinImpl extends base {
+ /**
+ * Creates setters and getters to properties defined in the passed list of properties.
+ * Property setter will trigger render function.
+ *
+ * @param {...string} props List of properties to initialize.
+ * @returns {void}
+ */
+ initObservableProperties(...props) {
+ props.forEach((item) => {
+ Object.defineProperty(this, item, {
+ get() {
+ const map = valuesMap.get(this);
+ return map[item];
+ },
+ set(newValue) {
+ this[setObservableProperty](item, newValue);
+ },
+ enumerable: true,
+ configurable: true,
+ });
+ });
+ }
+
+ /**
+ * @param {string} prop
+ * @param {any} value
+ * @returns {void}
+ */
+ [setObservableProperty](prop, value) {
+ let map = valuesMap.get(this);
+ if (!map) {
+ map = {};
+ valuesMap.set(this, map);
+ }
+ if (map[prop] === value) {
+ return;
+ }
+ map[prop] = value;
+ this.render();
+ }
+
+ /**
+ * The main render function. This is to be implemented by the mixin consumer.
+ * @returns {void}
+ */
+ render() {
+ // nothing
+ }
+ }
+ return ReactiveMixinImpl;
+}
+
+/**
+ * Adds methods to register reactive properties, the properties
+ * that trigger the `render()` function once changed.
+ *
+ * Use the `initObservableProperties()` function that accepts a list
+ * of properties set on the base class that once set triggers the render function. The setter checks
+ * whether the a value actually changed. It works well for primitives but it won't work as expected
+ * for complex types.
+ *
+ * ## Example
+ *
+ * ```javascript
+ * constructor() {
+ * super();
+ * this.initObservableProperties('prop1', 'prop2', 'prop3');
+ * this.prop1 = 'test'; // <- this triggers the render() function
+ * }
+ * ```
+ *
+ * @mixin
+ */
+export const ReactiveMixin = dedupeMixin(mxFunction);
diff --git a/src/app/mixins/RenderableMixin.d.ts b/src/app/mixins/RenderableMixin.d.ts
new file mode 100644
index 00000000..46332a18
--- /dev/null
+++ b/src/app/mixins/RenderableMixin.d.ts
@@ -0,0 +1,55 @@
+import { TemplateResult } from 'lit-html/lit-html.js';
+
+export declare const renderingValue: unique symbol;
+export declare const renderPage: unique symbol;
+
+declare function RenderableMixin {}>(base: T): T & RenderableMixinConstructor;
+interface RenderableMixinConstructor {
+ new(...args: any[]): RenderableMixin;
+}
+
+/**
+ * Adds methods that helps with asynchronous template rendering.
+ *
+ * @mixin
+ */
+declare interface RenderableMixin {
+ /**
+ * True when rendering debouncer is running.
+ */
+ readonly rendering: boolean;
+
+ [renderingValue]: boolean;
+ firstRendered: boolean;
+
+ /**
+ * A promise resolved when the render finished.
+ */
+ updateComplete: Promise;
+
+ /**
+ * Helper function to be overridden by child classes. It is called when the view
+ * is rendered for the first time.
+ */
+ firstRender(): void;
+
+ /**
+ * This to be used by the child classes to render page template.
+ * @returns {} Application page template
+ */
+ appTemplate(): TemplateResult;
+
+ /**
+ * The main render function. Sub classes should not override this method.
+ * Override `[renderPage]()` instead.
+ *
+ * The function calls `[renderPage]()` in a micro task so it is safe to call this
+ * multiple time in the same event loop.
+ */
+ render(): void;
+
+ [renderPage](): void;
+}
+
+export {RenderableMixinConstructor};
+export {RenderableMixin};
\ No newline at end of file
diff --git a/src/app/mixins/RenderableMixin.js b/src/app/mixins/RenderableMixin.js
new file mode 100644
index 00000000..e54458ba
--- /dev/null
+++ b/src/app/mixins/RenderableMixin.js
@@ -0,0 +1,124 @@
+/* eslint-disable class-methods-use-this */
+import { dedupeMixin } from '../../../web_modules/@open-wc/dedupe-mixin/index.js';
+import { html, render } from '../../../web_modules/lit-html/lit-html.js';
+
+/** @typedef {import('lit-html').TemplateResult} TemplateResult */
+
+export const renderingValue = Symbol('renderingValue');
+export const renderPage = Symbol('renderPage');
+export const setUpdatePromise = Symbol('setUpdatePromise');
+export const updateResolver = Symbol('updateResolver');
+export const hasPendingUpdatePromise = Symbol('hasPendingUpdatePromise');
+export const resolveUpdatePromise = Symbol('resolveUpdatePromise');
+
+/**
+ * @param {new (...args: any[]) => EventTarget} base
+ */
+const mxFunction = (base) => {
+ class RenderableMixin extends base {
+
+ /**
+ * True when rendering debouncer is running.
+ */
+ get rendering() {
+ return this[renderingValue];
+ }
+
+ constructor() {
+ super();
+ /**
+ * Determines whether the initial render had run and the `firstRender()`
+ * function was called.
+ *
+ * @type {boolean}
+ * @default false
+ */
+ this.firstRendered = false;
+
+ this[renderingValue] = false;
+
+ /**
+ * @type {Promise} A promise resolved when the render finished.
+ */
+ this.updateComplete = undefined;
+
+ this[setUpdatePromise]();
+ }
+
+ /**
+ * Helper function to be overridden by child classes. It is called when the view
+ * is rendered for the first time.
+ */
+ firstRender() {
+ }
+
+ /**
+ * A function called when the template has been rendered
+ */
+ updated() {}
+
+ /**
+ * This to be used by the child classes to render page template.
+ * @returns {TemplateResult} Application page template
+ */
+ appTemplate() {
+ return html``;
+ }
+
+ /**
+ * The main render function. Sub classes should not override this method.
+ * Override `[renderPage]()` instead.
+ *
+ * The function calls `[renderPage]()` in a micro task so it is safe to call this
+ * multiple time in the same event loop.
+ */
+ render() {
+ if (this.rendering) {
+ return;
+ }
+ this[renderingValue] = true;
+ if (!this[hasPendingUpdatePromise]) {
+ this[setUpdatePromise]();
+ }
+ requestAnimationFrame(() => {
+ this[renderingValue] = false;
+ this[renderPage]();
+ });
+ }
+
+ [renderPage]() {
+ if (!this.firstRendered) {
+ this.firstRendered = true;
+ setTimeout(() => this.firstRender());
+ }
+ render(this.appTemplate(), document.querySelector('#app'), { eventContext: this });
+ this[resolveUpdatePromise]();
+ this.updated();
+ }
+
+ [setUpdatePromise]() {
+ this.updateComplete = new Promise((resolve) => {
+ this[updateResolver] = resolve;
+ this[hasPendingUpdatePromise] = true;
+ });
+ }
+
+ [resolveUpdatePromise]() {
+ if (!this[hasPendingUpdatePromise]) {
+ return;
+ }
+ this[hasPendingUpdatePromise] = false;
+ this[updateResolver]();
+ }
+ }
+ return RenderableMixin;
+}
+
+/**
+ * Adds methods that helps with asynchronous template rendering.
+ *
+ * The application page content is rendered into the `#app` container.
+ *
+ * @mixin
+ */
+export const RenderableMixin = dedupeMixin(mxFunction);
diff --git a/src/app/popup-menu.html b/src/app/popup-menu.html
new file mode 100644
index 00000000..76ed45ba
--- /dev/null
+++ b/src/app/popup-menu.html
@@ -0,0 +1,17 @@
+
+
+
+ Advanced REST Client by MuleSoft
+
+
+
+
diff --git a/src/app/scripts/AboutDialog.js b/src/app/scripts/AboutDialog.js
new file mode 100644
index 00000000..83b375b0
--- /dev/null
+++ b/src/app/scripts/AboutDialog.js
@@ -0,0 +1,396 @@
+/* eslint-disable no-param-reassign */
+import { ApplicationPage } from '../ApplicationPage.js';
+import { html } from '../../../web_modules/lit-html/lit-html.js';
+import '../../../web_modules/@polymer/font-roboto-local/roboto.js';
+import '../../../web_modules/@anypoint-web-components/anypoint-dropdown-menu/anypoint-dropdown-menu.js';
+import '../../../web_modules/@anypoint-web-components/anypoint-listbox/anypoint-listbox.js';
+import '../../../web_modules/@anypoint-web-components/anypoint-item/anypoint-item.js';
+import '../../../web_modules/@anypoint-web-components/anypoint-item/anypoint-item-body.js';
+import '../../../web_modules/@anypoint-web-components/anypoint-button/anypoint-button.js';
+import '../../../web_modules/@anypoint-web-components/anypoint-switch/anypoint-switch.js';
+import '../../../web_modules/@advanced-rest-client/arc-icons/arc-icon.js';
+
+/** @typedef {import('lit-html').TemplateResult} TemplateResult */
+/** @typedef {import('electron-updater').UpdateInfo} UpdateInfo */
+/** @typedef {import('@advanced-rest-client/arc-types').Config.ARCConfig} ARCConfig */
+/** @typedef {import('@anypoint-web-components/anypoint-switch').AnypointSwitch} AnypointSwitch */
+
+/* global PreferencesProxy, ThemeManager, logger, ipc, PreferencesProxy */
+
+const checkingUpdateHandler = Symbol('checkingUpdateHandler');
+const updateAvailableHandler = Symbol('updateAvailableHandler');
+const updateNotAvailableHandler = Symbol('updateNotAvailableHandler');
+const updateErrorHandler = Symbol('updateErrorHandler');
+const downloadingHandler = Symbol('downloadingHandler');
+const downloadedHandler = Symbol('downloadedHandler');
+
+class AboutDialog extends ApplicationPage {
+ settings = new PreferencesProxy();
+
+ themeProxy = new ThemeManager();
+
+ get updateDownloaded() {
+ return this.updateStatePage === 3;
+ }
+
+ get updateProgress() {
+ return [1, 2, 3].indexOf(this.updateStatePage) !== -1;
+ }
+
+ get isError() {
+ return this.updateStatePage === 4;
+ }
+
+ get updateLabel() {
+ switch (this.updateStatePage) {
+ case 1: return html`Checking for update...`;
+ case 2: return html`Downloading update...`;
+ case 3: return html`Ready to install`;
+ case 4: return html`Update error`;
+ default: return html`ARC is up to date ❤ `;
+ }
+ }
+
+ constructor() {
+ super();
+
+ this.initObservableProperties(
+ 'autoUpdate', 'updateStatePage', 'errorMessage', 'releaseChannel', 'errorCode',
+ 'compatibility', 'upgradeInfo'
+ );
+ this.compatibility = false;
+
+ /**
+ * page of the update status label
+ */
+ this.updateStatePage = 0;
+ /**
+ * State of auto update setting.
+ */
+ this.autoUpdate = false;
+ /**
+ * Associated message with current error code.
+ * @type {string}
+ */
+ this.errorMessage = undefined;
+ /**
+ * @type {string}
+ */
+ this.errorCode = undefined;
+ /**
+ * Current release channel.
+ * @type {string}
+ */
+ this.releaseChannel = 'latest';
+ /**
+ * Current release channel.
+ * @type {UpdateInfo}
+ */
+ this.upgradeInfo = undefined;
+ /**
+ * Enables compatibility with Anypoint platform
+ */
+ this.compatibility = false;
+ }
+
+ async initialize() {
+ await this.loadTheme();
+ let cnf = /** @type ARCConfig */ ({});
+ try {
+ cnf = await this.settings.read();
+ } catch (e) {
+ this.reportCriticalError(e);
+ throw e;
+ }
+ const { updater={} } = cnf;
+ const { auto, channel } = updater;
+ this.releaseChannel = channel || 'latest';
+ this.autoUpdate = auto;
+ this.listen();
+ this.render();
+ }
+
+ /**
+ * Loads the current theme.
+ */
+ async loadTheme() {
+ const info = await this.themeProxy.readActiveThemeInfo();
+ const theme = info && info.name;
+ try {
+ await this.themeProxy.loadTheme(theme);
+ this.compatibility = theme === ThemeManager.anypointTheme;
+ } catch (e) {
+ logger.error(e);
+ }
+ }
+
+ listen() {
+ ipc.on('checking-for-update', this[checkingUpdateHandler].bind(this));
+ ipc.on('update-available', this[updateAvailableHandler].bind(this));
+ ipc.on('update-not-available', this[updateNotAvailableHandler].bind(this));
+ ipc.on('autoupdate-error', this[updateErrorHandler].bind(this));
+ ipc.on('download-progress', this[downloadingHandler].bind(this));
+ ipc.on('update-downloaded', this[downloadedHandler].bind(this));
+ }
+
+ [checkingUpdateHandler]() {
+ this.updateStatePage = 1;
+ }
+
+ /**
+ * @param {*} e
+ * @param {UpdateInfo} info
+ */
+ [updateAvailableHandler](e, info) {
+ this.upgradeInfo = info;
+ if (this.updateStatePage !== 2) {
+ this.updateStatePage = 2;
+ }
+ }
+
+ [updateNotAvailableHandler]() {
+ this.updateStatePage = 0;
+ }
+
+ /**
+ * @param {*} e
+ * @param {*} err
+ */
+ [updateErrorHandler](e, err) {
+ this.updateStatePage = 4;
+ this.createErrorMessage(err.code, err.message);
+ this.errorCode = err.code || undefined;
+ }
+
+ [downloadingHandler]() {
+ if (this.updateStatePage !== 2) {
+ this.updateStatePage = 2;
+ }
+ }
+
+ [downloadedHandler]() {
+ this.updateStatePage = 3;
+ }
+
+ /**
+ * @param {string=} code
+ * @param {string=} message
+ */
+ createErrorMessage(code, message) {
+ switch (code) {
+ case 'ERR_UPDATER_INVALID_RELEASE_FEED':
+ message = 'Unable to parse releases feed.';
+ break;
+ case 'ERR_UPDATER_NO_PUBLISHED_VERSIONS':
+ message = 'Unable to find published version.';
+ break;
+ case 'ERR_UPDATER_CHANNEL_FILE_NOT_FOUND':
+ message = 'Cannot find latest release information for this platform.';
+ break;
+ case 'ERR_UPDATER_LATEST_VERSION_NOT_FOUND':
+ message = 'Unable to find latest version on GitHub.';
+ break;
+ default:
+ message = message || 'Unknown error ocurred.';
+ }
+ this.errorMessage = message;
+ }
+
+ async updateCheck() {
+ // ipc.send('check-for-update');
+ try {
+ await ipc.invoke('check-for-update');
+ } catch (e) {
+ this.createErrorMessage(null, e.message);
+ this.updateStatePage = 4;
+ }
+ }
+
+ updateInstall() {
+ ipc.send('install-update');
+ }
+
+ /**
+ * @param {MouseEvent} e
+ */
+ linkHandler(e) {
+ e.preventDefault();
+ e.stopPropagation();
+ const anchor = /** @type HTMLAnchorElement */ (e.target);
+ ipc.send('open-external-url', anchor.href);
+ }
+
+ /**
+ * Checks if `channel` is a valid channel signature.
+ * @param {string} channel
+ * @returns {boolean}
+ */
+ isValidChannel(channel) {
+ return ['beta', 'alpha', 'latest'].indexOf(channel) !== -1;
+ }
+
+ /**
+ * @param {Event} e
+ */
+ autoChangeHandler(e) {
+ const button = /** @type AnypointSwitch */ (e.target);
+ if (this.autoUpdate === undefined && button.checked === false) {
+ this.autoUpdate = button.checked;
+ return;
+ }
+ if (button.checked === this.autoUpdate) {
+ return;
+ }
+ this.autoUpdate = button.checked;
+ this.settings.update('updater.auto', button.checked);
+ }
+
+ /**
+ * @param {CustomEvent} e
+ */
+ releaseChannelHandler(e) {
+ this.releaseChannel = e.detail.value;
+ this.settings.update('updater.channel', e.detail.value);
+ }
+
+ appTemplate() {
+ return html`
+
+ ${this.titleTemplate()}
+ ${this.updatesSettingsTemplate()}
+ ${this.errorTemplate()}
+ ${this.authorTemplate()}
+
+ `;
+ }
+
+ titleTemplate() {
+ const { versionInfo } = window;
+ return html`
+
+
+
+
Advanced REST Client
+
+
`;
+ }
+
+ updatesSettingsTemplate() {
+ const {
+ updateProgress,
+ updateDownloaded,
+ compatibility,
+ autoUpdate,
+ updateLabel,
+ } = this;
+ return html`
+
+
+
${updateLabel}
+ ${updateDownloaded ?
+ html`
Restart and install ` :
+ html`
Check for updates `}
+
+
+ Automatically download and install updates
+
+
`;
+ }
+
+ channelsTemplate() {
+ const {
+ compatibility,
+ releaseChannel
+ } = this;
+ return html`
+
+ Release channel
+
+
+
+ Stable
+ Default channel. Tested and targeted for production environment.
+
+
+
+
+ Beta
+ Next release. Tested but may contain bugs.
+
+
+
+
+ Unstable
+ Development version. May not be fully tested and contain bugs!
+
+
+
+
+
+ ${errorMessage}
+ ${errorCode ? html`${errorCode}
` : ''}
+ `;
+ }
+
+ authorTemplate() {
+ return html`
+
+ Coded by Pawel Psztyc .
+
+ With great support of MuleSoft, a Salesforce company.
+
+
+ `;
+ }
+}
+const page = new AboutDialog();
+page.initialize();
diff --git a/src/app/scripts/AnalyticsConsent.js b/src/app/scripts/AnalyticsConsent.js
new file mode 100644
index 00000000..8890fa2f
--- /dev/null
+++ b/src/app/scripts/AnalyticsConsent.js
@@ -0,0 +1,121 @@
+import { ApplicationPage } from '../ApplicationPage.js';
+import { html } from '../../../web_modules/lit-html/lit-html.js';
+import '../../../web_modules/@polymer/font-roboto-local/roboto.js';
+import '../../../web_modules/@anypoint-web-components/anypoint-dropdown-menu/anypoint-dropdown-menu.js';
+import '../../../web_modules/@anypoint-web-components/anypoint-listbox/anypoint-listbox.js';
+import '../../../web_modules/@anypoint-web-components/anypoint-item/anypoint-item.js';
+import '../../../web_modules/@anypoint-web-components/anypoint-item/anypoint-item-body.js';
+import '../../../web_modules/@anypoint-web-components/anypoint-button/anypoint-button.js';
+
+/** @typedef {import('lit-html').TemplateResult} TemplateResult */
+
+/* global PreferencesProxy, ThemeManager, logger, ipc */
+
+
+class AnalyticsConsent extends ApplicationPage {
+ settings = new PreferencesProxy();
+
+ themeProxy = new ThemeManager();
+
+ constructor() {
+ super();
+
+ this.selected = 0;
+ }
+
+ async initialize() {
+ await this.loadTheme();
+ this.render();
+ }
+
+ /**
+ * Loads the current theme.
+ */
+ async loadTheme() {
+ const info = await this.themeProxy.readActiveThemeInfo();
+ const theme = info && info.name;
+ try {
+ await this.themeProxy.loadTheme(theme);
+ } catch (e) {
+ logger.error(e);
+ }
+ }
+
+ selectionHandler(e) {
+ this.selected = e.target.selected;
+ }
+
+ async saveState() {
+ const cnf = await this.settings.read();
+ cnf.privacy = cnf.privacy || {};
+ cnf.privacy.telemetry = false;
+ if (this.selected === 1) {
+ cnf.privacy.exceptionsOnly = true;
+ } else {
+ cnf.privacy.exceptionsOnly = false;
+ }
+ if (this.selected === 0) {
+ cnf.privacy.telemetry = true;
+ }
+ await this.settings.update('privacy.telemetry', cnf.privacy.telemetry);
+ await this.settings.update('privacy.exceptionsOnly', cnf.privacy.exceptionsOnly);
+ ipc.send('telemetry-set');
+ }
+
+ appTemplate() {
+ return html`
+ ${this.headerTemplate()}
+
+
+ Welcome to Advanced REST Client!
+ Your privacy is important to us. You can limit or completely disable anonymous usage statistics for the application.
+ The analytics data are processed for usage analysis which helps us make design and development decisions. We do not share this data with anyone.
+ You can read our privacy statement in the Privacy policy document.
+
+
+
+ Select anonymous data collection level
+
+
+
+ Limited usage statistics
+ Opened screen names, few actions triggered, exceptions.
+
+
+
+
+ Exceptions only
+ Only collected when an exception occurs. No user data is included.
+
+
+
+
+ No consent
+ It makes us sad but we respect your decision.
+
+
+
+
+
You can always change it later in the application settings.
+
+
+ API Client by MuleSoft.
+ `;
+ }
+}
+const page = new AnalyticsConsent();
+page.initialize();
diff --git a/src/app/scripts/GoogleDrivePicker.js b/src/app/scripts/GoogleDrivePicker.js
new file mode 100644
index 00000000..d776a90f
--- /dev/null
+++ b/src/app/scripts/GoogleDrivePicker.js
@@ -0,0 +1,144 @@
+import { ApplicationPage } from '../ApplicationPage.js';
+import { html } from '../../../web_modules/lit-html/lit-html.js';
+import '../../../web_modules/@advanced-rest-client/google-drive-browser/google-drive-browser.js';
+
+/** @typedef {import('lit-html').TemplateResult} TemplateResult */
+/** @typedef {import('@advanced-rest-client/electron-oauth2/renderer/OAuth2Handler').OAuth2Handler} OAuth2Handler */
+/** @typedef {import('@advanced-rest-client/arc-types').Authorization.OAuth2Authorization} OAuth2Authorization */
+
+/* global ThemeManager, logger, OAuth2Handler, GoogleDriveProxy */
+
+export class GoogleDrivePickerScreen extends ApplicationPage {
+ /**
+ * @returns {OAuth2Authorization}
+ */
+ get oauthConfig() {
+ return {
+ clientId: '1076318174169-u4a5d3j2v0tbie1jnjgsluqk1ti7ged3.apps.googleusercontent.com',
+ authorizationUri: 'https://accounts.google.com/o/oauth2/v2/auth',
+ redirectUri: 'https://auth.advancedrestclient.com/oauth2',
+ scopes: [
+ 'https://www.googleapis.com/auth/drive.file',
+ 'https://www.googleapis.com/auth/drive.install',
+ ],
+ }
+ }
+
+ themeProxy = new ThemeManager();
+
+ oauth2Proxy = new OAuth2Handler();
+
+ gDrive = new GoogleDriveProxy();
+
+ constructor() {
+ super();
+
+ this.initObservableProperties(
+ 'compatibility', 'initializing', 'loadingStatus', 'driveToken',
+ );
+ this.compatibility = false;
+ /**
+ * @type {boolean} Whether the project is being restored from the metadata store.
+ */
+ this.initializing = true;
+ /**
+ * @type {string} A loading state information.
+ */
+ this.loadingStatus = 'Initializing application...';
+
+ this.logger = logger;
+ /**
+ * @type {string}
+ */
+ this.driveToken = undefined;
+ }
+
+ async initialize() {
+ this.listen();
+ await this.loadTheme();
+ this.requestGoogleDriveToken();
+ this.initializing = false;
+ }
+
+ listen() {
+ this.themeProxy.listen();
+ this.oauth2Proxy.listen();
+ window.addEventListener('themeactivated', (e) => {
+ // @ts-ignore
+ this.compatibility = e.detail === ThemeManager.anypointTheme;
+ });
+ }
+
+ /**
+ * Loads the current theme.
+ */
+ async loadTheme() {
+ const info = await this.themeProxy.readActiveThemeInfo();
+ const theme = info && info.name;
+ try {
+ await this.themeProxy.loadTheme(theme);
+ } catch (e) {
+ this.logger.error(e);
+ }
+ }
+
+ async requestGoogleDriveToken() {
+ const cnf = this.oauthConfig;
+ cnf.interactive = true;
+ const auth = await this.oauth2Proxy.requestToken(cnf);
+ if (!auth) {
+ return;
+ }
+ this.driveToken = auth.accessToken;
+ }
+
+ /**
+ * @param {CustomEvent} e
+ */
+ drivePickHandler(e) {
+ const id = e.detail;
+ this.gDrive.notifyParentFilePicked(id);
+ }
+
+ appTemplate() {
+ const { initializing } = this;
+ if (initializing) {
+ return this.loaderTemplate();
+ }
+ return html`
+
+ ${this.googleDriveTemplate()}
+
+ `;
+ }
+
+ /**
+ * @returns {TemplateResult} A template for the loader
+ */
+ loaderTemplate() {
+ return html`
+
+
Preparing Google Drive Picker
+
${this.loadingStatus}
+
[^/]*)/(?[^/]*)'
+ },
+ {
+ name: 'open',
+ pattern: 'open/(?[^/]*)/(?[^/]*)/(?[^/]*)'
+ },
+ {
+ name: 'api-console',
+ pattern: 'docs/?'
+ },
+ ];
+ }
+
+ settings = new PreferencesProxy();
+
+ themeProxy = new ThemeManager();
+
+ fs = new FilesystemProxy();
+
+ search = new ApplicationSearchProxy();
+
+ /**
+ * Responsible for processing API data and producing AMF model consumed by the API Console.
+ */
+ apiParser = new ElectronAmfService();
+
+ requestFactory = new ConsoleRequest();
+
+ constructor() {
+ super();
+
+ this.initObservableProperties(
+ 'route', 'initializing', 'loadingStatus', 'compatibility',
+ 'amfType', 'selectedShape', 'selectedShapeType',
+ 'navigationWidth', 'isStored',
+ 'indexItem', 'apiVersion',
+ );
+
+ /**
+ * @type {boolean} Whether the project is being restored from the metadata store.
+ */
+ this.initializing = true;
+ /**
+ * @type {string} A loading state information.
+ */
+ this.loadingStatus = 'Initializing application...';
+ this.logger = logger;
+
+ /**
+ * A flag to determine whether the current API is stored in the application data store.
+ * When set to true it renders controls to store the API data.
+ */
+ this.isStored = false;
+
+ /**
+ * @type {ARCRestApiIndex}
+ */
+ this.indexItem = undefined;
+
+ window.onunhandledrejection = this[unhandledRejectionHandler].bind(this);
+ this.oauth2RedirectUri = 'http://auth.advancedrestclient.com/arc.html';
+ this.compatibility = false;
+ }
+
+ async initialize() {
+ this.listen();
+ let cnf = {};
+ try {
+ cnf = await this.settings.read();
+ } catch (e) {
+ this.reportCriticalError(e);
+ throw e;
+ }
+ this.config = cnf;
+ this.setConfigVariables(cnf);
+ await this.loadTheme();
+ await this.afterInitialization();
+ this.initializing = false;
+ }
+
+ /**
+ * Sets local variables from the config object
+ * @param {ARCConfig} cnf
+ */
+ setConfigVariables(cnf) {
+ if (cnf.request) {
+ if (typeof cnf.request.timeout === 'number') {
+ this.requestFactory.requestTimeout = cnf.request.timeout;
+ }
+ if (typeof cnf.request.validateCertificates === 'boolean') {
+ this.requestFactory.validateCertificates = cnf.request.validateCertificates;
+ }
+ if (typeof cnf.request.nativeTransport === 'boolean') {
+ this.requestFactory.nativeTransport = cnf.request.nativeTransport;
+ }
+ }
+ }
+
+ listen() {
+ this.settings.observe();
+ this.themeProxy.listen();
+ this.fs.listen();
+ this.search.listen();
+ this.requestFactory.listen();
+ window.addEventListener(ConfigEventTypes.State.update, this[configStateChangeHandler].bind(this));
+ window.addEventListener('mousemove', this[resizeMouseMove].bind(this));
+ window.addEventListener('mouseup', this[resizeMouseUp].bind(this));
+ window.addEventListener('themeactivated', (e) => {
+ // @ts-ignore
+ this.compatibility = e.detail === ThemeManager.anypointTheme;
+ });
+ }
+
+ /**
+ * Tasks to be performed after the application is initialized.
+ */
+ async afterInitialization() {
+ window.onpopstate = () => {
+ this.onRoute();
+ }
+ requestAnimationFrame(() => this.onRoute());
+ }
+
+ /**
+ * Loads the current theme.
+ */
+ async loadTheme() {
+ const info = await this.themeProxy.readActiveThemeInfo();
+ const theme = info && info.name;
+ try {
+ await this.themeProxy.loadTheme(theme);
+ } catch (e) {
+ this.logger.error(e);
+ }
+ }
+
+ /**
+ * @param {PromiseRejectionEvent} e
+ */
+ [unhandledRejectionHandler](e) {
+ /* eslint-disable-next-line no-console */
+ console.error(e);
+ this.reportCriticalError(e.reason);
+ }
+
+ /**
+ * @param {ConfigStateUpdateEvent} e
+ */
+ [configStateChangeHandler](e) {
+ const { key, value } = e.detail;
+ if (key === 'request.timeout') {
+ this.requestFactory.requestTimeout = value;
+ } else if (key === 'request.validateCertificates') {
+ this.requestFactory.validateCertificates = value;
+ } else if (key === 'request.nativeTransport') {
+ this.requestFactory.nativeTransport = value;
+ }
+ }
+
+ /**
+ * Called when route change
+ */
+ onRoute() {
+ const url = new URL(window.location.href);
+ const path = url.hash.replace('#', '');
+ // @ts-ignore
+ const { routes } = this.constructor;
+ const result = findRoute(routes, path);
+ if (!result) {
+ return;
+ }
+ const { name } = result.route;
+ this.route = name;
+ if (name === 'open') {
+ this.openApi(result.params.type, result.params.id, result.params.version);
+ }
+ }
+
+ /**
+ * Opens an API from the given source
+ * @param {string} source Either `file` or `db`
+ * @param {string} id The id of the API to open
+ * @param {string=} version The version of the API to open.
+ * @returns {Promise}
+ */
+ async openApi(source, id, version) {
+ if (source === 'file') {
+ await this.restoreFromTmpFile(id);
+ } else if (source === 'db') {
+ await this.restoreFromDataStore(id, version);
+ }
+ }
+
+ /**
+ * Restores an API that has been stored in a temporary file to move the data
+ * between the main application page and API Console.
+ * @param {string} id The id of the generated file
+ */
+ async restoreFromTmpFile(id) {
+ this.initializing = true;
+ this.loadingStatus = 'Reading API model from a temporary file';
+ this.isStored = false;
+ try {
+ const result = await this.fs.restoreApicModelTmp(id);
+ const unresolved = result.model;
+ this.unresolvedModel = unresolved;
+ this.amfType = result.type;
+ this.loadingStatus = 'Resolving API graph model';
+ const resolved = await this.apiParser.resolveAPiConsole(unresolved, result.type.type);
+ this.amf = JSON.parse(resolved);
+ this.loadingStatus = 'Finishing up';
+ this.processUnsavedModel(this.amf);
+ this.resetSelection();
+ } catch (e) {
+ this.reportCriticalError(e.message);
+ }
+ this.initializing = false;
+ }
+
+ /**
+ * Computes variables used to determine whether the API can be stored in the data store.
+ * @param {any} amf The resolved AMF model.
+ */
+ async processUnsavedModel(amf) {
+ this.baseUri = this._computeBaseUri(amf);
+ this.apiVersion = this._getApiVersion(amf);
+ this.canSave = this._computeCanSave(this.baseUri, this.apiVersion);
+ try {
+ this.indexItem = await ArcModelEvents.RestApi.read(document.body, this.baseUri);
+ if (this.indexItem.versions.includes(this.apiVersion)) {
+ this.isStored = true;
+ }
+ } catch (e) {
+ this.indexItem = undefined;
+ }
+ }
+
+ /**
+ * Computes model's base Uri
+ * @param {any} model AMF data model
+ * @returns {string|undefined}
+ */
+ _computeBaseUri(model) {
+ if (!model) {
+ return undefined;
+ }
+ const server = this._computeServer(model);
+ const protocols = this._computeProtocols(model);
+ return this._getAmfBaseUri(server, protocols);
+ }
+
+ /**
+ * Computes API's version
+ * @param {any} amf AMF data model
+ * @returns {string|undefined}
+ */
+ _getApiVersion(amf) {
+ let version = this._computeApiVersion(amf);
+ if (!version) {
+ version = '1';
+ }
+ return String(version);
+ }
+
+ /**
+ * @param {string} baseUri
+ * @param {string} apiVersion
+ * @returns {boolean} True when this model can be stored in the data store.
+ */
+ _computeCanSave(baseUri, apiVersion) {
+ if (!baseUri || !apiVersion) {
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * Restores API Console from the local data store.
+ * @param {string} id The data store id of the API
+ * @param {string=} version The version of the API to open.
+ */
+ async restoreFromDataStore(id, version) {
+ this.isStored = true;
+ this.canSave = false;
+ this.initializing = true;
+ try {
+ this.loadingStatus = 'Reading data from the data store';
+ this.indexItem = await ArcModelEvents.RestApi.read(document.body, id);
+ const data = await ArcModelEvents.RestApi.dataRead(document.body, `${id}|${version}`);
+ this.loadingStatus = 'Resolving API graph model';
+ const resolved = await this.apiParser.resolveAPiConsole(data.data, this.indexItem.type);
+ this.loadingStatus = 'Finishing up';
+ this.amf = JSON.parse(resolved);
+ this.apiVersion = version;
+ this.resetSelection();
+ } catch (e) {
+ this.indexItem = undefined;
+ this.reportCriticalError('Unable to find the API.');
+ }
+ this.initializing = false;
+ }
+
+ /**
+ * @param {MouseEvent} e
+ */
+ [navResizeMousedown](e) {
+ this[isResizing] = true;
+ e.preventDefault();
+ }
+
+ /**
+ * @param {MouseEvent} e
+ */
+ [resizeMouseUp](e) {
+ if (!this[isResizing]) {
+ return;
+ }
+ this[isResizing] = false;
+ e.preventDefault();
+ }
+
+ /**
+ * @param {MouseEvent} e
+ */
+ [resizeMouseMove](e) {
+ if (!this[isResizing]) {
+ return;
+ }
+ const { pageX } = e;
+ if (pageX < 100) {
+ return;
+ }
+ if (pageX > window.innerWidth - 100) {
+ return;
+ }
+ this.navigationWidth = pageX;
+ }
+
+ [mainBackHandler]() {
+ navigatePage('app.html');
+ }
+
+ /**
+ * Handler for the navigation event dispatched by the `api-navigation`
+ * component.
+ *
+ * @param {CustomEvent} e
+ */
+ _apiNavigationOcurred(e) {
+ const { selected, type } = e.detail;
+ // const isPassive = passive === true;
+ // if (!isPassive && this.page !== 'docs') {
+ // this.closeTryIt();
+ // }
+ this.selectedShape = selected;
+ this.selectedShapeType = type;
+ }
+
+ /**
+ * Computes value of `apiTitle` property.
+ *
+ * @param {Object} shape Shape of AMF model.
+ * @return {String|undefined} Description if defined.
+ */
+ _computeApiTitle(shape) {
+ return /** @type string */ (this._getValue(shape, this.ns.aml.vocabularies.core.name));
+ }
+
+ /**
+ * Resets current selection to "summary" page
+ */
+ resetSelection() {
+ if (this.route !== 'docs') {
+ this.route = 'docs';
+ }
+ this.selectedShapeType = 'summary';
+ this.selectedShape = 'summary';
+ }
+
+ async saveApi() {
+ const { baseUri, apiVersion, amfType } = this;
+ let { indexItem } = this;
+ const webApi = this._computeWebApi(this.amf);
+ const title = this._computeApiTitle(webApi);
+ if (!title) {
+ throw new Error('API title is missing.');
+ }
+ if (indexItem) {
+ indexItem.versions.push(apiVersion);
+ indexItem.latest = apiVersion;
+ } else {
+ indexItem = {
+ _id: baseUri,
+ title,
+ order: 0,
+ latest: apiVersion,
+ versions: [apiVersion],
+ type: amfType.type,
+ }
+ }
+ const record = await ArcModelEvents.RestApi.update(document.body, indexItem);
+ this.indexItem = record.item;
+ this.isStored = true;
+ await ArcModelEvents.RestApi.dataUpdate(document.body, {
+ data: this.unresolvedModel,
+ indexId: baseUri,
+ version: apiVersion,
+ amfVersion: '4.5.1',
+ });
+ }
+
+ /**
+ * @param {Event} e
+ */
+ async _apiActionMenuChanged(e) {
+ const list = /** @type AnypointListbox */ (e.target);
+ const { selected, selectedItem } = list;
+ if (selected === undefined || selected === -1) {
+ return;
+ }
+ const { action } = selectedItem.dataset;
+ switch (action) {
+ case 'delete': this.delete(); break;
+ case 'delete-version': this.deleteVersion(); break;
+ default:
+ }
+ }
+
+ async delete() {
+ const { indexItem } = this;
+ await ArcModelEvents.RestApi.delete(document.body, indexItem._id);
+ navigatePage('app.html');
+ }
+
+ async deleteVersion() {
+ const { indexItem, apiVersion } = this;
+ await ArcModelEvents.RestApi.versionDelete(document.body, indexItem._id, apiVersion);
+ navigatePage('app.html');
+ }
+
+ /**
+ * Changes the API version after selecting a different version of the same API.
+ * @param {Event} e
+ */
+ async [apiVersionMenuHandler](e) {
+ const list = /** @type AnypointListbox */ (e.target);
+ const { selected } = list;
+ navigate('open', 'db', this.indexItem._id, String(selected));
+ }
+
+ appTemplate() {
+ const { initializing } = this;
+ if (initializing) {
+ return this.loaderTemplate();
+ }
+ return html`
+
+ ${this[navigationTemplate]()}
+ ${this[pageTemplate]()}
+
+ `;
+ }
+
+ /**
+ * @returns {TemplateResult} A template for the loader
+ */
+ loaderTemplate() {
+ return html`
+
+
Preparing API data
+
${this.loadingStatus}
+
+
+ ${this.apiNavigationTemplate()}
+
+
+ `;
+ }
+
+ /**
+ * @returns {TemplateResult} The template for the page content
+ */
+ [pageTemplate]() {
+ return html`
+
+ ${this.headerTemplate()}
+ ${this.docsTemplate()}
+
+ `;
+ }
+
+ /**
+ * @returns {TemplateResult|string} The template for the header
+ */
+ headerTemplate() {
+ return html`
+
+
+
+ API Console by MuleSoft.
+ `;
+ }
+
+ /**
+ * @returns {TemplateResult} The template for the main documentation section
+ */
+ docsTemplate() {
+ const {
+ compatibility,
+ selectedShape,
+ selectedShapeType,
+ oauth2RedirectUri,
+ } = this;
+ return html`
+ ${label}
+ `;
+ }
+
+ apiMenuTemplate() {
+ const { isStored, indexItem } = this;
+ if (!isStored) {
+ return '';
+ }
+ const hasMultiVersion = !!indexItem && Array.isArray(indexItem.versions) && !!indexItem.versions.length;
+ return html`
+
+
+
+
+ Delete API
+ ${hasMultiVersion ? html`Delete version ` : ''}
+
+
+
+
+ `;
+ }
+
+ apiVersionsTemplate() {
+ const { isStored, indexItem } = this;
+ if (!isStored) {
+ return '';
+ }
+ const hasMultiVersion = !!indexItem && Array.isArray(indexItem.versions) && !!indexItem.versions.length;
+ if (!hasMultiVersion) {
+ return '';
+ }
+ return html`
+
+ API version
+
+ ${indexItem.versions.map((item) => html`
+ ${item}
+ `)}
+
+
+ `;
+ }
+}
+
+const page = new ApiConsoleApplication();
+page.initialize();
diff --git a/src/app/scripts/apic/ConsoleRequest.js b/src/app/scripts/apic/ConsoleRequest.js
new file mode 100644
index 00000000..beb155d8
--- /dev/null
+++ b/src/app/scripts/apic/ConsoleRequest.js
@@ -0,0 +1,293 @@
+/* eslint-disable no-param-reassign */
+/* eslint-disable no-console */
+import { RequestFactory } from '../../../../web_modules/@advanced-rest-client/request-engine/index.js';
+import { TransportEventTypes, TransportEvents } from '../../../../web_modules/@advanced-rest-client/arc-events/index.js';
+import { ArcModelEvents } from '../../../../web_modules/@advanced-rest-client/arc-models/index.js';
+import jexl from '../../../../web_modules/jexl/dist/Jexl.js';
+
+/** @typedef {import('@advanced-rest-client/arc-events').ApiTransportEvent} ApiTransportEvent */
+/** @typedef {import('@advanced-rest-client/arc-types').ArcRequest.ArcBaseRequest} ArcBaseRequest */
+/** @typedef {import('@advanced-rest-client/arc-types').ArcRequest.TransportRequest} TransportRequest */
+/** @typedef {import('@advanced-rest-client/arc-types').ArcRequest.RequestConfig} RequestConfig */
+/** @typedef {import('@advanced-rest-client/arc-types').ArcResponse.Response} Response */
+/** @typedef {import('@advanced-rest-client/arc-types').ArcResponse.ErrorResponse} ErrorResponse */
+/** @typedef {import('@advanced-rest-client/electron-request').RequestOptions} RequestOptions */
+/** @typedef {import('@api-components/api-request/src/types').ApiConsoleRequest} ApiConsoleRequest */
+/** @typedef {import('@api-components/api-request/src/types').ApiConsoleResponse} ApiConsoleResponse */
+
+/* global ElectronRequest, SocketRequest, logger */
+
+const loadHandler = Symbol('loadHandler');
+const errorHandler = Symbol('errorHandler');
+const prepareRequest = Symbol('prepareRequest');
+const prepareNativeRequest = Symbol('prepareNativeRequest');
+const prepareArcRequest = Symbol('prepareArcRequest');
+const makeConnection = Symbol('makeConnection');
+const transportRequestHandler = Symbol('transportRequestHandler');
+const makeRequestHandler = Symbol('makeRequestHandler');
+const abortRequestHandler = Symbol('abortRequestHandler');
+const removeConnectionHandlers = Symbol('removeConnectionHandlers');
+
+export class ConsoleRequest {
+ constructor() {
+ this.factory = new RequestFactory(window, jexl);
+ /**
+ * @type {number}
+ */
+ this.requestTimeout = undefined;
+ /**
+ * @type {boolean}
+ */
+ this.nativeTransport = undefined;
+ /**
+ * @type {boolean}
+ */
+ this.validateCertificates = undefined;
+ /**
+ * @type {Map}
+ */
+ this.connections = new Map();
+
+ this[loadHandler] = this[loadHandler].bind(this);
+ this[errorHandler] = this[errorHandler].bind(this);
+ }
+
+ listen() {
+ window.addEventListener('api-request', this[makeRequestHandler].bind(this));
+ window.addEventListener('abort-api-request', this[abortRequestHandler].bind(this));
+ window.addEventListener(TransportEventTypes.transport, this[transportRequestHandler].bind(this));
+ }
+
+ /**
+ * @param {CustomEvent} e
+ */
+ async [makeRequestHandler](e) {
+ const consoleRequest = /** @type any */ (e.detail);
+ // this event is significant, even though it is handled by the same class.
+ TransportEvents.transport(document.body, consoleRequest.id, consoleRequest);
+ }
+
+ /**
+ * @param {ApiTransportEvent} e
+ */
+ async [transportRequestHandler](e) {
+ const transportRequest = /** @type any */ (e.detail);
+ const { id, request } = transportRequest;
+ await this.run(id, request);
+ }
+
+ /**
+ * @param {string} id
+ * @param {ApiConsoleRequest} request
+ */
+ async run(id, request) {
+ const config = this.prepareRequestOptions();
+ const baseRequest = this.translateRequest(request);
+ // the request can proceed without hosts
+ try {
+ const hosts = await ArcModelEvents.HostRules.list(document.body);
+ if (hosts && hosts.items) {
+ config.hosts = hosts.items;
+ }
+ } catch (e) {
+ logger.error(e);
+ }
+ logger.info(`The config passed to the request factory:`, config);
+ try {
+ const connection = await this[prepareRequest](id, baseRequest, config);
+ await this[makeConnection](connection);
+ } catch (e) {
+ logger.error(e);
+ this[errorHandler](e, id);
+ }
+ }
+
+ [abortRequestHandler](e) {
+ const { id } = e.detail;
+ this.factory.abort(id);
+ const info = this.connections.get(id);
+ info.connection.abort();
+ }
+
+ /**
+ * @returns {RequestOptions}
+ */
+ prepareRequestOptions() {
+ const result = /** @type RequestOptions */ ({});
+ result.logger = logger;
+ if (typeof this.requestTimeout === 'number') {
+ result.timeout = this.requestTimeout;
+ }
+ if (result.timeout) {
+ result.timeout *= 1000;
+ } else {
+ result.timeout = 0;
+ }
+
+ if (typeof result.validateCertificates === 'undefined' && typeof this.validateCertificates === 'boolean') {
+ result.validateCertificates = this.validateCertificates;
+ }
+ return result;
+ }
+
+ /**
+ * @param {ApiConsoleRequest} init
+ * @returns {ArcBaseRequest}
+ */
+ translateRequest(init) {
+ const result = /** @type ArcBaseRequest */ ({
+ url: init.url,
+ method: init.method,
+ headers: init.headers,
+ payload: init.payload,
+ auth: init.auth,
+ });
+ return result;
+ }
+
+ /**
+ * @param {string} id
+ * @param {ArcBaseRequest} request
+ * @param {RequestOptions} opts
+ * @returns {SocketRequest|ElectronRequest}
+ */
+ [prepareRequest](id, request, opts) {
+ return this.nativeTransport ? this[prepareNativeRequest](id, request, opts) : this[prepareArcRequest](id, request, opts);
+ }
+
+ /**
+ * @param {string} id
+ * @param {ArcBaseRequest} request
+ * @param {RequestOptions} opts
+ * @returns {ElectronRequest}
+ */
+ [prepareNativeRequest](id, request, opts) {
+ const conn = new ElectronRequest(request, id, opts);
+ this.connections.set(id, {
+ connection: conn,
+ aborted: false,
+ request,
+ });
+ conn.on('load', this[loadHandler]);
+ conn.on('error', this[errorHandler]);
+ return conn;
+ }
+
+ /**
+ * @param {string} id
+ * @param {ArcBaseRequest} request
+ * @param {RequestOptions} opts
+ * @returns {SocketRequest}
+ */
+ [prepareArcRequest](id, request, opts) {
+ const conn = new SocketRequest(request, id, opts);
+ this.connections.set(id, {
+ connection: conn,
+ aborted: false,
+ request,
+ });
+ conn.on('load', this[loadHandler]);
+ conn.on('error', this[errorHandler]);
+ return conn;
+ }
+
+ /**
+ * @param {SocketRequest|ElectronRequest} connection
+ */
+ async [makeConnection](connection) {
+ try {
+ await connection.send();
+ } catch (cause) {
+ this[errorHandler](cause, connection.id);
+ }
+ }
+
+ /**
+ * @param {string} id
+ * @param {Response} response
+ * @param {TransportRequest} transport
+ */
+ async [loadHandler](id, response, transport) {
+ const info = this.connections.get(id);
+ this.connections.delete(id);
+ if (!info || info.aborted) {
+ return;
+ }
+ this[removeConnectionHandlers](info.connection);
+ const fr = {
+ id,
+ request: info.request,
+ }
+ try {
+ // @ts-ignore
+ await this.factory.processResponse(fr, transport, response, {
+ evaluateVariables: false,
+ evaluateSystemVariables: false,
+ });
+ } catch (e) {
+ // ...
+ }
+ const resp = /** @type ApiConsoleResponse */ ({
+ id,
+ isError: false,
+ loadingTime: response.loadingTime,
+ request: transport,
+ response: {
+ status: response.status,
+ statusText: response.statusText,
+ headers: response.headers,
+ payload: response.payload,
+ }
+ });
+ this._notifyResponse(resp);
+ }
+
+ /**
+ * @param {Error} error
+ * @param {string} id
+ * @param {TransportRequest=} transport
+ * @param {ErrorResponse=} response
+ */
+ [errorHandler](error, id, transport, response) {
+ const info = this.connections.get(id);
+ this.connections.delete(id);
+ if (!info || info.aborted) {
+ return;
+ }
+ this[removeConnectionHandlers](info.connection);
+ const result = {
+ id,
+ request: info.request,
+ isError: true,
+ error,
+ loadingTime: 0,
+ response: response || {
+ status: 0,
+ },
+ };
+ // @ts-ignore
+ this._notifyResponse(result);
+ }
+
+ /**
+ * @param {SocketRequest|ElectronRequest} connection
+ */
+ [removeConnectionHandlers](connection) {
+ connection.removeAllListeners('load');
+ connection.removeAllListeners('error');
+ }
+
+ /**
+ * Dispatches `api-response` custom event.
+ *
+ * @param {ApiConsoleResponse} detail Request and response data.
+ */
+ _notifyResponse(detail) {
+ const e = new CustomEvent('api-response', {
+ bubbles: true,
+ composed: true,
+ detail
+ });
+ document.body.dispatchEvent(e);
+ }
+}
diff --git a/src/app/scripts/app.js b/src/app/scripts/app.js
new file mode 100644
index 00000000..443442f4
--- /dev/null
+++ b/src/app/scripts/app.js
@@ -0,0 +1,9 @@
+import './pouchdb.js';
+import { AdvancedRestClientApplication } from './arc/AdvancedRestClientApplication.js';
+import marked from '../../../web_modules/marked/lib/marked.js';
+
+// @ts-ignore
+window.marked = marked;
+
+const page = new AdvancedRestClientApplication();
+page.initialize();
diff --git a/src/app/scripts/arc/AdvancedRestClientApplication.js b/src/app/scripts/arc/AdvancedRestClientApplication.js
new file mode 100644
index 00000000..5632f116
--- /dev/null
+++ b/src/app/scripts/arc/AdvancedRestClientApplication.js
@@ -0,0 +1,1759 @@
+/* eslint-disable no-unused-vars */
+import { ApplicationPage } from '../../ApplicationPage.js';
+import { findRoute, navigate, navigatePage } from '../lib/route.js';
+import { html } from '../../../../web_modules/lit-html/lit-html.js';
+import { MonacoLoader } from '../../../../web_modules/@advanced-rest-client/monaco-support/index.js';
+import { ArcNavigationEventTypes, ProjectActions, ConfigEventTypes, DataImportEventTypes, WorkspaceEvents, ImportEvents, WorkspaceEventTypes, ArcNavigationEvents, RestApiEventTypes } from '../../../../web_modules/@advanced-rest-client/arc-events/index.js';
+import { ArcModelEvents, ArcModelEventTypes, ImportFactory, ImportNormalize, isSingleRequest } from '../../../../web_modules/@advanced-rest-client/arc-models/index.js';
+import { ModulesRegistry, RequestCookies } from '../../../../web_modules/@advanced-rest-client/request-engine/index.js';
+import { classMap } from '../../../../web_modules/lit-html/directives/class-map.js';
+import { styleMap } from '../../../../web_modules/lit-html/directives/style-map.js';
+import '../../arc-alert-dialog.js';
+import '../../../../web_modules/@polymer/font-roboto-local/roboto.js';
+import '../../../../web_modules/@advanced-rest-client/arc-request-ui/arc-request-workspace.js';
+import '../../../../web_modules/@advanced-rest-client/arc-models/project-model.js';
+import '../../../../web_modules/@advanced-rest-client/arc-models/url-history-model.js';
+import '../../../../web_modules/@advanced-rest-client/arc-models/websocket-url-history-model.js';
+import '../../../../web_modules/@advanced-rest-client/arc-models/history-data-model.js';
+import '../../../../web_modules/@advanced-rest-client/arc-models/client-certificate-model.js';
+import '../../../../web_modules/@advanced-rest-client/arc-models/variables-model.js';
+import '../../../../web_modules/@advanced-rest-client/arc-models/auth-data-model.js';
+import '../../../../web_modules/@advanced-rest-client/arc-models/request-model.js';
+import '../../../../web_modules/@advanced-rest-client/arc-models/host-rules-model.js';
+import '../../../../web_modules/@advanced-rest-client/arc-models/rest-api-model.js';
+import '../../../../web_modules/@advanced-rest-client/arc-models/url-indexer.js';
+import '../../../../web_modules/@advanced-rest-client/arc-menu/arc-menu.js';
+import '../../../../web_modules/@advanced-rest-client/requests-list/history-panel.js';
+import '../../../../web_modules/@advanced-rest-client/requests-list/saved-panel.js';
+import '../../../../web_modules/@advanced-rest-client/client-certificates/client-certificates-panel.js';
+import '../../../../web_modules/@advanced-rest-client/arc-ie/arc-data-export.js';
+import '../../../../web_modules/@advanced-rest-client/arc-ie/arc-export-form.js';
+import '../../../../web_modules/@advanced-rest-client/arc-ie/arc-data-import.js';
+import '../../../../web_modules/@advanced-rest-client/arc-ie/import-data-inspector.js';
+import '../../../../web_modules/@advanced-rest-client/arc-environment/variables-overlay.js';
+import '../../../../web_modules/@advanced-rest-client/arc-cookies/cookie-manager.js';
+import '../../../../web_modules/@advanced-rest-client/arc-settings/arc-settings.js';
+import '../../../../web_modules/@advanced-rest-client/arc-request-ui/request-meta-details.js';
+import '../../../../web_modules/@advanced-rest-client/arc-request-ui/request-meta-editor.js';
+import '../../../../web_modules/@advanced-rest-client/bottom-sheet/bottom-sheet.js';
+import '../../../../web_modules/@advanced-rest-client/arc-icons/arc-icon.js';
+import '../../../../web_modules/@anypoint-web-components/anypoint-input/anypoint-masked-input.js';
+import '../../../../web_modules/@advanced-rest-client/host-rules-editor/host-rules-editor.js';
+import '../../../../web_modules/@api-components/api-navigation/api-navigation.js';
+import '../../../../web_modules/@advanced-rest-client/exchange-search-panel/exchange-search-panel.js';
+// import '../../../../web_modules/@api-components/api-request-panel/api-request-panel.js';
+// import '../../../../web_modules/@api-components/api-documentation/api-documentation.js';
+import { Request } from './Request.js';
+import { ContextMenu } from '../context-menu/ContextMenu.js';
+import { ContextMenuStyles } from '../context-menu/ContextMenu.styles.js';
+import ContextMenuCommands from './ArcContextMenuCommands.js';
+import { getTabClickIndex } from './Utils.js';
+
+// @ts-ignore
+document.adoptedStyleSheets = document.adoptedStyleSheets.concat(ContextMenuStyles.styleSheet);
+
+/* global PreferencesProxy, OAuth2Handler, WindowManagerProxy, ThemeManager, logger, EncryptionService, WorkspaceManager, ipc, CookieBridge, ImportFilePreProcessor, FilesystemProxy, ApplicationSearchProxy, AppStateProxy, GoogleDriveProxy, ElectronAmfService, GoogleAnalytics */
+
+/** @typedef {import('../../../preload/PreferencesProxy').PreferencesProxy} PreferencesProxy */
+/** @typedef {import('../../../preload/WindowProxy').WindowProxy} WindowManagerProxy */
+/** @typedef {import('../../../preload/ThemeManager').ThemeManager} ThemeManager */
+/** @typedef {import('../../../preload/EncryptionService').EncryptionService} EncryptionService */
+/** @typedef {import('../../../preload/WorkspaceManager').WorkspaceManager} WorkspaceManager */
+/** @typedef {import('../../../preload/ImportFilePreProcessor').ImportFilePreProcessor} ImportFilePreProcessor */
+/** @typedef {import('../../../preload/FilesystemProxy').FilesystemProxy} FilesystemProxy */
+/** @typedef {import('../../../preload/ApplicationSearchProxy').ApplicationSearchProxy} ApplicationSearchProxy */
+/** @typedef {import('../../../types').ArcAppInitOptions} ArcAppInitOptions */
+/** @typedef {import('lit-html').TemplateResult} TemplateResult */
+/** @typedef {import('@advanced-rest-client/electron-oauth2/renderer/OAuth2Handler').OAuth2Handler} OAuth2Handler */
+/** @typedef {import('@advanced-rest-client/arc-types').Config.ARCConfig} ARCConfig */
+/** @typedef {import('@advanced-rest-client/arc-types').ArcState.ARCState} ARCState */
+/** @typedef {import('@advanced-rest-client/arc-events').ARCRequestNavigationEvent} ARCRequestNavigationEvent */
+/** @typedef {import('@advanced-rest-client/arc-events').ARCProjectNavigationEvent} ARCProjectNavigationEvent */
+/** @typedef {import('@advanced-rest-client/arc-events').ARCRestApiNavigationEvent} ARCRestApiNavigationEvent */
+/** @typedef {import('@advanced-rest-client/arc-events').ARCMenuPopupEvent} ARCMenuPopupEvent */
+/** @typedef {import('@advanced-rest-client/arc-events').ARCNavigationEvent} ARCNavigationEvent */
+/** @typedef {import('@advanced-rest-client/arc-events').ARCExternalNavigationEvent} ARCExternalNavigationEvent */
+/** @typedef {import('@advanced-rest-client/arc-events').ConfigStateUpdateEvent} ConfigStateUpdateEvent */
+/** @typedef {import('@advanced-rest-client/arc-events').ArcImportInspectEvent} ArcImportInspectEvent */
+/** @typedef {import('@advanced-rest-client/arc-events').WorkspaceAppendRequestEvent} WorkspaceAppendRequestEvent */
+/** @typedef {import('@advanced-rest-client/arc-events').WorkspaceAppendExportEvent} WorkspaceAppendExportEvent */
+/** @typedef {import('@advanced-rest-client/arc-events').RestApiProcessFileEvent} RestApiProcessFileEvent */
+/** @typedef {import('@advanced-rest-client/arc-models').IndexableRequest} IndexableRequest */
+/** @typedef {import('@advanced-rest-client/arc-models').ARCEnvironmentStateSelectEvent} ARCEnvironmentStateSelectEvent */
+/** @typedef {import('../../../../web_modules/@advanced-rest-client/arc-request-ui').ArcRequestWorkspaceElement} ArcRequestWorkspaceElement */
+/** @typedef {import('../../../../web_modules/@advanced-rest-client/arc-menu').ArcMenuElement} ArcMenuElement */
+/** @typedef {import('../context-menu/interfaces').ExecuteOptions} ExecuteOptions */
+/** @typedef {import('@advanced-rest-client/arc-types').Authorization.OAuth2Authorization} OAuth2Authorization */
+/** @typedef {import('@advanced-rest-client/electron-amf-service/types').ApiParseResult} ApiParseResult */
+/** @typedef {import('@advanced-rest-client/exchange-search-panel/src/types').ExchangeAsset} ExchangeAsset */
+
+const unhandledRejectionHandler = Symbol('unhandledRejectionHandler');
+const headerTemplate = Symbol('headerTemplate');
+const pageTemplate = Symbol('pageTemplate');
+const workspaceTemplate = Symbol('workspaceTemplate');
+const navigationTemplate = Symbol('navigationTemplate');
+const navigateRequestHandler = Symbol('navigateRequestHandler');
+const navigateHandler = Symbol('navigateHandler');
+const navigateProjectHandler = Symbol('navigateProjectHandler');
+const navigateRestApiHandler = Symbol('navigateRestApiHandler');
+const popupMenuHandler = Symbol('popupMenuHandler');
+const mainBackHandler = Symbol('mainBackHandler');
+const historyPanelTemplate = Symbol('historyPanelTemplate');
+const savedPanelTemplate = Symbol('savedPanelTemplate');
+const clientCertScreenTemplate = Symbol('clientCertScreenTemplate');
+const commandHandler = Symbol('commandHandler');
+const requestActionHandler = Symbol('requestActionHandler');
+const configStateChangeHandler = Symbol('configStateChangeHandler');
+const systemThemeChangeHandler = Symbol('systemThemeChangeHandler');
+const popupMenuOpenedHandler = Symbol('popupMenuOpenedHandler');
+const popupMenuClosedHandler = Symbol('popupMenuClosedHandler');
+const environmentTemplate = Symbol('environmentTemplate');
+const environmentSelectorHandler = Symbol('environmentSelectorHandler');
+const environmentSelectorKeyHandler = Symbol('environmentSelectorKeyHandler');
+const dataImportScreenTemplate = Symbol('dataImportScreenTemplate');
+const dataExportScreenTemplate = Symbol('dataExportScreenTemplate');
+const cookieManagerScreenTemplate = Symbol('cookieManagerScreenTemplate');
+const settingsScreenTemplate = Symbol('settingsScreenTemplate');
+const fileImportHandler = Symbol('fileImportHandler');
+const importInspectorTemplate = Symbol('importInspectorTemplate');
+const dataInspectHandler = Symbol('dataInspectHandler');
+const inspectDataValue = Symbol('inspectDataValue');
+const importDataHandler = Symbol('importDataHandler');
+const notifyIndexer = Symbol('notifyIndexer');
+const workspaceAppendRequestHandler = Symbol('workspaceAppendRequestHandler');
+const workspaceAppendExportHandler = Symbol('workspaceAppendExportHandler');
+const environmentSelectedHandler = Symbol('environmentSelectedHandler');
+const navMinimizedHandler = Symbol('navMinimizedHandler');
+const navResizeMousedown = Symbol('navResizeMousedown');
+const resizeMouseUp = Symbol('resizeMouseUp');
+const resizeMouseMove = Symbol('resizeMouseMove');
+const isResizing = Symbol('isResizing');
+const mainNavigateHandler = Symbol('mainNavigateHandler');
+const variablesEnabledValue = Symbol('variablesEnabledValue');
+const systemVariablesEnabledValue = Symbol('systemVariablesEnabledValue');
+const requestDetailTemplate = Symbol('requestDetailTemplate');
+const requestMetaTemplate = Symbol('requestMetaTemplate');
+const sheetClosedHandler = Symbol('sheetClosedHandler');
+const metaRequestHandler = Symbol('metaRequestHandler');
+const requestMetaCloseHandler = Symbol('requestMetaCloseHandler');
+const externalNavigationHandler = Symbol('externalNavigationHandler');
+const contextCommandHandler = Symbol('contextCommandHandler');
+const hostRulesTemplate = Symbol('hostRulesTemplate');
+const processApplicationState = Symbol('processApplicationState');
+const drivePickHandler = Symbol('drivePickHandler');
+const processApiFileHandler = Symbol('processApiFileHandler');
+const arcNavigationTemplate = Symbol('arcNavigationTemplate');
+const exchangeSearchTemplate = Symbol('exchangeSearchTemplate');
+const exchangeSelectionHandler = Symbol('exchangeSelectionHandler');
+
+/**
+ * A routes that does not go through the router and should not be remembered in the history.
+ */
+const HiddenRoutes = ['data-inspect'];
+
+export class AdvancedRestClientApplication extends ApplicationPage {
+ /**
+ * @returns {OAuth2Authorization}
+ */
+ get oauthConfig() {
+ return {
+ clientId: '1076318174169-u4a5d3j2v0tbie1jnjgsluqk1ti7ged3.apps.googleusercontent.com',
+ authorizationUri: 'https://accounts.google.com/o/oauth2/v2/auth',
+ redirectUri: 'https://auth.advancedrestclient.com/oauth2',
+ scopes: [
+ 'https://www.googleapis.com/auth/drive.file',
+ 'https://www.googleapis.com/auth/drive.install',
+ ],
+ }
+ }
+
+ static get routes() {
+ return [
+ {
+ name: 'workspace',
+ pattern: 'workspace/'
+ },
+ {
+ name: 'rest-projects',
+ pattern: 'rest-projects'
+ },
+ {
+ name: 'exchange-search',
+ pattern: 'exchange-search'
+ },
+ {
+ name: 'history',
+ pattern: 'history'
+ },
+ {
+ name: 'saved',
+ pattern: 'saved'
+ },
+ {
+ name: 'client-certificates',
+ pattern: 'client-certificates'
+ },
+ {
+ name: 'data-import',
+ pattern: 'data-import'
+ },
+ {
+ name: 'data-export',
+ pattern: 'data-export'
+ },
+ {
+ name: 'cookie-manager',
+ pattern: 'cookie-manager'
+ },
+ {
+ name: 'settings',
+ pattern: 'settings'
+ },
+ {
+ name: 'hosts',
+ pattern: 'hosts'
+ },
+ {
+ name: 'project',
+ pattern: 'project/(?[^/]*)/(?.*)'
+ },
+ // {
+ // name: 'model',
+ // pattern: 'project/(?[^/]*)/module(?/.*)/model/(?.*)'
+ // }, {
+ // name: 'module',
+ // pattern: 'project/(?[^/]*)/module(?/.*)'
+ // },
+ {
+ name: 'workspace',
+ pattern: '*'
+ }];
+ }
+
+ /**
+ * @type {ArcRequestWorkspaceElement}
+ */
+ #workspace = undefined;
+
+ #contextMenu = new ContextMenu(document.body);
+
+ stateProxy = new AppStateProxy();
+
+ settings = new PreferencesProxy();
+
+ oauth2Proxy = new OAuth2Handler();
+
+ windowProxy = new WindowManagerProxy();
+
+ themeProxy = new ThemeManager();
+
+ encryption = new EncryptionService();
+
+ workspace = new WorkspaceManager();
+
+ cookieBridge = new CookieBridge();
+
+ fs = new FilesystemProxy();
+
+ search = new ApplicationSearchProxy();
+
+ requestFactory = new Request();
+
+ gDrive = new GoogleDriveProxy();
+
+ /**
+ * Responsible for processing API data and producing AMF model consumed by the API Console.
+ */
+ apiParser = new ElectronAmfService();
+
+ ga = new GoogleAnalytics();
+
+ /**
+ * @returns {ArcRequestWorkspaceElement}
+ */
+ get workspaceElement() {
+ if (!this.#workspace) {
+ this.#workspace = document.querySelector('arc-request-workspace');
+ }
+ return this.#workspace;
+ }
+
+ get variablesEnabled() {
+ return this[variablesEnabledValue];
+ }
+
+ set variablesEnabled(value) {
+ const old = this[variablesEnabledValue];
+ if (old === value) {
+ return;
+ }
+ this[variablesEnabledValue] = value;
+ this.requestFactory.evaluateVariables = value;
+ this.render();
+ }
+
+ get systemVariablesEnabled() {
+ return this[systemVariablesEnabledValue];
+ }
+
+ set systemVariablesEnabled(value) {
+ const old = this[systemVariablesEnabledValue];
+ if (old === value) {
+ return;
+ }
+ this[systemVariablesEnabledValue] = value;
+ const model = document.body.querySelector('variables-model');
+ if (value) {
+ model.systemVariables = process.env;
+ } else {
+ model.systemVariables = undefined;
+ }
+ this.render();
+ }
+
+ constructor() {
+ super();
+
+ this.initObservableProperties(
+ 'route', 'initializing', 'loadingStatus',
+ 'compatibility', 'oauth2RedirectUri',
+ 'navigationDetached', 'updateState', 'hasAppUpdate',
+ 'popupMenuEnabled', 'draggableEnabled', 'historyEnabled',
+ 'listType', 'detailedSearch', 'currentEnvironment',
+ 'workspaceSendButton', 'workspaceProgressInfo', 'workspaceBodyEditor', 'workspaceAutoEncode',
+ 'navigationWidth',
+ 'requestDetailsOpened', 'requestMetaOpened', 'metaRequestId', 'metaRequestType',
+ );
+
+ /**
+ * @type {boolean} Whether the project is being restored from the metadata store.
+ */
+ this.initializing = true;
+
+ /**
+ * @type {ARCConfig}
+ */
+ this.config = undefined;
+
+ /**
+ * @type {string} A loading state information.
+ */
+ this.loadingStatus = 'Initializing application...';
+ this.logger = logger;
+
+
+ window.onunhandledrejection = this[unhandledRejectionHandler].bind(this);
+
+ // todo: do the below when the application is already initialized.
+
+ // this[navigationHandler] = this[navigationHandler].bind(this);
+
+ // window.addEventListener(ModelingEventTypes.State.Navigation.change, this[navigationHandler]);
+
+ this.oauth2RedirectUri = 'http://auth.advancedrestclient.com/arc.html';
+ this.compatibility = false;
+
+ /**
+ * A list of detached menu panels.
+ * @type {string[]}
+ */
+ this.menuPopup = [];
+ /**
+ * When set the navigation element is detached from the main application window.
+ */
+ this.navigationDetached = false;
+
+ /**
+ * Whether application update is available.
+ */
+ this.hasAppUpdate = false;
+ /**
+ * The current state of checking for update.
+ * @type {string}
+ */
+ this.updateState = undefined;
+
+ /**
+ * Whether the application menu can be detached to a new window.
+ */
+ this.popupMenuEnabled = true;
+ /**
+ * Whether the application support request object drag and drop
+ */
+ this.draggableEnabled = true;
+
+ /**
+ * Whether the requests history is enabled.
+ */
+ this.historyEnabled = true;
+
+ /**
+ * The current setting for the list types view.
+ */
+ this.listType = 'default';
+
+ /**
+ * Whether the history / saved search should perform slower but more detailed search
+ */
+ this.detailedSearch = false;
+
+ /**
+ * The name of the currently selected environment. Null for the default.
+ */
+ this.currentEnvironment = null;
+
+ /**
+ * Whether the application should process system variables.
+ */
+ this.systemVariablesEnabled = true;
+ /**
+ * Enables variables processor.
+ */
+ this[variablesEnabledValue] = true;
+
+ this.workspaceSendButton = true;
+ this.workspaceProgressInfo = true;
+ this.workspaceBodyEditor = 'Monaco';
+ this.workspaceAutoEncode = false;
+
+
+ this.requestDetailsOpened = false;
+ this.requestMetaOpened = false;
+ this.metaRequestId = undefined;
+ this.metaRequestType = undefined;
+ }
+
+ async initialize() {
+ await this.ga.initialize();
+ this.listen();
+ this.windowProxy.initContextMenu();
+ const init = this.collectInitOptions();
+ this.initOptions = init;
+
+ let cnf = {};
+ try {
+ cnf = await this.settings.read();
+ } catch (e) {
+ this.reportCriticalError(e);
+ throw e;
+ }
+ this.config = cnf;
+ this.setConfigVariables(cnf);
+
+ await this.loadTheme(init.darkMode);
+ this.workspace.id = init.workspaceId;
+ let state = /** @type ARCState */(null);
+ try {
+ state = await this.stateProxy.read();
+ } catch (e) {
+ state = {
+ kind: 'ARC#AppState',
+ };
+ }
+ this[processApplicationState](state);
+
+ await this.afterInitialization();
+ await this.loadMonaco();
+ this.initializing = false;
+ }
+
+ /**
+ * Sets local variables from the config object
+ * @param {ARCConfig} cnf
+ */
+ setConfigVariables(cnf) {
+ if (!!cnf.request || (cnf.request && typeof cnf.request.ignoreSessionCookies === 'boolean' && cnf.request.ignoreSessionCookies)) {
+ ModulesRegistry.register(ModulesRegistry.request, 'arc/request/cookies', RequestCookies.processRequestCookies, ['events']);
+ ModulesRegistry.register(ModulesRegistry.response, 'arc/response/cookies', RequestCookies.processResponseCookies, ['events']);
+ }
+
+ if (cnf.history) {
+ if (typeof cnf.history.enabled === 'boolean') {
+ this.historyEnabled = cnf.history.enabled;
+ }
+
+ if (typeof cnf.history.fastSearch === 'boolean') {
+ this.detailedSearch = !cnf.history.fastSearch;
+ }
+ }
+
+ if (cnf.request) {
+ if (typeof cnf.request.timeout === 'number') {
+ this.requestFactory.requestTimeout = cnf.request.timeout;
+ }
+ if (typeof cnf.request.followRedirects === 'boolean') {
+ this.requestFactory.followRedirects = cnf.request.followRedirects;
+ }
+ if (typeof cnf.request.defaultHeaders === 'boolean') {
+ this.requestFactory.defaultHeaders = cnf.request.defaultHeaders;
+ }
+ if (typeof cnf.request.validateCertificates === 'boolean') {
+ this.requestFactory.validateCertificates = cnf.request.validateCertificates;
+ }
+ if (typeof cnf.request.nativeTransport === 'boolean') {
+ this.requestFactory.nativeTransport = cnf.request.nativeTransport;
+ }
+ if (typeof cnf.request.useSystemVariables === 'boolean') {
+ this.systemVariablesEnabled = cnf.request.useSystemVariables;
+ }
+ if (typeof cnf.request.useAppVariables === 'boolean') {
+ this.variablesEnabled = cnf.request.useAppVariables;
+ }
+ if (cnf.request.oauth2redirectUri) {
+ this.oauth2RedirectUri = cnf.request.oauth2redirectUri;
+ }
+ }
+
+ if (cnf.view) {
+ if (typeof cnf.view.fontSize === 'number') {
+ document.body.style.fontSize = `${cnf.view.fontSize}px`;
+ }
+ if (typeof cnf.view.popupMenu === 'boolean') {
+ this.popupMenuEnabled = cnf.view.popupMenu;
+ }
+ if (typeof cnf.view.draggableEnabled === 'boolean') {
+ this.draggableEnabled = cnf.view.draggableEnabled;
+ }
+ if (typeof cnf.view.listType === 'string') {
+ this.listType = cnf.view.listType;
+ }
+ }
+ if (cnf.requestEditor) {
+ if (typeof cnf.requestEditor.sendButton === 'boolean') {
+ this.workspaceSendButton = cnf.requestEditor.sendButton;
+ }
+ if (typeof cnf.requestEditor.progressInfo === 'boolean') {
+ this.workspaceProgressInfo = cnf.requestEditor.progressInfo;
+ }
+ if (typeof cnf.requestEditor.bodyEditor === 'string') {
+ this.workspaceBodyEditor = cnf.requestEditor.bodyEditor;
+ }
+ if (typeof cnf.requestEditor.autoEncode === 'boolean') {
+ this.workspaceAutoEncode = cnf.requestEditor.autoEncode;
+ }
+ }
+ }
+
+ /**
+ * @param {ARCState} state
+ */
+ [processApplicationState](state) {
+ if (state.environment) {
+ if (state.environment.variablesEnvironment) {
+ // this.currentEnvironment = state.environment.variablesEnvironment;
+ ArcModelEvents.Environment.select(document.body, state.environment.variablesEnvironment);
+ }
+ }
+ }
+
+ listen() {
+ this.settings.observe();
+ this.oauth2Proxy.listen();
+ this.themeProxy.listen();
+ this.encryption.listen();
+ this.workspace.listen();
+ this.cookieBridge.listen();
+ this.fs.listen();
+ this.search.listen();
+ this.requestFactory.listen();
+ this.gDrive.listen();
+ this.#contextMenu.connect();
+ this.#contextMenu.registerCommands(ContextMenuCommands);
+ this.#contextMenu.registerCallback(this[contextCommandHandler].bind(this));
+
+ window.addEventListener(ArcNavigationEventTypes.navigateRequest, this[navigateRequestHandler].bind(this));
+ window.addEventListener(ArcNavigationEventTypes.navigate, this[navigateHandler].bind(this));
+ window.addEventListener(ArcNavigationEventTypes.navigateProject, this[navigateProjectHandler].bind(this));
+ window.addEventListener(ArcNavigationEventTypes.navigateRestApi, this[navigateRestApiHandler].bind(this));
+ window.addEventListener(ArcNavigationEventTypes.popupMenu, this[popupMenuHandler].bind(this));
+ window.addEventListener(ArcNavigationEventTypes.navigateExternal, this[externalNavigationHandler].bind(this));
+ window.addEventListener(WorkspaceEventTypes.appendRequest, this[workspaceAppendRequestHandler].bind(this));
+ window.addEventListener(WorkspaceEventTypes.appendExport, this[workspaceAppendExportHandler].bind(this));
+ window.addEventListener(ConfigEventTypes.State.update, this[configStateChangeHandler].bind(this));
+ window.addEventListener(DataImportEventTypes.inspect, this[dataInspectHandler].bind(this));
+ window.addEventListener(ArcModelEventTypes.Environment.State.select, this[environmentSelectedHandler].bind(this));
+ window.addEventListener(RestApiEventTypes.processFile, this[processApiFileHandler].bind(this));
+ window.addEventListener('mousemove', this[resizeMouseMove].bind(this));
+ window.addEventListener('mouseup', this[resizeMouseUp].bind(this));
+ window.addEventListener('themeactivated', (e) => {
+ // @ts-ignore
+ this.compatibility = e.detail === ThemeManager.anypointTheme;
+ });
+
+ ipc.on('command', this[commandHandler].bind(this));
+ ipc.on('request-action', this[requestActionHandler].bind(this));
+ ipc.on('system-theme-changed', this[systemThemeChangeHandler].bind(this));
+
+ ipc.on('popup-app-menu-opened', this[popupMenuOpenedHandler].bind(this));
+ ipc.on('popup-app-menu-closed', this[popupMenuClosedHandler].bind(this));
+ ipc.on('app-navigate', this[mainNavigateHandler].bind(this));
+ ipc.on('google-drive-file-pick', this[drivePickHandler].bind(this));
+
+ ipc.on('checking-for-update', () => {
+ this.logger.info('Checking for application update');
+ this.updateState = 'checking-for-update';
+ });
+ ipc.on('update-available', () => {
+ this.logger.info('Application update available.');
+ this.updateState = 'update-available';
+ });
+ ipc.on('update-not-available', () => {
+ this.logger.info('Application update not available.');
+ this.updateState = 'update-not-available';
+ });
+ ipc.on('autoupdate-error', (e, error) => {
+ this.updateState = 'autoupdate-error';
+ this.logger.error(error);
+ });
+ ipc.on('download-progress', (e, progressObj) => {
+ this.updateState = 'download-progress';
+ this.logger.info(progressObj);
+ });
+ ipc.on('update-downloaded', () => {
+ this.logger.info('Application update downloaded and ready to install.');
+ this.updateState = 'update-downloaded';
+ this.hasAppUpdate = true;
+ });
+ }
+
+ /**
+ * @returns {ArcAppInitOptions} The init options of this browser process.
+ */
+ collectInitOptions() {
+ const search = new URLSearchParams(window.location.search);
+ const result = /** @type ArcAppInitOptions */ ({});
+ const dt = search.get('darkMode');
+ if (dt) {
+ result.darkMode = dt === 'true';
+ }
+ const wId = search.get('workspaceId');
+ if (wId) {
+ result.workspaceId = wId;
+ }
+ return result;
+ }
+
+ /**
+ * Loads the current theme.
+ * @param {boolean} isDarkMode
+ */
+ async loadTheme(isDarkMode) {
+ const settings = await this.themeProxy.readState();
+ let theme;
+ if (isDarkMode && settings.systemPreferred) {
+ theme = ThemeManager.darkTheme;
+ } else {
+ const info = await this.themeProxy.readActiveThemeInfo();
+ theme = info && info.name;
+ }
+ try {
+ await this.themeProxy.loadTheme(theme);
+ } catch (e) {
+ this.logger.error(e);
+ }
+ }
+
+ /**
+ * Tasks to be performed after the application is initialized.
+ */
+ async afterInitialization() {
+ window.onpopstate = () => {
+ this.onRoute();
+ }
+ requestAnimationFrame(() => this.onRoute());
+ }
+
+ /**
+ * @param {PromiseRejectionEvent} e
+ */
+ [unhandledRejectionHandler](e) {
+ /* eslint-disable-next-line no-console */
+ console.error(e);
+ this.reportCriticalError(e.reason);
+ }
+
+ async loadMonaco() {
+ const base = `../../../../node_modules/monaco-editor/`;
+ MonacoLoader.createEnvironment(base);
+ await MonacoLoader.loadMonaco(base);
+ await MonacoLoader.monacoReady();
+ }
+
+ /**
+ * Called when route change
+ */
+ onRoute() {
+ const url = new URL(window.location.href);
+ const path = url.hash.replace('#', '');
+ // @ts-ignore
+ const { routes } = this.constructor;
+ const result = findRoute(routes, path);
+ if (!result) {
+ return;
+ }
+ const { name } = result.route;
+ this.route = name;
+ this.ga.screenView(name);
+ }
+
+ /**
+ * Closes a tab in the request workspace at the specified position
+ * @param {number} index
+ */
+ closeWorkspaceTab(index) {
+ this.workspaceElement.removeRequest(index);
+ }
+
+ /**
+ * Closes all tabs in the request workspace
+ */
+ closeAllWorkspaceTabs() {
+ this.workspaceElement.clear();
+ }
+
+ /**
+ * Closes all tabs in the request workspace except for the given index.
+ * @param {number} index
+ */
+ closeOtherWorkspaceTabs(index) {
+ // this.workspaceElement.removeRequest();
+ }
+
+ /**
+ * Duplicates a tab at the given index.
+ * @param {number} index
+ */
+ duplicateWorkspaceTab(index) {
+ this.workspaceElement.duplicateTab(index);
+ }
+
+ /**
+ * @param {ARCRequestNavigationEvent} e
+ */
+ [navigateRequestHandler](e) {
+ const { requestId, requestType, action } = e;
+ if (action === 'open') {
+ this.workspaceElement.addByRequestId(requestType, requestId);
+ if (this.route !== 'workspace') {
+ navigate('workspace');
+ }
+ return;
+ }
+ if (action === 'detail') {
+ this.requestMetaOpened = false;
+ this.requestDetailsOpened = true;
+ this.metaRequestId = requestId;
+ this.metaRequestType = requestType;
+ return;
+ }
+ if (action === 'edit') {
+ this.requestDetailsOpened = false;
+ this.requestMetaOpened = true;
+ this.metaRequestId = requestId;
+ this.metaRequestType = requestType;
+ }
+ }
+
+ /**
+ * @param {ARCProjectNavigationEvent} e
+ */
+ [navigateProjectHandler](e) {
+ const { id, action, route } = e;
+ if (route !== 'project') {
+ return;
+ }
+ if (action === ProjectActions.addWorkspace) {
+ this.workspaceElement.appendByProjectId(id);
+ } else if (action === ProjectActions.replaceWorkspace) {
+ this.workspaceElement.replaceByProjectId(id);
+ } else if (action === 'open') {
+ navigate(route, id, action);
+ } else {
+ // eslint-disable-next-line no-console
+ console.warn('Unhandled project event', id, action, route);
+ }
+ }
+
+ /**
+ * @param {ARCRestApiNavigationEvent} e
+ */
+ [navigateRestApiHandler](e) {
+ const { api, version } = e;
+ navigatePage('api-console.html', 'open', 'db', api, version);
+ }
+
+ /**
+ * @param {ARCMenuPopupEvent} e
+ */
+ [popupMenuHandler](e) {
+ const { menu } = e;
+ const element = document.querySelector('arc-menu');
+ const rect = element.getBoundingClientRect();
+ const sizing = {
+ height: rect.height,
+ width: rect.width
+ };
+ ipc.send('popup-app-menu', menu, sizing);
+ }
+
+ /**
+ * @param {ARCNavigationEvent} e
+ */
+ [navigateHandler](e) {
+ const allowed = [
+ 'rest-projects',
+ 'exchange-search',
+ 'history',
+ 'saved',
+ ];
+ if (e.route === 'client-certificate-import') {
+ this.importingCertificate = true;
+ } else if (allowed.includes(e.route)) {
+ navigate(e.route);
+ } else {
+ // eslint-disable-next-line no-console
+ console.warn('Unhandled navigate event', e);
+ }
+ }
+
+ /**
+ * @param {ARCExternalNavigationEvent} e
+ */
+ [externalNavigationHandler](e) {
+ const { url, detail } = e;
+ const { purpose } = detail;
+ ipc.send('open-web-url', url, purpose);
+ }
+
+ /**
+ * A handler for the main toolbar arrow back click.
+ * Always navigates to the workspace.
+ */
+ [mainBackHandler]() {
+ navigate('workspace');
+ }
+
+ /**
+ * Handler for application command.
+ *
+ * @param {EventEmitter} e Node's event
+ * @param {string} action
+ * @param {...any} args
+ */
+ [commandHandler](e, action, ...args) {
+ switch (action) {
+ case 'open-saved': navigate('saved'); break;
+ case 'open-history': navigate('history'); break;
+ case 'open-cookie-manager': navigate('cookie-manager'); break;
+ case 'open-hosts-editor': navigate('hosts'); break;
+ case 'open-themes': navigate('themes'); break;
+ case 'open-client-certificates': navigate('client-certificates'); break;
+ case 'open-requests-workspace': navigate('workspace'); break;
+ case 'open-web-socket': this.workspaceElement.addWsRequest(); break;
+ case 'process-external-file': this.processExternalFile(args[0]); break;
+ case 'import-data': navigate('data-import'); break;
+ case 'export-data': navigate('data-export'); break;
+ case 'show-settings': navigate('settings'); break;
+ case 'popup-menu': this.navigationDetached = !this.navigationDetached; break;
+ case 'export-workspace': this.exportWorkspace(); break;
+ case 'login-external-webservice': this.workspaceElement.openWebUrlInput(); break;
+ case 'open-workspace-details': this.workspaceElement.openWorkspaceDetails(); break;
+ default:
+ this.logger.warn(`Unhandled IO command ${action}`);
+ }
+ }
+
+ /**
+ * Handles action performed in main thread (menu action) related to a request.
+ *
+ * @param {EventEmitter} e
+ * @param {string} action Action name to perform.
+ * @param {...any} args
+ */
+ [requestActionHandler](e, action, ...args) {
+ if (this.route !== 'workspace') {
+ navigate('workspace');
+ }
+ switch (action) {
+ case 'save':
+ this.workspaceElement.saveOpened();
+ break;
+ case 'save-as':
+ this.workspaceElement.saveAsOpened();
+ break;
+ case 'new-http-tab':
+ this.workspaceElement.addHttpRequest();
+ break;
+ case 'new-websocket-tab':
+ this.workspaceElement.addWsRequest();
+ break;
+ case 'send-current':
+ this.workspaceElement.sendCurrent();
+ break;
+ case 'close-tab':
+ this.workspaceElement.closeActiveTab();
+ break;
+ default:
+ this.logger.warn(`Unhandled IO request command ${action}`);
+ }
+ }
+
+ /**
+ * @param {ExecuteOptions} args
+ */
+ [contextCommandHandler](args) {
+ const { command } = args;
+ switch (command) {
+ case 'close-tab': this.workspaceElement.removeRequest(getTabClickIndex(args.target)); break;
+ case 'close-other-tabs': this.workspaceElement.closeAllTabs(getTabClickIndex(args.target)); break;
+ case 'close-all-tabs': this.workspaceElement.closeAllTabs(); break;
+ case 'duplicate-tab': this.workspaceElement.duplicateTab(getTabClickIndex(args.target)); break;
+ default:
+ }
+ }
+
+ /**
+ * @param {ConfigStateUpdateEvent} e
+ */
+ [configStateChangeHandler](e) {
+ const { key, value } = e.detail;
+ if (key === 'request.ignoreSessionCookies') {
+ if (value) {
+ ModulesRegistry.register(ModulesRegistry.request, 'arc/request/cookies', RequestCookies.processRequestCookies, ['events']);
+ ModulesRegistry.register(ModulesRegistry.response, 'arc/response/cookies', RequestCookies.processResponseCookies, ['events']);
+ } else {
+ ModulesRegistry.unregister(ModulesRegistry.request, 'arc/request/cookies');
+ ModulesRegistry.unregister(ModulesRegistry.response, 'arc/response/cookies');
+ }
+ } else if (key === 'view.popupMenu') {
+ this.popupMenuEnabled = value;
+ } else if (key === 'view.draggableEnabled') {
+ this.draggableEnabled = value;
+ } else if (key === 'request.timeout') {
+ this.requestFactory.requestTimeout = value;
+ } else if (key === 'request.followRedirects') {
+ this.requestFactory.followRedirects = value;
+ } else if (key === 'request.defaultHeaders') {
+ this.requestFactory.defaultHeaders = value;
+ } else if (key === 'request.validateCertificates') {
+ this.requestFactory.validateCertificates = value;
+ } else if (key === 'request.nativeTransport') {
+ this.requestFactory.nativeTransport = value;
+ } else if (key === 'request.oauth2redirectUri') {
+ this.oauth2RedirectUri = value;
+ } else if (key === 'view.listType') {
+ this.listType = value;
+ } else if (key === 'history.enabled') {
+ this.historyEnabled = value;
+ } else if (key === 'history.fastSearch') {
+ this.detailedSearch = !value;
+ } else if (key === 'request.useSystemVariables') {
+ this.systemVariablesEnabled = value;
+ } else if (key === 'request.useAppVariables') {
+ this.variablesEnabled = value;
+ } else if (key === 'requestEditor.sendButton') {
+ this.workspaceSendButton = value;
+ } else if (key === 'requestEditor.progressInfo') {
+ this.workspaceProgressInfo = value;
+ } else if (key === 'requestEditor.bodyEditor') {
+ this.workspaceBodyEditor = value;
+ } else if (key === 'requestEditor.autoEncode') {
+ this.workspaceAutoEncode = value;
+ } else if (key === 'view.fontSize') {
+ document.body.style.fontSize = `${value}px`;
+ }
+ }
+
+ /**
+ * Handler for system theme change event dispatched by the IO thread.
+ * Updates theme depending on current setting.
+ *
+ * @param {any} e
+ * @param {Boolean} isDarkMode true when Electron detected dark mode
+ * @returns {Promise}
+ */
+ async [systemThemeChangeHandler](e, isDarkMode) {
+ const theme = isDarkMode ?
+ '@advanced-rest-client/arc-electron-dark-theme' :
+ '@advanced-rest-client/arc-electron-default-theme';
+ this.compatibility = false;
+ try {
+ await this.themeProxy.loadTheme(theme);
+ } catch (err) {
+ this.logger.error(err);
+ }
+ }
+
+ /**
+ * @param {string} filePath
+ */
+ async processExternalFile(filePath) {
+ const factory = new ImportFilePreProcessor(filePath);
+ try {
+ await factory.prepare();
+ const isApiFile = await factory.isApiFile();
+ if (isApiFile) {
+ const result = await this.apiParser.processBuffer(factory.buffer);
+ this.apiConsoleFromParser(result);
+ return;
+ }
+ const contents = factory.readContents();
+ await this.processExternalData(contents);
+ } catch (cause) {
+ this.logger.error(cause);
+ this.reportCriticalError(cause);
+ }
+ }
+
+ /**
+ * Process file contents after importing it to the application.
+ * @param {string} contents
+ */
+ async processExternalData(contents) {
+ const decrypted = await this.decryptIfNeeded(contents);
+ const data = JSON.parse(decrypted);
+ if (data.swagger) {
+ const result = await this.apiParser.processBuffer(Buffer.from(contents));
+ this.apiConsoleFromParser(result);
+ return;
+ }
+ const processor = new ImportNormalize();
+ const normalized = await processor.normalize(data);
+
+ if (isSingleRequest(normalized)) {
+ const insert = Array.isArray(normalized.requests) ? normalized.requests[0] : data;
+ WorkspaceEvents.appendRequest(document.body, insert);
+ return;
+ }
+
+ if (normalized.loadToWorkspace) {
+ WorkspaceEvents.appendExport(document.body, normalized);
+ return;
+ }
+ this.route = 'data-inspect';
+ this[inspectDataValue] = normalized;
+ this.render();
+ }
+
+ /**
+ * @param {ApiParseResult} result
+ */
+ async apiConsoleFromParser(result) {
+ const id = await this.fs.storeApicModelTmp(result);
+ navigatePage('api-console.html', 'open', 'file', id);
+ }
+
+ /**
+ * Processes incoming data and if encryption is detected then id processes
+ * the file for decryption.
+ *
+ * @param {string} content File content
+ * @return {Promise} The content of the file.
+ */
+ async decryptIfNeeded(content) {
+ const headerIndex = content.indexOf('\n');
+ const header = content.substr(0, headerIndex).trim();
+ if (header === 'aes') {
+ const data = content.substr(headerIndex + 1);
+ // eslint-disable-next-line no-param-reassign
+ content = await this.encryption.decode('aes', data);
+ }
+ return content;
+ }
+
+ [popupMenuOpenedHandler](e, type) {
+ this.menuToggleOption(type, true);
+ }
+
+ [popupMenuClosedHandler](e, type) {
+ this.menuToggleOption(type, false);
+ }
+
+ /**
+ * @param {string} type The menu name
+ * @param {boolean} value Whether the menu is rendered in an external window.
+ */
+ menuToggleOption(type, value) {
+ if (type === '*') {
+ this.navigationDetached = value;
+ return;
+ }
+ const { menuPopup } = this;
+ if (value && !menuPopup.includes(type)) {
+ menuPopup.push(type);
+ this.render();
+ } else if (!value && menuPopup.includes(type)) {
+ const index = menuPopup.indexOf(type);
+ menuPopup.splice(index, 1);
+ this.render();
+ }
+ }
+
+ /**
+ * @param {*} e
+ * @param {string} type
+ * @param {string[]} args
+ */
+ [mainNavigateHandler](e, type, args) {
+ switch (type) {
+ // @ts-ignore
+ case 'request': ArcNavigationEvents.navigateRequest(document.body, ...args); break;
+ // @ts-ignore
+ case 'project': ArcNavigationEvents.navigateProject(document.body, ...args); break;
+ // @ts-ignore
+ case 'navigate': ArcNavigationEvents.navigate(document.body, ...args); break;
+ default:
+ }
+ }
+
+ /**
+ * Calls ARC app to serialize workspace data and exports it to a file.
+ * @return {Promise}
+ */
+ async exportWorkspace() {
+ const id = await this.workspace.changeStoreLocation();
+ if (!id) {
+ return;
+ }
+ this.initOptions.workspaceId = id;
+ this.render();
+ this.workspaceElement.store();
+ }
+
+ /**
+ * @param {Event} e
+ */
+ [environmentSelectorHandler](e) {
+ const overlay = document.querySelector('variables-overlay');
+ overlay.positionTarget = /** @type HTMLElement */ (e.target);
+ overlay.opened = true;
+ }
+
+ /**
+ * @param {KeyboardEvent} e
+ */
+ [environmentSelectorKeyHandler](e) {
+ if (['Space', 'Enter', 'ArrowDown'].includes(e.code)) {
+ this[environmentSelectorHandler](e);
+ }
+ }
+
+ async [fileImportHandler]() {
+ const result = await this.fs.pickFile();
+ if (result.canceled) {
+ return;
+ }
+ const [file] = result.filePaths;
+ this.processExternalFile(file);
+ }
+
+ /**
+ * @param {ArcImportInspectEvent} e
+ */
+ [dataInspectHandler](e) {
+ const { data } = e.detail;
+ this.route = 'data-inspect';
+ this[inspectDataValue] = data;
+ this.render();
+ }
+
+ /**
+ * @param {CustomEvent} e
+ */
+ async [importDataHandler](e) {
+ const { detail } = e;
+ const store = new ImportFactory();
+ const result = await store.importData(detail);
+
+ const { savedIndexes, historyIndexes } = store;
+ this[notifyIndexer](savedIndexes, historyIndexes);
+ ImportEvents.dataImported(this);
+ this[mainBackHandler]();
+ }
+
+ /**
+ * Dispatches `url-index-update` event handled by `arc-models/url-indexer`.
+ * It will index URL data for search function.
+ * @param {IndexableRequest[]} saved List of saved requests indexes
+ * @param {IndexableRequest[]} history List of history requests indexes
+ */
+ [notifyIndexer](saved, history) {
+ let indexes = [];
+ if (saved) {
+ indexes = indexes.concat(saved);
+ }
+ if (history) {
+ indexes = indexes.concat(history);
+ }
+ if (!indexes.length) {
+ return;
+ }
+ ArcModelEvents.UrlIndexer.update(this, indexes);
+ }
+
+ /**
+ * @param {WorkspaceAppendRequestEvent} e
+ */
+ [workspaceAppendRequestHandler](e) {
+ const { request } = e.detail;
+ this.workspaceElement.add(request);
+ navigate('workspace');
+ }
+
+ /**
+ * @param {WorkspaceAppendExportEvent} e
+ */
+ [workspaceAppendExportHandler](e) {
+ const { requests, history } = e.detail.data;
+ const { workspaceElement } = this;
+ (requests || []).forEach((request) => workspaceElement.add(request));
+ (history || []).forEach((request) => workspaceElement.add(request));
+ navigate('workspace');
+ }
+
+ /**
+ * @param {ARCEnvironmentStateSelectEvent} e
+ */
+ [environmentSelectedHandler](e) {
+ const { environment } = e.detail;
+ if (environment) {
+ this.currentEnvironment = environment.name;
+ this.stateProxy.update('environment.variablesEnvironment', environment._id);
+ } else {
+ this.currentEnvironment = null;
+ this.stateProxy.update('environment.variablesEnvironment', null);
+ }
+ }
+
+ /**
+ * @param {Event} e
+ */
+ [navMinimizedHandler](e) {
+ const menu = /** @type ArcMenuElement */ (e.target);
+ if (menu.minimized) {
+ menu.parentElement.classList.add('minimized');
+ } else {
+ menu.parentElement.classList.remove('minimized');
+ }
+ }
+
+ /**
+ * @param {MouseEvent} e
+ */
+ [navResizeMousedown](e) {
+ this[isResizing] = true;
+ e.preventDefault();
+ }
+
+ /**
+ * @param {MouseEvent} e
+ */
+ [resizeMouseUp](e) {
+ if (!this[isResizing]) {
+ return;
+ }
+ this[isResizing] = false;
+ e.preventDefault();
+ }
+
+ /**
+ * @param {MouseEvent} e
+ */
+ [resizeMouseMove](e) {
+ if (!this[isResizing]) {
+ return;
+ }
+ const { pageX } = e;
+ if (pageX < 100) {
+ return;
+ }
+ if (pageX > window.innerWidth - 100) {
+ return;
+ }
+ this.navigationWidth = pageX;
+ }
+
+ [metaRequestHandler]() {
+ this.requestMetaOpened = true;
+ this.requestDetailsOpened = false;
+ }
+
+ [requestMetaCloseHandler]() {
+ this.requestMetaOpened = false;
+ }
+
+ [sheetClosedHandler](e) {
+ const prop = e.target.dataset.openProperty;
+ this[prop] = e.detail.value;
+ }
+
+ /**
+ * @param {Electron.IpcRendererEvent} e
+ * @param {string} fileId
+ */
+ async [drivePickHandler](e, fileId) {
+ try {
+ const result = await this.gDrive.getFile(fileId);
+ await this.processExternalData(result);
+ } catch (cause) {
+ this.logger.error(cause);
+ this.reportCriticalError(cause);
+ }
+ }
+
+ /**
+ * @param {RestApiProcessFileEvent} e
+ */
+ async [processApiFileHandler](e) {
+ const { file } = e;
+ const result = await this.apiParser.processApiFile(file);
+ this.apiConsoleFromParser(result);
+ }
+
+ /**
+ * @param {CustomEvent} e
+ */
+ async [exchangeSelectionHandler](e) {
+ const asset = /** @type ExchangeAsset */ (e.detail);
+ let file;
+ const types = ['fat-raml', 'raml', 'oas'];
+ for (let i = 0, len = asset.files.length; i < len; i++) {
+ if (types.indexOf(asset.files[i].classifier) !== -1) {
+ file = asset.files[i];
+ break;
+ }
+ }
+ if (!file || !file.externalLink) {
+ this.reportCriticalError('RAML data not found in the asset.');
+ return;
+ }
+ const { externalLink, mainFile, md5, packaging } = file;
+ try {
+ const result = await this.apiParser.processApiLink(externalLink, mainFile, md5, packaging);
+ this.apiConsoleFromParser(result);
+ } catch (cause) {
+ this.reportCriticalError(cause.message);
+ }
+ }
+
+ appTemplate() {
+ const { initializing } = this;
+ if (initializing) {
+ return this.loaderTemplate();
+ }
+ // @ts-ignore
+ const { appVersion } = window.versionInfo;
+ return html`
+
+ ${this[navigationTemplate]()}
+ ${this[pageTemplate](this.route)}
+
+ `;
+ }
+
+ /**
+ * @returns {TemplateResult} A template for the loader
+ */
+ loaderTemplate() {
+ return html`
+
+
Preparing something spectacular
+
${this.loadingStatus}
+
+ ${isWorkspace ? '' :
+ html`
+
+ `}
+ API Client
+ `;
+ }
+
+ /**
+ * @returns {TemplateResult|string} The template for the environment selector and the overlay.
+ */
+ [environmentTemplate]() {
+ const { compatibility, variablesEnabled } = this;
+ if (!variablesEnabled) {
+ return '';
+ }
+ let { currentEnvironment } = this;
+ if (!currentEnvironment) {
+ // this can be `null` so default values won't work
+ currentEnvironment = 'Default';
+ }
+ return html`
+
+ Environment: ${currentEnvironment}
+
+
+ ${this[arcNavigationTemplate]()}
+
+
+ `;
+ }
+
+ /**
+ * @returns {TemplateResult} The template for the ARC navigation
+ */
+ [arcNavigationTemplate]() {
+ const { compatibility, menuPopup, listType, historyEnabled, popupMenuEnabled, draggableEnabled } = this;
+ const hideHistory = menuPopup.includes('history-menu');
+ const hideSaved = menuPopup.includes('saved-menu');
+ const hideProjects = menuPopup.includes('projects-menu');
+ const hideApis = menuPopup.includes('rest-api-menu');
+ return html`
+
+ ${this[headerTemplate]()}
+ ${this[workspaceTemplate](route === 'workspace')}
+ ${this[historyPanelTemplate](route)}
+ ${this[savedPanelTemplate](route)}
+ ${this[clientCertScreenTemplate](route)}
+ ${this[dataImportScreenTemplate](route)}
+ ${this[dataExportScreenTemplate](route)}
+ ${this[cookieManagerScreenTemplate](route)}
+ ${this[settingsScreenTemplate](route)}
+ ${this[importInspectorTemplate](route)}
+ ${this[hostRulesTemplate](route)}
+ ${this[exchangeSearchTemplate](route)}
+ ${this[requestDetailTemplate]()}
+ ${this[requestMetaTemplate]()}
+
+ `;
+ }
+
+ /**
+ * @param {boolean} visible Whether the workspace is rendered in the view
+ * @returns
+ */
+ [workspaceTemplate](visible) {
+ const { oauth2RedirectUri, compatibility, initOptions, workspaceSendButton, workspaceProgressInfo } = this;
+ // if (typeof cnf.requestEditor.bodyEditor === 'string') {
+ // this.workspaceBodyEditor = cnf.requestEditor.bodyEditor;
+ // }
+ // if (typeof cnf.requestEditor.autoEncode === 'boolean') {
+ // this.workspaceAutoEncode = cnf.requestEditor.autoEncode;
+ // }
+ return html`
+
+
Data import
+
You can import ARC data from any previous version, Postman export and backup, and API specification (RAML or OAS)
+
Select file
+
+ `;
+ }
+
+ /**
+ * @returns {TemplateResult} The template for the request metadata editor dialog
+ */
+ [requestMetaTemplate]() {
+ const { compatibility, requestMetaOpened, metaRequestId, metaRequestType } = this;
+ return html`
+
+ `;
+ }
+
+ /**
+ * @param {string} route The current route
+ * @returns {TemplateResult|string} The template for the host rules mapping element
+ */
+ [hostRulesTemplate](route) {
+ if (route !== 'hosts') {
+ return '';
+ }
+ const { compatibility } = this;
+ return html`
+ }
+ */
+ this.connections = new Map();
+
+ this[loadStartHandler] = this[loadStartHandler].bind(this);
+ this[firstByteHandler] = this[firstByteHandler].bind(this);
+ this[loadEndHandler] = this[loadEndHandler].bind(this);
+ this[beforeRedirectHandler] = this[beforeRedirectHandler].bind(this);
+ this[headersReceivedHandler] = this[headersReceivedHandler].bind(this);
+ this[loadHandler] = this[loadHandler].bind(this);
+ this[errorHandler] = this[errorHandler].bind(this);
+ }
+
+ listen() {
+ window.addEventListener(TransportEventTypes.request, this[makeRequestHandler].bind(this));
+ window.addEventListener(TransportEventTypes.abort, this[abortRequestHandler].bind(this));
+ window.addEventListener(TransportEventTypes.transport, this[transportRequestHandler].bind(this));
+ }
+
+ async [makeRequestHandler](e) {
+ const transportRequest = e.detail;
+ const request = await this.factory.processRequest(transportRequest, {
+ evaluateVariables: this.evaluateVariables,
+ evaluateSystemVariables: this.evaluateSystemVariables,
+ });
+ // this event is significant, even though it is handled by the same class.
+ TransportEvents.transport(document.body, request.id, request.request);
+ }
+
+ /**
+ * @param {ApiTransportEvent} e
+ */
+ async [transportRequestHandler](e) {
+ const transportRequest = e.detail;
+ const { config, id, request } = transportRequest;
+ await this.run(request, id, config);
+ }
+
+ /**
+ * @param {ArcBaseRequest} request
+ * @param {string} id
+ * @param {RequestConfig=} config
+ */
+ async run(request, id, config={ enabled: false }) {
+ const rConf = /** @type RequestConfig */ (request.config || {});
+ const configInit = rConf.enabled ? rConf : /** @type RequestConfig */ ({});
+ const finalConfig = this.prepareRequestOptions(config, configInit);
+ if (request.clientCertificate) {
+ finalConfig.clientCertificate = request.clientCertificate;
+ }
+ // the request can proceed without hosts
+ try {
+ const hosts = await ArcModelEvents.HostRules.list(document.body);
+ if (hosts && hosts.items) {
+ finalConfig.hosts = hosts.items;
+ }
+ } catch (e) {
+ logger.error(e);
+ }
+ logger.info(`The config passed to the request factory:`, finalConfig);
+ try {
+ const connection = await this[prepareRequest](id, request, finalConfig);
+ await this[makeConnection](connection);
+ } catch (e) {
+ logger.error(e);
+ this[errorHandler](e, id);
+ }
+ }
+
+ [abortRequestHandler](e) {
+ const { id } = e.detail;
+ this.factory.abort(id);
+ const info = this.connections.get(id);
+ info.connection.abort();
+ }
+
+ /**
+ * @param {RequestConfig} primary
+ * @param {RequestConfig} secondary
+ * @returns {RequestOptions}
+ */
+ prepareRequestOptions(primary, secondary) {
+ const result = /** @type RequestOptions */ ({
+ ...secondary,
+ ...primary,
+ logger,
+ });
+ delete result.enabled;
+ delete result.ignoreSessionCookies;
+ if (typeof result.timeout === 'undefined' && typeof this.requestTimeout === 'number') {
+ result.timeout = this.requestTimeout;
+ }
+ if (result.timeout) {
+ result.timeout *= 1000;
+ } else {
+ result.timeout = 0;
+ }
+
+ if (typeof result.validateCertificates === 'undefined' && typeof this.validateCertificates === 'boolean') {
+ result.validateCertificates = this.validateCertificates;
+ }
+ if (typeof result.followRedirects === 'undefined' && typeof this.followRedirects === 'boolean') {
+ result.followRedirects = this.followRedirects;
+ }
+ if (typeof result.defaultHeaders === 'undefined' && typeof this.defaultHeaders === 'boolean') {
+ result.defaultHeaders = this.defaultHeaders;
+ }
+ if (typeof this.sentMessageLimit === 'number') {
+ result.sentMessageLimit = this.sentMessageLimit;
+ }
+ return result;
+ }
+
+ /**
+ * @param {ArcBaseRequest} request
+ * @param {RequestOptions} opts
+ * @returns {SocketRequest|ElectronRequest}
+ */
+ [prepareRequest](id, request, opts) {
+ return this.isNative(opts) ? this[prepareNativeRequest](id, request, opts) : this[prepareArcRequest](id, request, opts);
+ }
+
+ /**
+ * @param {string} id
+ * @param {ArcBaseRequest} request
+ * @param {RequestOptions} opts
+ * @returns {ElectronRequest}
+ */
+ [prepareNativeRequest](id, request, opts) {
+ const conn = new ElectronRequest(request, id, opts);
+ this.connections.set(id, {
+ connection: conn,
+ aborted: false,
+ request,
+ });
+ conn.on('loadstart', this[loadStartHandler]);
+ conn.on('firstbyte', this[firstByteHandler]);
+ conn.on('loadend', this[loadEndHandler]);
+ conn.on('beforeredirect', this[beforeRedirectHandler]);
+ conn.on('headersreceived', this[headersReceivedHandler]);
+ conn.on('load', this[loadHandler]);
+ conn.on('error', this[errorHandler]);
+ return conn;
+ }
+
+ /**
+ * @param {string} id
+ * @param {ArcBaseRequest} request
+ * @param {RequestOptions} opts
+ * @returns {SocketRequest}
+ */
+ [prepareArcRequest](id, request, opts) {
+ const conn = new SocketRequest(request, id, opts);
+ this.connections.set(id, {
+ connection: conn,
+ aborted: false,
+ request,
+ });
+ conn.on('loadstart', this[loadStartHandler]);
+ conn.on('firstbyte', this[firstByteHandler]);
+ conn.on('loadend', this[loadEndHandler]);
+ conn.on('beforeredirect', this[beforeRedirectHandler]);
+ conn.on('headersreceived', this[headersReceivedHandler]);
+ conn.on('load', this[loadHandler]);
+ conn.on('error', this[errorHandler]);
+ return conn;
+ }
+
+ /**
+ * @param {RequestOptions} opts
+ * @returns {boolean}
+ */
+ isNative(opts) {
+ if (typeof opts.nativeTransport === 'boolean') {
+ return opts.nativeTransport;
+ }
+ return !!this.nativeTransport;
+ }
+
+ /**
+ * @param {SocketRequest|ElectronRequest} connection
+ */
+ async [makeConnection](connection) {
+ try {
+ await connection.send();
+ } catch (cause) {
+ this[errorHandler](cause, connection.id);
+ }
+ }
+
+ /**
+ * @param {string} id
+ */
+ [loadStartHandler](id) {
+ this[informStatus]('requestloadstart', id);
+ }
+
+ /**
+ * @param {string} id
+ */
+ [firstByteHandler](id) {
+ this[informStatus]('requestfirstbytereceived', id);
+ }
+
+ /**
+ * @param {string} id
+ */
+ [loadEndHandler](id) {
+ this[informStatus]('requestloadend', id);
+ }
+
+ /**
+ * @param {string} id
+ * @param {any}
+ */
+ [beforeRedirectHandler](id, detail) {
+ const info = this.connections.get(id);
+ if (!info || info.aborted) {
+ return;
+ }
+ const e = new CustomEvent('beforeredirect', {
+ composed: true,
+ bubbles: true,
+ cancelable: true,
+ detail: {
+ id,
+ url: detail.location,
+ }
+ });
+ document.body.dispatchEvent(e);
+ if (e.defaultPrevented) {
+ detail.returnValue = false;
+ }
+ }
+
+ /**
+ * @param {string} id
+ * @param {any} detail
+ */
+ [headersReceivedHandler](id, detail) {
+ const info = this.connections.get(id);
+ if (!info || info.aborted) {
+ return;
+ }
+ const e = new CustomEvent('headersreceived', {
+ composed: true,
+ bubbles: true,
+ cancelable: true,
+ detail: {
+ id,
+ url: detail.location,
+ }
+ });
+ document.body.dispatchEvent(e);
+ if (e.defaultPrevented) {
+ detail.returnValue = false;
+ }
+ }
+
+ /**
+ * @param {string} id
+ * @param {Response} response
+ * @param {TransportRequest} transport
+ */
+ async [loadHandler](id, response, transport) {
+ const info = this.connections.get(id);
+ this.connections.delete(id);
+ if (!info || info.aborted) {
+ return;
+ }
+ this[removeConnectionHandlers](info.connection);
+ const fr = {
+ id,
+ request: info.request,
+ }
+ try {
+ await this.factory.processResponse(fr, transport, response, {
+ evaluateVariables: this.evaluateVariables,
+ evaluateSystemVariables: this.evaluateSystemVariables,
+ });
+ TransportEvents.response(document.body, id, info.request, transport, response);
+ } catch (e) {
+ const errorResponse = /** @type ErrorResponse */ ({
+ error: e,
+ status: response.status,
+ headers: response.headers,
+ payload: response.payload,
+ statusText: response.statusText,
+ id: response.id,
+ });
+ TransportEvents.response(document.body, id, info.request, transport, errorResponse);
+ }
+ }
+
+ /**
+ * @param {Error} error
+ * @param {string} id
+ * @param {TransportRequest=} transport
+ * @param {ErrorResponse=} response
+ */
+ [errorHandler](error, id, transport, response) {
+ const info = this.connections.get(id);
+ this.connections.delete(id);
+ if (!info || info.aborted) {
+ return;
+ }
+ this[removeConnectionHandlers](info.connection);
+ const errorResponse = response || {
+ error,
+ status: 0,
+ };
+
+ TransportEvents.response(document.body, id, info.request, transport, errorResponse);
+ }
+
+ /**
+ * @param {SocketRequest|ElectronRequest} connection
+ */
+ [removeConnectionHandlers](connection) {
+ connection.removeAllListeners('loadstart');
+ connection.removeAllListeners('firstbyte');
+ connection.removeAllListeners('loadend');
+ connection.removeAllListeners('beforeredirect');
+ connection.removeAllListeners('headersreceived');
+ connection.removeAllListeners('load');
+ connection.removeAllListeners('error');
+ }
+
+ /**
+ * @param {string} type
+ * @param {string} id
+ */
+ [informStatus](type, id) {
+ const info = this.connections.get(id);
+ if (!info || info.aborted) {
+ return;
+ }
+ document.body.dispatchEvent(new CustomEvent(type, {
+ composed: true,
+ bubbles: true,
+ detail: {
+ id,
+ }
+ }));
+ }
+}
diff --git a/src/app/scripts/arc/Utils.js b/src/app/scripts/arc/Utils.js
new file mode 100644
index 00000000..4eb6a8b6
--- /dev/null
+++ b/src/app/scripts/arc/Utils.js
@@ -0,0 +1,9 @@
+/**
+ * Gets an index of the tab which is the source of one of the pre-build actions.
+ * @param {Element} target
+ * @return {number} An index of the tab
+ */
+export function getTabClickIndex(target) {
+ const tab = target.closest('workspace-tab');
+ return Array.from(tab.parentElement.children).filter((node) => node.localName === tab.localName).indexOf(tab);
+}
diff --git a/src/app/scripts/common/ArcAlertDialogElement.d.ts b/src/app/scripts/common/ArcAlertDialogElement.d.ts
new file mode 100644
index 00000000..7d5df3a5
--- /dev/null
+++ b/src/app/scripts/common/ArcAlertDialogElement.d.ts
@@ -0,0 +1,27 @@
+import { LitElement, CSSResult, TemplateResult } from 'lit-element';
+import { AnypointDialogMixin } from '@anypoint-web-components/anypoint-dialog';
+
+export declare const closedHandler: unique symbol;
+
+export class ArcAlertDialogElement extends AnypointDialogMixin(LitElement) {
+ static get styles(): CSSResult[];
+
+ /**
+ * @attribute
+ */
+ message: string;
+ /**
+ * @attribute
+ */
+ compatibility: boolean;
+
+ constructor();
+
+ connectedCallback(): void;
+
+ disconnectedCallback(): void;
+
+ [closedHandler](): void;
+
+ render(): TemplateResult;
+}
diff --git a/src/app/scripts/common/ArcAlertDialogElement.js b/src/app/scripts/common/ArcAlertDialogElement.js
new file mode 100644
index 00000000..9816bbcf
--- /dev/null
+++ b/src/app/scripts/common/ArcAlertDialogElement.js
@@ -0,0 +1,69 @@
+import { html, css, LitElement } from '../../../../web_modules/lit-element/lit-element.js';
+import { AnypointDialogMixin } from '../../../../web_modules/@anypoint-web-components/anypoint-dialog/index.js';
+import AnypointDialogStyles from '../../../../web_modules/@anypoint-web-components/anypoint-dialog/src/AnypointDialogInternalStyles.js';
+import '../../../../web_modules/@anypoint-web-components/anypoint-button/anypoint-button.js';
+
+export const closedHandler = Symbol('closedHandler');
+
+export class ArcAlertDialogElement extends AnypointDialogMixin(LitElement) {
+ static get styles() {
+ return [
+ AnypointDialogStyles,
+ css`
+ :host {
+ background-color: #F44336;
+ }
+
+ :host > h2,
+ :host > * {
+ color: #fff !important;
+ }
+
+ .message {
+ font-family: monospace;
+ }
+
+ anypoint-button {
+ color: #fff;
+ }
+ `,
+ ];
+ }
+
+ static get properties() {
+ return {
+ message: { type: String },
+ };
+ }
+
+ constructor() {
+ super();
+ this.message = undefined;
+ this.compatibility = false;
+ this[closedHandler] = this[closedHandler].bind(this);
+ }
+
+ connectedCallback() {
+ super.connectedCallback();
+ this.addEventListener('overlay-closed', this[closedHandler]);
+ }
+
+ disconnectedCallback() {
+ super.disconnectedCallback();
+ this.removeEventListener('overlay-closed', this[closedHandler]);
+ }
+
+ [closedHandler]() {
+ this.parentNode.removeChild(this);
+ }
+
+ render() {
+ return html`
+ An error ocurred
+ ${this.message}
+
+ `;
+ }
+}
diff --git a/src/app/scripts/context-menu/ContextMenu.js b/src/app/scripts/context-menu/ContextMenu.js
new file mode 100644
index 00000000..c3402b3b
--- /dev/null
+++ b/src/app/scripts/context-menu/ContextMenu.js
@@ -0,0 +1,459 @@
+import '../../../../web_modules/@anypoint-web-components/anypoint-listbox/anypoint-listbox.js';
+import '../../../../web_modules/@anypoint-web-components/anypoint-item/anypoint-icon-item.js';
+import '../../../../web_modules/@advanced-rest-client/arc-icons/arc-icon.js';
+import { ContextMenuStore } from './ContextMenuStore.js';
+
+/** @typedef {import('./interfaces').RegisteredCommand} RegisteredCommand */
+/** @typedef {import('./interfaces').ClickVector} ClickVector */
+/** @typedef {import('./interfaces').ContextMenuCommand} ContextMenuCommand */
+/** @typedef {import('./interfaces').ExecuteOptions} ExecuteOptions */
+
+let index = 0;
+
+/**
+ * A plugin that adds content menu support to the visualization workspace.
+ *
+ * This is a base class and by its own it has no commands registered. Override this class
+ * to register own commands with the `registerCommand()` function. Child class must also
+ * override the `elementToTarget()` that translates click target to a registered in the commands
+ * name. Each command has the `target` that is used to recognize which command should be rendered.
+ *
+ * After the visualization workspace is initialized create an instance of this class
+ * and call `connect()` to register event listener. After the workspace is no longer rendered
+ * or when context change, call `disconnect()` to clean up listeners.
+ */
+export class ContextMenu {
+ #connectedValue = false;
+
+ /**
+ * @returns {boolean} True when the plug-in is listening for the input events.
+ */
+ get connected() {
+ return this.#connectedValue;
+ }
+
+ /**
+ * The root target of this context menu
+ * @type {HTMLElement}
+ */
+ workspace;
+
+ /**
+ * A reference to the store initialized with this context menu
+ * @type {ContextMenuStore}
+ */
+ store;
+
+ /**
+ * List of registered commands.
+ * @type {RegisteredCommand[]}
+ */
+ commands = [];
+
+ /**
+ * @type {RegisteredCommand[]}
+ */
+ currentCommands = undefined;
+
+ /**
+ * @type {(HTMLElement|SVGElement)}
+ */
+ currentTarget = undefined;
+
+ /**
+ * @type {HTMLDivElement}
+ */
+ currentMenu = undefined;
+
+ /**
+ * @type {ClickVector}
+ */
+ targetVector = undefined;
+
+ /**
+ * @type {((args: ExecuteOptions) => void)}
+ */
+ #callback = undefined;
+
+ /**
+ * @param {HTMLElement} workspace The root element that is the click handler
+ */
+ constructor(workspace) {
+ this.workspace = workspace;
+ this.store = new ContextMenuStore(this);
+ this.contextHandler = this.contextHandler.bind(this);
+ this.menuClickHandler = this.menuClickHandler.bind(this);
+ this.clickHandler = this.clickHandler.bind(this);
+ this.keydownHandler = this.keydownHandler.bind(this);
+ }
+
+ /**
+ * Registers a callback function to be called when a menu item is activated.
+ * This function is only called when the `execute` function is not defined on the action and the `command` property is set.
+ * @param {((args: ExecuteOptions) => void)} callback The function with the value of the `command` property of the action.
+ */
+ registerCallback(callback) {
+ this.#callback = callback;
+ }
+
+ /**
+ * Starts listening on user events
+ * @returns {void}
+ */
+ connect() {
+ this.workspace.addEventListener('contextmenu', this.contextHandler);
+ window.addEventListener('click', this.clickHandler);
+ window.addEventListener('keydown', this.keydownHandler);
+ this.connectedValue = true;
+ }
+
+ /**
+ * Cleans up the listeners
+ * @returns {void}
+ */
+ disconnect() {
+ this.workspace.removeEventListener('contextmenu', this.contextHandler);
+ window.removeEventListener('click', this.clickHandler);
+ window.removeEventListener('keydown', this.keydownHandler);
+ this.connectedValue = false;
+ }
+
+ /**
+ * Handler for the context menu event.
+ * @param {MouseEvent} e
+ * @returns {void}
+ */
+ contextHandler(e) {
+ this.destroy();
+ const target = this.findTarget(e);
+ if (!target) {
+ return;
+ }
+
+ // since the context menu has fixed position it doesn't matter what the context
+ // is as the menu is rendered over all element.
+ // The `readClickPosition()` is used to determine click target for the commands.
+ const clickVector = {
+ x: e.clientX,
+ y: e.clientY,
+ }
+ const targetVector = this.readClickPosition(e);
+ this.build(e, target, clickVector, targetVector);
+ }
+
+ /**
+ * Reads {x,y} vector of the click from the pointer event.
+ * @param {MouseEvent} e
+ * @returns {ClickVector}
+ */
+ readClickPosition(e) {
+ return {
+ x: e.clientX,
+ y: e.clientY,
+ }
+ }
+
+ /**
+ * Finds the click target from the event
+ * @param {MouseEvent} e
+ * @returns {HTMLElement|SVGElement|undefined}
+ */
+ findTarget(e) {
+ const target = e.composedPath()[0];
+ return /** @type HTMLElement|SVGElement|undefined */ (target);
+ }
+
+ /**
+ * Builds a menu for a specific target.
+ *
+ * @param {MouseEvent} e
+ * @param {HTMLElement|SVGElement} target The element that triggered the menu
+ * @param {ClickVector} placementVector
+ * @param {ClickVector} targetVector
+ * @returns {void}
+ */
+ build(e, target, placementVector, targetVector) {
+ const commands = this.listCommands(target);
+ if (!commands.length) {
+ return;
+ }
+ e.preventDefault();
+ e.stopPropagation();
+ this.targetVector = targetVector;
+ const groups = this.groupCommands(commands);
+ this.currentCommands = commands;
+ this.currentTarget = target;
+ this.render(target, placementVector, groups);
+ target.setAttribute('active', '');
+ }
+
+ /**
+ * @param {HTMLElement|SVGElement} target The element that triggered the menu
+ * @param {ClickVector} vector The canvas position of where to place the menu.
+ * @param {RegisteredCommand[][]} groups The commands render
+ * @returns {void}
+ */
+ render(target, vector, groups) {
+ const root = this.createContainer();
+ const box = root.querySelector('anypoint-listbox');
+ const size = groups.length;
+ groups.forEach((commands, i) => {
+ commands.forEach((command) => {
+ const item = this.createCommandItem(command, target);
+ box.append(item);
+ });
+ if (i + 1 !== size) {
+ box.append(this.createCommandDivider());
+ }
+ });
+ this.currentMenu = root;
+ root.style.top = `${vector.y}px`;
+ root.style.left = `${vector.x}px`;
+ const { workspace } = this;
+ if (workspace.shadowRoot) {
+ this.workspace.shadowRoot.append(root);
+ } else {
+ this.workspace.append(root);
+ }
+ }
+
+ /**
+ * Removes currently rendered menu.
+ * @returns {void}
+ */
+ destroy() {
+ if (!this.currentMenu) {
+ return;
+ }
+ const items = /** @type NodeListOf */ (this.currentMenu.querySelectorAll('.item'));
+ items.forEach((item) => item.removeEventListener('click', this.menuClickHandler));
+ this.currentTarget.removeAttribute('active');
+
+ this.currentCommands = undefined;
+ this.currentTarget = undefined;
+ this.targetVector = undefined;
+
+ const { workspace } = this;
+ if (workspace.shadowRoot) {
+ this.workspace.shadowRoot.removeChild(this.currentMenu);
+ } else {
+ this.workspace.removeChild(this.currentMenu);
+ }
+ this.currentMenu = undefined;
+ }
+
+ /**
+ * Maps an element to an internal target name. This should be overridden by the implementation.
+ *
+ * @param {HTMLElement|SVGElement} element The context click target
+ * @returns {string|undefined} The internal target name.
+ */
+ elementToTarget(element) {
+ if (element === this.workspace) {
+ return 'root';
+ }
+ return undefined;
+ }
+
+ /**
+ * Registers multiple commands in a batch call.
+ * @param {ContextMenuCommand[]} commands The list of commands to register
+ * @returns {void}
+ */
+ registerCommands(commands) {
+ commands.forEach((command) => this.registerCommand(command));
+ }
+
+ /**
+ * Registers a new command in the context menu.
+ * @param {ContextMenuCommand} command
+ * @returns {void}
+ */
+ registerCommand(command) {
+ index += 1;
+ const cmd = { ...command, id: index };
+ this.commands.push(cmd);
+ }
+
+ /**
+ * Lists all commands that matches the target.
+ *
+ * @param {HTMLElement|SVGElement} target The build target
+ * @returns {RegisteredCommand[]}
+ */
+ listCommands(target) {
+ const { commands } = this;
+ const result =/** @type RegisteredCommand[] */ ([]);
+ commands.forEach((cmd) => {
+ if (cmd.selector === '*' || target.matches(cmd.selector)) {
+ result.push(cmd);
+ }
+ });
+ return result;
+ }
+
+ /**
+ * Creates an ordered grouped list of commands
+ *
+ * @param {RegisteredCommand[]} commands The commands to group
+ * @returns {RegisteredCommand[][]} Ordered list of grouped commands.
+ */
+ groupCommands(commands) {
+ const main = /** @type RegisteredCommand[] */ ([]);
+ const tmp = /** @type Map */ (new Map());
+ commands.forEach((cmd) => {
+ const { group } = cmd;
+ if (!group || group === 'main') {
+ main.push(cmd);
+ } else {
+ if (!tmp.has(group)) {
+ tmp.set(group, []);
+ }
+ tmp.get(group).push(cmd);
+ }
+ });
+ const result = /** @type RegisteredCommand[][] */ ([]);
+ if (main.length) {
+ result.push(main);
+ }
+ for (const item of tmp) {
+ result.push(item[1]);
+ }
+ return result;
+ }
+
+ /**
+ * @return {HTMLDivElement}
+ */
+ createContainer() {
+ const container = document.createElement('div');
+ container.classList.add('context-menu');
+ const list = document.createElement('anypoint-listbox');
+ list.classList.add('listbox');
+ container.append(list);
+ return container;
+ }
+
+ /**
+ * @param {RegisteredCommand} command The command render
+ * @param {HTMLElement|SVGElement} target The element that triggered the menu
+ * @returns AnypointIconItem
+ */
+ createCommandItem(command, target) {
+ const { label, title, icon, enabled, id } = command;
+ const item = document.createElement('anypoint-icon-item');
+ item.classList.add('item');
+ const labelElement = document.createElement('span');
+ let disabled = false;
+ if (typeof enabled === 'function') {
+ disabled = !enabled({
+ store: this.store,
+ target,
+ root: this.workspace,
+ });
+ }
+ if (disabled) {
+ item.classList.add('disabled');
+ }
+ if (title) {
+ item.title = title;
+ }
+ if (icon) {
+ const mi = this.createIcon(icon);
+ item.append(mi);
+ } else {
+ const mi = document.createElement('div');
+ mi.slot = 'item-icon';
+ mi.classList.add('menu-icon');
+ item.append(mi);
+ }
+ labelElement.innerText = label;
+ item.append(labelElement);
+ item.addEventListener('click', this.menuClickHandler);
+ item.dataset.cmd = String(id);
+ return item;
+ }
+
+ /**
+ * Creates an icon to be added to the menu item.
+ * @param {string} icon
+ * @returns {HTMLElement}
+ */
+ createIcon(icon) {
+ const mi = document.createElement('arc-icon');
+ // @ts-ignore
+ mi.icon = icon;
+ mi.slot = 'item-icon';
+ mi.classList.add('menu-icon');
+ return mi;
+ }
+
+ /**
+ * Creates the menu items divider.
+ * @returns HTMLDivElement
+ */
+ createCommandDivider() {
+ const item = document.createElement('div');
+ item.classList.add('menu-divider');
+ return item;
+ }
+
+ /**
+ * Handles the click on the menu item.
+ * @param {MouseEvent} e
+ * @returns {void}
+ */
+ menuClickHandler(e) {
+ const node = /** @type HTMLElement */ (e.currentTarget);
+ const id = Number(node.dataset.cmd);
+ if (Number.isNaN(id)) {
+ return;
+ }
+ const { currentCommands, currentTarget, targetVector } = this;
+ this.destroy();
+ const command = currentCommands.find((item) => item.id === id);
+ if (!command) {
+ return;
+ }
+ const opts = {
+ store: this.store,
+ target: currentTarget,
+ root: this.workspace,
+ vector: targetVector,
+ command: command.command,
+ };
+ if (this.#callback && command.command) {
+ this.#callback(opts);
+ } else {
+ command.execute(opts);
+ }
+ }
+
+ /**
+ * Handles the click event on the document to close the menu is the click
+ * is outside the menu.
+ * @param {MouseEvent}e
+ * @returns {void}
+ */
+ clickHandler(e) {
+ if (!this.currentMenu || e.defaultPrevented) {
+ return;
+ }
+ const elm = /** @type Element */ (e.target);
+ const inside = this.currentMenu.contains(elm);
+ if (!inside) {
+ this.destroy();
+ }
+ }
+
+ /**
+ * Closes the menu when ESC is pressed
+ * @param {KeyboardEvent} e
+ * @returns {void}
+ */
+ keydownHandler(e) {
+ if (e.key === 'Escape' && this.currentMenu) {
+ this.destroy();
+ }
+ }
+}
diff --git a/src/app/scripts/context-menu/ContextMenu.styles.js b/src/app/scripts/context-menu/ContextMenu.styles.js
new file mode 100644
index 00000000..001c2e9a
--- /dev/null
+++ b/src/app/scripts/context-menu/ContextMenu.styles.js
@@ -0,0 +1,41 @@
+import { css } from '../../../../web_modules/lit-element/lit-element.js';
+
+export const ContextMenuStyles = css`
+.context-menu {
+ position: fixed;
+ font-size: 1rem;
+ color: var(--context-menu-color, #000);
+ user-select: none;
+ z-index: 100;
+ --anypoint-item-icon-width: 32px;
+ --anypoint-item-min-height: 32px;
+}
+
+.context-menu .listbox {
+ padding: 2px 0;
+ min-width: 160px;
+ border-radius: 4px;
+ box-shadow: var(--context-menu-shadow, var(--anypoint-dropdown-shadow));
+ background-color: var(--context-menu-background-color, var(--primary-background-color));
+}
+
+.context-menu .item {
+ margin: 8px 0;
+}
+
+.context-menu .item.disabled {
+ color: var(--context-menu-disabled-color, #9E9E9E);
+ pointer-events: none;
+}
+
+.menu-divider {
+ height: 1px;
+ background-color: var(--context-menu-divider-color, rgba(0, 0, 0, 0.12));
+ margin: 8px 0 8px 40px;
+}
+
+.menu-icon {
+ width: 20px;
+ height: 20px;
+}
+`;
diff --git a/src/app/scripts/context-menu/ContextMenuStore.js b/src/app/scripts/context-menu/ContextMenuStore.js
new file mode 100644
index 00000000..e22b3298
--- /dev/null
+++ b/src/app/scripts/context-menu/ContextMenuStore.js
@@ -0,0 +1,52 @@
+/** @typedef {import('./ContextMenu').ContextMenu} ContextMenu */
+
+export class ContextMenuStore {
+ /**
+ * Store's cache object when the menu items keeps their data.
+ * @type {Map}
+ */
+ #cache = new Map();
+
+ /**
+ * The context menu instance.
+ */
+ #menu;
+
+ /**
+ * @param {ContextMenu} targetMenu The instance of the context menu that has this store.
+ */
+ constructor(targetMenu) {
+ this.#menu = targetMenu;
+ }
+
+ /**
+ * Sets a value in the store.
+ *
+ * @param {string} key The key under which to store the value
+ * @param value {any} The value to store.
+ * @returns {void}
+ */
+ set(key, value) {
+ this.#cache.set(key, value);
+ }
+
+ /**
+ * Reads a value from the state store.
+ *
+ * @param {string} key The key under which the value exists
+ * @returns {any|undefined} Stored value or undefined if not set.
+ */
+ get(key) {
+ return this.#cache.get(key);
+ }
+
+ /**
+ * Removes a value from the store.
+ *
+ * @param {string} key The key under which the value exists
+ * @returns {void}
+ */
+ delete(key) {
+ this.#cache.delete(key);
+ }
+}
diff --git a/src/app/scripts/context-menu/interfaces.d.ts b/src/app/scripts/context-menu/interfaces.d.ts
new file mode 100644
index 00000000..76cb8510
--- /dev/null
+++ b/src/app/scripts/context-menu/interfaces.d.ts
@@ -0,0 +1,97 @@
+import { ContextMenuStore } from './ContextMenuStore';
+
+export declare interface ClickVector {
+ x: number;
+ y: number;
+}
+
+export declare interface EnabledOptions {
+ /**
+ * The object store to be used to store menu item data.
+ */
+ store: ContextMenuStore;
+ /**
+ * An instance of the element that triggered the command.
+ */
+ target: HTMLElement|SVGElement;
+ /**
+ * The element with which this context menu was initialized with.
+ */
+ root: HTMLElement;
+}
+
+export declare interface ExecuteOptions {
+ /**
+ * The object store to be used to store menu item data.
+ */
+ store: ContextMenuStore;
+ /**
+ * An instance of the element that triggered the command.
+ */
+ target: HTMLElement|SVGElement;
+ /**
+ * The element with which this context menu was initialized with.
+ */
+ root: HTMLElement;
+ /**
+ * The vector of the original click.
+ */
+ vector: ClickVector;
+ /**
+ * The value of the `command` set on the command.
+ */
+ command?: string;
+}
+
+export declare interface ContextMenuCommand {
+ /**
+ * The name of the CSS selector that identifies the click target.
+ */
+ selector: string;
+ /**
+ * The label to render.
+ */
+ label: string;
+ /**
+ * Optional title to use
+ */
+ title?: string;
+ /**
+ * The icon to render from the modeling-icons library.
+ * TODO: Make it also an `SVGTemplateResult`
+ */
+ icon?: string;
+ /**
+ * A shortcut that triggers the command.
+ */
+ shortcut?: string;
+ /**
+ * This value is not visualized. When set it creates a new group in the
+ * context menu in a way that they are separated with each other with
+ * a divider.
+ *
+ * @default main
+ */
+ group?: string | 'main' | 'edit' | 'view';
+ /**
+ * When set it is passed to the `execute` function and to the registered callback function.
+ */
+ command?: string;
+ /**
+ * Whether the command is enabled or not.
+ * When not set it is assumed that the command is enabled.
+ * The function returns a value indicating whether the command is enabled.
+ */
+ enabled?: ((args: EnabledOptions) => boolean);
+ /**
+ * The action to be executed when this command is activated
+ */
+ execute?: ((args: ExecuteOptions) => void);
+}
+
+export declare interface RegisteredCommand extends ContextMenuCommand {
+ /**
+ * The id of the registered command.
+ */
+ id: number;
+}
diff --git a/src/app/scripts/data-migration.js b/src/app/scripts/data-migration.js
new file mode 100644
index 00000000..8130bdaa
--- /dev/null
+++ b/src/app/scripts/data-migration.js
@@ -0,0 +1,67 @@
+/* eslint-disable no-unused-vars */
+import { ApplicationPage } from '../ApplicationPage.js';
+import { html } from '../../../web_modules/lit-html/lit-html.js';
+
+export class DataMigrationDialog extends ApplicationPage {
+ constructor() {
+ super();
+
+ this.initObservableProperties(
+ 'loadingStatus', 'error', 'stack'
+ );
+
+ this.loadingStatus = 'Checking the requirements...';
+ this.error = false;
+ this.stack = '';
+ }
+
+ initialize() {
+ /**
+ * @param {MessageEvent} e
+ */
+ window.onmessage = (e) => {
+ const { data } = e;
+ console.log('DATA', data);
+ if (data.loadingStatus) {
+ this.loadingStatus = data.loadingStatus;
+ } else if (data.error) {
+ const info = typeof data.error === 'string' ? JSON.parse(data.error) : data.error;
+ this.error = true;
+ this.loadingStatus = info.message;
+ this.stack = info.stack;
+ }
+ };
+ }
+
+ appTemplate() {
+ const { error } = this;
+ return error ? this.errorMessageTemplate() : this.loadingMessageTemplate();
+ }
+
+ loadingMessageTemplate() {
+ const { loadingStatus } = this;
+ return html`
+
+
+
Preparing something spectacular!
+
${loadingStatus}
+
+
+
Unthinkable happened!
+
Please, report an issue on the application GitHub page or contact us at arc@mulesoft.com for assistance.
+
${loadingStatus}
+
${stack}
+
+ ${this[searchBarSuffixTemplate]()}
+ Search text
+
+
+ `;
+ }
+
+ /**
+ * @returns {TemplateResult|string} The template for search bar counters, when has search results
+ */
+ [searchBarSuffixTemplate]() {
+ const { searchBarQuery, searchBarCount=0, searchBarOrdinal=0 } = this;
+ if (!searchBarQuery) {
+ return '';
+ }
+ return html`${searchBarOrdinal}/${searchBarCount}
`;
+ }
+}
+
+const page = new SearchBar();
+page.initialize();
diff --git a/src/app/scripts/themes.js b/src/app/scripts/themes.js
new file mode 100644
index 00000000..727c8682
--- /dev/null
+++ b/src/app/scripts/themes.js
@@ -0,0 +1,313 @@
+/* eslint-disable no-unused-vars */
+import { ApplicationPage } from '../ApplicationPage.js';
+import { html } from '../../../web_modules/lit-html/lit-html.js';
+import '../../../web_modules/@anypoint-web-components/anypoint-dropdown-menu/anypoint-dropdown-menu.js';
+import '../../../web_modules/@anypoint-web-components/anypoint-listbox/anypoint-listbox.js';
+import '../../../web_modules/@anypoint-web-components/anypoint-item/anypoint-item.js';
+import '../../../web_modules/@anypoint-web-components/anypoint-item/anypoint-icon-item.js';
+import '../../../web_modules/@anypoint-web-components/anypoint-input/anypoint-input.js';
+import '../../../web_modules/@anypoint-web-components/anypoint-switch/anypoint-switch.js';
+import '../../../web_modules/@advanced-rest-client/arc-icons/arc-icon.js';
+
+/** @typedef {import('@advanced-rest-client/arc-types').Themes.InstalledTheme} InstalledTheme */
+/** @typedef {import('@anypoint-web-components/anypoint-listbox').AnypointListbox} AnypointListbox */
+/** @typedef {import('lit-html').TemplateResult} TemplateResult */
+
+/* global ThemeManager, logger */
+
+const defaultTheme = '@advanced-rest-client/arc-electron-default-theme';
+
+export class ThemesScreen extends ApplicationPage {
+ /**
+ * @return {Boolean} `true` if selected theme is one of default themes.
+ */
+ get isDefaultTheme() {
+ const { themes, activeTheme } = this;
+ if (!themes || !activeTheme || !themes.length) {
+ return true;
+ }
+ const item = themes.find((info) => info.name === activeTheme);
+ if (!item) {
+ return false;
+ }
+ if (typeof item.isDefault !== 'boolean') {
+ return false;
+ }
+ return item.isDefault;
+ }
+
+ constructor() {
+ super();
+
+ this.initObservableProperties(
+ 'themes', 'activeTheme', 'installPending', 'compatibility',
+ 'systemPreferred',
+ );
+ this.compatibility = false;
+ this.installPending = false;
+ this.systemPreferred = false;
+ /**
+ * @type {string}
+ */
+ this.activeTheme = undefined;
+ /**
+ * @type {InstalledTheme[]}
+ */
+ this.themes = undefined;
+ this.logger = logger;
+ this.manager = new ThemeManager();
+
+ this.installThemeName = '';
+ }
+
+ async initialize() {
+ await this.refresh();
+ await this.loadTheme();
+ this.render();
+ }
+
+ async refresh() {
+ const info = await this.manager.readState();
+ if (!info) {
+ this.reportCriticalError('Unable to read application themes list.');
+ return;
+ }
+ const { kind, themes, active, systemPreferred } = info;
+ if (kind !== 'ARC#ThemeInfo') {
+ this.reportCriticalError('Unknown themes settings format.');
+ return;
+ }
+ this.themes = themes;
+ this.activeTheme = active || defaultTheme;
+ this.compatibility = this.activeTheme === '@advanced-rest-client/arc-electron-anypoint-theme';
+ this.systemPreferred = systemPreferred || false;
+ }
+
+ /**
+ * Loads the current theme.
+ */
+ async loadTheme() {
+ const search = new URLSearchParams(window.location.search);
+ const dt = search.get('darkMode');
+ const hasSystemDarkMode = dt === 'true';
+ let theme = this.activeTheme;
+ if (hasSystemDarkMode && !this.systemPreferred) {
+ theme = ThemeManager.darkTheme;
+ }
+ try {
+ await this.manager.loadTheme(theme);
+ } catch (e) {
+ this.logger.error(e);
+ }
+ }
+
+ /**
+ * Handler for the dropdown selection event. Activates the selected theme.
+ * @param {Event} e
+ */
+ async _selectionHandler(e) {
+ const list = /** @type AnypointListbox */ (e.target);
+ const { selected } = list;
+ if (selected === this.activeTheme) {
+ return;
+ }
+ const index = this.themes.findIndex((i) => i.name === selected);
+ if (index === -1) {
+ return;
+ }
+ this.activeTheme = String(selected);
+ await this.manager.activate(this.activeTheme);
+ this.manager.loadTheme(this.activeTheme);
+ this.compatibility = this.activeTheme === '@advanced-rest-client/arc-electron-anypoint-theme';
+ }
+
+ _themeNameHandler(e) {
+ this.installThemeName = e.target.value;
+ }
+
+ async _installHandler() {
+ const { installThemeName } = this;
+ if (!installThemeName) {
+ return;
+ }
+ this.installPending = true;
+ try {
+ await this.manager.installTheme(installThemeName);
+ await this.refresh();
+ await this.manager.loadTheme(this.activeTheme);
+ } catch (e) {
+ this.reportCriticalError(e.message);
+ }
+ this.installPending = false;
+ }
+
+ async _uninstallHandler() {
+ if (this.isDefaultTheme) {
+ this.reportCriticalError('Refusing to delete a default theme');
+ return;
+ }
+ this.installPending = true;
+ try {
+ await this.manager.uninstallTheme(this.activeTheme);
+ await this.manager.activate(defaultTheme);
+ await this.refresh();
+ await this.manager.loadTheme(this.activeTheme);
+ } catch (e) {
+ this.reportCriticalError(e.message);
+ }
+ this.installPending = false;
+ }
+
+ async _ignoreSysPrefChange(e) {
+ const {checked} = e.target;
+ if (checked === this.systemPreferred) {
+ return;
+ }
+ this.systemPreferred = checked;
+ try {
+ await this.manager.setSystemPreferred(checked);
+ } catch (error) {
+ this.reportCriticalError(error.message);
+ this.systemPreferred = !checked;
+ }
+ }
+
+ appTemplate() {
+ return html`
+ ${this.headerTemplate()}
+
+ ${this.selectorTemplate()}
+ ${this.systemPrefsTemplate()}
+ ${this.addTemplate()}
+
+ `;
+ }
+
+ headerTemplate() {
+ return html``;
+ }
+
+ /**
+ * @returns {TemplateResult} The template for the drop down selector with the remove option.
+ */
+ selectorTemplate() {
+ return html`
+
+
+ ${this.selectionDropdownTemplate()}
+ ${this.removeThemeTemplate()}
+
+ `;
+ }
+
+ /**
+ * @returns {TemplateResult} The template for the drop down selector.
+ */
+ selectionDropdownTemplate() {
+ const { compatibility, activeTheme, themes=[] } = this;
+ return html`
+
+ Active theme
+
+ ${themes.map((item) => this.selectionItemTemplate(item))}
+
+ `;
+ }
+
+ /**
+ * @param {InstalledTheme} item
+ * @returns {TemplateResult} The template for the drop down item.
+ */
+ selectionItemTemplate(item) {
+ const title = item.title || item.name;
+ return html`
+
+
+ ${title}
+ ${item.description ? html`${item.description}
` : ''}
+
+
+ `;
+ }
+
+ /**
+ * @returns {TemplateResult|string} The template for the uninstall icon
+ */
+ removeThemeTemplate() {
+ if (this.isDefaultTheme) {
+ return '';
+ }
+ const { compatibility } = this;
+ return html`
+
+ `;
+ }
+
+ systemPrefsTemplate() {
+ const { systemPreferred } = this;
+ return html`
+
+
+ System preferred theme
+
+
+ Install theme
+
+ Install new theme by providing its NPM name, GitHub repository as
+ owner/name#branch,
+ or absolute path to the theme on your local filesystem.
+
+
+
+ `;
+ }
+}
+
+const page = new ThemesScreen();
+page.initialize();
diff --git a/src/app/search-bar.html b/src/app/search-bar.html
new file mode 100644
index 00000000..a174b8bf
--- /dev/null
+++ b/src/app/search-bar.html
@@ -0,0 +1,14 @@
+
+
+
+ Advanced REST Client by MuleSoft
+
+
+
+
diff --git a/src/app/styles/GoogleDrivePicker.css b/src/app/styles/GoogleDrivePicker.css
new file mode 100644
index 00000000..170aebce
--- /dev/null
+++ b/src/app/styles/GoogleDrivePicker.css
@@ -0,0 +1,3 @@
+google-drive-browser {
+ width: 100%;
+}
diff --git a/src/app/styles/about.css b/src/app/styles/about.css
new file mode 100644
index 00000000..0651e628
--- /dev/null
+++ b/src/app/styles/about.css
@@ -0,0 +1,117 @@
+h1 {
+ font-size: var(--arc-font-display1-font-size);
+ font-weight: var(--arc-font-display1-font-weight);
+ letter-spacing: var(--arc-font-display1-letter-spacing);
+ line-height: var(--arc-font-display1-line-height);
+}
+
+.title-section {
+ display: flex;
+ flex-direction: column;
+ justify-content: center;
+ align-items: center;
+}
+
+.hero {
+ display: flex;
+ flex-direction: row;
+ align-items: center;
+}
+
+.logo {
+ width: 128px;
+ height: 128px;
+ display: block;
+}
+
+.app-title {
+ margin-left: 24px;
+}
+
+.version-meta {
+ display: flex;
+ flex-direction: row;
+ align-items: center;
+ font-size: 18px;
+ color: var(--about-arc-version-label-color, rgba(0, 0, 0, 0.74));
+}
+
+.version {
+ margin-right: 12px;
+ display: inline-block;
+ padding-right: 12px;
+ border-right: 1px var(--about-arc-version-section-border-right-color, rgba(0, 0, 0, 0.14)) solid;
+}
+
+.version-meta a {
+ color: inherit;
+ text-decoration: inherit;
+}
+
+.version-meta a:hover {
+ text-decoration: underline;
+}
+
+.open-external-icon {
+ width: 16px;
+ height: 16px;
+}
+
+.updates-section {
+ width: 100%;
+ max-width: 700px;
+ margin: 40px auto;
+ background-color: var(--about-arc-updates-section-background-color, #fff);
+ padding: 24px;
+ border: 1px var(--about-arc-updates-section-border-color, #e5e5e5) solid;
+}
+
+.update-status {
+ display: flex;
+ flex-direction: row;
+ align-items: center;
+}
+
+.update-message {
+ flex: 1;
+}
+
+.heart {
+ color: var(--about-arc-updated-heart-color, #FF5722);
+ margin-left: 8px;
+}
+
+.update-settings {
+ margin: 24px auto;
+}
+
+.author-line {
+ display: flex;
+ flex-direction: column;
+ justify-content: center;
+ align-items: center;
+ margin: 40px auto;
+}
+
+.powered {
+ display: block;
+ width: 180px;
+ height: 39px;
+}
+
+.error-code {
+ max-width: 360px;
+ margin: 20px auto;
+ background-color: var(--about-arc-error-code-background-color, #EF9A9A);
+ padding: 20px;
+ user-select: text;
+}
+
+.release-channel {
+ margin-top: 40px;
+}
+
+.channel-selector {
+ width: 100%;
+ margin: 0;
+}
diff --git a/src/app/styles/api-console.css b/src/app/styles/api-console.css
new file mode 100644
index 00000000..39bcdfb2
--- /dev/null
+++ b/src/app/styles/api-console.css
@@ -0,0 +1,29 @@
+.menu-title {
+ background-color: var(--arc-menu-title-background-color);
+ color: var(--arc-menu-title-color);
+ height: 56px;
+ display: flex;
+ align-items: center;
+ border-bottom: 1px solid #e5e5e5;
+ padding: 20px;
+ box-sizing: border-box;
+}
+
+.api-pages {
+ margin-left: 24px;
+}
+
+nav {
+ display: flex;
+ flex-direction: column;
+}
+
+api-navigation {
+ flex: 1;
+ overflow: auto;
+}
+
+.api-version-selector {
+ --anypoint-dropdown-menu-background-color: var(--arc-toolbar-background);
+ --anypoint-dropdown-menu-label-color: var(--arc-toolbar-color);
+}
diff --git a/src/app/styles/app.css b/src/app/styles/app.css
new file mode 100644
index 00000000..a5b45625
--- /dev/null
+++ b/src/app/styles/app.css
@@ -0,0 +1,56 @@
+main > .screen {
+ flex: 1;
+ height: 100vh;
+ overflow: hidden;
+ margin: 12px 20px;
+}
+
+main > .screen.scroll {
+ overflow: auto;
+}
+
+.environment-selector {
+ display: flex;
+ align-items: center;
+ cursor: pointer;
+ font-size: 1.2rem;
+}
+
+.env-dropdown {
+ transform: rotate(90deg);
+ margin-left: 8px;
+}
+
+variables-overlay {
+ color: initial;
+}
+
+#passwordPrompt {
+ min-width: 460px;
+}
+
+#passwordPrompt anypoint-masked-input {
+ width: auto;
+}
+
+.bottom-sheet-container {
+ width: var(--bottom-sheet-width, 100%);
+ max-width: var(--bottom-sheet-max-width, 700px);
+ right: var(--bottom-sheet-right, 40px);
+ left: var(--bottom-sheet-left, auto);
+}
+
+.arc-context-menu {
+ position: absolute;
+ color: var(--anypoint-listbox-color);
+ background-color: var(--anypoint-listbox-background-color, #FAFAFA);
+ box-shadow: 0 6px 10px 0 rgba(0, 0, 0, 0.14), 0 1px 18px 0 rgba(0, 0, 0, 0.12), 0 3px 5px -1px rgba(0, 0, 0, 0.4);
+ z-index: 100;
+ padding: 8px 0;
+}
+
+.arc-context-menu .context-item,
+.arc-context-menu .context-item {
+ min-height: 40px;
+ padding-left: 32px;
+}
diff --git a/src/app/styles/common.css b/src/app/styles/common.css
new file mode 100644
index 00000000..d0b678e3
--- /dev/null
+++ b/src/app/styles/common.css
@@ -0,0 +1,162 @@
+body,
+html {
+ /* background-color: #F5F5F5; */
+ height: 100%;
+ margin: 0;
+ padding: 0;
+ font-family: 'Roboto', 'Noto', sans-serif;
+ font-size: 16px;
+ user-select: none;
+ display: flex;
+ flex-direction: column;
+ margin: 0;
+ padding: 0;
+ background-color: #fff;
+}
+
+#app {
+ display: flex;
+ flex-direction: column;
+ flex: 1;
+ height: 100%;
+ overflow: hidden;
+ box-sizing: border-box;
+}
+
+.app-loader {
+ display: flex;
+ flex-direction: column;
+ flex: 1;
+ align-items: center;
+ justify-content: center;
+}
+
+.app-loader .message {
+ font-size: 24px;
+ font-weight: 300;
+}
+
+h2 {
+ font-size: var(--theme-h2-font-size, 56px);
+ font-weight: var(--theme-h2-font-weight, 200);
+ color: var(--theme-h1-color, currentColor);
+}
+
+h2.title {
+ font-size: 1.25rem;
+ line-height: 2rem;
+ font-weight: 500;
+}
+
+.title-line {
+ padding: 60px 0;
+ margin: 0;
+ text-align: center;
+}
+
+header {
+ height: 56px;
+ background-color: var(--arc-toolbar-background);
+ color: var(--arc-toolbar-color);
+ display: flex;
+ flex-direction: row;
+ align-items: center;
+ border-bottom: 1px solid #e5e5e5;
+ padding: 20px;
+ box-sizing: border-box;
+}
+
+main {
+ flex: 1;
+ display: flex;
+ flex-direction: column;
+ height: 100%;
+ overflow: auto;
+}
+
+.content {
+ display: flex;
+ flex-direction: row;
+ height: 100%;
+ overflow: hidden;
+}
+
+nav {
+ width: 360px;
+ position: relative;
+}
+
+nav.minimized {
+ width: 56px !important;
+ border-right: 1px solid #e5e5e5;
+}
+
+.nav-resize-rail {
+ background-color: transparent;
+ width: 8px;
+ right: -4px;
+ top: 0;
+ bottom: 0;
+ position: absolute;
+ cursor: col-resize;
+}
+
+.page {
+ flex: 1;
+}
+
+.full-page {
+ height: 100%;
+ width: 100%;
+}
+
+.spacer {
+ flex: 1;
+ display: block;
+}
+
+.drop-info,
+.file-processing {
+ display: none;
+ position: absolute;
+ top: 0;
+ left: 0;
+ right: 0;
+ bottom: 0;
+ background-color: rgba(255, 255, 255, 0.84);
+ align-items: center;
+ justify-content: center;
+ flex-direction: column;
+}
+
+.drop-info {
+ box-sizing: border-box;
+ border-width: 2px;
+ border-color: transparent;
+ border-style: dashed;
+}
+
+.drop-target .drop-info,
+.processing-domain .file-processing {
+ display: flex;
+}
+
+.drop-target .drop-info {
+ border-color: var(--file-drop-zone-border-color-active, #8f1d5a);
+}
+
+.drop-info > * {
+ pointer-events: none;
+}
+
+.drop-icon {
+ width: 80px;
+ height: 80px;
+ color: #8f1d5a;
+}
+
+.drop-message,
+.processing-message {
+ font-size: 2rem;
+ font-weight: 300;
+}
diff --git a/src/app/styles/data-migration.css b/src/app/styles/data-migration.css
new file mode 100644
index 00000000..42eaf8e5
--- /dev/null
+++ b/src/app/styles/data-migration.css
@@ -0,0 +1,14 @@
+.app-loader.error {
+ background-color: #F44336;
+ color: #fff;
+}
+
+.error-stack {
+ white-space: pre;
+}
+
+.error-message,
+.error-stack,
+.selectable {
+ user-select: text;
+}
diff --git a/src/app/styles/license.css b/src/app/styles/license.css
new file mode 100644
index 00000000..2762f240
--- /dev/null
+++ b/src/app/styles/license.css
@@ -0,0 +1,9 @@
+summary {
+ padding: 1rem;
+ border-bottom: 1px #e5e5e5 solid;
+ margin-bottom: 12px;
+}
+
+.preformatted {
+ white-space: pre-line;
+}
diff --git a/src/app/styles/popup-menu.css b/src/app/styles/popup-menu.css
new file mode 100644
index 00000000..6e2a9599
--- /dev/null
+++ b/src/app/styles/popup-menu.css
@@ -0,0 +1,11 @@
+html,
+body {
+ margin: 0;
+ padding: 0;
+}
+
+body {
+ background-color: #fff;
+ font-family: Roboto, sans-serif;
+ font-size: 15px;
+}
diff --git a/src/app/styles/search-bar.css b/src/app/styles/search-bar.css
new file mode 100644
index 00000000..3c5d5186
--- /dev/null
+++ b/src/app/styles/search-bar.css
@@ -0,0 +1,55 @@
+body,
+html {
+ height: 100%;
+ font-family: 'Roboto', 'Noto', sans-serif;
+ font-size: 16px;
+ user-select: none;
+ margin: 0;
+ padding: 0;
+ background-color: var(--search-bar-background-color, #fff);
+ overflow: hidden;
+}
+
+#app {
+ display: flex;
+ flex-direction: row;
+ align-items: center;
+ padding: 8px;
+ z-index: 100;
+
+ --anypoint-input-border-color: transparent;
+
+ /* border: 1px #e5e5e5 solid;
+ border-radius: 0 0 6px 6px;
+ box-shadow: var(--anypoint-dropdown-shadow); */
+}
+
+.counters {
+ color: var(--search-bar-counters-color, #9E9E9E);
+ font-size: 14px;
+}
+
+.controls {
+ display: flex;
+ flex-direction: row;
+ align-items: center;
+ margin-left: 8px;
+ padding-left: 8px;
+}
+
+anypoint-icon-button {
+ color: var(--search-bar-action-button-color, #616161);
+ width: 36px;
+ height: 36px;
+}
+
+anypoint-input {
+ flex: 1;
+ width: auto;
+ margin: 0;
+}
+
+.close-icon {
+ width: 20px;
+ height: 20px;
+}
diff --git a/src/app/styles/themes.css b/src/app/styles/themes.css
new file mode 100644
index 00000000..53fc073f
--- /dev/null
+++ b/src/app/styles/themes.css
@@ -0,0 +1,28 @@
+.themes-content {
+ max-width: 900px;
+ margin: 0 24px;
+}
+
+.add-form {
+ display: flex;
+ flex-direction: row;
+ align-items: center;
+}
+
+.add-form anypoint-input {
+ flex: 1;
+}
+
+.selection-actions {
+ display: flex;
+ flex-direction: row;
+ align-items: center;
+}
+
+.remove-theme {
+ margin-left: 8px;
+}
+
+anypoint-dropdown-menu {
+ width: 600px;
+}
diff --git a/src/app/themes.html b/src/app/themes.html
new file mode 100644
index 00000000..7640ac15
--- /dev/null
+++ b/src/app/themes.html
@@ -0,0 +1,15 @@
+
+
+
+ ARC Themes selector
+
+
+
+
diff --git a/src/arc-electron.js b/src/arc-electron.js
deleted file mode 100644
index e6531281..00000000
--- a/src/arc-electron.js
+++ /dev/null
@@ -1,891 +0,0 @@
-import { LitElement, html } from '../web_modules/lit-element/lit-element.js';
-import { ArcAppMixin } from '../web_modules/@advanced-rest-client/arc-app-mixin/arc-app-mixin.js';
-import { Jexl } from '../web_modules/jexl/lib/Jexl.js';
-import { moreVert } from '../web_modules/@advanced-rest-client/arc-icons/ArcIcons.js';
-import PouchDB from '../web_modules/pouchdb/dist/pouchdb.js';
-import PouchQuickSearch from
-'../web_modules/@advanced-rest-client/pouchdb-quick-search/dist/pouchdb.quick-search.min.js';
-import marked from '../web_modules/marked/lib/marked.js';
-import styles from '../web_modules/@advanced-rest-client/arc-app-mixin/AppStyles.js';
-import '../web_modules/@api-components/api-candidates-dialog/api-candidates-dialog.js';
-import '../web_modules/@advanced-rest-client/arc-models/client-certificate-model.js';
-import '../web_modules/@anypoint-web-components/anypoint-dialog/anypoint-dialog.js';
-import '../web_modules/@anypoint-web-components/anypoint-dialog/anypoint-dialog-scrollable.js';
-import '../web_modules/@advanced-rest-client/client-certificates-panel/certificate-import.js';
-import './electron-http-transport/electron-http-transport.js';
-import poweredIcon from './poweredby.js';
-window.PouchDB = PouchDB;
-window.PouchQuickSearch = PouchQuickSearch;
-window.PouchDB.plugin(window.PouchQuickSearch);
-window.marked = marked;
-window.Jexl = Jexl;
-/* eslint-disable max-len */
-/**
- * Main component for ARC electron app.
- *
- * @appliesMixin ArcAppMixin
- */
-class ArcElectron extends ArcAppMixin(LitElement) {
- static get styles() {
- return styles;
- }
-
- static get properties() {
- return {
- /**
- * When true it is rendering API console view.
- */
- isApiConsole: { type: Boolean },
- /**
- * When set the certificates import panel is currently rendered.
- * @type {Object}
- */
- ccImportOpened: { type: Boolean },
- };
- }
-
- get apic() {
- return this.shadowRoot.querySelector('#apic');
- }
-
- constructor() {
- super();
- this._openExternalHandler = this._openExternalHandler.bind(this);
- this._copyContentHandler = this._copyContentHandler.bind(this);
- this._exchangeAssetHandler = this._exchangeAssetHandler.bind(this);
- this._activeThemeHandler = this._activeThemeHandler.bind(this);
- this._apiDataHandler = this._apiDataHandler.bind(this);
- this._certCcImportHandler = this._certCcImportHandler.bind(this);
- /* global log */
- this.log = log;
- this.sysVars = process.env;
- this.withEncrypt = true;
- this.clientCertificateImport = true;
- }
-
- connectedCallback() {
- super.connectedCallback();
- window.addEventListener('open-external-url', this._openExternalHandler);
- window.addEventListener('content-copy', this._copyContentHandler);
- window.addEventListener('theme-activated', this._activeThemeHandler);
- window.addEventListener('api-data-ready', this._apiDataHandler);
- this.addEventListener('process-exchange-asset-data', this._exchangeAssetHandler);
- window.addEventListener('client-certificate-import', this._certCcImportHandler);
- }
-
- disconnectedCallback() {
- super.disconnectedCallback();
- window.removeEventListener('open-external-url', this._openExternalHandler);
- window.removeEventListener('content-copy', this._copyContentHandler);
- window.removeEventListener('theme-activated', this._activeThemeHandler);
- window.removeEventListener('api-data-ready', this._apiDataHandler);
- window.removeEventListener('client-certificate-import', this._certCcImportHandler);
- }
-
- _routeDataChanged() {
- switch (this.page) {
- case 'api-console': this._setupApiConsole(this.routeParams); break;
- default: super._routeDataChanged();
- }
- }
-
- async _pageChanged(page) {
- let id;
- let path;
- let scope;
- switch (page) {
- case 'api-console':
- await this._loadApic()
- return;
- case 'about':
- id = 'about-arc-electron';
- path = 'about-arc-electron/about-arc-electron';
- scope = '@advanced-rest-client';
- break;
- case 'exchange-search':
- id = 'exchange-search-panel';
- path = 'exchange-search-panel/exchange-search-panel';
- scope = '@advanced-rest-client';
- break;
- case 'rest-projects':
- id = 'rest-apis-list-panel';
- path = 'rest-apis-list-panel/rest-apis-list-panel';
- scope = '@advanced-rest-client';
- break;
- case 'themes-panel':
- id = 'themes-panel';
- path = 'themes-panel/themes-panel';
- scope = '@advanced-rest-client';
- break;
- case 'hosts-rules':
- id = 'host-rules-editor';
- path = 'host-rules-editor/host-rules-editor';
- scope = '@advanced-rest-client';
- break;
- case 'client-certificates':
- id = 'client-certificates-panel';
- path = 'client-certificates-panel/client-certificates-panel';
- scope = '@advanced-rest-client';
- break;
- }
- if (id) {
- const cls = window.customElements.get(id);
- if (cls) {
- return;
- }
- try {
- await this._loadComponent(path, scope)
- } catch (cmp) {
- this._reportComponentLoadingError(cmp);
- }
- } else {
- await super._pageChanged(page);
- }
- }
-
- _handleNavigation(e) {
- const { detail } = e;
- if (detail.base === 'api-console') {
- this.page = detail.base;
- this.routeParams = { id: detail.id };
- this._telemetryScreen();
- } else {
- super._handleNavigation(e);
- }
- }
-
- _telemetryScreen() {
- let screenName = this.page;
- switch (this.page) {
- case 'api-console': screenName = 'API Console'; break;
- case 'themes-panel': screenName = 'Themes panel'; break;
- case 'exchange-search': screenName = 'Exchange search'; break;
- case 'hosts-rules': screenName = 'Hosts rules'; break;
- case 'rest-projects': screenName = 'REST APIs list'; break;
- case 'about': screenName = 'About'; break;
- default: return super._telemetryScreen();
- }
- this.dispatchEvent(new CustomEvent('send-analytics', {
- composed: true,
- cancelable: true,
- bubbles: true,
- detail: {
- type: 'screenview',
- name: screenName
- }
- }));
- }
- /**
- * Navigates to themes panel
- */
- openThemesPanel() {
- this._dispatchNavigate({
- base: 'themes-panel'
- });
- }
- /**
- * Opens the host rules editor.
- */
- openHostRules() {
- this._dispatchNavigate({
- base: 'hosts-rules'
- });
- }
- /**
- * Navigates to Exchange search panel
- */
- openExchangeSearch() {
- this._dispatchNavigate({
- base: 'exchange-search'
- });
- }
- /**
- * Navigates to about screen
- */
- openAbout() {
- this._dispatchNavigate({
- base: 'about'
- });
- }
-
- _openWebUrlHandler(e) {
- ipc.send('open-web-url', e.detail.url, e.detail.purpose);
- }
-
- _requestAuthToken(interactive, scope) {
- if (this.__requestingToken) {
- return;
- }
- this.__requestingToken = true;
- /* global ipc */
- ipc.send('oauth-2-get-token', {
- interactive: interactive,
- scopes: scope
- });
- const context = this;
- let rejected;
- function resolved(sender, token) {
- const tokenValue = token ? token.accessToken : undefined;
- context.__requestingToken = false;
- ipc.removeListener('oauth-2-token-ready', resolved);
- ipc.removeListener('oauth-2-token-error', rejected);
- context.dispatchEvent(new CustomEvent('google-signin-success', {
- composed: true,
- cancelable: true,
- bubbles: true,
- detail: {
- scope: scope,
- token: tokenValue
- }
- }));
- context.driveAccessToken = tokenValue;
- }
- rejected = function() {
- context.__requestingToken = false;
- ipc.removeListener('oauth-2-token-ready', resolved);
- ipc.removeListener('oauth-2-token-error', rejected);
- context.dispatchEvent(new CustomEvent('google-signout', {
- composed: true,
- cancelable: true,
- bubbles: true,
- detail: {
- scope: scope
- }
- }));
- };
- ipc.on('oauth-2-token-ready', resolved);
- ipc.on('oauth-2-token-error', rejected);
- }
- /**
- * Handles `open-external-url` event from ARC components.
- * @param {CustomEvent} e
- */
- _openExternalHandler(e) {
- e.preventDefault();
- /* global ipcRenderer */
- ipcRenderer.send('open-external-url', e.detail.url);
- }
- /**
- * Handles new window open request.
- */
- onNewWindow() {
- ipcRenderer.send('new-window');
- }
- /**
- * Handles `clipboard-copy` event from ARC components.
- * The `clipboard` api is loaded in the preload script.
- *
- * @param {CustomEvent} e
- */
- _copyContentHandler(e) {
- /* global clipboard */
- clipboard.writeText(e.detail.value);
- e.preventDefault();
- }
- /**
- * Installs pading update.
- */
- updateInstall() {
- ipcRenderer.send('install-update');
- }
-
- notifyError(message) {
- const toast = this.shadowRoot.querySelector('#errorToast');
- toast.text = message;
- toast.opened = true;
- }
- /**
- * Handler for `popup-menu`. Sends command to the IO process.
- * IO process informs windows to hide the menu.
- * @param {CustomEvent} e
- */
- _popupMenuHandler(e) {
- const { type } = e.detail;
- let sizing;
- const menu = this.shadowRoot.querySelector('arc-menu');
- if (menu) {
- const rect = menu.getBoundingClientRect();
- sizing = {
- height: rect.height,
- width: rect.width
- };
- }
- ipcRenderer.send('popup-app-menu', type, sizing);
- }
-
- processExternalFile(file) {
- if (!file) {
- throw new Error('"file" argument is required.');
- }
- }
- /**
- * Opens onboarding element.
- */
- openOnboarding() {
- const node = this.shadowRoot.querySelector('arc-onboarding');
- node.opened = true;
- }
-
- async _setupApiConsole(params) {
- if (!params) {
- return;
- }
- const { id, version } = params;
- if (!id) {
- return;
- }
- try {
- await this._loadApic();
- // this.apiSelected = undefined;
- // this.apiSelectedType = undefined;
- this.isApiConsole = true;
- await this.apic.open(id, version);
- this.apiSelected = 'summary';
- this.apiSelectedType = 'summary';
- } catch (e) {
- this.apiProcessing = false;
- this.isApiConsole = false;
- this.notifyError(e.message);
- }
- }
-
- async _loadApic() {
- try {
- this.page = 'api-console';
- await import('./apic-electron/apic-electron.js');
- this._loadingSources = false;
- } catch (cause) {
- this._loadingSources = false;
- this._reportComponentLoadingError('apic-electron');
- throw cause;
- }
- }
-
- async _setApiData(api, type) {
- await this._loadApic();
- const apic = this.apic;
- apic.unresolvedAmf = api;
- apic.apiType = type;
- this.isApiConsole = (true);
- this.apiSelected = undefined;
- this.apiSelectedType = undefined;
- setTimeout(() => {
- this.apiSelected = 'summary';
- this.apiSelectedType = 'summary';
- });
- }
-
- async _exchangeAssetHandler(e) {
- if (e.defaultPrevented) {
- return;
- }
- e.preventDefault();
- const asset = e.detail;
- let file;
- const types = ['fat-raml', 'raml', 'oas'];
- for (let i = 0, len = asset.files.length; i < len; i++) {
- if (types.indexOf(asset.files[i].classifier) !== -1) {
- file = asset.files[i];
- break;
- }
- }
- if (!file || !file.externalLink) {
- this.notifyError('RAML data not found in the asset.');
- return;
- }
- try {
- await this._loadApic();
- const e = this._dispatchExchangeApiEvent(file);
- if (!e.defaultPrevented) {
- this.notifyError('API data processor not found.');
- return;
- }
- this.isApiConsole = true;
- this.apiProcessing = true;
- this._dispatchNavigate({
- base: 'api-console'
- });
- const api = await e.detail.result;
- this._setApiData(api.model, api.type.type);
- } catch (cause) {
- this.notifyError(cause.message);
- }
- }
-
- _dispatchExchangeApiEvent(file) {
- const e = new CustomEvent('api-process-link', {
- bubbles: true,
- composed: true,
- cancelable: true,
- detail: {
- url: file.externalLink,
- mainFile: file.mainFile,
- md5: file.md5,
- packaging: file.packaging
- }
- });
- this.dispatchEvent(e);
- return e;
- }
-
- _apiVersionMenuChanged(e) {
- const { value } = e.detail;
- if (!value) {
- return;
- }
- const id = this.apiInfo._id;
- const params = {
- id,
- version: value
- };
- this._setupApiConsole(params);
- }
-
- /**
- * Closes API console view
- */
- closeApiConsole() {
- this.isApiConsole = (false);
- this.page = 'exchange-search';
- }
-
- /**
- * Handler for the "back" icon click in main navigation.
- */
- _backHandler() {
- if (this.isApiConsole) {
- this.isApiConsole = false;
- }
- super._backHandler();
- }
- /**
- * Saves current API.
- */
- saveApi() {
- this.apic.save();
- }
-
- async _apiActionMenuChanged(e) {
- const selected = e.detail.value;
- if (selected === undefined || selected === -1) {
- return;
- }
- const { target } = e;
- const item = target.selectedItem;
- const action = item.dataset.action;
- const apic = this.apic;
- switch (action) {
- case 'delete':
- await apic.delete();
- break;
- case 'delete-version':
- await apic.deleteVersion(this.apiVersion);
- break;
- case 'save-oas':
- apic.saveAs('oas');
- break;
- case 'save-raml':
- apic.saveAs('raml');
- break;
- case 'upload-exchange':
- this.log.info('Not yet supported.');
- break;
- }
- target.selected = undefined;
- }
-
- _exchangeTokenHandler(e) {
- e.detail.clientSecret = '5d02cE95028E4Dc08A40907a0A4883fC';
- }
-
- _apiPropertyHandler(e) {
- const { value } = e.detail;
- switch (e.type) {
- case 'apiprocessing-changed':
- this.apiProcessing = value;
- break;
- case 'apiversion-changed':
- this.apiVersion = value;
- break;
- case 'apiinfo-changed':
- this.apiInfo = value;
- break;
- case 'versions-changed':
- this.apiVersions = value;
- break;
- case 'multiversion-changed':
- this.apiMultiVersionVersion = value;
- break;
- case 'saved-changed':
- this.apiIsSaved = value;
- break;
- case 'cansave-changed':
- this.canSaveApi = value;
- break;
- case 'versionsaved-changed':
- this.apiVersionSaved = value;
- break;
- }
- this.requestUpdate();
- }
- /**
- * Initialized the tutorial if needed.
- */
- async initTutorial() {
- /* global versionInfo */
- const major = versionInfo.appVersion.split('.')[0];
- const cnf = this.config;
- const passed = cnf.finishedOnboarding || [];
- if (passed.indexOf(major) !== -1) {
- return;
- }
- try {
- await this._loadComponent('arc-onboarding/arc-onboarding', '@advanced-rest-client');
- } catch (cmp) {
- this.log.error(`Unable to load ${cmp}`);
- return;
- }
- const element = document.createElement('arc-onboarding');
- element.addEventListener('tutorial-close', this._finalizeTutorial.bind(this));
- element.dataset.major = major;
- document.body.appendChild(element);
- element.opened = true;
- }
-
- _finalizeTutorial(e) {
- const cnf = this.config;
- const passed = cnf.finishedOnboarding || [];
- passed.push(e.target.dataset.major);
- const ev = new CustomEvent('settings-changed', {
- bubbles: true,
- composed: true,
- cancelable: true,
- detail: {
- name: 'finishedOnboarding',
- value: passed
- }
- });
- this.dispatchEvent(ev);
- }
-
- _activeThemeHandler(e) {
- if (e.detail === 'advanced-rest-client/arc-electron-anypoint-theme') {
- if (!this.compatibility) {
- this.compatibility = true;
- }
- } else {
- if (this.compatibility) {
- this.compatibility = false;
- }
- }
- }
-
- async _apiDataHandler(e) {
- const { model, type } = e.detail;
- await this._setApiData(model, type.type);
- this._dispatchNavigate({
- base: 'api-console'
- });
- }
-
- _platformHelpersTemplate() {
- return html`
- ${this.importExportTemplate({ electron: true })}
- ${this.appMessagesLogicTemplate('electron')}
- `;
- }
-
- /**
- * Opens cliet cetrificates panel by setting `page` to `client-certificates`.
- */
- openClientCertificates() {
- this.page = 'client-certificates';
- }
-
- _certCcImportHandler() {
- this.ccImportOpened = true;
- }
-
- _closeCcImportHandler() {
- this.ccImportOpened = false;
- }
-
- render() {
- return html`
- ${this.applicationTemplate()}
- ${this.apiCandidatedViewTemplate()}
- ${this._ccImportDialogTemplate()}
- Save API
- ` : ''}
- ${renderMultiVersion ? html`
-
- API version
-
- ${apiVersions.map((item) => html`
- ${item}
- `)}
-
- ` : ''}
- ${renderSaveVersion ? html`
- Save API version
- ` : ''}
- ${apiIsSaved ? html`
-
-
- ${moreVert}
-
-
- Delete API
- ${apiMultiVersionVersion ? html`
- Delete version
- ` : ''}
-
-
-
- ` : ''}
- `;
- }
-
- menuTemplate() {
- if (this.isApiConsole) {
- return this.apicNavigationTemplate();
- }
- return super.menuTemplate();
- }
-
- apicNavigationTemplate() {
- const {
- compatibility,
- apiProcessing,
- apiSelected,
- apiSelectedType
- } = this;
- return html`
-
- ${apiProcessing ? html`
` : ''}
-
-
- Import a certificate
-
-
-
- `;
- }
-}
-window.customElements.define('arc-electron', ArcElectron);
diff --git a/src/arc-menu-window/app-menu-preload.js b/src/arc-menu-window/app-menu-preload.js
deleted file mode 100644
index 7834b145..00000000
--- a/src/arc-menu-window/app-menu-preload.js
+++ /dev/null
@@ -1,8 +0,0 @@
-const { ipcRenderer: ipc } = require('electron');
-const { ThemeManager } = require('../../scripts/packages/themes-manager/renderer');
-const { ArcPreferencesProxy } = require('../../scripts/packages/arc-preferences/renderer');
-process.once('loaded', () => {
- global.ipc = ipc;
- global.ThemeManager = ThemeManager;
- global.ArcPreferencesProxy = ArcPreferencesProxy;
-});
diff --git a/src/arc-menu-window/arc-menu-window.html b/src/arc-menu-window/arc-menu-window.html
deleted file mode 100644
index ee35c222..00000000
--- a/src/arc-menu-window/arc-menu-window.html
+++ /dev/null
@@ -1,118 +0,0 @@
-
-
-
- Advanced REST client
-
-
-
-
- Task manager - Advanced REST client
-
-
-
-
-
- ${this._columTemplate('title', 'title', 'Process', orderTitle, orderDirection)}
- ${this._columTemplate('pid', 'pid', 'Pid', orderPid, orderDirection)}
- ${this._columTemplate('cpu-usage', 'cpu-usage', 'CPU', orderCpu, orderDirection)}
- ${this._columTemplate('memory-working-size', 'memory-working', 'Memory', orderMemWorkingSize, orderDirection)}
- ${this._columTemplate('memory-private-size', 'memory-private', 'Private memory',
- orderMemPrivateSize, orderDirection)}
- ${this._columTemplate('memory-shared-size', 'memory-shared', 'Shared memory', orderMemSharedSize, orderDirection)}
-
- ${this._itemsTemplate()}`;
- }
-
- _columTemplate(cls, prop, label, ordered, dir) {
- const icon = dir === 'asc' ? arrowDropDown : arrowDropUp;
- return html`
- ${label}
- ${ordered ? html`${icon} ` : ''}
-
`;
- }
-
- _itemsTemplate() {
- const items = this.items || [];
- return html`
- ${repeat(items, (i) => i.pid, (item) => html`
-
- ${item.title}
- ${item.pid}
- ${item.cpu.usage}
- ${item.memory.workingSetSize}
- ${item.memory.privateBytes}
- ${item.memory.sharedBytes}
-
- `)}
- `;
- }
-
- static get properties() {
- return {
- // List of items to display in the table.
- items: { type: Array },
- // True if the window is active.
- active: { type: Boolean },
- // True if ordering by title is enabled
- orderTitle: { type: Boolean },
- // True if ordering by pid is enabled
- orderPid: { type: Boolean },
- // True if ordering by cpu is enabled
- orderCpu: { type: Boolean },
- // True if ordering by memory working size is enabled
- orderMemWorkingSize: { type: Boolean },
- // True if ordering by memory private size is enabled
- orderMemPrivateSize: { type: Boolean },
- // True if ordering by memory shared size is enabled
- orderMemSharedSize: { type: Boolean },
- // Order direction. `acs` or `desc`.
- orderDirection: {
- type: String,
- value: 'asc'
- },
- // Order property name
- orderProperty: { type: String },
- mainId: { type: Number },
- thisPid: { type: Number }
- };
- }
-
- connectedCallback() {
- if (super.connectedCallback) {
- super.connectedCallback();
- }
- this.active = true;
- setTimeout(() => {
- this.setupGlobalVariables();
- this.refresh();
- });
- this.loadTheme();
- }
-
- disconnectedCallback() {
- if (super.disconnectedCallback) {
- super.disconnectedCallback();
- }
- this.active = false;
- }
-
- /**
- * Loads bar components.
- *
- * @return {Promise}
- */
- async loadTheme() {
- /* global ThemeManager */
- const mgr = new ThemeManager();
- await mgr.loadTheme('advanced-rest-client/arc-electron-default-theme');
- }
-
- setupGlobalVariables() {
- this.mainId = appProcess.pid;
- this.thisPid = appProcess.pid;
- }
-
- refresh() {
- if (!this.active) {
- return;
- }
- let metrics = app.getAppMetrics();
- metrics = this.translateMetrics(metrics);
- metrics.sort(this._sortItems.bind(this));
- this.items = metrics;
- setTimeout(() => this.refresh(), 2000);
- }
-
- /**
- * Translates electron app metrics into the data model.
- *
- * @param {Array} metrics List of current metrics
- * @return {Array} Internal data model.
- */
- translateMetrics(metrics) {
- const result = metrics.map((metric) => {
- const cpu = this.translateCpuMetrics(metric.cpu);
- let memory;
- // https://github.com/electron/electron/issues/16179
- if (metric.memory) {
- memory = this.translateMemoryMetrics(metric.memory);
- } else {
- memory = this._emptyMemoryInfo();
- }
- const title = this.translateMetricTitle(metric.type, metric.pid);
- return {
- pid: metric.pid,
- memory,
- cpu,
- title
- };
- });
- return result;
- }
- /**
- * Translates `type` property of the metric to a title to display
- * @param {String} type Metric type value
- * @param {Number} pid OS process id
- * @return {String} Title related to the type.
- */
- translateMetricTitle(type, pid) {
- if (this.mainId === pid) {
- return 'Application main thread';
- }
- if (this.thisPid === pid) {
- return 'Task manager';
- }
- const windows = BrowserWindow.getAllWindows();
- for (let i = 0; i < windows.length; i++) {
- if (windows[i].webContents.getOSProcessId() === pid) {
- const title = windows[i].getTitle();
- if (title) {
- return title;
- }
- }
- }
- switch (type) {
- case 'Tab': return 'Application window';
- case 'Browser': return 'Application';
- default: return type;
- }
- }
- /**
- * Creates a data model for the CPU usage.
- *
- * @param {Object} cpu CPU metric
- * @return {Object} Data model for CPU metrics
- */
- translateCpuMetrics(cpu) {
- return {
- usage: Math.round(cpu.percentCPUUsage),
- usageCompare: cpu.percentCPUUsage
- // wakeups: cpu.idleWakeupsPerSecond
- };
- }
- /**
- * Creates a data model for memory usage metrics
- *
- * @param {Object} memory Memory metric
- * @return {Object} Memory usage metrics
- */
- translateMemoryMetrics(memory) {
- return {
- // peak: peakWorkingSetSize
- workingSetSize: this.computeBytes(memory.workingSetSize),
- workingSetSizeCompare: memory.workingSetSize,
- privateBytes: this.computeBytes(memory.privateBytes),
- privateBytesCompare: memory.privateBytes,
- sharedBytes: this.computeBytes(memory.sharedBytes),
- sharedBytesCompare: memory.sharedBytes
- };
- }
-
- _emptyMemoryInfo() {
- return {
- workingSetSize: 'unknown',
- workingSetSizeCompare: 0,
- privateBytes: 'unknown',
- privateBytesCompare: 0,
- sharedBytes: 'unknown',
- sharedBytesCompare: 0
- };
- }
- /**
- * Computes readable value of bytes usage.
- * https://stackoverflow.com/a/18650828/1127848
- *
- * @param {Number} bytes Number of bytes
- * @param {String} decimals Decimal number
- * @return {String} Size label
- */
- computeBytes(bytes, decimals) {
- if (!bytes) {
- return '0 B';
- }
- const k = 1024;
- const dm = decimals || 2;
- const sizes = ['KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
- const i = Math.floor(Math.log(bytes) / Math.log(k));
- return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
- }
-
- _computeOrderIcon(direction) {
- return direction === 'asc' ? 'arc:arrow-drop-down' : 'arc:arrow-drop-up';
- }
-
- _changeOrder(e) {
- const target = e.currentTarget;
- const property = target.dataset.orderProperty;
- if (property === this.orderProperty) {
- this.toggleOrder();
- this._sort();
- return;
- }
- this._cancelOrderProperty();
- switch (property) {
- case 'title':
- this.orderTitle = true;
- break;
- case 'pid':
- this.orderPid = true;
- break;
- case 'cpu-usage':
- this.orderCpu = true;
- break;
- case 'memory-shared':
- this.orderMemSharedSize = true;
- break;
- case 'memory-private':
- this.orderMemPrivateSize = true;
- break;
- case 'memory-working':
- this.orderMemWorkingSize = true;
- break;
- }
- this.orderProperty = property;
- this._sort();
- }
-
- _sort() {
- const items = this.items || [];
- items.sort(this._sortItems.bind(this));
- this.items = items;
- }
-
- _cancelOrderProperty() {
- const prop = this.orderProperty;
- switch (prop) {
- case 'title':
- this.orderTitle = false;
- break;
- case 'pid':
- this.orderPid = false;
- break;
- case 'cpu-usage':
- this.orderCpu = false;
- break;
- case 'memory-shared':
- this.orderMemSharedSize = false;
- break;
- case 'memory-private':
- this.orderMemPrivateSize = false;
- break;
- case 'memory-working':
- this.orderMemWorkingSize = false;
- break;
- }
- this.orderProperty = undefined;
- }
-
- toggleOrder() {
- this.orderDirection = this.orderDirection === 'asc' ? 'desc' : 'asc';
- }
-
- _sortItems(a, b) {
- const prop = this.orderProperty;
- switch (prop) {
- case 'title': return this._sortTitle(a, b);
- case 'pid': return this._sortPid(a, b);
- case 'cpu-usage': return this._sortCpu(a, b);
- case 'memory-shared': return this._sortMemory(a, b, 'sharedBytesCompare');
- case 'memory-private': return this._sortMemory(a, b, 'privateBytesCompare');
- case 'memory-working': return this._sortMemory(a, b, 'workingSetSizeCompare');
- }
- }
-
- _sortTitle(a, b) {
- const dir = this.orderDirection;
- const result = a.title.localeCompare(b.title);
- if (dir === 'desc') {
- return -result;
- }
- return result;
- }
-
- _sortPid(a, b) {
- let result = 0;
- if (a.pid > b.pid) {
- result = -1;
- }
- if (a.pid < b.pid) {
- result = 1;
- }
- if (result === 0) {
- return result;
- }
- return this.orderDirection === 'asc' ? result : -result;
- }
-
- _sortCpu(a, b) {
- let result = 0;
- if (a.cpu.usageCompare > b.cpu.usageCompare) {
- result = -1;
- }
- if (a.cpu.usageCompare < b.cpu.usageCompare) {
- result = 1;
- }
- if (result === 0) {
- return result;
- }
- return this.orderDirection === 'asc' ? result : -result;
- }
-
- _sortMemory(a, b, property) {
- let result = 0;
- const aValue = a.memory[property];
- const bValue = b.memory[property];
-
- if (aValue > bValue) {
- result = -1;
- }
- if (aValue < bValue) {
- result = 1;
- }
- if (result === 0) {
- return result;
- }
- return this.orderDirection === 'asc' ? result : -result;
- }
-}
-window.customElements.define('arc-task-manager', ArcTaskManager);
diff --git a/src/arc-task-manager/task-manager-preload.js b/src/arc-task-manager/task-manager-preload.js
deleted file mode 100644
index fb7132bd..00000000
--- a/src/arc-task-manager/task-manager-preload.js
+++ /dev/null
@@ -1,17 +0,0 @@
-const { app, BrowserWindow, process } = require('electron').remote;
-const { ThemeManager } = require('../../scripts/packages/themes-manager/renderer');
-/*
-Normally it would require to use `process.once('loaded')` to pass the global variables.
-However, the task manager window is not intend to run as the first window.
-Because of that, when the manager is triggered, the process is already loaded
-and it is safe to set up global variables right away.
-*/
-
-global.app = {
- getAppMetrics: () => app.getAppMetrics()
-};
-global.BrowserWindow = BrowserWindow;
-global.appProcess = {
- pid: process.pid
-};
-global.ThemeManager = ThemeManager;
diff --git a/src/common/ArcPreferences.js b/src/common/ArcPreferences.js
new file mode 100644
index 00000000..9a90c04a
--- /dev/null
+++ b/src/common/ArcPreferences.js
@@ -0,0 +1,126 @@
+import { EventEmitter } from 'events';
+import fs from 'fs-extra';
+import log from 'electron-log';
+
+export class ArcPreferences extends EventEmitter {
+ /**
+ * The current settings
+ * @type {any}
+ */
+ #settings = undefined;
+
+ /**
+ * @returns {any=} Prefer to call `load()` to read the data.
+ * This should be used when the data has been already read.
+ */
+ get data() {
+ return this.#settings;
+ }
+
+ /**
+ * @constructor
+ *
+ * @param {string} file The settings file name
+ */
+ constructor(file) {
+ super();
+ /**
+ * Full path to the preferences file where the data is stored.
+ * @type {String}
+ */
+ this.settingsFile = file;
+ }
+
+ /**
+ * Ensures that the file exists and reads it's content as JSON.
+ *
+ * @param {string} file Path to the file
+ * @return {Promise} Promise resolved to file content or empty object.
+ */
+ async restoreFile(file) {
+ await fs.ensureFile(file);
+ return fs.readJson(file, { throws: false });
+ }
+
+ /**
+ * Stores JSON `data` in `file`.
+ *
+ * @param {string} file Path to a file.
+ * @param {object} data JavaScript object to store.
+ * @return {Promise} Promise resolved when the `file` is updated.
+ */
+ async storeFile(file, data) {
+ await fs.outputJson(file, data);
+ }
+
+ /**
+ * Loads current settings from settings file.
+ *
+ * @return {Promise} Promise resolved to a settings file.
+ */
+ async load() {
+ if (this.#settings) {
+ return this.#settings;
+ }
+ try {
+ const data = await this.restoreFile(this.settingsFile);
+ return this.processSettings(data);
+ } catch (e) {
+ log.warn(e);
+ return this.processSettings();
+ }
+ }
+
+ /**
+ * Processes data from settings file. Creates default settings if settings
+ * file do not exists.
+ *
+ * @param {object=} data Settings read from the settings file. May be empty
+ * @return {Promise} Settings for the app.
+ */
+ async processSettings(data) {
+ if (!data || !Object.keys(data).length) {
+ const settings = await this.defaultSettings();
+ this.#settings = settings;
+ await this.store();
+ return settings;
+ }
+ this.#settings = data;
+ return data;
+ }
+
+ /**
+ * @returns {Promise} Sets the default settings object
+ */
+ async defaultSettings() {
+ return {};
+ }
+
+ /**
+ * Stores current settings to file.
+ *
+ * @return {Promise} Promise resolved when the settings are stored.
+ */
+ async store() {
+ await this.storeFile(this.settingsFile, this.#settings);
+ }
+
+ /**
+ * Updates the value by path in the settings object
+ * @param {any} settings
+ * @param {string} path The path to the data
+ * @param {any} value The value to set.
+ */
+ updateValue(settings, path, value) {
+ const parts = path.split('.');
+ const last = parts.pop();
+ let current = settings;
+ parts.forEach((part) => {
+ if (!current[part]) {
+ current[part] = {};
+ }
+ current = current[part];
+ });
+ current[last] = value;
+ }
+}
diff --git a/src/electron-http-transport/electron-http-transport.js b/src/electron-http-transport/electron-http-transport.js
deleted file mode 100644
index bff1dd4c..00000000
--- a/src/electron-http-transport/electron-http-transport.js
+++ /dev/null
@@ -1,617 +0,0 @@
-/**
- * `electron-http-transport`
- *
- * A web comonent to work with @advanced-rest-client/electron-request
- * node package in web components environment
- *
- * @customElement
- * @memberof LogicElements
- */
-class ElectronHttpTransport extends HTMLElement {
- /* global SocketRequest, ElectronRequest */
- get requestTimeout() {
- const rt = this.getAttribute('requesttimeout');
- if (!rt || isNaN(rt)) {
- return null;
- }
- return Number(rt);
- }
-
- set requestTimeout(value) {
- if (!value) {
- this.removeAttribute('requesttimeout');
- } else {
- this.setAttribute('requesttimeout', value);
- }
- }
-
- get nativeTransport() {
- return this.hasAttribute('nativetransport');
- }
-
- set nativeTransport(value) {
- if (!value) {
- this.removeAttribute('native-transport');
- } else {
- this.setAttribute('native-transport', '');
- }
- }
-
- get validateCertificates() {
- return this.hasAttribute('validatecertificates');
- }
- /**
- * When set it validates certificates during request.
- * @param {Boolean} value
- */
- set validateCertificates(value) {
- if (!value) {
- this.removeAttribute('validatecertificates');
- } else {
- this.setAttribute('validatecertificates', '');
- }
- }
- /**
- * When not set the request object won't follow redirects.
- * @param {Boolean} value
- */
- set followRedirects(value) {
- if (!value) {
- this.removeAttribute('followredirects');
- } else {
- this.setAttribute('followredirects', '');
- }
- }
-
- get followRedirects() {
- return this.hasAttribute('followredirects');
- }
- /**
- * When set the HTTP client adds default headers, like cURL does
- * @param {Boolean} value
- */
- set defaultHeaders(value) {
- if (!value) {
- this.removeAttribute('defaultheaders');
- } else {
- this.setAttribute('defaultheaders', '');
- }
- }
-
- get defaultHeaders() {
- return this.hasAttribute('defaultheaders');
- }
- /**
- * A limit of characters to include into the `sentHttpMessage` property
- * of the request object. 0 to disable limit. Default to 2048.
- * @param {Number} value
- */
- set sentMessageLimit(value) {
- if (!value) {
- this.removeAttribute('sentmessagelimit');
- } else {
- this.setAttribute('sentmessagelimit', value);
- }
- }
-
- get sentMessageLimit() {
- const v = this.getAttribute('sentmessagelimit');
- if (!v || isNaN(v)) {
- return undefined;
- }
- return Number(v);
- }
-
- constructor() {
- super();
- // Socket handlers
- this._loadStartHandler = this._loadStartHandler.bind(this);
- this._firstByteHandler = this._firstByteHandler.bind(this);
- this._loadEndHandler = this._loadEndHandler.bind(this);
- this._beforeRedirectHandler = this._beforeRedirectHandler.bind(this);
- this._headersReceivedHandler = this._headersReceivedHandler.bind(this);
- this._loadHandler = this._loadHandler.bind(this);
- this._errorHandler = this._errorHandler.bind(this);
- // Host data handlers
- this._ruleUpdated = this._ruleUpdated.bind(this);
- this._ruleDeleted = this._ruleDeleted.bind(this);
- // Transport control
- this._onTransportRequested = this._onTransportRequested.bind(this);
- this._abortHandler = this._abortHandler.bind(this);
- // Local properties
- this._connections = {};
- }
-
- connectedCallback() {
- document.body.addEventListener('transport-request', this._onTransportRequested);
- document.body.addEventListener('abort-api-request', this._abortHandler);
- window.addEventListener('host-rules-changed', this._ruleUpdated);
- window.addEventListener('host-rules-deleted', this._ruleDeleted);
- }
-
- disconnectedCallback() {
- document.body.removeEventListener('transport-request', this._onTransportRequested);
- document.body.removeEventListener('abort-api-request', this._abortHandler);
- window.addEventListener('host-rules-changed', this._ruleUpdated);
- window.addEventListener('host-rules-deleted', this._ruleDeleted);
- }
-
- _abortHandler(e) {
- const id = e.detail.id;
- const info = this._connections[id];
- if (!info) {
- return;
- }
- e.preventDefault();
- info.connection.abort();
- info.aborted = true;
- }
-
- _onTransportRequested(e) {
- if (e.defaultPrevented) {
- return;
- }
- e.preventDefault();
- e.stopPropagation();
- this.run(e.detail);
- }
- /**
- * Runs the request with Electron's `SocketRequest` class.
- * @param {Object} request ARC request object
- * @param {?Object} opts Additional request options:
- * - timeout {Number} - Timeout in milliseconds
- * - followRedirects {Boolean} Note, as of ARC 13 this object is part of
- * the request object under `config` property.
- * @return {Promise} A promise when the request is started with the socket
- * library
- */
- async run(request, opts) {
- opts = opts ? Object.assign({}, opts) : {};
- request = Object.assign({}, request);
- if (request.config) {
- request.config = Object.assign({}, request.config);
- }
- opts = this._prepareRequestOptions(request, opts);
- try {
- const hosts = await this._readHosts();
- /* eslint-disable-next-line require-atomic-updates */
- opts.hosts = hosts;
- const connection = await this._prepareRequest(request, opts);
- return await this._makeConnection(connection);
- } catch (cause) {
- this._errorHandler(cause, request.id);
- }
- }
-
- _prepareRequestOptions(request, opts) {
- let rConfig;
- if (request.config && request.config.enabled !== false) {
- rConfig = Object.assign(request.config);
- delete rConfig.enabled;
- } else {
- rConfig = {};
- }
- opts = Object.assign({}, opts || {});
- opts = Object.assign(rConfig, opts);
- if (typeof opts.timeout === 'undefined') {
- const time = this.requestTimeout;
- if (time) {
- opts.timeout = time;
- }
- }
- if (opts.timeout) {
- opts.timeout = Number(opts.timeout) * 1000;
- } else {
- opts.timeout = 0;
- }
- if (!opts.validateCertificates) {
- opts.validateCertificates = this.validateCertificates;
- }
- if (typeof opts.followRedirects === 'undefined') {
- opts.followRedirects = this.followRedirects;
- }
- if (typeof opts.defaultHeaders === 'undefined') {
- opts.defaultHeaders = this.defaultHeaders;
- }
- if (typeof opts.sentMessageLimit === 'undefined') {
- opts.sentMessageLimit = this.sentMessageLimit;
- }
- if (opts.sentMessageLimit) {
- opts.sentMessageLimit = Number(opts.sentMessageLimit);
- }
- if (request.clientCertificate) {
- opts.clientCertificate = request.clientCertificate;
- }
- return opts;
- }
- /**
- * Reads application hosts configuration and returns it.
- * It returns empty array of hosts couldn't be read.
- * @return {Promise}
- */
- async _readHosts() {
- if (this.hosts !== undefined) {
- return this.hosts;
- }
- const e = new CustomEvent('host-rules-list', {
- bubbles: true,
- composed: true,
- cancelable: true,
- detail: {}
- });
- this.dispatchEvent(e);
- if (!e.defaultPrevented) {
- this.hosts = [];
- return this.hosts;
- }
- const rules = await e.detail.result;
- this.hosts = rules || [];
- return rules;
- }
-
- _isNative(opts) {
- if (opts && typeof opts.nativeTransport === 'boolean') {
- return opts.nativeTransport;
- }
- return this.nativeTransport;
- }
-
- _prepareRequest(request, opts) {
- return this._isNative(opts) ?
- this._prepareNativeRequest(request, opts) :
- this._prepareArcRequest(request, opts);
- }
-
- _prepareArcRequest(request, opts) {
- let conn;
- // In ARC electron the browser window is created without node integration
- // and therefore require is disabled. In tests node is enabled.
- if (typeof SocketRequest === 'undefined') {
- const { SocketRequest } = require('@advanced-rest-client/electron-request');
- conn = new SocketRequest(request, opts);
- } else {
- conn = new SocketRequest(request, opts);
- }
- this._connections[request.id] = {
- connection: conn,
- aborted: false
- };
- conn.on('loadstart', this._loadStartHandler);
- conn.on('firstbyte', this._firstByteHandler);
- conn.on('loadend', this._loadEndHandler);
- conn.on('beforeredirect', this._beforeRedirectHandler);
- conn.on('headersreceived', this._headersReceivedHandler);
- conn.on('load', this._loadHandler);
- conn.on('error', this._errorHandler);
- return conn;
- }
-
- _prepareNativeRequest(request, opts) {
- let conn;
- // In ARC electron the browser window is created without node integration
- // and therefore require is disabled. In tests node is enabled.
- if (typeof ElectronRequest === 'undefined') {
- const { ElectronRequest } = require('@advanced-rest-client/electron-request');
- conn = new ElectronRequest(request, opts);
- } else {
- conn = new ElectronRequest(request, opts);
- }
- this._connections[request.id] = {
- connection: conn,
- aborted: false
- };
- conn.on('loadstart', this._loadStartHandler);
- conn.on('firstbyte', this._firstByteHandler);
- conn.on('loadend', this._loadEndHandler);
- conn.on('beforeredirect', this._beforeRedirectHandler);
- conn.on('headersreceived', this._headersReceivedHandler);
- conn.on('load', this._loadHandler);
- conn.on('error', this._errorHandler);
- return conn;
- }
-
- async _makeConnection(connection) {
- try {
- return await connection.send();
- } catch (cause) {
- this._errorHandler(cause, connection.id);
- }
- }
-
- _removeConnectionHandlers(connection) {
- connection.removeListener('loadstart', this._loadStartHandler);
- connection.removeListener('firstbyte', this._firstByteHandler);
- connection.removeListener('loadend', this._loadEndHandler);
- connection.removeListener('beforeredirect', this._beforeRedirectHandler);
- connection.removeListener('headersreceived', this._headersReceivedHandler);
- connection.removeListener('load', this._loadHandler);
- connection.removeListener('error', this._errorHandler);
- }
-
- _informStatus(type, id) {
- const info = this._connections[id];
- if (!info || info.aborted) {
- return;
- }
- this.dispatchEvent(new CustomEvent(type, {
- composed: true,
- bubbles: true,
- detail: {
- id
- }
- }));
- }
-
- _loadStartHandler(id) {
- this._informStatus('request-load-start', id);
- }
-
- _firstByteHandler(id) {
- this._informStatus('request-first-byte-received', id);
- }
-
- _loadEndHandler(id) {
- this._informStatus('request-load-end', id);
- }
-
- _beforeRedirectHandler(id, detail) {
- const info = this._connections[id];
- if (!info || info.aborted) {
- return;
- }
- const e = new CustomEvent('before-redirect', {
- composed: true,
- bubbles: true,
- cancelable: true,
- detail: {
- id,
- url: detail.location
- }
- });
- this.dispatchEvent(e);
- if (e.defaultPrevented) {
- detail.returnValue = false;
- }
- }
-
- _headersReceivedHandler(id, detail) {
- const info = this._connections[id];
- if (!info || info.aborted) {
- return;
- }
- const e = new CustomEvent('headers-received', {
- composed: true,
- bubbles: true,
- cancelable: true,
- detail: {
- id,
- value: detail.value
- }
- });
- this.dispatchEvent(e);
- if (e.defaultPrevented) {
- detail.returnValue = false;
- }
- }
-
- _loadHandler(id, response, request) {
- const info = this._connections[id];
- if (!info || info.aborted) {
- return;
- }
- this._removeConnectionHandlers(info.connection);
- delete this._connections[id];
- this._processResponse(id, response, request);
- }
-
- _errorHandler(cause, id, request, response) {
- const info = this._connections[id];
- if (info) {
- this._removeConnectionHandlers(info.connection);
- delete this._connections[id];
- }
- if (info && info.aborted) {
- return;
- }
- if (!response) {
- response = {};
- }
- const data = Object.assign({}, response, {
- isError: true,
- error: cause
- });
- this._processResponse(id, data, request);
- }
- /**
- * Processes response data and creates ARC response object.
- * @param {String} id Request ID
- * @param {Object} data Response data
- * @param {Object} requestInfo Request data
- */
- _processResponse(id, data, requestInfo) {
- const detail = {
- isXhr: false,
- request: requestInfo
- };
- const redirects = this._processRedirects(data.redirects);
- if (redirects.timings.length) {
- detail.redirectsTiming = redirects.timings;
- detail.redirects = redirects.redirects;
- }
- if (data.error && typeof data.error !== 'function') {
- detail.isError = true;
- detail.error = data.error;
- } else {
- const stats = this._cleanTimings(data.stats);
- detail.isError = false;
- detail.response = data;
- detail.sentHttpMessage = data.sentHttpMessage;
- detail.loadingTime = this._computeLoadingTime(stats);
- detail.timing = stats;
- detail.auth = data.auth;
- delete detail.response.sentHttpMessage;
- delete detail.request.sentHttpMessage;
- }
- detail.id = id;
- this._beforeResponse(detail);
- }
- /**
- * Processes redirects data from the socket library.
- * @param {Set} set A set of redirects
- * @return {Object} Map of arrays of timings and redirects information.
- */
- _processRedirects(set) {
- const result = {
- timings: [],
- redirects: []
- };
- if (!set) {
- return result;
- }
- set.forEach((item) => {
- result.redirects.push(item);
- result.timings.push(item.stats);
- delete item.stats;
- });
- return result;
- }
- /**
- * Computes a request / response loading time from the stats object
- * @param {Objject} stats A stats property of the socket client response.
- * @return {Number} A time to full response in miliseconds. 0 if stats unavailable.
- */
- _computeLoadingTime(stats) {
- if (!stats) {
- return 0;
- }
- let value = 0;
- if (stats.dns && stats.dns > 0) {
- value += stats.dns;
- }
- if (stats.connect && stats.connect > 0) {
- value += stats.connect;
- }
- if (stats.receive && stats.receive > 0) {
- value += stats.receive;
- }
- if (stats.send && stats.send > 0) {
- value += stats.send;
- }
- if (stats.ssl && stats.ssl > 0) {
- value += stats.ssl;
- }
- if (stats.wait && stats.wait > 0) {
- value += stats.wait;
- }
- return value;
- }
- /**
- * Creates HAR 1.2 object from timing data
- * @param {Object} stats
- * @return {Object}
- */
- _cleanTimings(stats) {
- const result = {
- dns: stats.dns || -1,
- connect: stats.connect || -1,
- receive: stats.receive || -1,
- send: stats.send || -1,
- ssl: stats.ssl || -1,
- wait: stats.wait || -1
- };
- return result;
- }
- /**
- * Dispatches `response-ready` event with request data.
- * If the event is not caneled then it dispatches `report-response`
- * event.
- *
- * @param {Object} detail The request detail
- */
- _beforeResponse(detail) {
- const e = new CustomEvent('response-ready', {
- composed: true,
- bubbles: true,
- cancelable: true,
- detail
- });
- this.dispatchEvent(e);
- if (e.defaultPrevented) {
- return;
- }
- this._reportResponse(e.detail);
- }
- /**
- * Fires the `report-response` custom event with immutable response data.
- * @param {Object} detail The event detail object.
- */
- _reportResponse(detail) {
- detail = this._prepareTransportObject(detail);
- const e = new CustomEvent('report-response', {
- composed: true,
- bubbles: true,
- cancelable: false,
- detail
- });
- this.dispatchEvent(e);
- }
- /**
- * Creates an immutable `detail` object for the `report-response` custom
- * event.
- * @param {Object} detail
- * @return {Object} Immutable object.
- */
- _prepareTransportObject(detail) {
- const configuration = {};
- Object.keys(detail).forEach((key) => {
- configuration[key] = {
- value: detail[key],
- writable: false,
- enumerable: true
- };
- });
- return Object.create(Object.prototype, configuration);
- }
- /**
- * Updates a rule from the `host-rules-changed` custom event.
- * The event should contain `rule` property on the event's detail object
- * containing the rule object.
- * @param {CustomEvent} e
- */
- _ruleUpdated(e) {
- if (e.cancelable || !this.hosts) {
- // Don't update rules if there's no local hosts array. Let the component
- // ask for all rules first.
- return;
- }
- const updatedValue = e.detail.rule;
- const index = this.hosts.findIndex((item) => item._id === updatedValue._id);
- if (index === -1) {
- this.hosts.push(updatedValue);
- } else {
- this.hosts[index] = updatedValue;
- }
- }
- /**
- * Deletes the rule from the `host-rules-deleted` custom event.
- * The event should contain `rule` property on the event's detail object
- * containing the rule object.
- *
- * @param {CustomEvent} e
- */
- _ruleDeleted(e) {
- if (e.cancelable) {
- return;
- }
- if (!this.hosts || !this.hosts.length) {
- return;
- }
- const id = e.detail.id;
- const index = this.hosts.findIndex((item) => item._id === id);
- if (index === -1) {
- return;
- }
- this.hosts.splice(index, 1);
- }
-}
-window.customElements.define('electron-http-transport', ElectronHttpTransport);
diff --git a/src/io/AppPrompts.js b/src/io/AppPrompts.js
new file mode 100644
index 00000000..14c279b0
--- /dev/null
+++ b/src/io/AppPrompts.js
@@ -0,0 +1,119 @@
+import { dialog, ipcMain, BrowserWindow } from 'electron';
+import { logger } from './Logger.js';
+
+const saveDialogHandler = Symbol('saveDialogHandler');
+const openDialogHandler = Symbol('openDialogHandler');
+
+/**
+ * Class responsible for displaying system dialogs and
+ * to sends back results to the sender.
+ */
+export class AppPrompts {
+ /**
+ * Listens for the application events.
+ */
+ listen() {
+ ipcMain.handle('save-dialog', this[saveDialogHandler].bind(this));
+ ipcMain.handle('open-dialog', this[openDialogHandler].bind(this));
+ }
+
+ /**
+ * Handles save action dialog. Opens "save as..." dialog and returns the result to the app.
+ *
+ * @param {Event} e Event emitted by the BrowserWindow
+ * @param {Object} args Prompt dialog options:
+ * - file {String} - File name to suggest to the user.
+ * @return {Promise}
+ */
+ [saveDialogHandler](e, args={}) {
+ logger.debug('Save dialog requested', args);
+ const options = {
+ title: 'Save to file'
+ };
+ if (args.file) {
+ options.defaultPath = args.file;
+ }
+ return dialog.showSaveDialog(options);
+ }
+
+ /**
+ * Handles open file action. Opens file picker dialog and returns the result to the app.
+ *
+ * @param {Electron.IpcMainInvokeEvent} e
+ * @returns {Promise}
+ */
+ async [openDialogHandler](e) {
+ const win = BrowserWindow.fromWebContents(e.sender);
+ logger.debug('Opening file open dialog.');
+ return dialog.showOpenDialog(win, {
+ title: 'Select file to open',
+ buttonLabel: 'Open',
+ properties: ['openFile'],
+ filters: [
+ { name: 'All supported files', extensions: ['arc', 'json', 'raml', 'yaml', 'zip'] }
+ ]
+ });
+ }
+
+ /**
+ * A dialog that renders error message about missing workspace file.
+ * @param {String} file Requested workspace file location.
+ * @return {Promise}
+ */
+ static async workspaceMissing(file) {
+ let message = 'Workspace file cannot be located. Probably it was deleted or';
+ message += ' renamed.\n\n';
+ message += `Requested file: ${file}`;
+ return dialog.showMessageBox({
+ type: 'error',
+ message
+ });
+ }
+
+ /**
+ * Opens a dialog to open a file and notifies the window about new content.
+ *
+ * @param {Electron.BrowserWindow} bWindow
+ * @returns {Promise}
+ */
+ static async openAssetDialog(bWindow) {
+ logger.debug('Opening file import dialog.');
+ const result = await dialog.showOpenDialog(bWindow, {
+ title: 'Select file to import',
+ buttonLabel: 'Import',
+ properties: ['openFile'],
+ filters: [
+ { name: 'All supported files', extensions: ['arc', 'json', 'raml', 'yaml', 'zip'] }
+ ]
+ });
+ const { filePaths, canceled } = result;
+ if (canceled) {
+ logger.debug('Import dialog was canceled.');
+ return;
+ }
+ logger.debug(`Sending file path to open in UI thread: ${filePaths[0]}`);
+ bWindow.webContents.send('command', 'process-external-file', filePaths[0]);
+ }
+
+ /**
+ * @param {Electron.BrowserWindow} bWindow
+ * @returns {Promise}
+ */
+ static async openWorkspaceFile(bWindow) {
+ logger.debug('Opening workspace import dialog.');
+ const result = await dialog.showOpenDialog(bWindow, {
+ title: 'Select workspace file to open',
+ buttonLabel: 'Open',
+ properties: ['openFile'],
+ filters: [
+ { name: 'All supported files', extensions: ['arc', 'json'] }
+ ]
+ });
+ const { filePaths, canceled } = result;
+ if (canceled) {
+ logger.debug('Import dialog was canceled.');
+ return undefined;
+ }
+ return filePaths[0];
+ }
+}
diff --git a/src/io/AppStateManager.js b/src/io/AppStateManager.js
new file mode 100644
index 00000000..4f791944
--- /dev/null
+++ b/src/io/AppStateManager.js
@@ -0,0 +1,77 @@
+import { ipcMain } from 'electron';
+import log from 'electron-log';
+import { ArcPreferences } from "../common/ArcPreferences.js";
+
+/** @typedef {import('@advanced-rest-client/arc-types').ArcState.ARCState} ARCState */
+
+export const readHandler = Symbol('readHandler');
+export const changeHandler = Symbol('changeHandler');
+
+/**
+ * A class that manages state of the application.
+ * The state file stores application state that is not related to application settings. The state is restored for each window.
+ * The state is not propagated to other windows. Though, the last window that stores the sate wins the state for the next opened window.
+ * This is design this way so the user can open 2 windows and test APIs suing different environments (for example, as the current environment is not part of settings).
+ */
+export class AppStateManager extends ArcPreferences {
+ /**
+ * @constructor
+ *
+ * @param {string} file The state file path
+ */
+ constructor(file) {
+ super(file);
+ this[readHandler] = this[readHandler].bind(this);
+ this[changeHandler] = this[changeHandler].bind(this);
+ }
+
+ /**
+ * Listens for application events related to preferences management.
+ */
+ observe() {
+ ipcMain.handle('app-state-read', this[readHandler]);
+ ipcMain.handle('app-state-update', this[changeHandler]);
+ }
+
+ async [readHandler]() {
+ let data;
+ try {
+ data = await this.load();
+ } catch (cause) {
+ log.error(cause);
+ // eslint-disable-next-line no-console
+ console.error(cause);
+ throw cause;
+ }
+ return data;
+ }
+
+ /**
+ * @param {Event} event
+ * @param {string} path Preference name
+ * @param {any} value Preference value
+ */
+ async [changeHandler](event, path, value) {
+ try {
+ const data = await this.load();
+ this.updateValue(data, path, value);
+ await this.store();
+ } catch (cause) {
+ log.error(cause);
+ // eslint-disable-next-line no-console
+ console.error(cause);
+ throw cause;
+ }
+ }
+
+ /**
+ * Creates default settings object.
+ *
+ * @return {Promise} Default settings object.
+ */
+ async defaultSettings() {
+ return /** @type ARCState */ ({
+ kind: 'ARC#AppState',
+ });
+ }
+}
diff --git a/src/io/ApplicationDefaults.js b/src/io/ApplicationDefaults.js
new file mode 100644
index 00000000..9ca5655d
--- /dev/null
+++ b/src/io/ApplicationDefaults.js
@@ -0,0 +1,33 @@
+import { ThemeDefaults } from './defaults/ThemeDefaults.js';
+import { WorkspaceDefaults } from './defaults/WorkspaceDefaults.js';
+import { DataStore } from './defaults/DataStore.js';
+
+/** @typedef {import('./WindowsManager').WindowsManager} WindowsManager */
+
+/**
+ * Class responsible for keeping application base environment stable.
+ *
+ * It copies default resources to it's default locations and sets up
+ * the application environment.
+ */
+export class ApplicationDefaults {
+ /**
+ * Prepares environment files while opening the application.
+ * Copies application themes to themes location.
+ * @return {Promise}
+ */
+ async prepareEnvironment() {
+ const td = new ThemeDefaults();
+ await td.prepareEnvironment();
+ const wd = new WorkspaceDefaults();
+ await wd.prepareEnvironment();
+ }
+
+ /**
+ * @param {WindowsManager} vm
+ */
+ async prepareDatabaseUpgrade(vm) {
+ const db = new DataStore(vm);
+ await db.ensureDataUpgraded();
+ }
+}
diff --git a/src/io/ApplicationMenu.js b/src/io/ApplicationMenu.js
new file mode 100644
index 00000000..43696e28
--- /dev/null
+++ b/src/io/ApplicationMenu.js
@@ -0,0 +1,315 @@
+/* eslint-disable no-param-reassign */
+import { EventEmitter } from 'events';
+import { app, Menu, MenuItem } from 'electron';
+import fs from 'fs-extra';
+import path from 'path';
+import { logger } from './Logger.js';
+import { WorkspaceHistory } from './models/WorkspaceHistory.js';
+
+
+/** @typedef {import('../menus/types').MenuDefinition} MenuDefinition */
+/** @typedef {import('../menus/types').MenuItemDefinition} MenuItemDefinition */
+/** @typedef {import('./models/Models').WorkspaceHistoryEntry} WorkspaceHistoryEntry */
+/** @typedef {import('./ApplicationUpdater').ApplicationUpdater} ApplicationUpdater */
+/** @typedef {import('electron').BrowserWindow} BrowserWindow */
+
+export const appendHistoryEntry = Symbol('appendHistoryEntry');
+export const workspaceHistoryAction = Symbol('workspaceHistoryAction');
+export const clearWorkspaceHistory = Symbol('clearWorkspaceHistory');
+export const createWorkspaceHistory = Symbol('createWorkspaceHistory');
+
+/**
+ * The class that builds application menu per the OS and handles the differences.
+ * Also works with the ApplicationUpdated module to add support for the update process.
+ */
+export class ApplicationMenu extends EventEmitter {
+ /**
+ * @param {ApplicationUpdater} updateStatus The instance of the update status class
+ */
+ constructor(updateStatus) {
+ super();
+ this.topMenu = new Menu();
+ this.history = new WorkspaceHistory();
+ this.menuLoaded = false;
+ this.us = updateStatus;
+
+ this.us.on('status-changed', this.updateStatusHandler.bind(this));
+ this[workspaceHistoryAction] = this[workspaceHistoryAction].bind(this);
+ }
+
+ /**
+ * Builds and sets the application menu.
+ * @return {Promise} Resolved when the application menu is created.
+ */
+ async build() {
+ logger.info('Building application menu from a template...');
+ try {
+ const template = await this.getTemplate();
+ this.createFromTemplate(template);
+ this.menuLoaded = true;
+ Menu.setApplicationMenu(this.topMenu);
+ logger.info('Application menu is now set.');
+ } catch (cause) {
+ this.menuLoaded = false;
+ const message = 'Menu template file was not found.';
+ logger.error(message);
+ logger.error(cause);
+ }
+ }
+
+ /**
+ * Gets menu template depending on the platform.
+ * @return {Promise} Promise resolved to JS object of menu template
+ * definition.
+ */
+ async getTemplate() {
+ const osName = this.platformToName();
+ const name = `${osName}.json`;
+ const file = path.join(__dirname, '..', 'menus', name);
+ logger.info('Menu template location', file);
+ return fs.readJson(file);
+ }
+
+ /**
+ * Returns common names for the platform.
+ * @returns {string} Either `darwin`, `win` or `linux`
+ */
+ platformToName() {
+ switch (process.platform) {
+ case 'darwin': return process.platform;
+ case 'win32': return 'win';
+ default: return 'linux';
+ }
+ }
+
+ /**
+ * Creates a menu definition from ARC's internal template.
+ * @param {MenuDefinition} template [description]
+ */
+ createFromTemplate(template) {
+ logger.info('Creating application menu instance');
+ this.createMainMenu(template.menu);
+ }
+
+ /**
+ * Creates application menu.
+ * @param {MenuItemDefinition[]} template Menu template model.
+ */
+ createMainMenu(template) {
+ template.forEach((data) => {
+ const item = this.createMenuItem(data);
+ this.topMenu.append(item);
+ });
+ }
+
+ /**
+ * Creates a menu item from menu definition model.
+ * @param {MenuItemDefinition} options Menu item model.
+ * @return {MenuItem} Created menu item.
+ */
+ createMenuItem(options) {
+ const init = /** @type {Electron.MenuItemConstructorOptions} */ ({ ...options });
+ if (options.command) {
+ init.click = this.itemActionHandler.bind(this, options.command);
+ }
+ if (options.submenu) {
+ init.submenu = this.createSubMenu(options.submenu);
+ }
+ if (options.label === 'VERSION') {
+ init.label = `Version: ${app.getVersion()}`;
+ }
+ return new MenuItem(init);
+ }
+
+ /**
+ * Creates a sub menu for a menu item.
+ *
+ * @param {MenuItemDefinition[]} submenu Menu data model
+ * @return {Menu} Menu item to be appended to another menu item.
+ */
+ createSubMenu(submenu) {
+ const menu = new Menu();
+ submenu.forEach((item) => menu.append(this.createMenuItem(item)));
+ return menu;
+ }
+
+ /**
+ * Handler for the menu item click event. Emits the `menu-action` event.
+ *
+ * @param {string} command The command associated with the menu.
+ * @param {MenuItem} menuItem Clicked menu item.
+ * @param {BrowserWindow} browserWindow Target window.
+ */
+ itemActionHandler(command, menuItem, browserWindow) {
+ logger.info(`Main menu action detected: ${command}`);
+ this.emit('menu-action', command, browserWindow);
+ this.us.menuActionHandler(command);
+ }
+
+ /**
+ * Appends an item to the list of workspace history items.
+ * @param {string} filePath Location of the workspace file.
+ * @return {Promise}
+ */
+ async appendWorkspaceHistory(filePath) {
+ await this.history.addEntry(filePath)
+ this[appendHistoryEntry](filePath);
+ }
+
+ /**
+ * Clears list of workspace history.
+ * Persists the state in the settings file.
+ * @returns {Promise}
+ */
+ async clearWorkspaceHistory() {
+ await this.history.clearHistory();
+ this[clearWorkspaceHistory]();
+ }
+
+ /**
+ * Loads workspace history list and creates menu entries.
+ * @returns {Promise}
+ */
+ async loadWorkspaceHistory() {
+ const entries = await this.history.loadEntries();
+ if (!entries) {
+ return;
+ }
+ this[createWorkspaceHistory](entries);
+ }
+
+ /**
+ * @return {Menu} A reference to workspace history submenu.
+ */
+ getWorkspaceHistoryMenu() {
+ // linux: 5, win: 5, osx: 6
+ const index = process.platform === 'darwin' ? 6 : 5;
+ const workspaceMenu = this.topMenu.items[index];
+ const historyMenu = workspaceMenu.submenu.items[3];
+ return historyMenu.submenu;
+ }
+
+ /**
+ * Appends history entry item to the history menu.
+ *
+ * @param {string} filePath A path to the workspace file.
+ */
+ [appendHistoryEntry](filePath) {
+ const menu = this.getWorkspaceHistoryMenu();
+ const { items } = menu;
+ if (items[2].visible) {
+ items[2].visible = false;
+ }
+ const options = /** @type Electron.MenuItemConstructorOptions */ ({
+ label: filePath,
+ after: ['no-history-entry'],
+ click: this[workspaceHistoryAction],
+ });
+ const item = new MenuItem(options);
+ menu.append(item);
+ }
+
+ /**
+ * A handler for menu item click action.
+ *
+ * @param {MenuItem} menuItem Instance of the menu item
+ */
+ [workspaceHistoryAction](menuItem) {
+ this.emit('open-workspace', menuItem.label);
+ this.history.addEntry(menuItem.label);
+ }
+
+ /**
+ * Removes all workspace history entries from the menu.
+ */
+ [clearWorkspaceHistory]() {
+ const menu = this.getWorkspaceHistoryMenu();
+ const items = Array.from(menu.items);
+ items.splice(3);
+ items[2].visible = true;
+ // @ts-ignore
+ menu.clear();
+ items.forEach((item) => menu.append(item));
+ Menu.setApplicationMenu(this.topMenu);
+ }
+
+ /**
+ * Iterates over the argument and creates menu entries from it.
+ * @param {WorkspaceHistoryEntry[]} entries List of history entries.
+ */
+ [createWorkspaceHistory](entries) {
+ entries.forEach((item) => {
+ const filePath = item.file;
+ // Un-trusted source
+ if (typeof filePath !== 'string') {
+ return;
+ }
+ this[appendHistoryEntry](filePath);
+ });
+ }
+
+ //
+ // Auto updater methods
+ //
+
+ /**
+ * Called when update status has changed from auto updated.
+ * @param {string} status The current status
+ */
+ updateStatusHandler(status) {
+ if (!this.menuLoaded) {
+ return;
+ }
+ const name = this.platformToName();
+ switch (name) {
+ case 'darwin': this.updateDarwinMenuUpdater(status); break;
+ case 'linux': this.updateLinuxMenuUpdater(status); break;
+ case 'win': this.updateWindowsMenuUpdater(status); break;
+ default:
+ }
+ }
+
+ /**
+ * Updates the menu for the darwin platform menu.
+ *
+ * @param {string} status The current status
+ */
+ updateDarwinMenuUpdater(status) {
+ const items = this.topMenu.items[0].submenu;
+ this.updateUpdaterStatus(status, items.items, 2);
+ }
+
+ /**
+ * Updates the menu for the linux platform menu.
+ *
+ * @param {string} status The current status
+ */
+ updateLinuxMenuUpdater(status) {
+ const { length } = this.topMenu.items;
+ const items = this.topMenu.items[length - 1].submenu;
+ this.updateUpdaterStatus(status, items.items, 3);
+ }
+
+ /**
+ * Updates the menu for the linux platform menu.
+ *
+ * @param {string} status The current status
+ */
+ updateWindowsMenuUpdater(status) {
+ const { length } = this.topMenu.items;
+ const items = this.topMenu.items[length - 1].submenu;
+ this.updateUpdaterStatus(status, items.items, 1);
+ }
+
+ /**
+ * @param {string} status The current updater status
+ * @param {MenuItem[]} items The menu items containing the update status items
+ * @param {number} index The starting index where the updater menu items are located.
+ */
+ updateUpdaterStatus(status, items, index) {
+ items[index].visible = status === 'update-downloaded';
+ items[index + 1].visible = status === 'not-available';
+ items[index + 2].visible = status === 'checking-for-update';
+ items[index + 3].visible = status === 'download-progress';
+ }
+}
diff --git a/scripts/main/app-options.js b/src/io/ApplicationOptions.js
similarity index 57%
rename from scripts/main/app-options.js
rename to src/io/ApplicationOptions.js
index cb36c404..3bf913ea 100644
--- a/scripts/main/app-options.js
+++ b/src/io/ApplicationOptions.js
@@ -1,5 +1,10 @@
-const log = require('./logger');
-const camelCase = require('camelcase');
+import camelCase from 'camelcase';
+import { logger } from './Logger.js';
+
+/** @typedef {import('../types').ApplicationOption} ApplicationOption */
+/** @typedef {import('../types').ProcessedApplicationOption} ProcessedApplicationOption */
+/** @typedef {import('../types').ApplicationOptionsConfig} ApplicationOptionsConfig */
+/** @typedef {import('../types').ProtocolFile} ProtocolFile */
/**
* A class describing and processing application initial options.
@@ -8,19 +13,27 @@ const camelCase = require('camelcase');
* of this class.
* Use `getOptions` to create an object with configuration.
*/
-class AppOptions {
+export class ApplicationOptions {
/**
* List of command line options with mapping to properties.
*
- * @return {Array} List of app config options
+ * @return {ApplicationOption[]} List of app config options
*/
get availableOptions() {
- return [{
+ return [
+ {
// Path to the settings file. Overrides default location.
name: '--settings-file',
shortcut: '-s',
type: String
- }, {
+ },
+ {
+ // Path to the state file. Overrides default location.
+ name: '--state-file',
+ shortcut: '-S',
+ type: String
+ },
+ {
// Path to the workspace state files path. Overrides default location.
name: '--workspace-path',
shortcut: '-w',
@@ -30,14 +43,9 @@ class AppOptions {
name: '--themes-path',
shortcut: '-t',
type: String
- }, {
- // Path to application components directory (with ARC components)
- name: '--components-path',
- shortcut: '-c',
- type: String
}, {
// Opens ARC in dev mode (opened console, verbose log)
- name: '--debug',
+ name: '--dev',
shortcut: '-d',
type: Boolean
}, {
@@ -62,7 +70,6 @@ class AppOptions {
name: '--open',
shortcut: '-o',
type: String,
- allowArray: true
}, {
// Skips application update check for this run
name: '--skip-app-update',
@@ -73,21 +80,42 @@ class AppOptions {
name: '--skip-themes-update',
shortcut: '-x',
type: Boolean,
+ }, {
+ name: '--user-data-dir',
+ shortcut: '-D',
+ type: String,
+ }, {
+ name: '--release-channel',
+ shortcut: '-r',
+ type: String,
+ }, {
+ name: '--skip-cookie-consent',
+ type: Boolean,
+ }, {
+ name: '--skip-database-upgrade',
+ type: Boolean,
}];
}
+
+ constructor() {
+ /**
+ * @type {ProtocolFile}
+ */
+ this.openProtocolFile = undefined;
+ }
+
/**
* Produces list of startup options.
- * @return {Object} Map of configured options.
+ * @return {ApplicationOptionsConfig} Map of configured options.
*/
getOptions() {
const result = {};
- for (const key in this) {
- if (Object.prototype.hasOwnProperty.call(this, key)) {
- result[key] = this[key];
- }
- }
+ Object.entries(this).forEach(([key, value]) => {
+ result[key] = value;
+ });
return result;
}
+
/**
* Parses startup options.
*/
@@ -97,38 +125,42 @@ class AppOptions {
if (arg[0] !== '-') {
if (this.isDefaultProtocolFile(arg)) {
this.setDefaultProtocolFile(arg);
+ } else if (!this.open && /[a-zA-Z0-9]/.test(arg[0])) {
+ this.open = arg;
} else if (arg[0] !== '.') {
- log.warn('Unknown startup option ' + arg);
+ logger.warn(`Unknown startup option ${arg}`);
}
continue;
}
- let def = this.findDefinnition(arg);
- if (!def) {
- log.warn('Unknown startup option ' + arg);
+ const definition = this.findDefinition(arg);
+ if (!definition) {
+ logger.warn(`Unknown startup option ${arg}`);
continue;
}
- def = this.getPropertyDefinition(arg, def, process.argv[i + 1]);
- this.setProperty(def);
- if (def.skipNext) {
+ const processedDefinition = this.getPropertyDefinition(arg, definition, process.argv[i + 1]);
+ this.setProperty(processedDefinition);
+ if (processedDefinition.skipNext) {
i++;
}
}
}
+
/**
* Checks if the argument is default protocol file argument added to the
* program's options by the OS.
- * @param {String} arg Argument to test
- * @return {Boolean} True if passed argument represent default protocol file.
+ * @param {string} arg Argument to test
+ * @return {boolean} True if passed argument represent default protocol file.
*/
isDefaultProtocolFile(arg) {
return !!(arg && arg.indexOf('arc-file://') === 0);
}
+
/**
- * Sets `openProtocolFile` property with passed file path infomation.
+ * Sets `openProtocolFile` property with passed file path information.
* The `source` property represents file source (like google-drive).
* The `action` property represent an action to take (like `open` or `create`).
- * The `id` proeprty if the file identifier.
- * @param {String} url Default protocol file.
+ * The `id` property if the file identifier.
+ * @param {string} url Default protocol file.
*/
setDefaultProtocolFile(url) {
const fileData = url.substr(11);
@@ -137,65 +169,72 @@ class AppOptions {
case 'drive':
// arc-file://drive/open/file-id
// arc-file://drive/create/file-id
- this.openProtocolFile = {
+ this.openProtocolFile = /** @type ProtocolFile */ ({
source: 'google-drive',
action: parts[1],
id: parts[2]
- };
- break;
+ });
+ break;
+ default:
}
}
+
/**
* Finds an option definition from an argument.
*
- * @param {String} arg Argument passed to the application.
- * @return {Object} Option definition or undefined if not found.
+ * @param {string} arg Argument passed to the application.
+ * @return {ApplicationOption|undefined} Option definition or undefined if not found.
*/
- findDefinnition(arg) {
+ findDefinition(arg) {
+ let value = arg;
const eqIndex = arg.indexOf('=');
if (eqIndex !== -1) {
- arg = arg.substr(0, eqIndex);
+ value = value.substr(0, eqIndex);
+ }
+ if (value.indexOf('--') === 0) {
+ return this.availableOptions.find((item) => item.name === value);
}
- if (arg.indexOf('--') === 0) {
- return this.availableOptions.find((item) => item.name === arg);
- } else if (arg.indexOf('-') === 0) {
- return this.availableOptions.find((item) => item.shortcut === arg);
+ if (value.indexOf('-') === 0) {
+ return this.availableOptions.find((item) => item.shortcut === value);
}
+ return undefined;
}
+
/**
* Updates definition object with `value` and `skipNext` properties.
*
- * @param {String} arg Command line argument
- * @param {Object} def Existing command definition.
- * @param {?String} nextValue Next item in the arguments array.
- * @return {Object} Updated `def` object.
+ * @param {string} arg Command line argument
+ * @param {ApplicationOption} def Existing command definition.
+ * @param {string=} nextValue Next item in the arguments array.
+ * @return {ProcessedApplicationOption} Updated `def` object.
*/
getPropertyDefinition(arg, def, nextValue) {
- def.skipNext = false;
- if (def.type === Boolean) {
- def.value = true;
- return def;
+ const result = /** @type ProcessedApplicationOption */ ({ ...def, skipNext: false });
+ if (result.type === Boolean) {
+ result.value = true;
+ return result;
}
let value;
if (arg.indexOf('=') !== -1) {
value = this.getArgValue(arg);
} else {
value = nextValue;
- def.skipNext = true;
+ result.skipNext = true;
}
- if (def.type === Number) {
- def.value = Number(value);
+ if (result.type === Number) {
+ result.value = Number(value);
} else {
- def.value = value;
+ result.value = value;
}
- return def;
+ return result;
}
+
/**
* Gets a value from an argument line when value is passed as
* `arg="value"` or `arg=value`
*
- * @param {String} arg Argument pice
- * @return {String} Value for the argument.
+ * @param {string} arg Argument pice
+ * @return {string} Value for the argument.
*/
getArgValue(arg) {
const index = arg.indexOf('=');
@@ -209,17 +248,18 @@ class AppOptions {
}
return value;
}
+
/**
* Sets a property value on this object.
- * An option name is set as a property aftr it's camel cased.
+ * An option name is set as a property after it's camel cased.
*
- * @param {Object} def Command definition.
+ * @param {ProcessedApplicationOption} def Command definition.
*/
setProperty(def) {
const name = camelCase(def.name);
- if (this[name] && def.allowArray) {
+ if (this[name] && def.isArray) {
let v = this[name];
- if (!(v instanceof Array)) {
+ if (!Array.isArray(v)) {
v = [v];
}
v.push(def.value);
@@ -229,4 +269,3 @@ class AppOptions {
}
}
}
-exports.AppOptions = AppOptions;
diff --git a/src/io/ApplicationPaths.js b/src/io/ApplicationPaths.js
new file mode 100644
index 00000000..fe323195
--- /dev/null
+++ b/src/io/ApplicationPaths.js
@@ -0,0 +1,207 @@
+import { app } from 'electron';
+import path from 'path';
+import fs from 'fs-extra';
+import { logger } from './Logger.js';
+
+export class ApplicationPaths {
+ /**
+ * The path to the application settings file
+ * @type {string}
+ */
+ #settingsFile = undefined;
+
+ /**
+ * The path to the application themes folder
+ * @type {string}
+ */
+ #themesBasePath = undefined;
+
+ /**
+ * The path to the application themes settings file.
+ * @type {string}
+ */
+ #themesSettings = undefined;
+
+ /**
+ * The path to the application workspace directory
+ * @type {string}
+ */
+ #workspacePath = undefined;
+
+ /**
+ * The path to the application state file where other than "settings" preferences are stored.
+ * @type {string}
+ */
+ #stateFile = undefined;
+
+ get settingsFile() {
+ return this.#settingsFile;
+ }
+
+ get themesBasePath() {
+ return this.#themesBasePath;
+ }
+
+ get themesSettings() {
+ return this.#themesSettings;
+ }
+
+ get stateFile() {
+ return this.#stateFile;
+ }
+
+ /**
+ * Resolves file path to a correct path if it's starts with `~`.
+ *
+ * @param {string} file The file path
+ * @return {string} Resolved path to the file.
+ */
+ resolvePath(file) {
+ let result = file;
+ if (result[0] === '~') {
+ result = app.getPath('home') + result.substr(1);
+ }
+ return result;
+ }
+
+ /**
+ * @returns {string} a location to the application directory depending on the OS
+ */
+ getAppDirectory() {
+ switch (process.platform) {
+ case 'darwin':
+ return process.execPath.substring(0, process.execPath.indexOf('.app') + 4);
+ case 'linux':
+ case 'win32':
+ return path.join(process.execPath, '..');
+ default: return '';
+ }
+ }
+
+ /**
+ * Safely checks whether the current user has access to the location.
+ * @param {string} dir the location to test
+ * @returns {boolean} a location to the application directory depending on the OS
+ */
+ hasWriteAccess(dir) {
+ const testFilePath = path.join(dir, 'write.test');
+ try {
+ fs.writeFileSync(testFilePath, new Date().toISOString(), { flag: 'w+' });
+ fs.unlinkSync(testFilePath);
+ return true;
+ } catch (err) {
+ return false;
+ }
+ }
+
+ /**
+ * Initializes settings file location in the application.
+ * @param {string=} file Settings file location.
+ */
+ setSettingsFile(file) {
+ let loc = file;
+ if (loc) {
+ loc = this.resolvePath(loc);
+ const dir = path.dirname(loc);
+ try {
+ fs.ensureDirSync(dir);
+ this.#settingsFile = loc;
+ } catch (_) {
+ logger.error(`Insufficient permission to settings file folder "${dir}".`);
+ }
+ }
+ if (!this.#settingsFile) {
+ this.#settingsFile = path.join(process.env.ARC_HOME, 'settings.json');
+ }
+ process.env.ARC_SETTINGS_FILE = this.#settingsFile;
+ logger.debug(`ARC_SETTINGS_FILE is set to: ${process.env.ARC_SETTINGS_FILE}`);
+ }
+
+ /**
+ * Sets a home location for the application.
+ */
+ setHome() {
+ const portableHomePath = path.join(this.getAppDirectory(), '..', '.arc');
+ if (fs.pathExistsSync(portableHomePath)) {
+ if (this.hasWriteAccess(portableHomePath)) {
+ process.env.ARC_HOME = portableHomePath;
+ } else {
+ logger.error(`Insufficient permission to portable ARC_HOME "${portableHomePath}".`);
+ }
+ }
+ if (!process.env.ARC_HOME) {
+ process.env.ARC_HOME = app.getPath('userData');
+ }
+ logger.debug(`ARC_HOME is set to: ${process.env.ARC_HOME}`);
+ }
+
+ /**
+ * Sets locations related to themes
+ * @param {string=} themesPath A path to the themes directory
+ * @param {string=} [themesSettingsFile='themes-info.json'] A path to the themes settings file.
+ */
+ setThemesPath(themesPath, themesSettingsFile='themes-info.json') {
+ if (themesPath) {
+ const resolved = this.resolvePath(themesPath);
+ try {
+ fs.ensureDirSync(resolved);
+ this.#themesBasePath = resolved;
+ } catch (_) {
+ logger.error(`Insufficient permission to themes installation location "${resolved}".`);
+ }
+ }
+
+ if (!this.#themesBasePath) {
+ this.#themesBasePath = path.join(process.env.ARC_HOME, 'themes-esm');
+ }
+
+ this.#themesSettings = path.join(this.#themesBasePath, themesSettingsFile);
+ process.env.ARC_THEMES = this.#themesBasePath;
+ process.env.ARC_THEMES_SETTINGS = this.#themesSettings;
+ logger.debug(`ARC_THEMES is set to: ${process.env.ARC_THEMES}`);
+ logger.debug(`ARC_THEMES_SETTINGS is set to: ${process.env.ARC_THEMES_SETTINGS}`);
+ }
+
+ /**
+ * Sets the default location of the workspace data,
+ * @param {string=} workspacePath A path to the workspace directory
+ */
+ setWorkspacePath(workspacePath) {
+ if (workspacePath) {
+ const resolved = this.resolvePath(workspacePath);
+ try {
+ this.#workspacePath = resolved;
+ } catch (_) {
+ logger.error(`Insufficient permission to themes installation location "${resolved}".`);
+ }
+ }
+ if (!this.#workspacePath) {
+ this.#workspacePath = path.join(process.env.ARC_HOME, 'workspace');
+ }
+ process.env.ARC_WORKSPACE_PATH = this.#workspacePath;
+ logger.debug(`ARC_WORKSPACE_PATH is set to: ${process.env.ARC_WORKSPACE_PATH}`);
+ }
+
+ /**
+ * Initializes state file location in the application.
+ * @param {string=} file State file location.
+ */
+ setStateFile(file) {
+ let loc = file;
+ if (loc) {
+ loc = this.resolvePath(loc);
+ const dir = path.dirname(loc);
+ try {
+ fs.ensureDirSync(dir);
+ this.#stateFile = loc;
+ } catch (_) {
+ logger.error(`Insufficient permission to state file folder "${dir}".`);
+ }
+ }
+ if (!this.#stateFile) {
+ this.#stateFile = path.join(process.env.ARC_HOME, 'state.json');
+ }
+ process.env.ARC_STATE_FILE = this.#stateFile;
+ logger.debug(`ARC_STATE_FILE is set to: ${process.env.ARC_STATE_FILE}`);
+ }
+}
diff --git a/src/io/ApplicationUpdater.js b/src/io/ApplicationUpdater.js
new file mode 100644
index 00000000..b76878a0
--- /dev/null
+++ b/src/io/ApplicationUpdater.js
@@ -0,0 +1,319 @@
+import { autoUpdater } from 'electron-updater';
+import { EventEmitter } from 'events';
+import { dialog, nativeImage, ipcMain, BrowserWindow } from 'electron';
+import path from 'path';
+import { logger } from './Logger.js';
+
+autoUpdater.logger = logger;
+
+/** @typedef {import('electron-updater').UpdateInfo} UpdateInfo */
+/** @typedef {import('@advanced-rest-client/arc-types').Config.ARCConfig} ARCConfig */
+
+export const checkingHandler = Symbol('checkingHandler');
+export const updateAvailableHandler = Symbol('updateAvailableHandler');
+export const updateNotAvailableHandler = Symbol('updateNotAvailableHandle');
+export const updateErrorHandler = Symbol('updateErrorHandler');
+export const downloadProgressHandler = Symbol('downloadProgressHandler');
+export const downloadReadyHandler = Symbol('downloadReadyHandler');
+export const checkUpdateHandler = Symbol('checkUpdateHandler');
+
+/**
+ * A module to check for updates.
+ *
+ * UpdateInfo model:
+ * - version {String} - The version.
+ * - files {Array}
+ * - releaseName {String} - The release name.
+ * - releaseNotes {String} - The release notes.
+ * - releaseDate {String} - The release date.
+ * - stagingPercentage {Number} - The staged rollout percentage, 0-100.
+ */
+export class ApplicationUpdater extends EventEmitter {
+
+ constructor() {
+ super();
+ this.state = 0;
+ this.lastInfoObject = undefined;
+ this[checkingHandler] = this[checkingHandler].bind(this);
+ this[updateAvailableHandler] = this[updateAvailableHandler].bind(this);
+ this[updateNotAvailableHandler] = this[updateNotAvailableHandler].bind(this);
+ this[updateErrorHandler] = this[updateErrorHandler].bind(this);
+ this[downloadProgressHandler] = this[downloadProgressHandler].bind(this);
+ this[downloadReadyHandler] = this[downloadReadyHandler].bind(this);
+ this.installUpdate = this.installUpdate.bind(this);
+ this.check = this.check.bind(this);
+ }
+
+ /**
+ * Adds auto-update library event listeners.
+ */
+ listen() {
+ autoUpdater.on('checking-for-update', this[checkingHandler]);
+ autoUpdater.on('update-available', this[updateAvailableHandler]);
+ autoUpdater.on('update-not-available', this[updateNotAvailableHandler]);
+ autoUpdater.on('error', this[updateErrorHandler]);
+ autoUpdater.on('download-progress', this[downloadProgressHandler]);
+ autoUpdater.on('update-downloaded', this[downloadReadyHandler]);
+
+ ipcMain.handle('check-for-update', this[checkUpdateHandler].bind(this));
+ ipcMain.on('install-update', this.installUpdate);
+ }
+
+ /**
+ * Adds auto-update library event listeners.
+ */
+ unlisten() {
+ autoUpdater.off('checking-for-update', this[checkingHandler]);
+ autoUpdater.off('update-available', this[updateAvailableHandler]);
+ autoUpdater.off('update-not-available', this[updateNotAvailableHandler]);
+ autoUpdater.off('error', this[updateErrorHandler]);
+ autoUpdater.off('download-progress', this[downloadProgressHandler]);
+ autoUpdater.off('update-downloaded', this[downloadReadyHandler]);
+
+ ipcMain.removeHandler('check-for-update');
+ ipcMain.off('install-update', this.installUpdate);
+ }
+
+ /**
+ * Checks if `channel` is a valid channel signature.
+ * @param {String} channel
+ * @return {Boolean}
+ */
+ isValidChannel(channel) {
+ return ['beta', 'alpha', 'latest'].indexOf(channel) !== -1;
+ }
+
+ /**
+ * Checks for update.
+ *
+ * @param {object=} opts Options for checking for an update.
+ */
+ check(opts={}) {
+ this.lastOptions = opts;
+ logger.info('Checking for application updates...');
+ autoUpdater.checkForUpdates();
+ }
+
+ /**
+ * Sets the channel value on auto updater
+ * @param {string} channel Channel name
+ */
+ setReleaseChannel(channel) {
+ if (this.isValidChannel(channel)) {
+ logger.debug(`Setting the release channel to${ channel}`);
+ autoUpdater.channel = channel;
+ } else {
+ logger.warn(`Channel ${channel} is not a valid application release channel.`);
+ }
+ }
+
+ /**
+ * Checks for app update.
+ * This function **must** be called after the app ready event.
+ *
+ * @param {ARCConfig=} settings Current application configuration.
+ * @param {boolean=} skipAppUpdate When set it skips application update check
+ */
+ start(settings={}, skipAppUpdate=false) {
+ logger.info('ApplicationUpdater::Initializing auto updater.');
+ const { updater={} } = settings;
+ const { auto, channel } = updater;
+ if (channel) {
+ if (this.isValidChannel(channel)) {
+ logger.info(`ApplicationUpdater::Setting auto updater channel to ${channel}`);
+ autoUpdater.channel = channel;
+ }
+ }
+ if (skipAppUpdate || auto === false) {
+ logger.debug('Auto Updater is disabled. Manual requests will still download the update.');
+ autoUpdater.autoDownload = false;
+ autoUpdater.autoInstallOnAppQuit = false;
+ return;
+ }
+ if (!skipAppUpdate) {
+ setTimeout(() => this.check());
+ }
+ }
+
+ /**
+ * Quits the application and installs the update.
+ */
+ installUpdate() {
+ logger.info('Initializing update process (quit & install)');
+ autoUpdater.quitAndInstall();
+ }
+
+ /**
+ * Handler for the `check-for-update` event dispatched by the renderer process.
+ * Calls `check()` with option to not notify the user about the update
+ * @returns {Promise}
+ */
+ async [checkUpdateHandler]() {
+ const result = await autoUpdater.checkForUpdates();
+ if (!result || !result.updateInfo) {
+ return undefined;
+ }
+ return result.updateInfo;
+ }
+
+ /**
+ * Emitted when checking if an update has started.
+ */
+ [checkingHandler]() {
+ this.state = 1;
+ this.lastInfoObject = undefined;
+ this.emit('notify-windows', 'checking-for-update');
+ this.emit('status-changed', 'checking-for-update');
+ }
+
+ /**
+ * Emitted when there is an available update. The update is downloaded
+ * automatically.
+ *
+ * @param {UpdateInfo} info Update info object. See class docs for details.
+ */
+ [updateAvailableHandler](info) {
+ logger.debug('Update available.');
+ this.state = 2;
+ this.lastInfoObject = info;
+ this.emit('notify-windows', 'update-available', info);
+ this.emit('status-changed', 'download-progress');
+ if (!this.lastOptions || !this.lastOptions.notify) {
+ return;
+ }
+ this.updateAvailableDialog();
+ }
+
+ /**
+ * Emitted when there is no available update.
+ *
+ * @param {UpdateInfo} info Update info object. See class docs for details.
+ */
+ [updateNotAvailableHandler](info) {
+ logger.debug('Update not available.');
+ this.state = 3;
+ this.lastInfoObject = info;
+ this.emit('notify-windows', 'update-not-available', info);
+ this.emit('status-changed', 'not-available');
+ this.notifyUser('No update available.', `${info.version} is the latest version.`);
+ }
+
+ /**
+ * Emitted when there is an error while updating.
+ *
+ * @param {any} error Error from the library.
+ */
+ [updateErrorHandler](error) {
+ const { message, code } = error;
+ logger.error('Update error');
+ this.state = 4;
+ this.lastInfoObject = error;
+ this.emit('notify-windows', 'autoupdate-error', {
+ message,
+ code,
+ });
+ this.emit('status-changed', 'not-available');
+ if (code === 8) {
+ let msg = 'Unable to update the application when it runs in';
+ msg += ' read-only mode. Move the application to the Applications';
+ msg += ' folder first and try again.';
+ this.notifyUser('Update error', msg, true);
+ } else {
+ this.notifyUser('Update error', message, true);
+ }
+ }
+
+ /**
+ * Emitted on download progress.
+ *
+ * @param {object} progressObj Progress info data. Contains `progress` property which has the following properties:
+ * - bytesPerSecond
+ * - percent
+ * - total
+ * - transferred
+ */
+ [downloadProgressHandler](progressObj) {
+ logger.debug('Update download progress');
+ this.state = 5;
+ this.lastInfoObject = progressObj;
+ this.emit('notify-windows', 'download-progress', progressObj);
+ }
+
+ /**
+ * Emitted when a new version is downloaded.
+ *
+ * @param {UpdateInfo} info Update info object. See class docs for details.
+ */
+ [downloadReadyHandler](info) {
+ logger.debug('Update download ready', info);
+ this.state = 6;
+ this.lastInfoObject = info;
+ this.emit('notify-windows', 'update-downloaded', info);
+ this.emit('status-changed', 'update-downloaded');
+ if (this.lastOptions && this.lastOptions.notify) {
+ setImmediate(() => autoUpdater.quitAndInstall());
+ }
+ }
+
+ /**
+ * Notifies the user about update event.
+ *
+ * @param {string} message Message to display.
+ * @param {string} detail MacOS only. Additional detail message.
+ * @param {boolean=} isError Should be true when notifying about error.
+ */
+ notifyUser(message, detail, isError) {
+ this.lastOptions = this.lastOptions || {};
+ if (!this.lastOptions || !this.lastOptions.notify) {
+ return;
+ }
+ const dialogOpts = {
+ type: isError ? 'error' : 'info',
+ title: 'ARC updater',
+ message,
+ detail,
+ };
+ if (!isError) {
+ const imgPath = path.join(__dirname, '..', '..', 'assets', 'icon.iconset', 'icon_512x512.png');
+ dialogOpts.icon = nativeImage.createFromPath(imgPath);
+ }
+ dialog.showMessageBox(dialogOpts);
+ }
+
+ async updateAvailableDialog() {
+ let msg = 'Application update is available. ';
+ msg += 'Do you want to install it now?';
+ const window = BrowserWindow.getFocusedWindow();
+ const result = await dialog.showMessageBox(window, {
+ type: 'info',
+ title: 'Application update',
+ message: msg,
+ buttons: ['Yes', 'No']
+ });
+ if (result.response === 0) {
+ autoUpdater.downloadUpdate();
+ }
+ }
+
+ /**
+ * A function reserved for the application menu to call.
+ * Checks for the update status when requested.
+ * @param {string} action The action requested by the user.
+ */
+ menuActionHandler(action) {
+ if (action.indexOf('application') === -1) {
+ return;
+ }
+ switch (action) {
+ case 'application:install-update':
+ this.installUpdate();
+ break;
+ case 'application:check-for-update':
+ this.check({
+ notify: true,
+ });
+ break;
+ default:
+ }
+ }
+}
diff --git a/src/io/ArcEnvironment.js b/src/io/ArcEnvironment.js
new file mode 100644
index 00000000..d456840b
--- /dev/null
+++ b/src/io/ArcEnvironment.js
@@ -0,0 +1,400 @@
+import { app, BrowserWindow, ipcMain, nativeTheme } from 'electron';
+import { Oauth2Identity } from '@advanced-rest-client/electron-oauth2';
+import fs from 'fs-extra';
+import { ApplicationUpdater } from './ApplicationUpdater.js';
+import { logger } from './Logger.js';
+import { ThemesProtocol } from './ThemesProtocol.js';
+import { EsmProtocol } from './EsmProtocol.js';
+import { WindowsManager } from './WindowsManager.js';
+import { ApplicationMenu } from './ApplicationMenu.js';
+import { PopupMenuService } from './PopupMenuService.js';
+import { ThemeManager } from './ThemeManager.js';
+import { SessionManager } from './SessionManager.js';
+import { ContentSearchService } from './ContentSearchService.js';
+import { AppPrompts } from './AppPrompts.js';
+import { AppStateManager } from './AppStateManager.js';
+import { GoogleDrive } from './GoogleDrive.js';
+import { ExternalResourcesManager } from './ExternalResourcesManager.js';
+
+/** @typedef {import('../types').ApplicationOptionsConfig} ApplicationOptionsConfig */
+/** @typedef {import('../types').ProtocolFile} ProtocolFile */
+/** @typedef {import('./PreferencesManager').PreferencesManager} PreferencesManager */
+
+export const osThemeUpdateHandler = Symbol('osThemeUpdateHandler');
+export const importWorkspaceHandler = Symbol('importWorkspaceHandler');
+
+export class ArcEnvironment {
+ /**
+ * @param {PreferencesManager} prefMgr Initialized preferences manager
+ * @param {ApplicationOptionsConfig=} [params={}]
+ */
+ constructor(prefMgr, params={}) {
+ this.config = prefMgr;
+ this.initParams = params;
+ this.isDebug = params.dev || false;
+ this.withDevTools = params.withDevtools || false;
+
+ this.initializeConfiguration(prefMgr);
+ this.initializeAppState();
+ this.initializeWindowsManager(params);
+ this.initializeUpdater();
+ this.initializeOAuth2();
+ this.initializeMenu();
+ this.initializePopupMenu();
+ this.initializeThemes();
+ this.initializeSessionManager();
+ this.initializeSearchService();
+ this.initializePrompts();
+ this.initializeGoogleDrive();
+ this.initializeExternalResources();
+
+ app.on('activate', () => this.activateHandler.bind(this));
+ app.on('window-all-closed', this.allClosedHandler.bind(this));
+ // @todo(pawel): create an overlay window on quit to delay the quit from ctrl/cmd+q for a second.
+ // app.on('will-quit', () => this.willQuitHandler.bind(this));
+ // app.on('before-quit', () => this.beforeQuitHandler.bind(this));
+ }
+
+ /**
+ * Loads event listeners for the preferences manager
+ * @param {PreferencesManager} manager Initialized preferences manager
+ */
+ initializeConfiguration(manager) {
+ manager.on('settings-changed', (name, value) => {
+ this.wm.notifyAll('preferences-value-updated', [name, value]);
+ this.settingsChanged(name, value);
+ });
+ manager.observe();
+ }
+
+ initializeAppState() {
+ this.state = new AppStateManager(process.env.ARC_STATE_FILE);
+ this.state.observe();
+ }
+
+ /**
+ * Initializes the window manager class.
+ * @param {ApplicationOptionsConfig} params
+ */
+ initializeWindowsManager(params) {
+ logger.debug('Initializing windows manager.');
+ this.wm = new WindowsManager(params);
+ this.wm.listen();
+ }
+
+ /**
+ * Initializes auto updater.
+ */
+ initializeUpdater() {
+ this.updater = new ApplicationUpdater();
+ this.updater.listen();
+ this.updater.on('notify-windows', (type, arg) => {
+ this.wm.notifyAll(type, arg);
+ });
+ }
+
+ initializeOAuth2() {
+ Oauth2Identity.listen();
+ }
+
+ /**
+ * Initializes the application menu`
+ */
+ initializeMenu() {
+ logger.debug('Initializing application menu (system menu).');
+ this.menu = new ApplicationMenu(this.updater);
+ this.menu.build();
+ logger.debug('Listening for system menu events.');
+ this.menu.on('menu-action', (action, win) => {
+ this.menuActionHandler(action, win);
+ });
+ this.menu.loadWorkspaceHistory();
+ this.menu.on('open-workspace', (filePath) => this.openWorkspace(filePath));
+ }
+
+ initializePopupMenu() {
+ logger.debug('Initializing app menu service (popup listener).');
+ const instance = new PopupMenuService(this.wm);
+ instance.listen();
+ this.appMenuService = instance;
+ }
+
+ initializeThemes() {
+ logger.debug('Initializing theme manager.');
+ this.themes = new ThemeManager(this, this.initParams.skipThemesUpdate);
+ this.themes.listen();
+ nativeTheme.on('updated', this[osThemeUpdateHandler].bind(this));
+ }
+
+ initializeSessionManager() {
+ logger.debug('Initializing session manager.');
+ this.sm = new SessionManager({
+ appUrls: [
+ 'https://advancedrestclient-1155.appspot.com',
+ 'advancedrestclient.com'
+ ],
+ });
+ this.sm.listen();
+ this.sm.on('cookie-changed', (cookies) => this.wm.notifyAll('cookie-changed', [cookies]));
+ }
+
+ initializeSearchService() {
+ logger.debug('Initializing content search service.');
+ this.search = new ContentSearchService(this.wm);
+ this.search.listen();
+ }
+
+ initializePrompts() {
+ this.prompts = new AppPrompts();
+ this.prompts.listen();
+ }
+
+ initializeGoogleDrive() {
+ this.gDrive = new GoogleDrive();
+ this.gDrive.listen();
+ // this is dispatched by the `GoogleDriveProxy.js` preload class.
+ ipcMain.on('google-drive-proxy-file-pick', this.proxyGoogleDriveFilePick.bind(this));
+ }
+
+ initializeExternalResources() {
+ this.externalResources = new ExternalResourcesManager();
+ this.externalResources.listen();
+ }
+
+ /**
+ * @param {Electron.IpcMainEvent} event
+ * @param {string} fileId
+ */
+ proxyGoogleDriveFilePick(event, fileId) {
+ const child = BrowserWindow.fromWebContents(event.sender);
+ const parent = child.getParentWindow();
+ child.close();
+ if (!parent) {
+ return;
+ }
+ parent.webContents.send('google-drive-file-pick', fileId);
+ }
+
+ /**
+ * Handler for settings change.
+ * @param {String} name Changed property name
+ * @param {any} value Changed value
+ */
+ settingsChanged(name, value) {
+ switch (name) {
+ case 'releaseChannel':
+ this.updater.setReleaseChannel(value);
+ break;
+ default:
+ }
+ }
+
+ registerHandlers() {
+ logger.debug('initializing themes protocol');
+ const tp = new ThemesProtocol();
+ tp.register();
+ this.themesProtocol = tp;
+ logger.debug('initializing ESM protocol');
+ const mp = new EsmProtocol();
+ mp.register();
+ this.modulesProtocol = mp;
+ }
+
+ /**
+ * Reads current settings and initialized the environment:
+ * - the application updater
+ */
+ async loadEnvironment() {
+ logger.debug('Loading user configuration...');
+ const settings = await this.config.load();
+ logger.debug('User configuration ready.');
+ if (!this.isDebug) {
+ this.updater.start(settings, this.initParams.skipAppUpdate);
+ }
+ }
+
+ /**
+ * Opens a new application window.
+ * @param {string|ProtocolFile=} params
+ */
+ open(params) {
+ if (params === 'string' || !params) {
+ // @ts-ignore
+ this.wm.open(params);
+ } else {
+ this.wm.openWithAction(/** @type ProtocolFile */ (params));
+ }
+ }
+
+ /**
+ * A callback fof all windows closed event.
+ * It gives some time to the process to open another window.
+ * This may happen when calling close and open together. This callback runs
+ * and closes the app but new window is not yet ready. Hence a delay.
+ */
+ allClosedHandler() {
+ setTimeout(() => {
+ if (this.wm.hasWindow) {
+ return;
+ }
+ logger.debug('All windows are now closed.');
+ if (process.platform !== 'darwin') {
+ logger.debug('Quitting main thread.');
+ app.quit();
+ } else {
+ logger.debug('Keeping main thread running.');
+ }
+ }, 1000);
+ }
+
+ /**
+ * 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.
+ */
+ async activateHandler() {
+ logger.debug('Activating a window.');
+ if (!this.wm.hasWindow) {
+ await this.wm.open();
+ } else {
+ this.wm.restoreLast();
+ }
+ }
+
+ /**
+ * Event handler for menu actions.
+ *
+ * @param {String} action Action type to perform
+ * @param {Electron.BrowserWindow} win Browser window association with the action
+ */
+ menuActionHandler(action, win) {
+ logger.debug(`Handing menu command: ${action}`);
+ if (action.startsWith('application:')) {
+ this.applicationActionHandler(action.substr(12), win);
+ return;
+ }
+ if (action.startsWith('request:')) {
+ win.webContents.send('request-action', action.substr(8));
+ return;
+ }
+ logger.warn(`Menu command not handled: ${action}`);
+ }
+
+ /**
+ * Handles menu actions that are prefixed with `application:`.
+ * The `action` is without the application prefix.
+ *
+ * @param {String} action Action type to perform
+ * @param {Electron.BrowserWindow} win Browser window association with the action
+ */
+ applicationActionHandler(action, win) {
+ switch (action) {
+ case 'quit':
+ logger.debug('Quitting the application.');
+ app.quit();
+ break;
+ case 'new-window':
+ logger.debug('Opening new window.');
+ this.wm.open();
+ break;
+ case 'popup-menu':
+ logger.debug('Toggling popup menu.');
+ this.appMenuService.togglePopupMenu();
+ break;
+ case 'clear-workspace-history':
+ this.menu.clearWorkspaceHistory();
+ break;
+ case 'open-file':
+ AppPrompts.openAssetDialog(win);
+ break;
+ case 'open-drive':
+ this.wm.open({
+ page: 'drive-picker.html',
+ preload: 'arc-preload.js',
+ ignoreWindowSessionSettings: true,
+ noMenu: true,
+ noWebSecurity: true,
+ parent: win,
+ });
+ break;
+ case 'import-workspace':
+ this[importWorkspaceHandler](win);
+ break;
+ case 'find':
+ this.search.start(win);
+ break;
+ case 'open-themes':
+ this.wm.open({
+ page: 'themes.html',
+ preload: 'themes-preload.js',
+ ignoreWindowSessionSettings: true,
+ noMenu: true,
+ });
+ break;
+ case 'open-license':
+ this.wm.open({
+ page: 'license.html',
+ ignoreWindowSessionSettings: true,
+ noMenu: true,
+ });
+ break;
+ case 'about':
+ this.wm.open({
+ page: 'about.html',
+ preload: 'arc-preload.js',
+ ignoreWindowSessionSettings: true,
+ noMenu: true,
+ parent: win,
+ });
+ break;
+ case 'open-privacy-policy':
+ case 'open-documentation':
+ case 'open-faq':
+ case 'open-discussions':
+ case 'report-issue':
+ case 'search-issues':
+ case 'web-session-help':
+ this.externalResources.openHelpTopic(action);
+ break;
+ default:
+ logger.debug(`Sending "${action}" action to the UI thread.`);
+ win.webContents.send('command', action);
+ }
+ }
+
+ [osThemeUpdateHandler]() {
+ this.wm.notifyAll('system-theme-changed', nativeTheme.shouldUseDarkColors);
+ }
+
+ /**
+ * An application menu handler for open workspace from file.
+ * @param {Electron.BrowserWindow} win Window from where the request came from
+ * @return {Promise}
+ */
+ async [importWorkspaceHandler](win) {
+ const path = await AppPrompts.openWorkspaceFile(win);
+ if (path) {
+ logger.info('Opening workspace file in a new window.');
+ await this.wm.open({
+ workspaceFile: path,
+ });
+ await this.menu.appendWorkspaceHistory(path);
+ }
+ }
+
+ /**
+ * Opens workspace from file
+ * @param {string} filePath Workspace file location.
+ * @returns {Promise}
+ */
+ async openWorkspace(filePath) {
+ const exists = await fs.pathExists(filePath);
+ if (!exists) {
+ AppPrompts.workspaceMissing(filePath);
+ } else {
+ logger.info('Opening workspace file in a new window.');
+ await this.wm.open({
+ workspaceFile: filePath,
+ });
+ };
+ }
+}
diff --git a/src/io/ArcMeta.js b/src/io/ArcMeta.js
new file mode 100644
index 00000000..aff125d5
--- /dev/null
+++ b/src/io/ArcMeta.js
@@ -0,0 +1,59 @@
+import path from 'path';
+import { v4, v5 } from 'uuid';
+import { ArcPreferences } from '../common/ArcPreferences.js';
+/**
+ * ARC metadata
+ *
+ * Type: `Object`
+ * Properties:
+ * - `appId` {String} Generated application ID that can be used to
+ * link user data
+ * - `aid` {String} Anonymized id that can be used to link this app with the analytics account like Google Analytics.
+ * **This property is never stored outside local filesystem or analytics server which doesn't allow connect this information with specific app instance**
+ */
+export class ArcMeta extends ArcPreferences {
+ /**
+ * @constructor
+ */
+ constructor() {
+ super(path.join(process.env.ARC_HOME, 'app-meta.json'));
+ }
+
+ /**
+ * Returns generated application ID.
+ *
+ * @return {Promise} Promise resolved to the application ID.
+ */
+ async getAppId() {
+ const meta = await this.load();
+ return meta.appId;
+ }
+
+ /**
+ * To ensure anonymous app usage reporting the app is using generated UUID
+ * from the instance ID. Both are not stored together anywhere outside user's
+ * local filesystem.
+ *
+ * @return {Promise} Promise resolved to the application anonymized ID.
+ */
+ async getAnonymizedId() {
+ const meta = await this.load()
+ return meta.aid;
+ }
+
+ /**
+ * Creates default metadata for ARC.
+ *
+ *
+ * @return {Promise} Generated metadata object
+ */
+ async defaultSettings() {
+ const appId = v4();
+ const aid = v5('arc-electron', appId);
+ const result = {
+ appId,
+ aid
+ };
+ return result;
+ }
+}
diff --git a/src/io/ArcSessionRecorder.js b/src/io/ArcSessionRecorder.js
new file mode 100644
index 00000000..dc87187e
--- /dev/null
+++ b/src/io/ArcSessionRecorder.js
@@ -0,0 +1,50 @@
+import fetch from 'node-fetch';
+import { ArcMeta } from './ArcMeta.js';
+import { logger } from './Logger.js';
+/**
+ * This is first part analytics. This records the app start ONLY.
+ * The generated client id is random string generated per app instance and stored locally.
+ * There's no possibility to connect the id with a particular instance.
+ *
+ * The reason to have this is to keep project alive by proving that someone is using it..
+ */
+export class ArcSessionRecorder {
+ /**
+ * @constructor
+ */
+ constructor() {
+ this.meta = new ArcMeta();
+ this.endpoint = 'https://api.advancedrestclient.com/v1/analytics/record';
+ }
+
+ /**
+ * Pings the server to record the session.
+ * @return {Promise}
+ */
+ async record() {
+ try {
+ const id = await this.meta.getAnonymizedId();
+ await this._postSession(id);
+ } catch (cause) {
+ logger.error('Unable to record the session', cause.message);
+ }
+ }
+
+ /**
+ * Posts session data to the analytics server.
+ *
+ * @param {string} aid Anonymous app id.
+ * @return {Promise}
+ */
+ async _postSession(aid) {
+ const d = new Date();
+ const data = {
+ aid,
+ tz: d.getTimezoneOffset()
+ };
+ await fetch(this.endpoint, {
+ method: 'POST',
+ body: JSON.stringify(data),
+ });
+ }
+}
diff --git a/src/io/Constants.js b/src/io/Constants.js
new file mode 100644
index 00000000..4e6058fb
--- /dev/null
+++ b/src/io/Constants.js
@@ -0,0 +1,5 @@
+// this is not to be changed after the application is first published or the users will loose their data.
+export const MainWindowPersist = 'persist:arc-window';
+export const TaskManagerWindowPersist = 'persist:arc-task-manager';
+export const WebSessionPersist = 'persist:web-session';
+export const AppHostname = 'api-client.app';
diff --git a/src/io/ContentSearchService.js b/src/io/ContentSearchService.js
new file mode 100644
index 00000000..933263ba
--- /dev/null
+++ b/src/io/ContentSearchService.js
@@ -0,0 +1,325 @@
+import { ipcMain, BrowserWindow, nativeTheme } from 'electron';
+
+const findHandler = Symbol('findHandler');
+const clearHandler = Symbol('clearHandler');
+const foundInPageHandler = Symbol('foundInPageHandler');
+const initializeSearchBar = Symbol('initializeSearchBar');
+const positionWindow = Symbol('positionWindow');
+const listenTargetEvents = Symbol('listenTargetEvents');
+const unlistenTargetEvents = Symbol('unlistenTargetEvents');
+const listenBarEvents = Symbol('listenBarEvents');
+const unlistenBarEvents = Symbol('unlistenBarEvents');
+const resizeHandler = Symbol('resizeHandler');
+const moveHandler = Symbol('moveHandler');
+const targetCloseHandler = Symbol('targetCloseHandler');
+const barCloseHandler = Symbol('barCloseHandler');
+const focusBarInput = Symbol('focusBarInput');
+const targetReloadHandler = Symbol('targetReloadHandler');
+const searchBarCommandHandler = Symbol('searchBarCommandHandler');
+
+/** @typedef {import('./WindowsManager').WindowsManager} WindowsManager */
+
+/**
+ * A service that performs a content search in the WebContents using Chrome APIs.
+ *
+ * Why is this class creating a new BrowserWindow?
+ *
+ * When the search bar is included in the DOM it is also a part of the searched content. The search filed
+ * gets highlighted and when the user is typing the input looses focus.
+ * It is not enough to use iframe or (the current) web-view. Iframe is also being pare of the text search on
+ * the page and the web-view element is basically a new browser window which requires using IPC but is currently
+ * not recommended by Electron authors to use.
+ */
+export class ContentSearchService {
+ /**
+ * @returns {object} Bounds object for the window.
+ */
+ get searchBarBounds() {
+ return {
+ width: 400,
+ height: 56
+ };
+ }
+
+ /**
+ * @param {WindowsManager} windowsManager
+ */
+ constructor(windowsManager) {
+ this.windowsManager = windowsManager;
+ /**
+ * The map of find in page request IDs and the corresponding windows.
+ *
+ * @type {{[key: number]: Electron.WebContents}}
+ */
+ this.requests = {};
+ /**
+ * The list of WebContents being currently processed by this content search service.
+ * @type {Electron.WebContents[]}
+ */
+ this.contents = [];
+
+ /**
+ * @type {{ barWindow: BrowserWindow, targetWindow: BrowserWindow }[]}
+ */
+ this.map = [];
+
+ this[resizeHandler] = this[resizeHandler].bind(this);
+ this[moveHandler] = this[moveHandler].bind(this);
+ this[targetCloseHandler] = this[targetCloseHandler].bind(this);
+ this[barCloseHandler] = this[barCloseHandler].bind(this);
+ this[targetReloadHandler] = this[targetReloadHandler].bind(this);
+ }
+
+ listen() {
+ ipcMain.on('search-bar-command', this[searchBarCommandHandler].bind(this));
+ }
+
+ /**
+ * Starts a search for a content window or focuses on the search button if the search bar is already opened.
+ * @param {Electron.BrowserWindow} win
+ */
+ start(win) {
+ const item = this.map.find((entry) => entry.targetWindow === win);
+ if (item) {
+ this[focusBarInput](item.barWindow);
+ } else {
+ this[initializeSearchBar](win);
+ }
+ }
+
+ /**
+ * Creates a new search bar and attaches it to the given windows
+ * @param {Electron.BrowserWindow} targetWindow
+ */
+ [initializeSearchBar](targetWindow) {
+ const options = {
+ ...this.windowsManager.createBaseWindowOptions('search-bar.js'),
+ frame: false,
+ movable: false,
+ parent: targetWindow,
+ transparent: true,
+ // backgroundColor: '#00ffffff',
+ // hasShadow: false,
+ };
+ delete options.backgroundColor;
+ const barWindow = new BrowserWindow(options);
+ this.map.push({
+ barWindow,
+ targetWindow,
+ });
+ this[positionWindow](barWindow, targetWindow);
+ this.windowsManager.loadPage(barWindow, 'search-bar.html', '', {
+ darkMode: String(nativeTheme.shouldUseDarkColors),
+ });
+ this[listenTargetEvents](targetWindow);
+ this[listenBarEvents](barWindow);
+ barWindow.webContents.once('did-finish-load', () => this[focusBarInput](barWindow));
+ if (process.argv.includes('--dev')) {
+ barWindow.webContents.openDevTools();
+ }
+ }
+
+ /**
+ * Positions the search bar window according to main window position.
+ *
+ * @param {Electron.BrowserWindow} barWindow
+ * @param {Electron.BrowserWindow} targetWindow
+ */
+ [positionWindow](barWindow, targetWindow) {
+ const rect = targetWindow.getBounds();
+ const winBounds = this.searchBarBounds;
+ const maxRight = rect.width + rect.x;
+ const x = maxRight - winBounds.width - 12; // padding
+ const maxTop = rect.y + 26;
+ winBounds.x = x;
+ winBounds.y = maxTop;
+ barWindow.setBounds(winBounds);
+ }
+
+ /**
+ * Listens to the target window's move and resize events to reposition the corresponding search bar.
+ *
+ * @param {Electron.BrowserWindow} targetWindow
+ */
+ [listenTargetEvents](targetWindow) {
+ targetWindow.on('resize', this[resizeHandler]);
+ targetWindow.on('move', this[moveHandler]);
+ targetWindow.on('close', this[targetCloseHandler]);
+ targetWindow.webContents.on('did-start-loading', this[targetReloadHandler]);
+ }
+
+ /**
+ * Removes previously registered events.
+ *
+ * @param {Electron.BrowserWindow} targetWindow
+ */
+ [unlistenTargetEvents](targetWindow) {
+ targetWindow.removeListener('resize', this[resizeHandler]);
+ targetWindow.removeListener('move', this[moveHandler]);
+ targetWindow.removeListener('close', this[targetCloseHandler]);
+ targetWindow.webContents.removeListener('did-start-loading', this[targetReloadHandler]);
+ }
+
+ /**
+ * Listens to the search bar window events
+ *
+ * @param {Electron.BrowserWindow} barWindow
+ */
+ [listenBarEvents](barWindow) {
+ barWindow.on('close', this[barCloseHandler]);
+ }
+
+ /**
+ * Removes previously registered search events/
+ *
+ * @param {Electron.BrowserWindow} barWindow
+ */
+ [unlistenBarEvents](barWindow) {
+ barWindow.removeListener('close', this[barCloseHandler]);
+ }
+
+ /**
+ * A handler for `resize` event from the app window. Repositions the search bar window.
+ * @param {any} e Event sent from the app window.
+ */
+ [resizeHandler](e) {
+ const win = /** @type BrowserWindow */ (e.sender);
+ const item = this.map.find((entry) => entry.targetWindow === win);
+ if (!item) {
+ return;
+ }
+ this[positionWindow](item.barWindow, item.targetWindow);
+ }
+
+ /**
+ * A handler for `move` event from the app window. Repositions the search bar window.
+ * @param {any} e Event sent from the app window.
+ */
+ [moveHandler](e) {
+ const win = /** @type BrowserWindow */ (e.sender);
+ const item = this.map.find((entry) => entry.targetWindow === win);
+ if (!item) {
+ return;
+ }
+ this[positionWindow](item.barWindow, item.targetWindow);
+ }
+
+ /**
+ * Event handler for the application window close handler. Removes this service from cache,
+ * closes search bar (if any) amd removes window listeners.
+ * @param {any} e Event sent from the app window.
+ */
+ [targetCloseHandler](e) {
+ const win = /** @type BrowserWindow */ (e.sender);
+ const index = this.map.findIndex((entry) => entry.targetWindow === win);
+ if (index === -1) {
+ return
+ }
+ const item = this.map[index];
+ this.map.splice(index, 1);
+ if (!item.barWindow.isDestroyed()) {
+ item.barWindow.close();
+ }
+ }
+
+ [barCloseHandler](e) {
+ const win = /** @type BrowserWindow */ (e.sender);
+ const index = this.map.findIndex((entry) => entry.barWindow === win);
+ if (index === -1) {
+ return
+ }
+ const item = this.map[index];
+ this.map.splice(index, 1);
+ const { barWindow, targetWindow } = item;
+ if (!this.contents.includes(targetWindow.webContents)) {
+ const contentsIndex = this.contents.indexOf(targetWindow.webContents);
+ this.contents.splice(contentsIndex, 1);
+ }
+ targetWindow.webContents.stopFindInPage('clearSelection');
+ this[unlistenBarEvents](barWindow);
+ this[unlistenTargetEvents](targetWindow);
+ }
+
+ /**
+ * Focuses on the input element of the search bar
+ *
+ * @param {Electron.BrowserWindow} barWindow
+ */
+ [focusBarInput](barWindow) {
+ if (barWindow.isDestroyed()) {
+ return;
+ }
+ if (!barWindow.isVisible()) {
+ barWindow.show();
+ }
+ barWindow.webContents.send('command', 'focus-input');
+ }
+
+ /**
+ * @param {BrowserWindow} targetWindow
+ * @param {BrowserWindow} barWindow
+ * @param {string} query
+ * @param {Electron.FindInPageOptions=} opts
+ */
+ [findHandler](targetWindow, barWindow, query, opts) {
+ if (!this.contents.includes(targetWindow.webContents)) {
+ this.contents.push(targetWindow.webContents);
+ targetWindow.webContents.on('found-in-page', this[foundInPageHandler].bind(this));
+ }
+
+ const request = targetWindow.webContents.findInPage(query, opts);
+ this.requests[request] = barWindow.webContents;
+ }
+
+ /**
+ * @param {Electron.WebContents} targetContents
+ */
+ [clearHandler](targetContents) {
+ const index = this.contents.findIndex((item) => item === targetContents);
+ targetContents.stopFindInPage('clearSelection');
+ targetContents.removeAllListeners('found-in-page');
+ this.contents.splice(index, 1);
+ }
+
+ /**
+ * @param {Electron.Event} event
+ * @param {Electron.Result} detail
+ */
+ [foundInPageHandler](event, detail) {
+ const { requestId, matches, activeMatchOrdinal } = detail;
+ const barContents = this.requests[requestId];
+ if (!barContents) {
+ return;
+ }
+ delete this.requests[requestId];
+ barContents.send('search-bar-found-in-page', matches, activeMatchOrdinal);
+ }
+
+ /**
+ * @param {any} e
+ * @param {...any} args
+ */
+ [searchBarCommandHandler](e, ...args) {
+ const contents = /** @type Electron.WebContents */ (e.sender);
+ const item = this.map.find((entry) => entry.barWindow.webContents === contents);
+ if (!item) {
+ return
+ }
+ const [command, ...rest] = args;
+ switch (command) {
+ case 'find': this[findHandler](item.targetWindow, item.barWindow, rest[0], rest[1]); break;
+ case 'clear': this[clearHandler](item.targetWindow.webContents); break;
+ case 'close': item.barWindow.close(); break;
+ default:
+ }
+ }
+
+ [targetReloadHandler](e) {
+ const contents = /** @type Electron.WebContents */ (e.sender);
+ const item = this.map.find((entry) => entry.targetWindow.webContents === contents);
+ if (!item) {
+ return;
+ }
+ item.barWindow.close();
+ }
+}
diff --git a/src/io/ContextActions.js b/src/io/ContextActions.js
new file mode 100644
index 00000000..fa83e31a
--- /dev/null
+++ b/src/io/ContextActions.js
@@ -0,0 +1,50 @@
+import { Menu } from 'electron';
+import { logger } from './Logger.js';
+
+const selectionMenu = Menu.buildFromTemplate([
+ {role: 'copy', accelerator: 'ctrl+c'},
+ {type: 'separator'},
+ {role: 'selectAll', accelerator: 'ctrl+a'},
+]);
+
+const inputMenu = Menu.buildFromTemplate([
+ {role: 'undo', accelerator: 'ctrl+z'},
+ {role: 'redo', accelerator: 'ctrl+shift+z'},
+ {type: 'separator'},
+ {role: 'cut', accelerator: 'ctrl+x'},
+ {role: 'copy', accelerator: 'ctrl+c'},
+ {role: 'paste', accelerator: 'ctrl+v'},
+ {type: 'separator'},
+ {role: 'selectAll', accelerator: 'ctrl+a'},
+]);
+
+/**
+ * A class responsible for gathering information about registered context menu
+ * actions and creating a configuration for opened windows.
+ */
+export class ContextActions {
+ /**
+ * Registers application default actions on the window object.
+ *
+ * @param {Electron.WebContents} webContents A web contents object of the renderer process
+ */
+ registerDefaultActions(webContents) {
+ logger.debug('Registering window default context menu actions');
+ webContents.on('context-menu', (e, props) => {
+ const { selectionText, isEditable, editFlags } = props;
+ if (isEditable) {
+ inputMenu.items[0].enabled = editFlags.canUndo;
+ inputMenu.items[1].enabled = editFlags.canRedo;
+ inputMenu.items[3].enabled = editFlags.canCut;
+ inputMenu.items[4].enabled = editFlags.canCopy;
+ inputMenu.items[5].enabled = editFlags.canPaste;
+ inputMenu.items[7].enabled = editFlags.canSelectAll;
+ inputMenu.popup();
+ } else if (selectionText && selectionText.trim() !== '') {
+ inputMenu.items[0].enabled = editFlags.canCopy;
+ inputMenu.items[2].enabled = editFlags.canSelectAll;
+ selectionMenu.popup();
+ }
+ })
+ }
+}
diff --git a/src/io/EsmProtocol.js b/src/io/EsmProtocol.js
new file mode 100644
index 00000000..d662648a
--- /dev/null
+++ b/src/io/EsmProtocol.js
@@ -0,0 +1,195 @@
+/* eslint-disable no-bitwise */
+import { session, protocol } from 'electron';
+import path from 'path';
+import fs from 'fs-extra';
+import mime from 'mime-types';
+import { logger } from './Logger.js';
+import { MainWindowPersist, TaskManagerWindowPersist } from './Constants.js';
+
+export const requestHandler = Symbol('requestHandler');
+
+// const re = /import\s*(?:["']?([\w*{}\n, ]+)from\s*)?\s*["']?([@\w/\._-]+)["'].*/gm;
+const locationPrefixes = ['web_modules', 'node_modules', 'src'];
+
+/**
+ * A class responsible for handling `web-module:` protocol.
+ *
+ * Components protocol is used to load ES modules with correct mime types.
+ *
+ * Example usage in the renderer process:
+ *
+ * ```
+ *
+ * ```
+ *
+ * This checks for existing component in following order:
+ * - ./bower_components/{url} (application main components)
+ * - {applicationUserDataDir}/{url} (application modules installation root)
+ * - {url} (filesystem)
+ *
+ * If the component does not exists then it throws an error.
+ */
+export class EsmProtocol {
+ constructor() {
+ this[requestHandler] = this[requestHandler].bind(this);
+ /**
+ * Base path to the application folder.
+ * @type {String}
+ */
+ this.basePath = path.join(__dirname, '..', '..');
+ }
+
+ /**
+ * Registers the protocol handler.
+ * This must be called after the `ready` event.
+ */
+ register() {
+ logger.debug('Registering ESM protocol');
+ session.fromPartition(MainWindowPersist)
+ .protocol
+ .registerBufferProtocol('web-module', this[requestHandler]);
+ protocol
+ .registerBufferProtocol('web-module', this[requestHandler]);
+ session.fromPartition(TaskManagerWindowPersist)
+ .protocol
+ .registerBufferProtocol('web-module', this[requestHandler]);
+ }
+
+ /**
+ * @param {Electron.ProtocolRequest} request
+ * @param {(response: string | Electron.ProtocolResponse) => void} callback
+ * @returns
+ */
+ [requestHandler](request, callback) {
+ const url = new URL(request.url);
+ let fileLocation = this.findFile(url.pathname);
+ fileLocation = decodeURI(fileLocation);
+ // logger.silly(`EsmProtocolHandler::[requestHandler]: ${fileLocation}`);
+ fs.readFile(fileLocation, async (error, data) => {
+ if (error) {
+ logger.error(error);
+ // The file or directory cannot be found.
+ // NET_ERROR(FILE_NOT_FOUND, -6)
+ // @ts-ignore
+ callback(-6);
+ } else {
+ // let content = data;
+ const mimeType = mime.lookup(fileLocation) || 'application/octet-stream';
+ // if (fileLocation.includes('node_modules/@api-modeling/')) {
+ // let str = data.toString();
+ // const matches = [...str.matchAll(re)];
+ // if (matches.length) {
+ // str = await this.makeRelativePaths(str, fileLocation, matches);
+ // }
+ // content = Buffer.from(str);
+ // }
+ callback({
+ mimeType,
+ data,
+ });
+ }
+ });
+ }
+
+ /**
+ * Finds a file location in one of the predefined paths.
+ * @param {string} filepath Request path
+ * @param {string[]} prefixes Location prefixes
+ * @returns {string} Location of the file.
+ */
+ findFile(filepath, prefixes = locationPrefixes) {
+ for (let i = 0, len = prefixes.length; i }
+ */
+ [actionHandler](e, action, ...args) {
+ switch (action) {
+ case 'create-file': return this[saveHandler](args[0], args[1]);
+ case 'list-folders': return this[listFoldersHandler](args[0]);
+ case 'create-app-folder': return this[createFolderHandler](args[0], args[1]);
+ case 'get-file': return this.getFile(args[0], args[1]);
+ default: throw new Error('Unknown action.');
+ }
+ }
+
+ /**
+ * @param {SaveDriveFileOptions} config The file meta data
+ * @param {any} data The data to store
+ */
+ async [saveHandler](config, data) {
+ const { auth, id, meta } = config;
+ const resource = this._createResource(meta);
+ const media = this._createMedia(meta.mimeType, data);
+ if (id) {
+ return this.update(id, resource, media, config.parent, auth);
+ }
+ return this.create(resource, media, config.parent, auth);
+ }
+
+ /**
+ * @param {any} opts
+ */
+ async [listFoldersHandler](opts={}) {
+ if (this.cachedFolders) {
+ return this.cachedFolders;
+ }
+ const { auth } = opts;
+ const result = await this.listAppFolders(auth);
+ const folders = [];
+ if (result.files) {
+ result.files.forEach((item) => {
+ folders[folders.length] = {
+ id: item.id,
+ name: item.name,
+ };
+ });
+ }
+ this.cachedFolders = folders;
+ return folders;
+ }
+
+ /**
+ * @param {string} name
+ * @param {OAuth2Authorization=} auth
+ * @return {Promise}
+ */
+ async [createFolderHandler](name, auth={}) {
+ return this.ensureParent(name, auth);
+ }
+
+ /**
+ * Creates media data used by this library
+ * @param {string} contentType The content type of the file.
+ * @param {any} data The data to upload.
+ * @return {FileMedia} Resource object
+ */
+ _createMedia(contentType, data) {
+ let body = data;
+ if (typeof body !== 'string') {
+ body = JSON.stringify(body);
+ }
+ const media = {
+ mimeType: contentType || this.fileType,
+ body,
+ };
+ return media;
+ }
+
+ /**
+ * Creates resource data for Drive file.
+ * @param {FileResource} meta Passed user configuration
+ * @return {FileResource} Resource object
+ */
+ _createResource(meta) {
+ const result = { ...meta };
+ if (!result.description && this.fileDescription) {
+ result.description = this.fileDescription;
+ }
+ if (!result.mimeType && this.fileType) {
+ result.mimeType = this.fileType;
+ }
+ return result;
+ }
+
+ /**
+ * Authorize the user with Google Drive.
+ * @param {OAuth2Authorization=} auth Passed `auth` object to create / update functions.
+ * @return {Promise} Promise resolved to token info object.
+ */
+ async auth(auth) {
+ if (auth) {
+ if (auth.accessToken) {
+ return auth;
+ }
+ return Oauth2Identity.launchWebAuthFlow(auth);
+ }
+ return Oauth2Identity.getAuthToken({ interactive: true });
+ }
+
+ /**
+ * Lists folders in Google Drive.
+ * With regular set of authorization scopes this function lists folders
+ * created by this application.
+ * With additional scopes it will list all folders.
+ * ARC uses default set of scopes meaning it will only list folders
+ * previously created by it (as ling as OAuth client id is the same).
+ * @param {OAuth2Authorization=} auth The auth configuration.
+ * @return {Promise} Promise resolved to Drive response.
+ */
+ async listAppFolders(auth) {
+ const info = await this.auth(auth);
+ if (info) {
+ return this._listAppFolders(info);
+ }
+ return undefined;
+ }
+
+ /**
+ * Implementation for folders listing
+ * @param {OAuth2Authorization} auth
+ * @return {Promise}
+ */
+ _listAppFolders(auth) {
+ const params = {
+ q: 'trashed = false and mimeType="application/vnd.google-apps.folder"',
+ orderBy: 'modifiedTime desc',
+ };
+ let url = 'https://www.googleapis.com/drive/v3/files?';
+ Object.keys(params).forEach((key) => {
+ url += `${key}=${encodeURIComponent(params[key])}&`;
+ });
+ return new Promise((resolve, reject) => {
+ const request = net.request({
+ method: 'GET',
+ url,
+ });
+ request.setHeader('authorization', `Bearer ${auth.accessToken}`);
+ request.setHeader('accept', 'application/json');
+ request.on('response', (response) => {
+ const body = /** @type Buffer[] */ ([]);
+ response.on('data', (chunk) => {
+ body.push(chunk);
+ });
+ response.on('end', () => {
+ const data = Buffer.concat(body).toString();
+ let parsed;
+ try {
+ parsed = JSON.parse(data);
+ } catch (e) {
+ reject(e);
+ return;
+ }
+ if (parsed.error) {
+ reject(new Error(parsed.message));
+ } else {
+ resolve(parsed);
+ }
+ });
+ });
+ request.on('error', (error) => {
+ reject(error);
+ });
+ request.end();
+ });
+ }
+
+ /**
+ * Creates a Google Drive File.
+ *
+ * If `config.resource.mimeType` is not set and `drive.file.mime` is set then
+ * `this.mime` is used instead.
+ *
+ * This script will automatically set file thumbnail if not set
+ * (`config.resource.contentHints.thumbnail` object value).
+ *
+ * @param {FileResource} resource File metadata.
+ * @param {FileMedia} media A data to send with content type.
+ * @param {string=} parent The parent of the file. It may be the id of existing folder or a name of a folder to create
+ * @param {OAuth2Authorization=} auth The optional authorization
+ * @return {Promise} Promise resolved to Drive response object.
+ */
+ async create(resource, media, parent, auth) {
+ if (!resource.mimeType && this.mime) {
+ resource.mimeType = this.mime;
+ }
+ const info = await this.auth(auth);
+ let parentInfo;
+ if (parent) {
+ parentInfo = await this.ensureParent(parent, info);
+ resource.parents = [parentInfo.id];
+ }
+ const token = info.accessToken;
+ const url = await this._initializeSession(token, resource);
+ const result = await this._upload(token, url, media.body, media.mimeType);
+ if (parentInfo) {
+ result.parents = [parentInfo];
+ }
+ return result;
+ }
+
+ /**
+ * Update a file on Google Drive.
+ *
+ * @param {String} fileId A Google Drive file ID.
+ * @param {FileResource} resource The same as for `create` function.
+ * @param {FileMedia} media The same as for `create` function.
+ * @param {string=} parent The parent of the file. It may be the id of existing folder or a name of a folder to create
+ * @param {OAuth2Authorization=} auth The optional authorization
+ * @return {Promise} Fulfilled promise with file properties (the response).
+ */
+ async update(fileId, resource, media, parent, auth) {
+ if (!resource.mimeType && this.mime) {
+ resource.mimeType = this.mime;
+ }
+ const info = await this.auth(auth);
+ const token = info.accessToken;
+ const url = await this._initializeSession(token, resource, fileId);
+ return this._upload(token, url, media.body, media.mimeType);
+ }
+
+ /**
+ * Initializes resumable session to upload a file to Google Drive.
+ * @param {string} token Authorization token
+ * @param {FileResource=} meta Optional file meta data to send with the request
+ * @param {string=} fileId If it is the update request, this is file id to update
+ * @return {Promise} The upload URL.
+ */
+ _initializeSession(token, meta, fileId) {
+ let url = 'https://www.googleapis.com/upload/drive/v3/files';
+ let method;
+ if (fileId) {
+ url += `/${fileId}?uploadType=resumable`;
+ method = 'PATCH';
+ } else {
+ url += '?uploadType=resumable';
+ method = 'POST';
+ }
+ return new Promise((resolve, reject) => {
+ const request = net.request({
+ method,
+ url,
+ });
+ request.setHeader('authorization', `Bearer ${token}`);
+ request.setHeader('Content-Type', 'application/json; charset=UTF-8');
+ request.on('response', (response) => {
+ if (response.statusCode >= 400) {
+ const body = [];
+ response.on('data', (chunk) => {
+ body.push(chunk);
+ });
+ response.on('end', () => {
+ const msg = `Could not initialize Drive upload session. Reason: ${Buffer.concat(body).toString()}`;
+ reject(new Error(msg));
+ });
+ return;
+ }
+ const result = response.headers.location;
+ if (result) {
+ resolve(Array.isArray(result) ? result[0] : result);
+ // response.destroy();
+ } else {
+ reject(new Error('Could not initialize Drive upload session.'));
+ }
+ });
+ request.on('error', (error) => {
+ reject(error);
+ });
+ const message = meta ? JSON.stringify(meta) : undefined;
+ request.write(message);
+ request.end();
+ });
+ }
+
+ /**
+ * Uploads the file to the upload endpoint.
+ * The `url` is received from the Drive upload location of the upload for
+ * the resource.
+ * @param {String} token
+ * @param {String} url
+ * @param {String} message
+ * @param {String} mimeType
+ * @return {Promise}
+ */
+ _upload(token, url, message, mimeType) {
+ return new Promise((resolve, reject) => {
+ const request = net.request({
+ method: 'PUT',
+ url,
+ });
+ request.setHeader('authorization', `Bearer ${ token}`);
+ request.setHeader('content-type', mimeType);
+ request.on('response', (response) => {
+ const body = [];
+ response.on('data', (chunk) => {
+ body.push(chunk);
+ });
+ response.on('end', () => {
+ const data = Buffer.concat(body).toString();
+ let parsed;
+ try {
+ parsed = JSON.parse(data);
+ } catch (e) {
+ reject(e);
+ return;
+ }
+ resolve(parsed);
+ });
+ });
+ request.on('error', (error) => {
+ reject(error);
+ });
+ request.write(message);
+ request.end();
+ });
+ }
+
+ /**
+ * @param {string} parent The parent id or name.
+ * @param {OAuth2Authorization=} auth The auth configuration.
+ * @return {Promise} The id of the parent to use with the resource,
+ */
+ async ensureParent(parent, auth) {
+ const result = await this.listAppFolders(auth);
+ if (result.files) {
+ const existing = result.files.find((item) => item.id === parent || item.name === parent);
+ if (existing) {
+ return existing;
+ }
+ }
+ return this.createFolder(parent, auth);
+ }
+
+ /**
+ * Creates a Google Drive folder.
+ *
+ * @param {string} parent The folder name
+ * @param {OAuth2Authorization=} auth Authorization data to use
+ * @return {Promise}
+ */
+ async createFolder(parent, auth) {
+ const info = await this.auth(auth);
+ const token = info.accessToken;
+ const item = await this._createFolder(parent, token);
+ if (!this.cachedFolders) {
+ this.cachedFolders = [];
+ }
+ this.cachedFolders.push(item);
+ return item;
+ }
+
+ /**
+ * Makes a request to Drive API to create a folder.
+ * @param {String} name Folder name
+ * @param {String} token Authorization token.
+ * @return {Promise} A promise resolved to created folder ID.
+ */
+ _createFolder(name, token) {
+ const url = 'https://content.googleapis.com/drive/v3/files?alt=json';
+ const mimeType = 'application/vnd.google-apps.folder';
+ const message = JSON.stringify({
+ name,
+ mimeType,
+ });
+ return new Promise((resolve, reject) => {
+ const request = net.request({
+ method: 'POST',
+ url,
+ });
+ request.setHeader('authorization', `Bearer ${token}`);
+ request.setHeader('content-type', 'application/json');
+ request.on('response', (response) => {
+ const body = /** @type Buffer[] */ ([]);
+ response.on('data', (chunk) => {
+ body.push(chunk);
+ });
+ response.on('end', () => {
+ const data = Buffer.concat(body).toString();
+ let parsed;
+ try {
+ parsed = JSON.parse(data);
+ } catch (e) {
+ reject(e);
+ return;
+ }
+ if (parsed.error) {
+ reject(new Error(parsed.message));
+ } else {
+ resolve(parsed);
+ }
+ });
+ });
+ request.on('error', (error) => {
+ reject(error);
+ });
+ request.write(message);
+ request.end();
+ });
+ }
+
+ /**
+ * Downloads the file data by given ID.
+ * @param {string} id File ID
+ * @param {OAuth2Authorization=} auth Authorization data to use
+ * @return {Promise} Promise resolved to file's string data.
+ */
+ async getFile(id, auth) {
+ const info = await this.auth(auth);
+ return this._downloadFile(info, id);
+ }
+
+ /**
+ * Makes a request to Drive API to download file content.
+ * @param {OAuth2Authorization} auth Authorization object.
+ * @param {string} id File id
+ * @return {Promise}
+ */
+ _downloadFile(auth, id) {
+ const url = `https://www.googleapis.com/drive/v3/files/${id}?alt=media`;
+ return new Promise((resolve, reject) => {
+ const request = net.request({
+ method: 'GET',
+ url,
+ });
+ request.setHeader('authorization', `Bearer ${auth.accessToken}`);
+ request.on('response', (response) => {
+ let isError = false;
+ if (response.statusCode >= 400) {
+ isError = true;
+ }
+ const body = [];
+ response.on('data', (chunk) => {
+ body.push(chunk);
+ });
+ response.on('end', () => {
+ let data = Buffer.concat(body).toString();
+ if (isError) {
+ try {
+ let tmp = JSON.parse(data);
+ if (tmp.error) {
+ tmp = tmp.error;
+ }
+ if (tmp.message) {
+ data = (tmp.code ? (`${String(tmp.code)}: `) : '') + tmp.message;
+ }
+ } catch (_) {
+ // ...
+ }
+ reject(new Error(data));
+ } else {
+ resolve(data);
+ }
+ });
+ });
+ request.on('error', (error) => {
+ reject(error);
+ });
+ request.end();
+ });
+ }
+}
diff --git a/scripts/main/logger.js b/src/io/Logger.js
similarity index 56%
rename from scripts/main/logger.js
rename to src/io/Logger.js
index 96582395..835b969f 100644
--- a/scripts/main/logger.js
+++ b/src/io/Logger.js
@@ -1,22 +1,21 @@
-const path = require('path');
-const { app } = require('electron');
+/* eslint-disable no-param-reassign */
+/* eslint-disable no-console */
+import { app } from 'electron';
+import path from 'path';
+import { createLogger, format, transports } from 'winston';
-const { createLogger, format, transports } = require('winston');
const { combine, timestamp, printf } = format;
-const myFormat = printf((info) => {
- return `[${new Date(info.timestamp).toLocaleString()}]: ${info.level} ${info.message}`;
-});
+const myFormat = printf((info) => `[${new Date(info.timestamp).toLocaleString()}]: ${info.level} ${info.message}`);
let logRoot;
try {
logRoot = app.getPath('logs');
} catch (_) {
- logRoot = app.getPath('userData', 'logs');
+ logRoot = path.join(app.getPath('userData'), 'logs');
}
const logPath = path.join(logRoot, 'log.log');
const errorPath = path.join(logRoot, 'error.log');
-
const logger = createLogger({
exitOnError: false,
level: 'warning',
@@ -47,5 +46,19 @@ const logger = createLogger({
)
});
+/**
+ *
+ * @param {'debug'|'error'|'info'|'silly'|'verbose'|'warn'} level
+ */
+function setLevel(level) {
+ logger.transports.forEach((transport) => {
+ if (transport.level === undefined) {
+ return;
+ }
+ transport.level = level;
+ });
+}
+
+
console.log('Log file path is', logPath);
-module.exports = logger;
+export { logger, setLevel };
diff --git a/src/io/PopupMenuService.js b/src/io/PopupMenuService.js
new file mode 100644
index 00000000..b6d68be8
--- /dev/null
+++ b/src/io/PopupMenuService.js
@@ -0,0 +1,168 @@
+import { ipcMain } from 'electron';
+import { logger } from './Logger.js';
+
+/** @typedef {import('./WindowsManager').WindowsManager} WindowsManager */
+
+export const popupAppMenuHandler = Symbol('popupAppMenuHandler');
+export const windowClosedHandler = Symbol('windowClosedHandler');
+export const popupNavHandler = Symbol('popupNavHandler');
+export const addListeners = Symbol('addListeners');
+export const removeListeners = Symbol('removeListeners');
+export const createWindow = Symbol('createWindow');
+export const loadPage = Symbol('loadPage');
+
+/**
+ * Application menu by default is embedded in main application window.
+ * User has an option to pop up menu to a new window. This class handles
+ * events from the renderer process to make it possible.
+ */
+export class PopupMenuService {
+ /**
+ * @param {WindowsManager} wm
+ */
+ constructor(wm) {
+ this.wm = wm;
+ this.menuWindows = new Map();
+
+ this[popupAppMenuHandler] = this[popupAppMenuHandler].bind(this);
+ this[windowClosedHandler] = this[windowClosedHandler].bind(this);
+ this[popupNavHandler] = this[popupNavHandler].bind(this);
+ }
+
+ listen() {
+ logger.debug('Listening for menu popup events');
+ ipcMain.on('popup-app-menu', this[popupAppMenuHandler]);
+ ipcMain.on('popup-app-menu-nav', this[popupNavHandler]);
+ }
+
+ /**
+ * Handler for `popup-app-menu` event dispatched by ARC windows.
+ * @param {Event} e
+ * @param {string} type Menu type
+ * @param {object=} sizing `width` and `height`
+ */
+ [popupAppMenuHandler](e, type, sizing) {
+ logger.debug('Handling menu popup event from app window.');
+ if (this.menuWindows.has(type)) {
+ logger.debug('Showing existing window.');
+ const menu = this.menuWindows.get(type);
+ menu.show();
+ return;
+ }
+ this.createMenuWindow(type, sizing);
+ }
+
+ /**
+ * Creates menu window object.
+ * If the `type` already exists then nothing happens.
+ * @param {string} type Menu type
+ * @param {object=} sizing `width` and `height`
+ */
+ async createMenuWindow(type, sizing={}) {
+ if (this.menuWindows.has(type)) {
+ return;
+ }
+ logger.debug(`Creating menu popup window for type: ${type}`);
+ const width = sizing.width ? sizing.width : 320;
+ const height = sizing.height ? sizing.height : 800;
+ const win = await this.wm.open({
+ sizing: {
+ width,
+ height,
+ },
+ params: {
+ type
+ },
+ // noMenu: true,
+ page: 'popup-menu.html',
+ preload: 'popup-menu.js',
+ });
+ this[addListeners](win);
+ this.menuWindows.set(type, win);
+ this.wm.notifyAll('popup-app-menu-opened', type);
+ }
+
+ /**
+ * @param {Electron.BrowserWindow} bw
+ */
+ [addListeners](bw) {
+ bw.addListener('closed', this[windowClosedHandler]);
+ }
+
+ /**
+ * @param {Electron.BrowserWindow} bw
+ */
+ [removeListeners](bw) {
+ bw.removeListener('closed', this[windowClosedHandler]);
+ }
+
+ /**
+ * Handler for the BrowserWindow `closed` event.
+ *
+ * @param {Electron.Event} e Event emitted by the window.
+ */
+ [windowClosedHandler](e) {
+ // @ts-ignore
+ const win = /** @type BrowserWindow */ (e.sender);
+ const entires = this.menuWindows.entries();
+ let type;
+ for (const [key, value] of entires) {
+ if (value === win) {
+ type = key;
+ break;
+ }
+ }
+ if (!type) {
+ return;
+ }
+ this[removeListeners](win);
+ this.menuWindows.delete(type);
+ this.wm.notifyAll('popup-app-menu-closed', type);
+ }
+
+ /**
+ * Handler for an event dispatched by popup menu when navigation action was
+ * performed.
+ * @param {Event} e
+ * @param {string} type Navigation type
+ * @param {...string[]} detail Arguments
+ */
+ [popupNavHandler](e, type, ...detail) {
+ logger.debug('Handling popup menu event from the menu.');
+ if (!this.wm.hasWindow) {
+ logger.warn('Popup menu event handled without menu window registered.');
+ return;
+ }
+ const win = this.wm.lastArcFocused;
+ if (!win) {
+ logger.warn('Unable to perform navigation. No active window found.');
+ return;
+ }
+ logger.debug('Sending navigate event to the renderer process.');
+ win.webContents.send('app-navigate', type, detail);
+ }
+
+ /**
+ * Removes all generated menu windows.
+ */
+ clear() {
+ logger.debug('Removing all menu popup windows.');
+ for (const win of this.menuWindows.values()) {
+ win.destroy();
+ }
+ }
+
+ /**
+ * Toggles entire menu window.
+ */
+ togglePopupMenu() {
+ logger.debug('Toggling menu popup window.');
+ const win = this.menuWindows.get('*');
+ if (win) {
+ win.destroy();
+ } else {
+ this.clear();
+ this.createMenuWindow('*');
+ }
+ }
+}
diff --git a/src/io/PreferencesManager.js b/src/io/PreferencesManager.js
new file mode 100644
index 00000000..9c74f13c
--- /dev/null
+++ b/src/io/PreferencesManager.js
@@ -0,0 +1,122 @@
+import { ipcMain } from 'electron';
+import log from 'electron-log';
+import { ArcPreferences } from "../common/ArcPreferences.js";
+
+/** @typedef {import('@advanced-rest-client/arc-types').Config.ARCConfig} ARCConfig */
+
+export const readHandler = Symbol('readHandler');
+export const changeHandler = Symbol('changeHandler');
+
+export class PreferencesManager extends ArcPreferences {
+ /**
+ * @constructor
+ *
+ * @param {string} file The settings file name
+ */
+ constructor(file) {
+ super(file);
+ this[readHandler] = this[readHandler].bind(this);
+ this[changeHandler] = this[changeHandler].bind(this);
+ }
+
+ /**
+ * Listens for application events related to preferences management.
+ */
+ observe() {
+ ipcMain.handle('preferences-read', this[readHandler]);
+ ipcMain.handle('preferences-update', this[changeHandler]);
+ }
+
+ /**
+ * Loads current settings from settings file.
+ * This is just to provide typings.
+ *
+ * @returns {Promise} Promise resolved to a settings file.
+ */
+ async load() {
+ return super.load();
+ }
+
+ async [readHandler]() {
+ let data;
+ try {
+ data = await this.load();
+ } catch (cause) {
+ log.error(cause);
+ // eslint-disable-next-line no-console
+ console.error(cause);
+ throw cause;
+ }
+ return data;
+ }
+
+ /**
+ * Handler for the IPC `update-app-preference` event
+ *
+ * @param {Event} event
+ * @param {string} path Preference name
+ * @param {any} value Preference value
+ */
+ async [changeHandler](event, path, value) {
+ try {
+ const data = await this.load();
+ this.updateValue(data, path, value);
+ await this.store();
+ this.informChange(path, value);
+ } catch (cause) {
+ log.error(cause);
+ // eslint-disable-next-line no-console
+ console.error(cause);
+ throw cause;
+ }
+ }
+
+ /**
+ * Informs all available windows about the change in the preferences.
+ * @param {string} name Preference name
+ * @param {string} value New value
+ */
+ informChange(name, value) {
+ this.emit('settings-changed', name, value);
+ }
+
+ /**
+ * Creates default settings object.
+ *
+ * @return {Promise} Default settings object.
+ */
+ async defaultSettings() {
+ return /** @type ARCConfig */ ({
+ view: {
+ draggableEnabled: true,
+ listType: 'default',
+ popupMenu: true,
+ },
+ history: {
+ enabled: true,
+ fastSearch: true,
+ },
+ privacy: {
+ telemetry: false,
+ exceptionsOnly: true,
+ },
+ request: {
+ followRedirects: true,
+ useAppVariables: true,
+ useSystemVariables: true,
+ },
+ requestEditor: {
+ bodyEditor: 'Monaco',
+ progressInfo: true,
+ sendButton: true,
+ },
+ response: {
+ warningResponseMaxSize: 2048,
+ forceRawSize: 4096,
+ },
+ updater: {
+ auto: true,
+ },
+ });
+ }
+}
diff --git a/src/io/SessionManager.js b/src/io/SessionManager.js
new file mode 100644
index 00000000..d255f8cb
--- /dev/null
+++ b/src/io/SessionManager.js
@@ -0,0 +1,367 @@
+/* eslint-disable no-await-in-loop */
+import { session, BrowserWindow, ipcMain, app } from 'electron';
+import { EventEmitter } from 'events';
+import { WebSessionPersist } from './Constants.js';
+import { logger } from './Logger.js';
+
+/** @typedef {import('../types').SessionManagerConfig} SessionManagerConfig */
+/** @typedef {import('electron').Cookie} Cookie */
+/** @typedef {import('electron').Cookies} Cookies */
+/** @typedef {import('electron').CookiesSetDetails} CookiesSetDetails */
+
+const cookieChangedHandler = Symbol('cookieChangedHandler');
+const getAllCookiesHandler = Symbol('getAllCookiesHandler');
+const openSessionWindowHandler = Symbol('openSessionWindowHandler');
+const computeCookieUrl = Symbol('computeCookieUrl');
+const getDomainCookiesHandler = Symbol('getDomainCookiesHandler');
+const getUrlCookiesHandler = Symbol('getUrlCookiesHandler');
+const setCookieHandler = Symbol('setCookieHandler');
+const setCookiesHandler = Symbol('setCookiesHandler');
+const removeCookieHandler = Symbol('removeCookieHandler');
+const removeCookiesHandler = Symbol('removeCookiesHandler');
+const handleCertIssue = Symbol('handleCertIssue');
+const isAppUsedUrl = Symbol('isAppUsedUrl');
+const sessionValue = Symbol('sessionValue');
+
+/**
+ * A class responsible for managing chrome web session.
+ */
+export class SessionManager extends EventEmitter {
+ /**
+ * @return {Cookies} Instance of the session cookies object
+ */
+ get session() {
+ let existing = this[sessionValue];
+ if (!existing) {
+ this[sessionValue] = this.getSessionCookies();
+ existing = this[sessionValue];
+ }
+ return existing;
+ }
+
+ /**
+ * @param {SessionManagerConfig=} opts Configuration options
+ */
+ constructor(opts={}) {
+ super();
+ this.appUrls = opts.appUrls;
+
+ [
+ cookieChangedHandler,
+ getAllCookiesHandler,
+ openSessionWindowHandler,
+ getDomainCookiesHandler,
+ getUrlCookiesHandler,
+ setCookieHandler,
+ setCookiesHandler,
+ removeCookieHandler,
+ removeCookiesHandler,
+ handleCertIssue,
+ ].forEach((symbol) => {
+ this[symbol] = this[symbol].bind(this);
+ });
+ }
+
+ /**
+ * Listens on the IPC events from the renderer
+ */
+ listen() {
+ this.session.on('changed', this[cookieChangedHandler]);
+ ipcMain.on('open-web-url', this[openSessionWindowHandler]);
+ ipcMain.handle('cookies-session-get-all', this[getAllCookiesHandler]);
+ ipcMain.handle('cookies-session-get-domain', this[getDomainCookiesHandler]);
+ ipcMain.handle('cookies-session-get-url', this[getUrlCookiesHandler]);
+ ipcMain.handle('cookies-session-set-cookie', this[setCookieHandler]);
+ ipcMain.handle('cookies-session-set-cookies', this[setCookiesHandler]);
+ ipcMain.handle('cookies-session-remove-cookie', this[removeCookieHandler]);
+ ipcMain.handle('cookies-session-remove-cookies', this[removeCookiesHandler]);
+ app.on('certificate-error', this[handleCertIssue]);
+ }
+
+ /**
+ * Un-listens previously registered listeners
+ */
+ unlisten() {
+ this.session.removeListener('changed', this[cookieChangedHandler]);
+ ipcMain.removeListener('open-web-url', this[openSessionWindowHandler]);
+ ipcMain.removeHandler('cookies-session-get-all');
+ ipcMain.removeHandler('cookies-session-get-domain');
+ ipcMain.removeHandler('cookies-session-get-url');
+ ipcMain.removeHandler('cookies-session-set-cookie');
+ ipcMain.removeHandler('cookies-session-set-cookies');
+ ipcMain.removeHandler('cookies-session-remove-cookie');
+ ipcMain.removeHandler('cookies-session-remove-cookies');
+ app.removeListener('certificate-error', this[handleCertIssue]);
+ this[sessionValue] = null;
+ }
+
+ /**
+ * @param {Event} e
+ * @param {string} url
+ * @param {string} purpose
+ */
+ [openSessionWindowHandler](e, url, purpose) {
+ switch (purpose) {
+ case 'web-session': this.openWebBrowser(url); break;
+ default:
+ }
+ }
+
+ /**
+ * @param {Event} e
+ * @param {Cookie} cookie
+ * @param {string} cause
+ * @param {boolean} removed
+ */
+ [cookieChangedHandler](e, cookie, cause, removed) {
+ const data = {
+ cookie,
+ cause,
+ removed,
+ };
+ this.emit('cookie-changed', data);
+ }
+
+ /**
+ * @return {Cookies} Electron's Cookies class instance for session window.
+ */
+ getSessionCookies() {
+ const sis = session.fromPartition(WebSessionPersist);
+ return sis.cookies;
+ }
+
+ /**
+ * Retrieves all cookies stored with the session.
+ * @return {Promise} A promise resolved to a list of cookies.
+ */
+ async [getAllCookiesHandler]() {
+ return this.getAllCookies();
+ }
+
+ /**
+ * Retrieves all cookies stored with the session.
+ * @return {Promise} A promise resolved to a list of cookies.
+ */
+ async getAllCookies() {
+ return this.session.get({});
+ }
+
+ /**
+ * Retrieves cookies stored with the session for given domain.
+ * @param {String} domain
+ * @return {Promise} A promise resolved to a list of cookies.
+ */
+ async getDomainCookies(domain) {
+ return this.session.get({ domain });
+ }
+
+ /**
+ * Retrieves cookies stored with the session for given url.
+ * @param {string} url
+ * @return {Promise} A promise resolved to a list of cookies.
+ */
+ async getUrlCookies(url) {
+ return this.session.get({ url });
+ }
+
+ /**
+ * Computes a cookie URL from the cookie definition
+ *
+ * @param {Cookie} cookie
+ * @param {boolean=} secured
+ * @return {string}
+ */
+ [computeCookieUrl](cookie, secured=false) {
+ let { domain='' } = cookie;
+ if (domain[0] === '.') {
+ domain = domain.substr(1);
+ }
+ let protocol = 'http';
+ if (secured) {
+ protocol += 's';
+ }
+ protocol += '://';
+ return protocol + domain + (cookie.path || '/');
+ }
+
+ /**
+ * Sets a cookie in the cookie store
+ *
+ * @param {CookiesSetDetails|Cookie} cookie
+ * @return {Promise}
+ */
+ async setCookie(cookie) {
+ const typedSet = /** @type CookiesSetDetails */ (cookie);
+ const typed = /** @type Cookie */ (cookie);
+ if (!typedSet.url) {
+ typedSet.url = this[computeCookieUrl](typed, cookie.secure);
+ }
+ try {
+ await this.session.remove(typedSet.url, typedSet.name);
+ await this.session.set(typedSet);
+ await this.session.flushStore();
+ } catch (e) {
+ logger.error(e.message);
+ logger.error(e);
+ }
+ return typedSet;
+ }
+
+ /**
+ * Removes a cookie from the store
+ *
+ * @param {Cookie | CookiesSetDetails} cookie
+ * @param {boolean} flush
+ * @return {Promise}
+ */
+ async removeCookie(cookie, flush=true) {
+ const typed = /** @type CookiesSetDetails */ (cookie);
+ const { name, url } = typed;
+ if (url) {
+ await this.session.remove(url, name);
+ } else {
+ const typedCookie = /** @type Cookie */ (cookie);
+ await this.removeCookieMakeUrl(typedCookie, name);
+ }
+ if (flush) {
+ await this.session.flushStore();
+ }
+ }
+
+ /**
+ * Removes a cookie from the store using cookie details to construct the URL.
+ *
+ * @param {Cookie} cookie
+ * @param {string} name
+ * @return {Promise}
+ */
+ async removeCookieMakeUrl(cookie, name) {
+ const typed = /** @type Cookie */ (cookie);
+ const httpUrl = this[computeCookieUrl](typed);
+ const httpsUrl = this[computeCookieUrl](typed, true);
+ await this.session.remove(httpUrl, name);
+ await this.session.remove(httpsUrl, name);
+ }
+
+ /**
+ * Opens a new browser window for given URL so the user can
+ * authenticate himself in the external service and the app will store
+ * cookies from this session.
+ * @param {string} url An URL to open
+ * @return {BrowserWindow} an instance of created window.
+ */
+ openWebBrowser(url) {
+ const bw = new BrowserWindow({
+ webPreferences: {
+ partition: WebSessionPersist,
+ nodeIntegration: false,
+ },
+ });
+ bw.loadURL(url, { userAgent: 'Chrome' });
+ return bw;
+ }
+
+ /**
+ * Handler for the read cookies for a domain event
+ * @param {Event} e
+ * @param {string} domain
+ * @return {Promise}
+ */
+ async [getDomainCookiesHandler](e, domain) {
+ return this.getDomainCookies(domain);
+ }
+
+ /**
+ * Handler for the list all cookies event
+ * @param {Event} e
+ * @param {string} url
+ * @return {Promise}
+ */
+ async [getUrlCookiesHandler](e, url) {
+ return this.getUrlCookies(url);
+ }
+
+ /**
+ * @param {Event} e
+ * @param {Cookie | CookiesSetDetails} cookie
+ * @return {Promise}
+ */
+ async [setCookieHandler](e, cookie) {
+ return this.setCookie(cookie);
+ }
+
+ /**
+ * @param {Event} e
+ * @param {(Cookie | CookiesSetDetails)[]} cookies
+ * @return {Promise}
+ */
+ async [setCookiesHandler](e, cookies) {
+ for (let i = 0, len = cookies.length; i < len; i++) {
+ await this.setCookie(cookies[i]);
+ }
+ }
+
+ /**
+ * @param {Event} e
+ * @param {(Cookie | CookiesSetDetails)[]} cookies
+ * @return {Promise}
+ */
+ async [removeCookiesHandler](e, cookies) {
+ for (let i = 0, len = cookies.length; i < len; i++) {
+ await this.removeCookie(cookies[i], false);
+ }
+ await this.session.flushStore();
+ }
+
+ /**
+ * @param {Event} e
+ * @param {Cookie | CookiesSetDetails} cookie
+ * @return {Promise}
+ */
+ async [removeCookieHandler](e, cookie) {
+ await this.removeCookie(cookie);
+ }
+
+ /**
+ * Allows to ignore certificate errors when opening session window.
+ *
+ * @param {Event} e
+ * @param {Object} webContents
+ * @param {String} url
+ * @param {Object} error
+ * @param {Object} certificate
+ * @param {Function} callback
+ */
+ [handleCertIssue](e, webContents, url, error, certificate, callback) {
+ if (this[isAppUsedUrl](url)) {
+ callback(false);
+ } else {
+ e.preventDefault();
+ callback(true);
+ }
+ }
+
+ /**
+ * Checks if given URL is used by the application to request an external resource.
+ * It is used by the `[handleCertIssue]()` function to determine if allow
+ * bypass certificate error.
+ * Each application registered URL should be evaluated by Chromium default
+ * certificate test engine. Otherwise it's a user entered URL in
+ * web session and certificate test should be bypassed.
+ *
+ * @param {string} url An url
+ * @return {boolean} True if certificate validation should be applied.
+ */
+ [isAppUsedUrl](url) {
+ const { appUrls } = this;
+ if (!url || !appUrls || !appUrls.length) {
+ return false;
+ }
+ for (let i = 0, len = this.appUrls.length; i < len; i++) {
+ if (url.indexOf(this.appUrls[i]) !== -1) {
+ return true;
+ }
+ }
+ return false;
+ }
+}
diff --git a/src/io/TelemetryConsent.js b/src/io/TelemetryConsent.js
new file mode 100644
index 00000000..0c787b72
--- /dev/null
+++ b/src/io/TelemetryConsent.js
@@ -0,0 +1,67 @@
+/* eslint-disable no-param-reassign */
+import fs from 'fs-extra';
+import path from 'path';
+import { ipcMain, app, shell } from 'electron';
+
+/** @typedef {import('./WindowsManager').WindowsManager} WindowsManager */
+
+/**
+ * Users privacy is a great concern for this project. Therefore this class
+ * runs before the any ARC window is created to ask whether the user consent to
+ * send limited and anonymous data to Google Analytics.
+ *
+ * This checks whether the lock file is created in the application folder. If so the
+ * consent flow is canceled.
+ * It renders the UI to ask the user about the analytics data. The user choice is
+ * reflected in the application configuration.
+ */
+export class TelemetryConsent {
+ /**
+ * @param {WindowsManager} wm
+ */
+ constructor(wm) {
+ this.wm = wm;
+ this.lockFile = path.join(process.env.ARC_HOME, '.telemetry-consent.lock');
+ }
+
+ /**
+ * Runs the analytics data consent flow.
+ * @returns {Promise}
+ */
+ async run() {
+ const lockExists = await fs.pathExists(this.lockFile);
+ if (lockExists) {
+ return undefined;
+ }
+ await this.renderDialog();
+ ipcMain.on('telemetry-set', this.pageHandler.bind(this));
+ return new Promise((resolve) => {
+ this.resolve = resolve;
+ });
+ }
+
+ async renderDialog() {
+ const win = await this.wm.open({
+ ignoreWindowSessionSettings: true,
+ noMenu: true,
+ page: 'analytics-consent.html',
+ preload: 'arc-preload.js',
+ sizing: {
+ width: 1024,
+ height: 800,
+ }
+ });
+ this.loader = win;
+ win.setMenu(null);
+ win.webContents.on('new-window', (event, url) => {
+ event.preventDefault();
+ shell.openExternal(url);
+ });
+ }
+
+ async pageHandler() {
+ await fs.ensureFile(this.lockFile);
+ app.relaunch();
+ app.quit();
+ }
+}
diff --git a/src/io/ThemeManager.js b/src/io/ThemeManager.js
new file mode 100644
index 00000000..4b21e556
--- /dev/null
+++ b/src/io/ThemeManager.js
@@ -0,0 +1,186 @@
+/* eslint-disable no-param-reassign */
+import { ipcMain } from 'electron';
+import { ThemeInfo } from './models/ThemeInfo.js';
+import { ThemePluginsManager } from './ThemePluginsManager.js';
+import { logger } from './Logger.js';
+
+/** @typedef {import('./ArcEnvironment').ArcEnvironment} ArcEnvironment */
+/** @typedef {import('@advanced-rest-client/arc-types').Themes.ArcThemeStore} ArcThemeStore */
+/** @typedef {import('@advanced-rest-client/arc-types').Themes.InstalledTheme} InstalledTheme */
+
+export const checkUpdateDebounce = Symbol('checkUpdateDebounce');
+export const checkUpdate = Symbol('checkUpdate');
+
+export class ThemeManager {
+ /**
+ *
+ * @param {ArcEnvironment} arcApp
+ * @param {boolean} skipUpdateCheck
+ */
+ constructor(arcApp, skipUpdateCheck) {
+ this.arcApp = arcApp;
+ /**
+ * ARC default theme ID
+ * @type {string}
+ */
+ this.defaultTheme = '@advanced-rest-client/arc-electron-default-theme';
+ this.readState = this.readState.bind(this);
+ this.readActive = this.readActive.bind(this);
+ this.activateTheme = this.activateTheme.bind(this);
+ this.installTheme = this.installTheme.bind(this);
+ this.uninstallTheme = this.uninstallTheme.bind(this);
+ this.updatePropertyHandler = this.updatePropertyHandler.bind(this);
+
+ this.manager = new ThemePluginsManager();
+ if (!skipUpdateCheck) {
+ this[checkUpdateDebounce]();
+ }
+ }
+
+ /**
+ * Creates a model for theme info file.
+ * @return {ThemeInfo}
+ */
+ get themeInfo() {
+ return new ThemeInfo();
+ }
+
+ /**
+ * Listens for the ipc events to support theme changes
+ */
+ listen() {
+ ipcMain.handle('theme-manager-read-themes', this.readState);
+ ipcMain.handle('theme-manager-active-theme-info', this.readActive);
+ ipcMain.handle('theme-manager-activate-theme', this.activateTheme);
+ ipcMain.handle('theme-manager-install-theme', this.installTheme);
+ ipcMain.handle('theme-manager-uninstall-theme', this.uninstallTheme);
+ ipcMain.handle('theme-manager-update-property', this.updatePropertyHandler);
+ }
+
+ /**
+ * Removes event listeners
+ */
+ unlisten() {
+ ipcMain.removeHandler('theme-manager-read-themes');
+ ipcMain.removeHandler('theme-manager-active-theme-info');
+ ipcMain.removeHandler('theme-manager-activate-theme');
+ ipcMain.removeHandler('theme-manager-install-theme');
+ ipcMain.removeHandler('theme-manager-uninstall-theme');
+ ipcMain.removeHandler('theme-manager-update-property');
+ }
+
+ /**
+ * Reads the current theme info
+ * @returns {Promise}
+ */
+ async readState() {
+ return this.themeInfo.load();
+ }
+
+ /**
+ * @returns {Promise}
+ */
+ async readActive() {
+ const state = await this.readState();
+ const { themes, active } = state;
+ if (!Array.isArray(themes)) {
+ throw new Error(`No installed themes available.`);
+ }
+ const { defaultTheme } = this;
+ // first find the active theme
+ let info = themes.find((theme) => theme.name === active || theme._id === active);
+ if (!info && active === defaultTheme) {
+ throw new Error(`The default theme is not installed.`);
+ }
+ if (info) {
+ return info;
+ }
+ // then find the default theme.
+ info = themes.find((theme) => theme.name === defaultTheme || theme._id === defaultTheme);
+ if (!info && active === defaultTheme) {
+ throw new Error(`The default theme is not installed.`);
+ }
+ return info;
+ }
+
+ /**
+ * A handler for the `theme-manager-activate-theme` event from the renderer
+ * process.
+ * @param {any} event
+ * @param {string} name
+ * @returns {Promise}
+ */
+ async activateTheme(event, name) {
+ await this.themeInfo.setActive(name);
+ this.arcApp.wm.notifyAll('theme-manager-theme-activated', name);
+ }
+
+ /**
+ * @param {any} e
+ * @param {string} name The theme to install
+ * @returns {Promise}
+ */
+ async installTheme(e, name) {
+ if (!name || typeof name !== 'string') {
+ throw new Error('The name is not valid.');
+ }
+ const index = name.indexOf('#');
+ let version;
+ if (index !== -1) {
+ version = name.substr(index + 1);
+ name = name.substr(0, index);
+ }
+ const info = await this.manager.install(name, version);
+ await this.activateTheme(e, info.name);
+ }
+
+ /**
+ * @param {any} e
+ * @param {string} name The theme to uninstall
+ * @returns {Promise}
+ */
+ async uninstallTheme(e, name) {
+ if (!name || typeof name !== 'string') {
+ throw new Error('The name is not valid.');
+ }
+ await this.manager.uninstall(name);
+ await this.activateTheme(e, this.defaultTheme);
+ }
+
+ [checkUpdateDebounce]() {
+ setTimeout(() => this[checkUpdate](), 10000);
+ }
+
+ async [checkUpdate]() {
+ logger.debug('Checking for themes updates...');
+ try {
+ const info = await this.manager.checkForUpdates();
+ if (!info || !info.length) {
+ logger.debug('Themes update not available.');
+ return;
+ }
+ logger.debug('Updating themes....');
+ const result = await this.manager.update(info);
+ result.forEach((item) => {
+ if (!item.error) {
+ return;
+ }
+ const { name, message } = item;
+ logger.info(`Theme ${name} update error: ${message}`);
+ });
+ logger.info('Themes updated. The change will be applied with next app reload.');
+ } catch (e) {
+ logger.error(e);
+ }
+ }
+
+ /**
+ * @param {any} e
+ * @param {string} path The path to the value
+ * @param {any} value The value to set.
+ * @returns {Promise}
+ */
+ async updatePropertyHandler(e, path, value) {
+ await this.themeInfo.setProperty(path, value);
+ }
+}
diff --git a/src/io/ThemePluginsManager.js b/src/io/ThemePluginsManager.js
new file mode 100644
index 00000000..0869d69f
--- /dev/null
+++ b/src/io/ThemePluginsManager.js
@@ -0,0 +1,347 @@
+/* eslint-disable no-await-in-loop */
+/* eslint-disable no-bitwise */
+/* eslint-disable no-param-reassign */
+import { app } from 'electron';
+import path from 'path';
+import fs from 'fs-extra';
+import { PluginManager } from 'live-plugin-manager';
+import semver from 'semver';
+import { ThemeInfo } from './models/ThemeInfo.js';
+import { logger } from './Logger.js';
+
+/** @typedef {import('@advanced-rest-client/arc-types').Themes.ArcThemeStore} ArcThemeStore */
+/** @typedef {import('@advanced-rest-client/arc-types').Themes.InstalledTheme} InstalledTheme */
+/** @typedef {import('live-plugin-manager').IPluginInfo} IPluginInfo */
+/** @typedef {import('live-plugin-manager').PackageInfo} PackageInfo */
+
+export class ThemePluginsManager {
+ #pluginManager = new PluginManager({
+ cwd: process.env.ARC_THEMES,
+ pluginsPath: process.env.ARC_THEMES
+ });
+
+
+ /**
+ * Creates a model for theme info file.
+ * @return {ThemeInfo}
+ */
+ get themeInfo() {
+ return new ThemeInfo();
+ }
+
+ /**
+ * Resolves file path to correct path if it's starts with `~`.
+ *
+ * @param {String} file Settings file path
+ * @return {String} Path to the file.
+ */
+ resolvePath(file) {
+ if (file && file[0] === '~') {
+ file = app.getPath('home') + file.substr(1);
+ }
+ return file;
+ }
+
+ /**
+ * Installs a theme package to the themes directory.
+ * @param {string} name NPM name or Github repo. Local paths are symlink to target location.
+ * @param {String=} version Theme version to install.
+ * @returns {Promise}
+ */
+ async install(name, version) {
+ let message = `Installing theme: ${name}`;
+ if (version) {
+ message += `, version ${version}`;
+ }
+ logger.info(message);
+ const info = await this._installPackage(name, version);
+ await this.themeInfo.addTheme(info);
+ return info;
+ }
+
+ /**
+ * Implementation of installation process.
+ *
+ * If the `name` argument represents a path to a directory then
+ * local installation is performed. PluginManager is used otherwise.
+ *
+ * @param {String} name NPM name or Github repo. Local paths are symlink
+ * to target location.
+ * @param {String} version Theme version to install.
+ * @return {Promise} Promise resolved to theme info object
+ */
+ _installPackage(name, version) {
+ try {
+ fs.accessSync(name, fs.constants.R_OK | fs.constants.X_OK);
+ return this._installLocalPackage(name);
+ } catch (_) {
+ return this._installRemotePackage(name, version);
+ }
+ }
+
+ /**
+ * Creates a symlink from a local package to themes directory.
+ * @param {string} name Package location.
+ * @return {Promise} Promise resolved to theme info object
+ */
+ async _installLocalPackage(name) {
+ logger.info('Installing theme from local sources...');
+ let pkg;
+ try {
+ pkg = await fs.readJson(path.join(name, 'package.json'));
+ } catch (e) {
+ logger.error(e);
+ throw new Error('Unable to read package.json file of the theme.');
+ }
+
+ const location = path.join(process.env.ARC_THEMES, pkg.name);
+ let mainFile;
+ if (pkg.main) {
+ mainFile = path.join(location, pkg.main);
+ } else {
+ mainFile = path.join(location, path.basename(name));
+ }
+
+ const info = /** @type InstalledTheme */ ({
+ isSymlink: true,
+ _id: pkg.name,
+ name: pkg.name,
+ version: pkg.version,
+ location,
+ mainFile,
+ description: pkg.description,
+ isDefault: false,
+ });
+ if (pkg.themeTitle) {
+ info.title = pkg.themeTitle;
+ }
+
+ await this._ensureSymlinkPath(location);
+ await fs.symlink(path.resolve(name), path.resolve(info.location), 'dir');
+
+ logger.info('Installation complete.');
+ return info;
+ }
+
+ /**
+ * Ensures the path to create a symlink is created.
+ * @param {string} location Symlink location
+ * @return {Promise}
+ */
+ async _ensureSymlinkPath(location) {
+ location = path.dirname(location);
+ await fs.ensureDir(location);
+ }
+
+ /**
+ * Uses PluginManager to install package from npm or GitHub.
+ * @param {string} name NPM name or Github repo. Local paths are symlink
+ * to target location.
+ * @param {string} version Theme version to install.
+ * @return {Promise} Promise resolved to theme info object
+ */
+ async _installRemotePackage(name, version) {
+ logger.info('Installing theme from remote sources...');
+ const [n, v] = this._prepareSourceAndVersion(name, version);
+ const result = await this.#pluginManager.install(n, v);
+ const info = /** @type InstalledTheme */ ({
+ isSymlink: false,
+ _id: result.name,
+ name: result.name,
+ version: result.version,
+ location: result.location,
+ mainFile: result.mainFile,
+ title: '',
+ description: '',
+ isDefault: false,
+ });
+ return info;
+ }
+
+ /**
+ * Uninstalls package and removes it from the registry file.
+ * @param {string} name Name of the package.
+ * @return {Promise}
+ */
+ async uninstall(name) {
+ logger.info(`Uninstalling theme ${name}`);
+ await this._uninstallPackage(name);
+ await this.themeInfo.removeTheme(name);
+ }
+
+ /**
+ * Implementation of removing process.
+ * @param {string} name NPM name or Github repo. Local paths are symlink
+ * to target location.
+ * @return {Promise} Promise resolved to theme info object
+ */
+ async _uninstallPackage(name) {
+ const info = await this.themeInfo.readTheme(name);
+ if (!info) {
+ throw new Error(`Package ${name} is not installed.`);
+ }
+ if (info.isSymlink) {
+ await fs.remove(info.location);
+ } else {
+ await this.#pluginManager.uninstall(info.name);
+ }
+ return info;
+ }
+
+ /**
+ * Updates themes from passed list.
+ * @param {{name: string, version: string}[]} data A list of objects with `name` and `version`
+ * @returns {Promise<{name: string, error: boolean, message?: string}[]>} Update result.
+ */
+ async update(data) {
+ const result = [];
+ for (let i = 0, len = data.length; i < len; i++) {
+ const { name, version } = data[i];
+ try {
+ await this._installPackage(name, version);
+ await this.themeInfo.setThemeVersion(name, version);
+ result[result.length] = {
+ error: false,
+ name,
+ };
+ } catch (e) {
+ result[result.length] = {
+ error: true,
+ message: e.message,
+ name,
+ };
+ }
+ }
+ return result;
+ }
+
+
+ /**
+ * Checks for updates to all installed packages.
+ * @return {Promise} Promise resolved to a map of package names and
+ * info objects downloaded from the remote server. Only packages with
+ * update available are returned.
+ */
+ async checkForUpdates() {
+ const candidates = await this._getUpdateCandidates();
+ const result = [];
+ for (let i = 0, len = candidates.length; i < len; i++) {
+ const item = candidates[i];
+ const data = await this._processCandidateUpdateInfo(item);
+ if (data) {
+ result[result.length] = data;
+ }
+ }
+ return result;
+ }
+
+ /**
+ * @returns {Promise<{name: string, version: string}[]>} The list of installed packages to check for the update.
+ */
+ async _getUpdateCandidates() {
+ const now = Date.now();
+ const info = await this.themeInfo.load();
+ const { themes } = info;
+ const names = [];
+ themes.forEach((item) => {
+ if (item.isSymlink) {
+ return;
+ }
+ if (item.updateCheck) {
+ const delta = now - item.updateCheck;
+ if (delta < 7.2e+6) {
+ // 2 hours
+ return;
+ }
+ }
+ names[names.length] = {
+ name: item.name,
+ version: item.version
+ };
+ });
+ return names;
+ }
+
+ /**
+ *
+ * @param {{name: string, version: string}} candidate The package to check for update.
+ * @returns {Promise}
+ */
+ async _processCandidateUpdateInfo(candidate) {
+ const { name, version } = candidate;
+ /* eslint-disable require-atomic-updates */
+ let result;
+ try {
+ result = await this.checkUpdateAvailable(name, version);
+ await this.themeInfo.setUpdateCheckTime(name);
+ } catch (e) {
+ logger.warn(`Unable to get theme package info ${e.message}`);
+ }
+ return result;
+ }
+
+ /**
+ * Checks whether an update is available for the theme.
+ * @param {string} name The theme `name`
+ * @param {string} version The current version
+ * @returns {Promise}
+ */
+ async checkUpdateAvailable(name, version) {
+ const names = this._prepareSourceAndVersion(name, version);
+ const localInfo = await this.themeInfo.readTheme(name);
+ const remoteInfo = await this.#pluginManager.queryPackage(names[0]);
+ if (!this._compareVersions(remoteInfo, localInfo)) {
+ return undefined;
+ }
+ if (this._compareEngines(remoteInfo)) {
+ return remoteInfo;
+ }
+ return undefined;
+ }
+
+
+ /**
+ * Checks whether the version of the remove package is higher then the local package.
+ * @param {PackageInfo} remoteInfo Remote package version
+ * @param {InstalledTheme} localInfo Local package version
+ * @returns {boolean}
+ */
+ _compareVersions(remoteInfo, localInfo) {
+ return semver.gt(remoteInfo.version, localInfo.version);
+ }
+
+ /**
+ * @param {PackageInfo} remoteInfo
+ * @returns {boolean}
+ */
+ _compareEngines(remoteInfo) {
+ // @ts-ignore
+ const { engines } = remoteInfo;
+ if (!engines || !engines.arc) {
+ return true;
+ }
+ const engine = engines.arc;
+ const version = process.env.npm_package_version;
+ if (semver.validRange(engine)) {
+ return semver.satisfies(version, engine);
+ }
+ return true;
+ }
+
+ /**
+ * Processes source and version properties to produce right input for
+ * `live-plugin-manager`
+ * @param {string} source NPM name or Github repo
+ * @param {string=} version Theme version to install.
+ * @return {string[]} First item is the source and version the other.
+ */
+ _prepareSourceAndVersion(source, version) {
+ if (source.indexOf('/') !== -1 && source[0] !== '@') {
+ if (!version) {
+ version = 'master';
+ }
+ version = `${source}#${version}`;
+ }
+ return [source, version];
+ }
+}
diff --git a/src/io/ThemesProtocol.js b/src/io/ThemesProtocol.js
new file mode 100644
index 00000000..81d1930b
--- /dev/null
+++ b/src/io/ThemesProtocol.js
@@ -0,0 +1,142 @@
+/* eslint-disable no-bitwise */
+import { session } from 'electron';
+import path from 'path';
+import fs from 'fs-extra';
+import { logger } from './Logger.js';
+import { MainWindowPersist, TaskManagerWindowPersist } from './Constants.js';
+import { ThemeInfo } from './models/ThemeInfo.js';
+
+export const requestHandler = Symbol('requestHandler');
+
+/**
+ * A class responsible for handling `themes:` protocol.
+ *
+ *
+ *
+ * Theme protocol is used to load theme file from themes installation location
+ * by using only theme id.
+ *
+ * Example usage in the renderer process:
+ *
+ * ```
+ *
+ * ```
+ *
+ * If the location represents a path then then file will be loaded from this
+ * location.
+ *
+ * ```
+ *
+ * ```
+ */
+export class ThemesProtocol {
+ constructor() {
+ this[requestHandler] = this[requestHandler].bind(this);
+ }
+
+ /**
+ * Registers the protocol handler.
+ * This must be called after the `ready` event.
+ */
+ register() {
+ logger.debug('Registering themes protocol');
+ session.fromPartition(MainWindowPersist)
+ .protocol
+ .registerStringProtocol('themes', this[requestHandler]);
+ session.fromPartition(TaskManagerWindowPersist)
+ .protocol
+ .registerStringProtocol('themes', this[requestHandler]);
+ }
+
+ /**
+ * @param {Electron.ProtocolRequest} request
+ * @param {(response: string | Electron.ProtocolResponse) => void} callback
+ * @returns
+ */
+ async [requestHandler](request, callback) {
+ let url = request.url.substr(9);
+ logger.silly(`ThemesProtocol::requestHandler::${url}`);
+ try {
+ fs.accessSync(url, fs.constants.R_OK | fs.constants.X_OK);
+ await this.loadFileTheme(url, callback);
+ return;
+ } catch (_) {
+ // ..
+ }
+ if (url === 'dd1b715f-af00-4ee8-8b0c-2a262b3cf0c8') {
+ url = '@advanced-rest-client/arc-electron-default-theme';
+ }
+ await this.loadInstalledTheme(url, callback);
+ }
+
+ /**
+ * @param {string} themeLocation
+ * @param {(response: string | Electron.ProtocolResponse) => void} callback
+ */
+ async loadFileTheme(themeLocation, callback) {
+ logger.silly(`ThemesProtocol::loading theme from ${themeLocation}`);
+ try {
+ const data = await fs.readFile(themeLocation, 'utf8');
+ callback({
+ data,
+ mimeType: 'text/css',
+ charset: 'utf8'
+ });
+ } catch (cause) {
+ logger.error('Unable to load theme');
+ logger.error(cause);
+ // @ts-ignore
+ callback(-6);
+ }
+ }
+
+ /**
+ * @param {string} themeLocation
+ * @param {(response: string | Electron.ProtocolResponse) => void} callback
+ */
+ async loadInstalledTheme(themeLocation, callback) {
+ logger.info(`loading theme ${themeLocation}`);
+ const model = new ThemeInfo();
+ try {
+ let info = await model.readTheme(themeLocation);
+ if (!info && themeLocation[0] !== '@') {
+ info = await model.readTheme(`@${themeLocation}`);
+ }
+ if (!info) {
+ logger.error('Theme info not found');
+ // @ts-ignore
+ callback(-6);
+ return;
+ }
+ const mainExists = await fs.pathExists(info.mainFile);
+ const file = mainExists ? info.mainFile : path.join(process.env.ARC_THEMES, info.mainFile);
+ logger.silly(`Theme found. Reading theme file: ${file}`);
+ const data = await fs.readFile(file, 'utf8');
+ if (data) {
+ logger.silly('Sending theme file to renderer.');
+ callback({
+ data,
+ mimeType: 'text/css',
+ charset: 'utf8'
+ });
+ } else {
+ logger.error('Theme file is empty');
+ // @ts-ignore
+ callback(-6);
+ }
+ } catch (e) {
+ logger.error('Unable to load theme');
+ logger.error(e.message);
+ logger.error(e.stack);
+ // @ts-ignore
+ callback(-6);
+ }
+ }
+
+ findThemeInfo(id, themes) {
+ if (!themes || !themes.length) {
+ return null;
+ }
+ return themes.find((item) => item._id === id || item.name === id);
+ }
+}
diff --git a/src/io/WindowsManager.js b/src/io/WindowsManager.js
new file mode 100644
index 00000000..2009c7d2
--- /dev/null
+++ b/src/io/WindowsManager.js
@@ -0,0 +1,557 @@
+/* eslint-disable no-param-reassign */
+import { BrowserWindow, ipcMain, shell, nativeTheme } from 'electron';
+import path from 'path';
+import url from 'url';
+import { v4 } from 'uuid';
+import { MainWindowPersist, AppHostname } from './Constants.js';
+import { logger } from './Logger.js';
+import { ArcSessionRecorder } from './ArcSessionRecorder.js';
+import { WindowsPersistance } from './WindowsPersistance.js';
+import { ContextActions } from './ContextActions.js';
+
+/** @typedef {import('../types').ApplicationOptionsConfig} ApplicationOptionsConfig */
+/** @typedef {import('../types').ProtocolFile} ProtocolFile */
+/** @typedef {import('../types').WindowSession} WindowSession */
+/** @typedef {import('../types').OpenPageOptions} OpenPageOptions */
+/** @typedef {import('electron').WebContents} WebContents */
+
+
+export const closedHandler = Symbol('closedHandler');
+export const movedHandler = Symbol('movedHandler');
+export const resizedHandler = Symbol('resizedHandler');
+export const focusedHandler = Symbol('focusedHandler');
+export const popupHandler = Symbol('popupHandler');
+export const settingHandler = Symbol('settingHandler');
+export const windowOpenHandler = Symbol('windowOpenHandler');
+export const toggleDevToolsHandler = Symbol('toggleDevToolsHandler');
+export const windowReadyHandler = Symbol('windowReadyHandler');
+export const winContextInitHandler = Symbol('winContextInitHandler');
+export const workspaceLocationHandler = Symbol('workspaceLocationHandler');
+export const workspaceChangeLocationHandler = Symbol('workspaceChangeLocationHandler');
+
+export class WindowsManager {
+ /**
+ * A pointer to last focused window.
+ * @type {BrowserWindow}
+ */
+ #lastFocused = undefined;
+
+ /**
+ * A list of focused windows, in order of latest focus
+ * @type {BrowserWindow[]}
+ */
+ #focusQueue = [];
+
+ /**
+ * @param {ApplicationOptionsConfig} startupOptions Application startup options.
+ */
+ constructor(startupOptions={}) {
+ this.startupOptions = startupOptions;
+ /**
+ * @type {BrowserWindow[]}
+ */
+ this.windows = [];
+ this[closedHandler] = this[closedHandler].bind(this);
+ this[movedHandler] = this[movedHandler].bind(this);
+ this[resizedHandler] = this[resizedHandler].bind(this);
+ this[focusedHandler] = this[focusedHandler].bind(this);
+ this[popupHandler] = this[popupHandler].bind(this);
+ this[settingHandler] = this[settingHandler].bind(this);
+ this[windowOpenHandler] = this[windowOpenHandler].bind(this);
+ this[toggleDevToolsHandler] = this[toggleDevToolsHandler].bind(this);
+ this[winContextInitHandler] = this[winContextInitHandler].bind(this);
+ this[workspaceLocationHandler] = this[workspaceLocationHandler].bind(this);
+ this[workspaceChangeLocationHandler] = this[workspaceChangeLocationHandler].bind(this);
+
+ this.workspace = new WindowsPersistance();
+ this.recorder = new ArcSessionRecorder();
+ this.contextActions = new ContextActions();
+
+ /**
+ * A map with the location to the workspaces loaded in the current windows.
+ * @type {Map}
+ */
+ this.workspacesMap = new Map();
+ }
+
+ /**
+ * @returns {boolean} True if has at leas one window.
+ */
+ get hasWindow() {
+ return this.windows.length > 0;
+ }
+
+ /**
+ * @return {BrowserWindow|undefined} Reference to last focused browser window
+ * or undefined if the window is destroyed or undefined.
+ */
+ get lastFocused() {
+ if (!this.#lastFocused) {
+ return null;
+ }
+ if (this.#lastFocused.isDestroyed()) {
+ this.#lastFocused = undefined;
+ return null;
+ }
+ return this.#lastFocused;
+ }
+
+ /**
+ * @return {BrowserWindow|undefined} Reference to last focused browser window that is ARC main window.
+ */
+ get lastArcFocused() {
+ return this.#focusQueue.find((item) => {
+ if (item.isDestroyed()) {
+ return false;
+ }
+ const pageUrl = item.webContents.getURL();
+ return pageUrl.includes('/app.html');
+ })
+ }
+
+ /**
+ * @return {BrowserWindow} Returns reference to last created and still active
+ * window object.
+ */
+ get lastActive() {
+ const ws = this.windows;
+ if (!ws || !ws.length) {
+ return null;
+ }
+ for (let i = ws.length - 1; i >= 0; i--) {
+ if (!ws[i].isDestroyed()) {
+ return ws[i];
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Restores latest window is any present.
+ */
+ restoreLast() {
+ const win = this.lastActive;
+ if (win) {
+ win.show();
+ } else {
+ this.open();
+ }
+ }
+
+ /**
+ * Listens for relevant for this class events from the renderer.
+ */
+ listen() {
+ ipcMain.on('new-window', this[windowOpenHandler]);
+ ipcMain.on('toggle-devtools', this[toggleDevToolsHandler]);
+ ipcMain.on('settings-changed', this[settingHandler]);
+ ipcMain.on('window-context-menu-init', this[winContextInitHandler]);
+ ipcMain.handle('workspace-get-location', this[workspaceLocationHandler]);
+ ipcMain.handle('workspace-change-location', this[workspaceChangeLocationHandler]);
+ }
+
+ /**
+ * Notifies all opened windows with event data.
+ *
+ * @param {string} type Event type (channel name)
+ * @param {any=} args List of arguments or a single argument
+ * @param {BrowserWindow=} ignored The window that should not receive the notification.
+ */
+ notifyAll(type, args=[], ignored) {
+ logger.debug(`[WM] Notifying all windows with type: ${type}`);
+ this.windows.forEach((win, index) => {
+ if (win.isDestroyed()) {
+ this.windows.splice(index, 1);
+ return;
+ }
+ if (ignored && win.id === ignored.id) {
+ return;
+ }
+ if (Array.isArray(args)) {
+ win.webContents.send(type, ...args);
+ } else {
+ win.webContents.send(type, args);
+ }
+ });
+ }
+
+ /**
+ * Finds an index for a window.
+ * @returns {number}
+ */
+ findIndex() {
+ const { windows } = this;
+ if (!windows.length) {
+ return 1;
+ }
+ windows.sort((a, b) => a.id - b.id);
+ const len = windows.length;
+ for (let i = 1; i < len; i++) {
+ if (windows[i].id !== i) {
+ return i;
+ }
+ }
+ return len + 1;
+ }
+
+ /**
+ * Closes a window by its WebContents id
+ * @param {number} id
+ */
+ closeWindow(id) {
+ const bWin = this.windows.find((win) => win.webContents.id === id);
+ if (bWin.isDestroyed()) {
+ const index = this.windows.indexOf(bWin);
+ this.windows.splice(index, 1);
+ return;
+ }
+ bWin.close();
+ }
+
+ /**
+ * Opens a new application window.
+ *
+ * @param {OpenPageOptions=} [options={}] Page create options. Don't set for the default ARC window.
+ * @return {Promise} Resolved promise when the window is ready.
+ */
+ async open(options={}) {
+ const { page, route, params={}, workspaceFile } = options;
+ let { preload } = options;
+ if (!preload && !page || page === 'app.html') {
+ preload = 'arc-preload.js';
+ }
+ if (workspaceFile) {
+ const id = v4();
+ this.workspacesMap.set(id, workspaceFile);
+ params.workspaceId = id;
+ }
+ logger.debug('[WM] Opening new window');
+ const id = this.findIndex();
+ let info;
+ if (options.sizing) {
+ info = options.sizing;
+ } else {
+ info = options.ignoreWindowSessionSettings ? {} : await this.workspace.restoreWindowState(id);
+ }
+ const win = this.createWindow(info, preload, options);
+ if (options.noMenu) {
+ win.removeMenu();
+ win.setMenu(null);
+ }
+ this.addWidowListeners(win, options.ignoreWindowSessionSettings);
+ this.windows.push(win);
+ this.loadPage(win, page, route, params);
+ if (this.startupOptions.withDevtools) {
+ win.webContents.openDevTools();
+ }
+ this.recorder.record();
+ // win.webContents.openDevTools();
+ return win;
+ }
+
+ /**
+ * Opens ARC application window with path set to file action.
+ *
+ * @param {ProtocolFile} options Action configuration.
+ * @return {Promise}
+ */
+ async openWithAction(options) {
+ if (!options) {
+ logger.error('openWithAction called without argument.');
+ return undefined;
+ }
+ logger.debug(`[WM] Opening new window with action ${options.source} ${options.action}`);
+ const route = `file-protocol-action/${options.source}/${options.action}/${options.id}`;
+ return this.open({
+ route,
+ });
+ }
+
+ /**
+ * @param {string=} preload The preload script to load from the `src/preload/` folder.
+ * @returns {Electron.BrowserWindowConstructorOptions} The base options for ARC windows.
+ */
+ createBaseWindowOptions(preload) {
+ const options = /** @type Electron.BrowserWindowConstructorOptions */({
+ backgroundColor: '#00A2DF',
+ show: false,
+ title: 'Advanced REST Client',
+ webPreferences: {
+ partition: MainWindowPersist,
+ nativeWindowOpen: true,
+ nodeIntegration: false,
+ contextIsolation: false,
+ // DO NOT ENABLE THIS FOR ALL WINDOWS.
+ // webSecurity: false,
+ },
+ });
+ if (preload) {
+ options.webPreferences.preload = path.join(__dirname, '..', 'preload', preload);
+ }
+ return options;
+ }
+
+ /**
+ * Creates a configured browser window.
+ * @param {WindowSession} info
+ * @param {string=} preload The preload script to load from the `src/preload/` folder.
+ * @param {OpenPageOptions=} init
+ * @returns {BrowserWindow}
+ */
+ createWindow(info, preload, init={}) {
+ const options = { ...this.createBaseWindowOptions(preload), ...info };
+ if (init.noWebSecurity) {
+ options.webPreferences.webSecurity = false;
+ }
+ if (init.parent) {
+ options.parent = init.parent;
+ }
+ return new BrowserWindow(options);
+ }
+
+ /**
+ * Loads application for a path.
+ *
+ * @param {BrowserWindow} win Window to load the app to.
+ * @param {string=} [page='app.html'] The page to open from the src/app folder.
+ * @param {string=} [appPath=''] ARC internal routing path.
+ * @param {{[key: string]: string}=} [params={}] A list of parameters to pass to the page with query parameters
+ */
+ loadPage(win, page='app.html', appPath='', params={}) {
+ if (typeof params.darkMode === 'undefined') {
+ params.darkMode = String(nativeTheme.shouldUseDarkColors);
+ }
+ const full = url.format({
+ hostname: AppHostname,
+ pathname: `/src/app/${page}`,
+ // loads the entire page on the esm protocol so all assets are served through it
+ // TODO: ARC <16 uses the `file:` protocol and does not use host name. An adapter is needed to be shipped
+ // with ARC 16 to move all data from the old domain.
+ protocol: 'web-module:',
+ slashes: true,
+ hash: appPath,
+ query: params,
+ });
+ logger.debug(`[WM] Loading page: ${full}`);
+ win.loadURL(full);
+ }
+
+ /**
+ * Adds browser window event listeners
+ *
+ * @param {BrowserWindow} win Window to attach listeners to.
+ * @param {boolean=} ignoreWindowSessionSettings
+ */
+ addWidowListeners(win, ignoreWindowSessionSettings=false) {
+ win.addListener('closed', this[closedHandler]);
+ if (!ignoreWindowSessionSettings) {
+ win.addListener('move', this[movedHandler]);
+ win.addListener('resize', this[resizedHandler]);
+ }
+ win.addListener('focus', this[focusedHandler]);
+ win.once('ready-to-show', this[windowReadyHandler].bind(this, win));
+ win.webContents.on('new-window', this[windowOpenHandler]);
+ }
+
+ /**
+ * Finds window index position in windows array.
+ *
+ * @param {BrowserWindow} win Window to search
+ * @return {number} Window position or `-1` if not found.
+ */
+ findWindowIndex(win) {
+ const noId = win.isDestroyed();
+ return this.windows.findIndex((item) => {
+ if (item.isDestroyed()) {
+ return win === item;
+ }
+ if (noId) {
+ return false;
+ }
+ return item.id === win.id;
+ });
+ }
+
+ /**
+ * Reloads all not destroyed windows.
+ */
+ reloadWindows() {
+ logger.debug('[WM] Reloading all windows.');
+ const { windows } = this;
+ for (let i = windows.length - 1; i >= 0; i--) {
+ const win = windows[i];
+ if (win.isDestroyed()) {
+ this.windows.splice(i, 1);
+ return;
+ }
+ win.reload();
+ }
+ }
+
+ //
+ // Event handlers
+ //
+
+ [windowOpenHandler]() {
+ this.open();
+ }
+
+ /**
+ * Handler for `toggle-devtools` event. Opens devtools on sender.
+ *
+ * @param {any} e The event emitted by the renderer process.
+ */
+ [toggleDevToolsHandler](e) {
+ const win = /** @type BrowserWindow */ (e.sender);
+ win.webContents.toggleDevTools();
+ }
+
+ /**
+ * A handler for a `settings-changed` from the renderer process. It informs other windows about the change.
+ *
+ * @param {any} e The event emitted by the renderer process.
+ * @param {string} key
+ * @param {any} value
+ * @param {string} area
+ */
+ [settingHandler](e, key, value, area) {
+ const win = /** @type BrowserWindow */ (e.sender);
+ this.notifyAll('settings-changed', {
+ key,
+ value,
+ area,
+ }, win);
+ }
+
+ /**
+ * Handler for the `new-window` event emitted by the window object.
+ * Opens new chrome tab with requested content.
+ *
+ * @param {Electron.IpcMainEvent} event Emitted event.
+ * @param {string} openUrl Requested URL
+ * @param {string} frameName
+ */
+ [popupHandler](event, openUrl, frameName) {
+ if (frameName !== 'modal') {
+ return;
+ }
+ event.preventDefault();
+ shell.openExternal(openUrl);
+ }
+
+ /**
+ * @param {*} e
+ */
+ [focusedHandler](e) {
+ const win = /** @type Electron.BrowserWindow */ (e.sender);
+ this.#lastFocused = win;
+ const index = this.#focusQueue.indexOf(win);
+ if (index !== -1) {
+ this.#focusQueue.splice(index, 1);
+ }
+ this.#focusQueue.unshift(win);
+ }
+
+ [resizedHandler](e) {
+ const win = /** @type BrowserWindow */ (e.sender);
+ this.workspace.resizeHandler(win);
+ }
+
+ [movedHandler](e) {
+ const win = /** @type BrowserWindow */ (e.sender);
+ this.workspace.moveHandler(win);
+ }
+
+ /**
+ * Handler for the BrowserWindow `closed` event.
+ * Removes the window from the windows array.
+ *
+ * @param {*} e Event emitted by the window.
+ */
+ [closedHandler](e) {
+ const win = /** @type BrowserWindow */ (e.sender);
+ if (this.#lastFocused === win) {
+ this.#lastFocused = undefined;
+ }
+ const focusIndex = this.#focusQueue.indexOf(win);
+ if (focusIndex !== -1) {
+ this.#focusQueue.splice(focusIndex, 1);
+ }
+ const index = this.findWindowIndex(win);
+ if (index === -1) {
+ return;
+ }
+ this.windows.splice(index, 1);
+ // const { welcomeWindow } = this;
+ // this.welcomeWindow = undefined;
+ // if (win !== welcomeWindow && !this.windows.length) {
+ // this.openWelcome();
+ // }
+ }
+
+ /**
+ * Handler for the "ready-to-show" event
+ *
+ * @param {BrowserWindow} win
+ */
+ [windowReadyHandler](win) {
+ logger.debug('[WM] Window is ready to show');
+ win.show();
+ }
+
+ /**
+ * Handler for the window basic state info request.
+ *
+ * @param {Electron.IpcMainEvent} e Event emitted by the window.
+ */
+ [winContextInitHandler](e) {
+ this.contextActions.registerDefaultActions(e.sender);
+ }
+
+ /**
+ * @param {any} event
+ * @param {string=} id
+ */
+ async [workspaceLocationHandler](event, id) {
+ const loc = this.workspacesMap.get(id);
+ if (loc) {
+ return loc;
+ }
+ const contents = /** @type Electron.WebContents */ (event.sender);
+ // - 1 so it will be compatible with old architecture
+ const index = this.readWebContentsBrowserId(contents) - 1;
+ let file = 'workspace';
+ if (index) {
+ file += `.${index}`;
+ }
+ file += '.json';
+ return path.join(process.env.ARC_WORKSPACE_PATH, file);
+ }
+
+ /**
+ * The handler to the request to change the current workspace location.
+ * @param {any} event
+ * @param {string} fileLocation
+ */
+ async [workspaceChangeLocationHandler](event, fileLocation) {
+ const id = v4();
+ this.workspacesMap.set(id, fileLocation);
+ return id;
+ }
+
+ /**
+ * Searches for the BrowserWindow id by its web contents id.
+ * I expect the WebContents id equals to the BrowserWindow id but it is not documented
+ * or explicitly stated so it searches for the browser window id.
+ *
+ * @param {WebContents} contents
+ * @returns {number}
+ */
+ readWebContentsBrowserId(contents) {
+ const bw = this.windows.find((win) => win.webContents === contents);
+ if (!bw) {
+ return contents.id;
+ }
+ return bw.id;
+ }
+}
diff --git a/src/io/WindowsPersistance.js b/src/io/WindowsPersistance.js
new file mode 100644
index 00000000..ac054a8d
--- /dev/null
+++ b/src/io/WindowsPersistance.js
@@ -0,0 +1,188 @@
+import path from 'path';
+import { screen } from 'electron';
+import { ArcPreferences } from '../common/ArcPreferences.js';
+
+/** @typedef {import('../types').ApplicationConfig} ApplicationConfig */
+/** @typedef {import('../types').WindowsSessionSchema} WindowsSessionSchema */
+/** @typedef {import('../types').WindowSession} WindowSession */
+/** @typedef {import('electron').BrowserWindow} BrowserWindow */
+/** @typedef {import('electron').Display} Display */
+
+export const storeTimeout = Symbol('storeTimeout');
+
+/**
+ * This class stores opened windows position and size so it can be restored the next time the window is opened.
+ * It is used by the WindowManager.
+ */
+export class WindowsPersistance extends ArcPreferences {
+ constructor() {
+ super(path.join(process.env.ARC_HOME, 'workspace', 'windows.json'));
+
+ /**
+ * Store data debounce timer.
+ * By default it's 500 ms.
+ * @type {number}
+ */
+ this.storeDebounce = 500;
+ }
+
+ /**
+ * @param {WindowsSessionSchema} data
+ * @param {number} id
+ * @returns {WindowSession|null}
+ */
+ findWindow(data, id) {
+ if (!data) {
+ return null;
+ }
+ const { windows=[] } = data;
+ if (!Array.isArray(windows)) {
+ return null;
+ }
+ const result = windows.find((item) => item.id === id);
+ if (!result) {
+ return null;
+ }
+ return result;
+ }
+
+ /**
+ * Restores previous stores window position or creates default values
+ * @param {number} id
+ * @return {Promise}
+ */
+ async restoreWindowState(id) {
+ const data = await this.load();
+ const info = this.findWindow(data, id);
+ if (!info) {
+ return this.defaultWindowSession();
+ }
+ return this.readSafeWindowPosition(info);
+ }
+
+ /**
+ * Callback to be called when a window has moved
+ * @param {BrowserWindow} win
+ */
+ moveHandler(win) {
+ const [x, y] = win.getPosition();
+ this.setWindowPosition(win.id, x, y);
+ if (this[storeTimeout]) {
+ clearTimeout(this[storeTimeout]);
+ }
+ this[storeTimeout] = setTimeout(() => this.store(), this.storeDebounce);
+ }
+
+ /**
+ * Updates window position info
+ * @param {number} id
+ * @param {number} x
+ * @param {number} y
+ */
+ setWindowPosition(id, x, y) {
+ const settings = /** @type WindowsSessionSchema */ (this.data);
+ if (!Array.isArray(settings.windows)) {
+ settings.windows = [];
+ }
+ const info = this.findWindow(settings, id);
+ if (!info) {
+ settings.windows.push({
+ x, y, id,
+ });
+ } else {
+ info.x = x;
+ info.y = y;
+ }
+ }
+
+ /**
+ * Callback to be called when a window has been resized
+ * @param {BrowserWindow} win
+ */
+ resizeHandler(win) {
+ const [width, height] = win.getSize();
+ this.setWindowSize(win.id, width, height);
+ if (this[storeTimeout]) {
+ clearTimeout(this[storeTimeout]);
+ }
+ this[storeTimeout] = setTimeout(() => this.store(), this.storeDebounce);
+ }
+
+ /**
+ * Updates window size info
+ * @param {number} id
+ * @param {number} width
+ * @param {number} height
+ */
+ setWindowSize(id, width, height) {
+ const settings = /** @type WindowsSessionSchema */ (this.data);
+ if (!Array.isArray(settings.windows)) {
+ settings.windows = [];
+ }
+ const info = this.findWindow(settings, id);
+ if (!info) {
+ settings.windows.push({
+ width, height, id,
+ });
+ } else {
+ info.width = width;
+ info.height = height;
+ }
+ }
+
+ async defaultSettings() {
+ return {
+ windows: [],
+ };
+ }
+
+ /**
+ * @returns {WindowSession}
+ */
+ defaultWindowSession() {
+ return {
+ width: 1200,
+ height: 800,
+ };
+ }
+
+ /**
+ * Checks whether the window position is still visible and returns
+ * default position when not.
+ * This may happen when a screen is removed from the device.
+ *
+ * @TODO(pawel): When connecting a sound bar through an HDMI cable it is recognized as
+ * a "display". It looks like there's no way to tell a difference between this device
+ * and the actual display.
+ *
+ * @param {WindowSession} state
+ * @returns {WindowSession} state
+ */
+ readSafeWindowPosition(state) {
+ const { x=0, y=0 } = state;
+ const displays = screen.getAllDisplays();
+ const fit = displays.some((display) => this.pointInDisplay(display, x, y));
+ if (!fit) {
+ return this.defaultWindowSession();
+ }
+ return state;
+ }
+
+ /**
+ * Checks whether the point is inside a display
+ * @param {Display} display
+ * @param {number} x
+ * @param {number} y
+ * @returns {boolean}
+ */
+ pointInDisplay(display, x, y) {
+ const { x:dx, y:dy, width, height } = display.bounds;
+ if (x < dx || x > dx + width) {
+ return false;
+ }
+ if (y < dy || y > dy + height) {
+ return false;
+ }
+ return true;
+ }
+}
diff --git a/src/io/defaults/DataStore.js b/src/io/defaults/DataStore.js
new file mode 100644
index 00000000..212544ef
--- /dev/null
+++ b/src/io/defaults/DataStore.js
@@ -0,0 +1,181 @@
+import fs from 'fs-extra';
+import path from 'path';
+import url from 'url';
+import { BrowserWindow, ipcMain, app } from 'electron';
+import { AppHostname, MainWindowPersist } from '../Constants.js';
+import { logger } from '../Logger.js';
+
+/** @typedef {import('../WindowsManager').WindowsManager} WindowsManager */
+
+/**
+ * This class moves data from old ARC installation to new one.
+ *
+ * In ARC < 16 the renderer process was running from the `file:` scheme and without a hostname.
+ * ARC 16 >= 16 runs from the `web-module:` protocol and `advanced-rest-client` host name. The downside of this change
+ * is that the origin has changed and all data sha to be moved from the old origin to the new one.
+ */
+export class DataStore {
+
+ /**
+ * @param {WindowsManager} vm
+ */
+ constructor(vm) {
+ this.vm = vm;
+ this._noDataHandler = this._noDataHandler.bind(this);
+ this._serverDataHandler = this._serverDataHandler.bind(this);
+ this._reportedReady = this._reportedReady.bind(this);
+ this._receiverReady = this._receiverReady.bind(this);
+ this._errorHandler = this._errorHandler.bind(this);
+ this.lockFile = path.join(process.env.ARC_HOME, '.db-moved-hostname');
+ this.migrationExport = path.join(app.getPath('temp'), '.migrate-data');
+ ipcMain.on('server-db-no-data', this._noDataHandler);
+ ipcMain.on('server-db-finished', this._serverDataHandler);
+ ipcMain.on('data-transport-ready', this._reportedReady);
+ ipcMain.on('data-importer-finished', this._receiverReady);
+ ipcMain.on('db-error', this._errorHandler);
+ }
+
+ async ensureDataUpgraded() {
+ const lockExists = await fs.pathExists(this.lockFile);
+ if (lockExists) {
+ return undefined;
+ }
+ await this.showDataUpgradeDialog();
+ const serverWindow = this.getBrowserWindow();
+ this.openServerWindow(serverWindow);
+ this.server = serverWindow;
+
+ return new Promise((resolve) => {
+ this.resolve = resolve;
+ });
+ }
+
+ async showDataUpgradeDialog() {
+ return new Promise((resolve) => {
+ const win = this.vm.createWindow({
+ height: undefined,
+ width: undefined,
+ x: undefined,
+ y: undefined,
+ });
+ win.setMenu(null);
+ win.once('ready-to-show', () => {
+ win.show();
+ });
+ win.once('show', () => resolve());
+ this.vm.loadPage(win, 'data-migration.html');
+ this.loader = win;
+ });
+ }
+
+ async runImporterWindow() {
+ return new Promise((resolve) => {
+ const win = this.getBrowserWindow();
+ this.openReceiverWindow(win);
+ win.once('ready-to-show', () => {
+ resolve();
+ });
+ this.receiver = win;
+ });
+ }
+
+ /**
+ * @param {BrowserWindow} bw
+ */
+ openServerWindow(bw) {
+ const dest = path.join(__dirname, 'db-server.html');
+ const full = url.format({
+ pathname: dest,
+ protocol: 'file:',
+ slashes: true,
+ });
+ bw.loadURL(full);
+ bw.webContents.openDevTools();
+ }
+
+ /**
+ * @param {BrowserWindow} bw
+ */
+ openReceiverWindow(bw) {
+ const full = url.format({
+ hostname: AppHostname,
+ pathname: `/io/defaults/db-receiver.html`,
+ protocol: 'web-module:',
+ slashes: true,
+ });
+ bw.loadURL(full);
+ bw.webContents.openDevTools();
+ }
+
+ getBrowserWindow() {
+ const options = /** @type Electron.BrowserWindowConstructorOptions */({
+ show: false,
+ frame: false,
+ closable: false,
+ webPreferences: {
+ partition: MainWindowPersist,
+ nodeIntegration: true,
+ contextIsolation: false,
+ },
+ });
+ return new BrowserWindow(options);
+ }
+
+ _reportedReady(e, type) {
+ if (type === 'server') {
+ setTimeout(() => {
+ this.server.webContents.send('server-start', this.migrationExport);
+ }, 1000);
+ } else if (type === 'receiver') {
+ setTimeout(() => {
+ this.receiver.webContents.send('receiver-start', this.migrationExport);
+ }, 1000);
+ }
+ }
+
+ async _receiverReady() {
+ this.afterFinish();
+ this.receiver.close();
+ this.receiver = undefined;
+ }
+
+ _noDataHandler() {
+ this.afterFinish();
+ this.server.close();
+ this.server = undefined;
+ }
+
+ _errorHandler(e, message, stack) {
+ logger.error(message);
+ logger.error(stack);
+ const info = {
+ message, stack
+ };
+ const data = JSON.stringify(info);
+ this.loader.webContents.executeJavaScript(`window.postMessage({error: ${data}})`);
+ }
+
+ async _serverDataHandler() {
+ this.loader.webContents.executeJavaScript('window.postMessage({loadingStatus: "Migrating data stores."})');
+
+ this.runImporterWindow();
+ this.server.close();
+ this.server = undefined;
+ }
+
+ async afterFinish() {
+ ipcMain.removeAllListeners('server-db-no-data');
+ ipcMain.removeAllListeners('server-db-finished');
+ ipcMain.removeAllListeners('data-transport-ready');
+ ipcMain.removeAllListeners('data-receiver-ready');
+ ipcMain.removeAllListeners('db-error');
+
+ await fs.ensureFile(this.lockFile);
+ const tmpExists = await fs.pathExists(this.migrationExport);
+ if (tmpExists) {
+ await fs.remove(this.migrationExport);
+ }
+ app.relaunch();
+ app.quit();
+ }
+}
diff --git a/scripts/main/defaults/theme-defaults.js b/src/io/defaults/ThemeDefaults.js
similarity index 76%
rename from scripts/main/defaults/theme-defaults.js
rename to src/io/defaults/ThemeDefaults.js
index 688e8f74..bc4910d8 100644
--- a/scripts/main/defaults/theme-defaults.js
+++ b/src/io/defaults/ThemeDefaults.js
@@ -1,20 +1,22 @@
-const fs = require('fs-extra');
-const path = require('path');
-const log = require('../logger');
-const semver = require('semver');
+/* eslint-disable no-param-reassign */
+/* eslint-disable no-await-in-loop */
+import fs from 'fs-extra';
+import path from 'path';
+import semver from 'semver';
+import { logger } from '../Logger.js';
/**
* A class that is responsible for setting up theme defaults.
*/
-class ThemeDefaults {
+export class ThemeDefaults {
/**
* Sets defaults if the defaults are not yet set.
- * It copues anypoint and default theme to theme location
+ * It copies anypoint and default theme to theme location
* and creates theme-info file.
*
* @return {Promise} Resolved promise when the defaults are stored.
*/
async prepareEnvironment() {
- log.debug('Preparing themes environment...');
+ logger.debug('Preparing themes environment...');
const names = await this._readDefaultThemesPackages();
if (!names) {
return;
@@ -25,10 +27,10 @@ class ThemeDefaults {
async _readDefaultThemesPackages() {
const source = path.join(__dirname, '..', '..', '..', 'appresources', 'themes');
- log.silly('Searching for default themes...');
+ logger.silly('Searching for default themes...');
const themes = await this._listThemePackages(source);
if (themes) {
- log.silly(`Found ${themes.length} default themes.`);
+ logger.silly(`Found ${themes.length} default themes.`);
}
return themes;
}
@@ -38,8 +40,8 @@ class ThemeDefaults {
try {
items = await fs.readdir(themePath);
} catch (e) {
- log.warn(`Unable to read themes path ${themePath}.`);
- return;
+ logger.warn(`Unable to read themes path ${themePath}.`);
+ return undefined;
}
let themePaths = [];
for (let name of items) {
@@ -53,14 +55,14 @@ class ThemeDefaults {
if (parent) {
name = path.join(parent, name);
}
- log.silly('Found default theme: ' + name);
+ logger.silly(`Found default theme: ${name}`);
themePaths[themePaths.length] = {
name,
main,
location: loc
};
} else {
- log.silly(`Searching subdirectories of ${loc} for themes`);
+ logger.silly(`Searching subdirectories of ${loc} for themes`);
if (parent) {
parent = path.join(parent, name);
} else {
@@ -78,11 +80,11 @@ class ThemeDefaults {
async _readMainFile(pkgFile, name) {
// Default to package name ??
- const defaultName = name + '.js';
+ const defaultName = `${name}.js`;
let data;
try {
const content = await fs.readFile(pkgFile);
- data = JSON.parse(content);
+ data = JSON.parse(String(content));
} catch (_) {
return defaultName;
}
@@ -100,7 +102,7 @@ class ThemeDefaults {
try {
await this._ensureTheme(item);
} catch (e) {
- log.error(e);
+ logger.error(e);
}
await this._ensureThemes(themes);
}
@@ -109,7 +111,8 @@ class ThemeDefaults {
const file = path.join(process.env.ARC_THEMES, info.name, info.main);
const exists = await fs.pathExists(file);
if (!exists) {
- return await this._copyThemeFiles(info);
+ await this._copyThemeFiles(info);
+ return;
}
const localPkgFile = path.join(info.location, 'package.json');
const localPkg = await fs.readJson(localPkgFile);
@@ -118,65 +121,70 @@ class ThemeDefaults {
const localVersion = localPkg.version;
const installedVersion = installedPkg.version;
if (semver.gt(localVersion, installedVersion)) {
- return await this._copyThemeFiles(info);
+ await this._copyThemeFiles(info);
+ return;
}
- log.silly(`Theme ${file} exists. Skipping initialization.`);
+ logger.silly(`Theme ${file} exists. Skipping initialization.`);
}
async _copyThemeFiles(info) {
- log.debug(`Creating ${info.name} theme...`);
+ logger.debug(`Creating ${info.name} theme...`);
const dest = path.join(process.env.ARC_THEMES, info.name);
try {
await fs.emptyDir(dest);
await fs.copy(info.location, dest);
await this._updateThemeVersion(info);
} catch (cause) {
- log.error('Unable to copy default theme from ' + info.location + ' to ' + dest);
- log.error(cause);
+ logger.error(`Unable to copy default theme from ${info.location} to ${dest}`);
+ logger.error(cause);
}
}
+
// Setups theme info file if missing
async _setThemeInfo() {
const file = path.join(process.env.ARC_THEMES, 'themes-info.json');
const exists = await fs.pathExists(file);
if (exists) {
- log.debug(`${file} exists. Ensuring info scheme.`);
- return await this._ensureThemesInfoVersion(file);
+ logger.debug(`${file} exists. Ensuring info scheme.`);
+ return this._ensureThemesInfoVersion(file);
}
- log.info('Creating themes-info.json file');
- return await this._copyInfoFile();
+ logger.info('Creating themes-info.json file');
+ return this._copyInfoFile();
}
async _ensureThemesInfoVersion(file) {
const data = await fs.readJson(file, { throws: false });
if (!data) {
- return await this._copyInfoFile();
+ return this._copyInfoFile();
}
- if (data instanceof Array) {
+ if (Array.isArray(data)) {
// version 0
- return await this._upgradeInfoFile(file, data);
+ return this._upgradeInfoFile(file, data);
}
if (!(data.themes instanceof Array)) {
- return await this._copyInfoFile();
+ return this._copyInfoFile();
}
const item = data.themes[0];
if (!item.location) {
- return await this._copyInfoFile();
+ return this._copyInfoFile();
}
if ((item.mainFile || '').indexOf('.js') !== -1) {
// early 14.x.x preview
- return await this._copyInfoFile();
+ return this._copyInfoFile();
}
+ return undefined;
}
+
/**
- * @return {String} Location of theme info file in local resources.
+ * @return {string} Location of theme info file in local resources.
*/
get localThemeInfoFile() {
return path.join(__dirname, '..', '..', '..', 'appresources', 'themes', 'themes-info.json');
}
+
/**
* Copies theme info file from local resources to themes folder.
- * @return {Promise}
+ * @return {Promise}
*/
async _copyInfoFile() {
const dest = process.env.ARC_THEMES_SETTINGS;
@@ -185,13 +193,14 @@ class ThemeDefaults {
info = info || {};
await fs.writeJson(dest, info);
}
+
/**
* Upgrades original theme info file structure to v1.
*
* This function checks for already installed themes that are not default themes
* and adds it to the list of newly created file.
*
- * @param {String} file Theme info (installed) file location.
+ * @param {string} file Theme info (installed) file location.
* @param {Array} installed List of currently installed packages.
* @return {Promise}
*/
@@ -226,4 +235,3 @@ class ThemeDefaults {
});
}
}
-exports.ThemeDefaults = ThemeDefaults;
diff --git a/scripts/main/defaults/workspace-defaults.js b/src/io/defaults/WorkspaceDefaults.js
similarity index 65%
rename from scripts/main/defaults/workspace-defaults.js
rename to src/io/defaults/WorkspaceDefaults.js
index 7cd9cbdb..6ed0ea14 100644
--- a/scripts/main/defaults/workspace-defaults.js
+++ b/src/io/defaults/WorkspaceDefaults.js
@@ -1,17 +1,18 @@
-const fs = require('fs-extra');
-const path = require('path');
-const log = require('../logger');
+import fs from 'fs-extra';
+import path from 'path';
+import { logger } from '../Logger.js';
+
/**
* A class that is responsible for setting up theme defaults.
*/
-class WorkspaceDefaults {
+export class WorkspaceDefaults {
/**
* Ensures that the workspace
*
* @return {Promise} Resolved promise when the defaults are stored.
*/
async prepareEnvironment() {
- log.debug('Preparing ARC workspace.');
+ logger.debug('Preparing ARC workspace.');
await this._ensureWorkspaceDir();
}
@@ -22,14 +23,13 @@ class WorkspaceDefaults {
if (exists) {
return;
}
- log.silly('Workspace directory does not exists. Creating.');
+ logger.silly('Workspace directory does not exists. Creating.');
await fs.ensureDir(dir);
const fileExists = await fs.pathExists(file);
if (fileExists) {
return;
}
- log.silly('Workspace default file does not exists. Creating.');
+ logger.silly('Workspace default file does not exists. Creating.');
await fs.ensureFile(file);
}
}
-exports.WorkspaceDefaults = WorkspaceDefaults;
diff --git a/src/io/defaults/db-receiver.html b/src/io/defaults/db-receiver.html
new file mode 100644
index 00000000..d78e50ca
--- /dev/null
+++ b/src/io/defaults/db-receiver.html
@@ -0,0 +1,73 @@
+
+
+
+
+
+}
+ */
+ async load() {
+ return super.load();
+ }
+
+ /**
+ * Stores information about an installed theme.
+ * @param {InstalledTheme} info The theme to add.
+ * @returns {Promise}
+ */
+ async addTheme(info) {
+ const data = await this.load();
+ if (!Array.isArray(data.themes)) {
+ data.themes = [];
+ }
+ data.themes.push(info);
+ await this.store();
+ }
+
+ /**
+ * @param {string} name Theme `name` value.
+ * @returns {Promise}
+ */
+ async removeTheme(name) {
+ const data = await this.load();
+ if (!Array.isArray(data.themes)) {
+ return;
+ }
+ const index = data.themes.findIndex((item) => item.name === name);
+ if (index === -1) {
+ return;
+ }
+ data.themes.splice(index, 1);
+ await this.store();
+ }
+
+ /**
+ * Reads information about theme
+ * @param {string} name The `name` of the theme
+ * @returns {Promise}
+ */
+ async readTheme(name) {
+ const data = await this.load();
+ if (!Array.isArray(data.themes)) {
+ return undefined;
+ }
+ return data.themes.find((item) => item.name === name || item._id === name);
+ }
+
+ /**
+ * Sets a theme as active theme
+ * @param {string} name Theme `name` value.
+ * @returns {Promise}
+ */
+ async setActive(name) {
+ const data = await this.load();
+ if (!Array.isArray(data.themes)) {
+ throw new Error(`No installed themes.`);
+ }
+ const index = data.themes.findIndex((item) => item.name === name);
+ if (index === -1) {
+ throw new Error(`The ${name} theme is not installed.`);
+ }
+ data.active = name;
+ await this.store();
+ }
+
+ /**
+ * Sets the current timestamp on the theme info on the `updateCheck` property
+ * @param {string} name
+ * @returns {Promise}
+ */
+ async setUpdateCheckTime(name) {
+ const info = await this.readTheme(name);
+ if (!info) {
+ return;
+ }
+ info.updateCheck = Date.now();
+ await this.store();
+ }
+
+ /**
+ * Updates the version number on an installed theme
+ * @param {string} name
+ * @param {string} version
+ * @returns {Promise}
+ */
+ async setThemeVersion(name, version) {
+ const info = await this.readTheme(name);
+ if (!info) {
+ return;
+ }
+ info.version = version;
+ await this.store();
+ }
+
+ /**
+ * @returns {Promise}
+ */
+ async defaultSettings() {
+ return /** @type ArcThemeStore */ ({
+ kind: 'ARC#ThemeInfo',
+ version: '1.1.0',
+ themes: [],
+ });
+ }
+
+ /**
+ * Updates a property on the model without any side effects
+ * @param {string} path The path to the value
+ * @param {any} value The value to set
+ */
+ async setProperty(path, value) {
+ const data = await this.load();
+ this.updateValue(data, path, value);
+ await this.store();
+ }
+}
diff --git a/scripts/main/models/workspace-history.js b/src/io/models/WorkspaceHistory.js
similarity index 51%
rename from scripts/main/models/workspace-history.js
rename to src/io/models/WorkspaceHistory.js
index a32ca642..02d50bea 100644
--- a/scripts/main/models/workspace-history.js
+++ b/src/io/models/WorkspaceHistory.js
@@ -1,27 +1,43 @@
-const { ArcPreferences } = require('../../packages/arc-preferences');
-const path = require('path');
+import path from 'path';
+import { ArcPreferences } from '../../common/ArcPreferences.js';
+
+/** @typedef {import('./Models').WorkspaceHistoryModel} WorkspaceHistoryModel */
+/** @typedef {import('./Models').WorkspaceHistoryEntry} WorkspaceHistoryEntry */
+
/**
* A preferences class to store and read theme info file.
*/
-class WorkspaceHistory extends ArcPreferences {
- constructor(limit) {
- super({
- file: path.join(process.env.ARC_HOME, 'workspace', 'workspace-history.json')
- });
- this.limit = limit || 15;
+export class WorkspaceHistory extends ArcPreferences {
+ /**
+ * @param {number=} limit The menu items list limit
+ */
+ constructor(limit=15) {
+ super(path.join(process.env.ARC_HOME, 'workspace', 'workspace-history.json'));
+ this.limit = limit;
+ }
+
+ /**
+ * @returns {Promise}
+ */
+ async load() {
+ return super.load();
}
+ /**
+ * @returns {Promise}
+ */
async defaultSettings() {
return {
kind: 'ARC#WorkspaceHistory',
entries: []
};
}
+
/**
- * Sort function to sort history entirs by time.
- * @param {Object} a
- * @param {Object} b
- * @return {Number}
+ * Sort function to sort history entries by time.
+ * @param {WorkspaceHistoryEntry} a
+ * @param {WorkspaceHistoryEntry} b
+ * @returns {number}
*/
sortEntries(a, b) {
if (a.used > b.used) {
@@ -32,20 +48,21 @@ class WorkspaceHistory extends ArcPreferences {
}
return 0;
}
+
/**
* Loads list of history entires from the configuration file.
- * @return {Array|undefined} List of entries or undefined if none found.
+ * @return {Promise} List of entries or undefined if none found.
*/
async loadEntries() {
const data = await this.load();
if (!data) {
- return;
+ return undefined;
}
- if (!(data.entries instanceof Array)) {
- return;
+ if (!Array.isArray(data.entries)) {
+ return undefined;
}
if (!data.entries.length) {
- return;
+ return undefined;
}
data.entries.sort(this.sortEntries);
return data.entries;
@@ -53,19 +70,15 @@ class WorkspaceHistory extends ArcPreferences {
/**
* Adds history entry to the stored list.
- * @param {String} filePath A workspace file path location.
- * @return {Promise}
+ * @param {string} filePath A workspace file path location.
+ * @return {Promise}
*/
async addEntry(filePath) {
if (!filePath) {
throw new Error('File path argument not set.');
}
- let data = await this.load();
- if (!data) {
- data = {};
- this.__settings = data;
- }
- if (!(data.entries instanceof Array)) {
+ const data = await this.load();
+ if (!Array.isArray(data.entries)) {
data.entries = [];
}
const index = data.entries.findIndex((item) => item.file === filePath);
@@ -83,18 +96,14 @@ class WorkspaceHistory extends ArcPreferences {
}
await this.store();
}
+
/**
* Clears entries history.
* @return {Promise}
*/
async clearHistory() {
- let data = await this.load();
- if (!data) {
- data = {};
- this.__settings = data;
- }
+ const data = await this.load();
data.entries = [];
await this.store();
}
}
-module.exports.WorkspaceHistory = WorkspaceHistory;
diff --git a/src/io/start.js b/src/io/start.js
new file mode 100644
index 00000000..4fe694e7
--- /dev/null
+++ b/src/io/start.js
@@ -0,0 +1,155 @@
+import { app, protocol } from 'electron';
+import { logger, setLevel } from './Logger.js';
+import { ApplicationPaths } from './ApplicationPaths.js';
+import { ApplicationOptions } from './ApplicationOptions.js';
+import { ArcEnvironment } from './ArcEnvironment.js';
+import { PreferencesManager } from './PreferencesManager.js';
+import { ApplicationDefaults } from './ApplicationDefaults.js';
+import { TelemetryConsent } from './TelemetryConsent.js';
+
+app.allowRendererProcessReuse = true;
+let initOptions;
+
+/** @typedef {import('../types').ApplicationOptionsConfig} ApplicationOptionsConfig */
+
+function addUrlToOpen(event, url) {
+ event.preventDefault();
+ logger.debug(`Received URL to open: ${url}`);
+ const fileData = url.substr(11);
+ const parts = fileData.split('/');
+ switch (parts[0]) {
+ case 'drive':
+ // arc-file://drive/open/file-id
+ // arc-file://drive/create/file-id
+ initOptions.open.push(`/request/drive/${parts[1]}/${parts[2]}`);
+ break;
+ default:
+ }
+}
+
+/**
+ * Runs the environment
+ * @param {PreferencesManager} prefManager
+ * @param {ApplicationOptionsConfig} init
+ */
+async function readyHandler(prefManager, init) {
+ // @ts-ignore
+ global.appReadyTime = Date.now();
+ // @ts-ignore
+ logger.debug(`Electron ready time: ${global.appReadyTime - global.shellStartTime}ms`);
+ app.removeListener('open-url', addUrlToOpen);
+
+ const defaults = new ApplicationDefaults();
+ await defaults.prepareEnvironment();
+ const env = new ArcEnvironment(prefManager, init);
+ /**
+ * @type {ArcEnvironment}
+ */
+ // @ts-ignore
+ global.Arc = env;
+ env.registerHandlers();
+
+ if (!init.skipDatabaseUpgrade) {
+ // this has to be done after the protocols are registered.
+ await defaults.prepareDatabaseUpgrade(env.wm);
+ }
+
+ if (!init.skipCookieConsent) {
+ // telemetry consent screen
+ const telemetry = new TelemetryConsent(env.wm);
+ await telemetry.run();
+ }
+
+ await env.loadEnvironment();
+ // @ts-ignore
+ global.appLoadingTime = Date.now();
+ // @ts-ignore
+ logger.debug(`App init time: ${global.appLoadingTime - global.appReadyTime}ms`);
+ env.open(init.openProtocolFile || init.open);
+}
+
+/**
+ * Runs the IO thread of the application.
+ * @param {number} startTime The timestamp when the application first started
+ */
+export default async function start(startTime) {
+ // @ts-ignore
+ global.shellStartTime = startTime;
+ app.commandLine.appendSwitch('enable-experimental-web-platform-features');
+ app.commandLine.appendSwitch('disable-features', 'OutOfBlinkCors');
+
+ process.on('uncaughtException', (error) => {
+ if (error.message) {
+ logger.error(error.message);
+ }
+ if (error.stack) {
+ logger.error(error.stack);
+ }
+ });
+
+ process.on('unhandledRejection',
+ /**
+ * @param {Error} error
+ */
+ (error) => {
+ if (error.message) {
+ logger.error(error.message);
+ }
+
+ if (error.stack) {
+ logger.error(error.stack);
+ }
+ });
+
+ const startupOptions = new ApplicationOptions();
+ startupOptions.parse();
+ initOptions = startupOptions.getOptions();
+ if (initOptions.dev) {
+ setLevel(initOptions.debugLevel || 'silly');
+ // logger.level = initOptions.debugLevel || 'warn';
+ } else if (initOptions.debugLevel) {
+ // logger.level = initOptions.debugLevel;
+ setLevel(initOptions.debugLevel);
+ } else {
+ // logger.level = 'error';
+ setLevel('error');
+ }
+
+ if (initOptions.userDataDir) {
+ app.setPath('userData', initOptions.userDataDir);
+ }
+
+ // Standard scheme must be registered before the app is ready
+ protocol.registerSchemesAsPrivileged([
+ { scheme: 'web-module', privileges: { standard: true, secure: true } },
+ { scheme: 'themes', privileges: { standard: true, secure: true } }
+ ]);
+
+ logger.debug('Setting up the environment');
+ const appPaths = new ApplicationPaths();
+ appPaths.setHome();
+ appPaths.setSettingsFile(initOptions.settingsFile);
+ appPaths.setThemesPath(initOptions.themesPath);
+ appPaths.setWorkspacePath(initOptions.workspacePath);
+ appPaths.setStateFile(initOptions.stateFile);
+
+ // Overrides initial user path to processed by ApplicationPaths
+ initOptions.settingsFile = appPaths.settingsFile;
+ initOptions.themesPath = appPaths.themesBasePath;
+
+ // This prevents Win10 from showing dupe items in the taskbar
+ app.setAppUserModelId(`com.squirrel.mulesoft.arc.${process.arch}`);
+
+ const protocolResult = app.setAsDefaultProtocolClient('arc-file');
+ if (protocolResult) {
+ logger.debug('Registered "arc-file" protocol');
+ } else {
+ logger.warn('Unable to register "arc-file" protocol');
+ }
+
+ app.on('open-url', addUrlToOpen);
+ await app.whenReady();
+
+ const prefManager = new PreferencesManager(appPaths.settingsFile);
+ readyHandler(prefManager, initOptions);
+}
diff --git a/menus/darwin.json b/src/menus/darwin.json
similarity index 84%
rename from menus/darwin.json
rename to src/menus/darwin.json
index 45c4442f..128d5a0e 100644
--- a/menus/darwin.json
+++ b/src/menus/darwin.json
@@ -65,32 +65,52 @@
"label": "File",
"submenu": [
{
- "label": "New tab",
- "command": "request:new-tab",
- "accelerator": "CommandOrControl+t"
- }, {
+ "label": "New",
+ "submenu": [
+ {
+ "label": "HTTP request",
+ "command": "request:new-http-tab",
+ "accelerator": "CommandOrControl+t"
+ },
+ {
+ "label": "Web socket request",
+ "command": "request:new-websocket-tab"
+ },
+ {
+ "label": "Window",
+ "command": "application:new-window",
+ "accelerator": "CommandOrControl+n"
+ }
+ ]
+ },
+ {
+ "label": "Open",
+ "submenu": [
+ {
+ "label": "Open file",
+ "command": "application:open-file",
+ "accelerator": "CommandOrControl+Shift+o"
+ },
+ {
+ "label": "Open saved request",
+ "command": "application:open-saved",
+ "accelerator": "CommandOrControl+o"
+ },
+ {
+ "label": "Open history",
+ "command": "application:open-history",
+ "accelerator": "CommandOrControl+h"
+ },
+ {
+ "label": "Open from Google Drive",
+ "command": "application:open-drive"
+ }
+ ]
+ },
+ {
"label": "Close tab",
"command": "request:close-tab",
"accelerator": "CommandOrControl+w"
- }, {
- "label": "New window",
- "command": "application:new-window",
- "accelerator": "CommandOrControl+n"
- }, {
- "label": "Open file",
- "command": "application:open-file",
- "accelerator": "CommandOrControl+Shift+o"
- }, {
- "label": "Open saved request",
- "command": "application:open-saved",
- "accelerator": "CommandOrControl+o"
- }, {
- "label": "Open history",
- "command": "application:open-history",
- "accelerator": "CommandOrControl+Shift+h"
- }, {
- "label": "Open from Google Drive",
- "command": "application:open-drive"
},
{
"type": "separator"
@@ -168,10 +188,6 @@
},
{
"role": "toggledevtools"
- },
- {
- "label": "Task Manager",
- "command": "application:task-manager"
}
]
},
@@ -229,23 +245,17 @@
"role": "front"
},
{
- "type": "separator",
- "visible": false
+ "type": "separator"
},
{
"label": "Popup application menu",
- "command": "application:popup-menu",
- "visible": false
+ "command": "application:popup-menu"
}
]
},
{
"label": "Request",
"submenu": [
- {
- "label": "Open requests workspace",
- "command": "application:open-requests-workspace"
- },
{
"label": "Run current tab",
"command": "request:send-current",
@@ -341,14 +351,6 @@
"label": "Frequently Asked Questions",
"command": "application:open-faq"
},
- {
- "label": "What's new",
- "command": "application:open-messages"
- },
- {
- "label": "Show tutorial",
- "command": "application:open-onboarding"
- },
{
"type": "separator"
},
diff --git a/menus/linux.json b/src/menus/linux.json
similarity index 82%
rename from menus/linux.json
rename to src/menus/linux.json
index 2c5effdd..f4571c74 100644
--- a/menus/linux.json
+++ b/src/menus/linux.json
@@ -4,32 +4,52 @@
"label": "File",
"submenu": [
{
- "label": "New tab",
- "command": "request:new-tab",
- "accelerator": "CommandOrControl+t"
- }, {
+ "label": "New",
+ "submenu": [
+ {
+ "label": "HTTP request",
+ "command": "request:new-http-tab",
+ "accelerator": "CommandOrControl+t"
+ },
+ {
+ "label": "Web socket request",
+ "command": "request:new-websocket-tab"
+ },
+ {
+ "label": "Window",
+ "command": "application:new-window",
+ "accelerator": "CommandOrControl+n"
+ }
+ ]
+ },
+ {
+ "label": "Open",
+ "submenu": [
+ {
+ "label": "Open file",
+ "command": "application:open-file",
+ "accelerator": "CommandOrControl+Shift+o"
+ },
+ {
+ "label": "Open saved request",
+ "command": "application:open-saved",
+ "accelerator": "CommandOrControl+o"
+ },
+ {
+ "label": "Open history",
+ "command": "application:open-history",
+ "accelerator": "CommandOrControl+h"
+ },
+ {
+ "label": "Open from Google Drive",
+ "command": "application:open-drive"
+ }
+ ]
+ },
+ {
"label": "Close tab",
"command": "request:close-tab",
"accelerator": "CommandOrControl+w"
- }, {
- "label": "New Window",
- "command": "application:new-window",
- "accelerator": "CommandOrControl+n"
- }, {
- "label": "Open file",
- "command": "application:open-file",
- "accelerator": "CommandOrControl+Shift+o"
- }, {
- "label": "Open saved request",
- "command": "application:open-saved",
- "accelerator": "CommandOrControl+o"
- }, {
- "label": "Open history",
- "command": "application:open-history",
- "accelerator": "CommandOrControl+h"
- }, {
- "label": "Open from Google Drive",
- "command": "application:open-drive"
},
{
"type": "separator"
@@ -122,10 +142,6 @@
},
{
"role": "toggledevtools"
- },
- {
- "label": "Task Manager",
- "command": "application:task-manager"
}
]
},
@@ -178,23 +194,17 @@
"role": "front"
},
{
- "type": "separator",
- "visible": false
+ "type": "separator"
},
{
"label": "Popup application menu",
- "command": "application:popup-menu",
- "visible": false
+ "command": "application:popup-menu"
}
]
},
{
"label": "Request",
"submenu": [
- {
- "label": "Open requests workspace",
- "command": "application:open-requests-workspace"
- },
{
"label": "Run current tab",
"command": "request:send-current",
@@ -230,13 +240,6 @@
{
"label": "Hosts",
"command": "application:open-hosts-editor"
- },
- {
- "type": "separator"
- },
- {
- "label": "Web socket request",
- "command": "application:open-web-socket"
}
]
},
@@ -321,14 +324,6 @@
"label": "Frequently Asked Questions",
"command": "application:open-faq"
},
- {
- "label": "What's new",
- "command": "application:open-messages"
- },
- {
- "label": "Show tutorial",
- "command": "application:open-onboarding"
- },
{
"type": "separator"
},
diff --git a/src/menus/types.d.ts b/src/menus/types.d.ts
new file mode 100644
index 00000000..5461b385
--- /dev/null
+++ b/src/menus/types.d.ts
@@ -0,0 +1,12 @@
+export interface MenuDefinition {
+ menu: MenuItemDefinition[];
+}
+
+export class MenuItemDefinition {
+ label?: string;
+ command?: string;
+ accelerator?: string;
+ type?: string;
+ role?: string;
+ submenu?: MenuItemDefinition[];
+}
\ No newline at end of file
diff --git a/menus/win.json b/src/menus/win.json
similarity index 83%
rename from menus/win.json
rename to src/menus/win.json
index 4d761c20..5fa1e1c9 100644
--- a/menus/win.json
+++ b/src/menus/win.json
@@ -4,39 +4,53 @@
"label": "File",
"submenu": [
{
- "label": "New tab",
- "command": "request:new-tab",
- "accelerator": "CommandOrControl+t"
+ "label": "New",
+ "submenu": [
+ {
+ "label": "HTTP request",
+ "command": "request:new-http-tab",
+ "accelerator": "CommandOrControl+t"
+ },
+ {
+ "label": "Web socket request",
+ "command": "request:new-websocket-tab"
+ },
+ {
+ "label": "Window",
+ "command": "application:new-window",
+ "accelerator": "CommandOrControl+n"
+ }
+ ]
+ },
+ {
+ "label": "Open",
+ "submenu": [
+ {
+ "label": "Open file",
+ "command": "application:open-file",
+ "accelerator": "CommandOrControl+Shift+o"
+ },
+ {
+ "label": "Open saved request",
+ "command": "application:open-saved",
+ "accelerator": "CommandOrControl+o"
+ },
+ {
+ "label": "Open history",
+ "command": "application:open-history",
+ "accelerator": "CommandOrControl+h"
+ },
+ {
+ "label": "Open from Google Drive",
+ "command": "application:open-drive"
+ }
+ ]
},
{
"label": "Close tab",
"command": "request:close-tab",
"accelerator": "CommandOrControl+w"
},
- {
- "label": "New Window",
- "command": "application:new-window",
- "accelerator": "CommandOrControl+n"
- },
- {
- "label": "Open file",
- "command": "application:open-file",
- "accelerator": "CommandOrControl+Shift+o"
- },
- {
- "label": "Open saved request",
- "command": "application:open-saved",
- "accelerator": "CommandOrControl+o"
- },
- {
- "label": "Open history",
- "command": "application:open-history",
- "accelerator": "CommandOrControl+h"
- },
- {
- "label": "Open from Google Drive",
- "command": "application:open-drive"
- },
{
"type": "separator"
},
@@ -128,10 +142,6 @@
},
{
"role": "toggledevtools"
- },
- {
- "label": "Task Manager",
- "command": "application:task-manager"
}
]
},
@@ -184,23 +194,17 @@
"role": "front"
},
{
- "type": "separator",
- "visible": false
+ "type": "separator"
},
{
"label": "Popup application menu",
- "command": "application:popup-menu",
- "visible": false
+ "command": "application:popup-menu"
}
]
},
{
"label": "Request",
"submenu": [
- {
- "label": "Open requests workspace",
- "command": "application:open-requests-workspace"
- },
{
"label": "Run current tab",
"command": "request:send-current",
@@ -320,14 +324,6 @@
"label": "Frequently Asked Questions",
"command": "application:open-faq"
},
- {
- "label": "What's new",
- "command": "application:open-messages"
- },
- {
- "label": "Show tutorial",
- "command": "application:open-onboarding"
- },
{
"type": "separator"
},
diff --git a/src/poweredby.js b/src/poweredby.js
deleted file mode 100644
index ae4f38ea..00000000
--- a/src/poweredby.js
+++ /dev/null
@@ -1,17 +0,0 @@
-/**
-@license
-Copyright 2018 The Advanced REST client authors
-Licensed under the Apache License, Version 2.0 (the "License"); you may not
-use this file except in compliance with the License. You may obtain a copy of
-the License at
-http://www.apache.org/licenses/LICENSE-2.0
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-License for the specific language governing permissions and limitations under
-the License.
-*/
-import { svg } from '../web_modules/lit-element/lit-element.js';
-/* eslint-disable max-len */
-export default svg`
- Powered by `;
diff --git a/src/preload/Analytics.d.ts b/src/preload/Analytics.d.ts
new file mode 100644
index 00000000..f5e99b51
--- /dev/null
+++ b/src/preload/Analytics.d.ts
@@ -0,0 +1,35 @@
+export declare interface AnalyticsInit {
+ clientId: string;
+ trackingId: string;
+ userId?: string;
+ anonymizeIp?: boolean;
+ dataSource?: string;
+ useCacheBooster?: boolean;
+ referrer?: string;
+ campaignName?: string;
+ campaignSource?: string;
+ campaignMedium?: string;
+ appVersion?: string;
+ appName?: string;
+ appId?: string;
+ appInstallerId?: string;
+ debug?: boolean;
+ debugEndpoint?: boolean;
+ customMetrics?: CustomMetric[];
+ customDimensions?: CustomDimension[];
+}
+
+export declare interface CustomMetric {
+ index: number;
+ value: number;
+}
+
+export declare interface CustomDimension {
+ index: number;
+ value: string;
+}
+
+export declare interface BaseHitOptions {
+ customMetrics?: CustomMetric[];
+ customDimensions?: CustomDimension[];
+}
diff --git a/src/preload/AppStateProxy.js b/src/preload/AppStateProxy.js
new file mode 100644
index 00000000..879b89df
--- /dev/null
+++ b/src/preload/AppStateProxy.js
@@ -0,0 +1,26 @@
+import { ipcRenderer } from 'electron';
+
+/** @typedef {import('@advanced-rest-client/arc-types').ArcState.ARCState} ARCState */
+
+/**
+ * A class that acts as a proxy to read application settings.
+ */
+export class AppStateProxy {
+ /**
+ * Reads the current application state.
+ * @returns {Promise}
+ */
+ read() {
+ return ipcRenderer.invoke('app-state-read');
+ }
+
+ /**
+ * Updates a single state value
+ * @param {string} name Path to the state preference
+ * @param {any} value State value
+ * @returns {Promise}
+ */
+ update(name, value) {
+ return ipcRenderer.invoke('app-state-update', name, value);
+ }
+}
diff --git a/src/preload/ApplicationSearchProxy.js b/src/preload/ApplicationSearchProxy.js
new file mode 100644
index 00000000..b11ec670
--- /dev/null
+++ b/src/preload/ApplicationSearchProxy.js
@@ -0,0 +1,81 @@
+/* eslint-disable no-unused-vars */
+import { ipcRenderer } from 'electron';
+
+export const search = Symbol('search');
+export const resultHandler = Symbol('resultHandler');
+export const messageHandler = Symbol('messageHandler');
+
+/**
+ * A proxy for the corresponding class defined in the `io` namespace.
+ * Informs about search action.
+ */
+export class ApplicationSearchProxy {
+ constructor() {
+ /**
+ * The last query used with `search()`.
+ */
+ this.lastQuery = undefined;
+ }
+
+ listen() {
+ ipcRenderer.on('search-bar-found-in-page', this[resultHandler].bind(this));
+ window.addEventListener('message', this[messageHandler].bind(this));
+ }
+
+ /**
+ * Depending on the situation, either performs a new search or moves to another position
+ * @param {string|null} query The query to search for
+ */
+ search(query) {
+ if (this.lastQuery === query) {
+ this.searchNext();
+ return;
+ }
+ this.lastQuery = query;
+ const opts = {};
+ this[search](query, opts);
+ }
+
+ searchNext() {
+ const opts = {
+ findNext: true,
+ forward: true,
+ };
+ this[search](this.lastQuery, opts);
+ }
+
+ searchPrevious() {
+ const opts = {
+ findNext: true,
+ forward: false,
+ };
+ this[search](this.lastQuery, opts);
+ }
+
+ /**
+ * @param {string|null} query The query or null to stop the search
+ * @param {Electron.FindInPageOptions=} opts Search options
+ */
+ [search](query, opts) {
+ if (!query) {
+ ipcRenderer.send('search-bar-clear');
+ return;
+ }
+ ipcRenderer.send('search-bar-find', query, opts);
+ }
+
+ [resultHandler](e, matches, activeMatchOrdinal) {
+ // console.log('Search result', e, matches, activeMatchOrdinal);
+ }
+
+ /**
+ * @param {MessageEvent} e
+ */
+ [messageHandler](e) {
+ const { data } = e;
+ switch (data.action) {
+ case 'search-bar-query': this.search(data.query); break;
+ default:
+ }
+ }
+}
diff --git a/src/preload/CookieBridge.js b/src/preload/CookieBridge.js
new file mode 100644
index 00000000..36232dda
--- /dev/null
+++ b/src/preload/CookieBridge.js
@@ -0,0 +1,314 @@
+import { ipcRenderer as ipc } from 'electron';
+import { SessionCookieEventTypes, SessionCookieEvents } from '@advanced-rest-client/arc-events';
+
+/** @typedef {import('@advanced-rest-client/arc-events').SessionCookiesListEvent} SessionCookiesListEvent */
+/** @typedef {import('@advanced-rest-client/arc-events').SessionCookiesListDomainEvent} SessionCookiesListDomainEvent */
+/** @typedef {import('@advanced-rest-client/arc-events').SessionCookiesListUrlEvent} SessionCookiesListUrlEvent */
+/** @typedef {import('@advanced-rest-client/arc-events').SessionCookiesRemoveEvent} SessionCookiesRemoveEvent */
+/** @typedef {import('@advanced-rest-client/arc-events').SessionCookieUpdateEvent} SessionCookieUpdateEvent */
+/** @typedef {import('@advanced-rest-client/arc-events').SessionCookieUpdateBulkEvent} SessionCookieUpdateBulkEvent */
+/** @typedef {import('@advanced-rest-client/arc-types').Cookies.ARCCookie} ARCCookie */
+
+export const requestAllCookiesHandler = Symbol('requestAllCookiesHandler');
+export const requestDomainCookiesHandler = Symbol('requestDomainCookiesHandler');
+export const requestUrlCookiesHandler = Symbol('requestUrlCookiesHandler');
+export const updateCookieHandler = Symbol('updateCookieHandler');
+export const updateCookiesHandler = Symbol('updateCookiesHandler');
+export const deleteCookiesHandler = Symbol('deleteCookiesHandler');
+export const cookieChangeHandler = Symbol('cookieChangeHandler');
+
+/**
+ * Computes a cookie URL from the cookie definition
+ *
+ * @param {ARCCookie} cookie
+ * @param {boolean=} secured
+ * @return {string}
+ */
+function computeCookieUrl(cookie, secured=false) {
+ let { domain='' } = cookie;
+ if (domain[0] === '.') {
+ domain = domain.substr(1);
+ }
+ let protocol = 'http';
+ if (secured) {
+ protocol += 's';
+ }
+ protocol += '://';
+ return protocol + domain + (cookie.path || '/');
+}
+
+/**
+ * @param {Electron.Cookie} electronCookie
+ * @return {ARCCookie}
+ */
+export function electronToArcCookie(electronCookie) {
+ const cookie = /** @type ARCCookie */ ({
+ domain: electronCookie.domain,
+ httpOnly: electronCookie.httpOnly,
+ hostOnly: electronCookie.hostOnly,
+ name: electronCookie.name,
+ path: electronCookie.path,
+ secure: electronCookie.secure,
+ session: electronCookie.session,
+ value: electronCookie.value,
+ created: Date.now(),
+ expires: 0,
+ lastAccess: Date.now(),
+ persistent: false,
+ });
+ if (electronCookie.expirationDate) {
+ cookie.expires = electronCookie.expirationDate * 1000;
+ }
+ return cookie;
+}
+/**
+ * @param {ARCCookie} cookie
+ * @return {CookiesSetDetails} A copy of the cookie that is translated into an Electron cookie
+ */
+export function arcCookieToElectron(cookie) {
+ const electronCookie = /** @type CookiesSetDetails */ ({
+ domain: cookie.domain,
+ httpOnly: cookie.httpOnly,
+ hostOnly: cookie.hostOnly,
+ name: cookie.name,
+ path: cookie.path,
+ secure: cookie.secure,
+ value: cookie.value,
+ url: computeCookieUrl(cookie, cookie.secure),
+ });
+ if (cookie.expires) {
+ electronCookie.expirationDate = Math.round(cookie.expires / 1000);
+ }
+ return electronCookie;
+}
+
+
+/**
+ * Class responsible for cookie exchange between web app and the main process.
+ */
+export class CookieBridge {
+ constructor() {
+ this[requestAllCookiesHandler] = this[requestAllCookiesHandler].bind(this);
+ this[requestDomainCookiesHandler] = this[requestDomainCookiesHandler].bind(this);
+ this[requestUrlCookiesHandler] = this[requestUrlCookiesHandler].bind(this);
+ this[updateCookieHandler] = this[updateCookieHandler].bind(this);
+ this[updateCookiesHandler] = this[updateCookiesHandler].bind(this);
+ this[cookieChangeHandler] = this[cookieChangeHandler].bind(this);
+ this[deleteCookiesHandler] = this[deleteCookiesHandler].bind(this);
+ }
+
+ listen() {
+ window.addEventListener(SessionCookieEventTypes.listAll, this[requestAllCookiesHandler]);
+ window.addEventListener(SessionCookieEventTypes.listDomain, this[requestDomainCookiesHandler]);
+ window.addEventListener(SessionCookieEventTypes.listUrl, this[requestUrlCookiesHandler]);
+ window.addEventListener(SessionCookieEventTypes.delete, this[deleteCookiesHandler]);
+ window.addEventListener(SessionCookieEventTypes.update, this[updateCookieHandler]);
+ window.addEventListener(SessionCookieEventTypes.updateBulk, this[updateCookiesHandler]);
+ ipc.on('cookie-changed', this[cookieChangeHandler]);
+ }
+
+ unlisten() {
+ window.removeEventListener(SessionCookieEventTypes.listAll, this[requestAllCookiesHandler]);
+ window.removeEventListener(SessionCookieEventTypes.listDomain, this[requestDomainCookiesHandler]);
+ window.removeEventListener(SessionCookieEventTypes.listUrl, this[requestUrlCookiesHandler]);
+ window.removeEventListener(SessionCookieEventTypes.delete, this[deleteCookiesHandler]);
+ window.removeEventListener(SessionCookieEventTypes.update, this[updateCookieHandler]);
+ window.removeEventListener(SessionCookieEventTypes.updateBulk, this[updateCookiesHandler]);
+ ipc.removeListener('cookie-changed', this[cookieChangeHandler]);
+ }
+
+ /**
+ * @return {Promise} List of all cookies in the cookie session partition.
+ */
+ async getAllCookies() {
+ const result = /** @type Electron.Cookie[] */ (await ipc.invoke('cookies-session-get-all'));
+ return result.map((item) => electronToArcCookie(item));
+ }
+
+ /**
+ * @param {string} domain Cookies domain name
+ * @return {Promise} List of domain cookies in the cookie session partition.
+ */
+ async getDomainCookies(domain) {
+ const result = /** @type Electron.Cookie[] */ (await ipc.invoke('cookies-session-get-domain', domain));
+ return result.map((item) => electronToArcCookie(item));
+ }
+
+ /**
+ * Gets a list of cookies for given URL (matching domain and path as defined
+ * in Cookie spec) from the datastore.
+ *
+ * @param {string} url An URL to match cookies.
+ * @return {Promise} List of database objects that matches cookies.
+ */
+ async getUrlCookies(url) {
+ const result = /** @type Electron.Cookie[] */ (await ipc.invoke('cookies-session-get-url', url));
+ return result.map((item) => electronToArcCookie(item));
+ }
+
+ /**
+ * Removes cookie or cookies from the store.
+ * @param {ARCCookie[]} cookies A cookie or a list of cookies to delete.
+ * @return {Promise}
+ */
+ async removeCookies(cookies) {
+ const electronCookies = cookies.map((item) => arcCookieToElectron(item));
+ return ipc.invoke('cookies-session-remove-cookies', electronCookies);
+ }
+
+ /**
+ * Creates or updates cookies in the cookies partition.
+ * @param {ARCCookie} cookie ARC's cookie definition.
+ * @return {Promise}
+ */
+ async updateCookie(cookie) {
+ const electronCookie = arcCookieToElectron(cookie);
+ return ipc.invoke('cookies-session-set-cookie', electronCookie);
+ }
+
+ /**
+ * Stores list of cookies in the store.
+ *
+ * @param {ARCCookie[]} cookies List of cookies to store
+ * @return {Promise} Resolved promise when all cookies are stored.
+ */
+ async updateCookies(cookies) {
+ if (!cookies || !cookies.length) {
+ return undefined;
+ }
+ const items = cookies.map((cookie) => {
+ let item;
+ // @ts-ignore
+ if (cookie.toJSON) {
+ // compatibility with cookie-parser of ARC
+ // @ts-ignore
+ item = cookie.toJSON();
+ } else {
+ item = cookie;
+ }
+ return arcCookieToElectron(item);
+ });
+ return ipc.invoke('cookies-session-set-cookies', items);
+ }
+
+ /**
+ * @param {Electron.Cookie} cookie
+ * @returns {ARCCookie}
+ */
+ translateCookieForWeb(cookie) {
+ const result = /** @type ARCCookie */ ({ ...cookie });
+ if (cookie.expirationDate) {
+ result.expires = cookie.expirationDate * 1000;
+ // @ts-ignore
+ delete result.expirationDate;
+ }
+ return result;
+ }
+
+ /**
+ * Handler for the `session-cookie-list-all` DOM event.
+ * Sets a result of calling `getAllCookies()` to `detail.result` property.
+ * @param {SessionCookiesListEvent} e
+ */
+ [requestAllCookiesHandler](e) {
+ if (e.defaultPrevented) {
+ return;
+ }
+ e.preventDefault();
+ e.detail.result = this.getAllCookies();
+ }
+
+ /**
+ * Handler for the `session-cookie-list-domain` DOM event.
+ * Sets a result of calling `getDomainCookies()` to `detail.result` property.
+ *
+ * It expects the `domain` property to be set on the `detail` object.
+ *
+ * @param {SessionCookiesListDomainEvent} e
+ */
+ [requestDomainCookiesHandler](e) {
+ if (e.defaultPrevented) {
+ return;
+ }
+ e.preventDefault();
+ const { domain } = e;
+ e.detail.result = this.getDomainCookies(domain);
+ }
+
+ /**
+ * @param {SessionCookiesListUrlEvent} e
+ */
+ [requestUrlCookiesHandler](e) {
+ if (e.defaultPrevented) {
+ return;
+ }
+ e.preventDefault();
+ const { url } = e;
+ e.detail.result = this.getUrlCookies(url);
+ }
+
+ /**
+ * Handler for the `session-cookie-remove` DOM event.
+ * Sets a result of calling `removeCookies(detail.remove)` to `detail.result` property.
+ *
+ * It expects the `cookies` property to be set on the `detail` object.
+ *
+ * @param {SessionCookiesRemoveEvent} e
+ */
+ [deleteCookiesHandler](e) {
+ if (e.defaultPrevented) {
+ return;
+ }
+ e.preventDefault();
+ const { cookies } = e;
+ e.detail.result = this.removeCookies(cookies);
+ }
+
+ /**
+ * Handler for the `session-cookie-update` DOM event.
+ * Sets a result of calling `updateCookie(detail.cookie)` to `detail.result` property.
+ *
+ * It expects the `cookie` property to be set on the `detail` object.
+ *
+ * @param {SessionCookieUpdateEvent} e
+ */
+ [updateCookieHandler](e) {
+ if (e.defaultPrevented) {
+ return;
+ }
+ e.preventDefault();
+ const { cookie } = e;
+ e.detail.result = this.updateCookie(cookie);
+ }
+
+ /**
+ * @param {SessionCookieUpdateBulkEvent} e
+ */
+ [updateCookiesHandler](e) {
+ if (e.defaultPrevented) {
+ return;
+ }
+ e.preventDefault();
+ const { cookies } = e;
+ e.detail.result = this.updateCookies(cookies);
+ }
+
+ /**
+ * A handler from main thread's `cookie-changed` event.
+ * It dispatches `session-cookie-removed` or `session-cookie-changed` DOM event,
+ * depending on the change definition.
+ *
+ * @param {Event} e IPC event
+ * @param {Object} data Cookie data
+ * @param {Object} data.cookie The electron cookie object
+ * @param {boolean=} data.removed Set when a cookie was removed. Otherwise it is changed.
+ */
+ [cookieChangeHandler](e, data) {
+ const cookie = this.translateCookieForWeb(data.cookie);
+ if (data.removed) {
+ SessionCookieEvents.State.delete(document.body, cookie);
+ } else {
+ SessionCookieEvents.State.update(document.body, cookie);
+ }
+ }
+}
diff --git a/src/preload/EncryptionService.js b/src/preload/EncryptionService.js
new file mode 100644
index 00000000..ddbf47a6
--- /dev/null
+++ b/src/preload/EncryptionService.js
@@ -0,0 +1,142 @@
+// import prompt from 'electron-prompt';
+import { EncryptionEventTypes } from '@advanced-rest-client/arc-events';
+
+/** @typedef {import('@advanced-rest-client/arc-events').ArcEncryptEvent} ArcEncryptEvent */
+/** @typedef {import('@advanced-rest-client/arc-events').ArcDecryptEvent} ArcDecryptEvent */
+
+/**
+ * A class that handles DOM events to perform data encryption/decryption.
+ */
+export class EncryptionService {
+ constructor() {
+ this._decodeHandler = this._decodeHandler.bind(this);
+ this._encodeHandler = this._encodeHandler.bind(this);
+ }
+
+ listen() {
+ window.addEventListener(EncryptionEventTypes.decrypt, this._decodeHandler);
+ window.addEventListener(EncryptionEventTypes.encrypt, this._encodeHandler);
+ }
+
+ unlisten() {
+ window.removeEventListener(EncryptionEventTypes.decrypt, this._decodeHandler);
+ window.removeEventListener(EncryptionEventTypes.encrypt, this._encodeHandler);
+ }
+
+ /**
+ * @param {ArcDecryptEvent} e
+ */
+ _decodeHandler(e) {
+ const { method, data, passphrase } = e;
+ e.preventDefault();
+ e.detail.result = this.decode(method, data, passphrase);
+ }
+
+ /**
+ * @param {ArcEncryptEvent} e
+ */
+ _encodeHandler(e) {
+ const { method, passphrase, data } = e;
+ e.preventDefault();
+ e.detail.result = this.encode(method, data, passphrase);
+ }
+
+ /**
+ * @param {string} method The method to use. Currently only eas is supported.
+ * @param {string} data The data to encrypt
+ * @param {string} passphrase THe password to use
+ * @returns {Promise} Encoded string.
+ */
+ async encode(method, data, passphrase) {
+ switch (method) {
+ case 'aes': return this.encodeAes(data, passphrase);
+ default: throw new Error(`Unknown encryption method`);
+ }
+ }
+
+ /**
+ * @param {string} data The data to encode
+ * @param {string} passphrase THe password to use to encode the data
+ * @returns {Promise}
+ */
+ async encodeAes(data, passphrase) {
+ // see https://gist.github.com/chrisveness/43bcda93af9f646d083fad678071b90a
+ const pwUtf8 = new TextEncoder().encode(passphrase);
+ const pwHash = await crypto.subtle.digest('SHA-256', pwUtf8);
+ const iv = crypto.getRandomValues(new Uint8Array(12));
+ const alg = { name: 'AES-GCM', iv };
+ const key = await crypto.subtle.importKey('raw', pwHash, alg, false, ['encrypt']);
+ const ptUint8 = new TextEncoder().encode(data);
+ const ctBuffer = await crypto.subtle.encrypt(alg, key, ptUint8);
+ const ctArray = Array.from(new Uint8Array(ctBuffer));
+ const ctStr = ctArray.map(byte => String.fromCharCode(byte)).join('');
+ const ctBase64 = btoa(ctStr);
+ const ivHex = Array.from(iv).map(b => (`00${b.toString(16)}`).slice(-2)).join('');
+ return ivHex+ctBase64;
+ }
+
+ /**
+ * Decodes previously encoded data
+ * @param {string} method
+ * @param {string} data
+ * @param {string=} passphrase
+ * @returns {Promise} The decoded data
+ */
+ async decode(method, data, passphrase) {
+ switch (method) {
+ case 'aes': return this.decodeAes(data, passphrase);
+ default: throw new Error(`Unknown decryption method`);
+ }
+ }
+
+ /**
+ * Decodes previously encoded data with AES method.
+ * @param {string} data The data to decrypt
+ * @param {string=} passphrase When not provided it asks the user for the password.
+ * @returns {Promise} The decoded data
+ */
+ async decodeAes(data, passphrase) {
+ if (passphrase === undefined) {
+ // eslint-disable-next-line no-param-reassign
+ passphrase = await this.requestPassword();
+ }
+ try {
+ const pwUtf8 = new TextEncoder().encode(passphrase);
+ const pwHash = await crypto.subtle.digest('SHA-256', pwUtf8);
+ const iv = data.slice(0,24).match(/.{2}/g).map(byte => parseInt(byte, 16));
+ const alg = { name: 'AES-GCM', iv: new Uint8Array(iv) };
+ const key = await crypto.subtle.importKey('raw', pwHash, alg, false, ['decrypt']);
+ const ctStr = atob(data.slice(24));
+ const ctUint8 = new Uint8Array(ctStr.match(/[\s\S]/g).map(ch => ch.charCodeAt(0)));
+ const plainBuffer = await crypto.subtle.decrypt(alg, key, ctUint8);
+ const plaintext = new TextDecoder().decode(plainBuffer);
+ return plaintext;
+ } catch (_) {
+ throw new Error('Invalid password.');
+ }
+ }
+
+ /**
+ * Opens a password dialog, which is hard-coded into the `app.html` file to ask for the file password.
+ * @returns {Promise} User input or throws when cancelled.
+ */
+ async requestPassword() {
+ return new Promise((resolve, reject) => {
+ const dialog = document.getElementById('passwordPrompt');
+ // @ts-ignore
+ dialog.opened = true;
+ dialog.addEventListener('closed', function f(e) {
+ dialog.removeEventListener('closed', f);
+ // @ts-ignore
+ const { detail } = e;
+ if (detail.cancelled || !detail.confirmed) {
+ reject(new Error('The password is required.'));
+ } else {
+ const input = dialog.querySelector('anypoint-masked-input');
+ // no validation here, password can be an empty string
+ resolve(input.value);
+ }
+ });
+ });
+ }
+}
diff --git a/src/preload/FilesystemProxy.js b/src/preload/FilesystemProxy.js
new file mode 100644
index 00000000..5174b7dd
--- /dev/null
+++ b/src/preload/FilesystemProxy.js
@@ -0,0 +1,181 @@
+import path from 'path';
+import fs from 'fs-extra';
+import log from 'electron-log';
+import { ipcRenderer } from 'electron';
+import { DataExportEventTypes } from '@advanced-rest-client/arc-events';
+import { v4 } from 'uuid';
+
+/** @typedef {import('@advanced-rest-client/arc-events').ArcExportFilesystemEvent} ArcExportFilesystemEvent */
+/** @typedef {import('@advanced-rest-client/arc-types').DataExport.ProviderOptions} ProviderOptions */
+/** @typedef {import('@advanced-rest-client/arc-types').DataExport.ArcExportResult} ArcExportResult */
+/** @typedef {import('@advanced-rest-client/electron-amf-service/types').ApiParseResult} ApiParseResult */
+
+export const exportHandler = Symbol('exportHandler');
+export const writeContent = Symbol('writeContent');
+export const prepareData = Symbol('prepareData');
+
+/**
+ * This class is a proxy to access user filesystem from the renderer process.
+ *
+ * Node integration is disabled inside the application and scripts do not have
+ * access to the `fs` module. This class is loaded in the preload script and
+ * uses events API to store data in file.
+ *
+ * Also, data are not send to the IO thread as saving file is a blocking
+ * operation which could froze all application windows. If anything happens
+ * during IO operation it us better to crash single window.
+ */
+export class FilesystemProxy {
+ constructor() {
+ this[exportHandler] = this[exportHandler].bind(this);
+ }
+
+ listen() {
+ window.addEventListener(DataExportEventTypes.fileSave, this[exportHandler]);
+ }
+
+ unlisten() {
+ window.removeEventListener(DataExportEventTypes.fileSave, this[exportHandler]);
+ }
+
+ /**
+ * @param {ArcExportFilesystemEvent} e
+ */
+ [exportHandler](e) {
+ if (e.defaultPrevented) {
+ return;
+ }
+ e.preventDefault();
+ const { data, providerOptions } = e;
+ e.detail.result = this.exportFileData(data, providerOptions);
+ }
+
+ /**
+ * Requests a save file dialog and saves the data to selected path if not cancelled.
+ * This does nothing when dialog is canceled.
+ *
+ * @param {string|Buffer} content Data to write
+ * @param {ProviderOptions} options Export provider options
+ * @return {Promise}
+ */
+ async exportFileData(content, options) {
+ const opts = {
+ file: options.file,
+ };
+ let dialogResult;
+ try {
+ dialogResult = await ipcRenderer.invoke('save-dialog', opts);
+ } catch (e) {
+ log.error(e);
+ return /** @type ArcExportResult */ ({
+ interrupted: false,
+ success: false,
+ });
+ }
+ const { filePath, canceled } = dialogResult;
+ const result = /** @type ArcExportResult */ ({
+ interrupted: !!canceled,
+ success: !canceled,
+ });
+ if (canceled) {
+ return result;
+ }
+ result.fileId = path.basename(filePath);
+ result.parentId = path.dirname(filePath);
+ try {
+ await this[writeContent](filePath, content, options.contentType);
+ } catch (e) {
+ result.success = false;
+ log.error(e);
+ }
+ return result;
+ }
+
+ /**
+ * Writes content to a file
+ * @param {string} filePath Absolute path to a file
+ * @param {string|Buffer|any} content Data to be written
+ * @param {string=} mime Content media type.
+ * @return {Promise}
+ */
+ [writeContent](filePath, content, mime) {
+ let data = content;
+ if (typeof content !== 'string') {
+ data = this[prepareData](content, mime);
+ }
+ return fs.writeFile(filePath, data, 'utf8');
+ }
+
+ /**
+ * @param {any} data
+ * @param {string} mime
+ * @return {string}
+ */
+ [prepareData](data, mime) {
+ switch (mime) {
+ case 'application/json': return JSON.stringify(data);
+ default: return String(data);
+ }
+ }
+
+ /**
+ * Triggers the open file dialog pre-configured to pick supported by ARC files.
+ *
+ * @returns {Promise}
+ */
+ async pickFile() {
+ return ipcRenderer.invoke('open-dialog');
+ }
+
+ // /**
+ // * Allows to read file from user filesystem.
+ // * @param {string} filePath File path to ready
+ // * @return {Promise}
+ // */
+ // readFile(filePath) {
+ // return fs.readFile(filePath);
+ // }
+
+ // extname(filePath) {
+ // return path.extname(filePath);
+ // }
+
+ /**
+ * When the API data is processed by the AMF service, this function is called to store the temporary file
+ * in the application home directory with the API details.
+ * After the data is saved the function returns the name of the file to the main application so it can redirect the user to
+ * the API Console page with the file identifier.
+ *
+ * @param {ApiParseResult} data
+ * @returns {Promise}
+ */
+ async storeApicModelTmp(data) {
+ const dir = path.join(process.env.ARC_HOME, 'amf-models');
+ await fs.ensureDir(dir);
+ const id = v4();
+ const file = `${id}.json`;
+ const filePath = path.join(dir, file);
+ await fs.outputJSON(filePath, data);
+ return id;
+ }
+
+ /**
+ * Restores previously stored API data in a temporary file
+ * @param {string} id The id of the file previously generated by the `storeApicModelTmp()` function.
+ * @returns {Promise}
+ */
+ async restoreApicModelTmp(id) {
+ const dir = path.join(process.env.ARC_HOME, 'amf-models');
+ await fs.ensureDir(dir);
+ const file = `${id}.json`;
+ const filePath = path.join(dir, file);
+ const exists = await fs.pathExists(filePath);
+ if (!exists) {
+ throw new Error(`The API Console model does not exists as ${id}`);
+ }
+ const info = await fs.readJSON(filePath);
+ // @todo: uncomment when finished working on this implementation.
+ // fs.remove(filePath);
+ return info;
+ }
+}
diff --git a/src/preload/GoogleAnalytics.js b/src/preload/GoogleAnalytics.js
new file mode 100644
index 00000000..6a135482
--- /dev/null
+++ b/src/preload/GoogleAnalytics.js
@@ -0,0 +1,295 @@
+/* eslint-disable no-param-reassign */
+import { TelemetryEventTypes } from '@advanced-rest-client/arc-events';
+import { ipcRenderer } from 'electron';
+import { v4 } from 'uuid';
+import { UniversalAnalytics } from './UniversalAnalytics.js';
+
+/** @typedef {import('@advanced-rest-client/arc-events').TelemetryExceptionEvent} TelemetryExceptionEvent */
+/** @typedef {import('@advanced-rest-client/arc-events').TelemetryTimingEvent} TelemetryTimingEvent */
+/** @typedef {import('@advanced-rest-client/arc-events').TelemetryEventEvent} TelemetryEventEvent */
+/** @typedef {import('@advanced-rest-client/arc-events').TelemetryScreenEvent} TelemetryScreenEvent */
+/** @typedef {import('@advanced-rest-client/arc-types').Config.ARCConfig} ARCConfig */
+/** @typedef {import('./Analytics').AnalyticsInit} AnalyticsInit */
+
+const eventHandler = Symbol('eventHandler');
+const exceptionHandler = Symbol('exceptionHandler');
+const viewHandler = Symbol('viewHandler');
+const timingHandler = Symbol('viewHandler');
+const preferenceHandler = Symbol('preferenceHandler');
+const channelValue = Symbol('channelValue');
+const setupChannel = Symbol('setupChannel');
+
+/**
+ * @typedef Tracker
+ * @property {UniversalAnalytics} analytics
+ * @property {'web'|'app'} type
+ */
+
+/**
+ * The preload script that should be added to every window and page to add analytics support for the application.
+ * It listens for the DOM events defined in `@advanced-rest-client/arc-events` so the components can dispatch their analytics events
+ * outside the main application scope.
+ */
+export class GoogleAnalytics {
+ get channel() {
+ return this[channelValue];
+ }
+
+ set channel(value) {
+ const old = this[channelValue];
+ if (old === value) {
+ return;
+ }
+ this[channelValue] = value;
+ this[setupChannel](value);
+ }
+
+ constructor() {
+ /**
+ * Whether or not the Google Analytics is enabled.
+ * When disabled all functions are void.
+ */
+ this.telemetry = false;
+
+ /**
+ * The client ID needed to maintain the session.
+ */
+ this.clientId = undefined;
+
+ /**
+ * When `telemetry` equals `false` and this is `true` then it will allow to send
+ * information about exceptions only to google analytics.
+ */
+ this.exceptionsOnly = false;
+
+ /**
+ * The application identifier.
+ */
+ this.appId = 'com.mulesoft.arc';
+
+ /**
+ * The application name.
+ */
+ this.appName = 'Advanced REST Client';
+
+ /**
+ * @type {Tracker[]}
+ */
+ this.trackers = [];
+ }
+
+ addCustomDimensions() {
+ // @ts-ignore
+ const { versionInfo } = global;
+ const cd = [
+ {
+ index: 1,
+ value: versionInfo.chrome,
+ },
+ {
+ index: 2,
+ value: versionInfo.appVersion,
+ }
+ ];
+ this.trackers.forEach((tracker) => {
+ tracker.analytics.customDimensions = cd;
+ });
+ // channel is set up via the `channel` property.
+ }
+
+ async initialize() {
+ let cnf = /** @type ARCConfig */ ({});
+ try {
+ cnf = await ipcRenderer.invoke('preferences-read');
+ } catch (e) {
+ // ..
+ }
+ const { privacy={}, updater={} } = cnf;
+ this.channel = updater.channel || 'stable';
+ this.telemetry = typeof privacy.telemetry === 'boolean' ? privacy.telemetry : false;
+ try {
+ await this.setupClientId(privacy.clientId);
+ } catch (e) {
+ // ...
+ }
+ this.setupTrackers();
+ this.listen();
+ }
+
+ /**
+ * Sets up tracker instances.
+ */
+ setupTrackers() {
+ const base = /** @type AnalyticsInit */ ({
+ trackingId: '',
+ clientId: this.clientId,
+ appName: this.appName,
+ // @ts-ignore
+ appVersion: global.versionInfo.appVersion,
+ appId: this.appId,
+ // debug: true,
+ // debugEndpoint: true,
+ });
+ /**
+ * @type {Tracker[]}
+ */
+ this.trackers = [
+ {
+ analytics: new UniversalAnalytics({ ...base, trackingId: 'UA-18021184-6' }),
+ type: 'web',
+ },
+ {
+ analytics: new UniversalAnalytics({ ...base, trackingId: 'UA-18021184-14' }),
+ type: 'app',
+ },
+ {
+ analytics: new UniversalAnalytics({ ...base, trackingId: 'UA-71458341-1' }),
+ type: 'app',
+ }
+ ];
+ }
+
+ listen() {
+ window.addEventListener(TelemetryEventTypes.event, this[eventHandler].bind(this));
+ window.addEventListener(TelemetryEventTypes.exception, this[exceptionHandler].bind(this));
+ window.addEventListener(TelemetryEventTypes.view, this[viewHandler].bind(this));
+ window.addEventListener(TelemetryEventTypes.timing, this[timingHandler].bind(this));
+ ipcRenderer.on('preferences-value-updated', this[preferenceHandler].bind(this));
+ }
+
+ /**
+ * Sets the client id. When the `clientId` is not provided it generates one and updated the application settings.
+ * @param {string=} clientId
+ */
+ async setupClientId(clientId) {
+ if (typeof clientId === 'string') {
+ this.clientId = clientId;
+ return;
+ }
+ this.clientId = v4();
+ await ipcRenderer.invoke('preferences-update', 'privacy.clientId', this.clientId);
+ }
+
+ /**
+ * @param {string} screenName
+ */
+ screenView(screenName) {
+ if (!this.telemetry) {
+ return;
+ }
+ this.trackers.forEach((tracker) => {
+ if (tracker.type === 'web') {
+ tracker.analytics.sendPage(screenName);
+ } else {
+ tracker.analytics.sendScreen(screenName);
+ }
+ });
+ }
+
+ /**
+ * @param {string} category
+ * @param {string} action
+ * @param {string=} label
+ * @param {number=} value
+ */
+ event(category, action, label, value) {
+ if (!this.telemetry) {
+ return;
+ }
+ this.trackers.forEach((tracker) => {
+ tracker.analytics.sendEvent(category, action, label, value);
+ });
+ }
+
+ /**
+ * @param {string} message
+ * @param {boolean} fatal
+ */
+ exception(message, fatal) {
+ if (!this.telemetry) {
+ return;
+ }
+ this.trackers.forEach((tracker) => {
+ tracker.analytics.sendException(message, fatal);
+ });
+ }
+
+ /**
+ * @param {string} category
+ * @param {string} variable
+ * @param {number} value
+ * @param {string=} label
+ */
+ timing(category, variable, value, label) {
+ if (!this.telemetry) {
+ return;
+ }
+ this.trackers.forEach((tracker) => {
+ tracker.analytics.sendTimings(category, variable, value, label);
+ });
+ }
+
+ /**
+ * @param {TelemetryScreenEvent} e
+ */
+ [viewHandler](e) {
+ const { screenName } = e.detail;
+ this.screenView(screenName);
+ }
+
+ /**
+ * @param {TelemetryEventEvent} e
+ */
+ [eventHandler](e) {
+ const { action, category, label, value } = e.detail;
+ this.event(category, action, label, value);
+ }
+
+ /**
+ * @param {TelemetryExceptionEvent} e
+ */
+ [exceptionHandler](e) {
+ const { description, fatal } = e.detail;
+ this.exception(description, fatal);
+ }
+
+ /**
+ * @param {TelemetryTimingEvent} e
+ */
+ [timingHandler](e) {
+ const { category, variable, value, label } = e.detail;
+ this.timing(category, variable, value, label);
+ }
+
+ /**
+ * @param {string} value The application release channel.
+ */
+ [setupChannel](value) {
+ this.trackers.forEach((tracker) => {
+ const index = tracker.analytics.customDimensions.findIndex((i) => i.index === 5);
+ if (index === -1) {
+ tracker.analytics.customDimensions.push({
+ index: 5,
+ value,
+ });
+ } else {
+ tracker.analytics.customDimensions[index].value = value;
+ }
+ });
+ }
+
+ /**
+ * Handler for the IO event for settings update.
+ *
+ * @param {Electron.IpcRendererEvent} e
+ * @param {String} key The key of changed property
+ * @param {any} value
+ */
+ [preferenceHandler](e, key, value) {
+ switch (key) {
+ case 'privacy.telemetry': this.telemetry = value; break;
+ case 'updater.channel': this.channel = value; break;
+ default:
+ }
+ }
+}
diff --git a/src/preload/GoogleDriveProxy.js b/src/preload/GoogleDriveProxy.js
new file mode 100644
index 00000000..22190962
--- /dev/null
+++ b/src/preload/GoogleDriveProxy.js
@@ -0,0 +1,125 @@
+import { ipcRenderer } from 'electron';
+import { GoogleDriveEventTypes } from '@advanced-rest-client/arc-events';
+
+/** @typedef {import('@advanced-rest-client/arc-types').Authorization.OAuth2Authorization} OAuth2Authorization */
+/** @typedef {import('@advanced-rest-client/arc-events').GoogleDriveListFolderEvent} GoogleDriveListFolderEvent */
+/** @typedef {import('@advanced-rest-client/arc-events').GoogleDriveReadEvent} GoogleDriveReadEvent */
+/** @typedef {import('@advanced-rest-client/arc-events').GoogleDriveSaveEvent} GoogleDriveSaveEvent */
+/** @typedef {import('../types').SaveDriveFileOptions} SaveDriveFileOptions */
+
+const saveFileHandler = Symbol('saveFileHandler');
+const listAppFoldersHandler = Symbol('listAppFoldersHandler');
+const getFileHandler = Symbol('getFileHandler');
+
+/**
+ * A class to be used in the renderer process that listens for drive
+ * events and communicates with drive instance in the main process.
+ */
+export class GoogleDriveProxy {
+ /**
+ * @returns {OAuth2Authorization}
+ */
+ get oauthConfig() {
+ return {
+ clientId: '1076318174169-u4a5d3j2v0tbie1jnjgsluqk1ti7ged3.apps.googleusercontent.com',
+ authorizationUri: 'https://accounts.google.com/o/oauth2/v2/auth',
+ redirectUri: 'https://auth.advancedrestclient.com/oauth2',
+ scopes: [
+ 'https://www.googleapis.com/auth/drive.file',
+ 'https://www.googleapis.com/auth/drive.install',
+ ],
+ }
+ }
+
+ constructor() {
+ this[saveFileHandler] = this[saveFileHandler].bind(this);
+ this[listAppFoldersHandler] = this[listAppFoldersHandler].bind(this);
+ this[getFileHandler] = this[getFileHandler].bind(this);
+ }
+
+ /**
+ * Listens for both ipc and web events and makes the magic happen.
+ */
+ listen() {
+ window.addEventListener(GoogleDriveEventTypes.save, this[saveFileHandler]);
+ window.addEventListener(GoogleDriveEventTypes.listAppFolders, this[listAppFoldersHandler]);
+ window.addEventListener(GoogleDriveEventTypes.read, this[getFileHandler]);
+ }
+
+ /**
+ * Stops listening to the web and ipc events.
+ */
+ unlisten() {
+ window.removeEventListener(GoogleDriveEventTypes.save, this[saveFileHandler]);
+ window.removeEventListener(GoogleDriveEventTypes.listAppFolders, this[listAppFoldersHandler]);
+ window.removeEventListener(GoogleDriveEventTypes.read, this[getFileHandler]);
+ }
+
+ /**
+ * @param {GoogleDriveSaveEvent} e
+ */
+ [saveFileHandler](e) {
+ e.preventDefault();
+ const { data, providerOptions } = e;
+ const { file, contentType, parent } = providerOptions;
+ const meta = {
+ name: file,
+ mimeType: contentType,
+ };
+ const options = /** @type SaveDriveFileOptions */ ({
+ meta,
+ parent,
+ auth: this.oauthConfig,
+ });
+ e.detail.result = ipcRenderer.invoke('google-drive-process', 'create-file', options, data);
+ }
+
+ /**
+ * Handler for `google-drive-list-app-folders` event.
+ * Requests to get Drive folders list created by this application.
+ * @param {GoogleDriveListFolderEvent} e
+ */
+ [listAppFoldersHandler](e) {
+ e.detail.result = this.listFolders();
+ }
+
+ listFolders() {
+ const auth = this.oauthConfig;
+ auth.interactive = false;
+ return ipcRenderer.invoke('google-drive-process', 'list-folders', auth);
+ }
+
+ /**
+ * Downloads file from Google Drive by its ID.
+ * @param {String} fileId File ID
+ * @return {Promise} Promise resolved to file content.
+ */
+ getFile(fileId) {
+ const auth = this.oauthConfig;
+ auth.interactive = true;
+ return ipcRenderer.invoke('google-drive-process', 'get-file', fileId, auth);
+ }
+
+ /**
+ * @param {GoogleDriveReadEvent} e
+ */
+ [getFileHandler](e) {
+ e.preventDefault();
+ if (!e.id) {
+ e.detail.result = Promise.reject(new Error('The "id" detail property is missing.'));
+ } else {
+ e.detail.result = this.getFile(e.id);
+ }
+ }
+
+ /**
+ * Notifies the parent window about a file pick action.
+ * If the current window does not have a parent then it does nothing.
+ *
+ * @param {string} fileId The picked file id
+ */
+ notifyParentFilePicked(fileId) {
+ // this does not need a confirmation so simple send will do.
+ ipcRenderer.send('google-drive-proxy-file-pick', fileId);
+ }
+}
diff --git a/src/preload/ImportFilePreProcessor.js b/src/preload/ImportFilePreProcessor.js
new file mode 100644
index 00000000..63604f3c
--- /dev/null
+++ b/src/preload/ImportFilePreProcessor.js
@@ -0,0 +1,85 @@
+import path from 'path';
+import fs from 'fs-extra';
+
+export const isApiFile = Symbol('isApiFile');
+
+/**
+ * Simple class to read file picked by the user and that helps to decide whether the file
+ * is an API file to process with the AMF factory or is it ARC import file.
+ *
+ * @todo This has no sense to handle all imports through a single import file.
+ * THese should be specialized paths to import API data and to import ARC data.
+ */
+export class ImportFilePreProcessor {
+ /**
+ * @param {string} filePath The path to the imported file
+ */
+ constructor(filePath) {
+ this.filePath = filePath;
+
+ /**
+ * @type {Buffer}
+ */
+ this.buffer = undefined;
+ }
+
+ async prepare() {
+ const { filePath } = this;
+ if (!filePath) {
+ throw new Error('The file path is not set');
+ }
+ const exists = await fs.pathExists(filePath);
+ if (!exists) {
+ throw new Error('The file path does not exists');
+ }
+ try {
+ await fs.access(filePath, fs.constants.R_OK);
+ } catch (e) {
+ throw new Error('Unable to read import file. The current user has no permissions to the file.');
+ }
+ this.buffer = await fs.readFile(filePath);
+ }
+
+ /**
+ * Tests whether the buffer should be sent to the API processor instead of import processor.
+ *
+ * Note, the contents may be still an API as OAS (swagger) support JSON format. This is not here tested
+ * because the file content can be encrypted with password.
+ *
+ * @returns {Promise}
+ */
+ async isApiFile() {
+ const { filePath } = this;
+ if (!filePath) {
+ throw new Error('The file path is not set');
+ }
+ const ext = path.extname(filePath);
+ if (this[isApiFile](ext)) {
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Call `isApiFile()` first to test whether the file is the zip file.
+ *
+ * @return {string} The contents as string.
+ */
+ readContents() {
+ const { buffer } = this;
+ if (!buffer) {
+ throw new Error('Call the prepare function first.');
+ }
+ const content = buffer.toString().trim();
+ return content;
+ }
+
+ /**
+ * @param {string} ext
+ * @returns {boolean}
+ */
+ [isApiFile](ext) {
+ const apiTypes = ['.zip', '.yaml', '.raml'];
+ return apiTypes.includes(ext);
+ }
+}
diff --git a/src/preload/PreferencesProxy.js b/src/preload/PreferencesProxy.js
new file mode 100644
index 00000000..86e87f5a
--- /dev/null
+++ b/src/preload/PreferencesProxy.js
@@ -0,0 +1,88 @@
+import { ipcRenderer } from 'electron';
+import { ConfigEvents, ConfigEventTypes } from '@advanced-rest-client/arc-events';
+
+/** @typedef {import('@advanced-rest-client/arc-types').Config.ARCConfig} ARCConfig */
+/** @typedef {import('@advanced-rest-client/arc-events').ConfigUpdateEvent} ConfigUpdateEvent */
+
+export const domReadHandler = Symbol('domReadHandler');
+export const domChangeHandler = Symbol('domChangeHandler');
+export const ioChangeHandler = Symbol('ioChangeHandler');
+
+/**
+ * A class that acts as a proxy to read application settings.
+ */
+export class PreferencesProxy {
+ constructor() {
+ this[domReadHandler] = this[domReadHandler].bind(this);
+ this[domChangeHandler] = this[domChangeHandler].bind(this);
+ this[ioChangeHandler] = this[ioChangeHandler].bind(this);
+ }
+
+ /**
+ * Observers window and IPC events which makes this class work.
+ */
+ observe() {
+ window.addEventListener(ConfigEventTypes.readAll, this[domReadHandler]);
+ window.addEventListener(ConfigEventTypes.update, this[domChangeHandler]);
+ ipcRenderer.on('preferences-value-updated', this[ioChangeHandler]);
+ }
+
+ /**
+ * Stop observing window and IPC events
+ */
+ unobserve() {
+ window.removeEventListener(ConfigEventTypes.readAll, this[domReadHandler]);
+ window.removeEventListener(ConfigEventTypes.update, this[domChangeHandler]);
+ ipcRenderer.removeListener('preferences-value-updated', this[ioChangeHandler]);
+ }
+
+ /**
+ * Reads current application settings.
+ * @returns {Promise}
+ */
+ read() {
+ return ipcRenderer.invoke('preferences-read');
+ }
+
+ /**
+ * Updates a single preference
+ * @param {string} name Preference name
+ * @param {any} value Preference value
+ * @returns {Promise}
+ */
+ update(name, value) {
+ return ipcRenderer.invoke('preferences-update', name, value);
+ }
+
+ /**
+ * A handler for the preferences read event emitted on the DOM.
+ * @param {CustomEvent} e
+ */
+ [domReadHandler](e) {
+ e.detail.result = this.read();
+ }
+
+ /**
+ * A handler for the preferences read event emitted on the DOM.
+ * @param {ConfigUpdateEvent} e
+ */
+ [domChangeHandler](e) {
+ const { key, value } = e.detail;
+ if (!key) {
+ e.detail.result = Promise.reject(new Error(`The name cannot be empty`));
+ return;
+ }
+ e.detail.result = this.update(key, value);
+ }
+
+ /**
+ * Handler for the IO event for settings update.
+ *
+ * @param {Electron.IpcRendererEvent} e
+ * @param {String} name Name of changed property
+ * @param {any} value
+ */
+ [ioChangeHandler](e, name, value) {
+ ConfigEvents.State.update(document.body, name, value);
+ }
+}
diff --git a/src/preload/README.md b/src/preload/README.md
new file mode 100644
index 00000000..f5047e8b
--- /dev/null
+++ b/src/preload/README.md
@@ -0,0 +1,9 @@
+# Pre-load scripts for all windows
+
+Here is the location of all classes that are loaded in the pre-load scripts of a browser window.
+
+The purpose of those is to provide an access to the application main thread through IPC.
+
+ARC browser processes have disabled node integration (and they won't have it enabled). The way to deal with this is to create a class that deals with the logic in the renderer process or communicate with the IO process.
+
+Before accessing the user's filesystem make sure that unusual paths are not read / altered by the script.
diff --git a/src/preload/ThemeManager.js b/src/preload/ThemeManager.js
new file mode 100644
index 00000000..d2967ab0
--- /dev/null
+++ b/src/preload/ThemeManager.js
@@ -0,0 +1,167 @@
+import { ipcRenderer as ipc } from 'electron';
+import logger from 'electron-log';
+
+/** @typedef {import('@advanced-rest-client/arc-types').Themes.ArcThemeStore} ArcThemeStore */
+/** @typedef {import('@advanced-rest-client/arc-types').Themes.InstalledTheme} InstalledTheme */
+
+const themeActivatedHandler = Symbol('themeActivatedHandler');
+
+/**
+ * Theme manager class for renderer process.
+ *
+ * It listens for web and ipc events to manage themes.
+ */
+export class ThemeManager {
+ static get defaultTheme() {
+ return '@advanced-rest-client/arc-electron-default-theme';
+ }
+
+ static get anypointTheme() {
+ return '@advanced-rest-client/arc-electron-anypoint-theme';
+ }
+
+ static get darkTheme() {
+ return '@advanced-rest-client/arc-electron-dark-theme';
+ }
+
+ constructor() {
+ this[themeActivatedHandler] = this[themeActivatedHandler].bind(this);
+ }
+
+ /**
+ * Listens for the ipc events to support theme changes
+ */
+ listen() {
+ ipc.on('theme-manager-theme-activated', this[themeActivatedHandler]);
+ }
+
+ /**
+ * Removes event listeners
+ */
+ unlisten() {
+ ipc.off('theme-manager-theme-activated', this[themeActivatedHandler]);
+ }
+
+ /**
+ * Handler for the theme activated event. Updates the theme in the current window.
+ * @param {*} e
+ * @param {string} id
+ */
+ async [themeActivatedHandler](e, id) {
+ await this.loadTheme(id);
+ document.body.dispatchEvent(new CustomEvent('themeactivated', {
+ detail: id,
+ bubbles: true,
+ }));
+ }
+
+ /**
+ * Lists installed themes in the application.
+ * @return {Promise} A promise resolved to the theme info array
+ */
+ readState() {
+ logger.silly('listing themes');
+ return ipc.invoke('theme-manager-read-themes');
+ }
+
+ /**
+ * Reads information about current theme.
+ * @return {Promise} A promise resolved to the theme info
+ */
+ readActiveThemeInfo() {
+ logger.silly('reading active theme');
+ return ipc.invoke('theme-manager-active-theme-info');
+ }
+
+ /**
+ * Activates the theme. It stores theme id in user preferences and loads the
+ * theme.
+ * @param {string} name Theme name to activate
+ * @return {Promise} Promise resolved when the theme is activated
+ */
+ activate(name) {
+ logger.info(`activating theme: ${name}`);
+ return ipc.invoke('theme-manager-activate-theme', name);
+ }
+
+ /**
+ * @param {string} name The theme to install
+ * @returns {Promise}
+ */
+ installTheme(name) {
+ logger.info(`installing theme: ${name}`);
+ if (!name) {
+ return Promise.reject(new Error('Name is required'));
+ }
+ return ipc.invoke('theme-manager-install-theme', name);
+ }
+
+ /**
+ * @param {string} name The theme to uninstall
+ * @returns {Promise}
+ */
+ uninstallTheme(name) {
+ logger.info(`uninstalling a theme: ${name}`);
+ if (!name) {
+ return Promise.reject(new Error('Name is required'));
+ }
+ return ipc.invoke('theme-manager-uninstall-theme', name);
+ }
+
+ /**
+ * Loads theme file and activates it.
+ * @param {string=} themeId ID of installed theme of location of theme file.
+ *
+ * @param {boolean=} noFallback By default the manager will try to revert to default
+ * theme when passed theme cannot be loaded. When this option is set then
+ * it will throw error instead of loading default theme.
+ * @return {Promise}
+ */
+ async loadTheme(themeId, noFallback) {
+ logger.silly(`loading theme: ${themeId}`);
+ let id = themeId;
+ if (!id || id === 'dd1b715f-af00-4ee8-8b0c-2a262b3cf0c8') {
+ id = ThemeManager.defaultTheme;
+ } else if (id === '859e0c71-ce8b-44df-843b-bca602c13d06') {
+ id = ThemeManager.anypointTheme;
+ }
+ try {
+ await this._loadTheme(id);
+ } catch (cause) {
+ if (!noFallback && id !== ThemeManager.defaultTheme) {
+ await this._loadTheme(ThemeManager.defaultTheme);
+ return;
+ }
+ throw cause;
+ }
+ }
+
+ /**
+ * @param {string} themeId
+ * @returns {Promise}
+ */
+ async _loadTheme(themeId) {
+ const nodes = document.head.querySelectorAll('link[rel="stylesheet"]');
+ for (let i = nodes.length - 1; i >= 0; i--) {
+ // @ts-ignore
+ const { href } = nodes[i];
+ if (href && href.indexOf('themes:') === 0) {
+ logger.silly(`removing previous theme: ${href}`);
+ nodes[i].parentNode.removeChild(nodes[i]);
+ }
+ }
+ logger.silly(`adding theme to the DOM: ${themeId}`);
+ const link = document.createElement('link');
+ link.setAttribute('rel', 'stylesheet');
+ link.setAttribute('type', 'text/css');
+ link.setAttribute('href', `themes://${themeId}`);
+ document.head.appendChild(link);
+ }
+
+ /**
+ * @param {boolean} status Whether to ignore the system preferences for dark / light theme.
+ */
+ async setSystemPreferred(status) {
+ return ipc.invoke('theme-manager-update-property', 'systemPreferred', status);
+ }
+}
diff --git a/src/preload/UniversalAnalytics.js b/src/preload/UniversalAnalytics.js
new file mode 100644
index 00000000..8ec6d0e7
--- /dev/null
+++ b/src/preload/UniversalAnalytics.js
@@ -0,0 +1,935 @@
+/* eslint-disable no-param-reassign */
+/** @typedef {import('./Analytics').AnalyticsInit} AnalyticsInit */
+/** @typedef {import('./Analytics').CustomMetric} CustomMetric */
+/** @typedef {import('./Analytics').CustomDimension} CustomDimension */
+/** @typedef {import('./Analytics').BaseHitOptions} BaseHitOptions */
+
+export const initializingValue = Symbol('initializingValue');
+
+/**
+ * **Required for all hit types.**
+ *
+ * The Protocol version. The current value is '1'. This will only change when there
+ * are changes made that are not backwards compatible.
+ *
+ * - Parameter: **v**
+ * - Example value: 1
+ * - Example usage: v=1
+ *
+ * @type {Number}
+ */
+const protocolVersion = 1;
+/**
+ * A map of parameter names to its descriptions.
+ * @type {Object}
+ */
+export const paramsMap = {
+ v: 'Protocol Version',
+ tid: 'Tracking ID / Web Property ID',
+ aip: 'Anonymize IP',
+ ds: 'Data Source',
+ qt: 'Queue Time',
+ z: 'Cache Buster',
+ cid: 'Client ID',
+ uid: 'User ID',
+ sc: 'Session Control',
+ uip: 'IP Override',
+ ua: 'User Agent Override',
+ geoip: 'Geographical Override',
+ dr: 'Document Referrer',
+ cn: 'Campaign Name',
+ cs: 'Campaign Source',
+ cm: 'Campaign Medium',
+ ck: 'Campaign Keyword',
+ cc: 'Campaign Content',
+ ci: 'Campaign ID',
+ gclid: 'Google AdWords ID',
+ dclid: 'Google Display Ads ID',
+ sr: 'Screen Resolution',
+ vp: 'Viewport size',
+ de: 'Document Encoding',
+ sd: 'Screen Colors',
+ ul: 'User Language',
+ je: 'Java Enabled',
+ fl: 'Flash Version',
+ t: 'Hit type',
+ ni: 'Non-Interaction Hit',
+ dl: 'Document location URL',
+ dh: 'Document Host Name',
+ dp: 'Document Path',
+ dt: 'Document Title',
+ cd: 'Screen Name',
+ linkid: 'Link ID',
+ an: 'Application Name',
+ aid: 'Application ID',
+ av: 'Application Version',
+ aiid: 'Application Installer ID',
+ ec: 'Event Category',
+ ea: 'Event Action',
+ el: 'Event Label',
+ ev: 'Event Value',
+ sn: 'Social Network',
+ sa: 'Social Action',
+ st: 'Social Action Target',
+ utc: 'User timing category',
+ utv: 'User timing variable name',
+ utt: 'User timing time',
+ utl: 'User timing label',
+ plt: 'Page Load Time',
+ dns: 'DNS Time',
+ pdt: 'Page Download Time',
+ rrt: 'Redirect Response Time',
+ tcp: 'TCP Connect Time',
+ srt: 'Server Response Time',
+ dit: 'DOM Interactive Time',
+ clt: 'Content Load Time',
+ exd: 'Exception Description',
+ exf: 'Is Exception Fatal?',
+ xid: 'Experiment ID',
+ xvar: 'Experiment Variant'
+};
+
+for (let i = 1; i < 201; i++) {
+ paramsMap[`cd${i}`] = `Custom dimension #${i}`;
+ paramsMap[`cm${i}`] = `Custom metric #${i}`;
+}
+
+/**
+ * List of hist to be send when came back from offline state.
+ * Note, this is in memory information only.
+ * The component do not stores this information.
+ *
+ * @type {string[]}
+ */
+export const offlineQueue = [];
+
+export class UniversalAnalytics {
+ /**
+ * The Client ID for the measurement protocol.
+ *
+ * **It is required for all types of calls.**
+ *
+ * The value of this field should be a random UUID (version 4) as described
+ * in http://www.ietf.org/rfc/rfc4122.txt
+ *
+ * - Parameter: **cid**
+ * - Example value: 35009a79-1a05-49d7-b876-2b884d0f825b
+ * - Example usage: cid=35009a79-1a05-49d7-b876-2b884d0f825b
+ *
+ * @returns {string}
+ */
+ get clientId() {
+ return this._clientId;
+ }
+
+ set clientId(value) {
+ this._clientId = value;
+ this._configureBaseParams();
+ }
+
+ /**
+ * This is intended to be a known identifier for a user provided by the site owner/tracking
+ * library user. It must not itself be PII (personally identifiable information).
+ * The value should never be persisted in GA cookies or other Analytics provided storage.
+ *
+ * - Parameter: **uid**
+ * - Example value: as8eknlll
+ * - Example usage: uid=as8eknlll
+ *
+ * @returns {string}
+ */
+ get userId() {
+ return this._userId;
+ }
+
+ set userId(value) {
+ this._userId = value;
+ this._configureBaseParams();
+ }
+
+ /**
+ * **Required for all hit types.**
+ *
+ * The tracking ID / web property ID. The format is UA-XXXX-Y.
+ * All collected data is associated by this ID.
+ *
+ * - Parameter: **tid**
+ * - Example value: UA-XXXX-Y
+ * - Example usage: tid=UA-XXXX-Y
+ *
+ * @returns {string}
+ */
+ get trackingId() {
+ return this._trackingId;
+ }
+
+ set trackingId(value) {
+ this._trackingId = value;
+ this._configureBaseParams();
+ }
+
+ /**
+ * When present, the IP address of the sender will be anonymized.
+ * For example, the IP will be anonymized if any of the following parameters are present in
+ * the payload: &aip=, &aip=0, or &aip=1
+ *
+ * - Parameter: **aip**
+ * - Example value: 1
+ * - Example usage: aip=1
+ * @returns {boolean}
+ */
+ get anonymizeIp() {
+ return this._anonymizeIp;
+ }
+
+ set anonymizeIp(value) {
+ this._anonymizeIp = value;
+ this._configureBaseParams();
+ }
+
+ /**
+ * Indicates the data source of the hit. Hits sent from analytics.js will have data source
+ * set to 'web'; hits sent from one of the mobile SDKs will have data source set to 'app'.
+ *
+ * - Parameter: **ds**
+ * - Example value: call center
+ * - Example usage: ds=call%20center
+ *
+ * @returns {string}
+ */
+ get dataSource() {
+ return this._dataSource;
+ }
+
+ set dataSource(value) {
+ this._dataSource = value;
+ this._configureBaseParams();
+ }
+
+ /**
+ * Used to send a random number in GET requests to ensure browsers and proxies
+ * don't cache hits.
+ *
+ * - Parameter: **z**
+ * - Example value: 289372387623
+ * - Example usage: z=289372387623
+ *
+ * @returns {boolean}
+ */
+ get useCacheBooster() {
+ return this._useCacheBooster;
+ }
+
+ set useCacheBooster(value) {
+ this._useCacheBooster = value;
+ }
+
+ /**
+ * Specifies which referral source brought traffic to a website. This value is also used to
+ * compute the traffic source. The format of this value is a URL.
+ *
+ * - Parameter: **dr**
+ * - Example value: http://example.com
+ * - Example usage: dr=http%3A%2F%2Fexample.com
+ *
+ * @returns {string}
+ */
+ get referrer() {
+ return this._referrer;
+ }
+
+ set referrer(value) {
+ this._referrer = value;
+ this._configureBaseParams();
+ }
+
+ /**
+ * Specifies the campaign name.
+ *
+ * - Parameter: **cn**
+ * - Example value: (direct)
+ * - Example usage: cn=%28direct%29
+ *
+ * @returns {string}
+ */
+ get campaignName() {
+ return this._campaignName;
+ }
+
+ set campaignName(value) {
+ this._campaignName = value;
+ this._configureBaseParams();
+ }
+
+ /**
+ * Specifies the campaign source.
+ *
+ * - Parameter: **cs**
+ * - Example value: (direct)
+ * - Example usage: cs=%28direct%29
+ *
+ * @returns {string}
+ */
+ get campaignSource() {
+ return this._campaignSource;
+ }
+
+ set campaignSource(value) {
+ this._campaignSource = value;
+ this._configureBaseParams();
+ }
+
+ /**
+ * Specifies the campaign medium.
+ *
+ * - Parameter: **cm**
+ * - Example value: organic
+ * - Example usage: cm=organic
+ *
+ * @returns {string}
+ */
+ get campaignMedium() {
+ return this._campaignMedium;
+ }
+
+ set campaignMedium(value) {
+ this._campaignMedium = value;
+ this._configureBaseParams();
+ }
+
+ /**
+ * Specifies the application version.
+ *
+ * - Parameter: **av**
+ * - Example value: 1.2
+ * - Example usage: av=1.2
+ *
+ * @returns {string}
+ */
+ get appVersion() {
+ return this._appVersion;
+ }
+
+ set appVersion(value) {
+ this._appVersion = value;
+ this._configureBaseParams();
+ }
+
+ /**
+ * Specifies the application name. This field is required for any hit that has app related
+ * data (i.e., app version, app ID, or app installer ID). For hits sent to web properties,
+ * this field is optional.
+ *
+ * - Parameter: **an**
+ * - Example My App
+ * - Example usage: an=My%20App
+ *
+ * @returns {string}
+ */
+ get appName() {
+ return this._appName;
+ }
+
+ set appName(value) {
+ this._appName = value;
+ this._configureBaseParams();
+ }
+
+ /**
+ * Application identifier.
+ *
+ * - Parameter: **aid**
+ * - Example value: com.company.app
+ * - Example usage: aid=com.company.app
+ *
+ * @returns {string}
+ */
+ get appId() {
+ return this._appId;
+ }
+
+ set appId(value) {
+ this._appId = value;
+ this._configureBaseParams();
+ }
+
+ /**
+ * Application installer identifier.
+ *
+ * - Parameter: **aiid**
+ * - Example value: com.platform.vending
+ * - Example usage: aiid=com.platform.vending
+ *
+ * @returns {string}
+ */
+ get appInstallerId() {
+ return this._appInstallerId;
+ }
+
+ set appInstallerId(value) {
+ this._appInstallerId = value;
+ this._configureBaseParams();
+ }
+
+ /**
+ * If set to true it will prints debug messages into the console.
+ *
+ * @returns {boolean}
+ */
+ get debug() {
+ return this._debug;
+ }
+
+ set debug(value) {
+ this._debug = value;
+ }
+
+ /**
+ * If set it will send the data to GA's debug endpoint and the request won't be actually saved but only validated
+ *
+ * @returns {boolean}
+ */
+ get debugEndpoint() {
+ return this._debugEndpoint;
+ }
+
+ set debugEndpoint(value) {
+ this._debugEndpoint = value;
+ }
+
+ /**
+ * When set it queues requests to GA in memory and attempts to send the requests
+ * again when this flag is removed.
+ *
+ * @returns {boolean}
+ */
+ get offline() {
+ return this._offline;
+ }
+
+ set offline(value) {
+ this._offline = value;
+ this._offlineChanged(value);
+ }
+
+ /**
+ * Generated POST parameters based on a params
+ * @returns {Record}
+ */
+ get _baseParams() {
+ return this.__baseParams;
+ }
+
+ set _baseParams(value) {
+ this.__baseParams = value;
+ }
+
+ /**
+ * Each custom metric has an associated index. There is a maximum of 20 custom
+ * metrics (200 for Analytics 360 accounts). The metric index must be a positive
+ * integer between 1 and 200, inclusive.
+ *
+ * - Parameter: **cm**
+ * - Example value: 47
+ * - Example usage: cm1=47
+ *
+ * @return {CustomMetric[]}
+ */
+ get customMetrics() {
+ return this._customMetrics;
+ }
+
+ set customMetrics(value) {
+ this._customMetrics = value;
+ }
+
+ /**
+ * Each custom dimension has an associated index. There is a maximum of 20 custom
+ * dimensions (200 for Analytics 360 accounts). The dimension index must be a positive
+ * integer between 1 and 200, inclusive.
+ *
+ * - Parameter: **cd**
+ * - Example value: Sports
+ * - Example usage: cd1=Sports
+ *
+ * @return {CustomDimension[]}
+ */
+ get customDimensions() {
+ return this._customDimensions;
+ }
+
+ set customDimensions(value) {
+ this._customDimensions = value;
+ }
+
+ /**
+ * @param {AnalyticsInit} init
+ */
+ constructor(init) {
+ this[initializingValue] = true;
+ this.clientId = init.clientId;
+ this.trackingId = init.trackingId;
+ this._baseParams = {};
+ this._customMetrics = [];
+ this._customDimensions = [];
+
+ if (typeof init.userId === 'string') {
+ this.userId = init.userId;
+ }
+ if (typeof init.dataSource === 'string') {
+ this.dataSource = init.dataSource;
+ }
+ if (typeof init.referrer === 'string') {
+ this.referrer = init.referrer;
+ }
+ if (typeof init.campaignName === 'string') {
+ this.campaignName = init.campaignName;
+ }
+ if (typeof init.campaignSource === 'string') {
+ this.campaignSource = init.campaignSource;
+ }
+ if (typeof init.campaignMedium === 'string') {
+ this.campaignMedium = init.campaignMedium;
+ }
+ if (typeof init.appVersion === 'string') {
+ this.appVersion = init.appVersion;
+ }
+ if (typeof init.appName === 'string') {
+ this.appName = init.appName;
+ }
+ if (typeof init.appId === 'string') {
+ this.appId = init.appId;
+ }
+ if (typeof init.appInstallerId === 'string') {
+ this.appInstallerId = init.appInstallerId;
+ }
+ if (typeof init.debugEndpoint === 'boolean') {
+ this.debugEndpoint = init.debugEndpoint;
+ }
+ if (typeof init.anonymizeIp === 'boolean') {
+ this.anonymizeIp = init.anonymizeIp;
+ }
+ if (typeof init.useCacheBooster === 'boolean') {
+ this.useCacheBooster = init.useCacheBooster;
+ }
+ if (typeof init.debug === 'boolean') {
+ this.debug = init.debug;
+ }
+ if (Array.isArray(init.customDimensions)) {
+ this.customDimensions = init.customDimensions;
+ }
+ if (Array.isArray(init.customMetrics)) {
+ this.customMetrics = init.customMetrics;
+ }
+ this[initializingValue] = false;
+ this._configureBaseParams();
+ }
+
+ /**
+ * Sends the screen view hit to the GA.
+ *
+ * @param {string} name Screen name.
+ * @param {BaseHitOptions=} opts Custom data definition
+ * @returns {Promise}
+ */
+ sendScreen(name, opts) {
+ const data = {
+ cd: name,
+ };
+ this.appendCustomData(data, opts);
+ return this.sendHit('screenview', data);
+ }
+
+ /**
+ * Sends the screen view hit to the GA.
+ *
+ * @param {string} name Screen name.
+ * @param {string=} hostName Document hostname.
+ * @param {string=} path Page path
+ * @param {BaseHitOptions=} opts Custom data definition
+ * @returns {Promise}
+ */
+ sendPage(name, hostName=window.location.hostname, path=window.location.pathname, opts) {
+ const data = {
+ dh: hostName,
+ dp: path,
+ dt: name,
+ };
+ this.appendCustomData(data, opts);
+ return this.sendHit('pageview', data);
+ }
+
+ /**
+ * Sends event tracking.
+ *
+ * @param {string} category Specifies the event category. Must not be empty.
+ * @param {string} action Specifies the event action. Must not be empty.
+ * @param {string=} label Specifies the event label. Optional value.
+ * @param {number=} value Specifies the event value. Values must be non-negative. Optional.
+ * @param {BaseHitOptions=} opts Custom data definition.
+ * @returns {Promise}
+ */
+ sendEvent(category, action, label, value, opts) {
+ const missing = [];
+ if (!category) {
+ missing.push('category');
+ }
+ if (!action) {
+ missing.push('action');
+ }
+ if (missing.length) {
+ throw new Error(`Missing required parameters: ${missing.join(', ')}`);
+ }
+ const data = {
+ ec: category,
+ ea: action
+ };
+ if (label) {
+ data.el = label;
+ }
+ if (value) {
+ data.ev = value;
+ }
+ this.appendCustomData(data, opts);
+ return this.sendHit('event', data);
+ }
+
+ /**
+ * Sends the exception hit to GA.
+ *
+ * @param {string} description A description of the exception.
+ * @param {boolean} fatal Specifies whether the exception was fatal.
+ * @param {BaseHitOptions=} opts Custom data definition.
+ * @returns {Promise}
+ */
+ sendException(description, fatal, opts) {
+ const value = fatal ? '1' : '0';
+ const data = {
+ exd: description,
+ exf: value,
+ };
+ this.appendCustomData(data, opts);
+ return this.sendHit('exception', data);
+ }
+
+ /**
+ * Track social interaction
+ *
+ * @param {string} network Specifies the social network, for example Facebook or Google Plus.
+ * @param {string} action Specifies the social interaction action. For example on Google Plus
+ * when a user clicks the +1 button, the social action is 'plus'.
+ * @param {string} target Specifies the target of a social interaction. This value is
+ * typically a URL but can be any text.
+ * @param {BaseHitOptions=} opts Custom data definition.
+ * @returns {Promise}
+ */
+ sendSocial(network, action, target, opts) {
+ const missing = [];
+ if (!network) {
+ missing.push('network');
+ }
+ if (!action) {
+ missing.push('action');
+ }
+ if (!target) {
+ missing.push('target');
+ }
+ if (missing.length) {
+ throw new Error(`Missing required parameters: ${missing.join(', ')}`);
+ }
+ const data = {
+ sn: network,
+ sa: action,
+ st: target
+ };
+ this.appendCustomData(data, opts);
+ return this.sendHit('social', data);
+ }
+
+ /**
+ * Track timings in the app.
+ *
+ * @param {string} category Specifies the user timing category. **required**
+ * @param {string} variable Specifies the user timing variable. **required**
+ * @param {number} time Specifies the user timing value. The value is in milliseconds.
+ * @param {string} label Specifies the user timing label.
+ * @param {BaseHitOptions=} cmOpts Custom data definition.
+ * @returns {Promise}
+ */
+ sendTimings(category, variable, time, label, cmOpts) {
+ const missing = [];
+ if (!category) {
+ missing.push('category');
+ }
+ if (!variable) {
+ missing.push('variable');
+ }
+ if (!time) {
+ missing.push('time');
+ }
+ if (missing.length) {
+ throw new Error(`Missing required parameters: ${missing.join(', ')}`);
+ }
+ const opts = {
+ utc: category,
+ utv: variable,
+ utt: String(time)
+ };
+ if (label) {
+ opts.utl = label;
+ }
+ this.appendCustomData(opts, cmOpts);
+ return this.sendHit('timing', opts);
+ }
+
+ /**
+ * Append custom metrics / dimensions definitions to the
+ * parameters list.
+ *
+ * @param {Record} data The data to send
+ * @param {BaseHitOptions=} opts
+ */
+ appendCustomData(data, opts) {
+ if (!opts) {
+ return;
+ }
+ if (opts.customDimensions && opts.customDimensions.length) {
+ opts.customDimensions.forEach((item) => {
+ data[`cd${item.index}`] = item.value;
+ });
+ }
+ if (opts.customMetrics && opts.customMetrics.length) {
+ opts.customMetrics.forEach((item) => {
+ data[`cm${item.index}`] = String(item.value);
+ });
+ }
+ }
+
+ /**
+ * Send a hit to the GA server.
+ * The `type` parameter is required for all types of hits.
+ *
+ * @param {string} type The type of hit. Must be one of 'pageview', 'screenview', 'event',
+ * 'transaction', 'item', 'social', 'exception', 'timing'.
+ * @param {Record} params Map of params to send wit this hit.
+ * @returns {Promise}
+ */
+ sendHit(type, params) {
+ if (!['pageview', 'screenview', 'event', 'transaction', 'item', 'social', 'exception', 'timing'].includes(type)) {
+ throw new Error('Unknown hit type.');
+ }
+ params.t = type;
+ this._processParams(params);
+ const post = { ...this._baseParams, ...params};
+ const body = this._createBody(post);
+ if (this.debug) {
+ /* eslint-disable-next-line */
+ console.group('Running command for ', type);
+ this._printParamsTable(post);
+ /* eslint-disable-next-line */
+ console.groupEnd();
+ }
+ return this._transport(body);
+ }
+
+ /**
+ * Encodes parameters.
+ * @param {Record} params
+ */
+ _processParams(params) {
+ Object.keys(params).forEach((param) => {
+ params[param] = this.encodeQueryString(params[param]);
+ });
+ }
+
+ /**
+ * Creates a post body from the params.
+ * @param {Record} params List of parameters to send
+ * @returns {string} Request body
+ */
+ _createBody(params) {
+ let result = '';
+ Object.keys(params).forEach((param) => {
+ if (result) {
+ result += '&';
+ }
+ result += `${param}=${params[param]}`;
+ });
+ return result;
+ }
+
+ /**
+ * @param {string} str The value to URL encode
+ * @returns {string} The encoded value;
+ */
+ encodeQueryString(str) {
+ if (!str) {
+ return str;
+ }
+ const regexp = /%20/g;
+ return encodeURIComponent(str).replace(regexp, '+');
+ }
+
+ _configureBaseParams() {
+ if (this[initializingValue]) {
+ return;
+ }
+ const { screen } = window;
+ const data = {
+ v: String(protocolVersion),
+ tid: this.trackingId,
+ cid: this.clientId,
+ ul: navigator.language,
+ sr: `${screen.width}x${screen.height}`,
+ sd: String(screen.pixelDepth)
+ };
+ const iw = window.innerWidth;
+ const ih = window.innerHeight;
+ if (iw && ih) {
+ data.vp = `${iw}x${ih}`;
+ }
+
+ if (this.userId) {
+ data.uid = this.userId;
+ }
+ if (this.anonymizeIp) {
+ data.aip = '1';
+ }
+ if (this.dataSource) {
+ data.ds = this.encodeQueryString(this.dataSource);
+ }
+ if (this.referrer) {
+ data.dr = this.encodeQueryString(this.referrer);
+ }
+ if (this.campaignName) {
+ data.cn = this.encodeQueryString(this.campaignName);
+ }
+ if (this.campaignSource) {
+ data.cs = this.encodeQueryString(this.campaignSource);
+ }
+ if (this.campaignMedium) {
+ data.cm = this.encodeQueryString(this.campaignMedium);
+ }
+ if (this.appVersion) {
+ data.av = this.encodeQueryString(this.appVersion);
+ }
+ if (this.appName) {
+ data.an = this.encodeQueryString(this.appName);
+ }
+ if (this.appId) {
+ data.aid = this.encodeQueryString(this.appId);
+ }
+ if (this.appInstallerId) {
+ data.aiid = this.encodeQueryString(this.appInstallerId);
+ }
+ if (this.customMetrics.length) {
+ this.customMetrics.forEach((cm) => {
+ data[`cm${cm.index}`] = this.encodeQueryString(String(cm.value));
+ });
+ }
+ if (this._customDimensions.length) {
+ this._customDimensions.forEach((cd) => {
+ data[`cd${cd.index}`] = this.encodeQueryString(cd.value);
+ });
+ }
+ if (this.debug) {
+ /* eslint-disable-next-line */
+ console.info('[GA] Configuring base object', data);
+ }
+ this._baseParams = data;
+ }
+
+ /**
+ * @param {Record} list
+ */
+ _printParamsTable(list) {
+ const map = {};
+ const debugList = [];
+ Object.keys(list).forEach((param) => {
+ const name = paramsMap[param] || param;
+ const value = decodeURIComponent(list[param]);
+ map[param] = {
+ value,
+ name
+ };
+ debugList.push({
+ param,
+ value,
+ name
+ });
+ });
+ /* eslint-disable-next-line */
+ console.table(map, ['name', 'value']);
+ }
+
+ /**
+ * @param {string} body The message to send
+ * @returns {Promise}
+ */
+ async _transport(body) {
+ const { offline } = this;
+ if (offline) {
+ offlineQueue.push(body);
+ return;
+ }
+
+ const init = {
+ method: 'POST',
+ headers: { 'content-type': 'application/x-www-form-urlencoded' },
+ body,
+ };
+ let url = 'https://www.google-analytics.com';
+ if (this.debugEndpoint) {
+ url += '/debug';
+ }
+ url += '/collect';
+ if (this.useCacheBooster) {
+ url += `?z=${ Date.now()}`;
+ }
+
+ try {
+ const response = await fetch(url, init);
+ if (response.status !== 200) {
+ if (!offline) {
+ offlineQueue.push(body);
+ } else {
+ throw new Error('Unable send data.');
+ }
+ }
+ if (this.debugEndpoint) {
+ const result = await response.json();
+ // eslint-disable-next-line no-console
+ console.log(result);
+ }
+ } catch (e) {
+ if (!navigator.onLine && !offline) {
+ offlineQueue.push(body);
+ return;
+ }
+ throw new Error('Unable to send data');
+ }
+ }
+
+ /**
+ * @param {boolean} value
+ * @returns {Promise}
+ */
+ async _offlineChanged(value) {
+ if (value || !offlineQueue.length) {
+ // Nothing to do when offline of no pending tasks.
+ return;
+ }
+ const p = [];
+ for (let i = offlineQueue.length - 1; i >= 0; i--) {
+ const body = offlineQueue[i];
+ offlineQueue.splice(i, 1);
+ p[p.length] = this._transport(body);
+ }
+ try {
+ await Promise.all(p)
+ } catch (e) {
+ /* eslint-disable-next-line */
+ console.warn(e);
+ };
+ }
+}
diff --git a/src/preload/WindowProxy.js b/src/preload/WindowProxy.js
new file mode 100644
index 00000000..5a25cba6
--- /dev/null
+++ b/src/preload/WindowProxy.js
@@ -0,0 +1,13 @@
+import { ipcRenderer } from 'electron';
+
+/**
+ * A proxy for the renderer process to communicate with the WindowManager
+ */
+export class WindowProxy {
+ /**
+ * Queries for the initial data the page was loaded with.
+ */
+ async initContextMenu() {
+ ipcRenderer.send('window-context-menu-init');
+ }
+}
diff --git a/src/preload/WorkspaceManager.js b/src/preload/WorkspaceManager.js
new file mode 100644
index 00000000..d0202edb
--- /dev/null
+++ b/src/preload/WorkspaceManager.js
@@ -0,0 +1,213 @@
+import { ipcRenderer } from 'electron';
+import logger from 'electron-log';
+import fs from 'fs-extra';
+import { v4 } from 'uuid';
+import { WorkspaceEventTypes } from '@advanced-rest-client/arc-events';
+
+/** @typedef {import('@advanced-rest-client/arc-events').WorkspaceReadEvent} WorkspaceReadEvent */
+/** @typedef {import('@advanced-rest-client/arc-events').WorkspaceWriteEvent} WorkspaceWriteEvent */
+/** @typedef {import('@advanced-rest-client/arc-types').Workspace.DomainWorkspace} DomainWorkspace */
+/** @typedef {import('@advanced-rest-client/arc-types').Workspace.LegacyWorkspace} LegacyWorkspace */
+
+export const readHandler = Symbol('readHandler');
+export const writeHandler = Symbol('writeHandler');
+export const getFileLocation = Symbol('getFileLocation');
+
+/**
+ * A class that manipulates the content of the workspace file.
+ * The UI thread is not aware of the location of the workspace file. It only receives an autogenerated id by the `WindowManager`.
+ * This class needs to ask where the file is located. This is done so no other script other than the one loaded in the pre-load script
+ * can read the actual location of the file.
+ */
+export class WorkspaceManager {
+ /**
+ * @type {string} The read location of the workspace file.
+ */
+ #file = undefined;
+
+ /**
+ * @type {*}
+ */
+ #writeTimeout = undefined;
+
+ /**
+ * @param {string=} id The identifier of the workspace generated by the window manager. If not set the default file is used.
+ */
+ constructor(id) {
+ this.id = id;
+ /**
+ * Store data debounce timer.
+ * By default it's 500 ms.
+ * @type {Number}
+ */
+ this.timeout = 500;
+
+ this[readHandler] = this[readHandler].bind(this);
+ this[writeHandler] = this[writeHandler].bind(this);
+ }
+
+ listen() {
+ window.addEventListener(WorkspaceEventTypes.read, this[readHandler]);
+ window.addEventListener(WorkspaceEventTypes.write, this[writeHandler]);
+ }
+
+ /**
+ * @param {WorkspaceReadEvent} e
+ */
+ [readHandler](e) {
+ e.detail.result = this.read();
+ }
+
+ /**
+ * @param {WorkspaceWriteEvent} e
+ */
+ [writeHandler](e) {
+ const { contents } = e.detail;
+ e.detail.result = this.write(contents);
+ }
+
+ /**
+ * @returns {Promise} The current state of the workspace.
+ */
+ async read() {
+ const file = await this[getFileLocation]();
+ await fs.ensureFile(file);
+ let result;
+ try {
+ result = await fs.readJSON(file, { throws: false });
+ } catch (e) {
+ logger.error(`Workspace file read error for file ${file}`);
+ }
+ return this.processWorkspaceInput(result);
+ }
+
+ /**
+ * Stores the state to a file.
+ * @param {DomainWorkspace} workspace The workspace data to store.
+ */
+ async write(workspace) {
+ if (this.#writeTimeout) {
+ clearTimeout(this.#writeTimeout);
+ this.#writeTimeout = undefined;
+ }
+ const file = await this[getFileLocation]();
+ try {
+ await fs.ensureFile(file);
+ await fs.writeJSON(file, workspace);
+ } catch (e) {
+ logger.error(`Workspace file write error to file ${file}`);
+ }
+ }
+
+ /**
+ * Stores the state to a file.
+ * @param {DomainWorkspace} workspace The workspace data to store.
+ */
+ writeAsync(workspace) {
+ if (this.#writeTimeout) {
+ clearTimeout(this.#writeTimeout);
+ }
+ this.#writeTimeout = setTimeout(() => this.write(workspace), this.timeout);
+ }
+
+ /**
+ * @returns {Promise}
+ */
+ async [getFileLocation]() {
+ if (this.#file) {
+ return this.#file;
+ }
+ const location = await ipcRenderer.invoke('workspace-get-location', this.id);
+ this.#file = location;
+ return location;
+ }
+
+ /**
+ * If needed it upgrades the schema to the current one.
+ * It creates a new workspace if it detects that the input is invalid.
+ * @param {any} input The data read from the file.
+ * @returns {DomainWorkspace} Processed workspace data
+ */
+ processWorkspaceInput(input) {
+ if (!input) {
+ return this.createDefaultWorkspace();
+ }
+ if (input.kind === 'ARC#DomainWorkspace') {
+ return input;
+ }
+ const typedLegacy = /** @type LegacyWorkspace */ (input);
+ if (Array.isArray(typedLegacy.requests)) {
+ return this.upgradeLegacyWorkspace(typedLegacy);
+ }
+ return this.createDefaultWorkspace();
+ }
+
+ /**
+ * Creates an empty workspace definition.
+ * @returns {DomainWorkspace} Processed workspace data
+ */
+ createDefaultWorkspace() {
+ return {
+ kind: 'ARC#DomainWorkspace',
+ id: v4(),
+ readOnly: false,
+ };
+ }
+
+ /**
+ * @param {LegacyWorkspace} old
+ * @returns {DomainWorkspace} Processed workspace data
+ */
+ upgradeLegacyWorkspace(old) {
+ const info = this.createDefaultWorkspace();
+ info.meta = {
+ kind: 'ARC#ThingMeta',
+ };
+ if (typeof old.description === 'string') {
+ info.meta.description = old.description;
+ }
+ if (typeof old.version === 'string') {
+ info.meta.version = old.version;
+ }
+ if (typeof old.published === 'string') {
+ info.meta.published = old.published;
+ info.meta.updated = old.published;
+ }
+ if (typeof old.version === 'string') {
+ info.meta.version = old.version;
+ }
+ if (old.provider) {
+ info.provider = old.provider;
+ info.provider.kind = 'ARC#Provider';
+ }
+ if (typeof old.selected === 'number') {
+ info.selected = old.selected;
+ }
+ if (Array.isArray(old.variables)) {
+ info.variables = old.variables;
+ }
+ if (Array.isArray(old.requests)) {
+ info.requests = old.requests;
+ }
+ return info;
+ }
+
+ /**
+ * Triggers the save file dialog and when a file is picker then is changes the workspace file location.
+ * @returns {Promise}
+ */
+ async changeStoreLocation() {
+ const opts = {
+ file: 'arc-workspace.json',
+ };
+ const dialogResult = await ipcRenderer.invoke('save-dialog', opts);
+ const { canceled, filePath } = dialogResult;
+ if (canceled) {
+ return undefined;
+ }
+ const id = await ipcRenderer.invoke('workspace-change-location', filePath);
+ this.#file = undefined;
+ this.id = id;
+ return id;
+ }
+}
diff --git a/src/preload/arc-preload.esm.js b/src/preload/arc-preload.esm.js
new file mode 100644
index 00000000..6745b913
--- /dev/null
+++ b/src/preload/arc-preload.esm.js
@@ -0,0 +1,89 @@
+import { ipcRenderer, clipboard } from 'electron';
+import logger from 'electron-log';
+import { OAuth2Handler } from '@advanced-rest-client/electron-oauth2/renderer/OAuth2Handler.js';
+import { SocketRequest, ElectronRequest } from '@advanced-rest-client/electron-request';
+import { ElectronAmfService } from '@advanced-rest-client/electron-amf-service';
+import { PreferencesProxy } from './PreferencesProxy.js';
+import { WindowProxy } from './WindowProxy.js';
+import { CookieBridge } from './CookieBridge.js';
+import { ThemeManager } from './ThemeManager.js';
+import { EncryptionService } from './EncryptionService.js';
+import { WorkspaceManager } from './WorkspaceManager.js';
+import { ImportFilePreProcessor } from './ImportFilePreProcessor.js';
+import { FilesystemProxy } from './FilesystemProxy.js';
+import { ApplicationSearchProxy } from './ApplicationSearchProxy.js';
+import { AppStateProxy } from './AppStateProxy.js';
+import { GoogleDriveProxy } from './GoogleDriveProxy.js';
+import { GoogleAnalytics } from './GoogleAnalytics.js';
+
+const env = {};
+const APP_VERSION = process.env.npm_package_version;
+Object.keys(process.env).forEach((key) => {
+ if (key.indexOf('npm_') === 0 || key.indexOf('ARC_') === 0) {
+ return;
+ }
+ env[key] = process.env[key];
+});
+
+const { versions } = process;
+const nodeBuffer = Buffer;
+
+const origRequire = require;
+
+process.once('loaded', () => {
+ // @ts-ignore
+ global.OAuth2Handler = OAuth2Handler;
+ // @ts-ignore
+ global.PreferencesProxy = PreferencesProxy;
+ // @ts-ignore
+ global.AppStateProxy = AppStateProxy;
+ global.logger = logger;
+ // @ts-ignore
+ global.WindowManagerProxy = WindowProxy;
+ // @ts-ignore
+ global.CookieBridge = CookieBridge;
+ // @ts-ignore
+ global.SocketRequest = SocketRequest;
+ // @ts-ignore
+ global.ElectronRequest = ElectronRequest;
+ // @ts-ignore
+ global.ThemeManager = ThemeManager;
+ // @ts-ignore
+ global.EncryptionService = EncryptionService;
+ // @ts-ignore
+ global.WorkspaceManager = WorkspaceManager;
+ // @ts-ignore
+ global.ImportFilePreProcessor = ImportFilePreProcessor;
+ // @ts-ignore
+ global.FilesystemProxy = FilesystemProxy;
+ // @ts-ignore
+ global.ApplicationSearchProxy = ApplicationSearchProxy;
+ // @ts-ignore
+ global.GoogleDriveProxy = GoogleDriveProxy;
+ // @ts-ignore
+ global.ElectronAmfService = ElectronAmfService;
+ // @ts-ignore
+ global.GoogleAnalytics = GoogleAnalytics;
+ global.ipc = ipcRenderer;
+ global.clipboard = clipboard;
+
+ global.process = {
+ // @ts-ignore
+ env,
+ };
+
+ // @ts-ignore
+ global.versionInfo = {
+ // @ts-ignore
+ chrome: versions.chrome,
+ appVersion: APP_VERSION,
+ };
+
+ // this is important for the response view which uses Buffer class when the response has been recorded by Electron app.
+ global.Buffer = nodeBuffer;
+
+ if (process.env.NODE_ENV === 'test') {
+ // @ts-ignore
+ window.electronRequire = origRequire
+ }
+});
diff --git a/src/preload/arc-preload.js b/src/preload/arc-preload.js
new file mode 100644
index 00000000..0a81b19b
--- /dev/null
+++ b/src/preload/arc-preload.js
@@ -0,0 +1,3 @@
+const _require = require("esm")(module);
+
+_require('./arc-preload.esm.js');
diff --git a/src/preload/popup-menu.esm.js b/src/preload/popup-menu.esm.js
new file mode 100644
index 00000000..96347d02
--- /dev/null
+++ b/src/preload/popup-menu.esm.js
@@ -0,0 +1,13 @@
+import { ipcRenderer } from 'electron';
+import logger from 'electron-log';
+import { PreferencesProxy } from './PreferencesProxy.js';
+import { ThemeManager } from './ThemeManager.js';
+
+process.once('loaded', () => {
+ // @ts-ignore
+ global.PreferencesProxy = PreferencesProxy;
+ global.logger = logger;
+ // @ts-ignore
+ global.ThemeManager = ThemeManager;
+ global.ipc = ipcRenderer;
+});
diff --git a/src/preload/popup-menu.js b/src/preload/popup-menu.js
new file mode 100644
index 00000000..5380a87f
--- /dev/null
+++ b/src/preload/popup-menu.js
@@ -0,0 +1,3 @@
+const _require = require("esm")(module);
+
+_require('./popup-menu.esm.js');
diff --git a/src/preload/search-bar.esm.js b/src/preload/search-bar.esm.js
new file mode 100644
index 00000000..6097de9b
--- /dev/null
+++ b/src/preload/search-bar.esm.js
@@ -0,0 +1,8 @@
+import { ipcRenderer } from 'electron';
+import { ThemeManager } from './ThemeManager.js';
+
+process.once('loaded', () => {
+ global.ipc = ipcRenderer;
+ // @ts-ignore
+ global.ThemeManager = ThemeManager;
+});
diff --git a/src/preload/search-bar.js b/src/preload/search-bar.js
new file mode 100644
index 00000000..7016dd73
--- /dev/null
+++ b/src/preload/search-bar.js
@@ -0,0 +1,3 @@
+const _require = require("esm")(module);
+
+_require('./search-bar.esm.js');
diff --git a/src/preload/themes-preload.esm.js b/src/preload/themes-preload.esm.js
new file mode 100644
index 00000000..96347d02
--- /dev/null
+++ b/src/preload/themes-preload.esm.js
@@ -0,0 +1,13 @@
+import { ipcRenderer } from 'electron';
+import logger from 'electron-log';
+import { PreferencesProxy } from './PreferencesProxy.js';
+import { ThemeManager } from './ThemeManager.js';
+
+process.once('loaded', () => {
+ // @ts-ignore
+ global.PreferencesProxy = PreferencesProxy;
+ global.logger = logger;
+ // @ts-ignore
+ global.ThemeManager = ThemeManager;
+ global.ipc = ipcRenderer;
+});
diff --git a/src/preload/themes-preload.js b/src/preload/themes-preload.js
new file mode 100644
index 00000000..25fb4601
--- /dev/null
+++ b/src/preload/themes-preload.js
@@ -0,0 +1,3 @@
+const _require = require("esm")(module);
+
+_require('./themes-preload.esm.js');
diff --git a/src/search-bar/search-bar.html b/src/search-bar/search-bar.html
deleted file mode 100644
index 78789e0e..00000000
--- a/src/search-bar/search-bar.html
+++ /dev/null
@@ -1,32 +0,0 @@
-
-
-
- Search
-
-
-
-
- ${this._inputTemplate()}
-
- ${this._controlsTemplate()}
-
-
- ${this._suffixTemplate()}
- Search text
-
- `;
- }
-
- _suffixTemplate() {
- if (!this.hasValue) {
- return '';
- }
- const {
- selected,
- searchCount
- } = this;
- return html`${selected}/${searchCount}
`;
- }
-
- _controlsTemplate() {
- const { hasValue, compatibility } = this;
- return html`
-
- ${keyboardArrowUp}
-
-
- ${keyboardArrowDown}
-
-
- ${close}
-
- `;
- }
-}
-window.customElements.define('search-bar', SearchBar);
diff --git a/src/types.d.ts b/src/types.d.ts
new file mode 100644
index 00000000..43c82bfe
--- /dev/null
+++ b/src/types.d.ts
@@ -0,0 +1,262 @@
+import { Cookie } from 'electron';
+import { OAuth2Authorization } from '@advanced-rest-client/electron-oauth2';
+
+/**
+ * Configuration for an application config option.
+ */
+export declare interface ApplicationOption {
+ name: string;
+ shortcut?: string;
+ type: any;
+ isArray?: boolean;
+}
+/**
+ * Configuration option after internal processing
+ */
+export declare interface ProcessedApplicationOption extends ApplicationOption {
+ value?: any;
+ skipNext: boolean;
+}
+/**
+ * An object generated by the `ApplicationOptions` class.
+ */
+export declare interface ApplicationOptionsConfig {
+ settingsFile?: string;
+ stateFile?: string;
+ themesPath?: string;
+ workspacePath?: string;
+ dev?: boolean;
+ debugLevel?: 'debug'|'error'|'info'|'silly'|'verbose'|'warn';
+ withDevtools?: boolean;
+ // this is for development purposes only
+ port?: number;
+ // the domain model file to open.
+ open?: string;
+ /**
+ * When set it prohibits the application from auto update.
+ */
+ skipAppUpdate?: boolean;
+ skipThemesUpdate?: boolean;
+ userDataDir?: string;
+ /**
+ * Overrides current configuration for the release channel.
+ */
+ releaseChannel?: string;
+ openProtocolFile?: string;
+ /**
+ * When set it does not render the cookie consent dialog
+ */
+ skipCookieConsent?: boolean;
+ /**
+ * When set it does not render the cookie consent dialog
+ */
+ skipDatabaseUpgrade?: boolean;
+}
+
+/**
+ * When the application was opened from the protocol handler it will
+ * have a path that looks like `domain://[source]/[action]/[id]`
+ */
+export declare interface ProtocolFile {
+ source: string;
+ action: string;
+ id: string;
+}
+
+/**
+ * The final config object distributed to all windows.
+ */
+export declare interface ApplicationConfig {
+ /**
+ * Whether the telemetry is enabled.
+ */
+ telemetry?: boolean;
+ /**
+ * Application release channel.
+ */
+ releaseChannel?: 'beta' | 'alpha' | 'latest';
+ /**
+ * Whether the automatic updates are enabled.
+ * True by default.
+ */
+ autoUpdate?: boolean;
+}
+
+export declare interface WindowsSessionSchema {
+ windows: WindowSession[];
+}
+
+/**
+ * Interface describing a data structure for a window sizes and positions.
+ * Used in `WindowPersistance`.
+ */
+export declare interface WindowSession {
+ /**
+ * The id of the window.
+ */
+ id?: number,
+ width?: number;
+ height?: number;
+ x?: number;
+ y?: number;
+}
+
+export declare interface OpenPageOptions {
+ /**
+ * The name of the page in the `src/app/` directory to load in the window.
+ * Default to `app.html`.
+ */
+ page?: string;
+ /**
+ * A string to be appended to the has part of the loaded URL.
+ * No default value.
+ */
+ route?: string;
+ /**
+ * The name of the preload script located in the `src/preload/` folder.
+ * When not set no preload script is loaded, unless loading the default page (no value on `page`),
+ * then it is set to `arc-preload.js`.
+ */
+ preload?: string;
+ /**
+ * A list of init parameters to append to the loaded page's query string.
+ */
+ params?: {[key: string]: string};
+ /**
+ * The workspace file that has been requested to open with the window.
+ * This is only for the main application window.
+ */
+ workspaceFile?: string;
+ /**
+ * When set it ignores reading window sizing and position from the workspace file.
+ */
+ ignoreWindowSessionSettings?: boolean;
+ /**
+ * When set it removed the default menu
+ */
+ noMenu?: boolean;
+ /**
+ * Optional size and position to set on the window.
+ */
+ sizing?: WindowSession;
+ /**
+ * This is intended to be used with the Google Drive window only. Google does not allow other than http: https: origins
+ * and therefore the app is unable to make a request from the application.
+ * When a Drive picker window is opened it instructs Electron to disable web security to work around this problem.
+ */
+ noWebSecurity?: boolean;
+ /**
+ * Makes the new window a child of the `parent`.
+ */
+ parent?: Electron.BrowserWindow;
+}
+
+export declare interface ArcAppInitOptions {
+ /**
+ * Tells whether dark mode should be enabled, due to system settings.
+ */
+ darkMode?: boolean;
+ /**
+ * The backend id of the workspace file.
+ */
+ workspaceId?: string;
+}
+
+
+export interface SessionManagerConfig {
+ /**
+ * A list of application internal URLs for
+ * which certificate error should not be ignored.
+ */
+ appUrls?: string[];
+}
+
+export interface ElectronCookieChangeRecord {
+ /**
+ * The cookie that was changed.
+ */
+ cookie: Cookie;
+ /**
+ * The cause of the change with one of the following values:
+ * - `explicit` - The cookie was changed directly by a consumer's action.
+ * - `overwrite` - The cookie was automatically removed due to an insert operation that overwrote it.
+ * - `expired` - The cookie was automatically removed as it expired.
+ * - `evicted` - The cookie was automatically evicted during garbage collection.
+ * - `expired-overwrite` - The cookie was overwritten with an already-expired expiration date.
+ */
+ cause: string;
+ /**
+ * `true` if the cookie was removed, `false` otherwise.
+ */
+ removed: boolean;
+}
+
+
+export interface DriveExportInit {
+ /**
+ * Default mime type for a file if not defined when updating.
+ */
+ mime?: string;
+ fileDescription?: string;
+ fileType?: string;
+}
+
+export interface SaveDriveFileOptions {
+ /**
+ * Optional name of the parent folder
+ */
+ parent?: string;
+ /**
+ * Google Drive file id to update. Used when updating a file.
+ */
+ id?: string;
+ /**
+ * Google Drive file resource values. See Google Drive API documentation for details.
+ */
+ meta?: FileResource;
+ /**
+ * Authorization configuration to use when authorizing the request.
+ * If the `accessToken` property is set it skips authorization and uses this token instead.
+ * By default it expects `oauth2` configuration in the `package.json` file.
+ */
+ auth?: OAuth2Authorization;
+}
+
+export declare interface FileMedia {
+ mimeType: string;
+ body: string;
+}
+
+export declare interface FileResource {
+ description?: string;
+ parents?: string[];
+ /**
+ * The name of the file
+ */
+ name: string;
+ /**
+ * File content type. Defaults to `application/json`
+ */
+ mimeType?: string;
+}
+
+export declare interface AppFolderListResponse {
+ kind: 'drive#fileList';
+ incompleteSearch: boolean;
+ files: FolderListItem[];
+}
+
+export declare interface FolderListItem {
+ kind: 'drive#file';
+ id: string;
+ name: string;
+ mimeType: string;
+}
+
+export declare interface FileCreateItem {
+ kind: 'drive#file',
+ id: string;
+ name: string;
+ mimeType: string;
+ parents?: FolderListItem[];
+}
diff --git a/tasks/arc-publish.sh b/tasks/arc-publish.sh
index 1906a8e4..7170d822 100755
--- a/tasks/arc-publish.sh
+++ b/tasks/arc-publish.sh
@@ -3,6 +3,11 @@ if [ $TRAVIS_BRANCH != 'alpha' ] && [ $TRAVIS_BRANCH != 'master' ] && [ $TRAVIS_
exit 0
fi
+if [ "$TRAVIS_PULL_REQUEST" != "false" ]; then
+ echo "Skipping ARC build. This is a PR request."
+ exit 0
+fi
+
# Fails the build when the publishing process fails.
set -e
diff --git a/tasks/notarize.js b/tasks/notarize.js
index 4dedc5ca..68ad8368 100644
--- a/tasks/notarize.js
+++ b/tasks/notarize.js
@@ -4,7 +4,7 @@ const { notarize } = require('electron-notarize');
exports.default = async function notarizing(context) {
const { electronPlatformName, appOutDir } = context;
if (electronPlatformName !== 'darwin') {
- return;
+ return undefined;
}
const appName = context.packager.appInfo.productFilename;
@@ -12,7 +12,7 @@ exports.default = async function notarizing(context) {
/* eslint-disable-next-line no-console */
console.log('Notarizing macOS application...');
- return await notarize({
+ return notarize({
appBundleId: 'com.mulesoft.arc',
appPath: `${appOutDir}/${appName}.app`,
appleId: process.env.APPLEID,
diff --git a/tasks/prepare-app.js b/tasks/prepare-app.js
index 72729a49..5d0a9e91 100644
--- a/tasks/prepare-app.js
+++ b/tasks/prepare-app.js
@@ -1,3 +1,4 @@
+/* eslint-disable no-await-in-loop */
const fs = require('fs-extra');
const path = require('path');
/* eslint-disable no-console */
@@ -13,6 +14,7 @@ class PrepareApp {
process.exit(-1);
}
}
+
/**
* A function that checks whether any of `@advanced-rest-client` or `@api-components`
* module located in node_modules has inner `node_modules` component.
@@ -28,9 +30,13 @@ class PrepareApp {
async _analyzeNmPath(dir) {
const loc = path.join(__dirname, '..', 'node_modules', dir);
+ const exists = await fs.pathExists(loc);
+ if (!exists) {
+ return;
+ }
const items = await fs.readdir(loc);
for (let i = 0, len = items.length; i < len; i++) {
- if (items[i] === 'pouchdb-mapreduce-no-ddocs') {
+ if (['pouchdb-mapreduce-no-ddocs', 'electron-request'].includes(items[i])) {
continue;
}
const candidate = path.join(loc, items[i], 'node_modules');
diff --git a/test/basic.nottest.js b/test/.old/basic.nottest.js
similarity index 100%
rename from test/basic.nottest.js
rename to test/.old/basic.nottest.js
diff --git a/test/client-certificates/cc.app.spec.js b/test/.old/client-certificates/cc.app.spec.js
similarity index 100%
rename from test/client-certificates/cc.app.spec.js
rename to test/.old/client-certificates/cc.app.spec.js
diff --git a/test/configuration/renderer-configuration-setup.app.spec.js b/test/.old/configuration/renderer-configuration-setup.app.spec.js
similarity index 100%
rename from test/configuration/renderer-configuration-setup.app.spec.js
rename to test/.old/configuration/renderer-configuration-setup.app.spec.js
diff --git a/test/remote-api/api.app.spec.js b/test/.old/remote-api/api.app.spec.js
similarity index 100%
rename from test/remote-api/api.app.spec.js
rename to test/.old/remote-api/api.app.spec.js
diff --git a/test/session-cookies/basic.app.spec.js b/test/.old/session-cookies/basic.app.spec.js
similarity index 100%
rename from test/session-cookies/basic.app.spec.js
rename to test/.old/session-cookies/basic.app.spec.js
diff --git a/test/themes/dark-mode.app.spec.js b/test/.old/themes/dark-mode.app.spec.js
similarity index 100%
rename from test/themes/dark-mode.app.spec.js
rename to test/.old/themes/dark-mode.app.spec.js
diff --git a/test/window-bootstrap/database.app.spec.js b/test/.old/window-bootstrap/database.app.spec.js
similarity index 100%
rename from test/window-bootstrap/database.app.spec.js
rename to test/.old/window-bootstrap/database.app.spec.js
diff --git a/test/window-bootstrap/window-loading.app.spec.js b/test/.old/window-bootstrap/window-loading.app.spec.js
similarity index 100%
rename from test/window-bootstrap/window-loading.app.spec.js
rename to test/.old/window-bootstrap/window-loading.app.spec.js
diff --git a/test/basics/app-options.main.spec.js b/test/ApplicationOptions/ApplicationOptions.main.spec.js
similarity index 68%
rename from test/basics/app-options.main.spec.js
rename to test/ApplicationOptions/ApplicationOptions.main.spec.js
index ce643685..57bf8071 100644
--- a/test/basics/app-options.main.spec.js
+++ b/test/ApplicationOptions/ApplicationOptions.main.spec.js
@@ -1,18 +1,23 @@
-const { AppOptions } = require('../../scripts/main/app-options');
const { assert } = require('chai');
-describe('AppOptions', () => {
+const _require = require('esm')(module);
+
+/** @typedef {import('../../src/io/ApplicationOptions').ApplicationOptions} ApplicationOptions */
+
+const { ApplicationOptions } = _require('../../src/io/ApplicationOptions.js');
+
+describe('ApplicationOptions', () => {
describe('#availableOptions', () => {
- let instance;
+ let instance = /** @type ApplicationOptions */ (null);
before(() => {
- instance = new AppOptions();
+ instance = new ApplicationOptions();
});
[
'--settings-file',
+ '--state-file',
'--workspace-path',
'--themes-path',
- '--components-path',
- '--debug',
+ '--dev',
'--debug-level',
'--with-devtools',
'.',
@@ -20,6 +25,10 @@ describe('AppOptions', () => {
'--open',
'--skip-app-update',
'--skip-themes-update',
+ '--user-data-dir',
+ '--release-channel',
+ '--skip-cookie-consent',
+ '--skip-database-upgrade',
].forEach((option) => {
it(`supports ${option} option`, () => {
const opts = instance.availableOptions;
@@ -30,9 +39,9 @@ describe('AppOptions', () => {
[
'-s',
+ '-S',
'-w',
'-t',
- '-c',
'-d',
'-l',
'-w',
@@ -41,6 +50,8 @@ describe('AppOptions', () => {
'-o',
'-u',
'-x',
+ '-D',
+ '-r',
].forEach((option) => {
it(`supports ${option} shortcut`, () => {
const opts = instance.availableOptions;
@@ -51,10 +62,10 @@ describe('AppOptions', () => {
[
['--settings-file', String],
+ ['--state-file', String],
['--workspace-path', String],
['--themes-path', String],
- ['--components-path', String],
- ['--debug', Boolean],
+ ['--dev', Boolean],
['--debug-level', String],
['--with-devtools', Boolean],
['.', String],
@@ -62,6 +73,10 @@ describe('AppOptions', () => {
['--open', String],
['--skip-themes-update', Boolean],
['--skip-app-update', Boolean],
+ ['--user-data-dir', String],
+ ['--release-channel', String],
+ ['--skip-cookie-consent', Boolean],
+ ['--skip-database-upgrade', Boolean],
].forEach(([option, type]) => {
it(`has type for ${option} option`, () => {
const opts = instance.availableOptions;
@@ -72,23 +87,27 @@ describe('AppOptions', () => {
});
describe('parse()', () => {
- let instance;
+ let instance = /** @type ApplicationOptions */ (null);
beforeEach(() => {
- instance = new AppOptions();
+ instance = new ApplicationOptions();
});
[
['--settings-file', 'test-settings-file', 'test-settings-file', 'settingsFile'],
+ ['--state-file', 'test-state-file', 'test-state-file', 'stateFile'],
['--workspace-path', 'test-workspace-path', 'test-workspace-path', 'workspacePath'],
['--themes-path', 'test-themes-path', 'test-themes-path', 'themesPath'],
- ['--components-path', 'test-components-path', 'test-components-path', 'componentsPath'],
+ ['--dev', undefined, true, 'dev'],
['--debug-level', 'silly', 'silly', 'debugLevel'],
- ['--open', 'test-file', 'test-file', 'open'],
- ['--debug', undefined, true, 'debug'],
['--with-devtools', undefined, true, 'withDevtools'],
['--port', '8080', 8080, 'port'],
+ ['--open', 'test-file', 'test-file', 'open'],
['--skip-app-update', undefined, true, 'skipAppUpdate'],
['--skip-themes-update', undefined, true, 'skipThemesUpdate'],
+ ['--user-data-dir', 'data-path', 'data-path', 'userDataDir'],
+ ['--release-channel', 'latest', 'latest', 'releaseChannel'],
+ ['--skip-cookie-consent', undefined, true, 'skipCookieConsent'],
+ ['--skip-database-upgrade', undefined, true, 'skipDatabaseUpgrade'],
].forEach(([option, value, parsedValue, property]) => {
it(`sets ${option} property to ${value}`, () => {
const orig = process.argv;
@@ -96,18 +115,20 @@ describe('AppOptions', () => {
if (value) {
newArgs[newArgs.length] = value;
}
+ // @ts-ignore
process.argv = newArgs;
instance.parse();
process.argv = orig;
+ // @ts-ignore
assert.equal(instance[property], parsedValue);
});
});
});
describe('openProtocolFile()', () => {
- let instance;
+ let instance = /** @type ApplicationOptions */ (null);
beforeEach(() => {
- instance = new AppOptions();
+ instance = new ApplicationOptions();
});
it('sets Drive protocol info', () => {
diff --git a/test/ElectronCookies/CookieBridge.renderer.spec.js b/test/ElectronCookies/CookieBridge.renderer.spec.js
new file mode 100644
index 00000000..ff91e04e
--- /dev/null
+++ b/test/ElectronCookies/CookieBridge.renderer.spec.js
@@ -0,0 +1,423 @@
+/* eslint-disable prefer-destructuring */
+/* eslint-disable import/no-commonjs */
+
+const { assert } = require('chai');
+const _require = require('esm')(module);
+
+const { CookieBridge } = _require('../../src/preload/CookieBridge');
+const ArcEvents = _require('@advanced-rest-client/arc-events');
+const { DataGenerator } = require('./Generator.js');
+
+/** @typedef {import('@advanced-rest-client/arc-events').SessionCookieEvents} SessionCookieEventsType */
+/** @typedef {import('@advanced-rest-client/arc-types').Cookies.ARCCookie} ARCCookie */
+
+const SessionCookieEvents = /** @type SessionCookieEventsType */ (ArcEvents.SessionCookieEvents);
+
+describe('CookieBridge - renderer process', () => {
+ const generator = new DataGenerator();
+
+ /**
+ * @param {CookieBridge} instance
+ */
+ async function removeAllCookies(instance) {
+ const cookies = await instance.getAllCookies();
+ if (cookies.length) {
+ await instance.removeCookies(cookies);
+ }
+ }
+
+ describe('getAllCookies()', () => {
+ let instance = /** @type CookieBridge */ (null);
+
+ beforeEach(async () => {
+ instance = new CookieBridge();
+ });
+
+ afterEach(async () => {
+ await removeAllCookies(instance);
+ });
+
+ it('reads all cookies', async () => {
+ const cookies = generator.generateCookiesData({ size: 10 });
+ await instance.updateCookies(cookies);
+ const result = await instance.getAllCookies();
+ assert.lengthOf(result, 10);
+ });
+
+ it('returns empty array when no cookies', async () => {
+ const result = await instance.getAllCookies();
+ assert.lengthOf(result, 0);
+ });
+
+ it('has no expired cookies', async () => {
+ const cookie = generator.generateCookieObject();
+ cookie.expires = Date.now() - 1000;
+ delete cookie.maxAge;
+ await instance.updateCookies([cookie]);
+ const result = await instance.getAllCookies();
+ assert.lengthOf(result, 0);
+ });
+ });
+
+ describe('getDomainCookies()', () => {
+ let instance = /** @type CookieBridge */ (null);
+
+ beforeEach(async () => {
+ instance = new CookieBridge();
+ });
+
+ afterEach(async () => {
+ await removeAllCookies(instance);
+ });
+
+ it('reads cookies for the domain', async () => {
+ const cookies = generator.generateCookiesData({ size: 5 });
+ await instance.updateCookies(cookies);
+ const result = await instance.getDomainCookies(cookies[0].domain);
+ assert.lengthOf(result, 1);
+ });
+
+ it('returns empty array when no cookies', async () => {
+ const result = await instance.getDomainCookies('api.com');
+ assert.lengthOf(result, 0);
+ });
+
+ it('returns empty array when no domain cookies', async () => {
+ const cookies = generator.generateCookiesData({ size: 5 });
+ await instance.updateCookies(cookies);
+ const result = await instance.getDomainCookies('api.com');
+ assert.lengthOf(result, 0);
+ });
+ });
+
+ describe('removeCookies()', () => {
+ let instance = /** @type CookieBridge */ (null);
+
+ beforeEach(async () => {
+ instance = new CookieBridge();
+ });
+
+ afterEach(async () => {
+ await removeAllCookies(instance);
+ });
+
+ it('removes a cookie', async () => {
+ const cookie = generator.generateCookieObject();
+ await instance.updateCookie(cookie);
+ await instance.removeCookies([cookie]);
+ const result = await instance.getAllCookies();
+ assert.lengthOf(result, 0);
+ });
+
+ it('does nothing when cookie does not exist', async () => {
+ const cookie = generator.generateCookieObject();
+ await instance.removeCookies([cookie]);
+ });
+ });
+
+ describe('Events based tests', () => {
+ async function createTestCookies() {
+ const c1 = {
+ name: 'test-name',
+ value: 'test-value',
+ url: 'http://api.domain.com',
+ domain: 'api.domain.com',
+ path: '/',
+ };
+ const c2 = {
+ name: 'test2',
+ value: 'test2',
+ url: 'http://other.com',
+ domain: 'other.com',
+ path: '/',
+ };
+ await SessionCookieEvents.update(document.body, c1);
+ await SessionCookieEvents.update(document.body, c2);
+ }
+
+ async function removeTestCookies() {
+ const cookies = [{
+ name: 'test-name',
+ url: 'http://api.domain.com',
+ domain: 'api.domain.com',
+ path: '/',
+ }, {
+ name: 'test2',
+ url: 'http://other.com',
+ domain: 'other.com',
+ path: '/',
+ }];
+ await SessionCookieEvents.delete(document.body, cookies);
+ }
+
+ let instance = /** @type CookieBridge */ (null);
+ before(() => {
+ instance = new CookieBridge();
+ instance.listen();
+ });
+
+ after(() => {
+ instance.unlisten();
+ });
+
+ describe('session-cookie-list-all', () => {
+ before(() => createTestCookies());
+ after(() => removeTestCookies());
+
+ it('returns all cookies', async () => {
+ const result = await SessionCookieEvents.listAll(document.body);
+ assert.typeOf(result, 'array', 'returns an array');
+ assert.lengthOf(result, 2, 'has all created cookies');
+ });
+ });
+
+ describe('domain cookie list', () => {
+ before(() => createTestCookies());
+ after(() => removeTestCookies());
+
+ it('returns domain cookies', async () => {
+ const result = await SessionCookieEvents.listDomain(document.body, 'other.com');
+ assert.typeOf(result, 'array', 'returns an array');
+ assert.lengthOf(result, 1, 'has single cookie');
+ assert.equal(result[0].domain, '.other.com', 'has a domain cookie');
+ });
+ });
+
+ describe('updating a cookie', () => {
+ afterEach(() => removeAllCookies(instance));
+
+ it('persists the cookie in the store', async () => {
+ await SessionCookieEvents.update(document.body, {
+ name: 'test',
+ value: 'test',
+ path: '/',
+ domain: 'domain.com',
+ });
+ const cookies = await instance.getAllCookies();
+ const [cookie] = cookies;
+ // @ts-ignore
+ delete cookie.created;
+ // @ts-ignore
+ delete cookie.lastAccess;
+ // @ts-ignore
+ delete cookie.persistent;
+ assert.deepEqual(cookies[0], {
+ domain: '.domain.com',
+ // hostOnly: true,
+ httpOnly: false,
+ name: 'test',
+ path: '/',
+ secure: false,
+ session: true,
+ value: 'test',
+ expires: 0,
+ hostOnly: false,
+ });
+ });
+ });
+
+ describe('session-cookie-remove', () => {
+ before(() => createTestCookies());
+ after(() => removeTestCookies());
+
+ it('removes a cookie', async () => {
+ await SessionCookieEvents.delete(document.body, [{
+ name: 'test-name',
+ value: 'test-value',
+ // url: 'http://api.domain.com',
+ domain: 'api.domain.com',
+ path: '/',
+ }]);
+ const result = await instance.getDomainCookies('api.domain.com');
+ assert.lengthOf(result, 0);
+ });
+ });
+ });
+
+ describe('class APIs', () => {
+ describe('updateCookie()', () => {
+ let instance = /** @type CookieBridge */ (null);
+ let cookie = /** @type ARCCookie */ (null);
+ beforeEach(() => {
+ instance = new CookieBridge();
+ cookie = {
+ name: `test-cookie`,
+ value: 'test',
+ // url: `http://api.domain.com`,
+ domain: 'api.domain.com',
+ path: '/',
+ expires: Date.now() + 2000,
+ httpOnly: false,
+ secure: false,
+ hostOnly: false,
+ };
+ });
+
+ afterEach(async () => {
+ await removeAllCookies(instance);
+ });
+
+ it('returns created cookie', async () => {
+ const expires = Math.round(cookie.expires / 1000);
+ const result = await instance.updateCookie(cookie);
+ assert.deepEqual(result, {
+ domain: 'api.domain.com',
+ path: '/',
+ expirationDate: expires,
+ httpOnly: false,
+ hostOnly: false,
+ name: cookie.name,
+ secure: false,
+ url: `http://api.domain.com/`,
+ value: 'test',
+ });
+ });
+
+ it('stores the cookie in the data store', async () => {
+ const expires = Math.round(cookie.expires / 1000);
+ await instance.updateCookie(cookie);
+ const cookies = await instance.getAllCookies();
+ const [item] = cookies;
+ // @ts-ignore
+ delete item.created;
+ // @ts-ignore
+ delete item.lastAccess;
+ // @ts-ignore
+ delete item.persistent;
+ assert.deepEqual(item, {
+ domain: '.api.domain.com',
+ expires: expires * 1000,
+ hostOnly: false,
+ httpOnly: false,
+ name: cookie.name,
+ path: '/',
+ secure: false,
+ session: false,
+ value: 'test',
+ });
+ });
+ });
+
+ describe('updateCookies()', () => {
+ let instance = /** @type CookieBridge */ (null);
+ let cookies = /** @type ARCCookie[] */ (null);
+ beforeEach(() => {
+ instance = new CookieBridge();
+ cookies = [
+ {
+ name: `test-cookie1`,
+ value: 'test',
+ // url: `http://api.domain.com`,
+ domain: 'api.domain.com',
+ path: '/',
+ expires: Date.now() + 2000,
+ httpOnly: false,
+ },
+ {
+ name: `test-cookie2`,
+ value: 'test',
+ // url: `http://other.com`,
+ domain: 'other.com',
+ path: '/',
+ expires: Date.now() + 2000,
+ httpOnly: false,
+ },
+ ];
+ });
+
+ afterEach(async () => {
+ await removeAllCookies(instance);
+ });
+
+ it('stores created cookies in the data store', async () => {
+ await instance.updateCookies(cookies);
+ const all = await instance.getAllCookies();
+ assert.lengthOf(all, 2);
+ });
+ });
+
+ describe('removeCookies()', () => {
+ let instance = /** @type CookieBridge */ (null);
+ let cookies = /** @type ARCCookie[] */ (null);
+ beforeEach(async () => {
+ instance = new CookieBridge();
+ cookies = [
+ {
+ name: `test-cookie1`,
+ value: 'test',
+ // url: `http://api.domain.com`,
+ domain: 'api.domain.com',
+ path: '/',
+ expires: Date.now() + 2000,
+ httpOnly: false,
+ },
+ {
+ name: `test-cookie2`,
+ value: 'test',
+ // url: `http://other.com`,
+ domain: 'other.com',
+ path: '/',
+ expires: Date.now() + 2000,
+ httpOnly: false,
+ },
+ ];
+ await instance.updateCookies(cookies);
+ });
+
+ afterEach(async () => {
+ await removeAllCookies(instance);
+ });
+
+ it('removes all passed cookies', async () => {
+ await instance.removeCookies(cookies);
+ const all = await instance.getAllCookies();
+ assert.lengthOf(all, 0);
+ });
+
+ it('removes only passed cookies', async () => {
+ await instance.removeCookies([cookies[0]]);
+ const all = await instance.getAllCookies();
+ assert.lengthOf(all, 1);
+ assert.equal(all[0].name, 'test-cookie2');
+ });
+ });
+
+ describe('getDomainCookies()', () => {
+ let instance = /** @type CookieBridge */ (null);
+ let cookies = /** @type ARCCookie[] */ (null);
+ beforeEach(async () => {
+ instance = new CookieBridge();
+ cookies = [
+ {
+ name: 'test-cookie1',
+ value: 'test',
+ // url: 'http://api.domain.com',
+ expires: Date.now() + 2000,
+ httpOnly: false,
+ domain: 'api.domain.com',
+ path: '/',
+ },
+ {
+ name: `test-cookie2`,
+ value: 'test',
+ // url: `http://other.com`,
+ expires: Date.now() + 2000,
+ httpOnly: false,
+ domain: 'other.com',
+ path: '/'
+ },
+ ];
+ await instance.updateCookies(cookies);
+ });
+
+ afterEach(async () => {
+ await removeAllCookies(instance);
+ });
+
+ it('reads all cookies', async () => {
+ const result = await instance.getDomainCookies('api.domain.com');
+ assert.lengthOf(result, 1);
+ });
+ });
+ });
+});
diff --git a/test/ElectronCookies/Generator.js b/test/ElectronCookies/Generator.js
new file mode 100644
index 00000000..7cb7635a
--- /dev/null
+++ b/test/ElectronCookies/Generator.js
@@ -0,0 +1,43 @@
+/* eslint-disable import/no-commonjs */
+
+const Chance = require('chance');
+// @ts-ignore
+const _require = require('esm')(module);
+
+const { Cookie } = _require('@advanced-rest-client/arc-cookies/src/Cookie.js');
+
+const chance = new Chance();
+
+class DataGenerator {
+ // Generates random Cookie data
+ generateCookieObject() {
+ const cookie = new Cookie(chance.word(), chance.word(), {
+ 'domain': chance.domain(),
+ 'expires': chance.hammertime(),
+ 'hostOnly': chance.bool(),
+ 'httpOnly': chance.bool(),
+ 'path': chance.bool() ? '/' : `/${chance.word()}`,
+ 'secure': chance.bool(),
+ 'max-age': chance.integer({ min: 100, max: 1000 }),
+ });
+ return cookie;
+ }
+
+ /**
+ * Generates cookies list
+ *
+ * @param {object=} opts Configuration options:
+ * - `size` (Number) Number of items to generate. Default to 25.
+ * @return {object[]} List of datastore entries.
+ */
+ generateCookiesData(opts = {}) {
+ const size = opts.size || 25;
+ const result = [];
+ for (let i = 0; i < size; i++) {
+ result.push(this.generateCookieObject());
+ }
+ return result;
+ }
+}
+
+module.exports.DataGenerator = DataGenerator;
diff --git a/test/ElectronCookies/SessionManager.main.spec.js b/test/ElectronCookies/SessionManager.main.spec.js
new file mode 100644
index 00000000..a2c01b86
--- /dev/null
+++ b/test/ElectronCookies/SessionManager.main.spec.js
@@ -0,0 +1,383 @@
+/* eslint-disable no-await-in-loop */
+/* eslint-disable import/no-commonjs */
+const { assert } = require('chai');
+const { session } = require('electron');
+const _require = require('esm')(module);
+
+/** @typedef {import('../../src/io/SessionManager').SessionManager} SessionManager */
+
+const { SessionManager } = _require('../../src/io/SessionManager.js');
+const { WebSessionPersist } = _require('../../src/io/Constants.js');
+
+describe('SessionManager - main process', () => {
+ const url = 'https://domain.com/cookies';
+
+ async function cleanCookies() {
+ const sis = session.fromPartition(WebSessionPersist);
+ const Cookies = sis.cookies;
+ const cookies = await Cookies.get({});
+ if (!cookies || !cookies.length) {
+ return;
+ }
+ for (let i = 0; i < cookies.length; i++) {
+ let cookieUrl;
+ if (cookies[i].name === 't1') {
+ cookieUrl = 'https://domain.com/path';
+ } else if (cookies[i].name === 't2') {
+ cookieUrl = 'https://other.com/';
+ }
+ await Cookies.remove((cookieUrl || url), cookies[i].name);
+ }
+ }
+
+ async function createTestCookies() {
+ const sis = session.fromPartition(WebSessionPersist);
+ const Cookies = sis.cookies;
+ await Cookies.set({
+ url: 'https://domain.com/path',
+ name: 't1',
+ value: 'v1',
+ });
+ await Cookies.set({
+ url: 'https://other.com/',
+ name: 't2',
+ value: 'v2',
+ });
+ }
+
+ async function removeCookies(cookies) {
+ const sis = session.fromPartition(WebSessionPersist);
+ const Cookies = sis.cookies;
+ for (let i = 0, len = cookies.length; i < len; i++) {
+ const [curl, name] = cookies[i];
+ await Cookies.remove(curl, name);
+ }
+ await Cookies.flushStore();
+ }
+
+ describe('getSessionCookies()', () => {
+ let instance = /** @type SessionManager */ (null);
+ beforeEach(() => {
+ instance = new SessionManager();
+ instance.listen();
+ });
+
+ afterEach(() => {
+ instance.unlisten();
+ });
+
+ it('Returns Cookies class for session', () => {
+ const result = instance.getSessionCookies();
+ assert.equal(result.constructor.name, 'Cookies');
+ });
+ });
+
+ describe('#session', () => {
+ let instance = /** @type SessionManager */ (null);
+ beforeEach(() => {
+ instance = new SessionManager();
+ });
+
+ it('returns session cookies instance', () => {
+ const result = instance.session;
+ assert.equal(result.constructor.name, 'Cookies');
+ });
+
+ it('returns the same cookies instance', () => {
+ const result1 = instance.session;
+ const result2 = instance.session;
+ assert.isTrue(result1 === result2);
+ });
+ });
+
+ describe('setCookie()', () => {
+ let instance = /** @type SessionManager */ (null);
+ const name = 'test-cookie';
+ const value = 'test-value';
+
+ before(() => cleanCookies());
+
+ beforeEach(() => {
+ instance = new SessionManager();
+ instance.listen();
+ });
+
+ afterEach(async () => {
+ instance.unlisten();
+ await removeCookies([
+ [url, name],
+ ['https://domain.com/', name],
+ ['http://qax.anypoint.mulesoft.com/', '_csrf'],
+ ]);
+ });
+
+ it('creates a cookie', async () => {
+ await instance.setCookie({
+ url,
+ name,
+ value,
+ });
+ const cookies = await instance.session.get({});
+ assert.lengthOf(cookies, 1);
+ assert.equal(cookies[0].name, name);
+ assert.equal(cookies[0].value, value);
+ });
+
+ it('creates url for a cookie', async () => {
+ const created = await instance.setCookie({
+ name,
+ value,
+ domain: 'domain.com',
+ secure: true,
+ url: 'https://domain.com/',
+ });
+ assert.equal(created.url, 'https://domain.com/');
+ });
+
+ it('creates a cookie from renderer object', async () => {
+ const cookie = {
+ created: Date.now(),
+ domain: 'qax.anypoint.mulesoft.com',
+ expirationDate: 8640000000000,
+ hostOnly: true,
+ // httponly: null,
+ lastAccess: 1580162723841,
+ name: '_csrf',
+ path: '/',
+ persistent: false,
+ value: 'GwjXpexHYiv22J9Bd7NUF-4c',
+ url: 'http://qax.anypoint.mulesoft.com',
+ };
+ await instance.setCookie(cookie);
+
+ const cookies = await instance.session.get({});
+ assert.lengthOf(cookies, 1, 'has single cookie');
+ assert.deepEqual(cookies[0], {
+ name: '_csrf',
+ value: 'GwjXpexHYiv22J9Bd7NUF-4c',
+ domain: '.qax.anypoint.mulesoft.com',
+ hostOnly: false,
+ path: '/',
+ secure: false,
+ httpOnly: false,
+ session: false,
+ expirationDate: 8640000000000,
+ sameSite: 'no_restriction',
+ }, 'stores the cookie in the store');
+ });
+ });
+
+ describe('removeCookie()', () => {
+ let instance = /** @type SessionManager */ (null);
+ const curl = 'https://domain.com/cookies';
+ const name = 'test-cookie';
+ const value = 'test-value';
+
+ before(() => cleanCookies());
+
+ beforeEach(() => {
+ instance = new SessionManager();
+ instance.listen();
+ });
+
+ afterEach(async () => {
+ instance.unlisten();
+ });
+
+ it('removes existing cookie', async () => {
+ const created = await instance.setCookie({
+ url: curl,
+ name,
+ value,
+ });
+ await instance.removeCookie(created);
+ const cookies = await instance.session.get({});
+ assert.lengthOf(cookies, 0);
+ });
+
+ it('removes renderer based cookie', async () => {
+ const cookie = {
+ created: Date.now(),
+ domain: 'qax.anypoint.mulesoft.com',
+ expirationDate: 8640000000000,
+ hostOnly: true,
+ // httponly: null,
+ lastAccess: 1580162723841,
+ name: '_csrf',
+ path: '/',
+ persistent: false,
+ value: 'GwjXpexHYiv22J9Bd7NUF-4c',
+ url: 'http://qax.anypoint.mulesoft.com',
+ };
+ await instance.setCookie(cookie);
+ await instance.removeCookie({
+ url: 'http://qax.anypoint.mulesoft.com/',
+ name: '_csrf',
+ });
+ const cookies = await instance.session.get({});
+ assert.lengthOf(cookies, 0);
+ });
+ });
+
+ describe('getUrlCookies()', () => {
+ let instance = /** @type SessionManager */ (null);
+ before(async () => {
+ await cleanCookies();
+ await createTestCookies();
+ });
+
+ after(async () => {
+ await cleanCookies();
+ });
+
+ beforeEach(() => {
+ instance = new SessionManager();
+ instance.listen();
+ });
+
+ afterEach(() => {
+ instance.unlisten();
+ });
+
+ it('Reads url cookies with getUrlCookies()', async () => {
+ const cookies = await instance.getUrlCookies('https://other.com');
+ assert.lengthOf(cookies, 1);
+ });
+ });
+
+ describe('getAllCookies()', () => {
+ let instance = /** @type SessionManager */ (null);
+
+ beforeEach(() => {
+ instance = new SessionManager();
+ instance.listen();
+ });
+
+ afterEach(async () => {
+ instance.unlisten();
+ await cleanCookies();
+ });
+
+ it('reads all cookies', async () => {
+ await createTestCookies();
+ const cookies = await instance.getAllCookies();
+ assert.lengthOf(cookies, 2);
+ });
+
+ it('returns empty array when no cookies', async () => {
+ const cookies = await instance.getAllCookies();
+ assert.lengthOf(cookies, 0);
+ });
+ });
+
+ describe('getDomainCookies()', () => {
+ let instance = /** @type SessionManager */ (null);
+
+ beforeEach(() => {
+ instance = new SessionManager();
+ instance.listen();
+ });
+
+ afterEach(async () => {
+ instance.unlisten();
+ await cleanCookies();
+ });
+
+ it('reads domain cookies', async () => {
+ await createTestCookies();
+ const cookies = await instance.getDomainCookies('other.com');
+ assert.lengthOf(cookies, 1);
+ });
+
+ it('returns empty array when no cookies', async () => {
+ const cookies = await instance.getDomainCookies('abc.xyz');
+ assert.lengthOf(cookies, 0);
+ });
+
+ it('returns empty array when no domain cookies', async () => {
+ await createTestCookies();
+ const cookies = await instance.getDomainCookies('abc.xyz');
+ assert.lengthOf(cookies, 0);
+ });
+ });
+
+ describe('getUrlCookies()', () => {
+ let instance = /** @type SessionManager */ (null);
+
+ beforeEach(() => {
+ instance = new SessionManager();
+ instance.listen();
+ });
+
+ afterEach(async () => {
+ instance.unlisten();
+ await cleanCookies();
+ });
+
+ it('reads cookies by the URL', async () => {
+ await createTestCookies();
+ const cookies = await instance.getUrlCookies('https://other.com');
+ assert.lengthOf(cookies, 1);
+ });
+
+ it('returns empty array when no cookies', async () => {
+ const cookies = await instance.getUrlCookies('https://other.com');
+ assert.lengthOf(cookies, 0);
+ });
+
+ it('returns empty array when no URL cookies', async () => {
+ await createTestCookies();
+ const cookies = await instance.getUrlCookies('https://others.xyz');
+ assert.lengthOf(cookies, 0);
+ });
+ });
+
+ describe('removeCookieMakeUrl()', () => {
+ let instance = /** @type SessionManager */ (null);
+
+ beforeEach(() => {
+ instance = new SessionManager();
+ instance.listen();
+ });
+
+ afterEach(async () => {
+ instance.unlisten();
+ await cleanCookies();
+ });
+
+ it('removes a cookie', async () => {
+ await createTestCookies();
+ const cookiesPre = await instance.getAllCookies();
+ assert.lengthOf(cookiesPre, 2);
+ await instance.removeCookieMakeUrl({
+ domain: 'domain.com',
+ name: 't1',
+ value: 'v1',
+ sameSite: 'unspecified',
+ }, 't1');
+ const cookies = await instance.getAllCookies();
+ assert.notEqual(cookies.length, cookiesPre.length);
+ });
+ });
+
+ describe('openWebBrowser()', () => {
+ let instance = /** @type SessionManager */ (null);
+ const loc = 'about:blank';
+
+ beforeEach(() => {
+ instance = new SessionManager();
+ });
+
+ it('returns the browser URL', async () => {
+ const result = instance.openWebBrowser(loc);
+ assert.equal(result.constructor.name, 'BrowserWindow');
+ result.close();
+ });
+
+ it('has the user agent set', async () => {
+ const result = instance.openWebBrowser(loc);
+ assert.equal(result.webContents.userAgent, 'Chrome');
+ result.close();
+ });
+ });
+});
diff --git a/test/WindowsManager/WindowsManager.main.spec.js b/test/WindowsManager/WindowsManager.main.spec.js
new file mode 100644
index 00000000..f4106055
--- /dev/null
+++ b/test/WindowsManager/WindowsManager.main.spec.js
@@ -0,0 +1,150 @@
+const { assert } = require('chai');
+const { BrowserWindow } = require('electron');
+const _require = require('esm')(module);
+const testPaths = require('../setup-paths');
+
+const { WindowsManager } = _require('../../src/io/WindowsManager');
+const { ArcSessionRecorder } = _require('../../src/io/ArcSessionRecorder');
+const { ContextActions } = _require('../../src/io/ContextActions');
+const { WindowsPersistance } = _require('../../src/io/WindowsPersistance');
+const { setLevel } = _require('../../src/io/Logger');
+
+/** @typedef {import('../../src/io/WindowsManager').WindowsManager} WindowsManager */
+/** @typedef {import('../../src/io/ArcSessionRecorder').ArcSessionRecorder} ArcSessionRecorder */
+/** @typedef {import('../../src/io/ContextActions').ContextActions} ContextActions */
+/** @typedef {import('../../src/io/WindowsPersistance').WindowsPersistance} WindowsPersistance */
+
+setLevel('error');
+
+describe('WindowsManager', () => {
+ before(() => {
+ testPaths.getBasePath();
+ testPaths.setupEnvironment();
+ });
+
+ describe('constructor()', () => {
+ it('sets the default startup options', () => {
+ const instance = new WindowsManager();
+ assert.typeOf(instance.startupOptions, 'object');
+ assert.lengthOf(Object.keys(instance.startupOptions), 0);
+ });
+
+ it('sets passed startup options', () => {
+ const opts = { startPath: 'test' };
+ const instance = new WindowsManager(opts);
+ assert.deepEqual(instance.startupOptions, opts);
+ });
+
+ it('sets the windows array property', () => {
+ const instance = new WindowsManager();
+ assert.lengthOf(instance.windows, 0);
+ });
+
+ it('Sets ArcSessionRecorder', () => {
+ const instance = new WindowsManager();
+ assert.isTrue(instance.recorder instanceof ArcSessionRecorder);
+ });
+
+ it('Sets ContextActions', () => {
+ const instance = new WindowsManager();
+ assert.isTrue(instance.contextActions instanceof ContextActions);
+ });
+
+ it('sets the workspace property', () => {
+ const instance = new WindowsManager();
+ assert.isTrue(instance.workspace instanceof WindowsPersistance);
+ });
+ });
+
+ describe('get hasWindow()', () => {
+ let instance = /** @type WindowsManager */ (null);
+ before(() => {
+ instance = new WindowsManager();
+ });
+
+ it('Returns false when no windows', () => {
+ assert.isFalse(instance.hasWindow);
+ });
+
+ it('Returns true when has a window', () => {
+ // @ts-ignore
+ instance.windows = [{}];
+ assert.isTrue(instance.hasWindow);
+ });
+ });
+
+ describe('get lastFocused()', () => {
+ let instance = /** @type WindowsManager */ (null);
+ before(() => {
+ instance = new WindowsManager();
+ });
+
+ it('returns null when no focused window', () => {
+ assert.equal(instance.lastFocused, null);
+ });
+ });
+
+ describe('get lastActive()', () => {
+ let instance = /** @type WindowsManager */ (null);
+ before(() => {
+ instance = new WindowsManager();
+ });
+
+ it('returns null when no windows', () => {
+ assert.equal(instance.lastActive, null);
+ });
+
+ it('returns null when no active windows', () => {
+ instance.windows = [
+ // @ts-ignore
+ {
+ isDestroyed: () => true
+ },
+ // @ts-ignore
+ {
+ isDestroyed: () => true
+ }
+ ];
+ assert.equal(instance.lastActive, null);
+ });
+
+ it('Returns window instance', () => {
+ instance.windows = [
+ // @ts-ignore
+ {
+ isDestroyed: () => true
+ },
+ // @ts-ignore
+ {
+ isDestroyed: () => false
+ }
+ ];
+ assert.deepEqual(instance.lastActive, instance.windows[1]);
+ });
+ });
+
+ describe('open()', () => {
+ let instance = /** @type WindowsManager */ (null);
+ before(() => {
+ instance = new WindowsManager();
+ });
+
+ it('returns the window instance', async () => {
+ const win = await instance.open();
+ assert.isTrue(win instanceof BrowserWindow);
+ win.destroy();
+ });
+
+ it('adds window to the list of windows', async () => {
+ const win = await instance.open();
+ assert.isTrue(instance.windows.includes(win));
+ win.destroy();
+ });
+
+ it('removes window from the list when destroyed', async () => {
+ const win = await instance.open();
+ win.destroy();
+ assert.isFalse(instance.windows.includes(win));
+ });
+ });
+});
diff --git a/test/app-menu/ApplicationMenu.main.spec.js b/test/app-menu/ApplicationMenu.main.spec.js
new file mode 100644
index 00000000..983db170
--- /dev/null
+++ b/test/app-menu/ApplicationMenu.main.spec.js
@@ -0,0 +1,283 @@
+const { assert } = require('chai');
+const path = require('path');
+const fs = require('fs-extra');
+const sinon = require('sinon');
+const { Menu } = require('electron');
+const _require = require('esm')(module);
+const testPaths = require('../setup-paths');
+
+const { ApplicationMenu, clearWorkspaceHistory, appendHistoryEntry, createWorkspaceHistory, workspaceHistoryAction } = _require('../../src/io/ApplicationMenu');
+const { ApplicationUpdater } = _require('../../src/io/ApplicationUpdater');
+const { setLevel } = _require('../../src/io/Logger');
+
+/** @typedef {import('../../src/io/ApplicationMenu').ApplicationMenu} ApplicationMenu */
+/** @typedef {import('../../src/io/ApplicationUpdater').ApplicationUpdater} ApplicationUpdater */
+
+setLevel('error');
+
+describe('ApplicationMenu class', () => {
+ const historyPath = path.join('workspace', 'workspace-history.json');
+ let updater = /** @type ApplicationUpdater */ (null);
+ before(() => {
+ testPaths.getBasePath();
+ updater = new ApplicationUpdater();
+ });
+
+ after(() => {
+ updater.removeAllListeners('status-changed');
+ });
+
+ describe('Constructor', () => {
+ afterEach(() => {
+ updater.removeAllListeners('status-changed');
+ });
+
+ it('Sets topMenu', () => {
+ const instance = new ApplicationMenu(updater);
+ assert.ok(instance.topMenu);
+ });
+
+ it('Sets history', () => {
+ const instance = new ApplicationMenu(updater);
+ assert.typeOf(instance.history, 'object');
+ });
+ });
+
+ describe('build()', () => {
+ let instance = /** @type ApplicationMenu */ (null);
+ beforeEach(() => {
+ instance = new ApplicationMenu(updater);
+ });
+
+ afterEach(() => {
+ updater.removeAllListeners('status-changed');
+ });
+
+ it('calls getTemplate()', async () => {
+ const spy = sinon.spy(instance, 'getTemplate');
+ await instance.build();
+ assert.isTrue(spy.called);
+ });
+
+ it('calls createFromTemplate()', async () => {
+ const spy = sinon.spy(instance, 'createFromTemplate');
+ await instance.build();
+ assert.isTrue(spy.called);
+ });
+
+ it('sets menuLoaded', async () => {
+ await instance.build();
+ assert.isTrue(instance.menuLoaded);
+ });
+
+ it('sets application menu', async () => {
+ await instance.build()
+ const menu = Menu.getApplicationMenu();
+ assert.ok(menu);
+ assert.isAbove(menu.items.length, 5);
+ });
+ });
+
+ describe('appendWorkspaceHistory()', () => {
+ let instance = /** @type ApplicationMenu */ (null);
+ beforeEach(() => {
+ instance = new ApplicationMenu(updater);
+ return instance.build();
+ });
+
+ afterEach(() => {
+ updater.removeAllListeners('status-changed');
+ const file = path.join(process.env.ARC_HOME, historyPath);
+ return fs.remove(file);
+ });
+
+ it('calls WorkspaceHistory::addEntry', async () => {
+ const spy = sinon.spy(instance.history, 'addEntry');
+ await instance.appendWorkspaceHistory('/test');
+ assert.isTrue(spy.called);
+ });
+
+ it('calls [appendHistoryEntry]', async () => {
+ const spy = sinon.spy(instance, appendHistoryEntry);
+ await instance.appendWorkspaceHistory('/test');
+ assert.isTrue(spy.called);
+ });
+ });
+
+ describe('clearWorkspaceHistory()', () => {
+ let instance = /** @type ApplicationMenu */ (null);
+ beforeEach(() => {
+ instance = new ApplicationMenu(updater);
+ return instance.build();
+ });
+
+ afterEach(() => {
+ updater.removeAllListeners('status-changed');
+ const file = path.join(process.env.ARC_HOME, historyPath);
+ return fs.remove(file);
+ });
+
+ it('calls WorkspaceHistory::clearHistory', async () => {
+ const spy = sinon.spy(instance.history, 'clearHistory');
+ await instance.clearWorkspaceHistory()
+ assert.isTrue(spy.called);
+ });
+
+ it('calls [clearWorkspaceHistory]', async () => {
+ const spy = sinon.spy(instance, clearWorkspaceHistory);
+ await instance.clearWorkspaceHistory();
+ assert.isTrue(spy.called);
+ });
+ });
+
+ describe('loadWorkspaceHistory()', () => {
+ let instance = /** @type ApplicationMenu */ (null);
+ beforeEach(() => {
+ instance = new ApplicationMenu(updater);
+ return instance.build();
+ });
+
+ afterEach(() => {
+ updater.removeAllListeners('status-changed');
+ const file = path.join(process.env.ARC_HOME, historyPath);
+ return fs.remove(file);
+ });
+
+ it('calls WorkspaceHistory::loadEntries', async () => {
+ const spy = sinon.spy(instance.history, 'loadEntries');
+ await instance.loadWorkspaceHistory();
+ assert.isTrue(spy.called);
+ });
+
+ it('does not call [createWorkspaceHistory] when no entires', async () => {
+ const spy = sinon.spy(instance, createWorkspaceHistory);
+ await instance.loadWorkspaceHistory();
+ assert.isFalse(spy.called);
+ });
+
+ it('calls [createWorkspaceHistory] when has entires', async () => {
+ const file = path.join(process.env.ARC_HOME, historyPath);
+ const spy = sinon.spy(instance, createWorkspaceHistory);
+ await fs.outputJson(file, {
+ entries: [{
+ file: '/1',
+ used: 1
+ }, {
+ file: '/2',
+ used: 2
+ }]
+ });
+ await instance.loadWorkspaceHistory();
+ assert.isTrue(spy.called);
+ });
+ });
+
+ describe('[createWorkspaceHistory]()', () => {
+ let instance = /** @type ApplicationMenu */ (null);
+ beforeEach(() => {
+ instance = new ApplicationMenu(updater);
+ return instance.build();
+ });
+
+ afterEach(() => {
+ updater.removeAllListeners('status-changed');
+ });
+
+ it('calls [appendHistoryEntry] for each entry', () => {
+ const entries = [{
+ file: '/1',
+ used: 1
+ }, {
+ file: '/2',
+ used: 2
+ }];
+ const spy = sinon.spy(instance, appendHistoryEntry);
+ instance[createWorkspaceHistory](entries);
+ assert.equal(spy.callCount, 2);
+ });
+
+ it('ignores invalid entires', () => {
+ const entries = [{
+ file: 1,
+ used: 1
+ }, {
+ file: '/2',
+ used: 2
+ }];
+ const spy = sinon.spy(instance, appendHistoryEntry);
+ instance[createWorkspaceHistory](entries);
+ assert.equal(spy.callCount, 1);
+ });
+ });
+
+ describe('getWorkspaceHistoryMenu()', () => {
+ let instance = /** @type ApplicationMenu */ (null);
+ beforeEach(() => {
+ instance = new ApplicationMenu(updater);
+ return instance.build();
+ });
+
+ afterEach(() => {
+ updater.removeAllListeners('status-changed');
+ });
+
+ it('Returns the menu', () => {
+ const result = instance.getWorkspaceHistoryMenu();
+ assert.isTrue(result instanceof Menu);
+ });
+ });
+
+ describe('[appendHistoryEntry]()', () => {
+ let instance = /** @type ApplicationMenu */ (null);
+ beforeEach(() => {
+ instance = new ApplicationMenu(updater);
+ return instance.build();
+ });
+
+ afterEach(() => {
+ updater.removeAllListeners('status-changed');
+ });
+
+ it('Adds menu item', () => {
+ instance[appendHistoryEntry]('/1');
+ const menu = instance.getWorkspaceHistoryMenu();
+ assert.equal(menu.items[3].label, '/1');
+ });
+
+ it('Hides 3rd menu item', () => {
+ instance[appendHistoryEntry]('/1');
+ const menu = instance.getWorkspaceHistoryMenu();
+ assert.isFalse(menu.items[2].visible);
+ });
+ });
+
+ describe('[workspaceHistoryAction]()', () => {
+ let instance = /** @type ApplicationMenu */ (null);
+ beforeEach(() => {
+ instance = new ApplicationMenu(updater);
+ return instance.build();
+ });
+
+ afterEach(() => {
+ updater.removeAllListeners('status-changed');
+ const file = path.join(process.env.ARC_HOME, historyPath);
+ return fs.remove(file);
+ });
+
+ it('Calls WorkspaceHistory::addEntry', () => {
+ const spy = sinon.spy(instance.history, 'addEntry');
+ instance[workspaceHistoryAction]({ label: '/test' });
+ assert.equal(spy.args[0][0], '/test');
+ });
+
+ it('Emits open-workspace event', () => {
+ let called = false;
+ instance.on('open-workspace', () => {
+ called = true;
+ });
+ instance[workspaceHistoryAction]({ label: '/test' });
+ instance.removeAllListeners('open-workspace');
+ assert.isTrue(called);
+ });
+ });
+});
diff --git a/test/app-menu/app-menu.main.spec.js b/test/app-menu/app-menu.main.spec.js
deleted file mode 100644
index 689e7987..00000000
--- a/test/app-menu/app-menu.main.spec.js
+++ /dev/null
@@ -1,273 +0,0 @@
-const { assert } = require('chai');
-const path = require('path');
-const fs = require('fs-extra');
-const { ArcMainMenu } = require('../../scripts/main/main-menu.js');
-const sinon = require('sinon');
-const { Menu } = require('electron');
-
-describe('ArcMainMenu class', function() {
- const historyPath = path.join('workspace', 'workspace-history.json');
-
- describe('Constructor', function() {
- it('Sets topMenu', function() {
- const instance = new ArcMainMenu();
- assert.ok(instance.topMenu);
- });
-
- it('Sets history', function() {
- const instance = new ArcMainMenu();
- assert.typeOf(instance.history, 'object');
- });
- });
-
- describe('build()', () => {
- let instance;
- beforeEach(() => {
- instance = new ArcMainMenu();
- });
-
- it('Returns a promise', () => {
- const result = instance.build();
- assert.typeOf(result, 'promise');
- return result;
- });
-
- it('Calls _getTemplate()', () => {
- const spy = sinon.spy(instance, '_getTemplate');
- return instance.build()
- .then(() => {
- assert.isTrue(spy.called);
- });
- });
-
- it('Calls _createFromTemplate()', () => {
- const spy = sinon.spy(instance, '_createFromTemplate');
- return instance.build()
- .then(() => {
- assert.isTrue(spy.called);
- });
- });
-
- it('Sets _menuLoaded', () => {
- return instance.build()
- .then(() => {
- assert.isTrue(instance._menuLoaded);
- });
- });
-
- it('Sets application menu', () => {
- return instance.build()
- .then(() => {
- const menu = Menu.getApplicationMenu();
- assert.ok(menu);
- assert.isAbove(menu.items.length, 5);
- });
- });
-
- it('Executes pendingActions', () => {
- instance.pendingActions = ['disableAppMenuPopup'];
- const spy = sinon.spy(instance, 'disableAppMenuPopup');
- return instance.build()
- .then(() => {
- assert.isTrue(spy.called);
- });
- });
- });
-
- describe('appendWorkspaceHistory()', () => {
- let instance;
- beforeEach(() => {
- instance = new ArcMainMenu();
- return instance.build();
- });
-
- afterEach(() => {
- const file = path.join(process.env.ARC_HOME, historyPath);
- return fs.remove(file);
- });
-
- it('Calls WorkspaceHistory::addEntry', () => {
- const spy = sinon.spy(instance.history, 'addEntry');
- return instance.appendWorkspaceHistory('/test')
- .then(() => {
- assert.isTrue(spy.called);
- });
- });
-
- it('Calls _appendHistoryEntry', () => {
- const spy = sinon.spy(instance, '_appendHistoryEntry');
- return instance.appendWorkspaceHistory('/test')
- .then(() => {
- assert.isTrue(spy.called);
- });
- });
- });
-
- describe('clearWorkspaceHistory()', () => {
- let instance;
- beforeEach(() => {
- instance = new ArcMainMenu();
- return instance.build();
- });
-
- afterEach(() => {
- const file = path.join(process.env.ARC_HOME, historyPath);
- return fs.remove(file);
- });
-
- it('Calls WorkspaceHistory::clearHistory', async () => {
- const spy = sinon.spy(instance.history, 'clearHistory');
- await instance.clearWorkspaceHistory()
- assert.isTrue(spy.called);
- });
-
- it('Calls _clearWorkspaceHistory', async () => {
- const spy = sinon.spy(instance, '_clearWorkspaceHistory');
- await instance.clearWorkspaceHistory();
- assert.isTrue(spy.called);
- });
- });
-
- describe('loadWorkspaceHistory()', () => {
- let instance;
- beforeEach(() => {
- instance = new ArcMainMenu();
- return instance.build();
- });
-
- afterEach(() => {
- const file = path.join(process.env.ARC_HOME, historyPath);
- return fs.remove(file);
- });
-
- it('Calls WorkspaceHistory::clearHistory', () => {
- const spy = sinon.spy(instance.history, 'loadEntries');
- return instance.loadWorkspaceHistory()
- .then(() => {
- assert.isTrue(spy.called);
- });
- });
-
- it('Does not call _createWorkspaceHistory when no entires', () => {
- const spy = sinon.spy(instance, '_createWorkspaceHistory');
- return instance.loadWorkspaceHistory()
- .then(() => {
- assert.isFalse(spy.called);
- });
- });
-
- it('Calls _createWorkspaceHistory when has entires', () => {
- const file = path.join(process.env.ARC_HOME, historyPath);
- const spy = sinon.spy(instance, '_createWorkspaceHistory');
- return fs.outputJson(file, {
- entries: [{
- file: '/1',
- used: 1
- }, {
- file: '/2',
- used: 2
- }]
- })
- .then(() => instance.loadWorkspaceHistory())
- .then(() => {
- assert.isTrue(spy.called);
- });
- });
- });
-
- describe('_createWorkspaceHistory()', () => {
- let instance;
- beforeEach(() => {
- instance = new ArcMainMenu();
- return instance.build();
- });
-
- it('Calls _appendHistoryEntry for each entry', () => {
- const entries = [{
- file: '/1',
- used: 1
- }, {
- file: '/2',
- used: 2
- }];
- const spy = sinon.spy(instance, '_appendHistoryEntry');
- instance._createWorkspaceHistory(entries);
- assert.equal(spy.callCount, 2);
- });
-
- it('Ignores invalid entires', () => {
- const entries = [{
- file: 1,
- used: 1
- }, {
- file: '/2',
- used: 2
- }];
- const spy = sinon.spy(instance, '_appendHistoryEntry');
- instance._createWorkspaceHistory(entries);
- assert.equal(spy.callCount, 1);
- });
- });
-
- describe('getWorkspaceHistoryMenu()', () => {
- let instance;
- beforeEach(() => {
- instance = new ArcMainMenu();
- return instance.build();
- });
-
- it('Returns the menu', () => {
- const result = instance.getWorkspaceHistoryMenu();
- assert.isTrue(result instanceof Menu);
- });
- });
-
- describe('_appendHistoryEntry()', () => {
- let instance;
- beforeEach(() => {
- instance = new ArcMainMenu();
- return instance.build();
- });
-
- it('Adds menu item', () => {
- instance._appendHistoryEntry('/1');
- const menu = instance.getWorkspaceHistoryMenu();
- assert.equal(menu.items[3].label, '/1');
- });
-
- it('Hiddes 3rd menu item', () => {
- instance._appendHistoryEntry('/1');
- const menu = instance.getWorkspaceHistoryMenu();
- assert.isFalse(menu.items[2].visible);
- });
- });
-
- describe('_workspaceHistoryAction()', () => {
- let instance;
- beforeEach(() => {
- instance = new ArcMainMenu();
- return instance.build();
- });
-
- afterEach(() => {
- const file = path.join(process.env.ARC_HOME, historyPath);
- return fs.remove(file);
- });
-
- it('Calls WorkspaceHistory::addEntry', () => {
- const spy = sinon.spy(instance.history, 'addEntry');
- instance._workspaceHistoryAction({ label: '/test' });
- assert.equal(spy.args[0][0], '/test');
- });
-
- it('Emitts open-workspace event', () => {
- let called = false;
- instance.on('open-workspace', () => {
- called = true;
- });
- instance._workspaceHistoryAction({ label: '/test' });
- instance.removeAllListeners('open-workspace');
- assert.isTrue(called);
- });
- });
-});
diff --git a/test/app-paths/initial-paths.app.spec.js b/test/app-paths/initial-paths.app.spec.js
index 749126a9..7d87c7e6 100644
--- a/test/app-paths/initial-paths.app.spec.js
+++ b/test/app-paths/initial-paths.app.spec.js
@@ -1,102 +1,81 @@
-const bootstrap = require('../test-bootstrap.js');
const { assert } = require('chai');
const fs = require('fs-extra');
const path = require('path');
+const bootstrap = require('../test-bootstrap.js');
+
+/** @typedef {import('spectron').Application} Application */
-describe('Initial paths', function() {
+describe('Initial paths', () => {
const basePath = path.join('test', 'tests-exe-dir');
const settingsFilePath = path.join(basePath, 'test-settings.json');
const workspaceFilePath = path.join(basePath, 'workspace');
const themesFilePath = path.join(basePath, 'themes-esm');
- describe('Setups default file paths', function() {
- let app;
- before(function() {
- app = bootstrap.getApp();
- return app.start()
- .then(() => app.client.waitUntilWindowLoaded(10000))
- .catch((cause) => {
+ describe('Setups default file paths', () => {
+ let app = /** @type Application */ (null);
+ before(async () => {
+ const opts = {
+ args: [
+ '--skip-cookie-consent',
+ '--skip-database-upgrade',
+ ]
+ };
+ app = bootstrap.getApp(opts);
+ try {
+ await app.start();
+ // await app.client.waitUntilWindowLoaded();
+ await bootstrap.deffer(5000);
+ } catch (e) {
+ console.log('IS RUNNING', app.isRunning());
+ await app.stop()
if (app && app.isRunning()) {
- return app.stop()
- .then(() => {
- throw cause;
- });
+ throw e;
}
- throw cause;
- });
+ throw e;
+ }
});
- after(function() {
- let p;
+ after(async () => {
if (app && app.isRunning()) {
- p = app.stop();
- } else {
- p = Promise.resolve();
+ await app.stop();
}
- const basePath = path.join('test', 'playground');
- return p.then(() => fs.remove(basePath));
- });
-
- it('Should set default settings file location', function() {
- return app.electron.remote.app
- .testsInterface('get-application-settings-file-location')
- .then((location) => {
- assert.typeOf(location, 'string');
- });
- });
-
- it('Should set default workspace file location', function() {
- return app.electron.remote.app
- .testsInterface('get-application-workspace-state-file-location')
- .then((location) => {
- assert.typeOf(location, 'string');
- });
+ const bp = path.join('test', 'playground');
+ await fs.remove(bp);
});
- it('Sets ARC_HOME variable', () => {
- return app.mainProcess.env()
- .then((variables) => {
- assert.typeOf(variables.ARC_HOME, 'string');
- });
+ it('sets ARC_HOME variable', async () => {
+ console.log(app);
+ const variables = await app.mainProcess.env();
+ assert.typeOf(variables.ARC_HOME, 'string');
});
- it('Sets ARC_SETTINGS_FILE variable', () => {
- return app.mainProcess.env()
- .then((variables) => {
- assert.typeOf(variables.ARC_SETTINGS_FILE, 'string');
- });
+ it('sets ARC_SETTINGS_FILE variable', async () => {
+ const variables = await app.mainProcess.env();
+ assert.typeOf(variables.ARC_SETTINGS_FILE, 'string');
});
- it('Sets default ARC_SETTINGS_FILE is in ARC_HOME', () => {
- return app.mainProcess.env()
- .then((variables) => {
- assert.equal(variables.ARC_SETTINGS_FILE, bootstrap.settingsFilePath);
- });
+ it('sets default ARC_SETTINGS_FILE is in ARC_HOME', async () => {
+ const variables = await app.mainProcess.env();
+ assert.equal(variables.ARC_SETTINGS_FILE, bootstrap.settingsFilePath);
});
- it('Sets default ARC_THEMES in ARC_HOME', () => {
- return app.mainProcess.env()
- .then((variables) => {
- assert.equal(variables.ARC_THEMES, bootstrap.themesFilePath);
- });
+ it('sets default ARC_THEMES in ARC_HOME', async () => {
+ const variables = await app.mainProcess.env();
+ assert.equal(variables.ARC_THEMES, bootstrap.themesFilePath);
});
- it('Sets default ARC_THEMES_SETTINGS in ARC_THEMES', () => {
- return app.mainProcess.env()
- .then((variables) => {
- assert.equal(variables.ARC_THEMES_SETTINGS, path.join(bootstrap.themesFilePath, 'themes-info.json'));
- });
+ it('sets default ARC_THEMES_SETTINGS in ARC_THEMES', async () => {
+ const variables = await app.mainProcess.env();
+ assert.equal(variables.ARC_THEMES_SETTINGS, path.join(bootstrap.themesFilePath, 'themes-info.json'));
});
- it('Sets default ARC_WORKSPACE_PATH in ARC_HOME', () => {
- return app.mainProcess.env()
- .then((variables) => {
- assert.equal(variables.ARC_WORKSPACE_PATH, bootstrap.workspaceFilePath);
- });
+ it('sets default ARC_WORKSPACE_PATH in ARC_HOME', async () => {
+ const variables = await app.mainProcess.env();
+ assert.equal(variables.ARC_WORKSPACE_PATH, bootstrap.workspaceFilePath);
});
});
- describe('Setups configuration file paths', function() {
+ describe('Setups configuration file paths', () => {
const opts = {
args: [
'--settings-file',
@@ -104,54 +83,44 @@ describe('Initial paths', function() {
'--workspace-path',
workspaceFilePath,
'--themes-path',
- themesFilePath
+ themesFilePath,
+ '--skip-cookie-consent',
+ '--skip-database-upgrade',
]
};
- let app;
- before(function() {
+ let app = /** @type Application */ (null);
+ before(async () => {
app = bootstrap.getApp(opts);
- return app.start()
- .then(() => app.client.waitUntilWindowLoaded(10000));
+ await app.start()
+ await app.client.waitUntilWindowLoaded(10000);
});
- after(function() {
- let promise;
+ after(async () => {
if (app && app.isRunning()) {
- promise = app.stop();
- } else {
- promise = Promise.resolve();
+ await app.stop();
}
- return promise
- .then(() => fs.remove(settingsFilePath))
- .then(() => fs.remove(workspaceFilePath));
+ await fs.remove(settingsFilePath);
+ await fs.remove(workspaceFilePath);
});
- it('Sets ARC_SETTINGS_FILE variable', () => {
- return app.mainProcess.env()
- .then((variables) => {
- assert.equal(variables.ARC_SETTINGS_FILE, settingsFilePath);
- });
+ it('sets ARC_SETTINGS_FILE variable', async () => {
+ const variables = await app.mainProcess.env();
+ assert.equal(variables.ARC_SETTINGS_FILE, settingsFilePath);
});
- it('Sets ARC_WORKSPACE_PATH variable', () => {
- return app.mainProcess.env()
- .then((variables) => {
- assert.equal(variables.ARC_WORKSPACE_PATH, workspaceFilePath);
- });
+ it('sets ARC_WORKSPACE_PATH variable', async () => {
+ const variables = await app.mainProcess.env();
+ assert.equal(variables.ARC_WORKSPACE_PATH, workspaceFilePath);
});
- it('Sets ARC_THEMES variable', () => {
- return app.mainProcess.env()
- .then((variables) => {
- assert.equal(variables.ARC_THEMES, themesFilePath);
- });
+ it('sets ARC_THEMES variable', async () => {
+ const variables = await app.mainProcess.env();
+ assert.equal(variables.ARC_THEMES, themesFilePath);
});
- it('Sets ARC_THEMES_SETTINGS variable', () => {
- return app.mainProcess.env()
- .then((variables) => {
- assert.equal(variables.ARC_THEMES_SETTINGS, path.join(themesFilePath, 'themes-info.json'));
- });
+ it('sets ARC_THEMES_SETTINGS variable', async () => {
+ const variables = await app.mainProcess.env();
+ assert.equal(variables.ARC_THEMES_SETTINGS, path.join(themesFilePath, 'themes-info.json'));
});
});
});
diff --git a/test/basics/arc-base.main.spec.js b/test/basics/arc-base.main.spec.js
deleted file mode 100644
index f6a51011..00000000
--- a/test/basics/arc-base.main.spec.js
+++ /dev/null
@@ -1,187 +0,0 @@
-const { ArcBase } = require('../../scripts/main/arc-base');
-const { assert } = require('chai');
-
-describe('ArcBase class', function() {
- describe('Debounce', function() {
- let base;
- beforeEach(function() {
- base = new ArcBase();
- });
-
- it('Execute tasks', function(done) {
- const fn = function() {
- done();
- };
- base.debounce('name', fn, 10);
- });
-
- it('Execute tasks only once', function(done) {
- let called = 0;
- const fn = function() {
- called++;
- };
- base.debounce('name', fn, 10);
- setTimeout(function() {
- base.debounce('name', fn, 10);
- }, 2);
- base.debounce('name', fn, 10);
- setTimeout(function() {
- assert.equal(called, 1);
- done();
- }, 15);
- });
- }).timeout(10000);
-
- describe('Cancel debounce', function() {
- let base;
- beforeEach(function() {
- base = new ArcBase();
- });
-
- it('Does not execute tasks', function(done) {
- let called = 0;
- const fn = function() {
- called++;
- };
- base.debounce('name', fn, 10);
- setTimeout(function() {
- base.cancelDebounce('name');
- }, 2);
- setTimeout(function() {
- assert.equal(called, 0);
- done();
- }, 15);
- });
- }).timeout(10000);
-
- describe('_debounceIndex()', () => {
- let base;
- beforeEach(function() {
- base = new ArcBase();
- });
-
- it('Returns -1 if debouncer not set', () => {
- const result = base._debounceIndex('test');
- assert.equal(result, -1);
- });
-
- it('Returns index of a debouncer', () => {
- base._debouncers.push({
- name: 'test'
- });
- const result = base._debounceIndex('test');
- assert.equal(result, 0);
- });
- });
-
- describe('nextIpcRequestId()', () => {
- let base;
- beforeEach(function() {
- base = new ArcBase();
- });
-
- it('Returns a number', () => {
- const result = base.nextIpcRequestId();
- assert.typeOf(result, 'number');
- });
-
- it('Increases the number for each call', () => {
- const result1 = base.nextIpcRequestId();
- const result2 = base.nextIpcRequestId();
- assert.isAbove(result2, result1);
- });
- });
-
- describe('appendPromise()', () => {
- let base;
- beforeEach(function() {
- base = new ArcBase();
- });
-
- it('Returns a promise', () => {
- const result = base.appendPromise('test');
- assert.typeOf(result, 'promise');
- });
-
- it('Adds promise to the queue', () => {
- base.appendPromise('test');
- assert.lengthOf(base._promises, 1);
- });
-
- it('Added promise has the id', () => {
- base.appendPromise('test');
- assert.equal(base._promises[0].id, 'test');
- });
-
- it('Added promise has resolve function', () => {
- base.appendPromise('test');
- assert.typeOf(base._promises[0].resolve, 'function');
- });
-
- it('Added promise has reject function', () => {
- base.appendPromise('test');
- assert.typeOf(base._promises[0].reject, 'function');
- });
- });
-
- describe('_ipcPromiseCallback()', () => {
- let base;
- beforeEach(function() {
- base = new ArcBase();
- });
-
- it('Throws an error when promise not found in the queue', () => {
- assert.throws(function() {
- base._ipcPromiseCallback({}, 'test');
- });
- });
-
- it('Resolves promise', () => {
- const p = base.appendPromise('test');
- base._ipcPromiseCallback({}, 'test', false);
- return p;
- });
-
- it('Rejects promise', () => {
- const p = base.appendPromise('test');
- base._ipcPromiseCallback({}, 'test', true);
- let called = false;
- return p
- .then(() => {
- called = true;
- throw new Error('Resolves the promise');
- })
- .catch((cause) => {
- if (called) {
- throw cause;
- }
- });
- });
-
- it('Resolves promise with arguments', () => {
- const p = base.appendPromise('test');
- base._ipcPromiseCallback({}, 'test', false, 'a', 'b', 'c');
- return p
- .then((result) => {
- assert.deepEqual(result, ['a', 'b', 'c']);
- });
- });
-
- it('Rejects promise with arguments', () => {
- const p = base.appendPromise('test');
- base._ipcPromiseCallback({}, 'test', true, 'a', 'b', 'c');
- let called = false;
- return p
- .then(() => {
- called = true;
- throw new Error('Resolves the promise');
- })
- .catch((cause) => {
- if (called) {
- throw cause;
- }
- assert.deepEqual(cause, ['a', 'b', 'c']);
- });
- });
- });
-});
diff --git a/test/scripts/main/theme-defaults.main.spec.js b/test/defaults/ThemeDefaults.main.spec.js
similarity index 65%
rename from test/scripts/main/theme-defaults.main.spec.js
rename to test/defaults/ThemeDefaults.main.spec.js
index 7ce6804b..c7c1e90f 100644
--- a/test/scripts/main/theme-defaults.main.spec.js
+++ b/test/defaults/ThemeDefaults.main.spec.js
@@ -1,12 +1,20 @@
-const assert = require('chai').assert;
+/* eslint-disable no-param-reassign */
+const { assert } = require('chai');
const fs = require('fs-extra');
const path = require('path');
-const { ThemeDefaults } = require('../../../scripts/main/defaults/theme-defaults.js');
+const _require = require('esm')(module);
+const testPaths = require('../setup-paths');
-const testPaths = require('../../setup-paths');
testPaths.getBasePath();
-describe('ThemeDefaults', function() {
+const { ThemeDefaults } = _require('../../src/io/defaults/ThemeDefaults');
+const { setLevel } = _require('../../src/io/Logger');
+
+/** @typedef {import('../../src/io/defaults/ThemeDefaults').ThemeDefaults} ThemeDefaults */
+
+setLevel('error');
+
+describe('ThemeDefaults', () => {
const basePath = path.join(process.env.ARC_THEMES, '@advanced-rest-client');
const defaultFile = path.join(basePath, 'arc-electron-default-theme', 'arc-electron-default-theme.css');
const defaultPackage = path.join(basePath, 'arc-electron-default-theme', 'package.json');
@@ -15,57 +23,56 @@ describe('ThemeDefaults', function() {
const darkFile = path.join(basePath, 'arc-electron-dark-theme', 'arc-electron-dark-theme.css');
const darkPackage = path.join(basePath, 'arc-electron-dark-theme', 'package.json');
- let instance;
+ let instance = /** @type ThemeDefaults */ (null);
- describe('prepareEnvironment()', function() {
- beforeEach(function() {
+ describe('prepareEnvironment()', () => {
+ beforeEach(() => {
instance = new ThemeDefaults();
});
- afterEach(function() {
- return fs.remove(process.env.ARC_THEMES);
+ afterEach(async () => {
+ await fs.remove(process.env.ARC_THEMES);
});
async function testContents(themeFile, pkgFile) {
- const fileExists = await fs.exists(themeFile);
+ const fileExists = await fs.pathExists(themeFile);
assert.isTrue(fileExists, 'Main file exists');
- const pkgExists = await fs.exists(pkgFile);
+ const pkgExists = await fs.pathExists(pkgFile);
assert.isTrue(pkgExists, 'Package file exists');
}
- it('Copies default theme files', async () => {
+ it('copies default theme files', async () => {
await instance.prepareEnvironment();
await testContents(defaultFile, defaultPackage);
});
- it('Copies anypoint theme files', async () => {
+ it('copies anypoint theme files', async () => {
await instance.prepareEnvironment();
await testContents(anypointFile, anypointPackage);
});
- it('Copies dark theme files', async () => {
+ it('copies dark theme files', async () => {
await instance.prepareEnvironment();
await testContents(darkFile, darkPackage);
});
- it('Copies theme info file', async () => {
+ it('copies theme info file', async () => {
await instance.prepareEnvironment();
- const exists = await fs.exists(process.env.ARC_THEMES_SETTINGS);
+ const exists = await fs.pathExists(process.env.ARC_THEMES_SETTINGS);
assert.isTrue(exists, 'File exists');
});
});
describe('Updating preinstalled theme files', () => {
- beforeEach(function() {
+ beforeEach(() => {
instance = new ThemeDefaults();
});
- afterEach(function() {
- return fs.remove(process.env.ARC_THEMES);
+ afterEach(async () => {
+ await fs.remove(process.env.ARC_THEMES);
});
- async function installDummy(version) {
- version = version || '0.0.0';
+ async function installDummy(version='0.0.0') {
await fs.outputFile(defaultFile, 'not-a-theme-file');
await fs.writeJson(defaultPackage, {
version
@@ -73,9 +80,8 @@ describe('ThemeDefaults', function() {
}
async function installDb() {
- const db = await fs.readJson(
- path.join(__dirname, '..', '..', '..', 'appresources', 'themes', 'themes-info.json'));
- db.themes.forEach((item) => item.version = '0.0.0');
+ const db = await fs.readJson(path.join(__dirname, '..', '..', 'appresources', 'themes', 'themes-info.json'));
+ db.themes.forEach((item) => { item.version = '0.0.0' });
await fs.outputJson(process.env.ARC_THEMES_SETTINGS, db);
}
@@ -89,7 +95,7 @@ describe('ThemeDefaults', function() {
assert.notEqual(pkg.version, '0.0.0', 'Package version is updated');
});
- it('updates indo db', async () => {
+ it('updates the db', async () => {
await installDummy();
await installDb();
await instance.prepareEnvironment();
diff --git a/test/dev.js b/test/dev.js
deleted file mode 100644
index dbe51383..00000000
--- a/test/dev.js
+++ /dev/null
@@ -1,48 +0,0 @@
-// const path = require('path');
-// const Application = require('spectron').Application;
-
-// let electronPath = path.join(__dirname, '..', 'node_modules',
-// '.bin', 'electron');
-// if (process.platform === 'win32') {
-// electronPath += '.cmd';
-// }
-// const workspaceFilePath = 'test/test-workspace.json';
-// let appPath = path.join(__dirname, '..', 'main.js');
-// let app = new Application({
-// path: electronPath,
-// args: [
-// appPath,
-// '--workspace-file',
-// workspaceFilePath
-// ]
-// });
-// app.start();
-const {SocketRequest} = require('../scripts/renderer/socket-request.js');
-const parts = [
- // After processing status line
- Buffer.from([67, 111, 110, 116, 101, 110, 116, 45, 84, 121, 112, 101,
- 58, 32, 97, 112, 112, 108, 105, 99, 97, 116, 105, 111, 110,
- 47, 106, 115, 111, 110, 13, 10, 67, 111, 110, 116, 101, 110,
- 116, 45, 76, 101, 110, 103, 116, 104, 58, 32, 49, 49, 52,
- 13, 10]),
- Buffer.from([83,101,114,118,101,114,58,32,87,101,114,107,122,101,117,103,47,48,46,49,52,46,49,32,80,121,116,104,111,110,47,50,46,55,46,49,52,13,10,68,97,116,101,58,32,84,104,117,44,32,50,49,32,74,117,110,32,50,48,49,56,32,49,56,58,51,48,58,53,49,32,71,77,84,13,10,13,10,123,34,105,110,115,116,114,117,109,101,110,116,95,105,100,34,58,32,50,52,49,56,54,44,32,34,117,115,101,114,95,105,100,34,58,32,53,57,44,32,34,112,114,111,100,117,99,116,95,105,100,34,58,32,51,50,54,57,44,32,34,112,114,105,99,101,34,58,32,50,46,48,44,32,34,115,105,100,101,34,58,32,34,83,101,108,108,34,44,32,34,105,100,34,58,32,50,44,32,34,113,117,97,110,116,105,116,121,34,58,32,48,125,10])
-];
-const requests = [{
- url: `http://localhost:8080/api/endpoint?query=param`,
- method: 'GET',
- headers: 'Host: test.com\nContent-Length: 0',
- payload: 'abc'
-}];
-
-const opts = [{
- timeout: 50000,
- followRedirects: false,
- hosts: [{
- from: 'domain.com',
- to: 'test.com'
- }]
-}];
-const request = new SocketRequest(requests[0], opts[0]);
-request._processHeaders(parts[0]);
-debugger;
-request._processHeaders(parts[1]);
diff --git a/test/devtest.js b/test/devtest.js
deleted file mode 100644
index 0a4f6e1d..00000000
--- a/test/devtest.js
+++ /dev/null
@@ -1,14 +0,0 @@
-const bootstrap = require('./test-bootstrap.js');
-const workspaceFilePath = 'test/restore.workspace.json';
-const opts = {
- args: [
- '--workspace-file',
- workspaceFilePath
- ]
-};
-const app = bootstrap.getApp(opts);
-app.start()
-.then(() => app.client.waitUntilWindowLoaded(10000))
-.then(() => {
- global._testApp = app;
-});
diff --git a/test/module-import.js b/test/module-import.js
new file mode 100644
index 00000000..2c8b57a6
--- /dev/null
+++ b/test/module-import.js
@@ -0,0 +1,4 @@
+const _require = require("esm")(module);
+
+module.exports.WebSessionPersist = _require('../src/io/Constants.js');
+module.exports.SessionManager = _require('../src/io/SessionManager.js');
diff --git a/test/plugin-manager/ThemePluginsManager.main.spec.js b/test/plugin-manager/ThemePluginsManager.main.spec.js
new file mode 100644
index 00000000..d47e5310
--- /dev/null
+++ b/test/plugin-manager/ThemePluginsManager.main.spec.js
@@ -0,0 +1,221 @@
+const { assert } = require('chai');
+const fs = require('fs-extra');
+const path = require('path');
+const _require = require('esm')(module);
+const testPaths = require('../setup-paths');
+
+const { ThemePluginsManager } = _require('../../src/io/ThemePluginsManager.js');
+const { setLevel } = _require('../../src/io/Logger');
+
+/** @typedef {import('../../src/io/ThemePluginsManager').ThemePluginsManager} ThemePluginsManager */
+
+setLevel('error');
+
+describe('ThemePluginsManager - main process', () => {
+ let basePath;
+
+ before(async () => {
+ basePath = testPaths.getBasePath();
+ const logFile = path.join(basePath, 'log.log');
+ await fs.ensureFile(logFile);
+ });
+
+ after(() => fs.remove(basePath));
+
+ describe('themeInfo getter', () => {
+ let instance = /** @type ThemePluginsManager */ (null);
+ beforeEach(() => {
+ instance = new ThemePluginsManager();
+ });
+
+ it('Returns an instance of ThemeInfo', () => {
+ const result = instance.themeInfo;
+ assert.equal(result.constructor.name, 'ThemeInfo');
+ });
+
+ it('settingsFile is set', () => {
+ const result = instance.themeInfo;
+ assert.equal(result.settingsFile, process.env.ARC_THEMES_SETTINGS);
+ });
+
+ it('Always returns new instance', () => {
+ const i1 = instance.themeInfo;
+ const i2 = instance.themeInfo;
+ assert.isFalse(i1 === i2);
+ });
+ });
+
+ describe('resolvePath()', () => {
+ let instance = /** @type ThemePluginsManager */ (null);
+ beforeEach(() => {
+ instance = new ThemePluginsManager();
+ });
+
+ it('Reads home path', () => {
+ const result = instance.resolvePath('~/test');
+ assert.equal(result.indexOf('~/'), -1);
+ });
+ });
+
+ describe('_ensureSymlinkPath()', () => {
+ afterEach(() => fs.remove(basePath));
+
+ let instance = /** @type ThemePluginsManager */ (null);
+ beforeEach(() => {
+ instance = new ThemePluginsManager();
+ });
+
+ it('Creates path to the location', async () => {
+ const loc = path.join(basePath, 'a', 'b', 'c');
+ await instance._ensureSymlinkPath(loc);
+ const exists = await fs.pathExists(path.join(basePath, 'a', 'b'));
+ assert.isTrue(exists);
+ });
+
+ it('Last folder is not created', async () => {
+ const loc = `${basePath}/a/b/c`;
+ await instance._ensureSymlinkPath(loc);
+ const exists = await fs.pathExists(path.join(basePath, 'a', 'b', 'c'));
+ assert.isFalse(exists);
+ });
+ });
+
+ describe('_installLocalPackage()', () => {
+ const localPackage = path.join(__dirname, 'local-package');
+ afterEach(() => fs.remove(basePath));
+
+ let instance = /** @type ThemePluginsManager */ (null);
+ beforeEach(() => {
+ instance = new ThemePluginsManager();
+ });
+
+ it('creates the symlink', async () => {
+ await instance._installLocalPackage(localPackage);
+ const exists = await fs.pathExists(path.join(process.env.ARC_THEMES, 'test-package'));
+ assert.isTrue(exists);
+ });
+
+ it('returns package info object', async () => {
+ const result = await instance._installLocalPackage(localPackage);
+ assert.typeOf(result, 'object');
+ });
+
+ it('Has package name', async () => {
+ const result = await instance._installLocalPackage(localPackage);
+ assert.equal(result.name, 'test-package');
+ });
+
+ it('isSymlink is set', async () => {
+ const result = await instance._installLocalPackage(localPackage);
+ assert.isTrue(result.isSymlink);
+ });
+
+ it('version is set', async () => {
+ const result = await instance._installLocalPackage(localPackage);
+ assert.equal(result.version, '0.1.0');
+ });
+
+ it('location is set', async () => {
+ const result = await instance._installLocalPackage(localPackage);
+ assert.equal(result.location, path.join(process.env.ARC_THEMES, 'test-package'));
+ });
+
+ it('mainFile is set', async () => {
+ const result = await instance._installLocalPackage(localPackage);
+ assert.equal(result.mainFile, path.join(process.env.ARC_THEMES, 'test-package', 'theme.css'));
+ });
+ });
+
+ describe('_installRemotePackage()', () => {
+ afterEach(() => fs.remove(basePath));
+
+ const pkgName = 'advanced-rest-client/arc-electron-default-theme';
+ const pkgVersion = '2.0.0-preview';
+
+ it('installs GitHub package', async () => {
+ const instance = new ThemePluginsManager();
+ await instance._installRemotePackage(pkgName, pkgVersion);
+ const exists = await fs.pathExists(path.join(process.env.ARC_THEMES, '@advanced-rest-client', 'arc-electron-default-theme'));
+ assert.isTrue(exists);
+ });
+
+ it('Returns info object', async () => {
+ const instance = new ThemePluginsManager();
+ const result = await instance._installRemotePackage(pkgName, pkgVersion);
+ assert.typeOf(result, 'object');
+ assert.equal(result.name, '@advanced-rest-client/arc-electron-default-theme');
+ assert.equal(result.version, pkgVersion);
+ assert.equal(result.location, path.join(process.env.ARC_THEMES, `@${pkgName}`));
+ assert.equal(result.mainFile,path.join(process.env.ARC_THEMES, `@${pkgName}`, 'arc-electron-default-theme.html'));
+ });
+ });
+
+ describe('uninstall()', () => {
+ describe('Local package', () => {
+ let instance = /** @type ThemePluginsManager */ (null);
+ const pkgName = 'test-package';
+ const localPackage = path.join(__dirname, 'local-package');
+ beforeEach(async () => {
+ instance = new ThemePluginsManager();
+ await instance.install(localPackage);
+ const exists = await fs.pathExists(path.join(process.env.ARC_THEMES, 'test-package'));
+ assert.isTrue(exists, 'has the installed package in the themes location');
+ const exists2 = await fs.pathExists(path.join(process.env.ARC_THEMES, 'themes-info.json'))
+ assert.isTrue(exists2, 'has the theme info file');
+ });
+
+ afterEach(() => fs.remove(basePath));
+
+ it('Removes local package', async () => {
+ await instance.uninstall(pkgName);
+ const exists = await fs.pathExists(path.join(process.env.ARC_THEMES, 'test-package'));
+ assert.isFalse(exists);
+ });
+
+ it('Removes entry from info file.', async () => {
+ await instance.uninstall(pkgName);
+ const data = await fs.readJson(process.env.ARC_THEMES_SETTINGS);
+ assert.typeOf(data.themes, 'array');
+ assert.lengthOf(data.themes, 0);
+ });
+ });
+
+ describe('Remote package', () => {
+ let instance = /** @type ThemePluginsManager */ (null);
+ const pkgName = 'advanced-rest-client/arc-electron-default-theme';
+ const installedName = `@${pkgName}`;
+ const pkgVersion = '2.0.0-preview';
+ let installedLocation;
+
+ before(() => {
+ installedLocation = path.join(process.env.ARC_THEMES, '@advanced-rest-client', 'arc-electron-default-theme');
+ instance = new ThemePluginsManager();
+ return instance.install(pkgName, pkgVersion);
+ });
+
+ after(() => fs.remove(basePath));
+
+ it('has the installed package', async () => {
+ const exists = await fs.pathExists(installedLocation)
+ assert.isTrue(exists);
+ });
+
+ it('has the entry in the theme info file.', async () => {
+ const exists = await fs.pathExists(process.env.ARC_THEMES_SETTINGS)
+ assert.isTrue(exists);
+ });
+
+ it('removes remote package', async () => {
+ await instance.uninstall(installedName);
+ const exists = await fs.pathExists(installedLocation);
+ assert.isFalse(exists);
+ });
+
+ it('removes entry from the info file.', async () => {
+ const data = await fs.readJson(path.join(process.env.ARC_THEMES_SETTINGS));
+ assert.typeOf(data.themes, 'array');
+ assert.lengthOf(data.themes, 0);
+ });
+ });
+ });
+});
diff --git a/test/plugin-manager/theme-plugins-manager.main.spec.js b/test/plugin-manager/theme-plugins-manager.main.spec.js
deleted file mode 100644
index f200b78f..00000000
--- a/test/plugin-manager/theme-plugins-manager.main.spec.js
+++ /dev/null
@@ -1,391 +0,0 @@
-const assert = require('chai').assert;
-const fs = require('fs-extra');
-const path = require('path');
-const { ThemePluginsManager } = require('../../scripts/packages/plugin-manager/main');
-const testPaths = require('../setup-paths');
-
-describe('ThemePluginsManager - main process', function() {
- let basePath;
-
- before(async () => {
- basePath = testPaths.getBasePath();
- const logFile = path.join(basePath, 'log.log');
- await fs.ensureFile(logFile);
- });
-
- after(() => fs.remove(basePath));
-
- describe('pluginManager getter', () => {
- let instance;
- beforeEach(() => {
- instance = new ThemePluginsManager();
- });
-
- it('Returns an instance of PluginManager', function() {
- const result = instance.pluginManager;
- assert.equal(result.constructor.name, 'PluginManager');
- });
-
- it('cwd is set', function() {
- const result = instance.pluginManager;
- assert.equal(result.options.cwd, process.env.ARC_THEMES);
- });
-
- it('pluginsPath is set', function() {
- const result = instance.pluginManager;
- assert.equal(result.options.pluginsPath, process.env.ARC_THEMES);
- });
-
- it('Always returns the same instance', () => {
- const i1 = instance.pluginManager;
- const i2 = instance.pluginManager;
- assert.isTrue(i1 === i2);
- });
- });
-
- describe('themeInfo getter', () => {
- let instance;
- beforeEach(() => {
- instance = new ThemePluginsManager();
- });
-
- it('Returns an instance of ThemeInfo', function() {
- const result = instance.themeInfo;
- assert.equal(result.constructor.name, 'ThemeInfo');
- });
-
- it('settingsFile is set', function() {
- const result = instance.themeInfo;
- assert.equal(result.settingsFile, process.env.ARC_THEMES_SETTINGS);
- });
-
- it('Always returns new instance', () => {
- const i1 = instance.themeInfo;
- const i2 = instance.themeInfo;
- assert.isFalse(i1 === i2);
- });
- });
-
- describe('resolvePath()', function() {
- let instance;
- beforeEach(() => {
- instance = new ThemePluginsManager();
- });
-
- it('Reads home path', function() {
- const result = instance.resolvePath('~/test');
- assert.equal(result.indexOf('~/'), -1);
- });
- });
-
- describe('_ensureSymlinkPath()', () => {
- afterEach(() => fs.remove(basePath));
-
- let instance;
- beforeEach(() => {
- instance = new ThemePluginsManager();
- });
-
- it('Creates path to the location', () => {
- const loc = path.join(basePath, 'a', 'b', 'c');
- return instance._ensureSymlinkPath(loc)
- .then(() => fs.pathExists(path.join(basePath, 'a', 'b')))
- .then((exists) => assert.isTrue(exists));
- });
-
- it('Last folder is not created', () => {
- const loc = basePath + '/a/b/c';
- return instance._ensureSymlinkPath(loc)
- .then(() => fs.pathExists(path.join(basePath, 'a', 'b', 'c')))
- .then((exists) => assert.isFalse(exists));
- });
- });
-
- describe('_installLocalPackage()', () => {
- const localPackage = path.join(__dirname, 'local-package');
- afterEach(() => fs.remove(basePath));
-
- let instance;
- beforeEach(() => {
- instance = new ThemePluginsManager();
- });
-
- it('Creates a symlink', () => {
- return instance._installLocalPackage(localPackage)
- .then(() => fs.pathExists(path.join(process.env.ARC_THEMES, 'test-package')))
- .then((exists) => assert.isTrue(exists));
- });
-
- it('Returns package info object', () => {
- return instance._installLocalPackage(localPackage)
- .then((result) => {
- assert.typeOf(result, 'object');
- });
- });
-
- it('Has package name', () => {
- return instance._installLocalPackage(localPackage)
- .then((result) => {
- assert.equal(result.name, 'test-package');
- });
- });
-
- it('isSymlink is set', () => {
- return instance._installLocalPackage(localPackage)
- .then((result) => {
- assert.isTrue(result.isSymlink);
- });
- });
-
- it('version is set', () => {
- return instance._installLocalPackage(localPackage)
- .then((result) => {
- assert.equal(result.version, '0.1.0');
- });
- });
-
- it('location is set', () => {
- return instance._installLocalPackage(localPackage)
- .then((result) => {
- assert.equal(result.location, path.join(process.env.ARC_THEMES, 'test-package'));
- });
- });
-
- it('mainFile is set', () => {
- return instance._installLocalPackage(localPackage)
- .then((result) => {
- assert.equal(result.mainFile, path.join(process.env.ARC_THEMES, 'test-package', 'theme.css'));
- });
- });
- });
-
- describe('_installRemotePackage()', function() {
- afterEach(() => fs.remove(basePath));
-
- const pkgName = 'advanced-rest-client/arc-electron-default-theme';
- const pkgVersion = '2.0.0-preview';
-
- it('Installs GitHub package', function() {
- const instance = new ThemePluginsManager();
- return instance._installRemotePackage(pkgName, pkgVersion)
- .then(() => fs.pathExists(
- path.join(process.env.ARC_THEMES, '@advanced-rest-client', 'arc-electron-default-theme')))
- .then((exists) => assert.isTrue(exists));
- });
-
- it('Returns info object', function() {
- const instance = new ThemePluginsManager();
- return instance._installRemotePackage(pkgName, pkgVersion)
- .then((result) => {
- assert.typeOf(result, 'object');
- assert.equal(result.name, '@advanced-rest-client/arc-electron-default-theme');
- assert.equal(result.version, pkgVersion);
- assert.equal(result.location, path.join(process.env.ARC_THEMES, '@' + pkgName));
- assert.equal(result.mainFile,
- path.join(process.env.ARC_THEMES, '@' + pkgName, 'arc-electron-default-theme.html'));
- });
- });
- });
-
- describe('_createThemeInfo()', () => {
- const pkgName = 'test';
- let instance;
- let info;
- beforeEach(() => {
- instance = new ThemePluginsManager();
- info = {
- name: 'test-name',
- version: 'test-version',
- location: __dirname + '/local-package',
- mainFile: __dirname + '/local-package/theme.css',
- isSymlink: true
- };
- });
-
- it('Eventually returns an object', () => {
- return instance._createThemeInfo(pkgName, info)
- .then((result) => {
- assert.typeOf(result, 'object');
- });
- });
-
- it('_id is set', () => {
- return instance._createThemeInfo(pkgName, info)
- .then((result) => {
- assert.equal(result._id, pkgName);
- });
- });
-
- it('isSymlink is set', () => {
- return instance._createThemeInfo(pkgName, info)
- .then((result) => {
- assert.isTrue(result.isSymlink);
- });
- });
-
- it('name is set', () => {
- return instance._createThemeInfo(pkgName, info)
- .then((result) => {
- assert.equal(result.name, info.name);
- });
- });
-
- it('version is set', () => {
- return instance._createThemeInfo(pkgName, info)
- .then((result) => {
- assert.equal(result.version, info.version);
- });
- });
-
- it('location is set', () => {
- return instance._createThemeInfo(pkgName, info)
- .then((result) => {
- assert.equal(result.location, info.location);
- });
- });
-
- it('mainFile is set', () => {
- return instance._createThemeInfo(pkgName, info)
- .then((result) => {
- assert.equal(result.mainFile, info.mainFile);
- });
- });
-
- it('title is set from the package.json file', () => {
- return instance._createThemeInfo(pkgName, info)
- .then((result) => {
- assert.equal(result.title, 'Test title');
- });
- });
-
- it('description is set from the package.json file', () => {
- return instance._createThemeInfo(pkgName, info)
- .then((result) => {
- assert.equal(result.description, 'Test description');
- });
- });
- });
-
- describe('_addThemeEntry()', () => {
- let instance;
- let info;
- beforeEach(() => {
- instance = new ThemePluginsManager();
- info = {
- _id: 'test-id',
- name: 'test-name',
- version: 'test-version',
- location: __dirname + '/local-package',
- mainFile: __dirname + '/local-package/theme.css'
- };
- });
-
- afterEach(() => fs.remove(basePath));
-
- it('Creates theme registry file', () => {
- return instance._addThemeEntry(info)
- .then(() => fs.pathExists(process.env.ARC_THEMES_SETTINGS))
- .then((exists) => assert.isTrue(exists));
- });
-
- it('Adds info to theme registry file', () => {
- return instance._addThemeEntry(info)
- .then(() => fs.readJson(process.env.ARC_THEMES_SETTINGS))
- .then((data) => {
- assert.typeOf(data, 'object');
- assert.typeOf(data.themes, 'array');
- assert.lengthOf(data.themes, 1);
- });
- });
-
- it('Adds 2 info objects to theme registry file', () => {
- return instance._addThemeEntry(info)
- .then(() => instance._addThemeEntry(info))
- .then(() => fs.readJson(process.env.ARC_THEMES_SETTINGS))
- .then((data) => {
- assert.typeOf(data.themes, 'array');
- assert.lengthOf(data.themes, 2);
- });
- });
- });
-
- describe('uninstall()', () => {
- describe('Local package', () => {
- let instance;
- const localPackage = path.join(__dirname, 'local-package');
- beforeEach(() => {
- instance = new ThemePluginsManager();
- return instance.install(localPackage);
- });
-
- afterEach(() => fs.remove(basePath));
-
- it('Has package installed', () => {
- return fs.pathExists(path.join(process.env.ARC_THEMES, 'test-package'))
- .then((exists) => assert.isTrue(exists));
- });
-
- it('Has entry in theme info file.', () => {
- return fs.pathExists(path.join(process.env.ARC_THEMES, 'themes-info.json'))
- .then((exists) => assert.isTrue(exists));
- });
-
- it('Removes local package', async () => {
- await instance.uninstall(localPackage);
- const exists = await fs.pathExists(path.join(process.env.ARC_THEMES, 'test-package'));
- assert.isFalse(exists);
- });
-
- it('Removes entry from info file.', async () => {
- await instance.uninstall(localPackage);
- const data = await fs.readJson(process.env.ARC_THEMES_SETTINGS);
- assert.typeOf(data.themes, 'array');
- assert.lengthOf(data.themes, 0);
- });
- });
-
- describe('Remote package', () => {
- let instance;
- const pkgName = 'advanced-rest-client/arc-electron-default-theme';
- const pkgVersion = '2.0.0-preview';
- let installedLocation;
-
- before(() => {
- installedLocation = path.join(
- process.env.ARC_THEMES,
- '@advanced-rest-client',
- 'arc-electron-default-theme');
- instance = new ThemePluginsManager();
- return instance.install(pkgName, pkgVersion);
- });
-
- after(() => fs.remove(basePath));
-
- it('Has package installed', () => {
- return fs.pathExists(installedLocation)
- .then((exists) => assert.isTrue(exists));
- });
-
- it('Has entry in theme info file.', () => {
- return fs.pathExists(process.env.ARC_THEMES_SETTINGS)
- .then((exists) => assert.isTrue(exists));
- });
-
- it('Removes remote package', () => {
- return instance.uninstall(pkgName)
- .then(() => fs.pathExists(installedLocation))
- .then((exists) => {
- assert.isFalse(exists);
- });
- });
-
- it('Removes entry from info file.', () => {
- return fs.readJson(path.join(process.env.ARC_THEMES_SETTINGS))
- .then((data) => {
- assert.typeOf(data.themes, 'array');
- assert.lengthOf(data.themes, 0);
- });
- });
- });
- });
-});
diff --git a/test/renderer-setup-environment.js b/test/renderer-setup-environment.js
new file mode 100644
index 00000000..30d8ecac
--- /dev/null
+++ b/test/renderer-setup-environment.js
@@ -0,0 +1,13 @@
+const { app } = require('electron');
+// @ts-ignore
+const _require = require('esm')(module);
+const testPaths = require('./setup-paths');
+
+const { setLevel } = _require('../src/io/Logger');
+
+setLevel('error');
+
+app.on('ready', () => {
+ testPaths.getBasePath();
+ testPaths.setupEnvironment();
+});
diff --git a/test/renderer-setup-paths.js b/test/renderer-setup-paths.js
deleted file mode 100644
index a6309f1e..00000000
--- a/test/renderer-setup-paths.js
+++ /dev/null
@@ -1,2 +0,0 @@
-const testPaths = require('./setup-paths');
-testPaths.getBasePath();
diff --git a/test/scripts/main/app-options.main.spec.js b/test/scripts/main/app-options.main.spec.js
deleted file mode 100644
index 0a1de02a..00000000
--- a/test/scripts/main/app-options.main.spec.js
+++ /dev/null
@@ -1,275 +0,0 @@
-const {assert} = require('chai');
-const {AppOptions} = require('../../../scripts/main/app-options.js');
-
-describe('AppOptions', function() {
- let instance;
-
- describe('availableOptions', function() {
- before(function() {
- instance = new AppOptions();
- });
-
- it('Returns and Array', function() {
- assert.typeOf(instance.availableOptions, 'array');
- });
-
- it('Array is not empty', function() {
- assert.isAbove(instance.availableOptions.length, 1);
- });
-
- it('Properties are set', function() {
- const opts = instance.availableOptions;
- for (let i = 0, len = opts.length; i < len; i++) {
- assert.typeOf(opts[i].name, 'string', 'Name is a string');
- assert.typeOf(opts[i].shortcut, 'string', 'Shortcut is a string');
- assert.typeOf(opts[i].type, 'function', 'Type is set');
- }
- });
- });
-
- describe('parse()', function() {
- let origArgV;
- describe('Defaults', function() {
- before(function() {
- origArgV = process.argv;
- process.argv = [
- '/app/path'
- ];
- instance = new AppOptions();
- instance.parse();
- });
-
- after(function() {
- process.argv = origArgV;
- });
-
- it('Settings file is undefined', function() {
- assert.isUndefined(instance.settingsFile);
- });
-
- it('Workspace file is undefined', function() {
- assert.isUndefined(instance.workspacePath);
- });
-
- it('disableLog is undefined', function() {
- assert.isUndefined(instance.disableLog);
- });
- });
-
- describe('Full options names', function() {
- before(function() {
- origArgV = process.argv;
- process.argv = [
- '/app/path',
- '--settings-file',
- 'settings-file-test',
- '--workspace-path',
- 'workspace-path-test',
- '--debug',
- '--invalid-option',
- 'ivalid-value'
- ];
- instance = new AppOptions();
- instance.parse();
- });
-
- after(function() {
- process.argv = origArgV;
- });
-
- it('Sets settings file', function() {
- assert.equal(instance.settingsFile, 'settings-file-test');
- });
-
- it('Sets workspace file', function() {
- assert.equal(instance.workspacePath, 'workspace-path-test');
- });
-
- it('Sets debug', function() {
- assert.isTrue(instance.debug, 'debug is set');
- });
-
- it('invalidOption is not set', function() {
- assert.isUndefined(instance.invalidOption);
- });
- });
-
- describe('Shortcuts', function() {
- before(function() {
- origArgV = process.argv;
- process.argv = [
- '/app/path',
- '-d',
- '-s',
- 'settings-file-test',
- '-w',
- 'workspace-path-test'
- ];
- instance = new AppOptions();
- instance.parse();
- });
-
- after(function() {
- process.argv = origArgV;
- });
-
- it('Sets settings file', function() {
- assert.equal(instance.settingsFile, 'settings-file-test');
- });
-
- it('Sets workspace file', function() {
- assert.equal(instance.workspacePath, 'workspace-path-test');
- });
-
- it('Sets debug', function() {
- assert.isTrue(instance.debug, 'debug is set');
- });
- });
- });
-
- describe('findDefinnition()', function() {
- before(function() {
- instance = new AppOptions();
- });
-
- it('Finds a definition for full name', function() {
- const name = '--settings-file';
- const result = instance.findDefinnition(name);
- assert.typeOf(result, 'object');
- assert.equal(result.name, name);
- });
-
- it('Finds a definition for shortcut', function() {
- const name = '--settings-file';
- const result = instance.findDefinnition('-s');
- assert.typeOf(result, 'object');
- assert.equal(result.name, name);
- });
-
- it('Returns undefined for unknown name', function() {
- const result = instance.findDefinnition('--non-existing');
- assert.isUndefined(result);
- });
-
- it('Returns undefined for unknown shortcut', function() {
- const result = instance.findDefinnition('-non-existing');
- assert.isUndefined(result);
- });
- });
-
- describe('getPropertyDefinition()', function() {
- const def = {
- type: String,
- name: 'test'
- };
- const argWithValue = 'name="test-value"';
- const arg = 'name';
- before(function() {
- instance = new AppOptions();
- });
-
- it('Parses argument with value', function() {
- const defArg = Object.assign({}, def);
- const result = instance.getPropertyDefinition(argWithValue, defArg, 'other-test');
- assert.isFalse(result.skipNext);
- assert.equal(result.value, 'test-value');
- });
-
- it('Parses argument without value', function() {
- const defArg = Object.assign({}, def);
- const result = instance.getPropertyDefinition(arg, defArg, 'other-test');
- assert.isTrue(result.skipNext);
- assert.equal(result.value, 'other-test');
- });
-
- it('Value is number for numeric types', function() {
- const defArg = Object.assign({}, def);
- defArg.type = Number;
- const result = instance.getPropertyDefinition(arg, defArg, '2');
- assert.isTrue(result.skipNext);
- assert.strictEqual(result.value, 2);
- });
-
- it('Value is a Boolean for Boolean types', function() {
- const defArg = Object.assign({}, def);
- defArg.type = Boolean;
- const result = instance.getPropertyDefinition(arg, defArg);
- assert.isFalse(result.skipNext);
- assert.isTrue(result.value);
- });
- });
-
- describe('getArgValue()', function() {
- before(function() {
- instance = new AppOptions();
- });
-
- it('Returns value with quota', function() {
- const result = instance.getArgValue('name="test"');
- assert.equal(result, 'test');
- });
-
- it('Returns value without quota', function() {
- const result = instance.getArgValue('name=test');
- assert.equal(result, 'test');
- });
-
- it('Returns empty stirng when no value', function() {
- const result = instance.getArgValue('name');
- assert.equal(result, '');
- });
- });
-
- describe('setProperty()', function() {
- const def = {
- value: 'test'
- };
- before(function() {
- instance = new AppOptions();
- });
-
- it('Sets full name property', function() {
- const arg = Object.assign({name: '--my-name-argument'}, def);
- instance.setProperty(arg);
- assert.equal(instance.myNameArgument, 'test');
- });
- });
-
- describe('getOptions()', function() {
- let origArgV;
- before(function() {
- origArgV = process.argv;
- process.argv = [
- '/app/path',
- '--debug',
- '--settings-file',
- 'settings-file-test',
- '--workspace-path',
- 'workspace-path-test'
- ];
- instance = new AppOptions();
- instance.parse();
- });
-
- after(function() {
- process.argv = origArgV;
- });
-
- it('Returns object', function() {
- const result = instance.getOptions();
- assert.typeOf(result, 'object');
- });
-
- it('Object has 3 properties', function() {
- const result = instance.getOptions();
- assert.lengthOf(Object.keys(result), 3);
- });
-
- it('Returns all properties', function() {
- const result = instance.getOptions();
- assert.equal(result.settingsFile, 'settings-file-test');
- assert.equal(result.workspacePath, 'workspace-path-test');
- assert.isTrue(result.debug);
- });
- });
-});
diff --git a/test/scripts/main/window-manager.main.spec.js b/test/scripts/main/window-manager.main.spec.js
deleted file mode 100644
index 34b29dab..00000000
--- a/test/scripts/main/window-manager.main.spec.js
+++ /dev/null
@@ -1,177 +0,0 @@
-const { assert } = require('chai');
-const { ArcWindowsManager } = require('../../../scripts/main/windows-manager.js');
-const { ArcSessionRecorder } = require('../../../scripts/main/arc-session-recorder');
-const { ContextActions } = require('../../../scripts/packages/context-actions/main');
-const { BrowserWindow } = require('electron');
-
-describe('ArcWindowsManager', function() {
- describe('constructor()', function() {
- it('Sets default startupOptions', function() {
- const instance = new ArcWindowsManager();
- assert.typeOf(instance.startupOptions, 'object');
- assert.lengthOf(Object.keys(instance.startupOptions), 0);
- });
-
- it('Sets passed startupOptions', function() {
- const opts = { startPath: 'test' };
- const instance = new ArcWindowsManager(opts);
- assert.deepEqual(instance.startupOptions, opts);
- });
-
- it('Sets windows array', () => {
- const instance = new ArcWindowsManager();
- assert.lengthOf(instance.windows, 0);
- });
-
- it('Sets ArcSessionRecorder', () => {
- const instance = new ArcWindowsManager();
- assert.isTrue(instance.recorder instanceof ArcSessionRecorder);
- });
-
- it('Sets ContextActions', () => {
- const instance = new ArcWindowsManager();
- assert.isTrue(instance.contextActions instanceof ContextActions);
- });
- });
-
- describe('get hasWindow()', () => {
- let instance;
- before(() => {
- instance = new ArcWindowsManager();
- });
-
- it('Returns false when no windows', () => {
- assert.isFalse(instance.hasWindow);
- });
-
- it('Returns true when has a window', () => {
- instance.windows = [{}];
- assert.isTrue(instance.hasWindow);
- });
- });
-
- describe('get lastFocused()', () => {
- let instance;
- before(() => {
- instance = new ArcWindowsManager();
- });
-
- it('Returns null when no focused window', () => {
- assert.equal(instance.lastFocused, null);
- });
-
- it('Returns null when the window has been destroyed', () => {
- instance._lastFocused = {
- isDestroyed: () => true
- };
- assert.equal(instance.lastFocused, null);
- });
-
- it('Returns window instance', () => {
- instance._lastFocused = {
- isDestroyed: () => false
- };
- assert.deepEqual(instance.lastFocused, instance._lastFocused);
- });
- });
-
- describe('get lastActive()', () => {
- let instance;
- before(() => {
- instance = new ArcWindowsManager();
- });
-
- it('Returns null when no windows', () => {
- assert.equal(instance.lastActive, null);
- });
-
- it('Returns null when no active windows', () => {
- instance.windows = [{
- isDestroyed: () => true
- }, {
- isDestroyed: () => true
- }];
- assert.equal(instance.lastActive, null);
- });
-
- it('Returns window instance', () => {
- instance.windows = [{
- isDestroyed: () => true
- }, {
- isDestroyed: () => false
- }];
- assert.deepEqual(instance.lastActive, instance.windows[1]);
- });
- });
-
- describe('open()', () => {
- let instance;
- before(() => {
- instance = new ArcWindowsManager();
- });
-
- it('Returns window instance', () => {
- return instance.open()
- .then((win) => {
- assert.isTrue(win instanceof BrowserWindow);
- win.destroy();
- });
- });
-
- it('Sets __arcSession on the window', () => {
- return instance.open()
- .then((win) => {
- win.destroy();
- assert.ok(win.__arcSession);
- });
- });
-
- it('Sets __arcIndex on the window', () => {
- return instance.open()
- .then((win) => {
- win.destroy();
- assert.equal(win.__arcIndex, 0);
- });
- });
-
- it('Adds window to the list of windows', () => {
- return instance.open()
- .then((win) => {
- assert.notEqual(instance.windows.indexOf(win), -1);
- win.destroy();
- });
- });
-
- it('Removes window from the list when destroyed', () => {
- return instance.open()
- .then((win) => {
- win.destroy();
- assert.equal(instance.windows.indexOf(win), -1);
- });
- });
- });
-
- describe('__getNewWindow()', () => {
- let instance;
- let session;
- before(() => {
- instance = new ArcWindowsManager();
- session = {
- size: {
- width: 100,
- height: 200
- },
- position: {
- x: 10,
- y: 20
- }
- };
- });
-
- it('Creates BrowserWindow instance', () => {
- const result = instance.__getNewWindow(0, session);
- assert.isTrue(result instanceof BrowserWindow);
- result.destroy();
- });
- });
-});
diff --git a/test/setup-paths.js b/test/setup-paths.js
index a00cf69d..56eadef1 100644
--- a/test/setup-paths.js
+++ b/test/setup-paths.js
@@ -1,11 +1,18 @@
-const arcPaths = require('../scripts/main/arc-paths');
const electron = require('electron');
const path = require('path');
+// @ts-ignore
+const _require = require('esm')(module);
+
+const { ApplicationPaths } = _require('../src/io/ApplicationPaths.js');
+const { ArcEnvironment } = _require('../src/io/ArcEnvironment.js');
+const { PreferencesManager } = _require('../src/io/PreferencesManager.js');
+
+const arcPaths = new ApplicationPaths();
let pathsSet = false;
module.exports = {
- getBasePath: function() {
+ getBasePath: () => {
const app = electron.remote ? electron.remote.app : electron.app;
if (pathsSet) {
return app.getPath('userData');
@@ -17,6 +24,16 @@ module.exports = {
arcPaths.setSettingsFile();
arcPaths.setWorkspacePath();
arcPaths.setThemesPath();
+ arcPaths.setStateFile();
return basePath;
+ },
+
+ setupEnvironment() {
+ const prefManager = new PreferencesManager(path.join(__dirname, 'tests-exe-dir', 'test-settings.json'));
+ const env = new ArcEnvironment(prefManager, {});
+ // @ts-ignore
+ global.Arc = env;
+ env.registerHandlers();
+ // await env.loadEnvironment();
}
};
diff --git a/test/test-bootstrap.js b/test/test-bootstrap.js
index be723521..b7e52787 100644
--- a/test/test-bootstrap.js
+++ b/test/test-bootstrap.js
@@ -1,50 +1,52 @@
+/* eslint-disable no-multi-assign */
const path = require('path');
const { Application } = require('spectron');
const electronPath = require('electron');
const fs = require('fs-extra');
-const appPath = path.join(__dirname, '..', 'main.js');
+const appPath = path.join(__dirname, '..', 'src', 'io', 'main.js');
const basePath = path.join('test', 'playground');
-// console.log('App path ', appPath);
+
+/** @typedef {import('spectron').AppConstructorOptions} AppConstructorOptions */
const settingsFilePath = module.exports.settingsFilePath = path.join(basePath, 'settings.json');
const workspaceFilePath = module.exports.workspaceFilePath = path.join(basePath, 'workspace');
const themesFilePath = module.exports.themesFilePath = path.join(basePath, 'themes');
-function getApp(opts) {
- opts = opts || {};
- const options = {
- path: electronPath,
- startTimeout: 50000,
- waitTimeout: 50000,
+function getApp(opts={}) {
+ const options = /** @type AppConstructorOptions */ ({
+ path: /** @type any */ (electronPath),
+ // startTimeout: 5000,
+ // waitTimeout: 5000,
args: [
appPath, '--test'
],
- requireName: 'electronRequire'
- };
+ requireName: 'electronRequire',
+ // chromeDriverLogPath: path.join(__dirname, 'log.log'),
+ });
if (opts.args) {
options.args = options.args.concat(opts.args);
} else {
options.args = options.args.concat([
'--workspace-path', workspaceFilePath,
'--settings-file', settingsFilePath,
- '--themes-path', themesFilePath
+ '--themes-path', themesFilePath,
]);
}
+ // console.log(options);
return new Application(options);
}
function deffer(timeout) {
- return new Promise(function(resolve) {
- setTimeout(function() {
+ return new Promise((resolve) => {
+ setTimeout(() => {
resolve();
}, timeout);
});
}
-async function runAppDeffered(timeout, opts) {
+async function runAppDeferred(timeout=5000, opts) {
const app = getApp(opts);
- timeout = timeout || 5000;
try {
await app.start();
await app.client.waitUntilWindowLoaded(10000);
@@ -58,8 +60,7 @@ async function runAppDeffered(timeout, opts) {
}
}
-async function stopAndClean(app, clearPath) {
- clearPath = clearPath || basePath;
+async function stopAndClean(app, clearPath=basePath) {
if (app && app.isRunning()) {
await app.stop();
}
@@ -67,5 +68,6 @@ async function stopAndClean(app, clearPath) {
}
module.exports.getApp = getApp;
-module.exports.runAppDeffered = runAppDeffered;
+module.exports.runAppDeferred = runAppDeferred;
module.exports.stopAndClean = stopAndClean;
+module.exports.deffer = deffer;
diff --git a/test/workspaces/WorkspaceHistory.main.spec.js b/test/workspaces/WorkspaceHistory.main.spec.js
new file mode 100644
index 00000000..b18c689a
--- /dev/null
+++ b/test/workspaces/WorkspaceHistory.main.spec.js
@@ -0,0 +1,225 @@
+const { assert } = require('chai');
+const path = require('path');
+const fs = require('fs-extra');
+const _require = require('esm')(module);
+const testPaths = require('../setup-paths');
+
+/** @typedef {import('../../src/io/models/WorkspaceHistory').WorkspaceHistory} WorkspaceHistory */
+
+const { WorkspaceHistory } = _require('../../src/io/models/WorkspaceHistory');
+
+describe('WorkspaceHistory model class', () => {
+ const historyPath = path.join('workspace', 'workspace-history.json');
+
+ before(() => {
+ testPaths.getBasePath();
+ });
+
+ describe('Constructor', () => {
+ it('Sets default entries limit', () => {
+ const instance = new WorkspaceHistory();
+ assert.equal(instance.limit, 15);
+ });
+
+ it('Sets limit from the argument', () => {
+ const instance = new WorkspaceHistory(10);
+ assert.equal(instance.limit, 10);
+ });
+
+ it('Sets file path', () => {
+ const instance = new WorkspaceHistory();
+ const result = path.join(process.env.ARC_HOME, historyPath);
+ assert.equal(instance.settingsFile, result);
+ });
+ });
+
+ describe('defaultSettings()', () => {
+ let instance = /** @type WorkspaceHistory */ (null);
+ beforeEach(() => {
+ instance = new WorkspaceHistory();
+ });
+
+ it('returns an object', async () => {
+ const result = await instance.defaultSettings();
+ assert.typeOf(result, 'object');
+ });
+
+ it('has the "kind" property', async () => {
+ const result = await instance.defaultSettings()
+ assert.equal(result.kind, 'ARC#WorkspaceHistory');
+ });
+
+ it('has the "entries" property', async () => {
+ const result = await instance.defaultSettings()
+ assert.typeOf(result.entries, 'array');
+ });
+
+ it('has empty "entries" property', async () => {
+ const result = await instance.defaultSettings()
+ assert.lengthOf(result.entries, 0);
+ });
+ });
+
+ describe('sortEntries()', () => {
+ let instance = /** @type WorkspaceHistory */ (null);
+ beforeEach(() => {
+ instance = new WorkspaceHistory();
+ });
+
+ it('returns 1 when a is older', () => {
+ const a = { used: 1, file: 'a' };
+ const b = { used: 2, file: 'a' };
+ const result = instance.sortEntries(a, b);
+ assert.equal(result, 1);
+ });
+
+ it('returns -1 when a is younger', () => {
+ const a = { used: 2, file: 'a' };
+ const b = { used: 1, file: 'a' };
+ const result = instance.sortEntries(a, b);
+ assert.equal(result, -1);
+ });
+
+ it('returns 0 when equal', () => {
+ const a = { used: 1, file: 'a' };
+ const b = { used: 1, file: 'a' };
+ const result = instance.sortEntries(a, b);
+ assert.equal(result, 0);
+ });
+ });
+
+ describe('sortEntries()', () => {
+ let instance = /** @type WorkspaceHistory */ (null);
+ beforeEach(() => {
+ instance = new WorkspaceHistory();
+ });
+
+ afterEach(() => {
+ const file = path.join(process.env.ARC_HOME, historyPath);
+ return fs.remove(file);
+ });
+
+ it('returns undefined when no array items', async () => {
+ const result = await instance.loadEntries()
+ assert.isUndefined(result);
+ });
+
+ it('returns undefined when load function do not return data', async () => {
+ instance.load = async () => undefined;
+ const result = await instance.loadEntries()
+ assert.isUndefined(result);
+ });
+
+ it('returns undefined when no entires array', async () => {
+ instance.load = async () => ({ kind: 'ARC#WorkspaceHistory', entries: undefined });
+ const result = await instance.loadEntries()
+ assert.isUndefined(result);
+ });
+
+ it('returns undefined when entires is not an array', async () => {
+ // @ts-ignore
+ instance.load = async () => ({ kind: 'ARC#WorkspaceHistory', entries: {} });
+ const result = await instance.loadEntries()
+ assert.isUndefined(result);
+ });
+
+ it('returns list of entires', async () => {
+ const entries = [{ used: 1, file: 'test' }];
+ instance.load = async () => ({ kind: 'ARC#WorkspaceHistory', entries });
+ const result = await instance.loadEntries()
+ assert.deepEqual(result, entries);
+ });
+ });
+
+ describe('addEntry()', () => {
+ let instance = /** @type WorkspaceHistory */ (null);
+ beforeEach(() => {
+ instance = new WorkspaceHistory();
+ });
+
+ afterEach(() => {
+ const file = path.join(process.env.ARC_HOME, historyPath);
+ return fs.remove(file);
+ });
+
+ it('rejects when no argument', async () => {
+ let called = false;
+ try {
+ await instance.addEntry(undefined);
+ } catch (e) {
+ called = true;
+ }
+ assert.isTrue(called);
+ });
+
+ it('adds a new entry', async () => {
+ await instance.addEntry('/test');
+ const file = path.join(process.env.ARC_HOME, historyPath);
+ const data = await fs.readJson(file);
+ assert.lengthOf(data.entries, 1, 'Has an entry');
+ assert.equal(data.entries[0].file, '/test', 'Entry has file');
+ assert.typeOf(data.entries[0].used, 'number', 'Entry has used');
+ });
+
+ it('updates existing entry', async () => {
+ const file = path.join(process.env.ARC_HOME, historyPath);
+ await fs.outputJson(file, {
+ entries: [{
+ file: '/test',
+ used: 1
+ }]
+ });
+ await instance.addEntry('/test');
+ const data = await fs.readJson(file);
+ assert.typeOf(data.entries[0].used, 'number', 'Entry has used');
+ assert.notEqual(data.entries[0].used, 1, 'Entry used time is updated');
+ });
+
+ it('limits number of entries', async () => {
+ const file = path.join(process.env.ARC_HOME, historyPath);
+ instance.limit = 2;
+ await fs.outputJson(file, {
+ entries: [{
+ file: '/1',
+ used: 1
+ }, {
+ file: '/2',
+ used: 2
+ }]
+ });
+ await instance.addEntry('/3');
+ const data = await fs.readJson(file);
+ assert.equal(data.entries[0].file, '/3', 'New Entry added');
+ assert.equal(data.entries[1].file, '/2', 'Youngest entry stays');
+ assert.lengthOf(data.entries, 2, 'Oldest entry is removed');
+ });
+ });
+
+ describe('clearHistory()', () => {
+ let instance = /** @type WorkspaceHistory */ (null);
+ beforeEach(() => {
+ instance = new WorkspaceHistory();
+ });
+
+ afterEach(() => {
+ const file = path.join(process.env.ARC_HOME, historyPath);
+ return fs.remove(file);
+ });
+
+ it('clears entries', async () => {
+ const file = path.join(process.env.ARC_HOME, historyPath);
+ await fs.outputJson(file, {
+ entries: [{
+ file: '/1',
+ used: 1
+ }, {
+ file: '/2',
+ used: 2
+ }]
+ })
+ await instance.clearHistory();
+ const data = await fs.readJson(file);
+ assert.lengthOf(data.entries, 0);
+ });
+ });
+});
diff --git a/test/workspaces/workspace-history-model.main.spec.js b/test/workspaces/workspace-history-model.main.spec.js
deleted file mode 100644
index c10dd9dc..00000000
--- a/test/workspaces/workspace-history-model.main.spec.js
+++ /dev/null
@@ -1,273 +0,0 @@
-const { WorkspaceHistory } = require('../../scripts/main/models/workspace-history');
-const { assert } = require('chai');
-const path = require('path');
-const fs = require('fs-extra');
-
-describe('WorkspaceHistory model class', function() {
- const historyPath = path.join('workspace', 'workspace-history.json');
- describe('Constructor', function() {
- it('Sets default entries limit', function() {
- const instance = new WorkspaceHistory();
- assert.equal(instance.limit, 15);
- });
-
- it('Sets limit from the argument', function() {
- const instance = new WorkspaceHistory(10);
- assert.equal(instance.limit, 10);
- });
-
- it('Sets file path', () => {
- const instance = new WorkspaceHistory();
- const result = path.join(process.env.ARC_HOME, historyPath);
- assert.equal(instance.settingsFile, result);
- });
- });
-
- describe('defaultSettings()', () => {
- let instance;
- beforeEach(() => {
- instance = new WorkspaceHistory();
- });
-
- it('Returns a promise', () => {
- const result = instance.defaultSettings();
- assert.typeOf(result, 'promise');
- });
-
- it('Promise resolves to an object', () => {
- return instance.defaultSettings()
- .then((result) => {
- assert.typeOf(result, 'object');
- });
- });
-
- it('Object has kind property', () => {
- return instance.defaultSettings()
- .then((result) => {
- assert.equal(result.kind, 'ARC#WorkspaceHistory');
- });
- });
-
- it('Object has entries property', () => {
- return instance.defaultSettings()
- .then((result) => {
- assert.typeOf(result.entries, 'array');
- });
- });
-
- it('Entries property is empty', () => {
- return instance.defaultSettings()
- .then((result) => {
- assert.lengthOf(result.entries, 0);
- });
- });
- });
-
- describe('sortEntries()', () => {
- let instance;
- beforeEach(() => {
- instance = new WorkspaceHistory();
- });
-
- it('Returns 1 when a is older', () => {
- const a = { used: 1 };
- const b = { used: 2 };
- const result = instance.sortEntries(a, b);
- assert.equal(result, 1);
- });
-
- it('Returns -1 when a is yonger', () => {
- const a = { used: 2 };
- const b = { used: 1 };
- const result = instance.sortEntries(a, b);
- assert.equal(result, -1);
- });
-
- it('Returns 0 when equal', () => {
- const a = { used: 1 };
- const b = { used: 1 };
- const result = instance.sortEntries(a, b);
- assert.equal(result, 0);
- });
- });
-
- describe('sortEntries()', () => {
- let instance;
- beforeEach(() => {
- instance = new WorkspaceHistory();
- });
-
- afterEach(() => {
- const file = path.join(process.env.ARC_HOME, historyPath);
- return fs.remove(file);
- });
-
- it('Returns a promise', () => {
- const result = instance.loadEntries();
- assert.typeOf(result, 'promise');
- return result;
- });
-
- it('Returns undefined when no array items', () => {
- return instance.loadEntries()
- .then((result) => {
- assert.isUndefined(result);
- });
- });
-
- it('Returns undefined when load function do not return data', () => {
- instance.load = () => Promise.resolve();
- return instance.loadEntries()
- .then((result) => {
- assert.isUndefined(result);
- });
- });
-
- it('Returns undefined when no entires array', () => {
- instance.load = () => Promise.resolve({});
- return instance.loadEntries()
- .then((result) => {
- assert.isUndefined(result);
- });
- });
-
- it('Returns undefined when entires is not an array', () => {
- instance.load = () => Promise.resolve({ entries: {} });
- return instance.loadEntries()
- .then((result) => {
- assert.isUndefined(result);
- });
- });
-
- it('Returns list of entires', () => {
- const entries = [{ used: 1, file: 'test' }];
- instance.load = () => Promise.resolve({ entries });
- return instance.loadEntries()
- .then((result) => {
- assert.deepEqual(result, entries);
- });
- });
- });
-
- describe('addEntry()', () => {
- let instance;
- beforeEach(() => {
- instance = new WorkspaceHistory();
- });
-
- afterEach(() => {
- const file = path.join(process.env.ARC_HOME, historyPath);
- return fs.remove(file);
- });
-
- it('Rejects when no argument', (done) => {
- const result = instance.addEntry();
- result.then(() => {
- throw new Error('Should not resolve');
- })
- .catch((cause) => {
- assert.notEqual(cause.message, 'Should not resolve');
- done();
- });
- });
-
- it('Adds a new entry', () => {
- return instance.addEntry('/test')
- .then(() => {
- const file = path.join(process.env.ARC_HOME, historyPath);
- return fs.readJson(file);
- })
- .then((data) => {
- assert.lengthOf(data.entries, 1, 'Has an entry');
- assert.equal(data.entries[0].file, '/test', 'Entry has file');
- assert.typeOf(data.entries[0].used, 'number', 'Entry has used');
- });
- });
-
- it('Updates existing entry', () => {
- const file = path.join(process.env.ARC_HOME, historyPath);
- return fs.outputJson(file, {
- entries: [{
- file: '/test',
- used: 1
- }]
- })
- .then(() => instance.addEntry('/test'))
- .then(() => fs.readJson(file))
- .then((data) => {
- assert.typeOf(data.entries[0].used, 'number', 'Entry has used');
- assert.notEqual(data.entries[0].used, 1, 'Entry used time is updated');
- });
- });
-
- it('Limits number of entries', () => {
- const file = path.join(process.env.ARC_HOME, historyPath);
- instance.limit = 2;
- return fs.outputJson(file, {
- entries: [{
- file: '/1',
- used: 1
- }, {
- file: '/2',
- used: 2
- }]
- })
- .then(() => instance.addEntry('/3'))
- .then(() => fs.readJson(file))
- .then((data) => {
- assert.equal(data.entries[0].file, '/3', 'New Entry added');
- assert.equal(data.entries[1].file, '/2', 'Yongest entry stays');
- assert.lengthOf(data.entries, 2, 'Oldest entry is removed');
- });
- });
- });
-
- describe('clearHistory()', () => {
- let instance;
- beforeEach(() => {
- instance = new WorkspaceHistory();
- });
-
- afterEach(() => {
- const file = path.join(process.env.ARC_HOME, historyPath);
- return fs.remove(file);
- });
-
- it('Clears entries', () => {
- const file = path.join(process.env.ARC_HOME, historyPath);
- return fs.outputJson(file, {
- entries: [{
- file: '/1',
- used: 1
- }, {
- file: '/2',
- used: 2
- }]
- })
- .then(() => instance.clearHistory())
- .then(() => fs.readJson(file))
- .then((data) => {
- assert.lengthOf(data.entries, 0);
- });
- });
-
- it('Creates entries when no data', () => {
- instance.load = () => Promise.resolve();
- const file = path.join(process.env.ARC_HOME, historyPath);
- return fs.outputJson(file, {
- entries: [{
- file: '/1',
- used: 1
- }, {
- file: '/2',
- used: 2
- }]
- })
- .then(() => instance.clearHistory())
- .then(() => fs.readJson(file))
- .then((data) => {
- assert.lengthOf(data.entries, 0);
- });
- });
- });
-});
diff --git a/tsconfig.json b/tsconfig.json
new file mode 100644
index 00000000..c16d1f30
--- /dev/null
+++ b/tsconfig.json
@@ -0,0 +1,24 @@
+{
+ "compilerOptions": {
+ "target": "esnext",
+ "module": "esnext",
+ "moduleResolution": "node",
+ "lib": ["es2017", "dom"],
+ "allowJs": true,
+ "checkJs": true,
+ "noEmit": true,
+ "strict": false,
+ "noImplicitThis": true,
+ "alwaysStrict": true,
+ "esModuleInterop": true,
+ "plugins": [
+ {
+ "name": "typescript-lit-html-plugin"
+ }
+ ]
+ },
+ "include": ["**/*.js","node_modules/@open-wc/**/*.js", "types.d.ts"],
+ "exclude": [
+ "node_modules/!(@open-wc)"
+ ]
+}
diff --git a/types.d.ts b/types.d.ts
new file mode 100644
index 00000000..580b294b
--- /dev/null
+++ b/types.d.ts
@@ -0,0 +1,54 @@
+import { ElectronRequest as ElectronRequestBase, SocketRequest as SocketRequestBase } from "@advanced-rest-client/electron-request";
+import { OAuth2Handler as OAuth2HandlerBase } from "@advanced-rest-client/electron-oauth2/renderer/OAuth2Handler";
+import { ElectronAmfService as ElectronAmfServiceBase } from "@advanced-rest-client/electron-amf-service";
+import { Clipboard, IpcRenderer } from "electron";
+import { CookieBridge as CookieBridgeBase } from "./src/preload/CookieBridge";
+import { EncryptionService as EncryptionServiceBase } from "./src/preload/EncryptionService";
+import { ThemeManager as ThemeManagerBase } from "./src/preload/ThemeManager";
+import { WorkspaceManager as WorkspaceManagerBase } from "./src/preload/WorkspaceManager";
+import { WindowProxy as WindowProxyBase } from "./src/preload/WindowProxy";
+import { PreferencesProxy as PreferencesProxyBase } from "./src/preload/PreferencesProxy";
+import { ImportFilePreProcessor as ImportFilePreProcessorBase } from "./src/preload/ImportFilePreProcessor";
+import { FilesystemProxy as FilesystemProxyBase } from "./src/preload/FilesystemProxy";
+import { ApplicationSearchProxy as ApplicationSearchProxyBase } from "./src/preload/ApplicationSearchProxy";
+import { AppStateProxy as AppStateProxyBase } from "./src/preload/AppStateProxy";
+import { GoogleDriveProxy as GoogleDriveProxyBase } from "./src/preload/GoogleDriveProxy";
+import { GoogleAnalytics as GoogleAnalyticsBase } from "./src/preload/GoogleAnalytics";
+import logger from "electron-log";
+
+// declare global {
+// interface Global {
+// ipc: IpcRenderer;
+// }
+// }
+interface Window {
+ ipc: IpcRenderer;
+}
+
+declare interface AppVersionInfo {
+ chrome: string;
+ appVersion: string;
+}
+
+declare global {
+ var ipc: IpcRenderer;
+ var clipboard: Clipboard;
+ var logger: logger.ElectronLog;
+ var versionInfo: AppVersionInfo;
+ class AppStateProxy extends AppStateProxyBase {}
+ class WorkspaceManager extends WorkspaceManagerBase {}
+ class EncryptionService extends EncryptionServiceBase {}
+ class ThemeManager extends ThemeManagerBase {}
+ class ElectronRequest extends ElectronRequestBase {}
+ class SocketRequest extends SocketRequestBase {}
+ class CookieBridge extends CookieBridgeBase {}
+ class WindowManagerProxy extends WindowProxyBase {}
+ class PreferencesProxy extends PreferencesProxyBase {}
+ class OAuth2Handler extends OAuth2HandlerBase {}
+ class ImportFilePreProcessor extends ImportFilePreProcessorBase {}
+ class FilesystemProxy extends FilesystemProxyBase {}
+ class ApplicationSearchProxy extends ApplicationSearchProxyBase {}
+ class GoogleDriveProxy extends GoogleDriveProxyBase {}
+ class ElectronAmfService extends ElectronAmfServiceBase {}
+ class GoogleAnalytics extends GoogleAnalyticsBase {}
+}
diff --git a/using-arc/cookies-and-session-management.md b/using-arc/cookies-and-session-management.md
deleted file mode 100644
index 6bd3ed03..00000000
--- a/using-arc/cookies-and-session-management.md
+++ /dev/null
@@ -1,65 +0,0 @@
----
-description: >-
- Cookies are important part of session mechanism in the web and when working
- with APIs. This section describes how to use cookie manager to authenticate
- the request using cookies.
----
-
-# Cookies and session management
-
-{% hint style="warning" %}
-When possible, use other means to authenticate a request like Bearer token with JWT.
-{% endhint %}
-
-Advanced REST Client emulates browser behavior when it comes to handling cookies. When a `set-cookie` header is received as a response to an API call then the value of the cookie is processed according to [HTTP State Management Mechanism](https://tools.ietf.org/html/rfc6265) specification. When a request is made to the cookie domain after the cookie was received it is automatically added to the request.
-
-{% hint style="info" %}
-The "set-cookie" header tells the client \(web browser, ARC\) that the server requests to store some data on the client. This data should be then send back with any following request that matches set domain and path.
-{% endhint %}
-
-ARC is web based application and it has a browser included in it. To leverage this ARC allows you to open a Chromium browser window \(it is open source version of Chrome\), log in to a web service, and store received this way cookies into ARC storage. The window opened in ARC has a separate storage and session management than any other ARC window \(main application, menu popup window, task manager, and so on\). This way you can securely authenticate in the window and only incoming cookies are sent back to the application ignoring any other stored values.
-
-## Authenticating to a web service
-
-To obtain and store cookies by logging in to a web service using a browser window select Request > Web Session > Login to a web service menu option. This opens an URL input where you can put the login page URL.
-
-
-
-In this example we will use MuleSoft's Anypoint platform login scheme. The login page is accessible under `https://anypoint.mulesoft.com` URL.
-
-
-
-After successful login a regular page is rendered.
-
-
-
-Now the login window can be be closed. All cookies sent by the authorization server are now synchronized with ARC's cookies manager. You can see the cookies by selecting Request > Web session > Cookie manager menu option.
-
-
-
-When a request to matching domain is executed the cookies are automatically added to the request.
-
-
-
-## Creating cookies manually
-
-In Cookie manager \(Request > Web session > Cookie manager\) you have an option to create a cookie manually or to edit existing cookie. I am going to create a new cookie that is going to be set to a request send to `domain.com.`
-
-
-
-After saving the cookie a new entry is added to the list of cookies.
-
-
-
-You can preview cookie details or edit the cookie after pressing "details" button next to cookie name.
-
-
-
-After a cookie is set it will be automatically added to a request that matches the domain `domain.com`.
-
-
-
-{% hint style="info" %}
-Because the cookie was created with dot "." in front of the cookie domain, the cookie is applied to all requests sent to the domain and all its subdomains. This means the request to domain `http://www.domain.com` will also have the cookie applied to it.
-{% endhint %}
-
diff --git a/using-arc/environments-and-variables.md b/using-arc/environments-and-variables.md
deleted file mode 100644
index bdcde3e6..00000000
--- a/using-arc/environments-and-variables.md
+++ /dev/null
@@ -1,106 +0,0 @@
----
-description: >-
- This guide shows how to use environments and variables in Advanced REST
- Client.
----
-
-# Environments and variables
-
-## Variables overview
-
-Variables are used in all request fields \(method, URL, headers, body\) and allow to define a value in a global scope that is inserted in place when making a request.
-
-Environments are the way of organizing variables into a namespace. It allows to switch between different sets of variables. It can be used to define variables for different context like staging and production.
-
-Let's say you have "production" and "stage" environments for your API. Both are using different authorization keys. Environments and variables are made to manage situation like this. Let's say you API support `x-client-id` header with some value that is used to recognize the client. Because of the separation of the environments you have to use different keys for both environments. To deal with this create two environments for "production" and "stage" and create `apiClientId` variable with corresponding values. You can use the variable as `${apiClientId}` in the headers editor as a value. The value is automatically added to the headers before sending the request to the server.
-
-## Listing variables
-
-Advanced REST Client lists your application variables created for current environment and system variables available on your machine. You can use both keys to insert it into a request.
-
-
-
-To protect your data variables are masked by default. You can toggle visibility of the values using the button at the bottom of the variables list.
-
-{% hint style="success" %}
-You can disable application or system variables in application settings.
-{% endhint %}
-
-When switching the environment in the top toolbar you will switch between different application variables defined for this environment. System variables cannot be changed.
-
-
-
-## Editing variables
-
-To add a new environment first click on "Edit variables" to open variables editor.
-
-
-
-Then "Add" next to environment selector. It then renders a text field where you can enter new environment name. There are no limitation for environment name.
-
-
-
-When the environment is saved then you can define variables for it.
-
-
-
-You can disable a variable by toggling it on the left-hand side of the input field.
-
-{% hint style="danger" %}
-Variable name must start with a letter and only contain letters and numbers. Special characters or national accents are not supported.
-{% endhint %}
-
-{% hint style="warning" %}
-Variable value is always visible in the editor mode.
-{% endhint %}
-
-{% hint style="success" %}
-Variable value can be any value, even another variable.
-{% endhint %}
-
-You can repeat this steps as many times you need for each of your environments. After your variables are defined you can use them in the editors.
-
-## Applying variables
-
-To apply a variable simply as `${` before variable name and `}` after it.
-
-
-
-The value is applied to the header just before sending the request
-
-
-
-You can put a variable into a method, URL, headers, or payload field. Variables can be used as many times as you need in a request.
-
-## Composite variables
-
-Variable's value can use another variable. This variables makes it easier to build variables that requires values from multiple sources.
-
-As an example, basic authorization requires both username and password. It might be difficult to maintain credentials in multiple requests. It's a better idea to store both the username and the password as a separate variables and create new one that combines both with some additional value.
-
-
-
-As a result the combined value is used with the request.
-
-
-
-## Functions in variables
-
-You can use one of the predefined functions in your variables. The ARC's engine support various String, Math, and other functions. To run a function editor press a pencil icon next to variable value text field. It brings editor popup with available options with configuration.
-
-
-
-It uses JavaScript envine to evaluate the value. We will use a `slice` function from `String` class to demonstrate the principle. The `slice` function accepts two arguments start and end, and returns a string that contains characters found between start index and end index. We are going to "slice" our `${username}` variable to get a string from position 1 to 3. We would use the following syntax: `String.slice(${username}, 1, 3)` where the first argument is the string we are operating on and other arguments are arguments passed to the JavaScript function.
-
-In a programming world this would JavaScript would evaluate: `"uname".slice(1, 3)` which in result returns `na`.
-
-
-
-### Function execution group
-
-ARC support few additional functions. They are defined in miscellaneous tab. The the moment you can choose between `now` `random` `decodeURIComponent` and `encodeURIComponent` functions.
-
-Now and random functions support grouping that allows you to generate a value once when making a request and to reuse generated value again using the same group name. Pass a value to either of the functions as an argument and re-use the same function call more than once to recol generated value.
-
-
-
diff --git a/using-arc/host-rules.md b/using-arc/host-rules.md
deleted file mode 100644
index 51d2d3a9..00000000
--- a/using-arc/host-rules.md
+++ /dev/null
@@ -1,66 +0,0 @@
----
-description: This page describes how to use host rules in Advanced REST Client
----
-
-# Host rules
-
-## What are the host rules?
-
-Host rules assist your operating system to map a host name to an IP address. Historically it was used in first computers before first DNS \(Domain Naming System\) was created to tell the system what is the IP address of the remote machine while having it's name only. Today it is primarily used to alter host - IP address mapping to something different than DNS tells or to create a mapping that DNS is not aware of.
-
-## Why would you need it in ARC?
-
-While developing a web server or an API often the server is run locally or in local network. In most cases IP address, that is well known to you, is enough to run a request. However sometimes you need to test a configuration that depends on the value of `host` header. This is quite common for servers that are hosting several virtual hosts.
-
-Technically you can manually set the URL to an IP address and then put `host` header in the headers editor to test for virtual hosts. Other option is to alter system's `hosts` file to create a mapping but this usually requires administrative privileges. In ARC, however, recommended way of doing this is to define own hosts rules that maps parts of your URL to some other value, but keeps the original URL to generate a host header when connecting to a server.
-
-When you define a rule and the rule matches the URL of currently executed request, the URL that is used to make a connection is replaced by the mapping value. This way, say, instead of connecting to `host.com` you would be connecting to `127.0.0` \(local host\). However, when the HTTP message is constructed, the original URL value is used to set a value for `host` header which in this example will be `host: host.com`
-
-## Defining rules
-
-From the menu Request select Hosts. A host rules mapping screen appears. Click on the add button \(right bottom corner of the screen\) to add new entry.
-
-
-
-In the `from` filed enter the part of the URL that should be replaced with another value. It doesn't have to be a host name only. It can be a full URL or a part of it.
-
-
-
-In this example the rules mapping maps `https://hosts.com` to `http://127.0.0.1`. Notice that we are not only changing the host but also the scheme.
-
-Now you can test whether the mapping meets your expectations by running a request URL through rules tester.
-
-
-
-We are testing `https://host.com/index.html` URL against defined rules. The result shows that expected result is `http://127.0.0.1/index.html`.
-
-Now, we can run a request that uses `host.com` in the URL and the connection is made to the local host.
-
-
-
-Even though the request URL contains non-existing URL the request returned data from my locally run server.
-
-{% hint style="info" %}
-All rules are evaluated in order from the first one to the last one. Already altered URL can be altered again by another rule.
-{% endhint %}
-
-## Examples
-
-### Host only mapping
-
-From: `212.77.100.101` To: `127.0.0.1`
-
-This will result with translating the following URL `https://212.77.100.101/index.html` into `https://127.0.0.1/index.html`.
-
-### URI mapping
-
-From: `http://domain.com/api` To: `http://127.0.0.1:8081`
-
-This will result with translating the following URL `http://domain.com/api/endpoint/?query=something` into `https://127.0.0.1:8081/endpoint/?query=something`.
-
-### With asterisk
-
-From: `http://212.77.100.101/*/` To: `http://localhost/path/to/endpoint/`
-
-This will result with translating the following URL `http://212.77.100.101/api/whathever/here/test?query=something` into `http://localhost/path/to/endpoint/test?query=something`.
-
diff --git a/using-arc/request-actions.md b/using-arc/request-actions.md
deleted file mode 100644
index 826dbc5e..00000000
--- a/using-arc/request-actions.md
+++ /dev/null
@@ -1,177 +0,0 @@
----
-description: >-
- This documentation explain what is and how to use request actions in Advanced
- REST Client.
----
-
-# Request actions
-
-Create request actions to dynamically assign variables when the response from the endpoint is ready. ARC gives you convenient editor to create actions that are performed each time the request is send.
-
-Actions can be conditional. Create a condition rule for the request action and the action is performed only if all conditions are meet.
-
-This help page is to describe in details how to use request actions and conditions.
-
-
-
-There are two groups of actions that can be performed during the request
-
-* request actions - executed before the connection is made
-* response actions - executed when response is ready
-
-## Request actions
-
-Currently request action only allows you to set a value on a variable before the request is made. This value is not stored in the data store bur rather in memory only. This means when you restart the application the variable value will be restored to it's original value.
-
-
-
-In this example a `myAccessToken` variable is set to empty string before the request is executed.
-
-## Response action
-
-Response actions are more complex as they are made to extract data from the response and assign the value to a variable or store the variable in the data store.
-
-The data can be extracted from each part of the request/response parts of the HTTP message: URL, headers, status line, and the payload.
-
-### Extracting the data from the response
-
-You need to tell the application where to look for the data that you want to extract from the response. In the editor you can select either `Request` or `Response` as a main data source. In both cases the rest of the configuration is the same but it uses either request or response values.
-
-Next step is to define what type of data the application should query for the value. It can be `Url`, `Status code`, `Headers` or `Body`.
-
-Except for status code you should also define path to the data. Depending on selected type you can use different paths.
-
-#### Path to the data
-
-**URL**
-
-If you not specify path the application will use the whole URL of the last response \(it can be more than one response if there was redirection\). You can specify following paths for `url`:
-
-* host - Returns the host value, e.g. `api.domain.com`
-* `protocol` - Returns URL's protocol, e.g. `https:`
-* `path` - URL's path, e.g. `/path/to/resource.json`
-* `query` - Returns full query string, e.g. `version=1&page=test`
-* `query.[any string]` - Returns the value of a query parameter. For `query.version` it would return `1`and for `query.page` the value will be `test`.
-* `hash` - Returns everything that is after the `#` character, e.g. `access_token=token&state=A6RT7W`
-* `hast.[any string]` - It treats hash as query parameters and returns the value of the parameter. For `hash.access_token` it would return `token`
-
-**Example for URL type**
-
-`https://auth.domain.com/auth/oauth-popup?version=2&remember=true#access_token=z8a1d97c-c4e6-488f-8ac0-a32e3d749f49&token_type=bearer&state=Y2I1CD`
-
-```javascript
-path = 'host' // auth.domain.com
-path = 'protocol' // https:
-path = 'path' // /auth/oauth-popup
-path = 'query' // version=2&remember=true
-path = 'query.version' // 2 (String!)
-path = 'hash' // access_token=z8a1d97c-c4e6-488f-8ac0-a32e3d749f49&token_type=bearer&state=Y2I1CD
-path = 'hash.access_token' // z8a1d97c-c4e6-488f-8ac0-a32e3d749f49
-```
-
-**Headers**
-
-Set header name as a path and the value of the header will be extracted from request or response.
-
-**Example for headers**
-
-```http
-Content-Type: application/json
-Content-Length: 100
-Connection: close
-```
-
-```javascript
-path = 'content-type' // application/json
-path = 'Content-length' // 100 (String!)
-path = 'Connection' // close
-```
-
-**Body**
-
-Currently only **JSON** and **XML** responses are supported. Also, XML has to be valid XML string or the parser will not produce the value.
-
-For JSON types simply specify path to the data. To access array value use dot with index notation, for example `data.0.name`. This will get value from `name` from first item of the `data` array.
-
-**Example for JSON**
-
-```javascript
-{
- property: {
- otherProperty: {
- value: 123456
- }
- }
-}
-path = 'property.otherProperty.value' // 123456
-```
-
-**Example for JSON array**
-
-```javascript
-{
- "data": [{
- "name": "a"
- }, {
- "name": "b"
- }]
-}
-path = 'data.1.name' // b
-```
-
-**XML**
-
-Similar for XML:
-
-```javascript
-const xml = `
-
-
- 202-456-1111
-
- `
-path = 'people.person.0.phoneNumber' // 202-456-1111
-```
-
-**Accessing XML attribute value**
-
-XML path supports attr\(ATTRIBUTE NAME\) function that returns the value of the attribute:
-
-```text
-path = 'people.person.0.name.attr(first)' // george
-```
-
-### Defining the resulting action
-
-When `path` is set you can define two actions to be performed on the data. You can either permanently `Store variable` in application internal database or `Assign variable` temporarily until you restart the application. Last item is to define variable name that will be updated with the value.
-
-
-
-## Conditions
-
-
-
-You can add a condition to the action so the action will be executed if all defined conditions are meet.
-
-To add a condition to the action click on `Add condition` button. Source, Type and Path to data works the same way as in Action editor.
-
-After you define source of the data then choose operator to be used to compare the data. It can be one of:
-
-* equal
-* not-equal
-* greater-than
-* greater-than-equal
-* less-than
-* less-than-equal
-* contains
-
-Contains can operate on strings, whole headers object \(contains "content-type"\) and on JSON objects \(contains "property"\).
-
-Last field to set up is `Condition value` which is used to compare the data.
-
-## Further reading
-
-See our guide to [authorize the application with OAuth 2 and request actions](../guides/authenticating-with-oauth2-and-request-actions.md).
-
diff --git a/using-arc/searching-for-a-request.md b/using-arc/searching-for-a-request.md
deleted file mode 100644
index 1ecda0f8..00000000
--- a/using-arc/searching-for-a-request.md
+++ /dev/null
@@ -1,49 +0,0 @@
----
-description: >-
- Internally Advanced REST Client is using IndexedDB, a web standard of storing
- a data in client application. This comes with some limitations. This page
- describes search capabilities in the application
----
-
-# Searching for a request
-
-In general a request is stored in the data store as **History object** and **Saved object**.
-
-History object is created when history is not disabled in settings and every time you run a request in the workspace. A history entry is created for a combination of an URL and a method. Only one entry a day for the combination is created. This means that if you run the same request multiple time during the day only one entry is created and it reflects the last state after running the request. The history object does not recognize changes to headers or payload. It is always the last sent values.
-
-Saved object is generated when you press CTRL/CMD + S \(or File > Save\) and explicitly save a request to saved store. The difference between history and saved request is that the saved request have a name, description, and can be added to a project.
-
-Both types are stored in separate data stores. This means that when performing a search you are defining the type of a request you are searching for.
-
-## Search UI
-
-To search for a request go to history or saved screen. You can access it from the application menu:
-
-
-
-In the requests list screen \(for either history or saved\) there is a search text field that you can use to input your query.
-
-
-
-The search is performed on the following fields:
-
-* name \(saved request\)
-* headers
-* payload
-* url
-* method
-
-For name, headers, payload, and method is compares whole words. This means that for name "my saved request" the search will find the request for query like "my" or "request" but not "save".
-
-The URL is treated slightly different. Each URL is processed to produce few meaningful values that can help while searching for an endpoint. In normal circumstances you would have to provide the full URL to find a request which is not what anyone would expect. When an URL is stored it is stored as:
-
-* host, path, and search part of the URL, eg. `https://domain.com/path?param=value`
-* path and search part of the URL, eg. `path?param=value`
-* search parameters, each entry for each parameter, eg. `param=value`
-
-When searching for an URL each of this fields is queried for the data. IndexedDb does not support full search queries. ARC implements an algorithm that iterates over keys and compares compares whether an URL contains search phrase. This way it is a good compromise between functionality and performance.
-
-
-
-If you are more technical, you can check how searching is implemented in [url-indexer](https://github.com/advanced-rest-client/arc-models/blob/stage/url-indexer.js#L727).
-
diff --git a/using-arc/workspaces.md b/using-arc/workspaces.md
deleted file mode 100644
index 6db2aa33..00000000
--- a/using-arc/workspaces.md
+++ /dev/null
@@ -1,82 +0,0 @@
----
-description: This pages describes how to use workspaces in Advanced REST Client
----
-
-# Workspaces
-
-## Introducing workspaces
-
-{% hint style="info" %}
-Workspaces are available in ARC 14 and above
-{% endhint %}
-
-A workspace is the current state of the request editors opened in the application.
-
-
-
-Every time a request property is changed or a response is ready a new state is stored by the application automatically in a file. Request property can be the method, URL, headers, or the payload but also Actions and request configuration.
-
-Historically this data was stored in a file in application home directory. Now, however, you have an option to save the workspace state to some other file you select. This file can be later opened by ARC and it restores the same sate.
-
-## Why to use workspaces?
-
-When you creating a tutorial or a documentation for your API you can create a workspace that contains all required configuration to run requests one-by-one. You can design the workspace as each tab represent next step in your tutorial. The workspace also contains configuration data like variables and application configuration that should be applied to a request when executing it.
-
-## Using workspaces
-
-### Prepare your workspace
-
-To start with a workspace just create a sequence of requests you want to share with your audience. It's just like regular use of ARC. You can design request actions and configure request behavior in the corresponding tabs of the request editor.
-
-If you make a request and the response is ready then the response is also added to the current state.
-
-{% hint style="warning" %}
-ARC 14 does not allow to define workspace variables in application interface. Variables can be added by editing generated file.
-{% endhint %}
-
-When ready go to Workspace menu and select Open workspace details.
-
-
-
-This opens a dialog that shows workspace metadata like description, version, and author information. Don't worry about not having any data just yet.
-
-
-
-The workspace details are for the target audience that gives additional context to the data included into the workspace. Remember, however, that this step is optional.
-
-Go ahead and click "Edit" button. It opens workspace details editor that allows you to enter the corresponding values. All input fields are optional.
-
-{% hint style="info" %}
-The description field supports markdown.
-{% endhint %}
-
-After filling the form the preview shows updated information instead "No data".
-
-
-
-### Saving the workspace
-
-From the _Workspace_ menu select _Save as..._ option.
-
-
-
-This opens a regular save dialog. Select a location where the file should be stored.
-
-
-
-That's it. The workspace is now stored in the file you have requested.
-
-When you open the file you will see it's just a JSON file with a representation of the state:
-
-
-
-You can change any of the properties in the JSON if needed. However if you make any change in the application UI the state is automatically stored to the file, unless you open other workspace file.
-
-### Opening workspace file
-
-From the _Workspace_ menu select _Open from file_ option.
-
-
-
-This opens new ARC window with the same state as stored when the file was saved.
-
diff --git a/using-arc/your-first-api-call.md b/using-arc/your-first-api-call.md
deleted file mode 100644
index dcf92db8..00000000
--- a/using-arc/your-first-api-call.md
+++ /dev/null
@@ -1,188 +0,0 @@
----
-description: This guide describes how to make your first request to the API endpoint
----
-
-# Your first API call
-
-## The request editor
-
-You will use the request panel to enter request properties like method, URL, headers, and the body.
-
-
-
-### Request URL
-
-The request URL it is an API endpoint URL you want to connect to. The input field allows to provide any valid URL data, like, `https://api.domain.com/endpoint?param=value`
-
-
-
-{% hint style="info" %}
-The URL is passed to the HTTP client unprocessed to give you more control over request parameters. This means that special characters must be encoded before sending the request.
-{% endhint %}
-
-#### URL editor
-
-The URL editor has an alternative view to provide URL data. It allows to define each part of the URL separately. It also has a convenient way of defining query parameters.
-
-
-
-Query parameters can be added, removed, or disabled.
-
-You can add as much query parameters as you need. Names and values must be valid query parameter string.
-
-
-
-Don't worry, when the application say that the parameter is invalid you can use "Encode URL" button to fix the problem.
-
-
-
-{% hint style="info" %}
-Once encoded value will be encoded again producing invalid entry. When you want to encode values again, decode the values first and then encode.
-{% endhint %}
-
-To remove query parameter just press the "X" button on the right-hand side of the parameters.
-
-You can also disable query parameter using the toggle button on the left-hand side. This option removes the parameter from the final URL but keeps it in the editor so you can test various scenarios.
-
-### Request method
-
-The method tells what kind of operation is to be performed on the resource. In REST methods describe type of the operation:
-
-* POST - create resource operation
-* GET - read operation, like list resources, get a resource
-* PUT, PATCH - update a resource
-* DELETE - deletes a resource
-
-There are more less commonly used methods and Advanced REST Client support them all. You can even define custom method by selecting "custom" option in the drop down.
-
-
-
-
-
-{% hint style="warning" %}
-Custom methods are allowed but some clients may not fully support them.
-{% endhint %}
-
-### HTTP headers
-
-The headers are additional meta-information send to the server to inform it how to process the message. There are well defined request and response headers like `content-type` or `accept`. Your server, however, may require custom headers. The headers editor allows you to define this headers.
-
-{% hint style="info" %}
-ARC does not generate any request headers with exception of `Host` header which is required to make a request. Unlike other HTTP clients, only headers that are defined in the editor are send to the server.
-{% endhint %}
-
-By default ARC renders a form view with autofill options when defining headers.
-
-
-
-When a header is recognized as one of the standard header is renders a help icon that opens a description for the header.
-
-
-
-Similarly to query parameters editor, headers can be temporarily disabled to test various options. When the checkbox is unselected then the header value is kept in the editor but it is excluded from the request.
-
-For more advanced use you can switch to "Source view" which renders a text editor to provide header values manually.
-
-
-
-The editor support suggestions for header names and values.
-
-### Request body
-
-Body is the message you want to send to the server. In RESTful APIs this is the resource you create or update.
-
-
-
-{% hint style="info" %}
-GET and HEAD methods cannot define a body on a request. Even though it is technically possible, clients probably won't work with such request.
-{% endhint %}
-
-{% hint style="info" %}
-You don't need to set Content-Length header. It is added automatically when preparing the message. When this header is defined in the headers list it will be used instead. This way you can test your server for invalid input.
-{% endhint %}
-
-The body editor supports syntax highlighting for several content types like JSON and XML. Use the drop down type selector to switch between some popular media types.
-
-Form data editor can be a form based editor that allows you to enter and encode the data if needed.
-
-
-
-Multipart values are also supported. The editor allows you to add both file and text part to the message. You need to provide a name of the part and the value \(either a text for text part or a file for file part\). Additionally you can define a media type for the text part.
-
-
-
-ARC takes care about `content-type` header for multipart data. It is generated automatically when sending the request to comply with multipart specification.
-
-{% hint style="danger" %}
-Do not modify content-type header in the headers editor when using multipart data. When the "boundary" is not the same as in generated message then the request will fail.
-{% endhint %}
-
-When your request is ready you can press the "send" button to initialize the request. This sends the request data to ARC's HTTP client which generates HTTP message, makes a connection, send the message, and awaits the response.
-
-Try it with this example request data
-
-```
-Method: POST
-URL: https://httpbin.org/post
-Headers:
-Content-Type: application/json
-Accept: application/json
-x-custom-header: header value
-Payload:
-{
- "page": "test"
-}
-```
-
-## The response view
-
-When the response is ready ARC renders a response view below the request panel. By default it renders information about response status, processing time, and the received message.
-
-
-
-In most cases the response is parsed and syntax is highlighted for your convenience. You can see the original message by pressing "Source view" button.
-
-
-
-JSON response has additional option to render it in table view. It is an alternative way of presenting the data.
-
-
-
-Advanced REST Client collect detailed information about the request, response, and the process of receiving the response. Data like request and response headers, redirects, connection timings are available under "Details" panel.
-
-**Request headers** contains a final list of headers sent to the server. It also has a view that renders full HTTP message sent to the server.
-
-
-
-In this case the HTTP client added Host, Connection, and Content-Length headers to manage the the connection process and inform the server about the content.
-
-The **response headers** contains a list of all headers received from the server.
-
-
-
-{% hint style="success" %}
-Cookies are processed like a web browser would process it. Cookies are stored in internal protected storage and applied to a request send to the same domain and path.
-{% endhint %}
-
-The **redirects** panel renders a response for each redirect that happened during the request. It shows information where the request was redirect to, status code, and the list of headers.
-
-
-
-{% hint style="info" %}
-Only the final response is reported in the response body view.
-{% endhint %}
-
-{% hint style="info" %}
-Cookies are processed when redirecting the request as it would be for direct request.
-{% endhint %}
-
-The **timings tab** renders detailed information about each part of the request process like DNS lookup, connecting, SSL negotiation, message sending, and receiving time.
-
-If the request was redirected this will render timing information for each redirect.
-
-
-
-{% hint style="info" %}
-The reported timing in the main response view is for the last request in the redirects chain. The timing panel shows the total time for all requests.
-{% endhint %}
-
-