@dimensional-innovations/electron-background 2.0.4

package/README.md

@@ -0,0 +1,109 @@
+# @dimensional-innovations/electron-background
+
+electron-background aims to simplify electron apps by providing a simple api to customize the electron application.
+
+## Getting Started
+
+### Install
+Add the package using npm or yarn:
+```bash
+npm install @dimensional-innovations/electron-background
+```
+
+```bash
+yarn add @dimensional-innovations/electron-background
+```
+
+### Setup for Vue CLI / Webpack
+
+If you are using the Vue CLI, add the following to your main or background file. 
+```typescript
+import { AutoUpdater, DevTools, VueElectronSettings, init, KioskBrowserWindow, PrivilegedSchemes, StaticFileDir, TouchEvents, VueElectronVersion } from '@dimensional-innovations/electron-background';
+import { config } from '../package';
+
+init({
+  appUrl: process.env.WEBPACK_DEV_URL ? process.env.WEBPACK_DEV_URL : 'app://index.html',
+  config,
+  plugins: [
+    new AutoUpdater(),
+    new DevTools(),
+    new KioskBrowserWindow(),
+    new PrivilegedSchemes(['app']),
+    new StaticFileDir('app', __dirname),
+    new TouchEvents(),
+    new VueElectronSettings(),
+    new VueElectronVersion()
+  ]
+});
+```
+
+### Setup for Vite
+
+If you are using Vite, add the following to your main or background file. 
+```typescript
+import { AutoUpdater, DevTools, VueElectronSettings, init, KioskBrowserWindow, PrivilegedSchemes, TouchEvents, VueElectronVersion } from '@dimensional-innovations/electron-background';
+import { app } from 'electron';
+import { config } from '../package';
+
+init({
+  appUrl: process.env['ELECTRON_RENDERER_URL']
+    ? process.env['ELECTRON_RENDERER_URL']
+    : `file://${join(__dirname, '../renderer/index.html')}`,
+  config,
+  plugins: [
+    new AutoUpdater(),
+    new DevTools(),
+    new KioskBrowserWindow(),
+    new TouchEvents(),
+    new VueElectronSettings(),
+    new VueElectronVersion()
+  ]
+});
+```
+
+## Plugins
+
+By default, the init method creates a BrowserWindow and loads the specified application into the window. All other features of an application are managed through plugins. Each plugin customizes the application instance during the init process. The built-in plugins are listed below.
+
+If a feature you need isn't listed below, you can still add it to the init script by defining the plugin in your application. For example, if we wanted to customize the autoplay policy flag in electron, we would add the following to our init method.
+```typescript
+import { init } from '@dimensional-innovations/vue-electron-background';
+import { app } from 'electron';
+import { config } from '../package';
+
+init({
+  appUrl: ...,
+  config,
+  plugins: [
+    ...,
+    { beforeReady: () => app.commandLine.appendSwitch('autoplay-policy', 'no-user-gesture-required') }
+    ...,
+  ]
+});
+```
+
+### AutoUpdater
+Starts the auto update process, checking for updates every 3 minutes and automatically installing the update once one is found.
+
+For more info, see https://www.electron.build/auto-update
+
+### DevTools
+Installs dev tools extensions and opens the devTools panel.
+
+### KioskBrowserWindow
+Enables kiosk mode in the BrowserWindow when the application is packaged.
+
+### BetterUptimeHeartbeat
+Starts a heartbeat, which reports uptime to betteruptime.com. Requires that "heartbeatApiKey" is set in the settings.
+
+### PrivilegedSchemes
+Registers schemes as privileged.
+
+### StaticFileDir
+Registers a custom scheme to serve static files. 
+
+### TouchEvents
+Enables touch events in the app.
+
+## API Reference
+For the complete API exported by this package, see API.md

package/dist/AutoUpdater.d.ts

@@ -0,0 +1,18 @@
+import { InitContext, InitPlugin } from './init';
+/**
+ * Starts the auto update process, checking for updates every 3 minutes
+ * and automatically installing the update once one is found.
+ *
+ * For more info, see https://www.electron.build/auto-update
+ */
+export declare class AutoUpdater implements InitPlugin {
+    private readonly enabled;
+    /**
+     * @constructor
+     *
+     * @param enabled - Indicates if the plugin is enabled. Used to disable the plugin in development. Defaults to `app.isPackaged`.
+     */
+    constructor(enabled?: boolean);
+    afterLoad(context: InitContext): Promise<void>;
+    private startAutoUpdater;
+}

package/dist/AutoUpdater.js

@@ -0,0 +1,65 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoUpdater = void 0;
+const electron_updater_1 = require("electron-updater");
+const electron_log_1 = __importDefault(require("electron-log"));
+const electron_1 = require("electron");
+/**
+ * Starts the auto update process, checking for updates every 3 minutes
+ * and automatically installing the update once one is found.
+ *
+ * For more info, see https://www.electron.build/auto-update
+ */
+class AutoUpdater {
+    /**
+     * @constructor
+     *
+     * @param enabled - Indicates if the plugin is enabled. Used to disable the plugin in development. Defaults to `app.isPackaged`.
+     */
+    constructor(enabled = electron_1.app.isPackaged) {
+        this.enabled = enabled;
+    }
+    afterLoad(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { autoUpdaterChannel } = context.config;
+            if (this.enabled && autoUpdaterChannel) {
+                this.startAutoUpdater(autoUpdaterChannel);
+            }
+            else if (this.enabled) {
+                context.log.warn('autoUpdaterChannel was not set in the settings. AutoUpdater was not started.');
+            }
+        });
+    }
+    startAutoUpdater(autoUpdaterChannel) {
+        const threeMinutes = 180000;
+        electron_updater_1.autoUpdater.channel = autoUpdaterChannel;
+        electron_updater_1.autoUpdater.autoDownload = true;
+        electron_updater_1.autoUpdater.logger = electron_log_1.default;
+        electron_updater_1.autoUpdater.on('update-downloaded', () => {
+            electron_log_1.default.info('Updated app downloaded... restarting');
+            // https://www.electron.build/auto-update#module_electron-updater.AppUpdater+quitAndInstall
+            electron_updater_1.autoUpdater.quitAndInstall(true, true);
+        });
+        electron_updater_1.autoUpdater.on('update-not-available', () => {
+            electron_log_1.default.info('No update available. Will try again soon.');
+        });
+        // check for updates now and then every 3 minutes
+        electron_updater_1.autoUpdater.checkForUpdates();
+        setInterval(() => {
+            electron_updater_1.autoUpdater.checkForUpdates();
+        }, threeMinutes);
+    }
+}
+exports.AutoUpdater = AutoUpdater;

package/dist/BrowserWindow.d.ts

@@ -0,0 +1,48 @@
+import { BrowserWindowConstructorOptions } from "electron";
+import { InitContext, InitPlugin } from "./init";
+/**
+ * Applies default options to the browser window. If `appHeight`, `appWidth`, or `backgroundColor` are included in
+ * app config, they will be added to the window options as well.
+ */
+export declare class DefaultBrowserWindow implements InitPlugin {
+    protected readonly options: BrowserWindowConstructorOptions;
+    /**
+     * @constructor
+     *
+     * @param options - Additional options to apply to the browser window.
+     */
+    constructor(options?: BrowserWindowConstructorOptions);
+    afterReady(context: InitContext): Promise<void>;
+    protected getDefaultWindowOptions(): BrowserWindowConstructorOptions;
+    protected getWindowOptionsFromConfig({ appHeight, appWidth, backgroundColor }: Record<string, string | number | boolean>): BrowserWindowConstructorOptions;
+}
+/**
+ * Enables kiosk mode in the BrowserWindow when the application is packaged.
+ */
+export declare class KioskBrowserWindow extends DefaultBrowserWindow {
+    private readonly enabled;
+    /**
+     * @constructor
+     *
+     * @param options - Additional options to apply to the BrowserWindow.
+     * @param enableKioskMode - Indicates if the plugin is enabled. Used to disabled kiosk mode in development. Defaults to `app.isPackaged`
+     */
+    constructor(options?: BrowserWindowConstructorOptions, enabled?: boolean);
+    protected getDefaultWindowOptions(): BrowserWindowConstructorOptions;
+}
+/**
+ * Ensures the browser window will always be fullscreen. Generally, KioskBrowserWindow is preferred
+ * over this plugin, but there are times when app cannot be in kiosk mode.
+ */
+export declare class FullScreenBrowserWindow extends DefaultBrowserWindow {
+    private readonly enabled;
+    /**
+     * @constructor
+     *
+     * @param options - Additional options to apply to the BrowserWindow.
+     * @param enabled - Indicates if the plugin is enabled. Used to disable the plugin in development. Defaults to `app.isPackaged`.
+     */
+    constructor(options?: BrowserWindowConstructorOptions, enabled?: boolean);
+    beforeLoad(context: InitContext): Promise<void>;
+    protected getDefaultWindowOptions(): BrowserWindowConstructorOptions;
+}

package/dist/BrowserWindow.js

@@ -0,0 +1,143 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FullScreenBrowserWindow = exports.KioskBrowserWindow = exports.DefaultBrowserWindow = void 0;
+const electron_1 = require("electron");
+/**
+ * Applies default options to the browser window. If `appHeight`, `appWidth`, or `backgroundColor` are included in
+ * app config, they will be added to the window options as well.
+ */
+class DefaultBrowserWindow {
+    /**
+     * @constructor
+     *
+     * @param options - Additional options to apply to the browser window.
+     */
+    constructor(options = {}) {
+        this.options = options;
+    }
+    afterReady(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            context.browserWindowOptions = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, context.browserWindowOptions), this.getDefaultWindowOptions()), this.getWindowOptionsFromConfig(context.config)), this.options), { closable: true });
+        });
+    }
+    getDefaultWindowOptions() {
+        return {
+            webPreferences: {
+                nodeIntegration: true,
+                contextIsolation: false,
+                webSecurity: false
+            }
+        };
+    }
+    getWindowOptionsFromConfig({ appHeight, appWidth, backgroundColor }) {
+        const options = {};
+        if (appHeight !== undefined && typeof appHeight === 'number') {
+            options.height = appHeight;
+        }
+        if (appWidth !== undefined && typeof appWidth === 'number') {
+            options.width = appWidth;
+        }
+        if (backgroundColor !== undefined && typeof backgroundColor === 'string') {
+            options.backgroundColor = backgroundColor;
+        }
+        return options;
+    }
+}
+exports.DefaultBrowserWindow = DefaultBrowserWindow;
+/**
+ * Enables kiosk mode in the BrowserWindow when the application is packaged.
+ */
+class KioskBrowserWindow extends DefaultBrowserWindow {
+    /**
+     * @constructor
+     *
+     * @param options - Additional options to apply to the BrowserWindow.
+     * @param enableKioskMode - Indicates if the plugin is enabled. Used to disabled kiosk mode in development. Defaults to `app.isPackaged`
+     */
+    constructor(options = {}, enabled = electron_1.app.isPackaged) {
+        super(options);
+        this.enabled = enabled;
+    }
+    getDefaultWindowOptions() {
+        if (!this.enabled) {
+            return super.getDefaultWindowOptions();
+        }
+        return Object.assign(Object.assign({}, super.getDefaultWindowOptions()), { acceptFirstMouse: true, alwaysOnTop: true, autoHideMenuBar: true, fullscreen: true, kiosk: true, minimizable: false, movable: false, x: 0, y: 0 });
+    }
+}
+exports.KioskBrowserWindow = KioskBrowserWindow;
+/**
+ * Ensures the browser window will always be fullscreen. Generally, KioskBrowserWindow is preferred
+ * over this plugin, but there are times when app cannot be in kiosk mode.
+ */
+class FullScreenBrowserWindow extends DefaultBrowserWindow {
+    /**
+     * @constructor
+     *
+     * @param options - Additional options to apply to the BrowserWindow.
+     * @param enabled - Indicates if the plugin is enabled. Used to disable the plugin in development. Defaults to `app.isPackaged`.
+     */
+    constructor(options = {}, enabled = electron_1.app.isPackaged) {
+        super(options);
+        this.enabled = enabled;
+    }
+    beforeLoad(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.enabled) {
+                return;
+            }
+            const browserWindow = context.browserWindow;
+            if (!browserWindow) {
+                context.log.error('browserWindow is undefined');
+                return;
+            }
+            const { screen } = yield Promise.resolve().then(() => __importStar(require('electron')));
+            const resizeWindow = () => {
+                browserWindow.setBounds(screen.getPrimaryDisplay().bounds);
+            };
+            resizeWindow();
+            screen.on('display-added', resizeWindow);
+            screen.on('display-metrics-changed', resizeWindow);
+            screen.on('display-removed', resizeWindow);
+        });
+    }
+    getDefaultWindowOptions() {
+        if (!this.enabled) {
+            return super.getDefaultWindowOptions();
+        }
+        return Object.assign(Object.assign({}, super.getDefaultWindowOptions()), { alwaysOnTop: true, resizable: false, movable: false, frame: false });
+    }
+}
+exports.FullScreenBrowserWindow = FullScreenBrowserWindow;

package/dist/DevTools.d.ts

@@ -0,0 +1,18 @@
+import { VUEJS3_DEVTOOLS } from 'electron-devtools-installer';
+import { InitContext, InitPlugin } from './init';
+export type Extension = string | typeof VUEJS3_DEVTOOLS;
+/**
+ * Installs dev tools extensions and opens the devTools panel.
+ */
+export declare class DevTools implements InitPlugin {
+    private readonly devTools;
+    private readonly enabled;
+    /**
+     * @constructor
+     *
+     * @param devTools - The extensions to install.
+     * @param enabled - Indicates if the plugin is enabled. Used to disable the plugin when the app is packaged. Defaults to `!app.isPackaged`.
+     */
+    constructor(devTools: Array<Extension>, enabled?: boolean);
+    beforeLoad(context: InitContext): Promise<void>;
+}

package/dist/DevTools.js

@@ -0,0 +1,51 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevTools = void 0;
+const electron_1 = require("electron");
+const electron_devtools_installer_1 = __importDefault(require("electron-devtools-installer"));
+/**
+ * Installs dev tools extensions and opens the devTools panel.
+ */
+class DevTools {
+    /**
+     * @constructor
+     *
+     * @param devTools - The extensions to install.
+     * @param enabled - Indicates if the plugin is enabled. Used to disable the plugin when the app is packaged. Defaults to `!app.isPackaged`.
+     */
+    constructor(devTools, enabled = !electron_1.app.isPackaged) {
+        this.devTools = devTools;
+        this.enabled = enabled;
+    }
+    beforeLoad(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.enabled) {
+                return;
+            }
+            try {
+                yield (0, electron_devtools_installer_1.default)(this.devTools);
+            }
+            catch (error) {
+                console.error(`Failed to install dev tools: ${this.devTools.join(',')}`);
+                console.error(error);
+            }
+            if (context.browserWindow) {
+                const browserWindow = context.browserWindow;
+                browserWindow.on('ready-to-show', () => browserWindow.webContents.openDevTools());
+            }
+        });
+    }
+}
+exports.DevTools = DevTools;

package/dist/NodeHeartbeat.d.ts

@@ -0,0 +1,59 @@
+import { InitContext, InitPlugin } from './init';
+/**
+ * Options used to define the request used to monitor the app.
+ */
+export interface HeartbeatOptions {
+    /**
+     * The url to send a request to. If a function is provided, it is called with the current context and a request
+     * is sent to the returned value.
+     */
+    url: string | ((context: InitContext) => string);
+    /**
+     * The amount of time in milliseconds between requests.
+     */
+    pollInterval: number;
+}
+/**
+ * Starts a "heartbeat", which sends a request to the provided url on an interval.
+ */
+export declare class Heartbeat implements InitPlugin {
+    private readonly options;
+    private readonly enabled;
+    /**
+     * @constructor
+     *
+     * @param options - Options that define the url used to monitor the app.
+     * @param enabled - Indicates if the plugin is enabled. Used to disable the plugin during development. Defaults to `app.isPackaged`.
+     */
+    constructor(options: HeartbeatOptions, enabled?: boolean);
+    afterLoad(context: InitContext): Promise<void>;
+}
+export interface BetterStackHeartbeatOptions {
+    /**
+     * The unique key for the app, obtained from betterstack.com
+     */
+    heartbeatApiKey?: string;
+    /**
+     * If true sends a request to https://uptime.betterstack.com. Otherwise sends a request to https://betteruptiume.com.
+     */
+    isBetterStack?: boolean;
+    /**
+     * The amount of time in milliseconds between requests.
+     */
+    pollInterval?: number;
+}
+/**
+ * Starts a "heartbeat" by sending a request to https://betterstack.com on an interval. Requires the apiKey to be in the app config.
+ */
+export declare class BetterStackHeartbeat implements InitPlugin {
+    private readonly enabled;
+    private readonly options;
+    /**
+     * @constructor
+     *
+     * @param enabled - Indicates if the plugin is enabled. Used to disable the plugin during development. Defaults to `app.isPackaged`.
+     * @param options - Options that used to start the heartbeat.
+     */
+    constructor(enabled?: boolean, options?: BetterStackHeartbeatOptions);
+    afterLoad(context: InitContext): Promise<void>;
+}

package/dist/NodeHeartbeat.js

@@ -0,0 +1,89 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BetterStackHeartbeat = exports.Heartbeat = void 0;
+const electron_1 = require("electron");
+const axios_1 = __importDefault(require("axios"));
+/**
+ * Starts a "heartbeat", which sends a request to the provided url on an interval.
+ */
+class Heartbeat {
+    /**
+     * @constructor
+     *
+     * @param options - Options that define the url used to monitor the app.
+     * @param enabled - Indicates if the plugin is enabled. Used to disable the plugin during development. Defaults to `app.isPackaged`.
+     */
+    constructor(options, enabled = electron_1.app.isPackaged) {
+        this.options = options;
+        this.enabled = enabled;
+    }
+    afterLoad(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.enabled)
+                return;
+            const url = typeof this.options.url === 'string'
+                ? this.options.url
+                : this.options.url(context);
+            new NodeHeartbeat(url, this.options.pollInterval).start();
+        });
+    }
+}
+exports.Heartbeat = Heartbeat;
+/**
+ * Starts a "heartbeat" by sending a request to https://betterstack.com on an interval. Requires the apiKey to be in the app config.
+ */
+class BetterStackHeartbeat {
+    /**
+     * @constructor
+     *
+     * @param enabled - Indicates if the plugin is enabled. Used to disable the plugin during development. Defaults to `app.isPackaged`.
+     * @param options - Options that used to start the heartbeat.
+     */
+    constructor(enabled = electron_1.app.isPackaged, options = {}) {
+        this.enabled = enabled;
+        this.options = options;
+    }
+    afterLoad(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const heartbeatApiKey = context.config.heartbeatApiKey || this.options.heartbeatApiKey;
+            if (this.enabled && heartbeatApiKey && typeof heartbeatApiKey === 'string') {
+                const url = this.options.isBetterStack
+                    ? `https://uptime.betterstack.com/api/v1/heartbeat/${heartbeatApiKey}`
+                    : `https://betteruptime.com/api/v1/heartbeat/${heartbeatApiKey}`;
+                new NodeHeartbeat(url, this.options.pollInterval || 30000).start();
+            }
+            else if (this.enabled) {
+                context.log.warn('heartbeatApiKey was not in the settings. Heartbeat was not started.');
+            }
+        });
+    }
+}
+exports.BetterStackHeartbeat = BetterStackHeartbeat;
+class NodeHeartbeat {
+    constructor(url, pollInterval) {
+        this.url = url;
+        this.pollInterval = pollInterval;
+    }
+    start() {
+        this.poll();
+        this.interval = setInterval(() => this.poll(), this.pollInterval);
+    }
+    stop() {
+        clearInterval(this.interval);
+    }
+    poll() {
+        return axios_1.default.head(this.url);
+    }
+}

package/dist/PrivilegedSchemes.d.ts

@@ -0,0 +1,14 @@
+import { InitPlugin } from './init';
+/**
+ * Registers schemes as privileged.
+ */
+export declare class PrivilegedSchemes implements InitPlugin {
+    private readonly schemes;
+    /**
+     * @constructor
+     *
+     * @param schemes - The schemes to register as privileged.
+     */
+    constructor(schemes: Array<string>);
+    beforeReady(): Promise<void>;
+}

package/dist/PrivilegedSchemes.js

@@ -0,0 +1,37 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrivilegedSchemes = void 0;
+const electron_1 = require("electron");
+/**
+ * Registers schemes as privileged.
+ */
+class PrivilegedSchemes {
+    /**
+     * @constructor
+     *
+     * @param schemes - The schemes to register as privileged.
+     */
+    constructor(schemes) {
+        this.schemes = schemes;
+    }
+    beforeReady() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const customSchemes = this.schemes
+                .map((scheme) => ({
+                scheme,
+                privileges: { secure: true, standard: true, supportFetchAPI: true },
+            }));
+            electron_1.protocol.registerSchemesAsPrivileged(customSchemes);
+        });
+    }
+}
+exports.PrivilegedSchemes = PrivilegedSchemes;

package/dist/SingleInstance.d.ts

@@ -0,0 +1,10 @@
+import { InitContext, InitPlugin } from './init';
+/**
+ * Enforces that only a single instance of the app can run at the same time.
+ * If a second instance of the is opened, the second instance is closed and
+ * the first instance is brought back into focus.
+ */
+export declare class SingleInstance implements InitPlugin {
+    beforeReady(): Promise<void>;
+    afterReady(context: InitContext): Promise<void>;
+}

package/dist/SingleInstance.js

@@ -0,0 +1,43 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SingleInstance = void 0;
+const electron_1 = require("electron");
+/**
+ * Enforces that only a single instance of the app can run at the same time.
+ * If a second instance of the is opened, the second instance is closed and
+ * the first instance is brought back into focus.
+ */
+class SingleInstance {
+    beforeReady() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (electron_1.app.requestSingleInstanceLock())
+                return;
+            electron_1.app.quit();
+            process.exit(0);
+        });
+    }
+    afterReady(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            electron_1.app.on('second-instance', () => {
+                if (!context.browserWindow)
+                    return;
+                if (context.browserWindow.isMinimized()) {
+                    context.browserWindow.restore();
+                }
+                else {
+                    context.browserWindow.focus();
+                }
+            });
+        });
+    }
+}
+exports.SingleInstance = SingleInstance;

package/dist/StaticFileDir.d.ts

@@ -0,0 +1,26 @@
+import { InitPlugin } from './init';
+/**
+ * Registers a custom scheme to serve static files.
+ */
+export declare class StaticFileDir implements InitPlugin {
+    private readonly scheme;
+    private readonly dir;
+    /**
+     * @constructor
+     *
+     * @param scheme - The scheme to serve the files from.
+     * @param dir - The directory where the static files are located.
+     */
+    constructor(scheme: string, dir: string);
+    afterReady(): Promise<void>;
+}
+/**
+ * Wrapper around `protocol.registerFileProtocol` that serves files from the given source directory.
+ * The handler will convert any url with the custom scheme to a file path in the source directory in
+ * order to find the file to serve. For example, with "media" passed in for scheme and `/public` passed
+ * in for sourceDirectory "media://videos/demo.mp4" would resolve to "/public/media/videos/demo.mp4".
+ *
+ * @param scheme - The scheme to register.
+ * @param sourceDirectory - The directory where files are served from.
+ */
+export declare function createFileProtocol(scheme: string, sourceDirectory: string): void;

package/dist/StaticFileDir.js

@@ -0,0 +1,54 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFileProtocol = exports.StaticFileDir = void 0;
+const electron_1 = require("electron");
+const path_1 = require("path");
+/**
+ * Registers a custom scheme to serve static files.
+ */
+class StaticFileDir {
+    /**
+     * @constructor
+     *
+     * @param scheme - The scheme to serve the files from.
+     * @param dir - The directory where the static files are located.
+     */
+    constructor(scheme, dir) {
+        this.scheme = scheme;
+        this.dir = dir;
+    }
+    afterReady() {
+        return __awaiter(this, void 0, void 0, function* () {
+            createFileProtocol(this.scheme, this.dir);
+        });
+    }
+}
+exports.StaticFileDir = StaticFileDir;
+/**
+ * Wrapper around `protocol.registerFileProtocol` that serves files from the given source directory.
+ * The handler will convert any url with the custom scheme to a file path in the source directory in
+ * order to find the file to serve. For example, with "media" passed in for scheme and `/public` passed
+ * in for sourceDirectory "media://videos/demo.mp4" would resolve to "/public/media/videos/demo.mp4".
+ *
+ * @param scheme - The scheme to register.
+ * @param sourceDirectory - The directory where files are served from.
+ */
+function createFileProtocol(scheme, sourceDirectory) {
+    electron_1.protocol.registerFileProtocol(scheme, (request, respond) => {
+        const requestPath = decodeURI(request.url.replace(`${scheme}://`, ''));
+        const requestDir = (0, path_1.dirname)(requestPath);
+        const requestFile = (0, path_1.basename)(requestPath);
+        const path = (0, path_1.normalize)((0, path_1.join)(sourceDirectory, requestDir, requestFile));
+        respond({ path });
+    });
+}
+exports.createFileProtocol = createFileProtocol;

package/dist/TouchEvents.d.ts

@@ -0,0 +1,7 @@
+import { InitPlugin } from './init';
+/**
+ * Enables touch events in the app.
+ */
+export declare class TouchEvents implements InitPlugin {
+    afterReady(): Promise<void>;
+}

package/dist/TouchEvents.js

@@ -0,0 +1,24 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TouchEvents = void 0;
+const electron_1 = require("electron");
+/**
+ * Enables touch events in the app.
+ */
+class TouchEvents {
+    afterReady() {
+        return __awaiter(this, void 0, void 0, function* () {
+            electron_1.app.commandLine.appendSwitch('touch-events', 'enabled');
+        });
+    }
+}
+exports.TouchEvents = TouchEvents;

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from './AutoUpdater';
+export * from './BrowserWindow';
+export * from './DevTools';
+export * from './NodeHeartbeat';
+export * from './PrivilegedSchemes';
+export * from './SingleInstance';
+export * from './StaticFileDir';
+export * from './TouchEvents';
+export * from './init';

package/dist/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./AutoUpdater"), exports);
+__exportStar(require("./BrowserWindow"), exports);
+__exportStar(require("./DevTools"), exports);
+__exportStar(require("./NodeHeartbeat"), exports);
+__exportStar(require("./PrivilegedSchemes"), exports);
+__exportStar(require("./SingleInstance"), exports);
+__exportStar(require("./StaticFileDir"), exports);
+__exportStar(require("./TouchEvents"), exports);
+__exportStar(require("./init"), exports);

package/dist/init.d.ts

@@ -0,0 +1,106 @@
+import { BrowserWindow, BrowserWindowConstructorOptions } from 'electron';
+/**
+ * The context object passed to each plugin during the init process.
+ */
+export declare class InitContext {
+    /**
+     * The url used to load the application.
+     */
+    appUrl: string;
+    /**
+     * Application config used by the app and/or plugins.
+     */
+    config: Record<string, string | number | boolean>;
+    /**
+     * Options used to create the BrowserWindow. These can be modified in `beforeReady` or
+     * `beforeLoad` methods to change the created BrowserWindow.
+     */
+    browserWindowOptions: BrowserWindowConstructorOptions;
+    /**
+     * The main browser window that the app is loaded into. This is available in the context
+     * in the `afterLoad` method.
+     */
+    browserWindow: BrowserWindow | null;
+    /**
+     * The log instance. This should be used over `console` in plugin implementations.
+     */
+    log: Pick<Console, 'error' | 'warn' | 'info' | 'debug'>;
+    constructor(
+    /**
+     * The url used to load the application.
+     */
+    appUrl: string, 
+    /**
+     * Application config used by the app and/or plugins.
+     */
+    config: Record<string, string | number | boolean>, 
+    /**
+     * Options used to create the BrowserWindow. These can be modified in `beforeReady` or
+     * `beforeLoad` methods to change the created BrowserWindow.
+     */
+    browserWindowOptions: BrowserWindowConstructorOptions, 
+    /**
+     * The main browser window that the app is loaded into. This is available in the context
+     * in the `afterLoad` method.
+     */
+    browserWindow: BrowserWindow | null, 
+    /**
+     * The log instance. This should be used over `console` in plugin implementations.
+     */
+    log: Pick<Console, 'error' | 'warn' | 'info' | 'debug'>);
+}
+/**
+ * A plugin is used to execute logic at various stages during the init process.
+ *
+ * Implementations can define one or more of the optional methods to customize
+ * application instance.
+ */
+export interface InitPlugin {
+    /**
+     * beforeReady is executed before the `app.whenReady()` promise resolves.
+     *
+     * @param context - The current InitContext instance.
+     */
+    beforeReady?(context: InitContext): Promise<void>;
+    /**
+     * afterReady is executed after the `app.whenReady()` promise resolves, but before the
+     * BrowserWindow is created.
+     *
+     * @param context - The current InitContext instance.
+     */
+    afterReady?(context: InitContext): Promise<void>;
+    /**
+     * beforeLoad is executed after the browserWindow is created, but before the application
+     * has been loaded into the window.
+     *
+     * @param context - The current InitContext instance.
+     */
+    beforeLoad?(context: InitContext): Promise<void>;
+    /**
+     * afterLoad is executed after the application has been loaded into the browserWindow.
+     *
+     * @param context - The current InitContext instance.
+     */
+    afterLoad?(context: InitContext): Promise<void>;
+}
+export interface InitOptions {
+    /**
+     * The url to load once the the app has been created.
+     */
+    appUrl: string;
+    /**
+     * The default application settings.
+     */
+    config?: Record<string, string | number | boolean>;
+    /**
+     * The list of plugins to load with the application.
+     */
+    plugins?: Array<InitPlugin>;
+}
+/**
+ * Initializes the application, creating a browser window, and loads the provided app url.
+ *
+ * @param options - Options used to define how the application is initialized.
+ * @returns - The final state of the init context, including the created browser window for additional setup.
+ */
+export declare function init({ appUrl, config, plugins, }: InitOptions): Promise<InitContext>;

package/dist/init.js

@@ -0,0 +1,96 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = exports.InitContext = void 0;
+const electron_1 = require("electron");
+const electron_log_1 = __importDefault(require("electron-log"));
+/**
+ * The context object passed to each plugin during the init process.
+ */
+class InitContext {
+    constructor(
+    /**
+     * The url used to load the application.
+     */
+    appUrl, 
+    /**
+     * Application config used by the app and/or plugins.
+     */
+    config, 
+    /**
+     * Options used to create the BrowserWindow. These can be modified in `beforeReady` or
+     * `beforeLoad` methods to change the created BrowserWindow.
+     */
+    browserWindowOptions, 
+    /**
+     * The main browser window that the app is loaded into. This is available in the context
+     * in the `afterLoad` method.
+     */
+    browserWindow, 
+    /**
+     * The log instance. This should be used over `console` in plugin implementations.
+     */
+    log) {
+        this.appUrl = appUrl;
+        this.config = config;
+        this.browserWindowOptions = browserWindowOptions;
+        this.browserWindow = browserWindow;
+        this.log = log;
+    }
+}
+exports.InitContext = InitContext;
+/**
+ * Initializes the application, creating a browser window, and loads the provided app url.
+ *
+ * @param options - Options used to define how the application is initialized.
+ * @returns - The final state of the init context, including the created browser window for additional setup.
+ */
+function init({ appUrl, config = {}, plugins = [], }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        process.env.ELECTRON_DISABLE_SECURITY_WARNINGS = 'true';
+        electron_1.app.on('window-all-closed', electron_1.app.quit);
+        process.on('message', (data) => {
+            if (data === 'graceful-exit')
+                electron_1.app.quit();
+        });
+        process.on('SIGTERM', electron_1.app.quit);
+        const context = new InitContext(appUrl, config, { height: 1920, width: 1080, backgroundColor: '#000' }, null, electron_log_1.default);
+        for (const plugin of plugins) {
+            if (plugin.beforeReady) {
+                yield plugin.beforeReady(context);
+            }
+        }
+        yield electron_1.app.whenReady();
+        for (const plugin of plugins) {
+            if (plugin.afterReady) {
+                yield plugin.afterReady(context);
+            }
+        }
+        context.browserWindow = new electron_1.BrowserWindow(context.browserWindowOptions);
+        context.browserWindow.on('closed', () => context.browserWindow = null);
+        for (const plugin of plugins) {
+            if (plugin.beforeLoad) {
+                yield plugin.beforeLoad(context);
+            }
+        }
+        yield context.browserWindow.loadURL(context.appUrl);
+        for (const plugin of plugins) {
+            if (plugin.afterLoad) {
+                plugin.afterLoad(context);
+            }
+        }
+        return context;
+    });
+}
+exports.init = init;

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@dimensional-innovations/electron-background",
+  "version": "2.0.4",
+  "description": "the background script for electron apps",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "lint": "eslint ./src/**/*",
+    "lint:fix": "eslint ./src/**/* --fix",
+    "generate:docs": "jsdoc2md ./dist/* > API.md"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitlab.com/dimensional-innovations/electron-background.git"
+  },
+  "keywords": [
+    "vue",
+    "electron",
+    "background"
+  ],
+  "author": "Edgar Esparza",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://gitlab.com/dimensional-innovations/electron-background/issues"
+  },
+  "homepage": "https://gitlab.com/dimensional-innovations/electron-background#readme",
+  "dependencies": {
+    "axios": "^1.6.7",
+    "electron-devtools-installer": "^3.1.1",
+    "electron-log": "^5.1.1",
+    "electron-updater": "^6.1.7"
+  },
+  "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "^6.21.0",
+    "@typescript-eslint/parser": "^6.21.0",
+    "electron": "^28.2.1",
+    "eslint": "^8.56.0",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-plugin-import": "^2.29.1",
+    "jsdoc-to-markdown": "^8.0.1",
+    "typescript": "^5.3.3"
+  },
+  "peerDependencies": {
+    "electron": ">=16.0.0"
+  }
+}