electrobun 0.0.1 → 0.0.2

package/src/zig/rpc/schema/schema.zig

@@ -1,412 +0,0 @@
-// Zig sends to Bun
-pub const ZigSchema = struct { //
-    pub const requests = struct { //
-        pub const decideNavigation = struct { //
-            pub const params = struct {
-                webviewId: u32,
-                url: []const u8,
-            };
-            pub const response = struct {
-                allow: bool,
-            };
-        };
-
-        pub const sendSyncRequest = struct { //
-            pub const params = struct {
-                webviewId: u32,
-                request: []const u8,
-            };
-            pub const response = struct {
-                payload: ?[]const u8,
-            };
-        };
-        // Note: this should be a message not a request
-        // because we don't need a response
-        pub const log = struct {
-            pub const params = struct {
-                msg: []const u8,
-            };
-            pub const response = struct {
-                success: bool,
-            };
-        };
-        // Note: this should be a message not a request
-        // no need to block the thread we don't need a response.
-        pub const trayEvent = struct {
-            pub const params = struct {
-                id: u32,
-                action: []const u8,
-            };
-            pub const response = struct {
-                success: bool,
-            };
-        };
-        // Note: this should be a message not a request
-        // no need to block the thread we don't need a response.
-        pub const applicationMenuEvent = struct {
-            pub const params = struct {
-                action: []const u8,
-            };
-            pub const response = struct {
-                success: bool,
-            };
-        };
-        // Note: this should be a message not a request
-        // no need to block the thread we don't need a response.
-        pub const contextMenuEvent = struct {
-            pub const params = struct {
-                action: []const u8,
-            };
-            pub const response = struct {
-                success: bool,
-            };
-        };
-        // Note: this should be a message not a request
-        // no need to block the thread we don't need a response.
-        pub const webviewEvent = struct {
-            pub const params = struct {
-                id: u32,
-                eventName: []const u8,
-                detail: []const u8,
-            };
-            pub const response = struct {
-                success: bool,
-            };
-        };
-        pub const windowClose = struct {
-            pub const params = struct {
-                id: u32,
-            };
-            pub const response = struct {
-                success: bool,
-            };
-        };
-        pub const windowMove = struct {
-            pub const params = struct {
-                id: u32,
-                x: f64,
-                y: f64,
-            };
-            pub const response = struct {
-                success: bool,
-            };
-        };
-        pub const windowResize = struct {
-            pub const params = struct {
-                id: u32,
-                x: f64,
-                y: f64,
-                width: f64,
-                height: f64,
-            };
-            pub const response = struct {
-                success: bool,
-            };
-        };
-    };
-};
-
-// Bun sends to Zig
-pub const BunSchema = struct {
-    pub const requests = struct {
-        pub const createWindow = struct {
-            pub const params = struct {
-                id: u32,
-                title: []const u8,
-                url: ?[]const u8,
-                html: ?[]const u8, //
-                frame: struct {
-                    width: f64,
-                    height: f64,
-                    x: f64,
-                    y: f64,
-                },
-                styleMask: struct {
-                    Borderless: bool,
-                    Titled: bool,
-                    Closable: bool,
-                    Miniaturizable: bool,
-                    Resizable: bool,
-                    UnifiedTitleAndToolbar: bool,
-                    FullScreen: bool,
-                    FullSizeContentView: bool,
-                    UtilityWindow: bool,
-                    DocModalWindow: bool,
-                    NonactivatingPanel: bool,
-                    HUDWindow: bool,
-                },
-                titleBarStyle: []const u8,
-            };
-            pub const response = void;
-        };
-
-        pub const addWebviewToWindow = struct {
-            pub const params = struct {
-                windowId: u32,
-                webviewId: u32,
-            };
-            pub const response = void;
-        };
-        pub const setTitle = struct { //
-            pub const params = struct {
-                // todo: be consistent about winId vs windowId
-                winId: u32,
-                title: []const u8,
-            };
-            pub const response = void;
-        };
-        pub const closeWindow = struct { //
-            pub const params = struct {
-                // todo: be consistent about winId vs windowId
-                winId: u32,
-            };
-            pub const response = void;
-        };
-
-        pub const createWebview = struct {
-            pub const params = struct {
-                id: u32,
-                hostWebviewId: ?u32,
-                pipePrefix: []const u8,
-                url: ?[]const u8,
-                html: ?[]const u8,
-                preload: ?[]const u8,
-                partition: ?[]const u8,
-                frame: struct { //
-                    width: f64,
-                    height: f64,
-                    x: f64,
-                    y: f64,
-                },
-            };
-            pub const response = void;
-        };
-
-        pub const loadURL = struct {
-            pub const params = struct {
-                webviewId: u32,
-                url: []const u8,
-            };
-            pub const response = void;
-        };
-
-        pub const loadHTML = struct {
-            pub const params = struct {
-                webviewId: u32,
-                html: []const u8,
-            };
-            pub const response = void;
-        };
-
-        // fs
-        pub const moveToTrash = struct {
-            pub const params = struct {
-                path: []const u8,
-            };
-            pub const response = bool;
-        };
-        pub const showItemInFolder = struct {
-            pub const params = struct {
-                path: []const u8,
-            };
-            pub const response = bool;
-        };
-        pub const openFileDialog = struct {
-            pub const params = struct {
-                startingFolder: []const u8,
-                allowedFileTypes: []const u8,
-                canChooseFiles: bool,
-                canChooseDirectory: bool,
-                allowsMultipleSelection: bool,
-            };
-            pub const response = []const u8;
-        };
-
-        // system tray and menu
-        pub const createTray = struct {
-            pub const params = struct { id: u32, title: []const u8, image: []const u8, template: bool, width: u32, height: u32 };
-            pub const response = void;
-        };
-        pub const setTrayTitle = struct {
-            pub const params = struct {
-                id: u32,
-                title: []const u8,
-            };
-            pub const response = void;
-        };
-        pub const setTrayImage = struct {
-            pub const params = struct {
-                id: u32,
-                image: []const u8,
-            };
-            pub const response = void;
-        };
-        pub const setTrayMenu = struct {
-            pub const params = struct {
-                id: u32,
-                menuConfig: []const u8,
-            };
-            pub const response = void;
-        };
-        pub const setApplicationMenu = struct {
-            pub const params = struct {
-                menuConfig: []const u8,
-            };
-            pub const response = void;
-        };
-        pub const showContextMenu = struct {
-            pub const params = struct {
-                menuConfig: []const u8,
-            };
-            pub const response = void;
-        };
-    };
-};
-
-pub const RequestResult = struct { errorMsg: ?[]const u8, payload: ?RequestResponseType };
-// todo: can we replace this with a compile-time function
-pub const Handlers = struct {
-    createWindow: fn (params: BunSchema.requests.createWindow.params) RequestResult,
-    createWebview: fn (params: BunSchema.requests.createWebview.params) RequestResult,
-    setTitle: fn (params: BunSchema.requests.setTitle.params) RequestResult,
-    closeWindow: fn (params: BunSchema.requests.closeWindow.params) RequestResult,
-    addWebviewToWindow: fn (params: BunSchema.requests.addWebviewToWindow.params) RequestResult,
-    loadURL: fn (params: BunSchema.requests.loadURL.params) RequestResult,
-    loadHTML: fn (params: BunSchema.requests.loadHTML.params) RequestResult,
-    moveToTrash: fn (params: BunSchema.requests.moveToTrash.params) RequestResult,
-    showItemInFolder: fn (params: BunSchema.requests.showItemInFolder.params) RequestResult,
-    openFileDialog: fn (params: BunSchema.requests.openFileDialog.params) RequestResult,
-    createTray: fn (params: BunSchema.requests.createTray.params) RequestResult,
-    setTrayTitle: fn (params: BunSchema.requests.setTrayTitle.params) RequestResult,
-    setTrayImage: fn (params: BunSchema.requests.setTrayImage.params) RequestResult,
-    setTrayMenu: fn (params: BunSchema.requests.setTrayMenu.params) RequestResult,
-    setApplicationMenu: fn (params: BunSchema.requests.setApplicationMenu.params) RequestResult,
-    showContextMenu: fn (params: BunSchema.requests.showContextMenu.params) RequestResult,
-};
-
-pub const Requests = struct {
-    decideNavigation: fn (params: ZigSchema.requests.decideNavigation.params) ZigSchema.requests.decideNavigation.response,
-    sendSyncRequest: fn (params: ZigSchema.requests.sendSyncRequest.params) ZigSchema.requests.sendSyncRequest.response,
-    log: fn (params: ZigSchema.requests.log.params) ZigSchema.requests.log.response,
-    trayEvent: fn (params: ZigSchema.requests.trayEvent.params) ZigSchema.requests.trayEvent.response,
-    applicationMenuEvent: fn (params: ZigSchema.requests.applicationMenuEvent.params) ZigSchema.requests.applicationMenuEvent.response,
-    contextMenuEvent: fn (params: ZigSchema.requests.contextMenuEvent.params) ZigSchema.requests.contextMenuEvent.response,
-    webviewEvent: fn (params: ZigSchema.requests.webviewEvent.params) ZigSchema.requests.webviewEvent.response,
-    windowClose: fn (params: ZigSchema.requests.windowClose.params) ZigSchema.requests.windowClose.response,
-    windowMove: fn (params: ZigSchema.requests.windowMove.params) ZigSchema.requests.windowMove.response,
-    windowResize: fn (params: ZigSchema.requests.windowResize.params) ZigSchema.requests.windowResize.response,
-};
-
-// todo: currently the the keys will be a key of the payload struct because of how unions work in zig.
-// so it'll be payload = .{ webviewTagCanGoBackResponse: true} since the payload in schema is defined as bool.
-// rather than payload = true;
-pub const RequestResponseType = union(enum) {
-    CreateWindowResponse: BunSchema.requests.createWindow.response,
-    CreateWebviewResponse: BunSchema.requests.createWebview.response,
-    SetTitleResponse: BunSchema.requests.setTitle.response,
-    closeWindowResponse: BunSchema.requests.closeWindow.response,
-    addWebviewToWindowResponse: BunSchema.requests.addWebviewToWindow.response,
-    LoadURLResponse: BunSchema.requests.loadURL.response,
-    LoadHTMLResponse: BunSchema.requests.loadHTML.response,
-    moveToTrashResponse: BunSchema.requests.moveToTrash.response,
-    showItemInFolderResponse: BunSchema.requests.showItemInFolder.response,
-    openFileDialogResponse: BunSchema.requests.openFileDialog.response,
-
-    createTray: BunSchema.requests.createTray.response,
-    setTrayTitle: BunSchema.requests.setTrayTitle.response,
-    setTrayImage: BunSchema.requests.setTrayImage.response,
-    setTrayMenu: BunSchema.requests.setTrayMenu.response,
-
-    setApplicationMenu: BunSchema.requests.setApplicationMenu.response,
-    showContextMenu: BunSchema.requests.showContextMenu.response,
-
-    DecideNavigationResponse: ZigSchema.requests.decideNavigation.response,
-    SendSyncRequestResponse: ZigSchema.requests.sendSyncRequest.response,
-
-    webviewTagCanGoBackResponse: BrowserSchema.requests.webviewTagCanGoBack.response,
-    webviewTagCanGoForwardResponse: BrowserSchema.requests.webviewTagCanGoForward.response,
-};
-
-// todo: is this still used anywhere
-pub const ResponsePayloadType = union(enum) {
-    DecideNavigationResponse: ZigSchema.requests.decideNavigation.response,
-    // SomeOtherMethodResponse: ZigSchema.requests.someOtherMethod.response,
-};
-
-// browser -> zig schema
-pub const FromBrowserHandlers = struct {
-    // requests
-    webviewTagCanGoBack: fn (params: BrowserSchema.requests.webviewTagCanGoBack.params) RequestResult,
-    webviewTagCanGoForward: fn (params: BrowserSchema.requests.webviewTagCanGoForward.params) RequestResult,
-    webviewTagCallAsyncJavaScript: fn (params: BrowserSchema.requests.webviewTagCallAsyncJavaScript.params) RequestResult,
-    // messages
-    webviewTagResize: fn (params: BrowserSchema.messages.webviewTagResize) RequestResult,
-    webviewTagUpdateSrc: fn (params: BrowserSchema.messages.webviewTagUpdateSrc) RequestResult,
-    webviewTagUpdateHtml: fn (params: BrowserSchema.messages.webviewTagUpdateHtml) RequestResult,
-    webviewTagUpdatePreload: fn (params: BrowserSchema.messages.webviewTagUpdatePreload) RequestResult,
-    webviewTagGoBack: fn (params: BrowserSchema.messages.webviewTagGoBack) RequestResult,
-    webviewTagGoForward: fn (params: BrowserSchema.messages.webviewTagGoForward) RequestResult,
-    webviewTagReload: fn (params: BrowserSchema.messages.webviewTagReload) RequestResult,
-    webviewTagRemove: fn (params: BrowserSchema.messages.webviewTagRemove) RequestResult,
-    startWindowMove: fn (params: BrowserSchema.messages.startWindowMove) RequestResult,
-    stopWindowMove: fn (params: BrowserSchema.messages.stopWindowMove) RequestResult,
-    webviewTagSetTransparent: fn (params: BrowserSchema.messages.webviewTagSetTransparent) RequestResult,
-    webviewTagSetPassthrough: fn (params: BrowserSchema.messages.webviewTagSetPassthrough) RequestResult,
-    webviewTagSetHidden: fn (params: BrowserSchema.messages.webviewTagSetHidden) RequestResult,
-    webviewEvent: fn (params: BrowserSchema.messages.webviewEvent) RequestResult,
-};
-
-// Browser sends to Zig
-pub const BrowserSchema = struct { //
-    pub const requests = struct { //
-        pub const webviewTagCanGoBack = struct {
-            pub const params = struct { id: u32 };
-            pub const response = bool;
-        };
-        pub const webviewTagCanGoForward = struct {
-            pub const params = struct { id: u32 };
-            pub const response = bool;
-        };
-        // todo: maybe this should be a message
-        pub const webviewTagCallAsyncJavaScript = struct {
-            pub const params = struct { messageId: []const u8, webviewId: u32, hostWebviewId: u32, script: []const u8 };
-        };
-    };
-    pub const messages = struct {
-        pub const webviewTagResize = struct {
-            id: u32,
-            frame: struct {
-                width: f64,
-                height: f64,
-                x: f64,
-                y: f64,
-            },
-        };
-        pub const webviewTagUpdateSrc = struct {
-            id: u32,
-            url: []const u8,
-        };
-        pub const webviewTagUpdateHtml = struct {
-            id: u32,
-            html: []const u8,
-        };
-        pub const webviewTagUpdatePreload = struct {
-            id: u32,
-            preload: []const u8,
-        };
-        pub const webviewTagGoBack = struct { id: u32 };
-        pub const webviewTagGoForward = struct { id: u32 };
-        pub const webviewTagReload = struct { id: u32 };
-        pub const webviewTagRemove = struct { id: u32 };
-        pub const startWindowMove = struct { id: u32 };
-        pub const stopWindowMove = struct { id: u32 };
-        pub const webviewTagSetTransparent = struct { id: u32, transparent: bool };
-        pub const webviewTagSetPassthrough = struct { id: u32, enablePassthrough: bool };
-        pub const webviewTagSetHidden = struct { id: u32, hidden: bool };
-        pub const webviewEvent = struct {
-            id: u32,
-            eventName: []const u8,
-            detail: []const u8,
-        };
-    };
-};

package/src/zig/rpc/stdin.zig

@@ -1,112 +0,0 @@
-// todo: I think we can delete this file now
-
-const dispatch = @cImport({
-    @cInclude("dispatch/dispatch.h");
-});
-const std = @import("std");
-const rpcSchema = @import("schema/schema.zig");
-const rpcTypes = @import("types.zig");
-const rpcStdout = @import("stdout.zig");
-const rpcHandlers = @import("schema/handlers.zig");
-const handlers = rpcHandlers.handlers;
-
-const alloc = std.heap.page_allocator;
-
-// We listen on stdin for stuff to do from bun and then dispatch it to the main thread where the gui stuff happens
-// todo: add test for non-json input (should output an error and continue receiving inputs)
-pub fn stdInListener() void {
-    const stdin = std.io.getStdIn().reader();
-    // Note: this is a zig string.
-    var buffer: [1024]u8 = undefined;
-
-    while (true) {
-        const bytesRead = stdin.readUntilDelimiterOrEof(&buffer, '\n') catch continue;
-        if (bytesRead) |line| {
-            const messageWithType = std.json.parseFromSlice(rpcTypes._RPCMessage, alloc, line, .{ .ignore_unknown_fields = true }) catch |err| {
-                std.log.info("Error parsing line from stdin - {}: \nreceived: {s}", .{ err, line });
-                continue;
-            };
-
-            if (std.mem.eql(u8, messageWithType.value.type, "response")) {
-
-                // todo: handle _RPCResponsePacketError
-                const _response = std.json.parseFromSlice(rpcTypes._RPCResponsePacketSuccess, alloc, line, .{}) catch |err| {
-                    std.log.info("Error parsing line from stdin - {}: \nreceived: {s}", .{ err, line });
-                    continue;
-                };
-                // handle response
-                // _response = payload.allow;
-
-                std.log.info("decide Navigation - {}", .{_response.value.payload.?});
-
-                rpcStdout.setResponse(messageWithType.value.id, _response.value.payload);
-            } else {
-                // Handle UI events on main thread
-                // since line is re-used we need to copy it to the heap
-                const lineCopy = alloc.dupe(u8, line) catch {
-                    // Handle the error here, e.g., log it or set a default value
-                    std.debug.print("Error: {s}\n", .{line});
-                    continue;
-                };
-
-                messageQueue.append(lineCopy) catch {
-                    std.log.info("Error appending to messageQueue: \nreceived: {s}", .{line});
-                    continue;
-                };
-
-                dispatch.dispatch_async_f(dispatch.dispatch_get_main_queue(), null, processMessageQueue);
-
-                std.log.info("sending over to main thread", .{});
-            }
-        }
-    }
-}
-
-var messageQueue = std.ArrayList([]const u8).init(alloc);
-
-fn processMessageQueue(context: ?*anyopaque) callconv(.C) void {
-    std.log.info("processMessageQueue on main thread", .{});
-    _ = context;
-
-    const line = messageQueue.orderedRemove(0);
-    defer alloc.free(line);
-
-    std.log.info("parsed line on main thread {s}", .{line});
-
-    // Do the main json parsing work on the stdin thread, add it to a queue, and then
-    // process the generic jobs on the main thread
-    const json = std.json.parseFromSlice(std.json.Value, alloc, line, .{ .ignore_unknown_fields = true }) catch |err| {
-        std.log.info("Error parsing line from stdin - {}: \nreceived: {s}", .{ err, line });
-        return;
-    };
-
-    defer json.deinit();
-
-    const msgType = blk: {
-        const obj = json.value.object.get("type").?;
-        break :blk obj.string;
-    };
-
-    std.log.info("parsed line main thread {s}", .{msgType});
-
-    if (std.mem.eql(u8, msgType, "request")) {
-        const _request = std.json.parseFromValue(rpcTypes._RPCRequestPacket, alloc, json.value, .{}) catch |err| {
-            std.log.info("Error parsing line from stdin - {}: \nreceived: {s}", .{ err, line });
-            return;
-        };
-
-        const result = rpcHandlers.handleRequest(_request.value);
-
-        if (result.errorMsg == null) {
-            rpcStdout.sendResponseSuccess(_request.value.id, result.payload);
-        } else {
-            // todo: this doesn't work yet
-            rpcStdout.sendResponseError(_request.value.id, result.errorMsg.?);
-        }
-    } else if (std.mem.eql(u8, msgType, "message")) {
-        // todo: rpcHandlers.handleMessage(json.value);
-        std.log.info("it's a message meatball", .{});
-    } else {
-        std.log.info("it's an unhandled meatball", .{});
-    }
-}

package/src/zig/rpc/stdout.zig

@@ -1,106 +0,0 @@
-const std = @import("std");
-const rpcTypes = @import("types.zig");
-const rpcSchema = @import("schema/schema.zig");
-
-var _waitingForResponse = false;
-var _response: ?[]u8 = null;
-var m = std.Thread.Mutex{};
-var c = std.Thread.Condition{};
-
-const alloc = std.heap.page_allocator;
-
-pub fn sendRequest(method: []const u8, params: anytype, PayloadType: anytype) PayloadType {
-    const id = idGen.nextId();
-    send(.{
-        .id = id,
-        .type = "request",
-        .method = method,
-        .params = params,
-    });
-
-    m.lock();
-    defer m.unlock();
-    _waitingForResponse = true;
-    _response = null;
-
-    while (_waitingForResponse) {
-        c.wait(&m);
-    }
-
-    const responseWrapper = std.json.parseFromSlice(rpcTypes._RPCResponsePacketSuccess, alloc, _response.?, .{}) catch {
-        unreachable;
-    };
-
-    const rawPayload = responseWrapper.value.payload;
-    const parsedPayload = std.json.parseFromValue(PayloadType, alloc, rawPayload.?, .{}) catch {
-        unreachable;
-    };
-    return parsedPayload.value;
-}
-
-pub fn setResponse(id: u32, response: anytype) void {
-    // todo: consider using a hashmap instead of a single variable
-    // note: technically since main thread gets blocked and all
-    // requests currently originate from the main thread, we don't need
-    // this yet
-    _ = id;
-
-    m.lock();
-    defer m.unlock();
-    _response = response;
-    _waitingForResponse = false;
-    c.signal();
-}
-
-pub fn sendResponseSuccess(id: u32, payload: ?rpcSchema.RequestResponseType) void {
-    send(.{
-        .id = id,
-        .type = "response",
-        .success = true,
-        .payload = payload,
-    });
-}
-
-pub fn sendResponseError(id: u32, errorMsg: []const u8) void {
-    send(.{
-        .id = id,
-        .type = "response",
-        .success = false,
-        .@"error" = errorMsg,
-    });
-}
-
-pub fn sendMessage(payload: anytype) void {
-    send(.{
-        .id = idGen.nextId(),
-        .type = "message",
-        .payload = payload,
-    });
-}
-
-pub fn send(message: anytype) void {
-    // stringify message and send to stdout. note: message already has id and everything
-    // added
-    const stdoutWriter = std.io.getStdOut().writer();
-
-    std.json.stringify(message, .{}, stdoutWriter) catch |err| {
-        std.debug.print("Failed to stringify message: {}\n", .{err});
-        return;
-    };
-
-    // add a newline
-    _ = stdoutWriter.writeAll("\n") catch {
-        std.debug.print("Failed to write to stdout\n", .{});
-    };
-}
-
-var idGen = idGenerator{};
-const idGenerator = struct {
-    next_id: u32 = 0,
-    const NextIdMax: u32 = 100;
-
-    pub fn nextId(self: *idGenerator) u32 {
-        self.next_id = (self.next_id + 1) % (NextIdMax);
-        return self.next_id;
-    }
-};

package/src/zig/rpc/types.zig

@@ -1,41 +0,0 @@
-const std = @import("std");
-
-pub const MessageType = enum {
-    request,
-    response,
-    message,
-};
-
-pub const _RPCMessage = struct {
-    id: u32,
-    type: []const u8, // request, response, message
-};
-
-pub const _RPCRequestPacket = struct {
-    id: u32,
-    type: []const u8 = "request",
-    method: []const u8,
-    params: std.json.Value,
-};
-
-pub const _RPCResponsePacketSuccess = struct {
-    id: u32,
-    type: []const u8 = "response",
-    success: bool = true,
-    payload: ?std.json.Value,
-};
-
-pub const _RPCResponsePacketError = struct {
-    id: u32,
-    type: []const u8, // = "response",
-    success: bool, // = false,
-    // Note: error is a reserved key in zig so we have to cast it from error to msg
-    @"error": ?[]const u8, // error here is /Users/yoav/code/electrobun/libs/zig/webview/rpcAnywhere.zig:34:10: error: expected '.', found ':'
-};
-
-pub const _RPCMessagePacket = struct {
-    // Note: RPC Anywhere uses the id field for "method" when it's a message
-    id: []const u8,
-    type: []const u8 = "message",
-    payload: std.json.Value,
-};