@thatkawaiisam/electron-vite 5.0.0

package/dist/cli.js

@@ -0,0 +1,119 @@
+import { cac } from 'cac';
+import colors from 'picocolors';
+import { createLogger } from 'vite';
+
+var version = "5.0.0";
+
+const cli = cac('electron-vite');
+function createInlineConfig(root, options) {
+    return {
+        root,
+        mode: options.mode,
+        configFile: options.config,
+        logLevel: options.logLevel,
+        clearScreen: options.clearScreen,
+        ignoreConfigWarning: options.ignoreConfigWarning,
+        build: {
+            sourcemap: options.sourcemap,
+            outDir: options.outDir,
+            ...(options.w || options.watch ? { watch: {} } : null)
+        }
+    };
+}
+cli
+    .option('-c, --config <file>', `[string] use specified config file`)
+    .option('-l, --logLevel <level>', `[string] info | warn | error | silent`)
+    .option('--clearScreen', `[boolean] allow/disable clear screen when logging`)
+    .option('-d, --debug [feat]', `[string | boolean] show debug logs`)
+    .option('-f, --filter <filter>', `[string] filter debug logs`)
+    .option('-m, --mode <mode>', `[string] set env mode`)
+    .option('--ignoreConfigWarning', `[boolean] ignore config warning`)
+    .option('--sourcemap', `[boolean] output source maps for debug (default: false)`)
+    .option('--outDir <dir>', `[string] output directory (default: out)`)
+    .option('--entry <file>', `[string] specify electron entry file`);
+// dev
+cli
+    .command('[root]', 'start dev server and electron app')
+    .alias('serve')
+    .alias('dev')
+    .option('-w, --watch', `[boolean] rebuilds when main process or preload script modules have changed on disk`)
+    .option('--inspect [port]', `[boolean | number] enable V8 inspector on the specified port`)
+    .option('--inspectBrk [port]', `[boolean | number] enable V8 inspector on the specified port`)
+    .option('--remoteDebuggingPort <port>', `[string] port for remote debugging`)
+    .option('--noSandbox', `[boolean] forces renderer process to run un-sandboxed`)
+    .option('--rendererOnly', `[boolean] only dev server for the renderer`)
+    .action(async (root, options) => {
+    if (options.remoteDebuggingPort) {
+        process.env.REMOTE_DEBUGGING_PORT = options.remoteDebuggingPort;
+    }
+    if (options.inspect) {
+        process.env.V8_INSPECTOR_PORT = typeof options.inspect === 'number' ? `${options.inspect}` : '5858';
+    }
+    if (options.inspectBrk) {
+        process.env.V8_INSPECTOR_BRK_PORT = typeof options.inspectBrk === 'number' ? `${options.inspectBrk}` : '5858';
+    }
+    if (options.noSandbox) {
+        process.env.NO_SANDBOX = '1';
+    }
+    if (options['--']) {
+        process.env.ELECTRON_CLI_ARGS = JSON.stringify(options['--']);
+    }
+    if (options.entry) {
+        process.env.ELECTRON_ENTRY = options.entry;
+    }
+    const { createServer } = await import('./chunks/lib-B1EDBNjL.js');
+    const inlineConfig = createInlineConfig(root, options);
+    try {
+        await createServer(inlineConfig, { rendererOnly: options.rendererOnly });
+    }
+    catch (e) {
+        const error = e;
+        createLogger(options.logLevel).error(colors.red(`error during start dev server and electron app:\n${error.stack}`), { error });
+        process.exit(1);
+    }
+});
+// build
+cli.command('build [root]', 'build for production').action(async (root, options) => {
+    const { build } = await import('./chunks/lib-6iOrRH4E.js');
+    const inlineConfig = createInlineConfig(root, options);
+    if (options.entry) {
+        process.env.ELECTRON_ENTRY = options.entry;
+    }
+    try {
+        await build(inlineConfig);
+    }
+    catch (e) {
+        const error = e;
+        createLogger(options.logLevel).error(colors.red(`error during build:\n${error.stack}`), { error });
+        process.exit(1);
+    }
+});
+// preview
+cli
+    .command('preview [root]', 'start electron app to preview production build')
+    .option('--noSandbox', `[boolean] forces renderer process to run un-sandboxed`)
+    .option('--skipBuild', `[boolean] skip build`)
+    .action(async (root, options) => {
+    const { preview } = await import('./chunks/lib-CKGCTpsN.js');
+    const inlineConfig = createInlineConfig(root, options);
+    if (options.noSandbox) {
+        process.env.NO_SANDBOX = '1';
+    }
+    if (options.entry) {
+        process.env.ELECTRON_ENTRY = options.entry;
+    }
+    if (options['--']) {
+        process.env.ELECTRON_CLI_ARGS = JSON.stringify(options['--']);
+    }
+    try {
+        await preview(inlineConfig, { skipBuild: options.skipBuild });
+    }
+    catch (e) {
+        const error = e;
+        createLogger(options.logLevel).error(colors.red(`error during preview electron app:\n${error.stack}`), { error });
+        process.exit(1);
+    }
+});
+cli.help();
+cli.version(version);
+cli.parse();

package/dist/index.d.ts

@@ -0,0 +1,175 @@
+import { Plugin, UserConfig as UserConfig$1, BuildEnvironmentOptions, ConfigEnv, LogLevel, FilterPattern } from 'vite';
+export { LogLevel, createLogger, defineConfig as defineViteConfig, mergeConfig } from 'vite';
+import { TransformConfig } from '@swc/core';
+
+interface ExternalOptions {
+    exclude?: string[];
+    include?: string[];
+}
+/**
+ * Automatically externalize dependencies.
+ *
+ * @deprecated use `build.externalizeDeps` config option instead
+ */
+declare function externalizeDepsPlugin(options?: ExternalOptions): Plugin | null;
+
+interface BytecodeOptions {
+    chunkAlias?: string | string[];
+    transformArrowFunctions?: boolean;
+    removeBundleJS?: boolean;
+    protectedStrings?: string[];
+}
+/**
+ * Compile source code to v8 bytecode.
+ *
+ * @deprecated use `build.bytecode` config option instead
+ */
+declare function bytecodePlugin(options?: BytecodeOptions): Plugin | null;
+
+interface IsolatedEntriesMixin {
+    /**
+     * Build each entry point as an isolated bundle without code splitting.
+     *
+     * When enabled, each entry will include all its dependencies inline,
+     * preventing automatic code splitting across entries and ensuring each
+     * output file is fully standalone.
+     *
+     * **Important**: When using `isolatedEntries` in `preload` config, you
+     * should also disable `build.externalizeDeps` to ensure third-party dependencies
+     * from `node_modules` are bundled together, which is required for Electron
+     * sandbox support.
+     *
+     * @experimental
+     * @default false
+     */
+    isolatedEntries?: boolean;
+}
+interface ExternalizeDepsMixin {
+    /**
+     * Options pass on to `externalizeDeps` plugin in electron-vite.
+     *
+     * Automatically externalize dependencies.
+     *
+     * @default true
+     */
+    externalizeDeps?: boolean | ExternalOptions;
+}
+interface BytecodeMixin {
+    /**
+     * Options pass on to `bytecode` plugin in electron-vite.
+     * https://electron-vite.org/guide/source-code-protection#options
+     *
+     * Compile source code to v8 bytecode.
+     */
+    bytecode?: boolean | BytecodeOptions;
+}
+interface MainBuildOptions extends BuildEnvironmentOptions, ExternalizeDepsMixin, BytecodeMixin {
+}
+interface PreloadBuildOptions extends BuildEnvironmentOptions, ExternalizeDepsMixin, BytecodeMixin, IsolatedEntriesMixin {
+}
+interface RendererBuildOptions extends BuildEnvironmentOptions, IsolatedEntriesMixin {
+}
+interface BaseViteConfig<T> extends Omit<UserConfig$1, 'build'> {
+    /**
+     * Build specific options
+     */
+    build?: T;
+}
+interface MainViteConfig extends BaseViteConfig<MainBuildOptions> {
+}
+interface PreloadViteConfig extends BaseViteConfig<PreloadBuildOptions> {
+}
+interface RendererViteConfig extends BaseViteConfig<RendererBuildOptions> {
+}
+interface UserConfig {
+    /**
+     * Custom Electron package name (e.g., '@overwolf/ow-electron').
+     * Can also be set via ELECTRON_PKG_NAME environment variable.
+     *
+     * @default 'electron'
+     */
+    electronPackage?: string;
+    /**
+     * Vite config options for electron main process
+     *
+     * @see https://vitejs.dev/config/
+     */
+    main?: MainViteConfig;
+    /**
+     * Vite config options for electron renderer process
+     *
+     * @see https://vitejs.dev/config/
+     */
+    renderer?: RendererViteConfig;
+    /**
+     * Vite config options for electron preload scripts
+     *
+     * @see https://vitejs.dev/config/
+     */
+    preload?: PreloadViteConfig;
+}
+type ElectronViteConfigFnObject = (env: ConfigEnv) => UserConfig;
+type ElectronViteConfigFnPromise = (env: ConfigEnv) => Promise<UserConfig>;
+type ElectronViteConfigFn = (env: ConfigEnv) => UserConfig | Promise<UserConfig>;
+type ElectronViteConfigExport = UserConfig | Promise<UserConfig> | ElectronViteConfigFnObject | ElectronViteConfigFnPromise | ElectronViteConfigFn;
+/**
+ * Type helper to make it easier to use `electron.vite.config.*`
+ * accepts a direct {@link UserConfig} object, or a function that returns it.
+ * The function receives a object that exposes two properties:
+ * `command` (either `'build'` or `'serve'`), and `mode`.
+ */
+declare function defineConfig(config: UserConfig): UserConfig;
+declare function defineConfig(config: Promise<UserConfig>): Promise<UserConfig>;
+declare function defineConfig(config: ElectronViteConfigFnObject): ElectronViteConfigFnObject;
+declare function defineConfig(config: ElectronViteConfigFnPromise): ElectronViteConfigFnPromise;
+declare function defineConfig(config: ElectronViteConfigExport): ElectronViteConfigExport;
+type InlineConfig = Omit<UserConfig$1, 'base'> & {
+    configFile?: string | false;
+    envFile?: false;
+    ignoreConfigWarning?: boolean;
+};
+interface ResolvedConfig {
+    config?: UserConfig;
+    configFile?: string;
+    configFileDependencies: string[];
+}
+declare function resolveConfig(inlineConfig: InlineConfig, command: 'build' | 'serve', defaultMode?: string): Promise<ResolvedConfig>;
+declare function loadConfigFromFile(configEnv: ConfigEnv, configFile?: string, configRoot?: string, logLevel?: LogLevel, ignoreConfigWarning?: boolean): Promise<{
+    path: string;
+    config: UserConfig;
+    dependencies: string[];
+}>;
+
+declare function createServer(inlineConfig: InlineConfig | undefined, options: {
+    rendererOnly?: boolean;
+}): Promise<void>;
+
+/**
+ * Bundles the electron app for production.
+ */
+declare function build(inlineConfig?: InlineConfig): Promise<void>;
+
+declare function preview(inlineConfig: InlineConfig | undefined, options: {
+    skipBuild?: boolean;
+}): Promise<void>;
+
+/**
+ * Load `.env` files within the `envDir` (default: `process.cwd()`) .
+ * By default, only env variables prefixed with `VITE_`, `MAIN_VITE_`, `PRELOAD_VITE_` and
+ * `RENDERER_VITE_` are loaded, unless `prefixes` is changed.
+ */
+declare function loadEnv(mode: string, envDir?: string, prefixes?: string | string[]): Record<string, string>;
+
+type SwcOptions = {
+    include?: FilterPattern;
+    exclude?: FilterPattern;
+    transformOptions?: TransformConfig;
+};
+/**
+ * Use SWC to support for emitting type metadata for decorators.
+ * When using `swcPlugin`, you need to install `@swc/core`.
+ */
+declare function swcPlugin(options?: SwcOptions): Plugin;
+
+export { build, bytecodePlugin, createServer, defineConfig, externalizeDepsPlugin, loadConfigFromFile, loadEnv, preview, resolveConfig, swcPlugin };
+export type { BytecodeOptions, ElectronViteConfigExport, ElectronViteConfigFn, ElectronViteConfigFnObject, ElectronViteConfigFnPromise, ExternalOptions, InlineConfig, MainViteConfig, PreloadViteConfig, RendererViteConfig, ResolvedConfig, SwcOptions, UserConfig };

package/dist/index.js

@@ -0,0 +1,108 @@
+import { createFilter } from 'vite';
+export { createLogger, defineConfig as defineViteConfig, mergeConfig } from 'vite';
+export { b as bytecodePlugin, d as defineConfig, e as externalizeDepsPlugin, a as loadConfigFromFile, l as loadEnv, r as resolveConfig } from './chunks/lib-D8_qgfjp.js';
+export { createServer } from './chunks/lib-B1EDBNjL.js';
+export { build } from './chunks/lib-6iOrRH4E.js';
+export { preview } from './chunks/lib-CKGCTpsN.js';
+import { createRequire } from 'node:module';
+import 'node:path';
+import 'node:fs';
+import 'node:url';
+import 'picocolors';
+import 'esbuild';
+import 'node:child_process';
+import 'node:crypto';
+import 'node:fs/promises';
+import 'magic-string';
+import '@babel/core';
+
+async function transformWithSWC(code, id, options) {
+    const { sourcemap = false, minify = false } = options;
+    delete options.sourcemap;
+    delete options.minify;
+    const isTs = /\.tsx?$/.test(id);
+    const require = createRequire(import.meta.url);
+    let swc;
+    try {
+        swc = require('@swc/core');
+    }
+    catch {
+        throw new Error('swc plugin require @swc/core, you need to install it.');
+    }
+    const jsc = {
+        parser: {
+            syntax: isTs ? 'typescript' : 'ecmascript',
+            decorators: true
+        },
+        transform: {
+            legacyDecorator: true,
+            decoratorMetadata: true,
+            ...options
+        },
+        keepClassNames: true,
+        target: 'es2022',
+        minify: {
+            format: {
+                comments: false
+            }
+        }
+    };
+    const result = await swc.transform(code, {
+        jsc,
+        sourceMaps: sourcemap,
+        minify,
+        configFile: false,
+        swcrc: false
+    });
+    const map = sourcemap && result.map ? JSON.parse(result.map) : { mappings: '' };
+    return {
+        code: result.code,
+        map
+    };
+}
+/**
+ * Use SWC to support for emitting type metadata for decorators.
+ * When using `swcPlugin`, you need to install `@swc/core`.
+ */
+function swcPlugin(options = {}) {
+    const filter = createFilter(options.include || /\.(m?ts|[jt]sx)$/, options.exclude || /\.js$/);
+    let sourcemap = false;
+    let minify = false;
+    return {
+        name: 'vite:swc',
+        config() {
+            return {
+                esbuild: false
+            };
+        },
+        async configResolved(resolvedConfig) {
+            sourcemap = resolvedConfig.build?.sourcemap === 'inline' ? 'inline' : !!resolvedConfig.build?.sourcemap;
+            minify = resolvedConfig.build?.minify;
+        },
+        async transform(code, id) {
+            if (filter(id)) {
+                const result = await transformWithSWC(code, id, { sourcemap, ...(options.transformOptions || {}) });
+                return {
+                    code: result.code,
+                    map: result.map
+                };
+            }
+        },
+        async renderChunk(code, chunk) {
+            if (!minify || minify === 'terser') {
+                return null;
+            }
+            const result = await transformWithSWC(code, chunk.fileName, {
+                sourcemap,
+                minify: true,
+                ...(options.transformOptions || {})
+            });
+            return {
+                code: result.code,
+                map: result.map
+            };
+        }
+    };
+}
+
+export { swcPlugin };

package/node.d.ts

@@ -0,0 +1,112 @@
+// node worker
+declare module '*?nodeWorker' {
+  import type { Worker, WorkerOptions } from 'node:worker_threads'
+  export default function (options: WorkerOptions): Worker
+}
+
+// module path
+declare module '*?modulePath' {
+  const src: string
+  export default src
+}
+
+// node asset
+declare module '*?asset' {
+  const src: string
+  export default src
+}
+
+declare module '*?asset&asarUnpack' {
+  const src: string
+  export default src
+}
+
+declare module '*.json?commonjs-external&asset' {
+  const src: string
+  export default src
+}
+
+// native node module
+declare module '*.node' {
+  /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+  const node: any
+  export default node
+}
+
+// node wasm
+declare module '*.wasm?loader' {
+  const loadWasm: (options?: WebAssembly.Imports) => Promise<WebAssembly.Instance>
+  export default loadWasm
+}
+
+// build-in process env
+declare namespace NodeJS {
+  interface ProcessEnv {
+    /**
+     * Vite's dev server address for Electron renderers.
+     */
+    readonly ELECTRON_RENDERER_URL?: string
+  }
+}
+
+// Refer to Vite's ImportMeta type declarations
+// <https://github.com/vitejs/vite/blob/main/packages/vite/types/importMeta.d.ts>
+
+interface ImportMetaEnv {
+  MODE: string
+  DEV: boolean
+  PROD: boolean
+}
+
+interface ImportGlobOptions<Eager extends boolean, AsType extends string> {
+  /**
+   * Import type for the import url.
+   */
+  as?: AsType
+  /**
+   * Import as static or dynamic
+   *
+   * @default false
+   */
+  eager?: Eager
+  /**
+   * Import only the specific named export. Set to `default` to import the default export.
+   */
+  import?: string
+  /**
+   * Custom queries
+   */
+  query?: string | Record<string, string | number | boolean>
+  /**
+   * Search files also inside `node_modules/` and hidden directories (e.g. `.git/`). This might have impact on performance.
+   *
+   * @default false
+   */
+  exhaustive?: boolean
+}
+
+interface KnownAsTypeMap {
+  raw: string
+  url: string
+  worker: Worker
+}
+
+interface ImportGlobFunction {
+  /**
+   * Import a list of files with a glob pattern.
+   *
+   * https://vitejs.dev/guide/features.html#glob-import
+   */
+  <Eager extends boolean, As extends string, T = As extends keyof KnownAsTypeMap ? KnownAsTypeMap[As] : unknown>(
+    glob: string | string[],
+    options?: ImportGlobOptions<Eager, As>
+  ): (Eager extends true ? true : false) extends true ? Record<string, T> : Record<string, () => Promise<T>>
+  <M>(glob: string | string[], options?: ImportGlobOptions<false, string>): Record<string, () => Promise<M>>
+  <M>(glob: string | string[], options: ImportGlobOptions<true, string>): Record<string, M>
+}
+
+interface ImportMeta {
+  url: string
+  readonly env: ImportMetaEnv
+  glob: ImportGlobFunction
+}

package/package.json

@@ -0,0 +1,110 @@
+{
+  "name": "@thatkawaiisam/electron-vite",
+  "version": "5.0.0",
+  "private": false,
+  "description": "Electron build tooling based on Vite",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./node": {
+      "types": "./node.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "electron-vite": "bin/electron-vite.js"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "node.d.ts"
+  ],
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "packageManager": "pnpm@10.12.4",
+  "author": "Alex Wei<https://github.com/alex8088>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/alex8088/electron-vite.git"
+  },
+  "bugs": {
+    "url": "https://github.com/alex8088/electron-vite/issues"
+  },
+  "homepage": "https://electron-vite.org",
+  "keywords": [
+    "electron",
+    "vite",
+    "cli",
+    "plugin"
+  ],
+  "scripts": {
+    "format": "prettier --write .",
+    "lint": "eslint --cache .",
+    "typecheck": "tsc --noEmit",
+    "build": "pnpm run lint && rollup -c rollup.config.ts --configPlugin typescript"
+  },
+  "simple-git-hooks": {
+    "pre-commit": "npx lint-staged",
+    "commit-msg": "node scripts/verifyCommit.js $1"
+  },
+  "lint-staged": {
+    "*.js": [
+      "prettier --write"
+    ],
+    "*.ts?(x)": [
+      "eslint",
+      "prettier --parser=typescript --write"
+    ]
+  },
+  "peerDependencies": {
+    "@swc/core": "^1.0.0",
+    "vite": "^5.0.0 || ^6.0.0 || ^7.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@swc/core": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.37.0",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-typescript": "^12.1.4",
+    "@swc/core": "^1.13.5",
+    "@types/babel__core": "^7.20.5",
+    "@types/node": "^22.18.11",
+    "eslint": "^9.37.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "globals": "^16.4.0",
+    "lint-staged": "^16.2.4",
+    "prettier": "^3.6.2",
+    "rollup": "^4.52.4",
+    "rollup-plugin-dts": "^6.2.3",
+    "rollup-plugin-rm": "^1.0.2",
+    "simple-git-hooks": "^2.13.1",
+    "tslib": "^2.8.1",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.46.1",
+    "vite": "^7.1.10"
+  },
+  "dependencies": {
+    "@babel/core": "^7.28.4",
+    "@babel/plugin-transform-arrow-functions": "^7.27.1",
+    "cac": "^6.7.14",
+    "esbuild": "^0.25.11",
+    "magic-string": "^0.30.19",
+    "picocolors": "^1.1.1"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "@swc/core",
+      "esbuild",
+      "simple-git-hooks"
+    ]
+  }
+}