@emeryld/rrroutes-client 2.6.10 → 2.6.12

package/dist/routesV3.client.batch.d.ts

@@ -0,0 +1,13 @@
+import { type AnyLeafLowProfile } from '@emeryld/rrroutes-contract';
+import { type QueryClient } from '@tanstack/react-query';
+import type { BranchBuildOptions, BuiltBranch, BuiltLeafMap, RouteClientFetch } from './routesV3.client.types';
+type BuildBatchBranchDeps = {
+    fetchRaw: RouteClientFetch;
+    queryClient: QueryClient;
+    validateResponses: boolean;
+    getBuiltLeaf: (built: unknown) => AnyLeafLowProfile;
+    encodeLeafKey: (leaf: AnyLeafLowProfile) => string;
+    toArgsTuple: (args: unknown) => unknown[];
+};
+export declare function buildBatchBranch<T extends BuiltLeafMap>(leaves: T, options: BranchBuildOptions, deps: BuildBatchBranchDeps): BuiltBranch<T>;
+export {};

package/dist/sockets/socket.client.context.client.d.ts

@@ -2,4 +2,4 @@ import type { EventMap, SocketConnectionConfigOutput } from '@emeryld/rrroutes-c
 import * as React from 'react';
 import { SocketClient } from './socket.client.core';
 export declare const SocketCtx: React.Context<SocketClient<any, SocketConnectionConfigOutput> | null>;
-export declare function useSocketClient<T extends EventMap, C extends SocketConnectionConfigOutput>(): SocketClient<T, C>;
+export declare function useSocketClient<T extends EventMap, C extends SocketConnectionConfigOutput>(): SocketClient<T, C> | null;

package/dist/sockets/socket.client.context.connection.d.ts

@@ -5,7 +5,7 @@ export type UseSocketConnectionArgs<T extends EventMap, K extends keyof T & stri
     event: K;
     rooms?: Rooms;
     onMessage: (payload: Payload<T, K>, meta?: {
-        envelope: ServerEnvelope<T, K>;
+        envelope: ServerEnvelope<T[K]['__out']>;
         ctx: ClientCtx;
     }) => void;
     onCleanup?: () => void;

package/dist/sockets/socket.client.context.provider.d.ts

@@ -36,7 +36,7 @@ export declare function buildSocketProvider<T extends EventMap, C extends Socket
         fallback?: React.ReactNode;
         destroyLeaveMeta: SocketSchemaOutput<C["leaveMetaMessage"]>;
     }>) => import("react/jsx-runtime").JSX.Element;
-    useSocketClient: () => SocketClient<T, C>;
+    useSocketClient: () => SocketClient<T, C> | null;
     useSocketConnection: <K extends keyof T & string>(p: UseSocketConnectionArgs<T, K, C>) => void;
 };
 export {};

package/dist/sockets/socket.client.core.d.ts

@@ -1,11 +1,11 @@
 import type { EventMap, Payload, SocketConnectionConfigOutput, SocketSchemaOutput } from '@emeryld/rrroutes-contract';
 import { SocketClientDebugEvent } from './socket.client.debug';
 import type { MaybeSocket, SysEventMap } from './socket.client.sys';
-export type ServerEnvelope<T extends EventMap, K extends keyof T & string> = {
-    eventName: K;
+export type ServerEnvelope<Payload> = {
+    eventName: string;
     sentAt: string | Date;
     sentTo: string[];
-    data?: Payload<T, K>;
+    data?: Payload;
     metadata?: Record<string, unknown>;
     rooms: string[];
 };
@@ -115,8 +115,8 @@ export declare class SocketClient<T extends EventMap, C extends SocketConnection
     emit<K extends keyof T & string>(event: K, payload: Payload<T, K>, metadata?: Record<string, unknown>): void;
     joinRooms(rooms: string[] | string, meta: SocketSchemaOutput<C['joinMetaMessage']>): Promise<() => Promise<void>>;
     leaveRooms(rooms: string[] | string, meta: SocketSchemaOutput<C['leaveMetaMessage']>): Promise<void>;
-    on<K extends keyof T & string>(event: K, handler: (payload: Payload<T, K>, meta?: {
-        envelope: ServerEnvelope<T, K>;
+    on<K extends keyof T & string>(event: K, handler: (payload: T[K]['__out'], meta?: {
+        envelope: ServerEnvelope<T[K]['__out']>;
         ctx: ClientCtx;
     }) => void): () => void;
     /**

package/dist/sockets/socketedRoute/socket.client.helper.rooms.d.ts

@@ -1,5 +1,5 @@
 import type { AnyLeafLowProfile, InferOutput, SocketConnectionConfigOutput, SocketSchemaOutput } from '@emeryld/rrroutes-contract';
-import type { DataShape } from '../../routesV3.client.types';
+import type { ArgsFor, DataShape } from '../../routesV3.client.types';
 export type RoomsInput = string | string[] | undefined | null;
 export type RoomState<C extends SocketConnectionConfigOutput> = {
     rooms: string[];
@@ -11,7 +11,7 @@ export type ToRoomsResult<C extends SocketConnectionConfigOutput> = {
     joinMeta: SocketSchemaOutput<C['joinMetaMessage']>;
     leaveMeta: SocketSchemaOutput<C['leaveMetaMessage']>;
 };
-export type ToRoomsMapper<L extends AnyLeafLowProfile, C extends SocketConnectionConfigOutput> = (data: InferOutput<L>) => ToRoomsResult<C>;
+export type ToRoomsMapper<L extends AnyLeafLowProfile, C extends SocketConnectionConfigOutput> = (data: InferOutput<L>, args: ArgsFor<L> | undefined) => ToRoomsResult<C>;
 export declare function roomStateEqual<C extends SocketConnectionConfigOutput>(prev: RoomState<C>, next: RoomState<C>): boolean;
 export declare function mergeRoomState<L extends AnyLeafLowProfile, C extends SocketConnectionConfigOutput>(prev: RoomState<C>, toRoomsResult: ToRoomsResult<C>): RoomState<C>;
-export declare function roomsFromData<L extends AnyLeafLowProfile, C extends SocketConnectionConfigOutput>(data: DataShape<L> | undefined, toRooms: ToRoomsMapper<L, C>): RoomState<C>;
+export declare function roomsFromData<L extends AnyLeafLowProfile, C extends SocketConnectionConfigOutput>(data: DataShape<L> | undefined, args: ArgsFor<L> | undefined, toRooms: ToRoomsMapper<L, C>): RoomState<C>;

package/dist/sockets/socketedRoute/socket.client.helper.route.d.ts

@@ -1,4 +1,4 @@
-import type { AnyLeafLowProfile, EventMap, Payload, SocketConnectionConfigOutput } from '@emeryld/rrroutes-contract';
+import type { AnyLeafLowProfile, EventMap, SocketConnectionConfigOutput, SocketEvent } from '@emeryld/rrroutes-contract';
 import type { BuiltInfinite, BuiltQuery, DataShape, InfiniteUseEndpointResultFor, QueryUseEndpointResultFor, UseEndpointArgs } from '../../routesV3.client.types';
 import type { ClientCtx, ServerEnvelope, SocketClient } from '../socket.client.core';
 import { type SocketedRouteDebugOptions } from './socket.client.helper.debug';
@@ -7,6 +7,15 @@ export type SocketedBuilt<L extends AnyLeafLowProfile> = L['cfg']['feed'] extend
 export type SocketedRouteResult<L extends AnyLeafLowProfile> = (L['cfg']['feed'] extends true ? InfiniteUseEndpointResultFor<L> : QueryUseEndpointResultFor<L>) & {
     rooms: string[];
 };
+export type ApplySocket<L extends AnyLeafLowProfile, S extends SocketEvent> = (args: {
+    prev: DataShape<L> | undefined;
+    payload: S['__out'];
+    meta: {
+        envelope?: ServerEnvelope<S['__out']>;
+        ctx?: ClientCtx;
+        args: UseEndpointArgs<L>;
+    };
+}) => DataShape<L> | undefined | null;
 export type SocketedRouteOptions<L extends AnyLeafLowProfile, Events extends EventMap, C extends SocketConnectionConfigOutput> = {
     /** The built route to compose with socket wiring. This should be a route built with the `buildRoute` function */
     built: SocketedBuilt<L>;
@@ -14,14 +23,10 @@ export type SocketedRouteOptions<L extends AnyLeafLowProfile, Events extends Eve
     toRooms: ToRoomsMapper<L, C>;
     /** An object mapping socket event names to functions that apply incoming socket messages to the endpoint data. Each function receives the previous data, the socket message payload, and an optional meta object containing the server envelope and client context. The function should return the new data (new referrence), or null to indicate no change. */
     applySocket: {
-        [K in keyof Events & string]?: (prev: DataShape<L> | undefined, payload: Payload<Events, K>, meta: {
-            envelope?: ServerEnvelope<Events, keyof Events & string>;
-            ctx?: ClientCtx;
-            args: UseEndpointArgs<L>;
-        }) => DataShape<L> | undefined | null;
+        [K in keyof Events & string]?: ApplySocket<L, Events[K]>;
     };
     /** A hook that returns the SocketClient instance. This is required to access the socket client within the route and apply socket messages. */
-    useSocketClient: () => SocketClient<Events, C>;
+    useSocketClient: () => SocketClient<Events, C> | null;
     /** Debug options for the socketed route. This is optional and can be used to enable debug logging for the route's internal operations, such as room joining and socket message application.
      * client: Logs when the socket client becomes available or unavailable.
      * render: Logs on each render of the route, including whether the client is available and the current rooms.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@emeryld/rrroutes-client",
-  "version": "2.6.10",
+  "version": "2.6.12",
   "private": false,
   "type": "module",
   "main": "dist/index.cjs",