sparkbun 0.1.0

package/src/native/shared/ffi_helpers.h

@@ -0,0 +1,139 @@
+// ffi_helpers.h - Cross-platform FFI helper utilities
+// Helpers for passing strings and data across FFI boundaries
+// Used across Windows, macOS, and Linux
+//
+// This is a header-only implementation to avoid build complexity.
+
+#ifndef ELECTROBUN_FFI_HELPERS_H
+#define ELECTROBUN_FFI_HELPERS_H
+
+#include <string>
+#include <cstring>
+#include <cstdlib>
+
+namespace electrobun {
+
+// Create a copy of a string for FFI callbacks
+// The returned string is allocated with malloc/strdup and must be freed by the caller
+// Returns nullptr if the input is empty
+inline char* createFFIString(const std::string& str) {
+    if (str.empty()) {
+        return nullptr;
+    }
+    return strdup(str.c_str());
+}
+
+// Create a copy of a C string for FFI callbacks
+// The returned string is allocated with malloc/strdup and must be freed by the caller
+// Returns nullptr if the input is null or empty
+inline char* createFFIString(const char* str) {
+    if (!str || str[0] == '\0') {
+        return nullptr;
+    }
+    return strdup(str);
+}
+
+// Free an FFI string that was created with createFFIString
+inline void freeFFIString(char* str) {
+    if (str) {
+        free(str);
+    }
+}
+
+// Free an FFI string (const version for convenience)
+inline void freeFFIString(const char* str) {
+    if (str) {
+        free(const_cast<char*>(str));
+    }
+}
+
+// RAII wrapper for FFI strings
+// Automatically frees the string when it goes out of scope
+class FFIString {
+public:
+    FFIString() : str_(nullptr) {}
+
+    explicit FFIString(const std::string& str)
+        : str_(createFFIString(str)) {}
+
+    explicit FFIString(const char* str)
+        : str_(createFFIString(str)) {}
+
+    ~FFIString() {
+        freeFFIString(str_);
+    }
+
+    // Get the raw pointer (for passing to FFI)
+    const char* get() const { return str_; }
+
+    // Release ownership (caller takes responsibility for freeing)
+    char* release() {
+        char* temp = str_;
+        str_ = nullptr;
+        return temp;
+    }
+
+    // Check if string is valid
+    bool valid() const { return str_ != nullptr; }
+    explicit operator bool() const { return valid(); }
+
+    // Non-copyable
+    FFIString(const FFIString&) = delete;
+    FFIString& operator=(const FFIString&) = delete;
+
+    // Movable
+    FFIString(FFIString&& other) noexcept : str_(other.str_) {
+        other.str_ = nullptr;
+    }
+
+    FFIString& operator=(FFIString&& other) noexcept {
+        if (this != &other) {
+            freeFFIString(str_);
+            str_ = other.str_;
+            other.str_ = nullptr;
+        }
+        return *this;
+    }
+
+private:
+    char* str_;
+};
+
+// Helper to create event data strings for callbacks
+// Format: "key1=value1&key2=value2&..."
+class FFIEventBuilder {
+public:
+    FFIEventBuilder& add(const std::string& key, const std::string& value) {
+        if (!data_.empty()) {
+            data_ += "&";
+        }
+        data_ += key + "=" + value;
+        return *this;
+    }
+
+    FFIEventBuilder& add(const std::string& key, int value) {
+        return add(key, std::to_string(value));
+    }
+
+    FFIEventBuilder& add(const std::string& key, double value) {
+        return add(key, std::to_string(value));
+    }
+
+    FFIEventBuilder& add(const std::string& key, bool value) {
+        return add(key, value ? "true" : "false");
+    }
+
+    std::string str() const { return data_; }
+
+    // Create FFI string (caller must free)
+    char* createFFIString() const {
+        return electrobun::createFFIString(data_);
+    }
+
+private:
+    std::string data_;
+};
+
+} // namespace electrobun
+
+#endif // ELECTROBUN_FFI_HELPERS_H

package/src/native/shared/glob_match.h

@@ -0,0 +1,59 @@
+// glob_match.h - Cross-platform glob pattern matching utility
+// Used for navigation rules matching across Windows, macOS, and Linux
+//
+// This is a header-only implementation to avoid build complexity.
+// Supports * wildcard only, case-insensitive matching.
+
+#ifndef ELECTROBUN_GLOB_MATCH_H
+#define ELECTROBUN_GLOB_MATCH_H
+
+#include <string>
+#include <cctype>
+
+namespace electrobun {
+
+// Simple case-insensitive glob matcher (supports * wildcard only)
+// Returns true if text matches the glob pattern
+//
+// Examples:
+//   globMatch("*.example.com", "www.example.com") -> true
+//   globMatch("https://*.wikipedia.org/*", "https://en.wikipedia.org/wiki/Test") -> true
+//   globMatch("exact.match.com", "exact.match.com") -> true
+//   globMatch("*.google.com", "www.bing.com") -> false
+//
+inline bool globMatch(const std::string& pattern, const std::string& text) {
+    size_t p = 0, t = 0;
+    size_t starP = std::string::npos, starT = 0;
+
+    while (t < text.size()) {
+        if (p < pattern.size() && (std::tolower(static_cast<unsigned char>(pattern[p])) ==
+                                    std::tolower(static_cast<unsigned char>(text[t])))) {
+            // Characters match (case-insensitive)
+            p++;
+            t++;
+        } else if (p < pattern.size() && pattern[p] == '*') {
+            // Wildcard: remember position and try matching zero characters
+            starP = p++;
+            starT = t;
+        } else if (starP != std::string::npos) {
+            // Mismatch but we have a previous wildcard: backtrack
+            p = starP + 1;
+            t = ++starT;
+        } else {
+            // Mismatch and no wildcard to backtrack to
+            return false;
+        }
+    }
+
+    // Skip any trailing wildcards in pattern
+    while (p < pattern.size() && pattern[p] == '*') {
+        p++;
+    }
+
+    // Match if we consumed the entire pattern
+    return p == pattern.size();
+}
+
+} // namespace electrobun
+
+#endif // ELECTROBUN_GLOB_MATCH_H

package/src/native/shared/json_menu_parser.h

@@ -0,0 +1,223 @@
+// json_menu_parser.h - Cross-platform simple JSON menu parser
+// Lightweight JSON parsing for menu configurations
+// Used across Windows, macOS, and Linux
+//
+// This is a header-only implementation to avoid build complexity.
+// For complex JSON needs, use a proper JSON library instead.
+
+#ifndef ELECTROBUN_JSON_MENU_PARSER_H
+#define ELECTROBUN_JSON_MENU_PARSER_H
+
+#include <string>
+#include <vector>
+
+namespace electrobun {
+
+// Represents a parsed menu item from JSON
+struct MenuItemJson {
+    std::string type;       // "normal", "separator", "checkbox", "submenu"
+    std::string label;
+    std::string action;     // Action identifier for callbacks
+    std::string role;       // System role (e.g., "quit", "copy", "paste")
+    std::string tooltip;
+    std::string accelerator; // Keyboard shortcut
+    bool enabled = true;
+    bool checked = false;
+    bool hidden = false;
+    std::vector<MenuItemJson> submenu;
+};
+
+// Simple JSON string value extractor
+// Finds "key": "value" patterns and extracts the value
+inline std::string extractJsonStringValue(const std::string& json,
+                                          const std::string& key,
+                                          size_t startPos,
+                                          size_t endPos) {
+    std::string searchKey = "\"" + key + "\":";
+    size_t keyPos = json.find(searchKey, startPos);
+
+    if (keyPos == std::string::npos || keyPos >= endPos) {
+        return "";
+    }
+
+    // Skip whitespace after colon
+    size_t valueStart = keyPos + searchKey.length();
+    while (valueStart < endPos && (json[valueStart] == ' ' || json[valueStart] == '\t')) {
+        valueStart++;
+    }
+
+    if (valueStart >= endPos) return "";
+
+    // Check if it's a string value (starts with quote)
+    if (json[valueStart] == '"') {
+        valueStart++;
+        size_t valueEnd = json.find('"', valueStart);
+        if (valueEnd != std::string::npos && valueEnd < endPos) {
+            return json.substr(valueStart, valueEnd - valueStart);
+        }
+    }
+
+    return "";
+}
+
+// Simple JSON boolean value extractor
+inline bool extractJsonBoolValue(const std::string& json,
+                                 const std::string& key,
+                                 size_t startPos,
+                                 size_t endPos,
+                                 bool defaultValue = false) {
+    std::string searchKey = "\"" + key + "\":";
+    size_t keyPos = json.find(searchKey, startPos);
+
+    if (keyPos == std::string::npos || keyPos >= endPos) {
+        return defaultValue;
+    }
+
+    size_t valueStart = keyPos + searchKey.length();
+    while (valueStart < endPos && (json[valueStart] == ' ' || json[valueStart] == '\t')) {
+        valueStart++;
+    }
+
+    if (valueStart >= endPos) return defaultValue;
+
+    if (json.substr(valueStart, 4) == "true") {
+        return true;
+    } else if (json.substr(valueStart, 5) == "false") {
+        return false;
+    }
+
+    return defaultValue;
+}
+
+// Find the end of a JSON object starting at the given position
+// Returns the position of the closing brace
+inline size_t findObjectEnd(const std::string& json, size_t startPos) {
+    if (startPos >= json.length() || json[startPos] != '{') {
+        return std::string::npos;
+    }
+
+    int braceCount = 1;
+    size_t pos = startPos + 1;
+
+    while (pos < json.length() && braceCount > 0) {
+        if (json[pos] == '{') braceCount++;
+        else if (json[pos] == '}') braceCount--;
+        pos++;
+    }
+
+    return braceCount == 0 ? pos - 1 : std::string::npos;
+}
+
+// Find the end of a JSON array starting at the given position
+inline size_t findArrayEnd(const std::string& json, size_t startPos) {
+    if (startPos >= json.length() || json[startPos] != '[') {
+        return std::string::npos;
+    }
+
+    int bracketCount = 1;
+    size_t pos = startPos + 1;
+
+    while (pos < json.length() && bracketCount > 0) {
+        if (json[pos] == '[') bracketCount++;
+        else if (json[pos] == ']') bracketCount--;
+        pos++;
+    }
+
+    return bracketCount == 0 ? pos - 1 : std::string::npos;
+}
+
+// Parse a single menu item from JSON object boundaries
+inline MenuItemJson parseMenuItem(const std::string& json, size_t startPos, size_t endPos) {
+    MenuItemJson item;
+
+    item.label = extractJsonStringValue(json, "label", startPos, endPos);
+    item.type = extractJsonStringValue(json, "type", startPos, endPos);
+    item.action = extractJsonStringValue(json, "action", startPos, endPos);
+    item.role = extractJsonStringValue(json, "role", startPos, endPos);
+    item.tooltip = extractJsonStringValue(json, "tooltip", startPos, endPos);
+    item.accelerator = extractJsonStringValue(json, "accelerator", startPos, endPos);
+    item.enabled = extractJsonBoolValue(json, "enabled", startPos, endPos, true);
+    item.checked = extractJsonBoolValue(json, "checked", startPos, endPos, false);
+    item.hidden = extractJsonBoolValue(json, "hidden", startPos, endPos, false);
+
+    // Look for submenu array
+    std::string submenuKey = "\"submenu\":";
+    size_t submenuPos = json.find(submenuKey, startPos);
+    if (submenuPos != std::string::npos && submenuPos < endPos) {
+        size_t arrayStart = json.find('[', submenuPos);
+        if (arrayStart != std::string::npos && arrayStart < endPos) {
+            size_t arrayEnd = findArrayEnd(json, arrayStart);
+            if (arrayEnd != std::string::npos) {
+                // Recursively parse submenu items
+                size_t itemStart = json.find('{', arrayStart);
+                while (itemStart != std::string::npos && itemStart < arrayEnd) {
+                    size_t itemEnd = findObjectEnd(json, itemStart);
+                    if (itemEnd != std::string::npos && itemEnd <= arrayEnd) {
+                        item.submenu.push_back(parseMenuItem(json, itemStart, itemEnd));
+                        itemStart = json.find('{', itemEnd + 1);
+                    } else {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    // Set default type based on content
+    if (item.type.empty()) {
+        if (item.label == "-" || item.label.empty()) {
+            item.type = "separator";
+        } else if (!item.submenu.empty()) {
+            item.type = "submenu";
+        } else {
+            item.type = "normal";
+        }
+    }
+
+    return item;
+}
+
+// Parse a JSON array of menu items
+inline std::vector<MenuItemJson> parseMenuJson(const std::string& jsonStr) {
+    std::vector<MenuItemJson> items;
+
+    if (jsonStr.empty()) return items;
+
+    // Find the start of the array
+    size_t arrayStart = jsonStr.find('[');
+    if (arrayStart == std::string::npos) {
+        // Try parsing as a single object
+        size_t objStart = jsonStr.find('{');
+        if (objStart != std::string::npos) {
+            size_t objEnd = findObjectEnd(jsonStr, objStart);
+            if (objEnd != std::string::npos) {
+                items.push_back(parseMenuItem(jsonStr, objStart, objEnd));
+            }
+        }
+        return items;
+    }
+
+    size_t arrayEnd = findArrayEnd(jsonStr, arrayStart);
+    if (arrayEnd == std::string::npos) {
+        arrayEnd = jsonStr.length();
+    }
+
+    // Find and parse each menu item object
+    size_t pos = arrayStart + 1;
+    while (pos < arrayEnd) {
+        size_t objStart = jsonStr.find('{', pos);
+        if (objStart == std::string::npos || objStart >= arrayEnd) break;
+
+        size_t objEnd = findObjectEnd(jsonStr, objStart);
+        if (objEnd == std::string::npos || objEnd > arrayEnd) break;
+
+        items.push_back(parseMenuItem(jsonStr, objStart, objEnd));
+        pos = objEnd + 1;
+    }
+
+    return items;
+}
+
+} // namespace electrobun
+
+#endif // ELECTROBUN_JSON_MENU_PARSER_H

package/src/native/shared/mime_types.h

@@ -0,0 +1,101 @@
+// mime_types.h - Cross-platform MIME type detection
+// Based on Bun runtime supported file types and web development standards
+// Used across Windows, macOS, and Linux
+//
+// This is a header-only implementation to avoid build complexity.
+
+#ifndef ELECTROBUN_MIME_TYPES_H
+#define ELECTROBUN_MIME_TYPES_H
+
+#include <string>
+
+namespace electrobun {
+
+// Get MIME type from a URL or file path based on extension
+// Returns "application/octet-stream" as default for unknown types
+inline std::string getMimeTypeFromUrl(const std::string& url) {
+    // Web/Code Files (Bun native support)
+    if (url.find(".html") != std::string::npos || url.find(".htm") != std::string::npos) {
+        return "text/html";
+    } else if (url.find(".js") != std::string::npos || url.find(".mjs") != std::string::npos || url.find(".cjs") != std::string::npos) {
+        return "text/javascript";
+    } else if (url.find(".ts") != std::string::npos || url.find(".mts") != std::string::npos || url.find(".cts") != std::string::npos) {
+        return "text/typescript";
+    } else if (url.find(".jsx") != std::string::npos) {
+        return "text/jsx";
+    } else if (url.find(".tsx") != std::string::npos) {
+        return "text/tsx";
+    } else if (url.find(".css") != std::string::npos) {
+        return "text/css";
+    } else if (url.find(".json") != std::string::npos) {
+        return "application/json";
+    } else if (url.find(".xml") != std::string::npos) {
+        return "application/xml";
+    } else if (url.find(".md") != std::string::npos) {
+        return "text/markdown";
+    } else if (url.find(".txt") != std::string::npos) {
+        return "text/plain";
+    } else if (url.find(".toml") != std::string::npos) {
+        return "application/toml";
+    } else if (url.find(".yaml") != std::string::npos || url.find(".yml") != std::string::npos) {
+        return "application/x-yaml";
+
+    // Image Files
+    } else if (url.find(".png") != std::string::npos) {
+        return "image/png";
+    } else if (url.find(".jpg") != std::string::npos || url.find(".jpeg") != std::string::npos) {
+        return "image/jpeg";
+    } else if (url.find(".gif") != std::string::npos) {
+        return "image/gif";
+    } else if (url.find(".webp") != std::string::npos) {
+        return "image/webp";
+    } else if (url.find(".svg") != std::string::npos) {
+        return "image/svg+xml";
+    } else if (url.find(".ico") != std::string::npos) {
+        return "image/x-icon";
+    } else if (url.find(".avif") != std::string::npos) {
+        return "image/avif";
+
+    // Font Files
+    } else if (url.find(".woff") != std::string::npos) {
+        return "font/woff";
+    } else if (url.find(".woff2") != std::string::npos) {
+        return "font/woff2";
+    } else if (url.find(".ttf") != std::string::npos) {
+        return "font/ttf";
+    } else if (url.find(".otf") != std::string::npos) {
+        return "font/otf";
+
+    // Media Files
+    } else if (url.find(".mp3") != std::string::npos) {
+        return "audio/mpeg";
+    } else if (url.find(".mp4") != std::string::npos) {
+        return "video/mp4";
+    } else if (url.find(".webm") != std::string::npos) {
+        return "video/webm";
+    } else if (url.find(".ogg") != std::string::npos) {
+        return "audio/ogg";
+    } else if (url.find(".wav") != std::string::npos) {
+        return "audio/wav";
+
+    // Document Files
+    } else if (url.find(".pdf") != std::string::npos) {
+        return "application/pdf";
+
+    // WebAssembly (Bun support)
+    } else if (url.find(".wasm") != std::string::npos) {
+        return "application/wasm";
+
+    // Compressed Files
+    } else if (url.find(".zip") != std::string::npos) {
+        return "application/zip";
+    } else if (url.find(".gz") != std::string::npos) {
+        return "application/gzip";
+    }
+
+    return "application/octet-stream"; // default
+}
+
+} // namespace electrobun
+
+#endif // ELECTROBUN_MIME_TYPES_H

package/src/native/shared/navigation_rules.h

@@ -0,0 +1,98 @@
+// navigation_rules.h - Cross-platform navigation rules checking
+// Handles URL navigation rules with glob pattern matching
+// Used across Windows, macOS, and Linux
+//
+// This is a header-only implementation to avoid build complexity.
+
+#ifndef ELECTROBUN_NAVIGATION_RULES_H
+#define ELECTROBUN_NAVIGATION_RULES_H
+
+#include <string>
+#include <vector>
+#include "glob_match.h"
+
+namespace electrobun {
+
+// Represents a single navigation rule
+// Rules starting with "^" are block rules (inverts the match)
+struct NavigationRule {
+    std::string pattern;
+    bool isBlockRule;
+
+    NavigationRule(const std::string& ruleString) {
+        if (!ruleString.empty() && ruleString[0] == '^') {
+            isBlockRule = true;
+            pattern = ruleString.substr(1);
+        } else {
+            isBlockRule = false;
+            pattern = ruleString;
+        }
+    }
+};
+
+// Check if a URL should be allowed based on navigation rules
+// Uses "last match wins" semantics
+// Returns true if navigation should be allowed, false if blocked
+//
+// Rules are processed in order:
+// - Normal rules (no ^ prefix): if URL matches, allow navigation
+// - Block rules (^ prefix): if URL matches, block navigation
+// - Last matching rule determines the outcome
+// - If no rules match, returns defaultAllow
+inline bool checkNavigationRulesForUrl(const std::vector<std::string>& rules,
+                                       const std::string& url,
+                                       bool defaultAllow = true) {
+    bool shouldAllow = defaultAllow;
+    bool anyMatch = false;
+
+    for (const auto& ruleString : rules) {
+        if (ruleString.empty()) continue;
+
+        NavigationRule rule(ruleString);
+
+        if (globMatch(rule.pattern, url)) {
+            anyMatch = true;
+            // If it's a block rule, matching means we should NOT allow
+            // If it's a normal rule, matching means we SHOULD allow
+            shouldAllow = !rule.isBlockRule;
+        }
+    }
+
+    return shouldAllow;
+}
+
+// Overload that takes a comma-separated rules string
+inline bool checkNavigationRulesForUrl(const std::string& rulesString,
+                                       const std::string& url,
+                                       bool defaultAllow = true) {
+    std::vector<std::string> rules;
+
+    size_t start = 0;
+    size_t end = rulesString.find(',');
+
+    while (end != std::string::npos) {
+        std::string rule = rulesString.substr(start, end - start);
+        // Trim whitespace
+        size_t first = rule.find_first_not_of(" \t");
+        size_t last = rule.find_last_not_of(" \t");
+        if (first != std::string::npos) {
+            rules.push_back(rule.substr(first, last - first + 1));
+        }
+        start = end + 1;
+        end = rulesString.find(',', start);
+    }
+
+    // Add the last rule
+    std::string rule = rulesString.substr(start);
+    size_t first = rule.find_first_not_of(" \t");
+    size_t last = rule.find_last_not_of(" \t");
+    if (first != std::string::npos) {
+        rules.push_back(rule.substr(first, last - first + 1));
+    }
+
+    return checkNavigationRulesForUrl(rules, url, defaultAllow);
+}
+
+} // namespace electrobun
+
+#endif // ELECTROBUN_NAVIGATION_RULES_H