Support transparency; many other features (#11)

* Add transparency/devtools flags

Transparency is disabled by default because on osx it requires private APIs. That unfortunately means that an app with transparency *can't* be published to the app store.

Devtools are enabled in all debug builds but are disabled in release builds. Again, on OSX it uses private APIs so an app w/ devtools enabled can't be published to the app store.

* Use transparent flag in build

* Features out the wazoo

Author: zephraph

Cargo.toml

@@ -9,3 +9,16 @@ serde_json = "1"
 tao = "0.28.0"
 wry = "0.39.5"
 schemars = "0.8.21"
+
+[features]
+transparent = ["wry/transparent"]
+devtools = ["wry/devtools"]
+
+[target.'cfg(any(feature = "transparent", feature = "devtools"))'.dependencies]
+wry = { version = "0.39.5", features = [] }
+
+[target.'cfg(feature = "transparent")'.dependencies.wry]
+features = ["transparent"]
+
+[target.'cfg(feature = "devtools")'.dependencies.wry]
+features = ["devtools"]

deno.json

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

schemas/WebViewOptions.json

@@ -1,15 +1,15 @@
 import { walk } from "https://deno.land/std@0.190.0/fs/walk.ts";
 import { basename } from "https://deno.land/std@0.190.0/path/mod.ts";
 import { match, P } from "npm:ts-pattern";
-import {
-  type JSONSchema7 as JSONSchema,
-  JSONSchema7Definition,
+import type {
+  JSONSchema7 as JSONSchema,
+  JSONSchema7Definition as JSONSchemaDefinition,
 } from "npm:@types/json-schema";
 
 const schemasDir = new URL("../schemas", import.meta.url).pathname;
 const outputFile = new URL("../src/schemas.ts", import.meta.url).pathname;
 
-const isDescriminatedUnion = (def: JSONSchema7Definition[] | undefined) => {
+const isDescriminatedUnion = (def: JSONSchemaDefinition[] | undefined) => {
   return def && typeof def[0] === "object" &&
     def[0]?.required?.includes("$type");
 };
@@ -22,6 +22,13 @@ function generateZodSchema(schema: JSONSchema) {
   const wn = (...t: string[]) => w(...t, "\n");
 
   match(schema)
+    .with(
+      { type: "boolean" },
+      (schema) =>
+        w(
+          "z.boolean()" + (schema.default ? `.optional()` : ""),
+        ),
+    )
     .with({ type: "string", enum: P.array() }, (schema) => {
       w(`z.literal("${schema.enum[0]}")`);
     })
@@ -30,6 +37,7 @@ function generateZodSchema(schema: JSONSchema) {
       w("z");
       for (const type of schema.type) {
         match(type)
+          .with("boolean", () => w(".boolean()"))
           .with("string", () => w(".string()"))
           .with("null", () => w(".nullable()"))
           .otherwise(() => {

scripts/generate-zod.ts

@@ -1,16 +1,55 @@
+use std::borrow::{Borrow, BorrowMut};
 use std::env;
 use std::io::{self, BufRead, Write};
 use std::sync::mpsc;
 
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use serde_json;
+use tao::window::Fullscreen;
 
 #[derive(JsonSchema, Deserialize, Debug)]
 struct WebViewOptions {
     title: String,
     #[serde(flatten)]
     target: WebViewTarget,
+    /// Sets whether the window should be fullscreen.
+    #[serde(default)]
+    fullscreen: bool,
+    /// Sets whether the window should have a border, a title bar, etc.
+    #[serde(default = "default_true")]
+    decorations: bool,
+    #[serde(default)]
+    transparent: bool,
+    /// Sets whether all media can be played without user interaction.
+    #[serde(default)]
+    autoplay: bool,
+    /// Enable or disable web inspector which is usually called devtools.
+    ///
+    /// Note this only enables devtools to the webview. To open it, you can call WebView::open_devtools, or right click the page and open it from the context menu.
+    #[serde(default)]
+    devtools: bool,
+    /// Run the WebView with incognito mode. Note that WebContext will be ingored if incognito is enabled.
+    ///
+    /// Platform-specific:
+    /// - Windows: Requires WebView2 Runtime version 101.0.1210.39 or higher, does nothing on older versions, see https://learn.microsoft.com/en-us/microsoft-edge/webview2/release-notes/archive?tabs=dotnetcsharp#10121039
+    #[serde(default)]
+    incognito: bool,
+    /// Enables clipboard access for the page rendered on Linux and Windows.
+    ///
+    /// macOS doesn’t provide such method and is always enabled by default. But your app will still need to add menu item accelerators to use the clipboard shortcuts.
+    #[serde(default)]
+    clipboard: bool,
+    /// Sets whether the webview should be focused when created. Default is false.
+    #[serde(default)]
+    focused: bool,
+    /// Sets whether clicking an inactive window also clicks through to the webview. Default is false.
+    #[serde(default)]
+    accept_first_mouse: bool,
+}
+
+fn default_true() -> bool {
+    true
 }
 
 #[derive(JsonSchema, Deserialize, Debug)]
@@ -57,16 +96,29 @@ fn main() -> wry::Result<()> {
     use wry::WebViewBuilder;
 
     let event_loop = EventLoop::new();
-    let window = WindowBuilder::new()
+    let mut window_builder = WindowBuilder::new()
         .with_title(webview_options.title)
-        .build(&event_loop)
-        .unwrap();
+        .with_transparent(webview_options.transparent)
+        .with_decorations(webview_options.decorations);
+    if webview_options.fullscreen {
+        window_builder = window_builder.with_fullscreen(Some(Fullscreen::Borderless(None)));
+    }
+    let window = window_builder.build(&event_loop).unwrap();
+
+    eprintln!("transparent: {:?}", webview_options.transparent);
 
-    let webview = match webview_options.target {
+    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),
     }
-    .build()?;
+    .with_transparent(webview_options.transparent)
+    .with_autoplay(webview_options.autoplay)
+    .with_incognito(webview_options.incognito)
+    .with_clipboard(webview_options.clipboard)
+    .with_focused(webview_options.focused)
+    .with_devtools(webview_options.devtools)
+    .with_accept_first_mouse(webview_options.accept_first_mouse);
+    let webview = webview_builder.build()?;
 
     let (tx, to_deno) = mpsc::channel::<WebViewEvent>();
     let (from_deno, rx) = mpsc::channel::<ClientEvent>();

src/main.rs

@@ -15,7 +15,16 @@ export type ClientEvent = z.infer<typeof ClientEvent>;
 
 export const WebViewOptions = z.intersection(
   z.object({
+    accept_first_mouse: z.boolean().optional(),
+    autoplay: z.boolean().optional(),
+    clipboard: z.boolean().optional(),
+    decorations: z.boolean().optional().optional(),
+    devtools: z.boolean().optional(),
+    focused: z.boolean().optional(),
+    fullscreen: z.boolean().optional(),
+    incognito: z.boolean().optional(),
     title: z.string(),
+    transparent: z.boolean().optional(),
   }),
   z.union([
     z.object({