electron-incremental-update 2.0.0-beta.3 → 2.0.0-beta.5

package/dist/{types-DxhNaNgR.d.ts → types-C5P0h_bB.d.ts}

@@ -1,5 +1,30 @@
 import { Promisable } from '@subframe7536/type-utils';
-import { U as UpdateJSON, a as UpdateInfo } from './version-CemSHimT.js';
+
+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;
@@ -10,10 +35,14 @@ interface DownloadingInfo {
     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;
     /**
@@ -57,11 +86,10 @@ interface IProvider {
      */
     isLowerVersion: (oldVer: string, newVer: string) => boolean;
     /**
-     * unzip file
+     * unzip file buffer
      * @param buffer source buffer
-     * @param targetFilePath target file path
      */
-    unzipFile: (buffer: Buffer, targetFilePath: string) => Promise<void>;
+    unzipFile: (buffer: Buffer) => Promise<Buffer>;
     /**
      * verify asar signature
      * @param buffer file buffer
@@ -72,4 +100,4 @@ interface IProvider {
     verifySignaure: (buffer: Buffer, signature: string, cert: string) => Promisable<string | undefined>;
 }
 
-export type { DownloadingInfo as D, IProvider as I, OnDownloading as O, URLHandler as U };
+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

@@ -82,34 +82,34 @@ function getPathFromPublic(...paths) {
 function getPathFromEntryAsar(...paths) {
   return path.join(electron.app.getAppPath(), __EIU_ENTRY_DIST_PATH__, ...paths);
 }
-async function defaultZipFile(buffer, targetFilePath) {
+function handleUnexpectedErrors(callback) {
+  process.on("uncaughtException", callback);
+  process.on("unhandledRejection", callback);
+}
+async function defaultZipFile(buffer) {
   return new Promise((resolve, reject) => {
     zlib.brotliCompress(buffer, (err, buffer2) => {
       if (err) {
         reject(err);
+      } else {
+        resolve(buffer2);
       }
-      fs.writeFileSync(targetFilePath, buffer2);
-      resolve();
     });
   });
 }
-async function defaultUnzipFile(buffer, targetFilePath) {
+async function defaultUnzipFile(buffer) {
   return new Promise((resolve, reject) => {
     zlib.brotliDecompress(buffer, (err, buffer2) => {
       if (err) {
         reject(err);
+      } else {
+        resolve(buffer2);
       }
-      fs.writeFileSync(targetFilePath, buffer2);
-      resolve();
     });
   });
 }
 
 // src/utils/version.ts
-function handleUnexpectedErrors(callback) {
-  process.on("uncaughtException", callback);
-  process.on("unhandledRejection", callback);
-}
 function parseVersion(version) {
   const match = /^(\d+)\.(\d+)\.(\d+)(?:-([a-z0-9.-]+))?/i.exec(version);
   if (!match) {
@@ -154,21 +154,19 @@ function defaultIsLowerVersion(oldVer, newVer) {
   return false;
 }
 function isUpdateJSON(json) {
-  const is = (j) => !!(j && j.minimumVersion && j.signature && j.size && j.version);
+  const is = (j) => !!(j && j.minimumVersion && j.signature && j.version);
   return is(json) && is(json?.beta);
 }
-function defaultVersionJsonGenerator(existingJson, buffer, signature, version, minimumVersion) {
+function defaultVersionJsonGenerator(existingJson, signature, version, minimumVersion) {
   existingJson.beta = {
     version,
     minimumVersion,
-    signature,
-    size: buffer.length
+    signature
   };
   if (!parseVersion(version).stage) {
     existingJson.version = version;
     existingJson.minimumVersion = minimumVersion;
     existingJson.signature = signature;
-    existingJson.size = buffer.length;
   }
   return existingJson;
 }
@@ -198,8 +196,16 @@ function defaultVerify(buffer, signature, cert) {
   }
 }
 
+// src/utils/updater.ts
+async function autoUpdate(updater) {
+  if (await updater.checkUpdate() && await updater.downloadUpdate()) {
+    updater.quitAndInstall();
+  }
+}
+
 exports.aesDecrypt = aesDecrypt;
 exports.aesEncrypt = aesEncrypt;
+exports.autoUpdate = autoUpdate;
 exports.defaultIsLowerVersion = defaultIsLowerVersion;
 exports.defaultSignature = defaultSignature;
 exports.defaultUnzipFile = defaultUnzipFile;

package/dist/utils.d.cts

@@ -1,6 +1,9 @@
 import { BrowserWindow } from 'electron';
-export { c as aesDecrypt, a as aesEncrypt, b as defaultSignature, d as defaultUnzipFile, e as defaultVerify, h as hashBuffer } from './unzip-JjYLjJkH.cjs';
-export { a as UpdateInfo, U as UpdateJSON, V as Version, d as defaultIsLowerVersion, b as defaultVersionJsonGenerator, h as handleUnexpectedErrors, i as isUpdateJSON, p as parseVersion } from './version-CemSHimT.cjs';
+export { e as aesDecrypt, b as aesEncrypt, c as defaultSignature, a as defaultUnzipFile, f as defaultVerify, d as defaultZipFile, h as hashBuffer } from './zip-WRrEMkgp.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-C5P0h_bB.cjs';
+import { U as Updater } from './core-DmU2Vk_S.cjs';
+import '@subframe7536/type-utils';
+import 'node:events';
 
 /**
  * compile time dev check
@@ -63,7 +66,15 @@ 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;
 
-declare function defaultZipFile(buffer: Buffer, targetFilePath: string): Promise<void>;
+/**
+ * auto check update, download and install
+ */
+declare function autoUpdate(updater: Updater): Promise<void>;
 
-export { defaultZipFile, disableHWAccForWin7, getAppVersion, getEntryVersion, getPathFromAppNameAsar, getPathFromEntryAsar, getPathFromPreload, getPathFromPublic, isDev, isLinux, isMac, isWin, loadPage, requireNative, restartApp, setAppUserModelId, setPortableAppDataPath, singleInstance };
+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

@@ -1,6 +1,9 @@
 import { BrowserWindow } from 'electron';
-export { c as aesDecrypt, a as aesEncrypt, b as defaultSignature, d as defaultUnzipFile, e as defaultVerify, h as hashBuffer } from './unzip-JjYLjJkH.js';
-export { a as UpdateInfo, U as UpdateJSON, V as Version, d as defaultIsLowerVersion, b as defaultVersionJsonGenerator, h as handleUnexpectedErrors, i as isUpdateJSON, p as parseVersion } from './version-CemSHimT.js';
+export { e as aesDecrypt, b as aesEncrypt, c as defaultSignature, a as defaultUnzipFile, f as defaultVerify, d as defaultZipFile, h as hashBuffer } from './zip-WRrEMkgp.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-C5P0h_bB.js';
+import { U as Updater } from './core-CXETH_bb.js';
+import '@subframe7536/type-utils';
+import 'node:events';
 
 /**
  * compile time dev check
@@ -63,7 +66,15 @@ 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;
 
-declare function defaultZipFile(buffer: Buffer, targetFilePath: string): Promise<void>;
+/**
+ * auto check update, download and install
+ */
+declare function autoUpdate(updater: Updater): Promise<void>;
 
-export { defaultZipFile, disableHWAccForWin7, getAppVersion, getEntryVersion, getPathFromAppNameAsar, getPathFromEntryAsar, getPathFromPreload, getPathFromPublic, isDev, isLinux, isMac, isWin, loadPage, requireNative, restartApp, setAppUserModelId, setPortableAppDataPath, singleInstance };
+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,19 +1,12 @@
-export { disableHWAccForWin7, getAppVersion, getEntryVersion, getPathFromAppNameAsar, getPathFromEntryAsar, getPathFromPreload, getPathFromPublic, isDev, isLinux, isMac, isWin, loadPage, requireNative, restartApp, setAppUserModelId, setPortableAppDataPath, singleInstance } from './chunk-PNYRQYFC.js';
-export { aesDecrypt, aesEncrypt, defaultSignature, defaultUnzipFile, defaultVerify, hashBuffer } from './chunk-5WFXC5GU.js';
-export { defaultIsLowerVersion, defaultVersionJsonGenerator, handleUnexpectedErrors, isUpdateJSON, parseVersion } from './chunk-BVFQWBLK.js';
-import { writeFileSync } from 'node:fs';
-import { brotliCompress } from 'node:zlib';
+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, defaultVerify, defaultZipFile, hashBuffer } from './chunk-JSYIRKTR.js';
+export { defaultIsLowerVersion, defaultVersionJsonGenerator, isUpdateJSON, parseVersion } from './chunk-72ZAJ7AF.js';
 
-async function defaultZipFile(buffer, targetFilePath) {
-  return new Promise((resolve, reject) => {
-    brotliCompress(buffer, (err, buffer2) => {
-      if (err) {
-        reject(err);
-      }
-      writeFileSync(targetFilePath, buffer2);
-      resolve();
-    });
-  });
+// src/utils/updater.ts
+async function autoUpdate(updater) {
+  if (await updater.checkUpdate() && await updater.downloadUpdate()) {
+    updater.quitAndInstall();
+  }
 }
 
-export { defaultZipFile };
+export { autoUpdate };

package/dist/vite.d.ts

@@ -0,0 +1,401 @@
+import { PluginOption } from 'vite';
+import { ElectronSimpleOptions } from 'vite-plugin-electron/simple';
+import { Promisable } from '@subframe7536/type-utils';
+import { BuildOptions } from 'esbuild';
+
+/**
+ * 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 };