electron-incremental-update 2.0.0-beta.9 → 2.0.0

package/dist/vite.d.ts

@@ -5,7 +5,7 @@ import { BuildOptions } from 'esbuild';
 export { isCI } from 'ci-info';
 
 /**
- * update info json
+ * Update info json
  */
 type UpdateInfo = {
     signature: string;
@@ -23,6 +23,7 @@ interface PKG {
     name: string;
     version: string;
     main: string;
+    type: 'commonjs' | 'module';
 }
 interface DistinguishedName {
     countryName?: string;
@@ -39,27 +40,26 @@ interface DistinguishedName {
 }
 interface BuildEntryOption {
     /**
-     * whether to minify
+     * Override to minify on entry
      * @default isBuild
      */
     minify?: boolean;
     /**
-     * whether to generate sourcemap
-     * @default isBuild
+     * Override to generate sourcemap on entry
      */
     sourcemap?: boolean;
     /**
-     * path to app entry output file
+     * Path to app entry output file
      * @default 'dist-entry'
      */
     entryOutputDirPath?: string;
     /**
-     * path to app entry file
+     * Path to app entry file
      * @default 'electron/entry.ts'
      */
     appEntryPath?: string;
     /**
-     * esbuild path map of native modules in entry directory
+     * Esbuild path map of native modules in entry directory
      *
      * @default {}
      * @example
@@ -67,7 +67,7 @@ interface BuildEntryOption {
      */
     nativeModuleEntryMap?: Record<string, string>;
     /**
-     * custom options for esbuild
+     * Custom options for esbuild
      * ```ts
      * // default options
      * const options = {
@@ -86,34 +86,32 @@ interface BuildEntryOption {
      *   loader: {
      *     '.node': 'empty',
      *   },
-     *   define: {
-     *     __SIGNATURE_CERT__: JSON.stringify(cert),
-     *   },
+     *   define,
      * }
      * ```
      */
     overrideEsbuildOptions?: BuildOptions;
     /**
-     * resolve extra files on startup, such as `.node`
+     * Resolve extra files on startup, such as `.node`
      * @remark won't trigger will reload
      */
     postBuild?: (args: {
         /**
-         * get path from `entryOutputDirPath`
+         * Get path from `entryOutputDirPath`
          */
         getPathFromEntryOutputDir: (...paths: string[]) => string;
         /**
-         * check exist and copy file to `entryOutputDirPath`
+         * Check exist and copy file to `entryOutputDirPath`
          *
-         * if `to` absent, set to `basename(from)`
+         * If `to` absent, set to `basename(from)`
          *
-         * if `skipIfExist` absent, skip copy if `to` exist
+         * If `skipIfExist` absent, skip copy if `to` exist
          */
         copyToEntryOutputDir: (options: {
             from: string;
             to?: string;
             /**
-             * skip copy if `to` exist
+             * Skip copy if `to` exist
              * @default true
              */
             skipIfExist?: boolean;
@@ -122,15 +120,15 @@ interface BuildEntryOption {
 }
 interface GeneratorOverrideFunctions {
     /**
-     * custom signature generate function
+     * 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>;
+    generateSignature?: (buffer: Buffer, privateKey: string, cert: string, version: string) => Promisable<string>;
     /**
-     * custom generate version json function
+     * Custom generate version json function
      * @param existingJson The existing JSON object.
      * @param buffer file buffer
      * @param signature generated signature
@@ -138,25 +136,25 @@ interface GeneratorOverrideFunctions {
      * @param minVersion The minimum version
      * @returns The updated version json
      */
-    generateVersionJson?: (existingJson: UpdateJSON, signature: string, version: string, minVersion: string) => UpdateJSON | Promise<UpdateJSON>;
+    generateVersionJson?: (existingJson: UpdateJSON, signature: string, version: string, minVersion: string) => Promisable<UpdateJSON>;
     /**
-     * custom generate zip file buffer
+     * Custom generate zip file buffer
      * @param buffer source buffer
      */
-    generateGzipFile?: (buffer: Buffer) => Promise<Buffer>;
+    generateGzipFile?: (buffer: Buffer) => Promisable<Buffer>;
 }
 interface ElectronUpdaterOptions {
     /**
-     * mini version of entry
+     * Minimum version of entry
      * @default '0.0.0'
      */
     minimumVersion?: string;
     /**
-     * config for entry (app.asar)
+     * Options for entry (app.asar)
      */
     entry?: BuildEntryOption;
     /**
-     * paths config
+     * Options for paths
      */
     paths?: {
         /**
@@ -190,40 +188,40 @@ interface ElectronUpdaterOptions {
      */
     keys?: {
         /**
-         * path to the pem file that contains private key
-         * if not ended with .pem, it will be appended
+         * 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`**
+         * **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
+         * 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`**
+         * **If `UPDATER_CERT` is set, will read it instead of read from `certPath`**
          * @default 'keys/cert.pem'
          */
         certPath?: string;
         /**
-         * length of the key
+         * Length of the key
          * @default 2048
          */
         keyLength?: number;
         /**
          * X509 certificate info
          *
-         * only generate simple **self-signed** certificate **without extensions**
+         * Only generate simple **self-signed** certificate **without extensions**
          */
         certInfo?: {
             /**
-             * the subject of the certificate
+             * The subject of the certificate
              *
              * @default { commonName: `${app.name}`, organizationName: `org.${app.name}` }
              */
             subject?: DistinguishedName;
             /**
-             * expire days of the certificate
+             * Expire days of the certificate
              *
              * @default 3650
              */
@@ -236,15 +234,15 @@ interface ElectronUpdaterOptions {
 interface BytecodeOptions {
     enable: boolean;
     /**
-     * Remember to set `sandbox: false` when creating window
+     * Enable in preload script. Remember to set `sandbox: false` when creating window
      */
     preload?: boolean;
     /**
-     * before transformed code compile callback, if return `null` or `undefined`, it will be ignored
+     * 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>;
+    beforeCompile?: (code: string, id: string) => Promisable<string | null | undefined | void>;
 }
 
 type MakeRequired<T, K extends keyof T> = Exclude<T, undefined> & {
@@ -284,7 +282,7 @@ type ExcludeOutputDirOptions = {
 };
 interface ElectronWithUpdaterOptions {
     /**
-     * whether is in build mode
+     * Whether is in build mode
      * ```ts
      * export default defineConfig(({ command }) => {
      *   const isBuild = command === 'build'
@@ -293,113 +291,79 @@ interface ElectronWithUpdaterOptions {
      */
     isBuild: boolean;
     /**
-     * manually setup package.json, read name, version and main
+     * 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
+     * Whether to generate sourcemap
      * @default !isBuild
      */
     sourcemap?: boolean;
     /**
-     * whether to minify the code
+     * Whether to minify the code
      * @default isBuild
      */
     minify?: boolean;
     /**
-     * whether to generate bytecode
+     * Whether to generate bytecode
      *
-     * **only support commonjs**
+     * **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
+     * 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
+     * Use `NotBundle()` plugin in main
      * @default true
      */
     useNotBundle?: boolean;
     /**
-     * whether to generate version json
+     * Whether to generate version json
      * @default isCI
      */
     buildVersionJson?: boolean;
     /**
      * Whether to log parsed options
      *
-     * to show certificate and private keys, set `logParsedOptions: { showKeys: true }`
+     * To show certificate and private keys, set `logParsedOptions: { showKeys: true }`
      */
     logParsedOptions?: boolean | {
         showKeys: boolean;
     };
     /**
-     * main process options
+     * Main process options
      *
-     * to change output directories, use `options.updater.paths.electronDistPath` instead
+     * To change output directories, use `options.updater.paths.electronDistPath` instead
      */
     main: MakeRequiredAndReplaceKey<ElectronSimpleOptions['main'], 'entry', 'files'> & ExcludeOutputDirOptions;
     /**
-     * preload process options
+     * Preload process options
      *
-     * to change output directories, use `options.updater.paths.electronDistPath` instead
+     * To change output directories, use `options.updater.paths.electronDistPath` instead
      */
     preload: MakeRequiredAndReplaceKey<Exclude<ElectronSimpleOptions['preload'], undefined>, 'input', 'files'> & ExcludeOutputDirOptions;
     /**
-     * updater options
+     * Updater options
      */
     updater?: ElectronUpdaterOptions;
 }
 /**
- * build options for `vite-plugin-electron/simple`
+ * Base on `vite-plugin-electron/simple`
  * - integrate with updater
- * - only contains `main` and `preload` configs
- * - remove old electron files
+ * - no `renderer` config
+ * - remove old output file
  * - 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)
+ * 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 };
+export { type ElectronWithUpdaterOptions, debugStartup, electronWithUpdater as default, electronWithUpdater };

package/dist/vite.js

@@ -38,7 +38,7 @@ function parseVersion(version) {
     ret.stageVersion = Number(_v) || -1;
   }
   if (Number.isNaN(major) || Number.isNaN(minor) || Number.isNaN(patch) || Number.isNaN(ret.stageVersion)) {
-    throw new TypeError(`invalid version: ${version}`);
+    throw new TypeError(`Invalid version: ${version}`);
   }
   return ret;
 }
@@ -91,7 +91,7 @@ function getElectronPath() {
   return electronExecPath;
 }
 function getBytecodeCompilerPath() {
-  const scriptPath = path5.join(electronModulePath, "bytenode.cjs");
+  const scriptPath = path5.join(electronModulePath, "EIU_bytenode.cjs");
   if (!fs3.existsSync(scriptPath)) {
     fs3.writeFileSync(scriptPath, bytecodeGeneratorScript);
   }
@@ -140,7 +140,7 @@ function convertArrowFunctionAndTemplate(code) {
 }
 var decodeFn = ";function _0xstr_(a,b){return String.fromCharCode.apply(0,a.map(function(x){return x-b}))};";
 function obfuscateString(input, offset = ~~(Math.random() * 16) + 1) {
-  const hexArray = input.split("").map((c) => "0x" + (c.charCodeAt(0) + offset).toString(16));
+  const hexArray = input.split("").map((c) => `0x${(c.charCodeAt(0) + offset).toString(16)}`);
   return `_0xstr_([${hexArray.join(",")}],${offset})`;
 }
 function convertLiteral(code, sourcemap, offset) {
@@ -148,7 +148,7 @@ function convertLiteral(code, sourcemap, offset) {
   let hasTransformed = false;
   const ast = babel.parse(code, { ast: true });
   if (!ast) {
-    throw new Error("cannot parse code");
+    throw new Error("Cannot parse code");
   }
   babel.traverse(ast, {
     StringLiteral(path6) {
@@ -168,6 +168,9 @@ function convertLiteral(code, sourcemap, offset) {
       if (parent.type.startsWith("Import")) {
         return;
       }
+      if (parent.type === "ObjectMethod" && parent.key === node) {
+        return;
+      }
       if (parent.type === "ObjectProperty" && parent.key === node) {
         const result2 = `[${obfuscateString(node.value, offset)}]`;
         const start2 = node.start;
@@ -224,7 +227,7 @@ async function buildAsar({
   await Asar.createPackage(electronDistPath, asarOutputPath);
   const buf = await generateGzipFile(fs3.readFileSync(asarOutputPath));
   fs3.writeFileSync(gzipPath, buf);
-  log.info(`build update asar to '${gzipPath}' [${readableSize(buf.length)}]`, { timestamp: true });
+  log.info(`Build update asar to '${gzipPath}' [${readableSize(buf.length)}]`, { timestamp: true });
   return buf;
 }
 async function buildVersion({
@@ -252,7 +255,7 @@ async function buildVersion({
       if (isUpdateJSON(oldVersionJson)) {
         _json = oldVersionJson;
       } else {
-        log.warn("old version json is invalid, ignore it", { timestamp: true });
+        log.warn("Old version json is invalid, ignore it", { timestamp: true });
       }
     } catch {
     }
@@ -260,7 +263,7 @@ async function buildVersion({
   const sig = await generateSignature(asarBuffer, privateKey, cert, version);
   _json = await generateVersionJson(_json, sig, version, minimumVersion);
   if (!isUpdateJSON(_json)) {
-    throw new Error("invalid version info");
+    throw new Error("Invalid version info");
   }
   fs3.writeFileSync(versionPath, JSON.stringify(_json, null, 2));
   log.info(`build version info to '${versionPath}'`, { timestamp: true });
@@ -272,7 +275,7 @@ async function buildEntry({
   entryOutputDirPath,
   nativeModuleEntryMap,
   overrideEsbuildOptions
-}, define, bytecodeOptions) {
+}, isESM, define, bytecodeOptions) {
   const option = mergeConfig(
     {
       entryPoints: {
@@ -292,7 +295,8 @@ async function buildEntry({
       loader: {
         ".node": "empty"
       },
-      define
+      define,
+      format: isESM ? "esm" : "cjs"
     },
     overrideEsbuildOptions ?? {}
   );
@@ -376,14 +380,14 @@ function parseKeys({
   let privateKey = process.env.UPDATER_PK;
   let cert = process.env.UPDATER_CERT;
   if (privateKey && cert) {
-    log.info("use UPDATER_PK and UPDATER_CERT from environment variables", { timestamp: true });
+    log.info("Use `UPDATER_PK` and `UPDATER_CERT` from environment variables", { timestamp: true });
     return { privateKey, cert };
   }
   if (!fs3.existsSync(keysDir)) {
     fs3.mkdirSync(keysDir);
   }
   if (!fs3.existsSync(privateKeyPath) || !fs3.existsSync(certPath)) {
-    log.info("no key pair found, generate new key pair", { timestamp: true });
+    log.info("No key pair found, generate new key pair", { timestamp: true });
     generateKeyPair(keyLength, parseSubjects(subject), days, privateKeyPath, certPath);
   }
   privateKey = fs3.readFileSync(privateKeyPath, "utf-8");
@@ -476,7 +480,7 @@ function bytecodePlugin(env, options) {
     return null;
   }
   if (!preload && env === "preload") {
-    bytecodeLog.warn('bytecodePlugin is skiped in preload. To enable in preload, please manually set the "enablePreload" option to true and set `sandbox: false` when creating the window', { timestamp: true });
+    bytecodeLog.warn('`bytecodePlugin` is skiped in preload. To enable in preload, please manually set the "enablePreload" option to true and set `sandbox: false` when creating the window', { timestamp: true });
     return null;
   }
   const filter = createFilter(/\.(m?[jt]s|[jt]sx)$/);
@@ -499,7 +503,8 @@ function bytecodePlugin(env, options) {
       if (options2.format !== "es" && bytecodeRequired) {
         this.emitFile({
           type: "asset",
-          source: bytecodeModuleLoaderCode + "\n",
+          source: `${bytecodeModuleLoaderCode}
+`,
           name: "Bytecode Loader File",
           fileName: bytecodeModuleLoader
         });
@@ -508,7 +513,7 @@ function bytecodePlugin(env, options) {
     renderChunk(code, chunk, options2) {
       if (options2.format === "es") {
         bytecodeLog.warn(
-          'bytecodePlugin does not support ES module, please remove "type": "module" in package.json or set the "build.rollupOptions.output.format" option to "cjs".',
+          '`bytecodePlugin` does not support ES module, please set "build.rollupOptions.output.format" option to "cjs"',
           { timestamp: true }
         );
         return null;
@@ -541,8 +546,9 @@ function bytecodePlugin(env, options) {
           const chunk = output[name];
           if (chunk.type === "chunk") {
             let _code = chunk.code;
+            const chunkFilePath = path5.resolve(outDir, name);
             if (beforeCompile) {
-              const cbResult = await beforeCompile(_code, chunk.fileName);
+              const cbResult = await beforeCompile(_code, chunkFilePath);
               if (cbResult) {
                 _code = cbResult;
               }
@@ -553,19 +559,18 @@ function bytecodePlugin(env, options) {
               while (match = bytecodeRE.exec(_code)) {
                 const [prefix, chunkName] = match;
                 const len = prefix.length + chunkName.length;
-                s.overwrite(match.index, match.index + len, prefix + chunkName + "c", {
+                s.overwrite(match.index, match.index + len, `${prefix + chunkName}c`, {
                   contentOnly: true
                 });
               }
               _code = s.toString();
             }
-            const chunkFilePath = path5.resolve(outDir, name);
             if (bytecodeChunks.includes(name)) {
               const bytecodeBuffer = await compileToBytecode(_code);
-              fs3.writeFileSync(chunkFilePath + "c", bytecodeBuffer);
+              fs3.writeFileSync(`${chunkFilePath}c`, bytecodeBuffer);
               if (chunk.isEntry) {
                 const bytecodeLoaderBlock = getBytecodeLoaderBlock(chunk.fileName);
-                const bytecodeModuleBlock = `require("./${path5.basename(name) + "c"}");`;
+                const bytecodeModuleBlock = `require("./${`${path5.basename(name)}c`}");`;
                 const code = `${useStrict}
 ${bytecodeLoaderBlock}
 module.exports=${bytecodeModuleBlock}
@@ -574,7 +579,7 @@ module.exports=${bytecodeModuleBlock}
               } else {
                 fs3.unlinkSync(chunkFilePath);
               }
-              bytecodeFiles.push({ name: name + "c", size: bytecodeBuffer.length });
+              bytecodeFiles.push({ name: `${name}c`, size: bytecodeBuffer.length });
             } else {
               if (chunk.isEntry) {
                 let hasBytecodeMoudle = false;
@@ -638,12 +643,13 @@ function getMainFilePath(options) {
     }
     mainFilePath = options?.index ? "index.js" : "main.js";
   }
+  log.info(`Using "${mainFilePath}" as main file`, { timestamp: true });
   return mainFilePath.replace(/\.[cm]?ts$/, ".js");
 }
 function parseVersionPath(versionPath) {
   versionPath = normalizePath(versionPath);
   if (!versionPath.startsWith("./")) {
-    versionPath = "./" + versionPath;
+    versionPath = `./${versionPath}`;
   }
   return new URL(versionPath, "file://").pathname.slice(1);
 }
@@ -661,33 +667,43 @@ async function electronWithUpdater(options) {
     useNotBundle = true,
     logParsedOptions
   } = options;
-  if (!pkg) {
-    log.error(`package.json not found`, { timestamp: true });
+  if (!pkg || !pkg.version || !pkg.name || !pkg.main) {
+    log.error("package.json not found or invalid", { timestamp: true });
     return void 0;
   }
-  if (!pkg.version || !pkg.name || !pkg.main) {
-    log.error(`package.json not valid`, { timestamp: true });
-    return void 0;
+  const isESM = pkg.type === "module";
+  let bytecodeOptions = typeof bytecode === "object" ? bytecode : bytecode === true ? { enable: true } : void 0;
+  if (isESM && bytecodeOptions?.enable) {
+    bytecodeLog.warn(
+      '`bytecodePlugin` does not support ES module, please remove "type": "module" in package.json',
+      { timestamp: true }
+    );
+    bytecodeOptions = void 0;
   }
-  const _options = parseOptions(pkg, sourcemap, minify, updater);
-  const bytecodeOptions = typeof bytecode === "object" ? bytecode : bytecode === true ? { enable: true } : void 0;
+  const {
+    buildAsarOption,
+    buildEntryOption,
+    buildVersionOption,
+    postBuild,
+    cert
+  } = parseOptions(pkg, sourcemap, minify, updater);
+  const { entryOutputDirPath, nativeModuleEntryMap, appEntryPath } = buildEntryOption;
   try {
-    fs3.rmSync(_options.buildAsarOption.electronDistPath, { recursive: true, force: true });
-    fs3.rmSync(_options.buildEntryOption.entryOutputDirPath, { recursive: true, force: true });
+    fs3.rmSync(buildAsarOption.electronDistPath, { recursive: true, force: true });
+    fs3.rmSync(entryOutputDirPath, { recursive: true, force: true });
   } catch {
   }
-  log.info(`remove old files`, { timestamp: true });
-  const { buildAsarOption, buildEntryOption, buildVersionOption, postBuild, cert } = _options;
-  const { entryOutputDirPath, nativeModuleEntryMap, appEntryPath } = buildEntryOption;
+  log.info(`Clear cache files`, { timestamp: true });
   sourcemap ??= isBuild || !!process.env.VSCODE_DEBUG;
   const _appPath = normalizePath(path5.join(entryOutputDirPath, "entry.js"));
   if (path5.resolve(normalizePath(pkg.main)) !== path5.resolve(_appPath)) {
-    throw new Error(`wrong "main" field in package.json: "${pkg.main}", it should be "${_appPath}"`);
+    throw new Error(`Wrong "main" field in package.json: "${pkg.main}", it should be "${_appPath}"`);
   }
   const define = {
     __EIU_ELECTRON_DIST_PATH__: JSON.stringify(buildAsarOption.electronDistPath),
     __EIU_ENTRY_DIST_PATH__: JSON.stringify(buildEntryOption.entryOutputDirPath),
     __EIU_IS_DEV__: JSON.stringify(!isBuild),
+    __EIU_IS_ESM__: JSON.stringify(isESM),
     __EIU_MAIN_DEV_DIR__: JSON.stringify(buildAsarOption.electronDistPath),
     __EIU_MAIN_FILE__: JSON.stringify(getMainFilePath(_main.files)),
     __EIU_SIGNATURE_CERT__: JSON.stringify(cert),
@@ -696,10 +712,11 @@ async function electronWithUpdater(options) {
   const _buildEntry = async () => {
     await buildEntry(
       buildEntryOption,
+      isESM,
       define,
       bytecodeOptions
     );
-    log.info(`vite build entry to '${entryOutputDirPath}'`, { timestamp: true });
+    log.info(`Build entry to '${entryOutputDirPath}'`, { timestamp: true });
   };
   const _postBuild = postBuild ? async () => await postBuild({
     getPathFromEntryOutputDir(...paths) {
@@ -712,7 +729,7 @@ async function electronWithUpdater(options) {
           try {
             fs3.cpSync(from, target);
           } catch (error) {
-            log.warn(`copy failed: ${error}`);
+            log.warn(`Copy failed: ${error}`, { timestamp: true });
           }
         }
       }
@@ -774,7 +791,7 @@ async function electronWithUpdater(options) {
                 await _postBuild();
                 const buffer = await buildAsar(buildAsarOption);
                 if (!buildVersionJson && !isCI) {
-                  log.warn("no `buildVersionJson` setup, skip build version json. Will build in CI by default", { timestamp: true });
+                  log.warn("No `buildVersionJson` setup, skip build version json. Will build in CI by default", { timestamp: true });
                 } else {
                   await buildVersion(buildVersionOption, buffer);
                 }
@@ -800,7 +817,7 @@ async function electronWithUpdater(options) {
           ...electronPluginOptions,
           updater: { buildAsarOption, buildEntryOption, buildVersionOption }
         },
-        (key, value) => (key === "privateKey" || key === "cert") && !(typeof logParsedOptions === "object" && logParsedOptions.showKeys === true) ? "***" : value,
+        (key, value) => ["privateKey", "cert", "define"].includes(key) && !(typeof logParsedOptions === "object" && logParsedOptions.showKeys === true) ? "***" : value,
         2
       ),
       { timestamp: true }
@@ -831,5 +848,6 @@ async function electronWithUpdater(options) {
   }
   return [ElectronSimple(electronPluginOptions), extraHmrPlugin];
 }
+var vite_default = electronWithUpdater;
 
-export { debugStartup, electronWithUpdater };
+export { debugStartup, vite_default as default, electronWithUpdater };