@fiyuu/runtime 0.1.0

package/src/server-websocket.js

@@ -0,0 +1,55 @@
+/**
+ * WebSocket server attachment for the Fiyuu runtime.
+ * Wires up a ws.WebSocketServer on the HTTP server's upgrade event.
+ */
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { WebSocketServer } from "ws";
+import { importModule } from "./server-loader.js";
+export async function attachWebsocketServer(server, options, websocketPath) {
+    if (!options.config?.websocket?.enabled) {
+        return undefined;
+    }
+    const socketModulePath = path.join(options.rootDirectory, "server", "socket.ts");
+    const socketModule = existsSync(socketModulePath)
+        ? (await importModule(socketModulePath, options.mode))
+        : null;
+    const registration = socketModule?.registerSocketServer?.() ?? {};
+    const wss = new WebSocketServer({
+        noServer: true,
+        maxPayload: options.config?.websocket?.maxPayloadBytes ?? 64 * 1024,
+    });
+    wss.on("connection", (socket) => {
+        socket.send(JSON.stringify({
+            type: "fiyuu:ready",
+            namespace: registration.namespace ?? "app",
+            events: registration.events ?? [],
+        }));
+        registration.onConnect?.(socket);
+        socket.on("message", (message) => {
+            registration.onMessage?.(socket, message.toString());
+        });
+    });
+    const handledSockets = new WeakSet();
+    server.on("upgrade", (request, socket, head) => {
+        if (handledSockets.has(socket))
+            return;
+        handledSockets.add(socket);
+        if (!request.url) {
+            socket.destroy();
+            return;
+        }
+        const url = new URL(request.url, "http://localhost");
+        if (url.pathname !== websocketPath)
+            return;
+        try {
+            wss.handleUpgrade(request, socket, head, (client) => {
+                wss.emit("connection", client, request);
+            });
+        }
+        catch {
+            // Another WebSocket handler already processed this socket
+        }
+    });
+    return `ws://localhost:${options.port ?? 4050}${websocketPath}`;
+}

package/src/server.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Fiyuu runtime server — main orchestrator.
+ *
+ * This file wires together the modular pieces:
+ *   server-types     → shared interfaces
+ *   server-utils     → serialise, escapeHtml, sendJson/Text, parseBody, …
+ *   server-router    → buildRouteIndex, matchRoute
+ *   server-loader    → importModule, layout/meta loading, query cache, renderGeaComponent
+ *   server-renderer  → renderDocument, renderStatusPage, serveClientAsset, …
+ *   server-devtools  → renderUnifiedToolsScript (dev only)
+ *   server-middleware→ runMiddleware
+ *   server-websocket → attachWebsocketServer
+ */
+import { type RenderMode } from "@fiyuu/core";
+export type { StartServerOptions, StartedServer } from "./server-types.js";
+import type { StartedServer, StartServerOptions } from "./server-types.js";
+declare global {
+    interface Window {
+        __FIYUU_DATA__?: unknown;
+        __FIYUU_ROUTE__?: string;
+        __FIYUU_INTENT__?: string;
+        __FIYUU_RENDER__?: RenderMode;
+        __FIYUU_WS_PATH__?: string;
+        __FIYUU_DEVTOOLS__?: unknown;
+        fiyuu?: {
+            theme: {
+                get(): "light" | "dark";
+                set(value: "light" | "dark"): void;
+                toggle(): void;
+                bindToggle(elementId: string): void;
+                onChange(fn: (theme: "light" | "dark") => void): void;
+            };
+            bind(elementId: string, value?: unknown, asHtml?: boolean): void;
+            partial(elementId: string, url: string, options?: {
+                loading?: string;
+            }): Promise<void>;
+            onError(callback: (event: {
+                message: string;
+                error: Error | null;
+                source: string | null;
+                line: number | null;
+            }) => void): void;
+            state<T>(key: string, initialValue: T): {
+                get(): T;
+                set(value: T): void;
+                bind(elementId: string): object;
+                onChange(fn: (value: T) => void): object;
+            };
+            router: {
+                navigate(url: string): Promise<void>;
+                on(event: "navigate" | "before", fn: (detail: {
+                    route: string;
+                    render?: string;
+                    title?: string;
+                }) => void | false): object;
+            };
+            ws(overridePath?: string): {
+                on(type: string, handler: (data: unknown) => void): object;
+                onOpen(handler: () => void): object;
+                onClose(handler: () => void): object;
+                onError(handler: () => void): object;
+                send(data: unknown): object;
+                status(): "connecting" | "connected" | "closed" | "unavailable";
+            };
+        };
+    }
+}
+export declare function startServer(options: StartServerOptions): Promise<StartedServer>;