create-zudo-doc 0.1.0

package/templates/features/tauri/files/src/utils/find-in-page.ts

@@ -0,0 +1,175 @@
+export interface FindResult {
+  matches: number;
+  activeMatchOrdinal: number; // 1-based
+}
+
+export interface FindInPage {
+  find(container: HTMLElement, query: string): FindResult;
+  next(): FindResult;
+  prev(): FindResult;
+  stop(): void;
+}
+
+const MATCH_CLASS = "find-match";
+const ACTIVE_CLASS = "find-match-active";
+const MATCH_ATTR = "data-find-match";
+const ACTIVE_ATTR = "data-find-active";
+
+const EMPTY_RESULT: FindResult = Object.freeze({ matches: 0, activeMatchOrdinal: 0 });
+
+/**
+ * Create a DOM-based find-in-page utility.
+ *
+ * Limitation: only matches within single text nodes. Cross-element matching
+ * (e.g. "Hello world" spanning `<strong>Hello</strong> world`) is not supported.
+ */
+export function createFindInPage(): FindInPage {
+  let matchElements: HTMLElement[] = [];
+  let activeIndex = -1;
+
+  function clearMarks(): void {
+    const parentsToNormalize = new Set<Node>();
+
+    for (let i = matchElements.length - 1; i >= 0; i--) {
+      const mark = matchElements[i];
+      const parent = mark.parentNode;
+      if (parent) {
+        const textNode = document.createTextNode(mark.textContent || "");
+        parent.replaceChild(textNode, mark);
+        parentsToNormalize.add(parent);
+      }
+    }
+    for (const parent of parentsToNormalize) {
+      (parent as Element).normalize();
+    }
+    matchElements = [];
+    activeIndex = -1;
+  }
+
+  function setActive(index: number): void {
+    if (activeIndex >= 0 && activeIndex < matchElements.length) {
+      const prev = matchElements[activeIndex];
+      prev.classList.remove(ACTIVE_CLASS);
+      prev.removeAttribute(ACTIVE_ATTR);
+    }
+    activeIndex = index;
+    if (activeIndex >= 0 && activeIndex < matchElements.length) {
+      const current = matchElements[activeIndex];
+      current.classList.add(ACTIVE_CLASS);
+      current.setAttribute(ACTIVE_ATTR, "true");
+      current.scrollIntoView?.({ block: "center" });
+    }
+  }
+
+  function currentResult(): FindResult {
+    if (matchElements.length === 0) {
+      return EMPTY_RESULT;
+    }
+    return {
+      matches: matchElements.length,
+      activeMatchOrdinal: activeIndex + 1,
+    };
+  }
+
+  function find(container: HTMLElement, query: string): FindResult {
+    clearMarks();
+
+    if (!query) {
+      return EMPTY_RESULT;
+    }
+
+    const lowerQuery = query.toLowerCase();
+
+    const walker = document.createTreeWalker(
+      container,
+      NodeFilter.SHOW_TEXT,
+      null,
+    );
+
+    const textNodes: Text[] = [];
+    let node: Text | null;
+    while ((node = walker.nextNode() as Text | null)) {
+      textNodes.push(node);
+    }
+
+    for (const textNode of textNodes) {
+      const text = textNode.textContent || "";
+      const lowerText = text.toLowerCase();
+
+      const positions: number[] = [];
+      let searchFrom = 0;
+      while (searchFrom < lowerText.length) {
+        const idx = lowerText.indexOf(lowerQuery, searchFrom);
+        if (idx === -1) break;
+        positions.push(idx);
+        searchFrom = idx + lowerQuery.length;
+      }
+
+      if (positions.length === 0) continue;
+
+      const parent = textNode.parentNode;
+      if (!parent) continue;
+
+      let remainingNode: Text = textNode;
+      const nodeMarks: HTMLElement[] = [];
+
+      for (let i = positions.length - 1; i >= 0; i--) {
+        const pos = positions[i];
+        const matchLen = query.length;
+
+        if (pos + matchLen < remainingNode.length) {
+          remainingNode.splitText(pos + matchLen);
+        }
+
+        let matchNode: Text;
+        if (pos > 0) {
+          matchNode = remainingNode.splitText(pos);
+        } else {
+          matchNode = remainingNode;
+        }
+
+        const mark = document.createElement("mark");
+        mark.className = MATCH_CLASS;
+        mark.setAttribute(MATCH_ATTR, "true");
+        mark.textContent = matchNode.textContent;
+
+        parent.replaceChild(mark, matchNode);
+        nodeMarks.unshift(mark);
+      }
+
+      matchElements.push(...nodeMarks);
+    }
+
+    if (matchElements.length === 0) {
+      return EMPTY_RESULT;
+    }
+
+    setActive(0);
+    return currentResult();
+  }
+
+  function next(): FindResult {
+    if (matchElements.length === 0) {
+      return EMPTY_RESULT;
+    }
+    const newIndex = (activeIndex + 1) % matchElements.length;
+    setActive(newIndex);
+    return currentResult();
+  }
+
+  function prev(): FindResult {
+    if (matchElements.length === 0) {
+      return EMPTY_RESULT;
+    }
+    const newIndex =
+      (activeIndex - 1 + matchElements.length) % matchElements.length;
+    setActive(newIndex);
+    return currentResult();
+  }
+
+  function stop(): void {
+    clearMarks();
+  }
+
+  return { find, next, prev, stop };
+}

package/templates/features/tauri/files/src-tauri/Cargo.toml

@@ -0,0 +1,14 @@
+# Build the .app bundle: cargo tauri build
+# (requires `cargo install tauri-cli` or `cargo binstall tauri-cli`)
+
+[package]
+name = "zudo-doc"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+tauri = { version = "2", features = ["devtools"] }
+open = "5"
+
+[build-dependencies]
+tauri-build = { version = "2", features = [] }

package/templates/features/tauri/files/src-tauri/build.rs

@@ -0,0 +1,3 @@
+fn main() {
+    tauri_build::build()
+}

package/templates/features/tauri/files/src-tauri/capabilities/default.json

@@ -0,0 +1,11 @@
+{
+  "identifier": "default",
+  "description": "Default capabilities for the main window",
+  "windows": ["main"],
+  "remote": {
+    "urls": ["http://localhost:*/**"]
+  },
+  "permissions": [
+    "core:default"
+  ]
+}

package/templates/features/tauri/files/src-tauri/src/main.rs

@@ -0,0 +1,250 @@
+// Mode 1 — Standalone offline reader (src-tauri/)
+//
+// `cargo tauri build`     → bundles zudo-doc's own static `dist/` into a self-contained .app.
+//                           This is the shipped offline reader for zudo-doc itself.
+// `cargo tauri dev`       → repo-internal contributor convenience only. Uses `beforeDevCommand`
+//                           to spawn `pnpm dev` and opens the WebView against the local zfb dev
+//                           server. NOT a shipped product; only for zudo-doc contributors.
+//
+// For the shipped, configurable dev wrapper (for any project), see src-tauri-dev/ (Mode 2).
+// Mode 2 build: cd src-tauri-dev && cargo tauri build
+
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+use std::sync::Mutex;
+use std::thread;
+
+use tauri::menu::{MenuBuilder, MenuItemBuilder, SubmenuBuilder};
+use tauri::webview::PageLoadEvent;
+use tauri::{AppHandle, Manager, WebviewUrl, WebviewWindowBuilder};
+
+const DEV_PORT: u16 = 4321;
+const IS_DEV: bool = cfg!(debug_assertions);
+
+struct AppState {
+    zoom: Mutex<f64>,
+}
+
+// ── Helpers ───────────────────────────────────────
+
+fn dev_url() -> String {
+    format!("http://localhost:{DEV_PORT}/")
+}
+
+// ── Refresh / Zoom ───────────────────────────────
+
+fn do_refresh(app_handle: &AppHandle) {
+    if let Some(w) = app_handle.get_webview_window("main") {
+        if IS_DEV {
+            let _ = w.navigate(
+                dev_url()
+                    .parse()
+                    .expect("BUG: dev_url produced an invalid URL"),
+            );
+        } else {
+            let _ = w.eval("window.location.reload()");
+        }
+    }
+}
+
+fn apply_zoom(app_handle: &AppHandle, level: f64) {
+    let state = app_handle.state::<AppState>();
+    *state.zoom.lock().unwrap() = level;
+    if let Some(w) = app_handle.get_webview_window("main") {
+        // quirk: `document.body.style.zoom` is a non-standard Chromium-only CSS property.
+        // It is NOT part of any CSS spec (Firefox does not support it). Tauri's embedded
+        // Chromium/WebKit (WKWebView on macOS, Chromium on Windows/Linux) supports it, so
+        // it works here. The standards-based alternative is `webview.setZoom()` from the
+        // Tauri API, but migration is out of scope — keep as-is.
+        let _ = w.eval(&format!("document.body.style.zoom = '{level}'"));
+    }
+}
+
+// ── Main ──────────────────────────────────────────
+
+fn main() {
+    let app_state = AppState {
+        zoom: Mutex::new(1.0),
+    };
+
+    tauri::Builder::default()
+        .manage(app_state)
+        .setup(move |app| {
+            // ── Menu ──
+            let app_menu = SubmenuBuilder::new(app, "ZudoDoc")
+                .about(None)
+                .separator()
+                .quit()
+                .build()?;
+
+            let edit_menu = SubmenuBuilder::new(app, "Edit")
+                .undo()
+                .redo()
+                .separator()
+                .cut()
+                .copy()
+                .paste()
+                .select_all()
+                .build()?;
+
+            let view_menu = SubmenuBuilder::new(app, "View")
+                .item(
+                    &MenuItemBuilder::with_id("refresh", "Refresh")
+                        .accelerator("CmdOrCtrl+R")
+                        .build(app)?,
+                )
+                .item(
+                    &MenuItemBuilder::with_id("devtools", "Toggle Developer Tools")
+                        .accelerator("CmdOrCtrl+Alt+I")
+                        .build(app)?,
+                )
+                .separator()
+                .item(
+                    &MenuItemBuilder::with_id("actual_size", "Actual Size")
+                        .accelerator("CmdOrCtrl+0")
+                        .build(app)?,
+                )
+                .item(
+                    &MenuItemBuilder::with_id("zoom_in", "Zoom In")
+                        .accelerator("CmdOrCtrl+=")
+                        .build(app)?,
+                )
+                .item(
+                    &MenuItemBuilder::with_id("zoom_out", "Zoom Out")
+                        .accelerator("CmdOrCtrl+-")
+                        .build(app)?,
+                )
+                .build()?;
+
+            let menu = MenuBuilder::new(app)
+                .item(&app_menu)
+                .item(&edit_menu)
+                .item(&view_menu)
+                .build()?;
+
+            app.set_menu(menu)?;
+
+            app.on_menu_event(|app_handle, event| match event.id().as_ref() {
+                "refresh" => {
+                    let handle = app_handle.clone();
+                    thread::spawn(move || do_refresh(&handle));
+                }
+                "devtools" => {
+                    if let Some(w) = app_handle.get_webview_window("main") {
+                        if w.is_devtools_open() {
+                            w.close_devtools();
+                        } else {
+                            w.open_devtools();
+                        }
+                    }
+                }
+                "actual_size" => apply_zoom(app_handle, 1.0),
+                "zoom_in" => {
+                    let state = app_handle.state::<AppState>();
+                    let z = (*state.zoom.lock().unwrap() + 0.1).min(3.0);
+                    apply_zoom(app_handle, z);
+                }
+                "zoom_out" => {
+                    let state = app_handle.state::<AppState>();
+                    let z = (*state.zoom.lock().unwrap() - 0.1).max(0.1);
+                    apply_zoom(app_handle, z);
+                }
+                _ => {}
+            });
+
+            // ── Window ──
+            // Dev: connect to zfb dev server via devUrl (contributor convenience only)
+            // Production: Tauri serves embedded dist/ files via frontendDist
+            let initial_url = if IS_DEV {
+                WebviewUrl::External(
+                    dev_url()
+                        .parse()
+                        .expect("BUG: dev_url produced an invalid URL"),
+                )
+            } else {
+                WebviewUrl::default()
+            };
+
+            let window =
+                WebviewWindowBuilder::new(app, "main", initial_url)
+                    .title("ZudoDoc")
+                    .inner_size(1200.0, 800.0)
+                    .visible(false)
+                    .on_navigation(|url| {
+                        let s = url.as_str();
+                        // Allow internal schemes and the local dev / bundled app origins.
+                        // - http://localhost, https://localhost          : zfb dev server
+                        // - tauri://                                     : bundled app (macOS/Linux)
+                        // - http://tauri.localhost, https://tauri.localhost
+                        //                                                : bundled app (Windows)
+                        // - asset://                                     : Tauri asset protocol
+                        // - data:                                        : inline data URLs
+                        if s.starts_with("http://localhost")
+                            || s.starts_with("https://localhost")
+                            || s.starts_with("http://tauri.localhost")
+                            || s.starts_with("https://tauri.localhost")
+                            || s.starts_with("tauri://")
+                            || s.starts_with("asset://")
+                            || s.starts_with("data:")
+                        {
+                            return true;
+                        }
+                        // External http/https links -> default OS browser.
+                        if s.starts_with("http://") || s.starts_with("https://") {
+                            let owned = s.to_string();
+                            tauri::async_runtime::spawn_blocking(move || {
+                                let _ = open::that(owned);
+                            });
+                            return false;
+                        }
+                        // mailto: -> default mail client.
+                        if s.starts_with("mailto:") {
+                            let owned = s.to_string();
+                            tauri::async_runtime::spawn_blocking(move || {
+                                let _ = open::that(owned);
+                            });
+                            return false;
+                        }
+                        // Block any other scheme (javascript:, file:, etc.).
+                        false
+                    })
+                    .build()?;
+
+            // Show window after page loads to avoid white flash
+            let win = window.clone();
+            window.on_window_event(move |event| {
+                if let tauri::WindowEvent::Focused(true) = event {
+                    if !win.is_visible().unwrap_or(false) {
+                        let _ = win.show();
+                    }
+                }
+            });
+
+            // Fallback: show after a short delay if focus event doesn't fire
+            let win = window.clone();
+            thread::spawn(move || {
+                thread::sleep(std::time::Duration::from_millis(500));
+                let _ = win.show();
+            });
+
+            Ok(())
+        })
+        .on_page_load(|webview, payload| {
+            if webview.label() == "main"
+                && matches!(payload.event(), PageLoadEvent::Finished)
+            {
+                let _ = webview.window().show();
+            }
+        })
+        .build(tauri::generate_context!())
+        .expect("error while building tauri application")
+        .run(|app_handle, event| {
+            if let tauri::RunEvent::WindowEvent {
+                event: tauri::WindowEvent::Destroyed,
+                ..
+            } = &event
+            {
+                app_handle.exit(0);
+            }
+        });
+}

package/templates/features/tauri/files/src-tauri/tauri.conf.json

@@ -0,0 +1,25 @@
+{
+  "productName": "ZudoDoc",
+  "version": "0.1.0",
+  "identifier": "com.zudolab.zudo-doc",
+  "build": {
+    "frontendDist": "../dist",
+    "beforeDevCommand": "pnpm dev",
+    "devUrl": "http://localhost:4321/"
+  },
+  "app": {
+    "windows": [],
+    "security": {
+      "csp": null
+    }
+  },
+  "bundle": {
+    "active": false,
+    "targets": "all",
+    "icon": [],
+    "category": "DeveloperTool",
+    "macOS": {
+      "minimumSystemVersion": "10.15"
+    }
+  }
+}

package/templates/features/tauriDev/files/src-tauri-dev/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "zudo-doc-dev"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+tauri = { version = "2", features = ["devtools"] }
+libc = "0.2"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+
+[build-dependencies]
+tauri-build = { version = "2", features = [] }
+
+[dev-dependencies]

package/templates/features/tauriDev/files/src-tauri-dev/build.rs

@@ -0,0 +1,3 @@
+fn main() {
+    tauri_build::build()
+}

package/templates/features/tauriDev/files/src-tauri-dev/capabilities/default.json

@@ -0,0 +1,7 @@
+{
+  "identifier": "default",
+  "description": "Default capabilities for the main window",
+  "windows": ["main"],
+  "remote": { "urls": ["http://localhost:*/*"] },
+  "permissions": ["core:default"]
+}