@corelauncher/rod 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 CoreLauncher
+
+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/README.md

@@ -0,0 +1,2 @@
+# rod
+Custom webview implementation for bun based on tauri libraries

package/package.json

@@ -0,0 +1,43 @@
+{
+	"name": "@corelauncher/rod",
+	"version": "1.0.0",
+	"description": "Webview for bun based on tauri's tao and wry.",
+	"keywords": [
+		"corelauncher",
+		"webview",
+		"bun",
+		"tauri",
+		"tao",
+		"wry"
+	],
+	"homepage": "https://github.com/CoreLauncher/rod#readme",
+	"bugs": {
+		"url": "https://github.com/CoreLauncher/rod/issues"
+	},
+	"license": "MIT",
+	"author": "CoreByte",
+	"files": [
+		"/src-ts/*",
+		"/target/release/rod.dll"
+	],
+	"type": "module",
+	"main": "/src-ts/index.ts",
+	"module": "/src-ts/index.ts",
+	"scripts": {
+		"postinstall": "husky",
+		"prepack": "cargo build --release",
+		"dev": "bun run --watch ./src-playground/index.ts",
+		"lint": "bun run biome check --fix",
+		"knip": "bun run knip-bun"
+	},
+	"dependencies": {
+		"tiny-typed-emitter": "^2.1.0"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "2.3.10",
+		"@types/bun": "latest",
+		"husky": "^9.1.7",
+		"typescript": "^5",
+		"knip": "^5.76.3"
+	}
+}

package/src-ts/classes/eventloop.ts

@@ -0,0 +1,55 @@
+import { CString, FFIType, JSCallback, type Pointer } from "bun:ffi";
+import { TypedEmitter } from "tiny-typed-emitter";
+import {
+	rod_event_loop_create,
+	rod_event_loop_destroy,
+	rod_event_loop_poll,
+} from "../ffi";
+import type { Position, Size } from "../types";
+
+interface EventLoopEvents {
+	window_close_requested: (id: number) => void;
+	window_focused: (id: number, focused: boolean) => void;
+	window_moved: (id: number, position: Position) => void;
+	window_resized: (id: number, size: Size) => void;
+}
+
+export default class EventLoop extends TypedEmitter<EventLoopEvents> {
+	eventloopPtr: Pointer;
+
+	private callback: JSCallback;
+	private interval: NodeJS.Timeout;
+	constructor() {
+		super();
+
+		const eventloopPtr = rod_event_loop_create();
+		if (!eventloopPtr) throw new Error("Failed to create EventLoop");
+		this.eventloopPtr = eventloopPtr;
+
+		this.callback = new JSCallback(
+			(eventPtr: Pointer, rawDataPtr: Pointer) => {
+				const event = new CString(eventPtr).toString();
+				const rawData = new CString(rawDataPtr).toString();
+				console.log(event, rawData);
+				const data = JSON.parse(rawData);
+				console.log("EventLoop Event:", event, data);
+			},
+			{
+				args: [FFIType.cstring, FFIType.cstring],
+				returns: FFIType.void,
+			},
+		);
+
+		this.interval = setInterval(() => {
+			rod_event_loop_poll(this.eventloopPtr, this.callback);
+		});
+	}
+
+	destroy() {
+		clearInterval(this.interval);
+		if (this.eventloopPtr) {
+			rod_event_loop_destroy(this.eventloopPtr);
+			this.eventloopPtr = null as unknown as Pointer;
+		}
+	}
+}

package/src-ts/classes/rod.ts

@@ -0,0 +1,57 @@
+import type { WebViewOptions, WindowOptions } from "../types";
+import EventLoop from "./eventloop";
+import WebView from "./webview";
+
+let idIndex = 1;
+
+export default class Rod {
+	eventLoop: EventLoop;
+	private webviews: WebView[];
+	constructor() {
+		this.eventLoop = new EventLoop();
+		this.webviews = [];
+
+		this.eventLoop.on("window_close_requested", (id) => {
+			const webview = this.retrieveWebViewById(id);
+			if (!webview) return;
+			webview.emit("close_requested");
+		});
+
+		this.eventLoop.on("window_focused", (id, focused) => {
+			const webview = this.retrieveWebViewById(id);
+			if (!webview) return;
+			webview.emit("focused", focused);
+		});
+
+		this.eventLoop.on("window_moved", (id, position) => {
+			const webview = this.retrieveWebViewById(id);
+			if (!webview) return;
+			webview.emit("moved", position);
+		});
+
+		this.eventLoop.on("window_resized", (id, size) => {
+			const webview = this.retrieveWebViewById(id);
+			if (!webview) return;
+			webview.emit("resized", size);
+		});
+	}
+
+	private generateId() {
+		return idIndex++;
+	}
+
+	private retrieveWebViewById(id: number) {
+		return this.webviews.find((webview) => webview.id === id);
+	}
+
+	createWebView(options: WebViewOptions & WindowOptions = {}) {
+		const id = this.generateId();
+		const webview = new WebView(this.eventLoop, id, options);
+
+		webview.on("destroyed", () => {
+			this.webviews = this.webviews.filter((wv) => wv.id !== webview.id);
+		});
+
+		return webview;
+	}
+}

package/src-ts/classes/webview.ts

@@ -0,0 +1,83 @@
+import type { Pointer } from "bun:ffi";
+import {
+	rod_webview_clear_all_browsing_data,
+	rod_webview_close_devtools,
+	rod_webview_create,
+	rod_webview_destroy,
+	rod_webview_get_url,
+	rod_webview_is_devtools_open,
+	rod_webview_open_devtools,
+	rod_webview_reload,
+	rod_webview_set_html,
+	rod_webview_set_url,
+	rod_webview_zoom,
+} from "../ffi";
+import type { WebViewOptions, WindowOptions } from "../types";
+import { transformWebViewOptions } from "../utilities/options";
+import { encodeString } from "../utilities/strings";
+import type EventLoop from "./eventloop";
+import Window from "./window";
+
+export default class WebView extends Window {
+	protected webviewPtr: Pointer;
+	constructor(
+		eventLoop: EventLoop,
+		id: number,
+		options: WebViewOptions & WindowOptions,
+	) {
+		super(eventLoop.eventloopPtr, id, options);
+
+		const webviewPtr = rod_webview_create(
+			this.windowPtr,
+			encodeString(JSON.stringify(transformWebViewOptions(options))),
+		);
+		if (!webviewPtr) throw new Error("Failed to create WebView");
+		this.webviewPtr = webviewPtr;
+	}
+
+	get url() {
+		const raw = rod_webview_get_url(this.webviewPtr);
+		return raw.toString();
+	}
+
+	get isDevtoolsOpen() {
+		return rod_webview_is_devtools_open(this.webviewPtr);
+	}
+
+	setUrl(url: string) {
+		rod_webview_set_url(this.webviewPtr, encodeString(url));
+	}
+
+	setHtml(html: string) {
+		rod_webview_set_html(this.webviewPtr, encodeString(html));
+	}
+
+	reload() {
+		rod_webview_reload(this.webviewPtr);
+	}
+
+	clearAllBrowsingData() {
+		rod_webview_clear_all_browsing_data(this.webviewPtr);
+	}
+
+	openDevtools() {
+		rod_webview_open_devtools(this.webviewPtr);
+	}
+
+	closeDevtools() {
+		rod_webview_close_devtools(this.webviewPtr);
+	}
+
+	zoom(scaleFactor: number) {
+		rod_webview_zoom(this.webviewPtr, scaleFactor);
+	}
+
+	override destroy() {
+		if (!this.webviewPtr) return;
+
+		rod_webview_destroy(this.webviewPtr);
+		this.webviewPtr = null as unknown as Pointer;
+
+		super.destroy();
+	}
+}

package/src-ts/classes/window.ts

@@ -0,0 +1,239 @@
+import type { Pointer } from "bun:ffi";
+import { TypedEmitter } from "tiny-typed-emitter";
+import {
+	rod_window_create,
+	rod_window_destroy,
+	rod_window_get_always_on_top,
+	rod_window_get_closable,
+	rod_window_get_decorated,
+	rod_window_get_focused,
+	rod_window_get_maximizable,
+	rod_window_get_maximized,
+	rod_window_get_minimizable,
+	rod_window_get_minimized,
+	rod_window_get_position,
+	rod_window_get_resizable,
+	rod_window_get_size,
+	rod_window_get_title,
+	rod_window_get_visible,
+	rod_window_set_always_on_bottom,
+	rod_window_set_always_on_top,
+	rod_window_set_closable,
+	rod_window_set_content_protection,
+	rod_window_set_decorations,
+	rod_window_set_focus,
+	rod_window_set_focusable,
+	rod_window_set_fullscreen,
+	rod_window_set_ignore_cursor_events,
+	rod_window_set_maximizable,
+	rod_window_set_maximized,
+	rod_window_set_maximum_size,
+	rod_window_set_minimizable,
+	rod_window_set_minimized,
+	rod_window_set_minimum_size,
+	rod_window_set_position,
+	rod_window_set_progress_bar,
+	rod_window_set_resizable,
+	rod_window_set_size,
+	rod_window_set_title,
+	rod_window_set_visible,
+	rod_window_set_visible_on_all_workspaces,
+	rod_window_start_drag,
+} from "../ffi";
+import type { Position, ProgressState, Size, WindowOptions } from "../types";
+import { transformWindowOptions } from "../utilities/options";
+import { encodeString } from "../utilities/strings";
+
+interface WindowEvents {
+	close_requested: () => void;
+	focused: (focused: boolean) => void;
+	moved: (position: Position) => void;
+	resized: (size: Size) => void;
+	destroyed: () => void;
+}
+
+export default class Window extends TypedEmitter<WindowEvents> {
+	id: number;
+	protected windowPtr: Pointer;
+	constructor(eventLoop: Pointer, id: number, options: WindowOptions) {
+		super();
+
+		this.id = id;
+
+		const windowPtr = rod_window_create(
+			eventLoop,
+			id,
+			encodeString(JSON.stringify(transformWindowOptions(options))),
+		);
+		if (!windowPtr) throw new Error("Failed to create Window");
+		this.windowPtr = windowPtr;
+	}
+
+	get title() {
+		const title = rod_window_get_title(this.windowPtr);
+		return title.toString();
+	}
+
+	get size() {
+		const rawSize = rod_window_get_size(this.windowPtr);
+		return JSON.parse(rawSize.toString()) as Size;
+	}
+
+	get position() {
+		const rawPosition = rod_window_get_position(this.windowPtr);
+		return JSON.parse(rawPosition.toString()) as Position;
+	}
+
+	get isAlwaysOnTop() {
+		return rod_window_get_always_on_top(this.windowPtr);
+	}
+	get isClosable() {
+		return rod_window_get_closable(this.windowPtr);
+	}
+	get isDecorated() {
+		return rod_window_get_decorated(this.windowPtr);
+	}
+	get isFocused() {
+		return rod_window_get_focused(this.windowPtr);
+	}
+	get isMaximizable() {
+		return rod_window_get_maximizable(this.windowPtr);
+	}
+	get isMaximized() {
+		return rod_window_get_maximized(this.windowPtr);
+	}
+	get isMinimizable() {
+		return rod_window_get_minimizable(this.windowPtr);
+	}
+	get isMinimized() {
+		return rod_window_get_minimized(this.windowPtr);
+	}
+	get isResizable() {
+		return rod_window_get_resizable(this.windowPtr);
+	}
+	get isVisible() {
+		return rod_window_get_visible(this.windowPtr);
+	}
+
+	setAlwaysOnBottom(alwaysOnBottom: boolean) {
+		rod_window_set_always_on_bottom(this.windowPtr, alwaysOnBottom);
+	}
+
+	setAlwaysOnTop(alwaysOnTop: boolean) {
+		rod_window_set_always_on_top(this.windowPtr, alwaysOnTop);
+	}
+
+	setClosable(closable: boolean) {
+		rod_window_set_closable(this.windowPtr, closable);
+	}
+
+	setContentProtection(contentProtection: boolean) {
+		rod_window_set_content_protection(this.windowPtr, contentProtection);
+	}
+
+	setDecorations(decorations: boolean) {
+		rod_window_set_decorations(this.windowPtr, decorations);
+	}
+
+	setFocus() {
+		rod_window_set_focus(this.windowPtr);
+	}
+
+	setFocusable(focusable: boolean) {
+		rod_window_set_focusable(this.windowPtr, focusable);
+	}
+
+	setFullscreen(fullscreen: boolean) {
+		rod_window_set_fullscreen(this.windowPtr, fullscreen);
+	}
+
+	setIgnoreCursorEvents(ignore: boolean) {
+		rod_window_set_ignore_cursor_events(this.windowPtr, ignore);
+	}
+
+	setSize(size: Size) {
+		rod_window_set_size(this.windowPtr, encodeString(JSON.stringify(size)));
+	}
+
+	setMaximumSize(size: Size | null) {
+		if (size === null) {
+			rod_window_set_maximum_size(this.windowPtr, encodeString(""));
+		} else {
+			rod_window_set_maximum_size(
+				this.windowPtr,
+				encodeString(JSON.stringify(size)),
+			);
+		}
+	}
+
+	setMaximizable(maximizable: boolean) {
+		rod_window_set_maximizable(this.windowPtr, maximizable);
+	}
+
+	setMaximized(maximized: boolean) {
+		rod_window_set_maximized(this.windowPtr, maximized);
+	}
+
+	setMinimumSize(size: Size | null) {
+		if (size === null) {
+			rod_window_set_minimum_size(this.windowPtr, encodeString(""));
+		} else {
+			rod_window_set_minimum_size(
+				this.windowPtr,
+				encodeString(JSON.stringify(size)),
+			);
+		}
+	}
+
+	setMinimizable(minimizable: boolean) {
+		rod_window_set_minimizable(this.windowPtr, minimizable);
+	}
+
+	setMinimized(minimized: boolean) {
+		rod_window_set_minimized(this.windowPtr, minimized);
+	}
+
+	setPosition(position: Position) {
+		rod_window_set_position(
+			this.windowPtr,
+			encodeString(JSON.stringify(position)),
+		);
+	}
+
+	setProgressBar(state: ProgressState, progress: number) {
+		const payload = { state: state as number, progress };
+		rod_window_set_progress_bar(
+			this.windowPtr,
+			encodeString(JSON.stringify(payload)),
+		);
+	}
+
+	setResizable(resizable: boolean) {
+		rod_window_set_resizable(this.windowPtr, resizable);
+	}
+
+	setTitle(title: string) {
+		rod_window_set_title(this.windowPtr, encodeString(title));
+	}
+
+	setVisible(visible: boolean) {
+		rod_window_set_visible(this.windowPtr, visible);
+	}
+
+	setVisibleOnAllWorkspaces(visible: boolean) {
+		rod_window_set_visible_on_all_workspaces(this.windowPtr, visible);
+	}
+
+	startDrag() {
+		rod_window_start_drag(this.windowPtr);
+	}
+
+	destroy() {
+		if (!this.windowPtr) return;
+
+		this.emit("destroyed");
+
+		rod_window_destroy(this.windowPtr);
+		this.windowPtr = null as unknown as Pointer;
+	}
+}

package/src-ts/ffi.ts

@@ -0,0 +1,365 @@
+import { dlopen, FFIType, suffix } from "bun:ffi";
+import { join } from "node:path";
+
+const path = join(import.meta.dir, "..", "target", "debug", `rod.${suffix}`);
+
+const {
+	symbols: {
+		// event loop
+		rod_event_loop_create,
+		rod_event_loop_destroy,
+
+		// event loop actions
+		rod_event_loop_poll,
+
+		// window
+		rod_window_create,
+		rod_window_destroy,
+
+		// window getters
+		rod_window_get_title,
+		rod_window_get_size,
+		rod_window_get_position,
+		rod_window_get_always_on_top,
+		rod_window_get_closable,
+		rod_window_get_decorated,
+		rod_window_get_focused,
+		rod_window_get_maximizable,
+		rod_window_get_maximized,
+		rod_window_get_minimizable,
+		rod_window_get_minimized,
+		rod_window_get_resizable,
+		rod_window_get_visible,
+
+		// window setters
+		rod_window_set_always_on_bottom,
+		rod_window_set_always_on_top,
+		rod_window_set_closable,
+		rod_window_set_content_protection,
+		rod_window_set_decorations,
+		rod_window_set_focus,
+		rod_window_set_focusable,
+		rod_window_set_fullscreen,
+		rod_window_set_ignore_cursor_events,
+		rod_window_set_size,
+		rod_window_set_maximum_size,
+		rod_window_set_maximizable,
+		rod_window_set_maximized,
+		rod_window_set_minimum_size,
+		rod_window_set_minimizable,
+		rod_window_set_minimized,
+		rod_window_set_position,
+		rod_window_set_progress_bar,
+		rod_window_set_resizable,
+		rod_window_set_title,
+		rod_window_set_visible,
+		rod_window_set_visible_on_all_workspaces,
+
+		// window actions
+		rod_window_start_drag,
+
+		// webview
+		rod_webview_create,
+		rod_webview_destroy,
+
+		// webview getters
+		rod_webview_get_url,
+		rod_webview_is_devtools_open,
+
+		// webview setters
+		rod_webview_set_url,
+		rod_webview_set_html,
+		rod_webview_zoom,
+
+		// webview actions
+		rod_webview_open_devtools,
+		rod_webview_close_devtools,
+		rod_webview_reload,
+		rod_webview_clear_all_browsing_data,
+	},
+} = dlopen(path, {
+	// event loop
+	rod_event_loop_create: {
+		args: [],
+		returns: FFIType.ptr,
+	},
+	rod_event_loop_destroy: {
+		args: [FFIType.ptr],
+		returns: FFIType.void,
+	},
+	rod_event_loop_poll: {
+		args: [FFIType.ptr, FFIType.function],
+		returns: FFIType.void,
+	},
+
+	// window
+	rod_window_create: {
+		args: [FFIType.ptr, FFIType.u16, FFIType.cstring],
+		returns: FFIType.ptr,
+	},
+	rod_window_destroy: {
+		args: [FFIType.ptr],
+		returns: FFIType.void,
+	},
+
+	// window getters
+	rod_window_get_title: {
+		args: [FFIType.ptr],
+		returns: FFIType.cstring,
+	},
+	rod_window_get_size: {
+		args: [FFIType.ptr],
+		returns: FFIType.cstring,
+	},
+	rod_window_get_position: {
+		args: [FFIType.ptr],
+		returns: FFIType.cstring,
+	},
+	rod_window_get_always_on_top: {
+		args: [FFIType.ptr],
+		returns: FFIType.bool,
+	},
+	rod_window_get_closable: {
+		args: [FFIType.ptr],
+		returns: FFIType.bool,
+	},
+	rod_window_get_decorated: {
+		args: [FFIType.ptr],
+		returns: FFIType.bool,
+	},
+	rod_window_get_focused: {
+		args: [FFIType.ptr],
+		returns: FFIType.bool,
+	},
+	rod_window_get_maximizable: {
+		args: [FFIType.ptr],
+		returns: FFIType.bool,
+	},
+	rod_window_get_maximized: {
+		args: [FFIType.ptr],
+		returns: FFIType.bool,
+	},
+	rod_window_get_minimizable: {
+		args: [FFIType.ptr],
+		returns: FFIType.bool,
+	},
+	rod_window_get_minimized: {
+		args: [FFIType.ptr],
+		returns: FFIType.bool,
+	},
+	rod_window_get_resizable: {
+		args: [FFIType.ptr],
+		returns: FFIType.bool,
+	},
+	rod_window_get_visible: {
+		args: [FFIType.ptr],
+		returns: FFIType.bool,
+	},
+
+	// window setters
+	rod_window_set_always_on_bottom: {
+		args: [FFIType.ptr, FFIType.bool],
+		returns: FFIType.void,
+	},
+	rod_window_set_always_on_top: {
+		args: [FFIType.ptr, FFIType.bool],
+		returns: FFIType.void,
+	},
+	rod_window_set_closable: {
+		args: [FFIType.ptr, FFIType.bool],
+		returns: FFIType.void,
+	},
+	rod_window_set_content_protection: {
+		args: [FFIType.ptr, FFIType.bool],
+		returns: FFIType.void,
+	},
+	rod_window_set_decorations: {
+		args: [FFIType.ptr, FFIType.bool],
+		returns: FFIType.void,
+	},
+	rod_window_set_focus: {
+		args: [FFIType.ptr],
+		returns: FFIType.void,
+	},
+	rod_window_set_focusable: {
+		args: [FFIType.ptr, FFIType.bool],
+		returns: FFIType.void,
+	},
+	rod_window_set_fullscreen: {
+		args: [FFIType.ptr, FFIType.bool],
+		returns: FFIType.void,
+	},
+	rod_window_set_ignore_cursor_events: {
+		args: [FFIType.ptr, FFIType.bool],
+		returns: FFIType.void,
+	},
+	rod_window_set_size: {
+		args: [FFIType.ptr, FFIType.cstring],
+		returns: FFIType.void,
+	},
+	rod_window_set_maximum_size: {
+		args: [FFIType.ptr, FFIType.cstring],
+		returns: FFIType.void,
+	},
+	rod_window_set_maximizable: {
+		args: [FFIType.ptr, FFIType.bool],
+		returns: FFIType.void,
+	},
+	rod_window_set_maximized: {
+		args: [FFIType.ptr, FFIType.bool],
+		returns: FFIType.void,
+	},
+	rod_window_set_minimum_size: {
+		args: [FFIType.ptr, FFIType.cstring],
+		returns: FFIType.void,
+	},
+	rod_window_set_minimizable: {
+		args: [FFIType.ptr, FFIType.bool],
+		returns: FFIType.void,
+	},
+	rod_window_set_minimized: {
+		args: [FFIType.ptr, FFIType.bool],
+		returns: FFIType.void,
+	},
+	rod_window_set_position: {
+		args: [FFIType.ptr, FFIType.cstring],
+		returns: FFIType.void,
+	},
+	rod_window_set_progress_bar: {
+		args: [FFIType.ptr, FFIType.cstring],
+		returns: FFIType.void,
+	},
+	rod_window_set_resizable: {
+		args: [FFIType.ptr, FFIType.bool],
+		returns: FFIType.void,
+	},
+	rod_window_set_title: {
+		args: [FFIType.ptr, FFIType.cstring],
+		returns: FFIType.void,
+	},
+	rod_window_set_visible: {
+		args: [FFIType.ptr, FFIType.bool],
+		returns: FFIType.void,
+	},
+	rod_window_set_visible_on_all_workspaces: {
+		args: [FFIType.ptr, FFIType.bool],
+		returns: FFIType.void,
+	},
+
+	// window actions
+	rod_window_start_drag: {
+		args: [FFIType.ptr],
+		returns: FFIType.void,
+	},
+
+	// webview
+	rod_webview_create: {
+		args: [FFIType.ptr, FFIType.cstring],
+		returns: FFIType.ptr,
+	},
+	rod_webview_destroy: {
+		args: [FFIType.ptr],
+		returns: FFIType.void,
+	},
+	rod_webview_set_url: {
+		args: [FFIType.ptr, FFIType.cstring],
+		returns: FFIType.void,
+	},
+	rod_webview_get_url: {
+		args: [FFIType.ptr],
+		returns: FFIType.cstring,
+	},
+	rod_webview_open_devtools: {
+		args: [FFIType.ptr],
+		returns: FFIType.void,
+	},
+	rod_webview_close_devtools: {
+		args: [FFIType.ptr],
+		returns: FFIType.void,
+	},
+	rod_webview_is_devtools_open: {
+		args: [FFIType.ptr],
+		returns: FFIType.bool,
+	},
+	rod_webview_zoom: {
+		args: [FFIType.ptr, FFIType.f64],
+		returns: FFIType.void,
+	},
+	rod_webview_reload: {
+		args: [FFIType.ptr],
+		returns: FFIType.void,
+	},
+	rod_webview_set_html: {
+		args: [FFIType.ptr, FFIType.cstring],
+		returns: FFIType.void,
+	},
+	rod_webview_clear_all_browsing_data: {
+		args: [FFIType.ptr],
+		returns: FFIType.void,
+	},
+});
+
+export {
+	// event loop
+	rod_event_loop_create,
+	rod_event_loop_destroy,
+	// event loop actions
+	rod_event_loop_poll,
+	// window
+	rod_window_create,
+	rod_window_destroy,
+	// window getters
+	rod_window_get_title,
+	rod_window_get_size,
+	rod_window_get_position,
+	rod_window_get_always_on_top,
+	rod_window_get_closable,
+	rod_window_get_decorated,
+	rod_window_get_focused,
+	rod_window_get_maximizable,
+	rod_window_get_maximized,
+	rod_window_get_minimizable,
+	rod_window_get_minimized,
+	rod_window_get_resizable,
+	rod_window_get_visible,
+	// window setters
+	rod_window_set_always_on_bottom,
+	rod_window_set_always_on_top,
+	rod_window_set_closable,
+	rod_window_set_content_protection,
+	rod_window_set_decorations,
+	rod_window_set_focus,
+	rod_window_set_focusable,
+	rod_window_set_fullscreen,
+	rod_window_set_ignore_cursor_events,
+	rod_window_set_size,
+	rod_window_set_maximum_size,
+	rod_window_set_maximizable,
+	rod_window_set_maximized,
+	rod_window_set_minimum_size,
+	rod_window_set_minimizable,
+	rod_window_set_minimized,
+	rod_window_set_position,
+	rod_window_set_progress_bar,
+	rod_window_set_resizable,
+	rod_window_set_title,
+	rod_window_set_visible,
+	rod_window_set_visible_on_all_workspaces,
+	// window actions
+	rod_window_start_drag,
+	// webview
+	rod_webview_create,
+	rod_webview_destroy,
+	// webview getters
+	rod_webview_get_url,
+	rod_webview_is_devtools_open,
+	// webview setters
+	rod_webview_set_url,
+	rod_webview_set_html,
+	rod_webview_zoom,
+	// webview actions
+	rod_webview_open_devtools,
+	rod_webview_close_devtools,
+	rod_webview_reload,
+	rod_webview_clear_all_browsing_data,
+};

package/src-ts/index.ts

@@ -0,0 +1,2 @@
+import Rod from "./classes/rod";
+export default Rod;

package/src-ts/types.ts

@@ -0,0 +1,51 @@
+export type WebViewOptions = {
+	autoplay?: boolean;
+	backForwardNavigationGestures?: boolean;
+	devTools?: boolean;
+	hotkeysZoom?: boolean;
+	transparent?: boolean;
+	html?: string;
+	url?: string;
+	incognito?: boolean;
+};
+
+export type WindowOptions = {
+	alwaysOnBottom?: boolean;
+	alwaysOnTop?: boolean;
+	closable?: boolean;
+	contentProtection?: boolean;
+	decorations?: boolean;
+	focusable?: boolean;
+	focused?: boolean;
+	// fullscreen?: boolean;
+	size?: Size;
+	minimumSize?: Size;
+	maximumSize?: Size;
+	maximizable?: boolean;
+	maximized?: boolean;
+	minimizable?: boolean;
+	position?: Position;
+	resizable?: boolean;
+	title?: string;
+	transparent?: boolean;
+	visible?: boolean;
+	visibleOnAllWorkspaces?: boolean;
+};
+
+export type Size = {
+	width: number;
+	height: number;
+};
+
+export type Position = {
+	x: number;
+	y: number;
+};
+
+export enum ProgressState {
+	Normal = 0,
+	Intermediate = 1,
+	Paused = 2,
+	Error = 3,
+	None = 4,
+}

package/src-ts/utilities/options.ts

@@ -0,0 +1,39 @@
+import type { WebViewOptions, WindowOptions } from "../types";
+
+export function transformWebViewOptions(options: WebViewOptions) {
+	return {
+		autoplay: options.autoplay,
+		back_forward_navigation_gestures: options.backForwardNavigationGestures,
+		dev_tools: options.devTools,
+		hotkeys_zoom: options.hotkeysZoom,
+		transparent: options.transparent,
+		html: options.html,
+		url: options.url,
+		incognito: options.incognito,
+	};
+}
+
+export function transformWindowOptions(options: WindowOptions) {
+	return {
+		always_on_bottom: options.alwaysOnBottom,
+		always_on_top: options.alwaysOnTop,
+		closable: options.closable,
+		content_protection: options.contentProtection,
+		decorations: options.decorations,
+		focusable: options.focusable,
+		focused: options.focused,
+		// fullscreen: options.fullscreen,
+		size: options.size,
+		minimum_size: options.minimumSize,
+		maximum_size: options.maximumSize,
+		maximizable: options.maximizable,
+		maximized: options.maximized,
+		minimizable: options.minimizable,
+		position: options.position,
+		resizable: options.resizable,
+		title: options.title,
+		transparent: options.transparent,
+		visible: options.visible,
+		visible_on_all_workspaces: options.visibleOnAllWorkspaces,
+	};
+}

package/src-ts/utilities/strings.ts

@@ -0,0 +1,11 @@
+import { type Pointer, ptr, toArrayBuffer } from "bun:ffi";
+
+export function encodeString(str: string) {
+	return ptr(new TextEncoder().encode(`${str}\0`));
+}
+
+export function decodeString(ptr: Pointer): string {
+	const arr = toArrayBuffer(ptr);
+	const enc = new TextDecoder("utf-8");
+	return enc.decode(arr);
+}