0.1.0-1-alpha.2-fix.3

crates/apps/game-reflex-poc-tauri/frontend/ts/logging.ts

@@ -1,38 +1,98 @@
 // file: crates/apps/game-reflex-poc-tauri/frontend/ts/logging.ts
-// version: 1
+// version: 2
 
-import { attachConsole, debug, error, info, trace, warn } from "@fltsci/tauri-plugin-tracing";
+import { attachConsole } from "@fltsci/tauri-plugin-tracing";
+import { invoke } from "@tauri-apps/api/core";
 
-let detachRustConsole: (() => void) | null = null;
+export type FrontendLogLevel = "trace" | "debug" | "info" | "warn" | "error";
+export type FrontendLogTarget = "frontend" | "main";
 
-export async function initializeTracing(): Promise<void> {
-    detachRustConsole = await attachConsole();
-    await info("Reflex Tauri frontend tracing initialized", "games::tauri::reflex::frontend");
-}
+type ConsoleMethod = (...items: unknown[]) => void;
 
-export async function tracingTrace(message: string): Promise<void> {
-    await trace(message, "games::tauri::reflex::frontend");
-}
+const originalConsole = {
+    trace: console.trace.bind(console),
+    debug: console.debug.bind(console),
+    info: console.info.bind(console),
+    warn: console.warn.bind(console),
+    error: console.error.bind(console),
+};
 
-export async function tracingDebug(message: string): Promise<void> {
-    await debug(message, "games::tauri::reflex::frontend");
-}
-
-export async function tracingInfo(message: string): Promise<void> {
-    await info(message, "games::tauri::reflex::frontend");
-}
-
-export async function tracingWarn(message: string): Promise<void> {
-    await warn(message, "games::tauri::reflex::frontend");
-}
-
-export async function tracingError(message: string): Promise<void> {
-    await error(message, "games::tauri::reflex::frontend");
-}
-
-export function detachTracingConsole(): void {
-    if (detachRustConsole !== null) {
-        detachRustConsole();
-        detachRustConsole = null;
+function stringifyItem(item: unknown): string {
+    if (item instanceof Error) {
+        return item.stack ?? item.message;
+    }
+    if (typeof item === "string") {
+        return item;
+    }
+    try {
+        const serialized = JSON.stringify(item);
+        return serialized ?? String(item);
+    } catch {
+        return String(item);
     }
 }
+
+function formatMessage(items: unknown[]): string {
+    return items.map(item => stringifyItem(item)).join(" ");
+}
+
+async function sendFrontendLog(level: FrontendLogLevel, targetId: FrontendLogTarget, message: string): Promise<void> {
+    await invoke("emit_frontend_log", {
+        payload: {
+            level,
+            targetId,
+            message,
+        },
+    });
+}
+
+function originalConsoleFor(level: FrontendLogLevel): ConsoleMethod {
+    return level === "trace"
+        ? originalConsole.trace
+        : level === "debug"
+          ? originalConsole.debug
+          : level === "info"
+            ? originalConsole.info
+            : level === "warn"
+              ? originalConsole.warn
+              : originalConsole.error;
+}
+
+export async function initializeTracing(): Promise<void> {
+    await attachConsole();
+    await emitFrontendLog("info", "main", "Reflex Tauri frontend tracing initialized");
+}
+
+export async function emitFrontendLog(level: FrontendLogLevel, targetId: FrontendLogTarget, ...items: unknown[]): Promise<void> {
+    const message = formatMessage(items);
+    originalConsoleFor(level)(message);
+    await sendFrontendLog(level, targetId, message);
+}
+
+function emitDetached(level: FrontendLogLevel, targetId: FrontendLogTarget, items: unknown[]): void {
+    const message = formatMessage(items);
+    originalConsoleFor(level)(message);
+    void sendFrontendLog(level, targetId, message).catch(caughtError => {
+        originalConsole.error("Reflex frontend logging bridge failed", caughtError);
+    });
+}
+
+export function tracingTrace(...items: unknown[]): void {
+    emitDetached("trace", "frontend", items);
+}
+
+export function tracingDebug(...items: unknown[]): void {
+    emitDetached("debug", "frontend", items);
+}
+
+export function tracingInfo(...items: unknown[]): void {
+    emitDetached("info", "frontend", items);
+}
+
+export function tracingWarn(...items: unknown[]): void {
+    emitDetached("warn", "frontend", items);
+}
+
+export function tracingError(...items: unknown[]): void {
+    emitDetached("error", "frontend", items);
+}