sparkbun 0.1.0

package/src/bun/core/GpuWindow.ts

@@ -0,0 +1,289 @@
+import { ffi } from "../proc/native";
+import sparkBunEventEmitter from "../events/eventEmitter";
+import { type Pointer } from "bun:ffi";
+import { WGPUView } from "./WGPUView";
+import { BuildConfig } from "./BuildConfig";
+
+
+export type GpuWindowOptionsType = {
+	trafficLightOffset?: {
+		x: number;
+		y: number;
+	};
+	activate?: boolean;
+	title: string;
+	frame: {
+		x: number;
+		y: number;
+		width: number;
+		height: number;
+	};
+	styleMask?: {};
+	titleBarStyle: "hidden" | "hiddenInset" | "default";
+	transparent: boolean;
+};
+
+const defaultOptions: GpuWindowOptionsType = {
+	title: "SparkBun",
+	frame: {
+		x: 0,
+		y: 0,
+		width: 800,
+		height: 600,
+	},
+	titleBarStyle: "default",
+	transparent: false,
+};
+
+const buildConfig = BuildConfig.getSync();
+ffi.request.setExitOnLastWindowClosed({
+	enabled: buildConfig.runtime?.exitOnLastWindowClosed ?? true,
+});
+
+export const GpuWindowMap: {
+	[id: number]: GpuWindow;
+} = {};
+
+// Clean up JS wrapper state when a window closes. Native child cleanup is core-owned.
+sparkBunEventEmitter.on("close", (event: { data: { id: number } }) => {
+	const windowId = event.data.id;
+	delete GpuWindowMap[windowId];
+
+	// Clean up all WGPU views associated with this window
+	for (const view of WGPUView.getAll()) {
+		if (view.windowId === windowId) {
+			view.remove();
+		}
+	}
+
+});
+
+export class GpuWindow {
+	id = 0;
+	title: string = "SparkBun";
+	state: "creating" | "created" = "creating";
+	transparent: boolean = false;
+	trafficLightOffset: { x: number; y: number } = { x: 0, y: 0 };
+	frame: {
+		x: number;
+		y: number;
+		width: number;
+		height: number;
+	} = {
+		x: 0,
+		y: 0,
+		width: 800,
+		height: 600,
+	};
+	wgpuViewId!: number;
+
+	get ptr(): Pointer | null {
+		return ffi.request.getWindowPointer({ winId: this.id }) as Pointer | null;
+	}
+
+	constructor(options: Partial<GpuWindowOptionsType> = defaultOptions) {
+		this.title = options.title || "New Window";
+		this.frame = options.frame
+			? { ...defaultOptions.frame, ...options.frame }
+			: { ...defaultOptions.frame };
+		this.transparent = options.transparent ?? false;
+		this.trafficLightOffset = {
+			x: options.trafficLightOffset?.x ?? 0,
+			y: options.trafficLightOffset?.y ?? 0,
+		};
+
+		this.init(options);
+	}
+
+	init({
+		styleMask,
+		titleBarStyle,
+		transparent,
+		activate,
+	}: Partial<GpuWindowOptionsType>) {
+		const windowId = ffi.request.createWindow({
+			title: this.title,
+			url: "",
+			frame: {
+				width: this.frame.width,
+				height: this.frame.height,
+				x: this.frame.x,
+				y: this.frame.y,
+			},
+			styleMask: {
+				Borderless: false,
+				Titled: true,
+				Closable: true,
+				Miniaturizable: true,
+				Resizable: true,
+				UnifiedTitleAndToolbar: false,
+				FullScreen: false,
+				FullSizeContentView: false,
+				UtilityWindow: false,
+				DocModalWindow: false,
+				NonactivatingPanel: false,
+				HUDWindow: false,
+				...(styleMask || {}),
+				// hiddenInset: transparent titlebar with inset native controls
+				...(titleBarStyle === "hiddenInset"
+					? {
+							Titled: true,
+							FullSizeContentView: true,
+						}
+					: {}),
+				// hidden: no titlebar, no native controls (for fully custom chrome)
+				...(titleBarStyle === "hidden"
+					? {
+							Titled: false,
+							FullSizeContentView: true,
+						}
+					: {}),
+			},
+			titleBarStyle: titleBarStyle || "default",
+			transparent: transparent ?? false,
+			activate: activate ?? true,
+			trafficLightOffset: this.trafficLightOffset,
+		});
+
+		if (!windowId) {
+			throw "Failed to create window";
+		}
+
+		this.id = windowId as number;
+
+		GpuWindowMap[this.id] = this;
+
+		const wgpuView = new WGPUView({
+			frame: {
+				x: 0,
+				y: 0,
+				width: this.frame.width,
+				height: this.frame.height,
+			},
+			windowId: this.id,
+			autoResize: true,
+			startTransparent: false,
+			startPassthrough: false,
+		});
+
+		this.wgpuViewId = wgpuView.id;
+	}
+
+	get wgpuView() {
+		return WGPUView.getById(this.wgpuViewId) as WGPUView;
+	}
+
+	static getById(id: number) {
+		return GpuWindowMap[id];
+	}
+
+	setTitle(title: string) {
+		this.title = title;
+		return ffi.request.setTitle({ winId: this.id, title });
+	}
+
+	close() {
+		return ffi.request.closeWindow({ winId: this.id });
+	}
+
+	activate() {
+		return ffi.request.activateWindow({ winId: this.id });
+	}
+
+	focus() {
+		console.log(
+			"[sparkbun] GpuWindow.focus() is deprecated. Use window.activate() instead.",
+		);
+		return this.activate();
+	}
+
+	show() {
+		return ffi.request.showWindow({ winId: this.id, activate: true });
+	}
+
+	showInactive() {
+		return ffi.request.showWindow({ winId: this.id, activate: false });
+	}
+
+	minimize() {
+		return ffi.request.minimizeWindow({ winId: this.id });
+	}
+
+	unminimize() {
+		return ffi.request.restoreWindow({ winId: this.id });
+	}
+
+	isMinimized(): boolean {
+		return ffi.request.isWindowMinimized({ winId: this.id });
+	}
+
+	maximize() {
+		return ffi.request.maximizeWindow({ winId: this.id });
+	}
+
+	unmaximize() {
+		return ffi.request.unmaximizeWindow({ winId: this.id });
+	}
+
+	isMaximized(): boolean {
+		return ffi.request.isWindowMaximized({ winId: this.id });
+	}
+
+	setFullScreen(fullScreen: boolean) {
+		return ffi.request.setWindowFullScreen({ winId: this.id, fullScreen });
+	}
+
+	isFullScreen(): boolean {
+		return ffi.request.isWindowFullScreen({ winId: this.id });
+	}
+
+	setAlwaysOnTop(alwaysOnTop: boolean) {
+		return ffi.request.setWindowAlwaysOnTop({ winId: this.id, alwaysOnTop });
+	}
+
+	isAlwaysOnTop(): boolean {
+		return ffi.request.isWindowAlwaysOnTop({ winId: this.id });
+	}
+
+	setPosition(x: number, y: number) {
+		this.frame.x = x;
+		this.frame.y = y;
+		return ffi.request.setWindowPosition({ winId: this.id, x, y });
+	}
+
+	setWindowButtonPosition(x: number, y: number) {
+		return ffi.request.setWindowButtonPosition({ winId: this.id, x, y });
+	}
+
+	setSize(width: number, height: number) {
+		this.frame.width = width;
+		this.frame.height = height;
+		return ffi.request.setWindowSize({ winId: this.id, width, height });
+	}
+
+	setFrame(x: number, y: number, width: number, height: number) {
+		this.frame = { x, y, width, height };
+		return ffi.request.setWindowFrame({ winId: this.id, x, y, width, height });
+	}
+
+	getFrame(): { x: number; y: number; width: number; height: number } {
+		const frame = ffi.request.getWindowFrame({ winId: this.id });
+		this.frame = frame;
+		return frame;
+	}
+
+	getPosition(): { x: number; y: number } {
+		const frame = this.getFrame();
+		return { x: frame.x, y: frame.y };
+	}
+
+	getSize(): { width: number; height: number } {
+		const frame = this.getFrame();
+		return { width: frame.width, height: frame.height };
+	}
+
+	on(name: string, handler: (event: unknown) => void) {
+		const specificName = `${name}-${this.id}`;
+		sparkBunEventEmitter.on(specificName, handler);
+	}
+}

package/src/bun/core/Paths.ts

@@ -0,0 +1,5 @@
+import { resolve } from "path";
+
+export const RESOURCES_FOLDER = resolve("../Resources/");
+
+export const VIEWS_FOLDER = resolve(RESOURCES_FOLDER, "app/views");

package/src/bun/core/Socket.ts

@@ -0,0 +1,22 @@
+import { ffi } from "../proc/native";
+
+export const removeSocketForWebview = (webviewId: number) => {
+	ffi.request.clearWebviewHostTransport({ id: webviewId });
+};
+
+// Will return true if message was sent over the core-owned websocket transport.
+// False means the caller should fall back to the native bridge / evaluateJS path.
+export const sendMessageToWebviewViaSocket = (
+	webviewId: number,
+	message: unknown,
+): boolean => {
+	try {
+		return ffi.request.sendHostMessageToWebviewViaTransport({
+			id: webviewId,
+			messageJson: JSON.stringify(message),
+		}) as boolean;
+	} catch (error) {
+		console.error("Error sending message to webview via host transport:", error);
+		return false;
+	}
+};

package/src/bun/core/Tray.ts

@@ -0,0 +1,197 @@
+import { ffi, type MenuItemConfig, type Rectangle } from "../proc/native";
+import sparkBunEventEmitter from "../events/eventEmitter";
+import { VIEWS_FOLDER } from "./Paths";
+import { join } from "path";
+
+type NonDividerMenuItem = Exclude<
+	MenuItemConfig,
+	{ type: "divider" | "separator" }
+>;
+
+const TrayMap: { [id: number]: Tray } = {};
+
+export type TrayOptions = {
+	title?: string;
+	image?: string;
+	template?: boolean;
+	width?: number;
+	height?: number;
+};
+
+export class Tray {
+	id = 0;
+	visible = false;
+	title = "";
+	image = "";
+	template = true;
+	width = 16;
+	height = 16;
+	menu: Array<MenuItemConfig> | null = null;
+
+	constructor({
+		title = "",
+		image = "",
+		template = true,
+		width = 16,
+		height = 16,
+	}: TrayOptions = {}) {
+		this.title = title;
+		this.image = image;
+		this.template = template;
+		this.width = width;
+		this.height = height;
+
+		if (this.createNativeTray()) {
+			TrayMap[this.id] = this;
+		}
+	}
+
+	private createNativeTray(): boolean {
+		try {
+			const trayId = ffi.request.createTray({
+				title: this.title,
+				image: this.resolveImagePath(this.image),
+				template: this.template,
+				width: this.width,
+				height: this.height,
+			}) as number;
+
+			if (!trayId) {
+				throw new Error("Tray creation returned an invalid id");
+			}
+
+			this.id = trayId;
+			this.visible = true;
+			return true;
+		} catch (error) {
+			console.warn("Tray creation failed:", error);
+			console.warn(
+				"System tray functionality may not be available on this platform",
+			);
+			this.visible = false;
+			return false;
+		}
+	}
+
+	resolveImagePath(imgPath: string) {
+		if (imgPath.startsWith("views://")) {
+			return join(VIEWS_FOLDER, imgPath.replace("views://", ""));
+		} else {
+			// can specify any file path here
+			return imgPath;
+		}
+	}
+
+	setTitle(title: string) {
+		this.title = title;
+		if (!this.id) return;
+		ffi.request.setTrayTitle({ id: this.id, title });
+	}
+
+	setImage(imgPath: string) {
+		this.image = imgPath;
+		if (!this.id) return;
+		ffi.request.setTrayImage({
+			id: this.id,
+			image: this.resolveImagePath(imgPath),
+		});
+	}
+
+	setMenu(menu: Array<MenuItemConfig>) {
+		this.menu = menu;
+		if (!this.id) return;
+		const menuWithDefaults = menuConfigWithDefaults(menu);
+		ffi.request.setTrayMenu({
+			id: this.id,
+			menuConfig: JSON.stringify(menuWithDefaults),
+		});
+	}
+
+	on(name: "tray-clicked", handler: (event: unknown) => void) {
+		const specificName = `${name}-${this.id}`;
+		sparkBunEventEmitter.on(specificName, handler);
+	}
+
+	setVisible(visible: boolean) {
+		if (visible === this.visible) {
+			return;
+		}
+
+		if (!visible) {
+			if (this.id) ffi.request.hideTray({ id: this.id });
+			this.visible = false;
+			return;
+		}
+
+		if (!this.id) {
+			if (this.createNativeTray()) {
+				TrayMap[this.id] = this;
+			}
+			return;
+		}
+
+		this.visible = ffi.request.showTray({ id: this.id }) as boolean;
+	}
+
+	getBounds(): Rectangle {
+		return ffi.request.getTrayBounds({ id: this.id });
+	}
+
+	remove() {
+		console.log("Tray.remove() called for id:", this.id);
+		const trayId = this.id;
+		if (trayId) {
+			ffi.request.removeTray({ id: trayId });
+		}
+		this.visible = false;
+		delete TrayMap[trayId];
+		this.id = 0;
+		console.log("Tray removed from TrayMap");
+	}
+
+	static getById(id: number) {
+		return TrayMap[id];
+	}
+
+	static getAll() {
+		return Object.values(TrayMap);
+	}
+
+	static removeById(id: number) {
+		const tray = TrayMap[id];
+		if (tray) {
+			tray.remove();
+		}
+	}
+}
+
+const menuConfigWithDefaults = (
+	menu: Array<MenuItemConfig>,
+): Array<MenuItemConfig> => {
+	return menu.map((item) => {
+		if (item.type === "divider" || item.type === "separator") {
+			return { type: "divider" } as const;
+		} else {
+			const menuItem = item as NonDividerMenuItem;
+			// Use shared serialization method
+			const actionWithDataId = ffi.internal.serializeMenuAction(
+				menuItem.action || "",
+				menuItem.data,
+			);
+
+			return {
+				label: menuItem.label || "",
+				type: menuItem.type || "normal",
+				action: actionWithDataId,
+				// default enabled to true unless explicitly set to false
+				enabled: menuItem.enabled === false ? false : true,
+				checked: Boolean(menuItem.checked),
+				hidden: Boolean(menuItem.hidden),
+				tooltip: menuItem.tooltip || undefined,
+				...(menuItem.submenu
+					? { submenu: menuConfigWithDefaults(menuItem.submenu) }
+					: {}),
+			};
+		}
+	});
+};