electron-incremental-update 2.0.0-beta.6 → 2.0.0-beta.7

package/dist/types-CItP6bL-.d.ts

@@ -0,0 +1,104 @@
+import { Promisable } from '@subframe7536/type-utils';
+
+interface Version {
+    major: number;
+    minor: number;
+    patch: number;
+    stage: string;
+    stageVersion: number;
+}
+declare function parseVersion(version: string): Version;
+declare function defaultIsLowerVersion(oldVer: string, newVer: string): boolean;
+/**
+ * update info json
+ */
+type UpdateInfo = {
+    signature: string;
+    minimumVersion: string;
+    version: string;
+};
+/**
+ * {@link UpdateInfo} with beta
+ */
+type UpdateJSON = UpdateInfo & {
+    beta: UpdateInfo;
+};
+declare function isUpdateJSON(json: any): json is UpdateJSON;
+declare function defaultVersionJsonGenerator(existingJson: UpdateJSON, signature: string, version: string, minimumVersion: string): UpdateJSON;
+
+type URLHandler = (url: URL, isDownloadAsar: boolean) => Promisable<URL | string | undefined | null>;
+type OnDownloading = (progress: DownloadingInfo) => void;
+interface DownloadingInfo {
+    /**
+     * download delta
+     */
+    delta: number;
+    /**
+     * downloaded percent, 0 ~ 100
+     *
+     * If not `Content-Length` header, will be nagative
+     */
+    percent: number;
+    /**
+     * total size
+     *
+     * If not `Content-Length` header, will be -1
+     */
+    total: number;
+    /**
+     * downloaded size
+     */
+    transferred: number;
+    /**
+     * download speed, bytes per second
+     */
+    bps: number;
+}
+interface IProvider {
+    /**
+     * provider name
+     */
+    name: string;
+    /**
+     * custom url handler
+     *
+     * for Github, there are some {@link https://github.com/XIU2/UserScript/blob/master/GithubEnhanced-High-Speed-Download.user.js#L34 public CDN links}
+     */
+    urlHandler?: URLHandler;
+    onDownloading?: OnDownloading;
+    /**
+     * download update json
+     * @param versionPath parsed version path
+     */
+    downloadJSON: (versionPath: string) => Promise<UpdateJSON>;
+    /**
+     * download update asar
+     * @param name app name
+     * @param updateInfo existing update info
+     * @param onDownloading hook for on downloading
+     */
+    downloadAsar: (name: string, updateInfo: UpdateInfo, onDownloading?: (info: DownloadingInfo) => void) => Promise<Buffer>;
+    /**
+     * compare version
+     * @param oldVer old version string
+     * @param newVer new version string
+     * @returns if version1 < version2
+     */
+    isLowerVersion: (oldVer: string, newVer: string) => boolean;
+    /**
+     * unzip file buffer
+     * @param buffer source buffer
+     */
+    unzipFile: (buffer: Buffer) => Promise<Buffer>;
+    /**
+     * verify asar signature
+     * @param buffer file buffer
+     * @param version target version
+     * @param signature signature
+     * @param cert certificate
+     * @returns if signature is valid, returns the version, otherwise returns `undefined`
+     */
+    verifySignaure: (buffer: Buffer, version: string, signature: string, cert: string) => Promisable<boolean>;
+}
+
+export { type DownloadingInfo as D, type IProvider as I, type OnDownloading as O, type UpdateInfo as U, type Version as V, type UpdateJSON as a, defaultVersionJsonGenerator as b, type URLHandler as c, defaultIsLowerVersion as d, isUpdateJSON as i, parseVersion as p };

package/dist/utils.cjs

@@ -5,7 +5,6 @@ var path = require('path');
 var electron = require('electron');
 var zlib = require('zlib');
 var crypto = require('crypto');
-var ciInfo = require('ci-info');
 
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
@@ -206,10 +205,6 @@ async function autoUpdate(updater) {
   }
 }
 
-Object.defineProperty(exports, "isCI", {
-  enumerable: true,
-  get: function () { return ciInfo.isCI; }
-});
 exports.aesDecrypt = aesDecrypt;
 exports.aesEncrypt = aesEncrypt;
 exports.autoUpdate = autoUpdate;

package/dist/utils.d.cts

@@ -0,0 +1,80 @@
+import { BrowserWindow } from 'electron';
+export { e as aesDecrypt, b as aesEncrypt, c as defaultSignature, a as defaultUnzipFile, f as defaultVerifySignature, d as defaultZipFile, h as hashBuffer } from './zip-DPF5IFkK.cjs';
+export { U as UpdateInfo, a as UpdateJSON, V as Version, d as defaultIsLowerVersion, b as defaultVersionJsonGenerator, i as isUpdateJSON, p as parseVersion } from './types-CItP6bL-.cjs';
+import { U as Updater } from './core-ZUlLHadf.cjs';
+import '@subframe7536/type-utils';
+import 'node:events';
+
+/**
+ * compile time dev check
+ */
+declare const isDev: boolean;
+declare const isWin: boolean;
+declare const isMac: boolean;
+declare const isLinux: boolean;
+/**
+ * get the absolute path of `${electron.app.name}.asar` (not `app.asar`)
+ *
+ * if is in dev, **always** return `'DEV.asar'`
+ */
+declare function getPathFromAppNameAsar(...path: string[]): string;
+/**
+ * get app version, if is in dev, return `getEntryVersion()`
+ */
+declare function getAppVersion(): string;
+/**
+ * get entry version
+ */
+declare function getEntryVersion(): string;
+/**
+ * use `require` to load native module from entry
+ * @param moduleName file name in entry
+ */
+declare function requireNative<T = any>(moduleName: string): T;
+/**
+ * Restarts the Electron app.
+ */
+declare function restartApp(): void;
+/**
+ * fix app use model id, only for Windows
+ * @param id app id, default is `org.${electron.app.name}`
+ */
+declare function setAppUserModelId(id?: string): void;
+/**
+ * disable hardware acceleration for Windows 7
+ */
+declare function disableHWAccForWin7(): void;
+/**
+ * keep single electron instance and auto restore window on `second-instance` event
+ * @param window brwoser window to show
+ * @returns `false` if the app is running
+ */
+declare function singleInstance(window?: BrowserWindow): boolean;
+/**
+ * set `AppData` dir to the dir of .exe file
+ *
+ * useful for portable Windows app
+ * @param dirName dir name, default to `data`
+ */
+declare function setPortableAppDataPath(dirName?: string): void;
+/**
+ * load `process.env.VITE_DEV_SERVER_URL` when dev, else load html file
+ * @param win window
+ * @param htmlFilePath html file path, default is `index.html`
+ */
+declare function loadPage(win: BrowserWindow, htmlFilePath?: string): void;
+declare function getPathFromPreload(...paths: string[]): string;
+declare function getPathFromPublic(...paths: string[]): string;
+declare function getPathFromEntryAsar(...paths: string[]): string;
+/**
+ * handle all unhandled error
+ * @param callback callback function
+ */
+declare function handleUnexpectedErrors(callback: (err: unknown) => void): void;
+
+/**
+ * auto check update, download and install
+ */
+declare function autoUpdate(updater: Updater): Promise<void>;
+
+export { autoUpdate, disableHWAccForWin7, getAppVersion, getEntryVersion, getPathFromAppNameAsar, getPathFromEntryAsar, getPathFromPreload, getPathFromPublic, handleUnexpectedErrors, isDev, isLinux, isMac, isWin, loadPage, requireNative, restartApp, setAppUserModelId, setPortableAppDataPath, singleInstance };

package/dist/utils.d.ts

@@ -0,0 +1,80 @@
+import { BrowserWindow } from 'electron';
+export { e as aesDecrypt, b as aesEncrypt, c as defaultSignature, a as defaultUnzipFile, f as defaultVerifySignature, d as defaultZipFile, h as hashBuffer } from './zip-DPF5IFkK.js';
+export { U as UpdateInfo, a as UpdateJSON, V as Version, d as defaultIsLowerVersion, b as defaultVersionJsonGenerator, i as isUpdateJSON, p as parseVersion } from './types-CItP6bL-.js';
+import { U as Updater } from './core-DJdvtwvU.js';
+import '@subframe7536/type-utils';
+import 'node:events';
+
+/**
+ * compile time dev check
+ */
+declare const isDev: boolean;
+declare const isWin: boolean;
+declare const isMac: boolean;
+declare const isLinux: boolean;
+/**
+ * get the absolute path of `${electron.app.name}.asar` (not `app.asar`)
+ *
+ * if is in dev, **always** return `'DEV.asar'`
+ */
+declare function getPathFromAppNameAsar(...path: string[]): string;
+/**
+ * get app version, if is in dev, return `getEntryVersion()`
+ */
+declare function getAppVersion(): string;
+/**
+ * get entry version
+ */
+declare function getEntryVersion(): string;
+/**
+ * use `require` to load native module from entry
+ * @param moduleName file name in entry
+ */
+declare function requireNative<T = any>(moduleName: string): T;
+/**
+ * Restarts the Electron app.
+ */
+declare function restartApp(): void;
+/**
+ * fix app use model id, only for Windows
+ * @param id app id, default is `org.${electron.app.name}`
+ */
+declare function setAppUserModelId(id?: string): void;
+/**
+ * disable hardware acceleration for Windows 7
+ */
+declare function disableHWAccForWin7(): void;
+/**
+ * keep single electron instance and auto restore window on `second-instance` event
+ * @param window brwoser window to show
+ * @returns `false` if the app is running
+ */
+declare function singleInstance(window?: BrowserWindow): boolean;
+/**
+ * set `AppData` dir to the dir of .exe file
+ *
+ * useful for portable Windows app
+ * @param dirName dir name, default to `data`
+ */
+declare function setPortableAppDataPath(dirName?: string): void;
+/**
+ * load `process.env.VITE_DEV_SERVER_URL` when dev, else load html file
+ * @param win window
+ * @param htmlFilePath html file path, default is `index.html`
+ */
+declare function loadPage(win: BrowserWindow, htmlFilePath?: string): void;
+declare function getPathFromPreload(...paths: string[]): string;
+declare function getPathFromPublic(...paths: string[]): string;
+declare function getPathFromEntryAsar(...paths: string[]): string;
+/**
+ * handle all unhandled error
+ * @param callback callback function
+ */
+declare function handleUnexpectedErrors(callback: (err: unknown) => void): void;
+
+/**
+ * auto check update, download and install
+ */
+declare function autoUpdate(updater: Updater): Promise<void>;
+
+export { autoUpdate, disableHWAccForWin7, getAppVersion, getEntryVersion, getPathFromAppNameAsar, getPathFromEntryAsar, getPathFromPreload, getPathFromPublic, handleUnexpectedErrors, isDev, isLinux, isMac, isWin, loadPage, requireNative, restartApp, setAppUserModelId, setPortableAppDataPath, singleInstance };

package/dist/utils.js

@@ -1,7 +1,6 @@
 export { disableHWAccForWin7, getAppVersion, getEntryVersion, getPathFromAppNameAsar, getPathFromEntryAsar, getPathFromPreload, getPathFromPublic, handleUnexpectedErrors, isDev, isLinux, isMac, isWin, loadPage, requireNative, restartApp, setAppUserModelId, setPortableAppDataPath, singleInstance } from './chunk-DFNDKSE6.js';
 export { aesDecrypt, aesEncrypt, defaultSignature, defaultUnzipFile, defaultVerifySignature, defaultZipFile, hashBuffer } from './chunk-N77WQ5WB.js';
 export { defaultIsLowerVersion, defaultVersionJsonGenerator, isUpdateJSON, parseVersion } from './chunk-72ZAJ7AF.js';
-export { isCI } from 'ci-info';
 
 // src/utils/updater.ts
 async function autoUpdate(updater) {

package/dist/vite.d.ts

@@ -0,0 +1,402 @@
+import { PluginOption } from 'vite';
+import { ElectronSimpleOptions } from 'vite-plugin-electron/simple';
+import { Promisable } from '@subframe7536/type-utils';
+import { BuildOptions } from 'esbuild';
+export { isCI } from 'ci-info';
+
+/**
+ * update info json
+ */
+type UpdateInfo = {
+    signature: string;
+    minimumVersion: string;
+    version: string;
+};
+/**
+ * {@link UpdateInfo} with beta
+ */
+type UpdateJSON = UpdateInfo & {
+    beta: UpdateInfo;
+};
+
+interface PKG {
+    name: string;
+    version: string;
+    main: string;
+}
+interface DistinguishedName {
+    countryName?: string;
+    stateOrProvinceName?: string;
+    localityName?: string;
+    organizationName?: string;
+    organizationalUnitName?: string;
+    commonName?: string;
+    serialNumber?: string;
+    title?: string;
+    description?: string;
+    businessCategory?: string;
+    emailAddress?: string;
+}
+interface BuildEntryOption {
+    /**
+     * whether to minify
+     * @default isBuild
+     */
+    minify?: boolean;
+    /**
+     * whether to generate sourcemap
+     * @default isBuild
+     */
+    sourcemap?: boolean;
+    /**
+     * path to app entry output file
+     * @default 'dist-entry'
+     */
+    entryOutputDirPath?: string;
+    /**
+     * path to app entry file
+     * @default 'electron/entry.ts'
+     */
+    appEntryPath?: string;
+    /**
+     * esbuild path map of native modules in entry directory
+     *
+     * @default {}
+     * @example
+     * { db: './electron/native/db.ts' }
+     */
+    nativeModuleEntryMap?: Record<string, string>;
+    /**
+     * custom options for esbuild
+     * ```ts
+     * // default options
+     * const options = {
+     *   entryPoints: {
+     *     entry: appEntryPath,
+     *     ...moduleEntryMap,
+     *   },
+     *   bundle: true,
+     *   platform: 'node',
+     *   outdir: entryOutputDirPath,
+     *   minify,
+     *   sourcemap,
+     *   entryNames: '[dir]/[name]',
+     *   assetNames: '[dir]/[name]',
+     *   external: ['electron', 'original-fs'],
+     *   loader: {
+     *     '.node': 'empty',
+     *   },
+     *   define: {
+     *     __SIGNATURE_CERT__: JSON.stringify(cert),
+     *   },
+     * }
+     * ```
+     */
+    overrideEsbuildOptions?: BuildOptions;
+    /**
+     * resolve extra files on startup, such as `.node`
+     * @remark won't trigger will reload
+     */
+    postBuild?: (args: {
+        /**
+         * get path from `entryOutputDirPath`
+         */
+        getPathFromEntryOutputDir: (...paths: string[]) => string;
+        /**
+         * check exist and copy file to `entryOutputDirPath`
+         *
+         * if `to` absent, set to `basename(from)`
+         *
+         * if `skipIfExist` absent, skip copy if `to` exist
+         */
+        copyToEntryOutputDir: (options: {
+            from: string;
+            to?: string;
+            /**
+             * skip copy if `to` exist
+             * @default true
+             */
+            skipIfExist?: boolean;
+        }) => void;
+    }) => Promisable<void>;
+}
+interface GeneratorOverrideFunctions {
+    /**
+     * custom signature generate function
+     * @param buffer file buffer
+     * @param privateKey private key
+     * @param cert certificate string, **EOL must be '\n'**
+     * @param version current version
+     */
+    generateSignature?: (buffer: Buffer, privateKey: string, cert: string, version: string) => string | Promise<string>;
+    /**
+     * custom generate version json function
+     * @param existingJson The existing JSON object.
+     * @param buffer file buffer
+     * @param signature generated signature
+     * @param version current version
+     * @param minVersion The minimum version
+     * @returns The updated version json
+     */
+    generateVersionJson?: (existingJson: UpdateJSON, signature: string, version: string, minVersion: string) => UpdateJSON | Promise<UpdateJSON>;
+    /**
+     * custom generate zip file buffer
+     * @param buffer source buffer
+     */
+    generateGzipFile?: (buffer: Buffer) => Promise<Buffer>;
+}
+interface ElectronUpdaterOptions {
+    /**
+     * mini version of entry
+     * @default '0.0.0'
+     */
+    minimumVersion?: string;
+    /**
+     * config for entry (app.asar)
+     */
+    entry?: BuildEntryOption;
+    /**
+     * paths config
+     */
+    paths?: {
+        /**
+         * Path to asar file
+         * @default `release/${app.name}.asar`
+         */
+        asarOutputPath?: string;
+        /**
+         * Path to version info output, content is {@link UpdateJSON}
+         * @default `version.json`
+         */
+        versionPath?: string;
+        /**
+         * Path to gzipped asar file
+         * @default `release/${app.name}-${version}.asar.gz`
+         */
+        gzipPath?: string;
+        /**
+         * Path to electron build output
+         * @default `dist-electron`
+         */
+        electronDistPath?: string;
+        /**
+         * Path to renderer build output
+         * @default `dist`
+         */
+        rendererDistPath?: string;
+    };
+    /**
+     * signature config
+     */
+    keys?: {
+        /**
+         * path to the pem file that contains private key
+         * if not ended with .pem, it will be appended
+         *
+         * **if `UPDATER_PK` is set, will read it instead of read from `privateKeyPath`**
+         * @default 'keys/private.pem'
+         */
+        privateKeyPath?: string;
+        /**
+         * path to the pem file that contains public key
+         * if not ended with .pem, it will be appended
+         *
+         * **if `UPDATER_CERT` is set, will read it instead of read from `certPath`**
+         * @default 'keys/cert.pem'
+         */
+        certPath?: string;
+        /**
+         * length of the key
+         * @default 2048
+         */
+        keyLength?: number;
+        /**
+         * X509 certificate info
+         *
+         * only generate simple **self-signed** certificate **without extensions**
+         */
+        certInfo?: {
+            /**
+             * the subject of the certificate
+             *
+             * @default { commonName: `${app.name}`, organizationName: `org.${app.name}` }
+             */
+            subject?: DistinguishedName;
+            /**
+             * expire days of the certificate
+             *
+             * @default 3650
+             */
+            days?: number;
+        };
+    };
+    overrideGenerator?: GeneratorOverrideFunctions;
+}
+
+interface BytecodeOptions {
+    /**
+     * strings that should be transformed
+     */
+    protectedStrings?: string[];
+    /**
+     * Remember to set `sandbox: false` when creating window
+     */
+    enablePreload?: boolean;
+}
+
+type MakeRequired<T, K extends keyof T> = Exclude<T, undefined> & {
+    [P in K]-?: T[P];
+};
+type ReplaceKey<T, Key extends keyof T, NewKey extends string> = Omit<T, Key> & {
+    [P in NewKey]: T[Key];
+};
+type MakeRequiredAndReplaceKey<T, K extends keyof T, NewKey extends string> = MakeRequired<ReplaceKey<T, K, NewKey>, NewKey>;
+/**
+ * startup function for debug (see {@link https://github.com/electron-vite/electron-vite-vue/blob/main/vite.config.ts electron-vite-vue template})
+ * @example
+ * import { debugStartup, buildElectronPluginOptions } from 'electron-incremental-update/vite'
+ * const options = buildElectronPluginOptions({
+ *   // ...
+ *   main: {
+ *     // ...
+ *     startup: debugStartup
+ *   },
+ * })
+ */
+declare function debugStartup(args: {
+    startup: (argv?: string[]) => Promise<void>;
+    reload: () => void;
+}): void;
+type ExcludeOutputDirOptions = {
+    vite?: {
+        build?: {
+            outDir: never;
+            rollupOptions?: {
+                output?: {
+                    dir: never;
+                };
+            };
+        };
+    };
+};
+interface ElectronWithUpdaterOptions {
+    /**
+     * whether is in build mode
+     * ```ts
+     * export default defineConfig(({ command }) => {
+     *   const isBuild = command === 'build'
+     * })
+     * ```
+     */
+    isBuild: boolean;
+    /**
+     * manually setup package.json, read name, version and main
+     * ```ts
+     * import pkg from './package.json'
+     * ```
+     */
+    pkg?: PKG;
+    /**
+     * whether to generate sourcemap
+     * @default !isBuild
+     */
+    sourcemap?: boolean;
+    /**
+     * whether to minify the code
+     * @default isBuild
+     */
+    minify?: boolean;
+    /**
+     * whether to generate bytecode
+     *
+     * **only support commonjs**
+     *
+     * only main process by default, if you want to use in preload script, please use `electronWithUpdater({ bytecode: { enablePreload: true } })` and set `sandbox: false` when creating window
+     */
+    bytecode?: boolean | BytecodeOptions;
+    /**
+     * use NotBundle() plugin in main
+     * @default true
+     */
+    useNotBundle?: boolean;
+    /**
+     * whether to generate version json
+     * @default isCI
+     */
+    buildVersionJson?: boolean;
+    /**
+     * Whether to log parsed options
+     *
+     * to show certificate and private keys, set `logParsedOptions: { showKeys: true }`
+     */
+    logParsedOptions?: boolean | {
+        showKeys: boolean;
+    };
+    /**
+     * main process options
+     *
+     * to change output directories, use `options.updater.paths.electronDistPath` instead
+     */
+    main: MakeRequiredAndReplaceKey<ElectronSimpleOptions['main'], 'entry', 'files'> & ExcludeOutputDirOptions;
+    /**
+     * preload process options
+     *
+     * to change output directories, use `options.updater.paths.electronDistPath` instead
+     */
+    preload: MakeRequiredAndReplaceKey<Exclude<ElectronSimpleOptions['preload'], undefined>, 'input', 'files'> & ExcludeOutputDirOptions;
+    /**
+     * updater options
+     */
+    updater?: ElectronUpdaterOptions;
+}
+/**
+ * build options for `vite-plugin-electron/simple`
+ * - integrate with updater
+ * - only contains `main` and `preload` configs
+ * - remove old electron files
+ * - externalize dependencies
+ * - auto restart when entry file changes
+ * - other configs in {@link https://github.com/electron-vite/electron-vite-vue/blob/main/vite.config.ts electron-vite-vue template}
+ * - no `vite-plugin-electron-renderer` config
+ *
+ * you can override all the vite configs, except output directories (use `options.updater.paths.electronDistPath` instead)
+ *
+ * @example
+ * import { defineConfig } from 'vite'
+ * import { debugStartup, electronWithUpdater } from 'electron-incremental-update/vite'
+ * import pkg from './package.json'
+ *
+ * export default defineConfig(async ({ command }) => {
+ *   const isBuild = command === 'build'
+ *   return {
+ *     plugins: [
+ *       electronWithUpdater({
+ *         pkg,
+ *         isBuild,
+ *         logParsedOptions: true,
+ *         main: {
+ *           files: ['./electron/main/index.ts', './electron/main/worker.ts'],
+ *           // see https://github.com/electron-vite/electron-vite-vue/blob/85ed267c4851bf59f32888d766c0071661d4b94c/vite.config.ts#L22-L28
+ *           onstart: debugStartup,
+ *         },
+ *         preload: {
+ *           files: './electron/preload/index.ts',
+ *         },
+ *         updater: {
+ *           // options
+ *         }
+ *       }),
+ *     ],
+ *     server: process.env.VSCODE_DEBUG && (() => {
+ *       const url = new URL(pkg.debug.env.VITE_DEV_SERVER_URL)
+ *       return {
+ *         host: url.hostname,
+ *         port: +url.port,
+ *       }
+ *     })(),
+ *   }
+ * })
+ */
+declare function electronWithUpdater(options: ElectronWithUpdaterOptions): Promise<PluginOption[] | undefined>;
+
+export { type ElectronWithUpdaterOptions, debugStartup, electronWithUpdater };