bunite-core 0.0.1

package/src/native/shared/cef_response_filter.h

@@ -0,0 +1,116 @@
+#pragma once
+
+#include <algorithm>
+#include <cctype>
+#include <cstring>
+#include <string>
+
+class BuniteResponseFilter : public CefResponseFilter {
+public:
+  explicit BuniteResponseFilter(std::string script)
+    : script_(std::move(script)) {}
+
+  bool InitFilter() override {
+    buffer_.clear();
+    output_offset_ = 0;
+    injected_ = false;
+    return true;
+  }
+
+  FilterStatus Filter(
+    void* data_in,
+    size_t data_in_size,
+    size_t& data_in_read,
+    void* data_out,
+    size_t data_out_size,
+    size_t& data_out_written
+  ) override {
+    if (data_in_size > 0) {
+      buffer_.append(static_cast<const char*>(data_in), data_in_size);
+      data_in_read = data_in_size;
+    } else {
+      data_in_read = 0;
+    }
+
+    if (!injected_) {
+      tryInject();
+      if (!injected_ && data_in_size == 0 && !script_.empty() && output_offset_ == 0) {
+        buffer_.insert(0, "<script>\n" + escapeInlineScript(script_) + "\n</script>\n");
+        injected_ = true;
+      }
+    }
+
+    const size_t remaining = buffer_.size() - output_offset_;
+    const size_t copy_size = std::min(remaining, data_out_size);
+    if (copy_size > 0) {
+      std::memcpy(data_out, buffer_.data() + output_offset_, copy_size);
+      output_offset_ += copy_size;
+    }
+    data_out_written = copy_size;
+
+    if (data_in_size == 0 && output_offset_ >= buffer_.size()) {
+      return RESPONSE_FILTER_DONE;
+    }
+    return RESPONSE_FILTER_NEED_MORE_DATA;
+  }
+
+private:
+  static std::string lowercase(std::string value) {
+    std::transform(
+      value.begin(),
+      value.end(),
+      value.begin(),
+      [](unsigned char ch) { return static_cast<char>(std::tolower(ch)); }
+    );
+    return value;
+  }
+
+  static std::string escapeInlineScript(const std::string& script) {
+    std::string escaped = script;
+    std::string::size_type offset = 0;
+    while ((offset = escaped.find("</script", offset)) != std::string::npos) {
+      escaped.replace(offset, 8, "<\\/script");
+      offset += 9;
+    }
+    return escaped;
+  }
+
+  void tryInject() {
+    if (injected_ || script_.empty()) {
+      return;
+    }
+
+    const std::string lowered = lowercase(buffer_);
+    std::string tag = "<script>\n" + escapeInlineScript(script_) + "\n</script>\n";
+
+    auto inject_after = [&](const std::string& token) -> bool {
+      const auto start = lowered.find(token);
+      if (start == std::string::npos) {
+        return false;
+      }
+      const auto end = buffer_.find('>', start);
+      if (end == std::string::npos) {
+        return false;
+      }
+      buffer_.insert(end + 1, tag);
+      injected_ = true;
+      return true;
+    };
+
+    if (inject_after("<head") || inject_after("<html")) {
+      return;
+    }
+
+    if (buffer_.size() > 1024 && output_offset_ == 0) {
+      buffer_.insert(0, tag);
+      injected_ = true;
+    }
+  }
+
+  std::string script_;
+  std::string buffer_;
+  size_t output_offset_ = 0;
+  bool injected_ = false;
+
+  IMPLEMENT_REFCOUNTING(BuniteResponseFilter);
+};

package/src/native/shared/ffi_exports.h

@@ -0,0 +1,119 @@
+#pragma once
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "callbacks.h"
+
+#if defined(_WIN32)
+#define BUNITE_EXPORT __declspec(dllexport)
+#else
+#define BUNITE_EXPORT __attribute__((visibility("default")))
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+BUNITE_EXPORT bool bunite_init(
+	const char* process_helper_path,
+	const char* cef_dir,
+	bool hide_console,
+	bool popup_blocking,
+	const char* chromium_flags_json
+);
+BUNITE_EXPORT void bunite_run_loop(void);
+BUNITE_EXPORT void bunite_quit(void);
+BUNITE_EXPORT void bunite_free_cstring(const char* value);
+BUNITE_EXPORT void bunite_set_webview_event_handler(BuniteWebviewEventHandler handler);
+BUNITE_EXPORT void bunite_set_window_event_handler(BuniteWindowEventHandler handler);
+
+BUNITE_EXPORT void* bunite_window_create(
+	uint32_t window_id,
+	double x,
+	double y,
+	double width,
+	double height,
+	const char* title,
+	const char* title_bar_style,
+	bool transparent,
+	bool hidden,
+	bool minimized,
+	bool maximized
+);
+BUNITE_EXPORT void bunite_window_show(void* window_ptr);
+BUNITE_EXPORT void bunite_window_close(void* window_ptr);
+BUNITE_EXPORT void bunite_window_set_title(void* window_ptr, const char* title);
+BUNITE_EXPORT void bunite_window_minimize(void* window_ptr);
+BUNITE_EXPORT void bunite_window_unminimize(void* window_ptr);
+BUNITE_EXPORT bool bunite_window_is_minimized(void* window_ptr);
+BUNITE_EXPORT void bunite_window_maximize(void* window_ptr);
+BUNITE_EXPORT void bunite_window_unmaximize(void* window_ptr);
+BUNITE_EXPORT bool bunite_window_is_maximized(void* window_ptr);
+BUNITE_EXPORT void bunite_window_set_frame(
+	void* window_ptr,
+	double x,
+	double y,
+	double width,
+	double height
+);
+
+BUNITE_EXPORT void* bunite_view_create(
+	uint32_t view_id,
+	void* window_ptr,
+	const char* url,
+	const char* html,
+	const char* preload,
+	const char* views_root,
+	const char* navigation_rules_json,
+	double x,
+	double y,
+	double width,
+	double height,
+	bool auto_resize,
+	bool sandbox
+);
+BUNITE_EXPORT void bunite_view_load_url(void* view_ptr, const char* url);
+BUNITE_EXPORT void bunite_view_load_html(void* view_ptr, const char* html);
+BUNITE_EXPORT void bunite_register_view_route(const char* path);
+BUNITE_EXPORT void bunite_unregister_view_route(const char* path);
+BUNITE_EXPORT void bunite_complete_route_request(uint32_t request_id, const char* html);
+BUNITE_EXPORT void bunite_view_set_visible(void* view_ptr, bool visible);
+BUNITE_EXPORT void bunite_view_set_bounds(
+	void* view_ptr,
+	double x,
+	double y,
+	double width,
+	double height
+);
+BUNITE_EXPORT void bunite_view_set_anchor(void* view_ptr, int mode, double inset);
+BUNITE_EXPORT void bunite_view_go_back(void* view_ptr);
+BUNITE_EXPORT void bunite_view_reload(void* view_ptr);
+BUNITE_EXPORT void bunite_view_remove(void* view_ptr);
+BUNITE_EXPORT void bunite_view_open_devtools(void* view_ptr);
+BUNITE_EXPORT void bunite_view_close_devtools(void* view_ptr);
+BUNITE_EXPORT void bunite_view_toggle_devtools(void* view_ptr);
+BUNITE_EXPORT void bunite_complete_permission_request(uint32_t request_id, uint32_t state);
+BUNITE_EXPORT int32_t bunite_show_message_box(
+	const char* type,
+	const char* title,
+	const char* message,
+	const char* detail,
+	const char* buttons,
+	int32_t default_id,
+	int32_t cancel_id
+);
+BUNITE_EXPORT uint32_t bunite_show_browser_message_box(
+	const char* type,
+	const char* title,
+	const char* message,
+	const char* detail,
+	const char* buttons,
+	int32_t default_id,
+	int32_t cancel_id
+);
+BUNITE_EXPORT void bunite_cancel_browser_message_box(uint32_t request_id);
+
+#ifdef __cplusplus
+}
+#endif

package/src/native/shared/webview_storage.h

@@ -0,0 +1,89 @@
+#pragma once
+
+#include <cstdint>
+#include <map>
+#include <mutex>
+#include <optional>
+#include <set>
+#include <string>
+
+namespace bunite {
+
+class WebviewContentStorage {
+public:
+  static WebviewContentStorage& instance() {
+    static WebviewContentStorage storage;
+    return storage;
+  }
+
+  void set(uint32_t webview_id, std::string content) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    content_[webview_id] = std::move(content);
+  }
+
+  std::string get(uint32_t webview_id) const {
+    std::lock_guard<std::mutex> lock(mutex_);
+    const auto it = content_.find(webview_id);
+    return it == content_.end() ? std::string{} : it->second;
+  }
+
+  void remove(uint32_t webview_id) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    content_.erase(webview_id);
+  }
+
+private:
+  WebviewContentStorage() = default;
+
+  mutable std::mutex mutex_;
+  std::map<uint32_t, std::string> content_;
+};
+
+// Tracks which views:// paths have registered dynamic handlers on the Bun side.
+// The actual handler function lives in JS; this only stores the set of registered paths
+// and completed route responses.
+class ViewsRouteStorage {
+public:
+  static ViewsRouteStorage& instance() {
+    static ViewsRouteStorage storage;
+    return storage;
+  }
+
+  void registerRoute(const std::string& path) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    registered_.insert(path);
+  }
+
+  void unregisterRoute(const std::string& path) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    registered_.erase(path);
+  }
+
+  bool hasRoute(const std::string& path) const {
+    std::lock_guard<std::mutex> lock(mutex_);
+    return registered_.count(path) > 0;
+  }
+
+  void setResponse(uint32_t request_id, std::string content) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    responses_[request_id] = std::move(content);
+  }
+
+  std::optional<std::string> takeResponse(uint32_t request_id) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    const auto it = responses_.find(request_id);
+    if (it == responses_.end()) return std::nullopt;
+    auto result = std::move(it->second);
+    responses_.erase(it);
+    return result;
+  }
+
+private:
+  ViewsRouteStorage() = default;
+
+  mutable std::mutex mutex_;
+  std::set<std::string> registered_;
+  std::map<uint32_t, std::string> responses_;
+};
+
+} // namespace bunite