electron-incremental-update 1.0.2 → 1.1.0

package/dist/vite.mjs

@@ -1,392 +0,0 @@
-import {
-  signature
-} from "./chunk-GXZSAUBR.mjs";
-import {
-  isUpdateJSON,
-  parseVersion,
-  zipFile
-} from "./chunk-GB6VLKJZ.mjs";
-
-// src/vite.ts
-import { join as join2, resolve } from "node:path";
-import { rmSync } from "node:fs";
-import { createLogger, mergeConfig, normalizePath } from "vite";
-import ElectronSimple from "vite-plugin-electron/simple";
-import { startup } from "vite-plugin-electron";
-import { notBundle } from "vite-plugin-electron/plugin";
-
-// src/build-plugins/build.ts
-import { readFile, rename, writeFile } from "node:fs/promises";
-import { cpSync, existsSync } from "node:fs";
-import { basename, join } from "node:path";
-import Asar from "@electron/asar";
-import { build } from "esbuild";
-async function buildAsar({
-  version,
-  asarOutputPath,
-  gzipPath,
-  electronDistPath,
-  rendererDistPath
-}) {
-  await rename(rendererDistPath, join(electronDistPath, "renderer"));
-  await writeFile(join(electronDistPath, "version"), version);
-  await Asar.createPackage(electronDistPath, asarOutputPath);
-  await zipFile(asarOutputPath, gzipPath);
-}
-async function buildVersion({
-  gzipPath,
-  versionPath,
-  privateKey,
-  cert,
-  version,
-  minimumVersion,
-  generateSignature,
-  generateVersionJson
-}) {
-  let _json = {
-    beta: {
-      minimumVersion: version,
-      signature: "",
-      size: 0,
-      version
-    },
-    minimumVersion: version,
-    signature: "",
-    size: 0,
-    version
-  };
-  if (existsSync(versionPath)) {
-    try {
-      const oldVersionJson = JSON.parse(await readFile(versionPath, "utf-8"));
-      if (isUpdateJSON(oldVersionJson)) {
-        _json = oldVersionJson;
-      } else {
-        console.warn("old version json is invalid, ignore it");
-      }
-    } catch (error) {
-    }
-  }
-  const buffer = await readFile(gzipPath);
-  const sig = await (generateSignature ?? signature)(buffer, privateKey, cert, version);
-  if (generateVersionJson) {
-    _json = await generateVersionJson(_json, buffer, sig, version, minimumVersion);
-    if (!isUpdateJSON(_json)) {
-      throw new Error("invalid version info");
-    }
-  } else {
-    _json.beta = {
-      version,
-      minimumVersion,
-      signature: sig,
-      size: buffer.length
-    };
-    if (!parseVersion(version).stage) {
-      _json.version = version;
-      _json.minimumVersion = minimumVersion;
-      _json.signature = sig;
-      _json.size = buffer.length;
-    }
-  }
-  await writeFile(versionPath, JSON.stringify(_json, null, 2));
-}
-async function buildEntry({
-  sourcemap,
-  minify,
-  appEntryPath,
-  entryOutputDirPath,
-  nativeModuleEntryMap,
-  overrideEsbuildOptions,
-  postBuild
-}) {
-  await build({
-    entryPoints: {
-      entry: appEntryPath,
-      ...nativeModuleEntryMap
-    },
-    bundle: true,
-    platform: "node",
-    outdir: entryOutputDirPath,
-    minify,
-    sourcemap,
-    entryNames: "[dir]/[name]",
-    assetNames: "[dir]/[name]",
-    external: ["electron", "original-fs"],
-    loader: {
-      ".node": "empty"
-    },
-    ...overrideEsbuildOptions
-  });
-  await postBuild?.({
-    getPathFromEntryOutputDir(...paths) {
-      return join(entryOutputDirPath, ...paths);
-    },
-    existsAndCopyToEntryOutputDir({ from, to, skipIfExist = true }) {
-      if (existsSync(from)) {
-        const target = join(entryOutputDirPath, to ?? basename(from));
-        if (!skipIfExist || !existsSync(target)) {
-          cpSync(from, target);
-        }
-      }
-    }
-  });
-}
-
-// src/build-plugins/key.ts
-import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
-import { generate } from "selfsigned";
-function generateKeyPair(keyLength, subject, days, privateKeyPath, certPath) {
-  const privateKeyDir = dirname(privateKeyPath);
-  if (!existsSync2(privateKeyDir)) {
-    mkdirSync(privateKeyDir, { recursive: true });
-  }
-  const certDir = dirname(certPath);
-  if (!existsSync2(certDir)) {
-    mkdirSync(certDir, { recursive: true });
-  }
-  const { cert, private: privateKey } = generate(subject, {
-    keySize: keyLength,
-    algorithm: "sha256",
-    days
-  });
-  writeFileSync(privateKeyPath, privateKey.replace(/\r\n?/g, "\n"));
-  writeFileSync(certPath, cert.replace(/\r\n?/g, "\n"));
-}
-var noCertRegex = /(?<=const SIGNATURE_CERT\s*=\s*)['"]{2}/m;
-var existCertRegex = /(?<=const SIGNATURE_CERT\s*=\s*)(['"]-----BEGIN CERTIFICATE-----[\s\S]*-----END CERTIFICATE-----\\n['"])/m;
-function writeCertToEntry(entryPath, cert) {
-  if (!existsSync2(entryPath)) {
-    throw new Error(`entry not exist: ${entryPath}`);
-  }
-  const file = readFileSync(entryPath, "utf-8");
-  const replacement = cert.split("\n").filter(Boolean).map((s) => `'${s}\\n'`).join("\n  + ");
-  let replaced = file;
-  if (noCertRegex.test(file)) {
-    replaced = file.replace(noCertRegex, replacement);
-  } else if (existCertRegex.test(file)) {
-    replaced = file.replace(existCertRegex, replacement);
-  } else {
-    throw new Error("no `SIGNATURE_CERT` found in entry");
-  }
-  writeFileSync(entryPath, replaced);
-}
-function parseKeys({
-  keyLength,
-  privateKeyPath,
-  certPath,
-  appEntryPath,
-  subject,
-  days
-}) {
-  const keysDir = dirname(privateKeyPath);
-  !existsSync2(keysDir) && mkdirSync(keysDir);
-  if (!existsSync2(privateKeyPath) || !existsSync2(certPath)) {
-    console.warn("no key pair found, generate new key pair");
-    generateKeyPair(keyLength, parseSubjects(subject), days, privateKeyPath, certPath);
-  }
-  const privateKey = process.env.UPDATER_PK || readFileSync(privateKeyPath, "utf-8");
-  const cert = process.env.UPDATER_CERT || readFileSync(certPath, "utf-8");
-  writeCertToEntry(appEntryPath, cert);
-  return { privateKey, cert };
-}
-function parseSubjects(subject) {
-  return Object.entries(subject).filter(([_, value]) => !!value).map(([name, value]) => ({ name, value }));
-}
-
-// src/build-plugins/option.ts
-function parseOptions(isBuild, pkg, options = {}) {
-  const {
-    minimumVersion = "0.0.0",
-    entry: {
-      minify = isBuild,
-      sourcemap = isBuild,
-      entryOutputDirPath = "dist-entry",
-      appEntryPath = "electron/entry.ts",
-      nativeModuleEntryMap = {},
-      postBuild,
-      overrideEsbuildOptions
-    } = {},
-    paths: {
-      asarOutputPath = `release/${pkg.name}.asar`,
-      gzipPath = `release/${pkg.name}-${pkg.version}.asar.gz`,
-      electronDistPath = "dist-electron",
-      rendererDistPath = "dist",
-      versionPath = "version.json"
-    } = {},
-    keys: {
-      privateKeyPath = "keys/private.pem",
-      certPath = "keys/cert.pem",
-      keyLength = 2048,
-      certInfo = {},
-      overrideGenerator = {}
-    } = {}
-  } = options;
-  const { generateSignature, generateVersionJson } = overrideGenerator;
-  let {
-    subject = {
-      commonName: pkg.name,
-      organizationName: `org.${pkg.name}`
-    },
-    days = 3650
-  } = certInfo;
-  const buildAsarOption = {
-    version: pkg.version,
-    asarOutputPath,
-    gzipPath,
-    electronDistPath,
-    rendererDistPath
-  };
-  const buildEntryOption = {
-    minify,
-    sourcemap,
-    entryOutputDirPath,
-    appEntryPath,
-    nativeModuleEntryMap,
-    postBuild,
-    overrideEsbuildOptions
-  };
-  const { privateKey, cert } = parseKeys({
-    keyLength,
-    privateKeyPath,
-    certPath,
-    appEntryPath,
-    subject,
-    days
-  });
-  const buildVersionOption = {
-    version: pkg.version,
-    minimumVersion,
-    gzipPath,
-    privateKey,
-    cert,
-    versionPath,
-    generateSignature,
-    generateVersionJson
-  };
-  return { buildAsarOption, buildEntryOption, buildVersionOption };
-}
-
-// src/vite.ts
-function debugStartup(args) {
-  process.env.VSCODE_DEBUG ? console.log("[startup] Electron App") : args.startup();
-}
-var id = "electron-incremental-updater";
-var log = createLogger("info", { prefix: `[${id}]` });
-function electronWithUpdater(options) {
-  const {
-    isBuild,
-    pkg,
-    main: _main,
-    preload: _preload,
-    updater,
-    useNotBundle = true,
-    logParsedOptions
-  } = options;
-  const _options = parseOptions(isBuild, pkg, updater);
-  try {
-    rmSync(_options.buildAsarOption.electronDistPath, { recursive: true, force: true });
-    rmSync(_options.buildEntryOption.entryOutputDirPath, { recursive: true, force: true });
-  } catch (ignore) {
-  }
-  log.info(`remove old files`, { timestamp: true });
-  const { buildAsarOption, buildEntryOption, buildVersionOption } = _options;
-  const { entryOutputDirPath, nativeModuleEntryMap, appEntryPath } = buildEntryOption;
-  const sourcemap = isBuild || !!process.env.VSCODE_DEBUG;
-  const _appPath = join2(entryOutputDirPath, "entry.js");
-  if (resolve(normalizePath(pkg.main)) !== resolve(normalizePath(_appPath))) {
-    throw new Error(`wrong "main" field in package.json: "${pkg.main}", it should be "${normalizePath(_appPath)}"`);
-  }
-  let isInit = false;
-  const _buildEntry = async () => {
-    await buildEntry(buildEntryOption);
-    log.info(`build entry to '${entryOutputDirPath}'`, { timestamp: true });
-  };
-  const electronPluginOptions = {
-    main: {
-      entry: _main.files,
-      onstart: async (args) => {
-        if (!isInit) {
-          isInit = true;
-          await _buildEntry();
-        }
-        _main.onstart ? _main.onstart(args) : args.startup();
-      },
-      vite: mergeConfig(
-        {
-          plugins: !isBuild && useNotBundle ? [notBundle()] : void 0,
-          build: {
-            sourcemap,
-            minify: isBuild,
-            outDir: `${buildAsarOption.electronDistPath}/main`,
-            rollupOptions: {
-              external: Object.keys("dependencies" in pkg ? pkg.dependencies : {})
-            }
-          }
-        },
-        _main.vite ?? {}
-      )
-    },
-    preload: {
-      input: _preload.files,
-      onstart: _preload.onstart,
-      vite: mergeConfig(
-        {
-          plugins: [
-            {
-              name: `${id}-build`,
-              enforce: "post",
-              apply() {
-                return isBuild;
-              },
-              async closeBundle() {
-                await _buildEntry();
-                await buildAsar(buildAsarOption);
-                log.info(`build asar to '${buildAsarOption.asarOutputPath}'`, { timestamp: true });
-                await buildVersion(buildVersionOption);
-                log.info(`build version info to '${buildVersionOption.versionPath}'`, { timestamp: true });
-              }
-            }
-          ],
-          build: {
-            sourcemap: sourcemap ? "inline" : void 0,
-            minify: isBuild,
-            outDir: `${buildAsarOption.electronDistPath}/preload`,
-            rollupOptions: {
-              external: Object.keys("dependencies" in pkg ? pkg.dependencies : {})
-            }
-          }
-        },
-        _preload.vite ?? {}
-      )
-    }
-  };
-  logParsedOptions && log.info(
-    JSON.stringify(
-      {
-        ...electronPluginOptions,
-        updater: { buildAsarOption, buildEntryOption, buildVersionOption }
-      },
-      (key, value) => key === "privateKey" || key === "cert" ? "***" : value,
-      2
-    ),
-    { timestamp: true }
-  );
-  let extraHmrPlugin;
-  if (nativeModuleEntryMap) {
-    const files = [...Object.values(nativeModuleEntryMap), appEntryPath].map((file) => resolve(normalizePath(file)));
-    extraHmrPlugin = {
-      name: `${id}-dev`,
-      apply() {
-        return !isBuild;
-      },
-      configureServer: (server) => {
-        server.watcher.add(files).on("change", (p) => files.includes(p) && _buildEntry().then(() => startup()));
-      }
-    };
-  }
-  return [ElectronSimple(electronPluginOptions), extraHmrPlugin];
-}
-export {
-  debugStartup,
-  electronWithUpdater
-};