Dynamically pull down binary (#28)

* Dynamically pull down binary

Pull the binary from GitHub releases unless the WEBVIEW_BIN env var is provided.

* Bump cargo version

* Delete misc file

* Add mechanism to automatically upgrade version

.vscode/settings.json

@@ -2,5 +2,8 @@
   "editor.semanticHighlighting.enabled": true,
   "[typescript]": {
     "editor.defaultFormatter": "denoland.vscode-deno"
+  },
+  "[json]": {
+    "editor.defaultFormatter": "denoland.vscode-deno"
   }
 }

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deno-webview"
-version = "0.1.3"
+version = "0.1.4"
 edition = "2021"
 
 [profile.release]

deno.json

@@ -5,7 +5,7 @@
   },
   "tasks": {
     "dev": "deno run --watch main.ts",
-    "gen": "cargo test && deno run -A scripts/generate-zod.ts",
+    "gen": "cargo test && deno run -A scripts/generate-zod.ts && deno run -A scripts/sync-versions.ts",
     "build": "deno task gen && cargo build -F transparent",
     "example:simple": "deno run -A examples/simple.ts"
   }

examples/simple.ts

@@ -1,6 +1,6 @@
-import { WebView } from "../src/lib.ts";
+import { createWebView } from "../src/lib.ts";
 
-const webview = new WebView({
+using webview = await createWebView({
   title: "Simple",
   html: "<h1>Hello, World!</h1>",
 });

scripts/sync-versions.ts

@@ -0,0 +1,25 @@
+/**
+ * Keeps the version of the WebView binary in sync with the version in Cargo.toml.
+ */
+
+import { parse } from "jsr:@std/toml";
+
+const latestVersion = await Deno
+  .readTextFile("./Cargo.toml").then((text) =>
+    parse(text) as { package: { version: string } }
+  ).then((config) => config.package.version);
+
+// Read the content of src/lib.ts
+const libPath = "./src/lib.ts";
+const libContent = await Deno.readTextFile(libPath);
+
+// Replace the version in the URL
+const updatedContent = libContent.replace(
+  /releases\/download\/v\d+\.\d+\.\d+\/deno-webview/,
+  `releases/download/v${latestVersion}/deno-webview`,
+);
+
+// Write the updated content back to src/lib.ts
+await Deno.writeTextFile(libPath, updatedContent);
+
+console.log(`Updated WebView binary version to ${latestVersion} in src/lib.ts`);

src/lib.ts

@@ -7,6 +7,9 @@ import {
 } from "./schemas.ts";
 import { monotonicUlid as ulid } from "jsr:@std/ulid";
 import type { Except } from "npm:type-fest";
+import { join } from "jsr:@std/path";
+import { ensureDir } from "jsr:@std/fs";
+import { exists } from "jsr:@std/fs";
 
 type JSON =
   | string
@@ -68,7 +71,82 @@ const returnAck = (result: WebViewResponse) => {
   }
 };
 
-export class WebView implements Disposable {
+async function getWebViewBin(options: WebViewOptions) {
+  if (Deno.permissions.querySync({ name: "env" }).state === "granted") {
+    const binPath = Deno.env.get("WEBVIEW_BIN");
+    if (binPath) return binPath;
+  }
+
+  const flags = options.devtools
+    ? "-devtools"
+    : options.transparent && Deno.build.os === "darwin"
+    ? "-transparent"
+    : "";
+
+  const cacheDir = getCacheDir();
+  const fileName = `deno-webview${flags}${
+    Deno.build.os === "windows" ? ".exe" : ""
+  }`;
+  const filePath = join(cacheDir, fileName);
+
+  // Check if the file already exists in cache
+  if (await exists(filePath)) {
+    return filePath;
+  }
+
+  // If not in cache, download it
+  let url =
+    "https://github.com/zephraph/webview/releases/download/v0.1.4/deno-webview";
+  switch (Deno.build.os) {
+    case "darwin": {
+      url += "-mac" + flags;
+      break;
+    }
+    case "linux": {
+      url += "-linux" + flags;
+      break;
+    }
+    case "windows": {
+      url += "-windows" + flags + ".exe";
+      break;
+    }
+    default:
+      throw new Error("unsupported OS");
+  }
+
+  const res = await fetch(url);
+
+  // Ensure the cache directory exists
+  await ensureDir(cacheDir);
+
+  // Write the binary to disk
+  await Deno.writeFile(filePath, new Uint8Array(await res.arrayBuffer()), {
+    mode: 0o755,
+  });
+
+  return filePath;
+}
+
+// Helper function to get the OS-specific cache directory
+function getCacheDir(): string {
+  switch (Deno.build.os) {
+    case "darwin":
+      return join(Deno.env.get("HOME")!, "Library", "Caches", "deno-webview");
+    case "linux":
+      return join(Deno.env.get("HOME")!, ".cache", "deno-webview");
+    case "windows":
+      return join(Deno.env.get("LOCALAPPDATA")!, "deno-webview", "Cache");
+    default:
+      throw new Error("Unsupported OS");
+  }
+}
+
+export async function createWebView(options: WebViewOptions) {
+  const binPath = await getWebViewBin(options);
+  return new WebView(options, binPath);
+}
+
+class WebView implements Disposable {
   #process: Deno.ChildProcess;
   #stdin: WritableStreamDefaultWriter;
   #stdout: ReadableStreamDefaultReader;
@@ -77,8 +155,8 @@ export class WebView implements Disposable {
   #externalEvent = new EventEmitter();
   #messageLoop: Promise<void>;
 
-  constructor(options: WebViewOptions) {
-    this.#process = new Deno.Command("./target/debug/deno-webview", {
+  constructor(options: WebViewOptions, binPath: string) {
+    this.#process = new Deno.Command(binPath, {
       args: [JSON.stringify(options)],
       stdin: "piped",
       stdout: "piped",

src/main.rs

@@ -137,8 +137,6 @@ fn main() -> wry::Result<()> {
     }
     let window = window_builder.build(&event_loop).unwrap();
 
-    eprintln!("transparent: {:?}", webview_options.transparent);
-
     let webview_builder = match webview_options.target {
         WebViewTarget::Url(url) => WebViewBuilder::new(&window).with_url(url),
         WebViewTarget::Html(html) => WebViewBuilder::new(&window).with_html(html),
@@ -171,7 +169,6 @@ fn main() -> wry::Result<()> {
         let mut stdout_lock = stdout.lock();
 
         while let Ok(event) = to_deno.recv() {
-            eprintln!("Sending event: {:?}", event);
             match serde_json::to_string(&event) {
                 Ok(json) => {
                     let mut buffer = json.replace("\0", "").into_bytes();