@corelauncher/rod 1.0.7 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@corelauncher/rod",
-	"version": "1.0.7",
+	"version": "1.1.0",
 	"description": "Webview for bun based on tauri's tao and wry.",
 	"keywords": [
 		"corelauncher",

package/src-ts/classes/eventloop.ts

@@ -12,6 +12,7 @@ interface EventLoopEvents {
 	window_focused: (id: number, focused: boolean) => void;
 	window_moved: (id: number, position: Position) => void;
 	window_resized: (id: number, size: Size) => void;
+	tray_clicked: (id: number) => void;
 }
 
 export default class EventLoop extends TypedEmitter<EventLoopEvents> {
@@ -47,7 +48,11 @@ export default class EventLoop extends TypedEmitter<EventLoopEvents> {
 							width: data.width,
 							height: data.height,
 						});
+					case "tray_clicked":
+						return this.emit("tray_clicked", data.id);
 				}
+
+				throw new Error(`Unknown event type: ${event}`);
 			},
 			{
 				args: [FFIType.cstring, FFIType.cstring],

package/src-ts/classes/rod.ts

@@ -1,5 +1,6 @@
-import type { WebViewOptions, WindowOptions } from "../types";
+import type { TrayOptions, WebViewOptions, WindowOptions } from "../types";
 import EventLoop from "./eventloop";
+import Tray from "./tray";
 import WebView from "./webview";
 
 let idIndex = 1;
@@ -7,9 +8,11 @@ let idIndex = 1;
 export default class Rod {
 	eventLoop: EventLoop;
 	private webviews: WebView[];
+	private trays: Tray[];
 	constructor() {
 		this.eventLoop = new EventLoop();
 		this.webviews = [];
+		this.trays = [];
 
 		this.eventLoop.on("window_close_requested", (id) => {
 			const webview = this.retrieveWebViewById(id);
@@ -34,6 +37,12 @@ export default class Rod {
 			if (!webview) return;
 			webview.emit("resized", size);
 		});
+
+		this.eventLoop.on("tray_clicked", (id) => {
+			const tray = this.trays.find((t) => t.id === id);
+			if (!tray) return;
+			tray.emit("click");
+		});
 	}
 
 	private generateId() {
@@ -47,6 +56,7 @@ export default class Rod {
 	createWebView(options: WebViewOptions & WindowOptions = {}) {
 		const id = this.generateId();
 		const webview = new WebView(this.eventLoop, id, options);
+		this.webviews.push(webview);
 
 		webview.on("destroyed", () => {
 			this.webviews = this.webviews.filter((wv) => wv.id !== webview.id);
@@ -54,4 +64,27 @@ export default class Rod {
 
 		return webview;
 	}
+
+	createTray(options: TrayOptions) {
+		const id = this.generateId();
+		const tray = new Tray(id, options);
+		this.trays.push(tray);
+
+		tray.on("destroyed", () => {
+			this.trays = this.trays.filter((t) => t.id !== tray.id);
+		});
+
+		return tray;
+	}
+
+	destroy() {
+		this.webviews.forEach((webview) => {
+			webview.destroy();
+		});
+		this.trays.forEach((tray) => {
+			tray.destroy();
+		});
+
+		this.eventLoop.destroy();
+	}
 }

package/src-ts/classes/tray.ts

@@ -0,0 +1,37 @@
+import type { Pointer } from "bun:ffi";
+import { TypedEmitter } from "tiny-typed-emitter";
+import { rod_tray_create, rod_tray_destroy } from "../ffi";
+import type { TrayOptions } from "../types";
+import { transformTrayOptions } from "../utilities/options";
+import { encodeString } from "../utilities/strings";
+
+interface TrayEvents {
+	click: () => void;
+	destroyed: () => void;
+}
+
+export default class Tray extends TypedEmitter<TrayEvents> {
+	id: number;
+	protected trayPtr: Pointer;
+	constructor(id: number, options: TrayOptions) {
+		super();
+
+		this.id = id;
+
+		const trayPtr = rod_tray_create(
+			this.id,
+			encodeString(JSON.stringify(transformTrayOptions(options))),
+		);
+		if (!trayPtr) throw new Error("Failed to create Tray");
+		this.trayPtr = trayPtr;
+	}
+
+	destroy() {
+		if (!this.trayPtr) return;
+
+		rod_tray_destroy(this.trayPtr);
+		this.trayPtr = null as unknown as Pointer;
+
+		this.emit("destroyed");
+	}
+}

package/src-ts/classes/webcontext.ts

@@ -0,0 +1,21 @@
+import type { Pointer } from "bun:ffi";
+import { resolve } from "node:path";
+import { rod_webcontext_create, rod_webcontext_destroy } from "../ffi";
+import { encodeString } from "../utilities/strings";
+
+export default class WebContext {
+	readonly path: string;
+	readonly webcontextPtr: Pointer;
+
+	constructor(path: string) {
+		this.path = resolve(path);
+
+		const webcontextPtr = rod_webcontext_create(encodeString(this.path));
+		if (!webcontextPtr) throw new Error("Failed to create WebContext");
+		this.webcontextPtr = webcontextPtr;
+	}
+
+	destroy() {
+		rod_webcontext_destroy(this.webcontextPtr);
+	}
+}

package/src-ts/classes/webview.ts

@@ -16,9 +16,11 @@ import type { WebViewOptions, WindowOptions } from "../types";
 import { transformWebViewOptions } from "../utilities/options";
 import { encodeString } from "../utilities/strings";
 import type EventLoop from "./eventloop";
+import WebContext from "./webcontext";
 import Window from "./window";
 
 export default class WebView extends Window {
+	private webcontext: WebContext;
 	protected webviewPtr: Pointer;
 	constructor(
 		eventLoop: EventLoop,
@@ -27,8 +29,11 @@ export default class WebView extends Window {
 	) {
 		super(eventLoop.eventloopPtr, id, options);
 
+		this.webcontext = new WebContext(options.dataDirectory || "./rod_data");
+
 		const webviewPtr = rod_webview_create(
 			this.windowPtr,
+			this.webcontext.webcontextPtr,
 			encodeString(JSON.stringify(transformWebViewOptions(options))),
 		);
 		if (!webviewPtr) throw new Error("Failed to create WebView");
@@ -78,6 +83,7 @@ export default class WebView extends Window {
 		rod_webview_destroy(this.webviewPtr);
 		this.webviewPtr = null as unknown as Pointer;
 
+		this.webcontext.destroy();
 		super.destroy();
 	}
 }

package/src-ts/ffi.ts

@@ -65,6 +65,10 @@ const {
 		// window actions
 		rod_window_start_drag,
 
+		// webcontext
+		rod_webcontext_create,
+		rod_webcontext_destroy,
+
 		// webview
 		rod_webview_create,
 		rod_webview_destroy,
@@ -83,6 +87,10 @@ const {
 		rod_webview_close_devtools,
 		rod_webview_reload,
 		rod_webview_clear_all_browsing_data,
+
+		// tray
+		rod_tray_create,
+		rod_tray_destroy,
 	},
 } = dlopen(library.default, {
 	// event loop
@@ -259,9 +267,19 @@ const {
 		returns: FFIType.void,
 	},
 
+	// webcontext
+	rod_webcontext_create: {
+		args: [FFIType.ptr, FFIType.cstring],
+		returns: FFIType.ptr,
+	},
+	rod_webcontext_destroy: {
+		args: [FFIType.ptr],
+		returns: FFIType.void,
+	},
+
 	// webview
 	rod_webview_create: {
-		args: [FFIType.ptr, FFIType.cstring],
+		args: [FFIType.ptr, FFIType.ptr, FFIType.cstring],
 		returns: FFIType.ptr,
 	},
 	rod_webview_destroy: {
@@ -304,6 +322,16 @@ const {
 		args: [FFIType.ptr],
 		returns: FFIType.void,
 	},
+
+	// tray
+	rod_tray_create: {
+		args: [FFIType.u16, FFIType.cstring],
+		returns: FFIType.ptr,
+	},
+	rod_tray_destroy: {
+		args: [FFIType.ptr],
+		returns: FFIType.void,
+	},
 });
 
 export {
@@ -354,6 +382,9 @@ export {
 	rod_window_set_visible_on_all_workspaces,
 	// window actions
 	rod_window_start_drag,
+	// webcontext
+	rod_webcontext_create,
+	rod_webcontext_destroy,
 	// webview
 	rod_webview_create,
 	rod_webview_destroy,
@@ -369,4 +400,7 @@ export {
 	rod_webview_close_devtools,
 	rod_webview_reload,
 	rod_webview_clear_all_browsing_data,
+	// tray
+	rod_tray_create,
+	rod_tray_destroy,
 };

package/src-ts/types.ts

@@ -7,6 +7,7 @@ export type WebViewOptions = {
 	html?: string;
 	url?: string;
 	incognito?: boolean;
+	dataDirectory?: string;
 };
 
 export type WindowOptions = {
@@ -32,6 +33,12 @@ export type WindowOptions = {
 	visibleOnAllWorkspaces?: boolean;
 };
 
+export type TrayOptions = {
+	iconPath?: string;
+	tooltip?: string;
+	title?: string;
+};
+
 export type Size = {
 	width: number;
 	height: number;

package/src-ts/utilities/options.ts

@@ -1,4 +1,5 @@
-import type { WebViewOptions, WindowOptions } from "../types";
+import { resolve } from "node:path";
+import type { TrayOptions, WebViewOptions, WindowOptions } from "../types";
 
 export function transformWebViewOptions(options: WebViewOptions) {
 	return {
@@ -37,3 +38,11 @@ export function transformWindowOptions(options: WindowOptions) {
 		visible_on_all_workspaces: options.visibleOnAllWorkspaces,
 	};
 }
+
+export function transformTrayOptions(options: TrayOptions) {
+	return {
+		icon_path: options.iconPath ? resolve(options.iconPath) : undefined,
+		tooltip: options.tooltip,
+		title: options.title,
+	};
+}