electron-incremental-update 2.4.0 → 2.4.2

package/README.md

@@ -127,6 +127,35 @@ export default defineConfig(async ({ command }) => {
 })
 ```
 
+Or use the helper function
+
+```ts
+import { defineElectronConfig } from 'electron-incremental-update/vite'
+
+export default defineElectronConfig({
+  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
+  },
+  renderer: {
+    server: process.env.VSCODE_DEBUG && (() => {
+      const url = new URL(pkg.debug.env.VITE_DEV_SERVER_URL)
+      return {
+        host: url.hostname,
+        port: +url.port,
+      }
+    })(),
+  }
+})
+```
+
 ### Modify package.json
 
 ```json
@@ -838,10 +867,10 @@ export interface ElectronWithUpdaterOptions {
   /**
    * Updater options
    */
-  updater?: ElectronUpdaterOptions
+  updater?: UpdaterOptions
 }
 
-export interface ElectronUpdaterOptions {
+export interface UpdaterOptions {
   /**
    * Minimum version of entry
    * @default '0.0.0'

package/dist/vite.d.ts

@@ -1,26 +1,20 @@
 import { Promisable, AnyFunction } from '@subframe7536/type-utils';
-import { InlineConfig, PluginOption } from 'vite';
+import { InlineConfig, PluginOption, UserConfig, UserConfigFn } from 'vite';
+import { ElectronOptions } from 'vite-plugin-electron';
 import { ElectronSimpleOptions } from 'vite-plugin-electron/simple';
 export { isCI } from 'ci-info';
 export { getPackageInfo, getPackageInfoSync, loadPackageJSON, resolveModule } from 'local-pkg';
 
-interface BytecodeOptions {
-    enable: boolean;
-    /**
-     * Enable in preload script. Remember to set `sandbox: false` when creating window
-     */
-    preload?: boolean;
-    /**
-     * Custom electron binary path
-     */
-    electronPath?: string;
-    /**
-     * Before transformed code compile function. If return `Falsy` value, it will be ignored
-     * @param code transformed code
-     * @param id file path
-     */
-    beforeCompile?: (code: string, id: string) => Promisable<string | null | undefined | void>;
-}
+/**
+ * Obfuscate string
+ * @param code source code
+ * @param sourcemap whether to generate sourcemap
+ * @param offset custom offset
+ */
+declare function convertLiteral(code: string, sourcemap?: boolean, offset?: number): {
+    code: string;
+    map?: any;
+};
 
 /**
  * Update info json
@@ -49,6 +43,24 @@ type UpdateJSON = UpdateInfo & {
     beta: UpdateInfo;
 };
 
+interface BytecodeOptions {
+    enable: boolean;
+    /**
+     * Enable in preload script. Remember to set `sandbox: false` when creating window
+     */
+    preload?: boolean;
+    /**
+     * Custom electron binary path
+     */
+    electronPath?: string;
+    /**
+     * Before transformed code compile function. If return `Falsy` value, it will be ignored
+     * @param code transformed code
+     * @param id file path
+     */
+    beforeCompile?: (code: string, id: string) => Promisable<string | null | undefined | void>;
+}
+
 interface DistinguishedName {
     countryName?: string;
     stateOrProvinceName?: string;
@@ -69,6 +81,105 @@ interface PKG {
     main: string;
     type: 'commonjs' | 'module';
 }
+interface ViteOverride {
+    /**
+     * Override vite options
+     */
+    vite?: ElectronOptions['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,
+     * use `local-pkg` of `loadPackageJSON()` to load package.json by default
+     * ```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;
+    /**
+     * Main process options
+     *
+     * To change output directories, use `options.updater.paths.electronDistPath` instead
+     */
+    main: {
+        /**
+         * Shortcut of `build.rollupOptions.input`
+         */
+        files: NonNullable<ElectronOptions['entry']>;
+        /**
+         * Electron App startup function.
+         *
+         * It will mount the Electron App child-process to `process.electronApp`.
+         * @param argv default value `['.', '--no-sandbox']`
+         * @param options options for `child_process.spawn`
+         * @param customElectronPkg custom electron package name (default: 'electron')
+         */
+        onstart?: ElectronOptions['onstart'];
+    } & ViteOverride;
+    /**
+     * Preload process options
+     *
+     * To change output directories, use `options.updater.paths.electronDistPath` instead
+     */
+    preload: {
+        /**
+         * Shortcut of `build.rollupOptions.input`.
+         *
+         * Preload scripts may contain Web assets, so use the `build.rollupOptions.input` instead `build.lib.entry`.
+         */
+        files: NonNullable<ElectronOptions['entry']>;
+    } & ViteOverride;
+    /**
+     * Updater options
+     */
+    updater?: UpdaterOptions;
+}
 interface BuildEntryOption {
     /**
      * Override to minify on entry
@@ -197,7 +308,7 @@ interface GeneratorOverrideFunctions {
      */
     generateGzipFile?: (buffer: Buffer) => Promisable<Buffer>;
 }
-interface ElectronUpdaterOptions {
+interface UpdaterOptions {
     /**
      * Minimum version of entry
      * @default '0.0.0'
@@ -285,24 +396,6 @@ interface ElectronUpdaterOptions {
     overrideGenerator?: GeneratorOverrideFunctions;
 }
 
-/**
- * Obfuscate string
- * @param code source code
- * @param sourcemap whether to generate sourcemap
- * @param offset custom offset
- */
-declare function convertLiteral(code: string, sourcemap?: boolean, offset?: number): {
-    code: string;
-    map?: any;
-};
-
-type MakeRequired<T, K extends keyof T> = NonNullable<T> & {
-    [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>;
 type StartupFn = NonNullable<NonNullable<ElectronSimpleOptions['main']>['onstart']>;
 /**
  * Startup function for debug
@@ -349,81 +442,6 @@ declare function filterErrorMessageStartup(args: Parameters<StartupFn>[0], filte
  * })
  */
 declare function fixWinCharEncoding<T extends AnyFunction>(fn: T): T;
-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,
-     * use `local-pkg` of `loadPackageJSON()` to load package.json by default
-     * ```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;
-    /**
-     * 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;
-}
 /**
  * Base on `vite-plugin-electron/simple`
  * - integrate with updater
@@ -472,4 +490,44 @@ interface ElectronWithUpdaterOptions {
  */
 declare function electronWithUpdater(options: ElectronWithUpdaterOptions): Promise<PluginOption[] | undefined>;
 
-export { type ElectronWithUpdaterOptions, convertLiteral, debugStartup, electronWithUpdater as default, electronWithUpdater, filterErrorMessageStartup, fixWinCharEncoding };
+type MakeOptional<T, K extends keyof T> = Partial<Pick<T, K>> & Omit<T, K>;
+interface ElectronViteHelperOptions extends MakeOptional<ElectronWithUpdaterOptions, 'isBuild'> {
+    /**
+     * Config for renderer process
+     */
+    renderer?: UserConfig;
+}
+/**
+ * Vite config helper
+ * @see {@link electronWithUpdater}
+ * @example
+ * ```ts
+ * import { defineElectronConfig } from 'electron-incremental-update/vite'
+ *
+ * export default defineElectronConfig({
+ *   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
+ *   },
+ *   renderer: {
+ *     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 defineElectronConfig(options: ElectronViteHelperOptions): UserConfigFn;
+
+export { type ElectronViteHelperOptions, type ElectronWithUpdaterOptions, convertLiteral, debugStartup, electronWithUpdater as default, defineElectronConfig, electronWithUpdater, filterErrorMessageStartup, fixWinCharEncoding };

package/dist/vite.js

@@ -1,23 +1,23 @@
+import cp from 'child_process';
 import fs5 from 'fs';
 import path5 from 'path';
-import { isCI } from 'ci-info';
-export { isCI } from 'ci-info';
+import * as babel from '@babel/core';
 import { getPackageInfoSync, loadPackageJSON } from 'local-pkg';
 export { getPackageInfo, getPackageInfoSync, loadPackageJSON, resolveModule } from 'local-pkg';
+import MagicString from 'magic-string';
 import { createLogger, normalizePath, mergeConfig, createFilter } from 'vite';
+import { isCI } from 'ci-info';
+export { isCI } from 'ci-info';
 import { startup, build } from 'vite-plugin-electron';
 import { notBundle } from 'vite-plugin-electron/plugin';
 import ElectronSimple from 'vite-plugin-electron/simple';
 import Asar from '@electron/asar';
-import MagicString from 'magic-string';
-import cp from 'child_process';
-import * as babel from '@babel/core';
 import { builtinModules } from 'module';
 import crypto from 'crypto';
 import zlib from 'zlib';
 import { generate } from 'selfsigned';
 
-// src/vite/index.ts
+// src/vite/bytecode/utils.ts
 
 // src/utils/version.ts
 function parseVersion(version) {
@@ -65,28 +65,12 @@ var bytecodeId = `${id}-bytecode`;
 var esmId = `${id}-esm`;
 var log = createLogger("info", { prefix: `[${id}]` });
 var bytecodeLog = createLogger("info", { prefix: `[${bytecodeId}]` });
-function readableSize(size) {
-  const units = ["B", "KB", "MB", "GB"];
-  let i = 0;
-  while (size >= 1024 && i < units.length - 1) {
-    size /= 1024;
-    i++;
-  }
-  return `${size.toFixed(2)} ${units[i]}`;
-}
-function copyAndSkipIfExist(from, to, skipIfExist) {
-  if (!skipIfExist || !fs5.existsSync(to)) {
-    try {
-      fs5.cpSync(from, to, { recursive: true });
-    } catch (error) {
-      log.warn(`Copy failed: ${error}`, { timestamp: true });
-    }
-  }
-}
 
 // src/vite/bytecode/code.ts
 var bytecodeGeneratorScript = "const vm = require('vm')\nconst v8 = require('v8')\nconst wrap = require('module').wrap\nv8.setFlagsFromString('--no-lazy')\nv8.setFlagsFromString('--no-flush-bytecode')\nlet code = ''\nprocess.stdin.setEncoding('utf-8')\nprocess.stdin.on('readable', () => {\n  const data = process.stdin.read()\n  if (data !== null) {\n    code += data\n  }\n})\nprocess.stdin.on('end', () => {\n  try {\n    if (typeof code !== 'string') {\n      throw new Error('javascript code must be string.')\n    }\n    const script = new vm.Script(wrap(code), { produceCachedData: true })\n    const bytecodeBuffer = script.createCachedData()\n    process.stdout.write(bytecodeBuffer)\n  } catch (error) {\n    console.error(error)\n  }\n})\n";
 var bytecodeModuleLoaderCode = '"use strict";\nconst fs = require("fs");\nconst path = require("path");\nconst vm = require("vm");\nconst v8 = require("v8");\nconst Module = require("module");\nv8.setFlagsFromString("--no-lazy");\nv8.setFlagsFromString("--no-flush-bytecode");\nconst FLAG_HASH_OFFSET = 12;\nconst SOURCE_HASH_OFFSET = 8;\nlet dummyBytecode;\nfunction setFlagHashHeader(bytecodeBuffer) {\n  if (!dummyBytecode) {\n    const script = new vm.Script("", {\n      produceCachedData: true\n    });\n    dummyBytecode = script.createCachedData();\n  }\n  dummyBytecode.slice(FLAG_HASH_OFFSET, FLAG_HASH_OFFSET + 4).copy(bytecodeBuffer, FLAG_HASH_OFFSET);\n};\nfunction getSourceHashHeader(bytecodeBuffer) {\n  return bytecodeBuffer.slice(SOURCE_HASH_OFFSET, SOURCE_HASH_OFFSET + 4);\n};\nfunction buffer2Number(buffer) {\n  let ret = 0;\n  ret |= buffer[3] << 24;\n  ret |= buffer[2] << 16;\n  ret |= buffer[1] << 8;\n  ret |= buffer[0];\n  return ret;\n};\nModule._extensions[".jsc"] = Module._extensions[".cjsc"] = function (module, filename) {\n  const bytecodeBuffer = fs.readFileSync(filename);\n  if (!Buffer.isBuffer(bytecodeBuffer)) {\n    throw new Error("BytecodeBuffer must be a buffer object.");\n  }\n  setFlagHashHeader(bytecodeBuffer);\n  const length = buffer2Number(getSourceHashHeader(bytecodeBuffer));\n  let dummyCode = "";\n  if (length > 1) {\n    dummyCode = "\\"" + "\\u200b".repeat(length - 2) + "\\"";\n  }\n  const script = new vm.Script(dummyCode, {\n    filename: filename,\n    lineOffset: 0,\n    displayErrors: true,\n    cachedData: bytecodeBuffer\n  });\n  if (script.cachedDataRejected) {\n    throw new Error("Invalid or incompatible cached data (cachedDataRejected)");\n  }\n  const require = function (id) {\n    return module.require(id);\n  };\n  require.resolve = function (request, options) {\n    return Module._resolveFilename(request, module, false, options);\n  };\n  if (process.mainModule) {\n    require.main = process.mainModule;\n  }\n  require.extensions = Module._extensions;\n  require.cache = Module._cache;\n  const compiledWrapper = script.runInThisContext({\n    filename: filename,\n    lineOffset: 0,\n    columnOffset: 0,\n    displayErrors: true\n  });\n  const dirname = path.dirname(filename);\n  const args = [module.exports, require, module, filename, dirname, process, global];\n  return compiledWrapper.apply(module.exports, args);\n};\n';
+
+// src/vite/bytecode/utils.ts
 var electronModule = getPackageInfoSync("electron");
 var electronMajorVersion = parseVersion(electronModule.version).major;
 var useStrict = "'use strict';";
@@ -222,6 +206,24 @@ function convertLiteral(code, sourcemap, offset) {
     map: sourcemap ? s.generateMap({ hires: true }) : void 0
   };
 }
+function readableSize(size) {
+  const units = ["B", "KB", "MB", "GB"];
+  let i = 0;
+  while (size >= 1024 && i < units.length - 1) {
+    size /= 1024;
+    i++;
+  }
+  return `${size.toFixed(2)} ${units[i]}`;
+}
+function copyAndSkipIfExist(from, to, skipIfExist) {
+  if (!skipIfExist || !fs5.existsSync(to)) {
+    try {
+      fs5.cpSync(from, to, { recursive: true });
+    } catch (error) {
+      log.warn(`Copy failed: ${error}`, { timestamp: true });
+    }
+  }
+}
 
 // src/vite/bytecode/index.ts
 function getBytecodeLoaderBlock(chunkFileName) {
@@ -672,7 +674,8 @@ function parseOptions(isBuild, pkg, sourcemap = false, minify = false, options =
   };
   return { buildAsarOption, buildEntryOption, buildVersionOption, postBuild, cert };
 }
-var vite_default = electronWithUpdater;
+
+// src/vite/core.ts
 var debugStartup = async (args) => {
   if (process.env.VSCODE_DEBUG) {
     console.log("[startup] Electron App");
@@ -851,7 +854,6 @@ async function electronWithUpdater(options) {
     },
     preload: {
       input: _preload.files,
-      onstart: _preload.onstart,
       vite: mergeConfig(
         {
           plugins: [
@@ -928,4 +930,16 @@ async function electronWithUpdater(options) {
   return result;
 }
 
-export { convertLiteral, debugStartup, vite_default as default, electronWithUpdater, filterErrorMessageStartup, fixWinCharEncoding };
+// src/vite/define.ts
+function defineElectronConfig(options) {
+  return ({ command }) => {
+    options.isBuild ??= command === "build";
+    const electronPlugin = electronWithUpdater(options);
+    const result = options.renderer ?? {};
+    result.plugins ??= [];
+    result.plugins.push(electronPlugin);
+    return result;
+  };
+}
+
+export { convertLiteral, debugStartup, electronWithUpdater as default, defineElectronConfig, electronWithUpdater, filterErrorMessageStartup, fixWinCharEncoding };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "electron-incremental-update",
   "type": "module",
-  "version": "2.4.0",
+  "version": "2.4.2",
   "description": "Electron incremental update tools with Vite plugin, support bytecode protection",
   "author": "subframe7536",
   "license": "MIT",