janela 0.1.0

package/shim/wvshim.cc

@@ -0,0 +1,201 @@
+// wvshim.cc — a C-ABI shim over webview.h shaped to scriptc's FFI format 2.
+//
+// Three constraints drive every design decision here:
+//   1. scriptc has no pointer/u64 type, so webview_t can never cross the
+//      boundary. We keep a handle table and hand out int32 indices.
+//   2. Callback params/returns are numeric scalars only, so the request JSON
+//      cannot be passed as a callback argument. We stage it in a shim-side
+//      buffer and let TS drain it byte-at-a-time via re-entrant FFI calls.
+//   3. Callbacks are lifetime:"call" only. webview_bind wants a retained
+//      callback, which is not expressible. Instead the TS callback is handed
+//      to wv_run(), which blocks for the whole app lifetime — so "call scope"
+//      and "app lifetime" coincide, and bind dispatch happens inside it.
+
+#include "webview.h"
+
+#include <cstdint>
+#include <cstring>
+#include <string>
+#include <vector>
+
+namespace {
+
+struct Bind {
+  std::string name;
+};
+
+struct App {
+  webview_t w = nullptr;
+  bool used = false;
+  std::vector<Bind> binds;
+
+  // Callback supplied by TS for the duration of wv_run().
+  int32_t (*cb)(uint32_t, uint32_t, void *) = nullptr;
+  void *cb_ctx = nullptr;
+
+  // Staging for the in-flight request.
+  std::string req;      // JSON args array from JS
+  std::string cur_id;   // webview's call id, needed by webview_return
+  std::string reply;    // response body assembled by TS
+  uint32_t seq = 0;
+};
+
+// Fixed-size table: handles are indices, never pointers.
+App g_apps[8];
+
+App *app_at(int32_t h) {
+  if (h < 0 || h >= 8 || !g_apps[h].used) return nullptr;
+  return &g_apps[h];
+}
+
+// scriptc passes strings as (ptr, len) and does NOT NUL-terminate.
+std::string to_str(const uint8_t *p, size_t n) {
+  return std::string(reinterpret_cast<const char *>(p), n);
+}
+
+// The single C trampoline registered with webview_bind for every binding.
+// `arg` encodes the app index and bind index.
+void trampoline(const char *id, const char *req, void *arg) {
+  uintptr_t packed = reinterpret_cast<uintptr_t>(arg);
+  App *a = &g_apps[packed >> 32];
+  uint32_t bind_index = static_cast<uint32_t>(packed & 0xffffffffu);
+
+  if (!a->cb) return;  // no TS handler installed
+
+  a->req = req ? req : "";
+  a->cur_id = id ? id : "";
+  a->reply.clear();
+  a->seq++;
+
+  // Re-entrancy: this call lands back in TS, which will call wv_req_byte()
+  // etc. back into this shim before returning.
+  int32_t status = a->cb(bind_index, a->seq, a->cb_ctx);
+
+  webview_return(a->w, a->cur_id.c_str(), status,
+                 a->reply.empty() ? "null" : a->reply.c_str());
+}
+
+}  // namespace
+
+extern "C" {
+
+int32_t wv_create(int32_t debug) {
+  for (int32_t i = 0; i < 8; i++) {
+    if (g_apps[i].used) continue;
+    webview_t w = webview_create(debug, nullptr);
+    if (!w) return -1;
+    g_apps[i] = App{};
+    g_apps[i].w = w;
+    g_apps[i].used = true;
+    return i;
+  }
+  return -1;
+}
+
+int32_t wv_set_title(int32_t h, const uint8_t *p, size_t n) {
+  App *a = app_at(h);
+  if (!a) return -1;
+  return webview_set_title(a->w, to_str(p, n).c_str());
+}
+
+int32_t wv_set_size(int32_t h, int32_t width, int32_t height, int32_t hint) {
+  App *a = app_at(h);
+  if (!a) return -1;
+  return webview_set_size(a->w, width, height,
+                          static_cast<webview_hint_t>(hint));
+}
+
+int32_t wv_set_html(int32_t h, const uint8_t *p, size_t n) {
+  App *a = app_at(h);
+  if (!a) return -1;
+  return webview_set_html(a->w, to_str(p, n).c_str());
+}
+
+int32_t wv_navigate(int32_t h, const uint8_t *p, size_t n) {
+  App *a = app_at(h);
+  if (!a) return -1;
+  return webview_navigate(a->w, to_str(p, n).c_str());
+}
+
+int32_t wv_init(int32_t h, const uint8_t *p, size_t n) {
+  App *a = app_at(h);
+  if (!a) return -1;
+  return webview_init(a->w, to_str(p, n).c_str());
+}
+
+int32_t wv_eval(int32_t h, const uint8_t *p, size_t n) {
+  App *a = app_at(h);
+  if (!a) return -1;
+  return webview_eval(a->w, to_str(p, n).c_str());
+}
+
+// Returns the bind index that wv_run's callback will receive.
+int32_t wv_bind(int32_t h, const uint8_t *p, size_t n) {
+  App *a = app_at(h);
+  if (!a) return -1;
+  uint32_t idx = static_cast<uint32_t>(a->binds.size());
+  a->binds.push_back(Bind{to_str(p, n)});
+  uintptr_t packed = (static_cast<uintptr_t>(h) << 32) | idx;
+  int rc = webview_bind(a->w, a->binds[idx].name.c_str(), trampoline,
+                        reinterpret_cast<void *>(packed));
+  if (rc != WEBVIEW_ERROR_OK) return -1;
+  return static_cast<int32_t>(idx);
+}
+
+// ---- request payload, drained byte-at-a-time from inside the TS callback ----
+int32_t wv_req_len(int32_t h) {
+  App *a = app_at(h);
+  if (!a) return -1;
+  return static_cast<int32_t>(a->req.size());
+}
+
+int32_t wv_req_byte(int32_t h, int32_t i) {
+  App *a = app_at(h);
+  if (!a || i < 0 || static_cast<size_t>(i) >= a->req.size()) return -1;
+  return static_cast<uint8_t>(a->req[i]);
+}
+
+// ---- reply payload, pushed byte-at-a-time from inside the TS callback ----
+int32_t wv_reply_reset(int32_t h) {
+  App *a = app_at(h);
+  if (!a) return -1;
+  a->reply.clear();
+  return 0;
+}
+
+int32_t wv_reply_push(int32_t h, int32_t byte) {
+  App *a = app_at(h);
+  if (!a) return -1;
+  a->reply.push_back(static_cast<char>(byte & 0xff));
+  return 0;
+}
+
+// Blocks for the app's lifetime; dispatches bind calls into `cb`.
+int32_t wv_run(int32_t h, int32_t (*cb)(uint32_t, uint32_t, void *),
+               void *cb_ctx) {
+  App *a = app_at(h);
+  if (!a) return -1;
+  a->cb = cb;
+  a->cb_ctx = cb_ctx;
+  int rc = webview_run(a->w);
+  a->cb = nullptr;  // callback must not outlive the call, per lifetime:"call"
+  a->cb_ctx = nullptr;
+  return rc;
+}
+
+int32_t wv_terminate(int32_t h) {
+  App *a = app_at(h);
+  if (!a) return -1;
+  return webview_terminate(a->w);
+}
+
+int32_t wv_destroy(int32_t h) {
+  App *a = app_at(h);
+  if (!a) return -1;
+  webview_destroy(a->w);
+  a->used = false;
+  a->w = nullptr;
+  return 0;
+}
+
+}  // extern "C"

package/templates/index.html

@@ -0,0 +1,48 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <style>
+      body { font: 16px -apple-system, sans-serif; padding: 2rem; }
+      input[type="number"] { width: 5em; }
+      #events { color: #666; font-size: 13px; }
+    </style>
+  </head>
+  <body>
+    <h1>__NAME__</h1>
+    <p>
+      <input id="a" type="number" value="2" /> +
+      <input id="b" type="number" value="40" />
+      <button id="add">add</button>
+      <button id="quit">Quit</button>
+    </p>
+    <pre id="out">booting…</pre>
+    <ul id="events"></ul>
+
+    <script>
+      // `janela.invoke(name, args)` and `janela.listen(event, cb)` are injected by
+      // janela before the page loads — the Tauri-shaped frontend API.
+      window.onload = async () => {
+        const out = document.getElementById("out");
+        const events = document.getElementById("events");
+
+        janela.listen("added", (sum) => {
+          const li = document.createElement("li");
+          li.textContent = "event 'added' from host: " + sum;
+          events.prepend(li);
+        });
+
+        out.textContent = await janela.invoke("greet", { name: "__NAME__" });
+        await janela.invoke("log", "page loaded");
+
+        document.getElementById("add").onclick = async () => {
+          const a = Number(document.getElementById("a").value);
+          const b = Number(document.getElementById("b").value);
+          const sum = await janela.invoke("add", { a, b });
+          out.textContent = `add(${a}, ${b}) -> ${sum}`;
+        };
+        document.getElementById("quit").onclick = () => janela.invoke("quit");
+      };
+    </script>
+  </body>
+</html>

package/templates/janela.conf.json

@@ -0,0 +1,10 @@
+{
+  "name": "__NAME__",
+  "identifier": "dev.janela.__NAME__",
+  "version": "0.1.0",
+  "window": {
+    "title": "__NAME__",
+    "width": 640,
+    "height": 420
+  }
+}

package/templates/main.ts

@@ -0,0 +1,37 @@
+// src-host/main.ts — your app's backend, compiled to native code by scriptc.
+//
+// Register commands here; the page calls them with `await janela.invoke(name, args)`.
+// Handlers receive the args as JSON text and return JSON text (what the
+// frontend promise resolves with).
+//
+// Gotcha inherited from scriptc 0.0.32: never use a bare FFI-backed call as a
+// complete variable initializer — wrap it in any expression (`+ 0`). Plain
+// TypeScript like everything in this file is unaffected.
+
+import type { JanelaApp } from "./janela";
+
+export function setup(app: JanelaApp): void {
+  app.command("add", (argsJson) => {
+    const a = JSON.parse(argsJson) as { a: number; b: number };
+    const sum = a.a + a.b;
+    // Backend→frontend event, just to show the channel exists.
+    app.emit("added", JSON.stringify(sum));
+    return JSON.stringify(sum);
+  });
+
+  app.command("greet", (argsJson) => {
+    const a = JSON.parse(argsJson) as { name: string };
+    return JSON.stringify("Hello, " + a.name + " — from the native TS binary");
+  });
+
+  app.command("log", (argsJson) => {
+    const a = JSON.parse(argsJson) as string;
+    console.log("[host] page says:", a);
+    return "null";
+  });
+
+  app.command("quit", (_argsJson) => {
+    app.quit();
+    return "null";
+  });
+}

package/vendor-webview/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2017 Serge Zaitsev
+Copyright (c) 2022 Steffen André Langnes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/vendor-webview/core/include/webview/api.h

@@ -0,0 +1,251 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2017 Serge Zaitsev
+ * Copyright (c) 2022 Steffen André Langnes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef WEBVIEW_API_H
+#define WEBVIEW_API_H
+
+#include "errors.h"
+#include "macros.h"
+#include "types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Creates a new webview instance.
+ *
+ * @param debug Enable developer tools if supported by the backend.
+ * @param window Optional native window handle, i.e. @c GtkWindow pointer
+ *        @c NSWindow pointer (Cocoa) or @c HWND (Win32). If non-null,
+ *        the webview widget is embedded into the given window, and the
+ *        caller is expected to assume responsibility for the window as
+ *        well as application lifecycle. If the window handle is null,
+ *        a new window is created and both the window and application
+ *        lifecycle are managed by the webview instance.
+ * @remark Win32: The function also accepts a pointer to @c HWND (Win32) in the
+ *         window parameter for backward compatibility.
+ * @remark Win32/WebView2: @c CoInitializeEx should be called with
+ *         @c COINIT_APARTMENTTHREADED before attempting to call this function
+ *         with an existing window. Omitting this step may cause WebView2
+ *         initialization to fail.
+ * @return @c NULL on failure. Creation can fail for various reasons such
+ *         as when required runtime dependencies are missing or when window
+ *         creation fails.
+ * @retval WEBVIEW_ERROR_MISSING_DEPENDENCY
+ *         May be returned if WebView2 is unavailable on Windows.
+ */
+WEBVIEW_API webview_t webview_create(int debug, void *window);
+
+/**
+ * Destroys a webview instance and closes the native window.
+ *
+ * @param w The webview instance.
+ */
+WEBVIEW_API webview_error_t webview_destroy(webview_t w);
+
+/**
+ * Runs the main loop until it's terminated.
+ *
+ * @param w The webview instance.
+ */
+WEBVIEW_API webview_error_t webview_run(webview_t w);
+
+/**
+ * Stops the main loop. It is safe to call this function from another
+ * background thread.
+ *
+ * @param w The webview instance.
+ */
+WEBVIEW_API webview_error_t webview_terminate(webview_t w);
+
+/**
+ * Schedules a function to be invoked on the thread with the run/event loop.
+ *
+ * Since library functions generally do not have thread safety guarantees,
+ * this function can be used to schedule code to execute on the main/GUI
+ * thread and thereby make that execution safe in multi-threaded applications.
+ *
+ * @param w The webview instance.
+ * @param fn The function to be invoked.
+ * @param arg An optional argument passed along to the callback function.
+ */
+WEBVIEW_API webview_error_t webview_dispatch(webview_t w,
+                                             void (*fn)(webview_t w, void *arg),
+                                             void *arg);
+
+/**
+ * Returns the native handle of the window associated with the webview instance.
+ * The handle can be a @c GtkWindow pointer (GTK), @c NSWindow pointer (Cocoa)
+ * or @c HWND (Win32).
+ *
+ * @param w The webview instance.
+ * @return The handle of the native window.
+ */
+WEBVIEW_API void *webview_get_window(webview_t w);
+
+/**
+ * Get a native handle of choice.
+ *
+ * @param w The webview instance.
+ * @param kind The kind of handle to retrieve.
+ * @return The native handle or @c NULL.
+ * @since 0.11
+ */
+WEBVIEW_API void *webview_get_native_handle(webview_t w,
+                                            webview_native_handle_kind_t kind);
+
+/**
+ * Updates the title of the native window.
+ *
+ * @param w The webview instance.
+ * @param title The new title.
+ */
+WEBVIEW_API webview_error_t webview_set_title(webview_t w, const char *title);
+
+/**
+ * Updates the size of the native window.
+ *
+ * Remarks:
+ * - Subsequent calls to this function may behave inconsistently across
+ *   different versions of GTK and windowing systems (X11/Wayland).
+ * - Using WEBVIEW_HINT_MAX for setting the maximum window size is not
+ *   supported with GTK 4 because X11-specific functions such as
+ *   gtk_window_set_geometry_hints were removed. This option has no effect
+ *   when using GTK 4.
+ *
+ * @param w The webview instance.
+ * @param width New width.
+ * @param height New height.
+ * @param hints Size hints.
+ */
+WEBVIEW_API webview_error_t webview_set_size(webview_t w, int width, int height,
+                                             webview_hint_t hints);
+
+/**
+ * Navigates webview to the given URL. URL may be a properly encoded data URI.
+ *
+ * Example:
+ * @code{.c}
+ * webview_navigate(w, "https://github.com/webview/webview");
+ * webview_navigate(w, "data:text/html,%3Ch1%3EHello%3C%2Fh1%3E");
+ * webview_navigate(w, "data:text/html;base64,PGgxPkhlbGxvPC9oMT4=");
+ * @endcode
+ *
+ * @param w The webview instance.
+ * @param url URL.
+ */
+WEBVIEW_API webview_error_t webview_navigate(webview_t w, const char *url);
+
+/**
+ * Load HTML content into the webview.
+ *
+ * Example:
+ * @code{.c}
+ * webview_set_html(w, "<h1>Hello</h1>");
+ * @endcode
+ *
+ * @param w The webview instance.
+ * @param html HTML content.
+ */
+WEBVIEW_API webview_error_t webview_set_html(webview_t w, const char *html);
+
+/**
+ * Injects JavaScript code to be executed immediately upon loading a page.
+ * The code will be executed before @c window.onload.
+ *
+ * @param w The webview instance.
+ * @param js JS content.
+ */
+WEBVIEW_API webview_error_t webview_init(webview_t w, const char *js);
+
+/**
+ * Evaluates arbitrary JavaScript code.
+ *
+ * Use bindings if you need to communicate the result of the evaluation.
+ *
+ * @param w The webview instance.
+ * @param js JS content.
+ */
+WEBVIEW_API webview_error_t webview_eval(webview_t w, const char *js);
+
+/**
+ * Binds a function pointer to a new global JavaScript function.
+ *
+ * Internally, JS glue code is injected to create the JS function by the
+ * given name. The callback function is passed a request identifier,
+ * a request string and a user-provided argument. The request string is
+ * a JSON array of the arguments passed to the JS function.
+ *
+ * @param w The webview instance.
+ * @param name Name of the JS function.
+ * @param fn Callback function.
+ * @param arg User argument.
+ * @retval WEBVIEW_ERROR_DUPLICATE
+ *         A binding already exists with the specified name.
+ */
+WEBVIEW_API webview_error_t webview_bind(webview_t w, const char *name,
+                                         void (*fn)(const char *id,
+                                                    const char *req, void *arg),
+                                         void *arg);
+
+/**
+ * Removes a binding created with webview_bind().
+ *
+ * @param w The webview instance.
+ * @param name Name of the binding.
+ * @retval WEBVIEW_ERROR_NOT_FOUND No binding exists with the specified name.
+ */
+WEBVIEW_API webview_error_t webview_unbind(webview_t w, const char *name);
+
+/**
+ * Responds to a binding call from the JS side.
+ *
+ * This function is safe to call from another thread.
+ *
+ * @param w The webview instance.
+ * @param id The identifier of the binding call. Pass along the value received
+ *           in the binding handler (see webview_bind()).
+ * @param status A status of zero tells the JS side that the binding call was
+ *               successful; any other value indicates an error.
+ * @param result The result of the binding call to be returned to the JS side.
+ *               This must either be a valid JSON value or an empty string for
+ *               the primitive JS value @c undefined.
+ */
+WEBVIEW_API webview_error_t webview_return(webview_t w, const char *id,
+                                           int status, const char *result);
+
+/**
+ * Get the library's version information.
+ *
+ * @since 0.10
+ */
+WEBVIEW_API const webview_version_info_t *webview_version(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // WEBVIEW_API_H

package/vendor-webview/core/include/webview/backends.hh

@@ -0,0 +1,40 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2017 Serge Zaitsev
+ * Copyright (c) 2022 Steffen André Langnes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef WEBVIEW_BACKENDS_HH
+#define WEBVIEW_BACKENDS_HH
+
+#if defined(__cplusplus) && !defined(WEBVIEW_HEADER)
+
+#include "detail/backends/cocoa_webkit.hh"
+#include "detail/backends/gtk_webkitgtk.hh"
+#include "detail/backends/win32_edge.hh"
+
+namespace webview {
+using webview = browser_engine;
+}
+
+#endif // defined(__cplusplus) && !defined(WEBVIEW_HEADER)
+#endif // WEBVIEW_BACKENDS_HH