@emeryld/rrroutes-client 2.8.8 → 2.8.10

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

@@ -30,8 +30,8 @@ export type UseSocketConnectionDebugOptions = {
 };
 export type UseSocketRoomsArgs<C extends SocketConnectionConfigOutput> = {
     rooms?: Rooms;
-    joinMeta: SocketSchemaOutput<C['joinMetaMessage']>;
-    leaveMeta: SocketSchemaOutput<C['leaveMetaMessage']>;
+    joinMeta?: SocketSchemaOutput<C['joinMetaMessage']>;
+    leaveMeta?: SocketSchemaOutput<C['leaveMetaMessage']>;
     autoJoin?: boolean;
     autoLeave?: boolean;
     enabled?: boolean;

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

@@ -34,8 +34,8 @@ export declare function buildSocketProvider<T extends EventMap, C extends Socket
 }): {
     SocketProvider: (props: React.PropsWithChildren<ProviderRuntimeSocket & {
         fallback?: React.ReactNode;
-        destroyLeaveMeta: SocketSchemaOutput<C["leaveMetaMessage"]>;
-    }>) => import("react/jsx-runtime").JSX.Element;
+        destroyLeaveMeta?: SocketSchemaOutput<C["leaveMetaMessage"]>;
+    }>) => React.JSX.Element;
     useSocketClient: () => SocketClient<T, C> | null;
     useSocketRooms: (p: UseSocketRoomsArgs<C>) => void;
     useSocketEvent: <K extends keyof T & string>(p: UseSocketEventArgs<T, K, C>) => void;

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

@@ -43,6 +43,28 @@ export type HeartbeatClientOptions = {
     /** Give up waiting for pong after this many ms. Default 7_500. */
     timeoutMs?: number;
 };
+export type SocketReconnectionMode = 'managed' | 'manual' | 'inherit';
+/**
+ * Controls reconnect ownership independently from room restoration.
+ *
+ * - `managed`: RRRoutes configures Socket.IO's Manager.
+ * - `manual`: RRRoutes disables Manager retries; the consumer calls
+ *   `client.connect()` (or `socket.connect()`) with its own policy.
+ * - `inherit`: RRRoutes leaves the injected Socket.IO Manager untouched.
+ *
+ * Desired rooms are restored after every successful reconnect by default in
+ * all modes, including consumer-managed reconnects.
+ */
+export type SocketReconnectionOptions = {
+    mode?: SocketReconnectionMode;
+    restoreRooms?: boolean;
+    attempts?: number;
+    delayMs?: number;
+    delayMaxMs?: number;
+    randomizationFactor?: number;
+    timeoutMs?: number | false;
+};
+export type SocketReconnectionConfig = boolean | SocketReconnectionOptions;
 export type SocketClientOptions<T extends EventMap = EventMap, C extends SocketConnectionConfigOutput = SocketConnectionConfigOutput> = {
     /** Inject an existing socket.io-client Socket. Can be null while bootstrapping. */
     socket: MaybeSocket;
@@ -63,6 +85,13 @@ export type SocketClientOptions<T extends EventMap = EventMap, C extends SocketC
     debug?: SocketClientDebugOptions;
     /** Optional heartbeat configuration. If provided, the client will start the heartbeat loop on the default 'sys:connect' handler. */
     heartbeat?: HeartbeatClientOptions;
+    /**
+     * Reconnect behavior. `true` enables RRRoutes-managed Socket.IO defaults;
+     * `false` disables Manager retries for a consumer-managed policy. Omit it
+     * to inherit the injected socket's Manager configuration. Room restoration
+     * remains enabled unless `restoreRooms` is explicitly false.
+     */
+    reconnection?: SocketReconnectionConfig;
     sys: SysEventMap<T, C>;
 };
 export declare class SocketClient<T extends EventMap, C extends SocketConnectionConfigOutput = SocketConnectionConfigOutput> {
@@ -74,6 +103,7 @@ export declare class SocketClient<T extends EventMap, C extends SocketConnection
     private readonly sysEvents;
     private readonly roomJoinSchema;
     private readonly roomLeaveSchema;
+    private readonly reconnection;
     private readonly hb;
     private hbTimer;
     /** keep references so we can .off() later */
@@ -83,7 +113,9 @@ export declare class SocketClient<T extends EventMap, C extends SocketConnection
     private readonly onConnectError;
     private readonly onPong;
     private readonly roomCounts;
+    private readonly roomJoinMeta;
     private readonly handlerMap;
+    private hasConnected;
     private snapshotSocketConfig;
     private logSocketConfigSnapshot;
     private getValidationDetails;
@@ -92,9 +124,17 @@ export declare class SocketClient<T extends EventMap, C extends SocketConnection
     private getNamespace;
     constructor(events: T, opts: SocketClientOptions<T, C>);
     private getSysEvent;
+    private resolveReconnectionOptions;
+    private configureReconnection;
     private dbg;
     /** internal stats snapshot */
     stats(): ClientStatsSnapshot;
+    /**
+     * Re-emit joins for all rooms with active references without incrementing
+     * their reference counts. This is safe to call after any externally or
+     * internally managed reconnect.
+     */
+    restoreRooms(): Promise<string[]>;
     private toArray;
     private rollbackJoinIncrement;
     private rollbackLeaveDecrement;
@@ -113,8 +153,8 @@ 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<() => Promise<void>>;
-    leaveRooms(rooms: string[] | string, meta: SocketSchemaOutput<C['leaveMetaMessage']>): 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: T[K]['__out'], meta?: {
         envelope: ServerEnvelope<T[K]['__out']>;
         ctx: ClientCtx;
@@ -123,7 +163,7 @@ export declare class SocketClient<T extends EventMap, C extends SocketConnection
      * Remove all listeners, stop timers, and leave rooms.
      * Call when disposing the client instance.
      */
-    destroy(leaveMeta: SocketSchemaOutput<C['leaveMetaMessage']>): Promise<void>;
+    destroy(leaveMeta?: SocketSchemaOutput<C['leaveMetaMessage']>): Promise<void>;
     /** Pass-throughs. Managing connection is the caller’s responsibility. */
     disconnect(): void;
     connect(): void;

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

@@ -20,7 +20,7 @@ type DebugDetails = {
 };
 export type SocketClientDebugEvent<K extends string = string> = ({
     type: 'connection';
-    phase: 'connect_event' | 'reconnect_event' | 'disconnect_event' | 'connect_error_event' | 'connect' | 'disconnect';
+    phase: 'connect_event' | 'reconnect_event' | 'reconnect_config' | 'disconnect_event' | 'connect_error_event' | 'connect' | 'disconnect';
     id?: string;
     attempt?: number;
     reason?: string;
@@ -38,7 +38,7 @@ export type SocketClientDebugEvent<K extends string = string> = ({
     err?: string;
 } & DebugDetails['details']) | ({
     type: 'room';
-    phase: 'join' | 'leave';
+    phase: 'join' | 'leave' | 'restore';
     rooms: string[];
     err?: string;
 } & DebugDetails) | ({

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

@@ -43,14 +43,14 @@ export type SysEventMap<T extends EventMap, C extends SocketConnectionConfigOutp
         socket: Socket;
         client: SocketClient<T, C>;
         rooms: string | string[];
-        meta: SocketSchemaOutput<C['joinMetaMessage']>;
+        meta?: SocketSchemaOutput<C['joinMetaMessage']>;
     }) => Promise<boolean> | boolean;
     /** Room leave event, triggered when the client attempts to leave one or more rooms. Return true to allow the leave, or false to deny it. */
     'sys:room_leave': (args: {
         socket: Socket;
         client: SocketClient<T, C>;
         rooms: string | string[];
-        meta: SocketSchemaOutput<C['leaveMetaMessage']>;
+        meta?: SocketSchemaOutput<C['leaveMetaMessage']>;
     }) => Promise<boolean> | boolean;
 };
 declare const roomValueSchema: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodString]>;

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

@@ -6,11 +6,14 @@ export type RoomState<C extends SocketConnectionConfigOutput> = {
     joinMeta?: SocketSchemaOutput<C['joinMetaMessage']>;
     leaveMeta?: SocketSchemaOutput<C['leaveMetaMessage']>;
 };
+type MetaField<K extends string, V> = undefined extends V ? {
+    [P in K]?: V;
+} : {
+    [P in K]: V;
+};
 export type ToRoomsResult<C extends SocketConnectionConfigOutput> = {
     rooms: RoomsInput;
-    joinMeta: SocketSchemaOutput<C['joinMetaMessage']>;
-    leaveMeta: SocketSchemaOutput<C['leaveMetaMessage']>;
-};
+} & MetaField<'joinMeta', SocketSchemaOutput<C['joinMetaMessage']>> & MetaField<'leaveMeta', SocketSchemaOutput<C['leaveMetaMessage']>>;
 export type ToRoomsMeta<AppContext = undefined> = {
     appContext?: AppContext;
 };
@@ -22,3 +25,4 @@ export type ToRoomsMapper<L extends AnyLeafLowProfile, C extends SocketConnectio
 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, AppContext = undefined>(data: DataShape<L> | undefined, args: ArgsFor<L> | undefined, toRooms: ToRoomsMapper<L, C, AppContext>, meta?: ToRoomsMeta<AppContext>): RoomState<C>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@emeryld/rrroutes-client",
-  "version": "2.8.8",
+  "version": "2.8.10",
   "private": false,
   "type": "module",
   "main": "dist/index.cjs",
@@ -30,7 +30,7 @@
   },
   "devDependencies": {
     "@jest/globals": "^30.4.1",
-    "@types/react": "^18.3.28",
+    "@types/react": "^18.3.31",
     "@types/react-native": "^0.73.0"
   },
   "repository": {