@witchcraft/nuxt-electron 0.1.0 → 0.2.0

package/dist/runtime/electron/createProxiedProtocolHandler.js

@@ -0,0 +1,158 @@
+import { keys } from "@alanscodelog/utils/keys";
+import { pick } from "@alanscodelog/utils/pick";
+import { net } from "electron";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+const cache = /* @__PURE__ */ new Map();
+async function getPathToServe(originalPath, pathWithIndexHtml, key, logger) {
+  if (cache.has(key)) {
+    const result = cache.get(key);
+    if (logger) {
+      logger.trace({
+        ns: "main:createProxiedProtocolHandler:cacheHit",
+        requestUrl: key,
+        result: cache.get(key)
+      });
+    }
+    return result;
+  }
+  const stats = await fs.stat(originalPath).catch(() => void 0);
+  if (logger) {
+    logger.trace({
+      ns: "main:createProxiedProtocolHandler:stats",
+      key,
+      stats,
+      isFile: stats?.isFile(),
+      isDirectory: stats?.isDirectory()
+    });
+  }
+  const pathToServe = stats !== void 0 ? stats.isFile() ? originalPath : stats.isDirectory() ? (await fs.stat(pathWithIndexHtml).catch(() => void 0))?.isFile() ? pathWithIndexHtml : void 0 : void 0 : void 0;
+  cache.set(key, pathToServe);
+  return pathToServe;
+}
+export function createProxiedProtocolHandler(protocol, protocolName = "app", basePath, routeProxies, {
+  logger,
+  errorPage = "404.html"
+} = {}) {
+  const routeProxyKeys = keys(routeProxies);
+  if (protocol.isProtocolHandled(protocolName)) {
+    throw new Error(`Protocol ${protocolName} is already handled.`);
+  }
+  if (routeProxyKeys.length > 0) {
+    if (!process.env.PUBLIC_SERVER_URL && !process.env.VITE_DEV_URL && !process.env.PUBLIC_SERVER_URL) {
+      throw new Error("You defined proxy routes but didn't set PUBLIC_SERVER_URL or VITE_DEV_URL set. This is required for the /api routes to work.");
+    }
+  }
+  let errorPage404;
+  protocol.handle(protocolName, async (request) => {
+    errorPage404 ??= await getPathToServe(path.join(basePath, errorPage), "404.html", "404.html", logger);
+    if (!errorPage404) {
+      throw new Error(`Error page ${path.join(basePath, errorPage)} does not exist. Did you override the routeRules for it?`);
+    }
+    const parsedUrl = new URL(request.url);
+    const requestPath = decodeURIComponent(parsedUrl.pathname);
+    const proxyKey = routeProxyKeys.find((key) => requestPath.startsWith(key));
+    if (proxyKey) {
+      const proxyUrl = routeProxies[proxyKey];
+      const finalPath2 = proxyUrl + requestPath;
+      if (logger) {
+        logger.trace({
+          ns: "main:createProxiedProtocolHandler:fetchingViaProxy",
+          requestUrl: request.url,
+          proxyKey,
+          route: proxyUrl,
+          requestPath,
+          finalPath: finalPath2
+        });
+      }
+      return net.fetch(finalPath2, {
+        ...pick(request, ["headers", "destination", "referrer", "referrerPolicy", "mode", "credentials", "cache", "redirect", "integrity", "keepalive"])
+      });
+    }
+    const originalPath = path.join(basePath, requestPath);
+    const pathWithIndexHtml = path.join(originalPath, "index.html");
+    const relativePath = path.relative(basePath, originalPath);
+    const isSafe = !relativePath.startsWith("..") && !path.isAbsolute(relativePath);
+    if (!isSafe) {
+      if (logger) {
+        logger.error({
+          ns: "main:createProxiedProtocolHandler:badRequest",
+          request: pick(request, [
+            "url",
+            "headers",
+            "destination",
+            "referrer",
+            "referrerPolicy",
+            "mode",
+            "credentials",
+            "cache",
+            "redirect",
+            "integrity",
+            "keepalive",
+            // these also seem to exist
+            ...["isReloadNavigation", "isHistoryNavigation"]
+          ]),
+          requestPath,
+          pathWithIndexHtml,
+          relativePath,
+          originalPath,
+          isSafe
+        });
+      }
+      return new Response(JSON.stringify({
+        error: "Bad Request - Unsafe Path"
+      }), {
+        headers: { "content-type": "application/json" },
+        status: 400
+      });
+    }
+    const pathToServe = await getPathToServe(originalPath, pathWithIndexHtml, request.url, logger);
+    if (!pathToServe) {
+      if (logger) {
+        logger.error({
+          ns: "main:createProxiedProtocolHandler:noFileFound",
+          requestUrl: request.url,
+          originalPath,
+          requestPath,
+          pathWithIndexHtml,
+          pathToServe,
+          errorPath: pathToFileURL(errorPage404).toString()
+        });
+      }
+      const res = await net.fetch(pathToFileURL(errorPage404).toString(), {
+        // see below
+        bypassCustomProtocolHandlers: true
+      }).catch((err) => err);
+      return res;
+    }
+    const finalPath = pathToFileURL(pathToServe).toString();
+    if (logger) {
+      logger.trace({
+        ns: "main:createProxiedProtocolHandler:fetchingFile",
+        requestUrl: request.url,
+        finalPath,
+        requestPath,
+        originalPath
+      });
+    }
+    const response = await net.fetch(finalPath, {
+      // avoid infinite loop if protocolName protocol is "file"
+      // or file is otherwise handled
+      bypassCustomProtocolHandlers: true
+    }).catch((err) => {
+      if (logger) {
+        logger.error({
+          ns: "main:createProxiedProtocolHandler:fetchError",
+          requestUrl: request.url,
+          finalPath,
+          requestPath,
+          originalPath,
+          err
+        });
+      }
+      return err;
+    });
+    return response;
+  });
+}

package/dist/runtime/electron/getPaths.d.ts

@@ -1,25 +1,17 @@
-export declare function forceRelativePath(filepath: string): string;
 /**
  * Calculates the correct paths for the app to run in electron.
  *
- * Note: For serverUrl to not be overridable in production, you should set `electron.additionalElectronVariables.publicServerUrl` to a quoted string.
  *
- * ```ts[nuxt.config.ts]
- * export default defineNuxtConfig({
- * 	modules: [
- * 		"@witchcraft/nuxt-electron",
- * 	],
- * 	electron: {
- * 		additionalElectronVariables: {
- * 			publicServerUrl: process.env.NODE_ENV === "production"
- * 			? `"mysite.com"`
- * 			: `undefined`
- * 		}
- * 	}
+ * Paths are not overridable in production unless you pass the variables that can override them.
+ *
+ * ```ts
+ * const paths = getPaths("app", {
+ * 	windowUrl: process.env.OVERRIDE_WINDOW_URL,
+ * 	publicServerUrl: process.env.OVERRIDE_PUBLIC_SERVER_URL
  * })
  * ```
  */
-export declare function getPaths(): {
+export declare function getPaths(protocolName?: string, overridingEnvs?: Record<string, string | undefined>): {
     windowUrl: string;
     publicServerUrl: string;
     nuxtPublicDir: string;

package/dist/runtime/electron/getPaths.js

@@ -1,32 +1,38 @@
 import { unreachable } from "@alanscodelog/utils/unreachable";
-import { app } from "electron";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { STATIC } from "./static.js";
-export function forceRelativePath(filepath) {
-  return path.join(`.${path.sep}`, filepath);
-}
-export function getPaths() {
-  const rootDir = app.getAppPath();
-  const nuxtPublicDir = path.resolve(rootDir, forceRelativePath(STATIC.ELECTRON_NUXT_PUBLIC_DIR));
-  const preloadPath = path.resolve(rootDir, forceRelativePath(STATIC.ELECTRON_BUILD_DIR), "./preload.cjs");
+export function getPaths(protocolName = "app", overridingEnvs = {
+  windowUrl: void 0,
+  publicServerUrl: void 0
+}) {
+  const __dirname = path.dirname(fileURLToPath(import.meta.url));
+  const nuxtPublicDir = path.join(__dirname, STATIC.ELECTRON_NUXT_PUBLIC_DIR);
+  const preloadPath = path.join(__dirname, STATIC.ELECTRON_BUILD_DIR, "./preload.cjs");
   const base = {
     nuxtPublicDir,
     preloadPath,
-    publicServerUrl: process.env.PUBLIC_SERVER_URL ?? process.env.PUBLIC_SERVER_URL ?? process.env.VITE_DEV_SERVER_URL
+    publicServerUrl: overridingEnvs.publicServerUrl ?? process.env.PUBLIC_SERVER_URL ?? process.env.VITE_DEV_SERVER_URL
   };
   if (!base.publicServerUrl) {
     throw new Error("publicServerUrl could not be determined.");
   }
-  if (process.env.VITE_DEV_SERVER_URL) {
+  if (overridingEnvs.windowUrl) {
+    return {
+      ...base,
+      windowUrl: `${overridingEnvs.windowUrl}${STATIC.ELECTRON_ROUTE}`
+    };
+  }
+  if (process.env.NODE_ENV === "production" && process.env.VITE_DEV_SERVER_URL) {
     return {
       ...base,
       windowUrl: `${process.env.VITE_DEV_SERVER_URL}${STATIC.ELECTRON_ROUTE}`
     };
-  } else if (STATIC.ELECTRON_PROD_URL && STATIC.ELECTRON_BUILD_DIR) {
+  } else if (STATIC.ELECTRON_PROD_URL !== void 0 && STATIC.ELECTRON_BUILD_DIR !== void 0) {
     return {
       ...base,
       // careful, do not use path.join, it will remove extra slashes
-      windowUrl: `file://${STATIC.ELECTRON_PROD_URL}`
+      windowUrl: `${protocolName}://bundle/${STATIC.ELECTRON_PROD_URL}`
     };
   }
   unreachable();

package/dist/runtime/electron/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./types";
 export { getPaths } from "./getPaths";
-export { createNuxtFileProtocolHandler } from "./createNuxtFileProtocolHandler";
+export { createProxiedProtocolHandler } from "./createProxiedProtocolHandler";
+export { createPrivilegedProtocolScheme } from "./createPrivilegedProtocolScheme";
 export { createWindowControlsApi } from "./createWindowControlsApi";
 export { createWindowControlsApiHandler } from "./createWindowControlsApiHandler";
 export { useNuxtRuntimeConfig } from "./useNuxtRuntimeConfig";

package/dist/runtime/electron/index.js

@@ -1,6 +1,7 @@
 export * from "./types.js";
 export { getPaths } from "./getPaths.js";
-export { createNuxtFileProtocolHandler } from "./createNuxtFileProtocolHandler.js";
+export { createProxiedProtocolHandler } from "./createProxiedProtocolHandler.js";
+export { createPrivilegedProtocolScheme } from "./createPrivilegedProtocolScheme.js";
 export { createWindowControlsApi } from "./createWindowControlsApi.js";
 export { createWindowControlsApiHandler } from "./createWindowControlsApiHandler.js";
 export { useNuxtRuntimeConfig } from "./useNuxtRuntimeConfig.js";

package/genDevDesktop.js

@@ -1,9 +1,12 @@
+import { crop } from "@alanscodelog/utils/crop"
 import { run } from "@alanscodelog/utils/run"
 import JSON5 from "json5"
+import fsSync from "node:fs"
 import fs from "node:fs/promises"
 import path from "node:path"
 
 if (process.env.CI) {
+	// eslint-disable-next-line no-console
 	console.log("Skipping desktop file generation in CI.")
 	process.exit(0)
 }
@@ -15,10 +18,54 @@ if (["darwin", "linux"].includes(process.platform)) {
 	process.exit(0)
 }
 
-const electronBuilderConfigPath = path.join(process.cwd(), "electron-builder.json5")
-const electronBuilderConfig = JSON5.parse(await fs.readFile(electronBuilderConfigPath, "utf8"))
+function getConfigPath() {
+	const electronBuilderConfigJsPath = path.join(process.cwd(), "electron-builder-config.js")
+	const electronBuilderConfigJson5Path = path.join(process.cwd(), "electron-builder.json5")
+	const electronBuilderConfigJsonPath = path.join(process.cwd(), "electron-builder.json")
+	const existingPath = fsSync.existsSync(electronBuilderConfigJsPath)
+		? electronBuilderConfigJsPath
+		: fsSync.existsSync(electronBuilderConfigJsonPath)
+			? electronBuilderConfigJsonPath
+			: fsSync.existsSync(electronBuilderConfigJson5Path)
+				? electronBuilderConfigJson5Path
+				: undefined
+	if (!existingPath) {
+		throw new Error(crop`Electron builder config file could not be found at the default locations. If you are using a different file path, please pass it as the second argument.
+
+			Default search locations:
+				- electron-builder-config.js (this cannot be named electron-builder.js, see, https://github.com/electron-userland/electron-builder/issues/6227)
+				- electron-builder.json5
+				- electron-builder.json
+			`
+		)
+	} else {
+		// eslint-disable-next-line no-console
+		console.log(`Using config path ${existingPath}.`)
+	}
+	return existingPath
+}
+
+async function getConfig(pathOverride) {
+	const configPath = pathOverride ?? getConfigPath()
+	/** @type {import("electron-builder").Configuration} */
+	let config
+	if (configPath.endsWith(".js")) {
+		config = (await import(configPath)).default
+	} else {
+		config = JSON5.parse(await fs.readFile(configPath, "utf-8"))
+	}
+	if (process.env.DEBUG) {
+		// eslint-disable-next-line no-console
+		console.log(config)
+	}
+	return config
+}
+
+const configPathOverride = process.argv[4]
+
+const config = await getConfig(configPathOverride)
 
-const desktopFile = electronBuilderConfig.linux?.desktop
+const desktopFile = config.linux?.desktop
 
 desktopFile.Path = process.cwd()
 desktopFile.Exec = process.argv[3] ?? `npm run launch:electron "%u"`

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@witchcraft/nuxt-electron",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Nuxt module for working with electron.",
-  "repository": "witchcraftjs/nuxt-electron",
+  "repository": "https://github.com/witchcraftjs/nuxt-electron",
   "license": "MIT",
   "type": "module",
   "sideEffects": false,
@@ -26,17 +26,18 @@
   ],
   "dependencies": {
     "@alanscodelog/utils": "^6.0.2",
-    "@nuxt/kit": "^4.0.3",
+    "@nuxt/kit": "^4.3.1",
     "@witchcraft/nuxt-utils": "^0.3.6",
-    "@witchcraft/ui": "^0.3.7",
+    "@witchcraft/ui": "^0.3.24",
     "defu": "^6.1.4",
-    "es-toolkit": "^1.39.10",
+    "electron": "^37.10.3",
+    "es-toolkit": "^1.44.0",
     "vite-plugin-electron": "^0.29.0",
     "vite-plugin-externalize-deps": "^0.9.0"
   },
   "peerDependencies": {
-    "@witchcraft/ui": "^0.3.7",
-    "unplugin-icons": "^22.3.0"
+    "@witchcraft/ui": "^0.3.24",
+    "unplugin-icons": "^22.5.0"
   },
   "peerDependenciesMeta": {
     "unplugin-icons": {
@@ -48,23 +49,22 @@
   },
   "devDependencies": {
     "@alanscodelog/eslint-config": "^6.3.1",
-    "@alanscodelog/semantic-release-config": "^6.0.0",
+    "@alanscodelog/semantic-release-config": "^6.0.2",
     "@alanscodelog/tsconfigs": "^6.2.0",
-    "@nuxt/eslint-config": "^1.9.0",
+    "@nuxt/eslint-config": "^1.15.1",
     "@nuxt/module-builder": "^1.0.2",
-    "@nuxt/schema": "^4.0.3",
-    "@nuxt/test-utils": "^3.19.2",
+    "@nuxt/schema": "^4.3.1",
+    "@nuxt/test-utils": "^3.23.0",
     "@types/node": "latest",
     "changelogen": "^0.6.2",
-    "electron": "^38.0.0",
-    "eslint": "^9.34.0",
+    "eslint": "^9.39.2",
     "husky": "^9.1.7",
     "json5": "^2.2.3",
-    "nuxt": "^4.0.3",
-    "typescript": "^5.8.3",
-    "unplugin-icons": "^22.3.0",
+    "nuxt": "^4.3.1",
+    "typescript": "^5.9.3",
+    "unplugin-icons": "^22.5.0",
     "vitest": "^3.2.4",
-    "vue-tsc": "^3.0.6"
+    "vue-tsc": "^3.2.4"
   },
   "release": {
     "extends": [
@@ -80,11 +80,13 @@
     "access": "public"
   },
   "scripts": {
-    "build": "nuxt-module-build prepare && nuxt-module-build build && nuxi build playground",
+    "build": "nuxt-module-build prepare && nuxt-module-build build && pnpm build:playground",
+    "build:playground": "cd playground && pnpm nuxt prepare && pnpm build:electron",
     "build:only": "nuxt-module-build build",
-    "dev": "nuxi dev playground",
+    "dev": "cd playground && pnpm dev:electron",
     "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground",
-    "lint": "eslint \"{src,test,playground/app}/**/*.{ts,vue}\" \"*.{js,cjs,mjs,ts}\"",
+    "lint": "pnpm lint:eslint && pnpm lint:types",
+    "lint:eslint": "eslint \"{src,test,playground/app}/**/*.{ts,vue}\" \"*.{js,cjs,mjs,ts}\"",
     "lint:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit",
     "test": "vitest run",
     "test:watch": "vitest watch"

package/src/module.ts

@@ -9,7 +9,7 @@ import {
 	extendRouteRules,
 	useLogger
 } from "@nuxt/kit"
-import { createConstantCaseVariables, nuxtFileBasedRouting, nuxtRemoveUneededPages, nuxtRerouteOutputTo } from "@witchcraft/nuxt-utils/utils"
+import { createConstantCaseVariables, nuxtRemoveUneededPages, nuxtRerouteOutputTo } from "@witchcraft/nuxt-utils/utils"
 import { defu } from "defu"
 import fs from "node:fs/promises"
 import path from "node:path"
@@ -20,7 +20,6 @@ import { build, type ElectronOptions, startup } from "vite-plugin-electron"
 import { notBundle } from "vite-plugin-electron/plugin"
 import { externalizeDeps } from "vite-plugin-externalize-deps"
 
-import pkg from "../package.json" with { type: "json" }
 
 // https://github.com/electron-vite/vite-plugin-electron/issues/251#issuecomment-2360153184
 startup.exit = async () => {
@@ -206,13 +205,14 @@ export default defineNuxtModule<ModuleOptions>({
 		const srcDir = await resolvePath(options.srcDir, nuxt.options.alias)
 		const nonElectronNuxtBuildDir = await resolvePath(options.nonElectronNuxtBuildDir, nuxt.options.alias)
 
+		// at this point they are made relative to the nuxt dir
+		// for passing to electron we make them relative to main
 		const electronRootBuildDir = await resolvePath(options.electronBuildDir, nuxt.options.alias)
 		const relativeElectronDir = path.relative(nuxt.options.rootDir, electronRootBuildDir)
 		// must be relative
 		const electronNuxtDir = path.join(relativeElectronDir, ".output")
 		// must be relative
 		const electronBuildDir = path.join(relativeElectronDir, "build")
-		// relative to nuxt dir
 		const electronProdUrl = `${options.electronRoute}/index.html`
 		const electronRoute = options.electronRoute
 
@@ -230,7 +230,7 @@ export default defineNuxtModule<ModuleOptions>({
 		}
 
 		const isElectronBuild = process.env.BUILD_ELECTRON === "true" && hasScripts
-		const skipElectronPack = process.env.SKIP_ELECTRON_PACK === "true"
+		const skipElectronPack = !isElectronBuild || process.env.SKIP_ELECTRON_PACK === "true"
 
 		const autoOpen = !!(options.autoOpen && hasScripts && isDev)
 		const useWatch = nuxt.options.dev
@@ -295,6 +295,7 @@ export default defineNuxtModule<ModuleOptions>({
 		let started = false
 
 		nuxt.hook("vite:extendConfig", config => {
+			// @ts-expect-error it's both readonly and possible undefined???
 			config.define ??= {}
 			config.define["import.meta.electron"] = "false"
 			config.define["process.electron"] = "false"
@@ -313,11 +314,11 @@ export default defineNuxtModule<ModuleOptions>({
 			)
 			const additionalElectronVariables = defu(
 				options.additionalElectronVariables,
-				nuxt.options.electron.additionalElectronVariables
+				(nuxt.options.electron === false ? {} : nuxt.options.electron.additionalElectronVariables)
 			)
 			const additionalViteDefinesToCopy = [
 				...options.additionalViteDefinesToCopy,
-				...(nuxt.options.electron.additionalViteDefinesToCopy ?? [])
+				...(nuxt.options.electron === false ? [] : (nuxt.options.electron.additionalViteDefinesToCopy ?? []))
 			]
 
 			const copyFromVite = [
@@ -337,11 +338,13 @@ export default defineNuxtModule<ModuleOptions>({
 					copyFromVite.map(v => [v, viteConfig.define![v]])
 				),
 				...createConstantCaseVariables({
-					electronRoute,
-					electronProdUrl,
-					electronNuxtDir,
-					electronNuxtPublicDir,
-					electronBuildDir,
+					// on windows the backslashes in the paths must be double escaped
+					electronRoute: electronRoute.replaceAll("\\", "\\\\"),
+					electronProdUrl: electronProdUrl.replaceAll("\\", "\\\\"),
+					// all paths muxt be made relative to the build dir where electron will launch from in production
+					electronNuxtDir: path.relative(electronBuildDir, relativeElectronDir).replaceAll("\\", "\\\\"),
+					electronNuxtPublicDir: path.relative(electronBuildDir, electronNuxtPublicDir).replaceAll("\\", "\\\\"),
+					electronBuildDir: path.relative(electronBuildDir, electronBuildDir).replaceAll("\\", "\\\\"),
 					// ...options.additionalElectronVariables,
 					// nuxt's runtimeConfig cannot be used in electron's main since it's built seperately
 					// also we must stringify ourselves since escaped double quotes are not preserved in the final output :/
@@ -514,12 +517,28 @@ export default defineNuxtModule<ModuleOptions>({
 
 			// the "/" is not technically needed but only if we properly split the chunks by pages and that was causing issues
 			nuxtRemoveUneededPages(nuxt, ["/", electronRoute, ...options.additionalRoutes!])
-			extendRouteRules(electronRoute, { ssr: false, prerender: true }, { override: true })
 
-			nuxt.options.router = defu(
-				nuxtFileBasedRouting().router,
-				(nuxt.options.router as any) ?? {}
-			)
+			nuxt.options.router.options ??= {}
+			nuxt.options.router.options.hashMode = false
+
+			extendRouteRules(electronRoute + "/**", {
+				prerender: true
+			}, { override: true })
+
+			for (const route of options.additionalRoutes) {
+				extendRouteRules(route, {
+					prerender: true
+				}, { override: true })
+			}
+
+
+			/* Nuxt in build mode won't generate this. And we need build mode so api calls aren't baked in. */
+			nuxt.hook("prerender:routes", ({ routes }) => {
+				for (const route of ["/404.html"]) {
+					routes.add(route)
+				}
+			})
+
 
 			nuxtRerouteOutputTo(nuxt, electronNuxtDir)
 
@@ -550,8 +569,16 @@ export default defineNuxtModule<ModuleOptions>({
 			} else {
 				logger.info(`Skipping Electron Build`)
 			}
-
-			nuxtRerouteOutputTo(nuxt, nonElectronNuxtBuildDir)
+			const nuxtOutputDir = nuxt.options.nitro?.output?.dir
+			if (nuxtOutputDir === undefined || nuxtOutputDir === ".output") {
+				logger.warn(crop`Nitro output dir is not set or set to the default, it's suggested you set it to the following when using nuxt-electron:
+					nitro: {
+						output: ".dist/web/.output",
+						serverDir: ".dist/web/.output/server"
+						publicDir: ".dist/web/.output/public"
+					}
+				.`)
+			}
 		}
 
 		addImportsDir(resolve("runtime/utils"))

package/src/runtime/electron/createPriviledgedProtocolScheme.ts

@@ -0,0 +1,40 @@
+/**
+ * Creates a protocol scheme to register as privileged with the following permissions (you can override them with the second parameter).
+ *
+ * Note this must be called before the app's ready event:
+ *
+ * ```ts
+ * protocol.registerSchemesAsPrivileged([
+ * 	createPrivilegedProtocolScheme("app")
+ * })
+ * ```
+ *
+ * ## Privileges
+ *
+ * Basically all except `bypassCSP` and `enableCORS`.
+ *
+ * - `standard`
+ * - `allowServiceWorkers`
+ * - `bypassCSP`
+ * - `corsEnabled`
+ * - `secure`
+ * - `supportFetchAPI`
+ * - `codeCache`
+ * - `stream`
+ */
+export function createPrivilegedProtocolScheme(protocolName: string, privileges: Partial<Electron.CustomScheme["privileges"]> = {}): Electron.CustomScheme {
+	return {
+		scheme: protocolName,
+		privileges: {
+			bypassCSP: false,
+			corsEnabled: false,
+			stream: false,
+			standard: true,
+			secure: true,
+			supportFetchAPI: true,
+			allowServiceWorkers: true,
+			codeCache: true,
+			...privileges
+		}
+	}
+}

package/src/runtime/electron/createPrivilegedProtocolScheme.ts

@@ -0,0 +1,40 @@
+/**
+ * Creates a protocol scheme to register as privileged with the following permissions (you can override them with the second parameter).
+ *
+ * Note this must be called before the app's ready event:
+ *
+ * ```ts
+ * protocol.registerSchemesAsPrivileged([
+ * 	createPrivilegedProtocolScheme("app")
+ * })
+ * ```
+ *
+ * ## Privileges
+ *
+ * Basically all except `bypassCSP` and `enableCORS`.
+ *
+ * - `standard`
+ * - `allowServiceWorkers`
+ * - `bypassCSP`
+ * - `corsEnabled`
+ * - `secure`
+ * - `supportFetchAPI`
+ * - `codeCache`
+ * - `stream`
+ */
+export function createPrivilegedProtocolScheme(protocolName: string, privileges: Partial<Electron.CustomScheme["privileges"]> = {}): Electron.CustomScheme {
+	return {
+		scheme: protocolName,
+		privileges: {
+			bypassCSP: false,
+			corsEnabled: false,
+			stream: false,
+			standard: true,
+			secure: true,
+			supportFetchAPI: true,
+			allowServiceWorkers: true,
+			codeCache: true,
+			...privileges
+		}
+	}
+}