electrobun 0.0.1 → 0.0.2

package/src/zig/macos/window.zig

@@ -1,189 +0,0 @@
-const std = @import("std");
-const rpc = @import("../rpc/schema/request.zig");
-const objc = @import("./objc.zig");
-const pipesin = @import("../rpc/pipesin.zig");
-const webview = @import("./webview.zig");
-const rpcSchema = @import("../rpc/schema/schema.zig");
-const utils = @import("../utils.zig");
-
-const alloc = std.heap.page_allocator;
-
-const WindowType = struct {
-    id: u32,
-    // todo: rename this to 'handle'
-    window: *anyopaque,
-    webviews: std.ArrayList(u32),
-    title: []const u8,
-    frame: struct {
-        width: f64,
-        height: f64,
-        x: f64,
-        y: f64,
-    },
-
-    pub fn deinit(self: *WindowType) void {
-        for (self.webviews.items) |webviewId| {
-            webview.remove(.{ .id = webviewId });
-        }
-
-        defer self.webviews.deinit();
-    }
-};
-
-// todo: use the types in rpc.zig (or move them to a shared location)
-const CreateWindowOpts = struct {
-    id: u32,
-    url: ?[]const u8,
-    html: ?[]const u8,
-    title: []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,
-    },
-};
-const SetTitleOpts = struct {
-    winId: u32,
-    title: []const u8,
-};
-
-const WindowMap = std.AutoHashMap(u32, WindowType);
-pub var windowMap: WindowMap = WindowMap.init(alloc);
-
-pub fn windowCloseHandler(windowId: u32) void {
-    _ = rpc.request.windowClose(.{ .id = windowId });
-    windowCleanup(windowId);
-}
-
-pub fn windowMoveHandler(windowId: u32, x: f64, y: f64) void {
-    _ = rpc.request.windowMove(.{ .id = windowId, .x = x, .y = y });
-}
-
-pub fn windowResizeHandler(windowId: u32, x: f64, y: f64, width: f64, height: f64) void {
-    _ = rpc.request.windowResize(.{ .id = windowId, .x = x, .y = y, .width = width, .height = height });
-}
-
-pub fn createWindow(opts: rpcSchema.BunSchema.requests.createWindow.params) WindowType {
-    const objcWin = objc.createNSWindowWithFrameAndStyle(opts.id, .{ //
-        .styleMask = .{
-            .Borderless = opts.styleMask.Borderless,
-            .Titled = opts.styleMask.Titled,
-            .Closable = opts.styleMask.Closable,
-            .Miniaturizable = opts.styleMask.Miniaturizable,
-            .Resizable = opts.styleMask.Resizable,
-            .UnifiedTitleAndToolbar = opts.styleMask.UnifiedTitleAndToolbar,
-            .FullScreen = opts.styleMask.FullScreen,
-            .FullSizeContentView = opts.styleMask.FullSizeContentView,
-            .UtilityWindow = opts.styleMask.UtilityWindow,
-            .DocModalWindow = opts.styleMask.DocModalWindow,
-            .NonactivatingPanel = opts.styleMask.NonactivatingPanel,
-            .HUDWindow = opts.styleMask.HUDWindow,
-        },
-        .frame = .{ //
-            .origin = .{ .x = opts.frame.x, .y = opts.frame.y },
-            .size = .{ .width = opts.frame.width, .height = opts.frame.height },
-        },
-        .titleBarStyle = utils.toCString(opts.titleBarStyle),
-    }, windowCloseHandler, windowMoveHandler, windowResizeHandler);
-
-    objc.setNSWindowTitle(objcWin, utils.toCString(opts.title));
-
-    const _window = WindowType{ //
-        .id = opts.id,
-        .title = opts.title,
-        .frame = .{
-            .width = opts.frame.width,
-            .height = opts.frame.height,
-            .x = opts.frame.x,
-            .y = opts.frame.y,
-        },
-        .window = objcWin,
-        .webviews = std.ArrayList(u32).init(alloc),
-    };
-
-    windowMap.put(opts.id, _window) catch {
-        std.log.info("Error putting window into hashmap: ", .{});
-        return _window;
-    };
-
-    objc.makeNSWindowKeyAndOrderFront(objcWin);
-
-    // todo: no need to return anything here
-    return _window;
-}
-
-pub fn setTitle(opts: SetTitleOpts) void {
-    const win = windowMap.get(opts.winId) orelse {
-        std.debug.print("Failed to get window from hashmap for id {}\n", .{opts.winId});
-        return;
-    };
-
-    objc.setNSWindowTitle(win.window, utils.toCString(opts.title));
-}
-
-pub fn windowCleanup(winId: u32) void {
-    var win = windowMap.get(winId) orelse {
-        std.debug.print("Failed to get window from hashmap for id {}\n", .{winId});
-        return;
-    };
-
-    defer win.deinit();
-    _ = windowMap.remove(winId);
-}
-
-pub fn closeWindow(opts: rpcSchema.BunSchema.requests.closeWindow.params) void {
-    var win = windowMap.get(opts.winId) orelse {
-        std.debug.print("Failed to get window from hashmap for id {}\n", .{opts.winId});
-        return;
-    };
-
-    objc.closeNSWindow(
-        win.window,
-    );
-}
-
-pub fn addWebviewToWindow(opts: struct { webviewId: u32, windowId: u32 }) void {
-    var win = windowMap.get(opts.windowId) orelse {
-        std.debug.print("Failed to get window from hashmap for id {}\n", .{opts.windowId});
-        return;
-    };
-
-    var view = webview.webviewMap.get(opts.webviewId) orelse {
-        std.debug.print("Failed to get webview from hashmap for id {}\n", .{opts.webviewId});
-        return;
-    };
-
-    // Note: Keep this in sync with browser api
-    var jsScript = std.fmt.allocPrint(alloc, "window.__electrobunWindowId = {}\n", .{opts.windowId}) catch {
-        return;
-    };
-    defer alloc.free(jsScript);
-
-    // we want to make this a preload script so that it gets re-applied after navigations before any
-    // other code runs.
-    webview.addPreloadScriptToWebview(view.handle, jsScript, true);
-
-    win.webviews.append(opts.webviewId) catch {
-        std.debug.print("Failed to append webview id to window\n", .{});
-        return;
-    };
-
-    // at least in 0.11.0 get() returns a copy so you have to put it back to persist
-    // any changes
-    windowMap.put(opts.windowId, win) catch {
-        std.debug.print("Failed to put window back into hashmap {}\n", .{opts.windowId});
-        return;
-    };
-
-    objc.addWebviewToWindow(win.window, view.handle);
-}

package/src/zig/main.zig

@@ -1,16 +0,0 @@
-const std = @import("std");
-const rpc = @import("rpc/rpc.zig");
-const application = @import("macos/application.zig");
-
-// timer reference
-// var startTime = std.time.nanoTimestamp();
-// std.debug.print("Time taken: {} ns\n", .{std.time.nanoTimestamp() - startTime});
-// startTime = std.time.nanoTimestamp();
-
-const alloc = std.heap.page_allocator;
-
-pub fn main() !void {
-    try rpc.init();
-
-    application.startAppkitGuiEventLoop();
-}

package/src/zig/rpc/pipesin.zig

@@ -1,202 +0,0 @@
-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 webview = @import("../macos/webview.zig");
-
-const alloc = std.heap.page_allocator;
-
-var messageQueue = std.ArrayList([]const u8).init(alloc);
-var kqueue: std.os.fd_t = 0;
-
-pub fn pipesInEventListener() !void {
-    kqueue = std.os.kqueue() catch {
-        std.log.err("Failed to create kqueue", .{});
-        return;
-    };
-    defer std.os.close(kqueue);
-
-    const mainPipeIn = blk: {
-        // This is passed as an environment variable from bun
-        const MAIN_PIPE_IN = std.os.getenv("MAIN_PIPE_IN") orelse {
-            // todo: return an error here
-            return error.ELECTROBUN_MAIN_PIPE_IN_NOT_SET;
-        };
-        const bunPipeInPath = MAIN_PIPE_IN;
-        const bunPipeInFileResult = std.fs.cwd().openFile(bunPipeInPath, .{ .mode = .read_only });
-
-        if (bunPipeInFileResult) |file| {
-            break :blk file;
-        } else |err| {
-            std.debug.print("Failed to main pipe file: {}\n", .{err});
-            break :blk null;
-        }
-    };
-
-    if (mainPipeIn) |pipeInFile| {
-        addPipe(pipeInFile.handle, 0);
-    }
-
-    var events: [10]std.os.Kevent = undefined; // todo: Adjust based on expected concurrency
-    var changelist: []std.os.Kevent = &[_]std.os.Kevent{};
-
-    // Event loop
-    while (true) {
-        const n = std.os.kevent(kqueue, changelist, &events, null) catch |err| {
-            std.log.err("Error in kevent: {}", .{err});
-            continue;
-        };
-
-        for (0..n) |i| {
-            const ev = events[i];
-            // Check ev.ident to see which fd has an event
-            if (ev.filter == std.os.darwin.EVFILT_READ) {
-                // Note: readLineFromPipe reads until the end of the buffer or the delimeter.
-                // so the buffer is the max size of a line.
-                // setting it to 10MB
-                var buffer: [1024 * 1024 * 10]u8 = undefined;
-                const bytesRead = readLineFromPipe(&buffer, ev.ident);
-
-                if (bytesRead) |line| {
-                    if (mainPipeIn != null and mainPipeIn.?.handle == ev.ident) {
-                        // todo: do we need both this and stdin.zig
-                        handleLineFromMainPipe(line);
-                    } else {
-                        webview.sendLineToWebview(@intCast(ev.udata), line);
-                    }
-                }
-
-                // The fd is ready to be read
-                // Proceed to read from the fd
-                // .ident is the file descriptor
-                // .data is the number of bytes available to read
-                // .udata is the window/webview id
-
-            }
-        }
-    }
-}
-
-pub fn addPipe(fd: std.os.fd_t, webviewId: u32) void {
-    var events: [10]std.os.Kevent = undefined;
-    var event = std.os.Kevent{
-        .ident = @as(usize, @intCast(fd)),
-        .filter = std.os.darwin.EVFILT_READ,
-        .flags = std.os.darwin.EV_ADD | std.os.darwin.EV_ENABLE,
-        .fflags = 0,
-        .data = 0,
-        // The .udata field is typically used to store user-defined data or a pointer to user-defined data that can be retrieved when an event occurs.
-        // this could be the id of the window/webview
-        .udata = @as(usize, @intCast(webviewId)),
-    };
-
-    var changes: [1]std.os.Kevent = undefined;
-    changes[0] = event;
-
-    // Register the event
-    const nev = std.os.kevent(kqueue, &changes, &events, null) catch |err| {
-        std.log.err("Failed to register kqueue event: {}\n", .{err});
-        return;
-    };
-
-    if (nev == -1) {
-        std.log.err("Failed to register kqueue event", .{});
-        return;
-    }
-}
-
-pub fn readLineFromPipe(buffer: []u8, fd: usize) ?[]const u8 {
-
-    // Wrap the file descriptor in a std.os.File
-    const file = std.fs.File{ .handle = @as(c_int, @intCast(fd)) };
-
-    // Create a buffered reader for more efficient reading
-    var pipeReader = file.reader();
-    // var buffer: [1024]u8 = undefined;
-
-    const bytesRead = pipeReader.readUntilDelimiterOrEof(buffer, '\n') catch return null;
-
-    if (bytesRead) |line| {
-        return line;
-    } else {
-        return null;
-    }
-}
-
-pub fn handleLineFromMainPipe(line: []const u8) void {
-    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 });
-        return;
-    };
-
-    if (std.mem.eql(u8, messageWithType.value.type, "response")) {
-        // todo: handle _RPCResponsePacketError
-        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});
-            return;
-        };
-        rpcStdout.setResponse(messageWithType.value.id, lineCopy);
-    } 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});
-            return;
-        };
-
-        messageQueue.append(lineCopy) catch {
-            std.log.info("Error appending to messageQueue: \nreceived: {s}", .{line});
-            return;
-        };
-
-        dispatch.dispatch_async_f(dispatch.dispatch_get_main_queue(), null, processMessageQueue);
-    }
-}
-
-fn processMessageQueue(context: ?*anyopaque) callconv(.C) void {
-    _ = context;
-
-    const line = messageQueue.orderedRemove(0);
-    defer alloc.free(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;
-    };
-
-    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 {
-            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/rpc.zig

@@ -1,19 +0,0 @@
-// NOTE: This rpc mechanism is loosely based on rpcAnywhere. It's implemented in sort of an inverted way
-// to the ts version since that's the most straightforward way to do it in zig and we only need
-// the zig version to be compatible with ts version and somewhat organized. Right now this is more
-// rpcAnywhere-only-over-stdio in zig, and not a zig rewrite of rpcAnywhere
-
-// NOTE: there is a way to pass in just ClientSchema, ServerSchema, and handlers and generically
-// derive things in zig using compile time types and reflection,
-// but it's a big lift and outside the current scope of this project.
-
-// needed to access grand central dispatch to dispatch things from
-// other threads to the main thread
-const std = @import("std");
-const pipesin = @import("pipesin.zig");
-
-pub fn init() !void {
-    _ = try std.Thread.spawn(.{}, pipesin.pipesInEventListener, .{});
-    // Note: don't defer ipcThread.join() here, doing so will cause init() to wait for the thread to complete
-    // which never happens, which will in turn block the calling functino (probably main()) blocking that execution path
-}