@mauroandre/velojs 0.0.25 → 0.0.27

package/dist/testing/socketSession.d.ts

@@ -0,0 +1,13 @@
+/**
+ * In-memory WebSocket session for tests.
+ *
+ * Invokes a `socket_*` handler directly with a mock Context — bypassing the
+ * real HTTP upgrade path. Middlewares do NOT run; set `opts.user` to supply
+ * `c.get("user")`.
+ */
+import type { Hono } from "hono";
+import type { SocketHandler } from "../sockets.js";
+import type { SocketTestOptions, TestSocketSession } from "./types.js";
+export declare function buildSocketSession(hono: Hono, handlerInput: SocketHandler | {
+    __path?: string;
+} | string, opts?: SocketTestOptions): Promise<TestSocketSession>;

package/dist/testing/types.d.ts

@@ -4,6 +4,7 @@
 import type { Hono, Context } from "hono";
 import type { AppRoutes } from "../types.js";
 import type { EventStream } from "../events.js";
+import type { SocketHandler, SocketStub } from "../sockets.js";
 export type Cookies = Record<string, string>;
 export type Headers = Record<string, string>;
 export type Query = Record<string, string | string[]>;
@@ -64,6 +65,30 @@ export interface NextOptions {
     /** Reject if no event arrives within this many ms. */
     timeoutMs: number;
 }
+export interface SocketTestOptions extends RequestOptions {
+    /** Channel ID — sent as `?channel=...` on the WS URL. */
+    channel?: string;
+    /** URL params (for socket paths with `:param`). */
+    params?: Params;
+    /** `c.get("user")` value (shortcut — avoids a full middleware chain). */
+    user?: any;
+}
+export interface TestSocketSession {
+    /** Send a frame. Objects are `JSON.stringify`'d, strings/Uint8Array pass through. */
+    send(msg: string | Uint8Array | object): void;
+    /** Wait for the next incoming frame from the server. Rejects on timeout. */
+    next(opts: NextOptions): Promise<string | Uint8Array>;
+    /** Wait for N incoming frames total (order preserved). */
+    nextN(n: number, opts: NextOptions): Promise<(string | Uint8Array)[]>;
+    /** All frames received from the server so far. */
+    readonly messages: ReadonlyArray<string | Uint8Array>;
+    /** True once the server-side handler has finished (or the session was aborted). */
+    readonly closed: boolean;
+    /** Client-side close — aborts the server handler's abortSignal. */
+    close(code?: number, reason?: string): Promise<void>;
+    /** Resolves when the handler finishes or the session is aborted. */
+    readonly done: Promise<void>;
+}
 export interface TestSubscription<TEvent = any, TSnapshot = any> {
     /** HTTP status of the initial SSE response (200, 403, etc). */
     readonly status: number;
@@ -109,6 +134,17 @@ export interface TestApp {
      */
     loader<T = any>(fn: Function | string, opts?: LoaderRequestOptions): Promise<T | TestResponse>;
     subscribe<TEvent = any, TSnapshot = any>(stream: EventStream<TEvent, TSnapshot> | string, opts?: SubscribeOptions): Promise<TestSubscription<TEvent, TSnapshot>>;
+    /**
+     * Open an in-memory session against a `socket_*` handler.
+     *
+     * Accepts the socket handler function directly (server-imported), a
+     * `{ __path }` stub, or a string path. **Middleware is not simulated** —
+     * test middleware separately through a regular endpoint or page that uses
+     * it. Use `opts.user` to shortcut `c.get("user")`.
+     */
+    socket(handler: SocketHandler | SocketStub | {
+        __path: string;
+    } | string, opts?: SocketTestOptions): Promise<TestSocketSession>;
     /** Build cookies for a user via `getSessionCookie` config. */
     sessionCookies(input: {
         user: any;

package/dist/types.d.ts

@@ -24,9 +24,18 @@ export interface RouteModule {
     metadata?: Metadata;
     [key: `action_${string}`]: (args: ActionArgs<any>) => Promise<any>;
 }
+export type HTTPMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+export interface EndpointHandlerArgs {
+    c: Context;
+    params: Record<string, string>;
+    query: Record<string, string>;
+}
+export type EndpointHandler = (args: EndpointHandlerArgs) => Response | Promise<Response>;
 export interface RouteNode {
     path?: string;
-    module: RouteModule;
+    module?: RouteModule;
+    method?: HTTPMethod;
+    handler?: EndpointHandler;
     children?: RouteNode[];
     middlewares?: MiddlewareHandler[];
     isRoot?: boolean;

package/dist/vite.d.ts

@@ -12,8 +12,26 @@ export declare function transformActionsForClient(code: string, moduleId: string
  * só rodam no server. O client precisa apenas do path para abrir o EventSource.
  */
 export declare function transformStreamsForClient(code: string, moduleId: string): string;
+/**
+ * Transforms `export const socket_xxx = async (...) => {...}` on the client
+ * into a stub with only `{ __isVeloSocket: true, __path: "/_socket/{moduleId}/{name}" }`.
+ *
+ * The body is discarded — the handler runs only on the server. The client
+ * needs just the path to open the WebSocket.
+ */
+export declare function transformSocketsForClient(code: string, moduleId: string): string;
 export declare function removeLoaders(code: string): string;
 export declare function removeMiddlewares(code: string): string;
+/**
+ * On client builds, strip EndpointRoute objects from the default-export array
+ * of `routes.tsx` so server-only handler code (and its imports) don't ship to
+ * the browser. Mirrors the pattern used by `removeMiddlewares`.
+ *
+ * Detection: any ObjectExpression that has a `handler` property is treated as
+ * an endpoint and removed from its containing array. Imports referenced only
+ * by removed endpoints are dropped afterwards.
+ */
+export declare function removeEndpointRoutes(code: string): string;
 export interface PathInfo {
     fullPath: string;
     path: string;