@emeryld/rrroutes-client 2.1.11 → 2.2.0

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

@@ -1,7 +1,7 @@
 import type { InfiniteData, QueryClient, QueryKey, UseInfiniteQueryOptions, UseInfiniteQueryResult, UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
 import type { AnyLeaf, HttpMethod, InferBody, InferOutput, InferParams, InferQuery, Prettify } from '@emeryld/rrroutes-contract';
 /** Helper type used when setting React Query cache data. */
-export type Updater<T> = T | ((prev: T | undefined) => T);
+export type Updater<T> = T | ((prev: T | undefined) => T | undefined) | undefined;
 /** Cursor string extracted from paginated endpoints. */
 export type Cursor = string | undefined;
 /** Runtime request details consumed by a `Fetcher` implementation. */
@@ -164,7 +164,7 @@ export type BuildOptionsFor<L extends AnyLeaf> = L['method'] extends 'get' ? L['
 type UseEndpointOptionsFor<L extends AnyLeaf> = {
     onReceive?: OnReceive<L>;
 };
-type UseEndpointArgs<L extends AnyLeaf, O> = keyof ArgsFor<L> extends never ? [options?: O] : [args: ArgsFor<L>, options?: O];
+export type UseEndpointArgs<L extends AnyLeaf, O> = keyof ArgsFor<L> extends never ? [options?: O] : [args: ArgsFor<L>, options?: O];
 export type QueryUseEndpointOptionsFor<L extends AnyLeaf> = UseEndpointOptionsFor<L>;
 export type InfiniteUseEndpointOptionsFor<L extends AnyLeaf> = UseEndpointOptionsFor<L>;
 export type MutationUseEndpointOptionsFor<L extends AnyLeaf> = UseEndpointOptionsFor<L>;

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

@@ -64,7 +64,6 @@ export type UseSocketConnectionArgs<T extends EventMap, K extends keyof T & stri
     onCleanup?: () => void;
     autoJoin?: boolean;
     autoLeave?: boolean;
-    deps?: React.DependencyList;
     joinMeta: SocketSchemaOutput<C['joinMetaMessage']>;
     leaveMeta: SocketSchemaOutput<C['leaveMetaMessage']>;
 };

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

@@ -99,7 +99,7 @@ export declare class SocketClient<T extends EventMap, C extends SocketConnection
      */
     stopHeartbeat(reason?: string): void;
     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<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>;
@@ -116,3 +116,4 @@ export declare class SocketClient<T extends EventMap, C extends SocketConnection
 }
 export * from './socket.client.context';
 export * from './socket.client.sys';
+export * from './socketedRoute/socket.client.helper';

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

@@ -0,0 +1,52 @@
+import type { AnyLeaf, InferOutput, EventMap as ContractEventMap, SocketConnectionConfig, SocketSchemaOutput, Payload } from '@emeryld/rrroutes-contract';
+import type { BuildMeta, BuildOptionsFor, ArgsFor, DataShape, InfiniteUseEndpointOptionsFor, RouterBuilder } from '../../routesV3.client.types';
+import type { ClientCtx, ServerEnvelope, SocketClient } from '../socket.client.index';
+/** Narrow to feed-style GET leaves so `data.pages` is always present. */
+type FeedLeaf = AnyLeaf & {
+    method: 'get';
+    cfg: {
+        feed: true;
+    };
+};
+type PageOf<L extends FeedLeaf> = InferOutput<L>;
+type SocketedHandlers<L extends FeedLeaf, E extends ContractEventMap, K extends keyof E & string, C extends SocketConnectionConfig> = {
+    /**
+     * Derive the full set of rooms to join based on a newly received page plus
+     * the current active room list. Return the complete desired list (not a delta).
+     */
+    onReceiveRooms?: (page: PageOf<L>, activeRooms: string[]) => string[];
+    /**
+     * Update the cached route data when a socket message arrives.
+     * Return the next cache value (or undefined to keep it unchanged).
+     */
+    handleMessage: (prev: DataShape<L> | undefined, payload: Payload<E, K>, meta: {
+        envelope: ServerEnvelope<E, K>;
+        ctx: ClientCtx;
+    }) => DataShape<L> | undefined;
+    /** Meta payloads for join/leave messages. */
+    joinMeta: SocketSchemaOutput<C['joinMetaMessage']>;
+    leaveMeta: SocketSchemaOutput<C['leaveMetaMessage']>;
+};
+/**
+  * Build a hook that wires an infinite GET route to a socket event:
+  * - Keeps React Query cache in sync when socket messages arrive.
+  * - Derives and joins rooms from the route’s feed pages.
+  */
+export declare function createSocketedRouteHook<Routes extends Record<PropertyKey, FeedLeaf>, Names extends string, Events extends ContractEventMap, C extends SocketConnectionConfig>(args: {
+    buildRoute: RouterBuilder<Routes, Names>;
+    useClient?: () => SocketClient<Events, C>;
+}): <K extends keyof Routes, Ev extends keyof Events & string>(params: {
+    routeKey: K;
+    socketEvent: Ev;
+    handlers: SocketedHandlers<Routes[K], Events, Ev, C>;
+    buildOptions?: BuildOptionsFor<Routes[K]>;
+    buildMeta?: BuildMeta<Names>;
+    useOptions?: {
+        args?: ArgsFor<Routes[K]>;
+        options?: InfiniteUseEndpointOptionsFor<Routes[K]>;
+    };
+}) => {
+    data: import("@tanstack/react-query").InfiniteData<InferOutput<Routes[K]>, unknown> | undefined;
+    rooms: string[];
+};
+export {};

package/package.json

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