@mauroandre/velojs 0.0.25 → 0.0.27

package/dist/sockets.d.ts

@@ -0,0 +1,94 @@
+/**
+ * VeloJS Sockets — declarative WebSocket convention.
+ *
+ * Dev pattern: export `socket_<name>` from a page/layout module.
+ *
+ * ```typescript
+ * // app/workers/WorkerTerminal.tsx
+ * export const socket_terminal = async ({
+ *     incoming, send, keepOpen, close, abortSignal, c, params, query,
+ * }) => {
+ *     const user = c.get("user");
+ *     const session = await createTerminal(params.workerId);
+ *     session.on("data", (d) => send({ type: "data", data: d.toString() }));
+ *     abortSignal.addEventListener("abort", () => session.destroy());
+ *     keepOpen();
+ *     for await (const raw of incoming) {
+ *         const msg = JSON.parse(typeof raw === "string" ? raw : "");
+ *         if (msg.type === "resize") session.resize(msg.cols, msg.rows);
+ *         else if (msg.type === "data") session.write(msg.data);
+ *     }
+ * };
+ * ```
+ *
+ * The plugin strips `socket_*` bodies from the client bundle and replaces them
+ * with a stub carrying `__path`. On the client, use `useSocket(socket_terminal)`.
+ */
+import type { Context, Hono, MiddlewareHandler } from "hono";
+import type { RouteNode } from "./types.js";
+export interface SocketHandlerArgs {
+    /** Raw message frames from the client. Text frames → `string`, binary → `Uint8Array`. */
+    incoming: AsyncIterable<string | Uint8Array>;
+    /** Send a message. Objects are auto-serialized with `JSON.stringify`. */
+    send: (msg: string | Uint8Array | object) => void;
+    /** Close the socket imperatively. Accepts an optional WS close code + reason. */
+    close: (code?: number, reason?: string) => void;
+    /**
+     * Mark the socket as long-running. If the handler returns without calling
+     * `keepOpen()`, the framework closes the socket. When `keepOpen()` is set,
+     * the socket stays open until the abort signal fires.
+     *
+     * `for await (const msg of incoming)` naturally keeps the handler alive
+     * while messages flow — `keepOpen()` is redundant in that case but not
+     * harmful.
+     */
+    keepOpen: () => void;
+    /** Fires when the client disconnects, the server aborts, or `app.close()` is called. */
+    abortSignal: AbortSignal;
+    /** Hono Context — use `c.get("user")` etc. for middleware-provided values. */
+    c: Context;
+    /** URL params (e.g. `/:workerId`). */
+    params: Record<string, string>;
+    /** Query-string values. */
+    query: Record<string, string>;
+}
+export type SocketHandler = (args: SocketHandlerArgs) => void | Promise<void>;
+/** Client-side stub shape — what the Vite plugin replaces `socket_*` with on the client bundle. */
+export interface SocketStub {
+    readonly __isVeloSocket: true;
+    readonly __path: string;
+}
+/**
+ * Wraps a raw `incoming` iterable so each frame is JSON-parsed. Invalid JSON
+ * frames are skipped with a console warning (not thrown). Use when all client
+ * messages are JSON objects.
+ *
+ * ```typescript
+ * for await (const msg of parseJson<TerminalMsg>(incoming)) {
+ *     if (msg.type === "resize") session.resize(msg.cols, msg.rows);
+ * }
+ * ```
+ */
+export declare function parseJson<T = unknown>(incoming: AsyncIterable<string | Uint8Array>): AsyncIterable<T>;
+interface RegisteredSocket {
+    path: string;
+    handler: SocketHandler;
+    middlewares: MiddlewareHandler[];
+}
+/** @internal Used by the testing toolkit so `app.close()` aborts in-memory sessions too. */
+export declare function trackSocketSession(app: Hono, ctrl: AbortController): () => void;
+/** @internal Abort every open socket session on `app`. Called by testing toolkit + disposers. */
+export declare function abortAllSocketSessions(app: Hono): void;
+/** @internal Returns registered sockets for `app` (used by the testing toolkit). */
+export declare function getAppSockets(app: Hono): ReadonlyMap<string, RegisteredSocket>;
+export declare function registerSocketHandler(app: Hono, path: string, handler: SocketHandler, middlewares?: MiddlewareHandler[]): Promise<void>;
+/** Walks the route tree and registers every `socket_*` export. */
+export declare function registerSocketRoutes(app: Hono, nodes: RouteNode[], parentMiddlewares?: MiddlewareHandler[]): Promise<void>;
+/**
+ * Inject the WebSocket adapter into an HTTP server. Call after `serve()`
+ * returns (prod) or with Vite's dev http server (dev).
+ *
+ * No-op when no sockets are registered on `app`.
+ */
+export declare function injectWebSocketServer(app: Hono, server: any): Promise<void>;
+export {};

package/dist/sockets.js

@@ -0,0 +1,182 @@
+async function* W(e) {
+  for await (const t of e) {
+    const n = typeof t == "string" ? t : new TextDecoder().decode(t);
+    try {
+      yield JSON.parse(n);
+    } catch {
+      console.warn("[velojs] parseJson: invalid JSON frame, skipped");
+    }
+  }
+}
+const S = /* @__PURE__ */ new WeakMap(), g = /* @__PURE__ */ new WeakMap(), k = /* @__PURE__ */ new WeakMap();
+async function m(e) {
+  let t = S.get(e);
+  if (t) return t;
+  try {
+    return t = (await import("@hono/node-ws")).createNodeWebSocket({ app: e }), S.set(e, t), t;
+  } catch (n) {
+    return console.error("[velojs] failed to load @hono/node-ws:", n), null;
+  }
+}
+function p(e, t) {
+  let n = k.get(e);
+  n || (n = /* @__PURE__ */ new Set(), k.set(e, n)), n.add(t);
+}
+function b(e, t) {
+  k.get(e)?.delete(t);
+}
+function _(e, t) {
+  return p(e, t), () => b(e, t);
+}
+function M(e) {
+  const t = k.get(e);
+  if (t) {
+    for (const n of t)
+      try {
+        n.abort();
+      } catch {
+      }
+    t.clear();
+  }
+}
+function O(e) {
+  return g.get(e) ?? /* @__PURE__ */ new Map();
+}
+function j(e, t, n) {
+  const s = [];
+  let a = null, i = !1, c = !1, o = null;
+  const f = new AbortController();
+  p(e, f);
+  const u = {
+    async *[Symbol.asyncIterator]() {
+      for (; ; ) {
+        for (; s.length > 0; )
+          yield s.shift();
+        if (i) return;
+        await new Promise((l) => {
+          a = l;
+        }), a = null;
+      }
+    }
+  }, d = (l) => {
+    if (!(!o || i))
+      try {
+        typeof l == "string" || l instanceof Uint8Array ? o.send(l) : o.send(JSON.stringify(l));
+      } catch (r) {
+        console.error("[velojs] socket send failed:", r);
+      }
+  }, h = (l, r) => {
+    if (o)
+      try {
+        o.close(l, r);
+      } catch {
+      }
+  }, y = () => {
+    c = !0;
+  }, w = () => {
+    if (i || (i = !0, a?.()), !f.signal.aborted)
+      try {
+        f.abort();
+      } catch {
+      }
+    b(e, f);
+  };
+  return {
+    events: {
+      onOpen(l, r) {
+        o = r, Promise.resolve(
+          t({
+            incoming: u,
+            send: d,
+            close: h,
+            keepOpen: y,
+            abortSignal: f.signal,
+            c: n,
+            params: n.req.param(),
+            query: n.req.query()
+          })
+        ).then(() => {
+          if (!c && o && !i)
+            try {
+              o.close();
+            } catch {
+            }
+        }).catch((v) => {
+          console.error("[velojs] socket handler threw:", v);
+          try {
+            o?.close(1011, "handler error");
+          } catch {
+          }
+        });
+      },
+      onMessage(l) {
+        if (i) return;
+        const r = l.data;
+        typeof r == "string" ? s.push(r) : r instanceof ArrayBuffer ? s.push(new Uint8Array(r)) : r && typeof r == "object" && "buffer" in r && r.buffer instanceof ArrayBuffer && s.push(new Uint8Array(r.buffer)), a?.();
+      },
+      onClose() {
+        w();
+      },
+      onError() {
+        w();
+      }
+    },
+    cleanup: w
+  };
+}
+async function A(e, t, n, s = []) {
+  let a = g.get(e);
+  a || (a = /* @__PURE__ */ new Map(), g.set(e, a)), a.set(t, { path: t, handler: n, middlewares: s });
+  const i = await m(e);
+  if (!i) return;
+  const c = i.upgradeWebSocket((o) => j(e, n, o).events);
+  s.length > 0 ? e.on(["GET"], [t], ...s, c) : e.on(["GET"], [t], c);
+}
+async function q(e, t, n = []) {
+  const s = async (a, i) => {
+    for (const c of a) {
+      const o = c.module?.metadata?.moduleId, f = [...i, ...c.middlewares ?? []];
+      if (c.module && o)
+        for (const u of Object.keys(c.module)) {
+          if (!u.startsWith("socket_")) continue;
+          const d = c.module[u];
+          if (typeof d != "function") {
+            console.warn(
+              `[velojs] socket_* export ${o}/${u} is not a function; skipped`
+            );
+            continue;
+          }
+          const h = u.replace("socket_", ""), y = `/_socket/${o}/${h}`;
+          try {
+            d.__path = y;
+          } catch {
+          }
+          try {
+            d.__isVeloSocket = !0;
+          } catch {
+          }
+          await A(e, y, d, f);
+        }
+      c.children && await s(c.children, f);
+    }
+  };
+  await s(t, n);
+}
+async function x(e, t) {
+  const n = S.get(e);
+  if (n)
+    try {
+      n.injectWebSocket(t);
+    } catch (s) {
+      console.error("[velojs] injectWebSocket failed:", s);
+    }
+}
+export {
+  M as abortAllSocketSessions,
+  O as getAppSockets,
+  x as injectWebSocketServer,
+  W as parseJson,
+  A as registerSocketHandler,
+  q as registerSocketRoutes,
+  _ as trackSocketSession
+};

package/dist/static.js

@@ -1,13 +1,13 @@
 import i from "node:fs";
 import a from "node:path";
-async function h(c, n = "") {
+async function d(c, n = "") {
   const e = [];
   for (const t of c) {
-    const o = t.module.metadata?.fullPath ?? "";
+    const o = t.module?.metadata?.fullPath ?? "";
     if (t.children) {
-      const s = await h(t.children, o);
+      const s = await d(t.children, o);
       e.push(...s);
-    } else {
+    } else if (t.module) {
       const s = t.module.metadata?.fullPath;
       if (!s) continue;
       const r = Object.keys(t.module).filter((l) => l.startsWith("action_"));
@@ -17,9 +17,9 @@ async function h(c, n = "") {
         const l = t.module.staticPaths;
         if (typeof l == "function") {
           const u = await l();
-          for (const d of u) {
+          for (const h of u) {
             let f = s;
-            for (const [p, m] of Object.entries(d))
+            for (const [p, m] of Object.entries(h))
               f = f.replace(`:${p}`, m);
             e.push({ fullPath: f, module: t.module });
           }
@@ -29,7 +29,8 @@ async function h(c, n = "") {
           );
       } else
         e.push({ fullPath: s, module: t.module });
-    }
+    } else
+      continue;
   }
   return e;
 }
@@ -60,7 +61,7 @@ function w(c) {
 async function j(c, n) {
   const e = a.resolve(process.cwd(), "dist");
   console.log("Generating static pages...");
-  const t = await h(n);
+  const t = await d(n);
   if (t.length === 0) {
     console.warn("No routes found for static generation.");
     return;