@api.global/typedsocket 4.0.0 → 4.1.0

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@api.global/typedsocket',
-    version: '4.0.0',
+    version: '4.1.0',
     description: 'A library for creating typed WebSocket connections, supporting bi-directional communication with type safety.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx5QkFBeUI7SUFDL0IsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLCtHQUErRztDQUM3SCxDQUFBIn0=

package/dist_ts/typedsocket.classes.typedsocket.d.ts

@@ -1,8 +1,17 @@
 import * as plugins from './typedsocket.plugins.js';
 export type TTypedSocketSide = 'server' | 'client';
+export type TConnectionStatus = 'new' | 'connecting' | 'connected' | 'disconnected' | 'reconnecting';
+/**
+ * Options for creating a TypedSocket client
+ */
+export interface ITypedSocketClientOptions {
+    autoReconnect?: boolean;
+    maxRetries?: number;
+    initialBackoffMs?: number;
+    maxBackoffMs?: number;
+}
 /**
  * Wrapper for SmartServe's IWebSocketPeer to provide tag compatibility
- * SmartServe uses Set<string> for tags, while TypedSocket uses {id, payload} format
  */
 export interface ISmartServeConnectionWrapper {
     peer: plugins.IWebSocketPeer;
@@ -13,15 +22,32 @@ export interface ISmartServeConnectionWrapper {
 }
 export declare class TypedSocket {
     /**
-     * creates a typedsocket server
-     * note: this will fail in browser environments as server libs are not bundled.
+     * Creates a TypedSocket client using native WebSocket.
+     * Works in both browser and Node.js environments.
+     *
+     * @param typedrouterArg - TypedRouter for handling server-initiated requests
+     * @param serverUrlArg - Server URL (e.g., 'http://localhost:3000' or 'wss://example.com')
+     * @param options - Connection options
+     *
+     * @example
+     * ```typescript
+     * const typedRouter = new TypedRouter();
+     * const client = await TypedSocket.createClient(
+     *   typedRouter,
+     *   'http://localhost:3000',
+     *   { autoReconnect: true }
+     * );
+     * ```
+     */
+    static createClient(typedrouterArg: plugins.typedrequest.TypedRouter, serverUrlArg: string, options?: ITypedSocketClientOptions): Promise<TypedSocket>;
+    /**
+     * Returns the current window location origin URL.
+     * Useful in browser environments for connecting to the same origin.
      */
-    static createServer(typedrouterArg: plugins.typedrequest.TypedRouter): Promise<TypedSocket>;
-    static createClient(typedrouterArg: plugins.typedrequest.TypedRouter, serverUrlArg: string, aliasArg?: string): Promise<TypedSocket>;
     static useWindowLocationOriginUrl: () => string;
     /**
      * Creates a TypedSocket server from an existing SmartServe instance.
-     * Use this when you want TypedSocket to work with SmartServe's WebSocket handling.
+     * This is the only way to create a server-side TypedSocket.
      *
      * @param smartServeArg - SmartServe instance with typedRouter configured in websocket options
      * @param typedRouterArg - TypedRouter for handling requests (must match SmartServe's typedRouter)
@@ -41,41 +67,98 @@ export declare class TypedSocket {
      * ```
      */
     static fromSmartServe(smartServeArg: plugins.SmartServe, typedRouterArg: plugins.typedrequest.TypedRouter): TypedSocket;
-    side: TTypedSocketSide;
-    typedrouter: plugins.typedrequest.TypedRouter;
-    private smartServeRef?;
+    /**
+     * Registers built-in TypedHandlers for tag management
+     */
+    private static registerTagHandlers;
+    readonly side: TTypedSocketSide;
+    readonly typedrouter: plugins.typedrequest.TypedRouter;
+    statusSubject: plugins.smartrx.rxjs.Subject<TConnectionStatus>;
+    private connectionStatus;
+    private websocket;
+    private clientOptions;
+    private serverUrl;
+    private retryCount;
+    private currentBackoff;
+    private pendingRequests;
+    private smartServeRef;
     private smartServeConnectionWrappers;
-    get eventSubject(): plugins.smartrx.rxjs.Subject<plugins.smartsocket.TConnectionStatus>;
-    private postMethod;
-    private socketServerOrClient;
-    constructor(sideArg: TTypedSocketSide, typedrouterArg: plugins.typedrequest.TypedRouter, postMethodArg: plugins.typedrequest.IPostMethod, socketServerOrClientArg: plugins.smartsocket.Smartsocket | plugins.smartsocket.SmartsocketClient);
-    addTag<T extends plugins.typedrequestInterfaces.ITag = any>(nameArg: T['name'], payloadArg: T['payload']): void;
-    createTypedRequest<T extends plugins.typedrequestInterfaces.ITypedRequest>(methodName: T['method'], targetConnection?: plugins.smartsocket.SocketConnection | ISmartServeConnectionWrapper): plugins.typedrequest.TypedRequest<T>;
+    private constructor();
+    /**
+     * Connects the client to the server using native WebSocket
+     */
+    private connect;
+    /**
+     * Converts an HTTP(S) URL to a WebSocket URL
+     */
+    private toWebSocketUrl;
+    /**
+     * Handles incoming WebSocket messages
+     */
+    private handleMessage;
     /**
-     * returns all matching target connections
-     * Works with both Smartsocket and SmartServe backends
-     * @param asyncFindFuncArg - async filter function
-     * @returns array of matching connections
+     * Handles WebSocket disconnection
      */
-    findAllTargetConnections(asyncFindFuncArg: (connectionArg: plugins.smartsocket.SocketConnection | ISmartServeConnectionWrapper) => Promise<boolean>): Promise<(plugins.smartsocket.SocketConnection | ISmartServeConnectionWrapper)[]>;
+    private handleDisconnect;
     /**
-     * returns a single target connection by returning the first one of all matching ones
-     * @param asyncFindFuncArg
-     * @returns
+     * Schedules a reconnection attempt with exponential backoff
      */
-    findTargetConnection(asyncFindFuncArg: (connectionArg: plugins.smartsocket.SocketConnection | ISmartServeConnectionWrapper) => Promise<boolean>): Promise<plugins.smartsocket.SocketConnection | ISmartServeConnectionWrapper | undefined>;
+    private scheduleReconnect;
     /**
-     * Find all connections that have a specific tag
-     * Works with both Smartsocket and SmartServe backends
+     * Updates connection status and notifies subscribers
      */
-    findAllTargetConnectionsByTag<TTag extends plugins.typedrequestInterfaces.ITag = any>(keyArg: TTag['name'], payloadArg?: TTag['payload']): Promise<(plugins.smartsocket.SocketConnection | ISmartServeConnectionWrapper)[]>;
+    private updateStatus;
     /**
-     * Find a single connection by tag
+     * Sends a request to the server and waits for response (client-side)
      */
-    findTargetConnectionByTag<TTag extends plugins.typedrequestInterfaces.ITag = any>(keyArg: TTag['name'], payloadArg?: TTag['payload']): Promise<plugins.smartsocket.SocketConnection | ISmartServeConnectionWrapper | undefined>;
+    private sendRequest;
     /**
-     * Stop the TypedSocket server/client
-     * Note: In SmartServe mode, SmartServe manages its own lifecycle
+     * Creates a TypedRequest for the specified method.
+     * On clients, sends to the server.
+     * On servers, sends to the specified target connection.
+     */
+    createTypedRequest<T extends plugins.typedrequestInterfaces.ITypedRequest>(methodName: T['method'], targetConnection?: ISmartServeConnectionWrapper): plugins.typedrequest.TypedRequest<T>;
+    /**
+     * Gets the current connection status
+     */
+    getStatus(): TConnectionStatus;
+    /**
+     * Stops the TypedSocket client or cleans up server state
      */
     stop(): Promise<void>;
+    /**
+     * Sets a tag on this client connection.
+     * Tags are stored on the server and can be used for filtering.
+     * @client-only
+     */
+    setTag<T extends plugins.typedrequestInterfaces.ITag>(name: T['name'], payload: T['payload']): Promise<void>;
+    /**
+     * Removes a tag from this client connection.
+     * @client-only
+     */
+    removeTag(name: string): Promise<void>;
+    /**
+     * Gets or creates a connection wrapper for a peer
+     */
+    private getOrCreateWrapper;
+    /**
+     * Finds all connections matching the filter function.
+     * @server-only
+     */
+    findAllTargetConnections(asyncFindFuncArg: (connectionArg: ISmartServeConnectionWrapper) => Promise<boolean>): Promise<ISmartServeConnectionWrapper[]>;
+    /**
+     * Finds the first connection matching the filter function.
+     * @server-only
+     */
+    findTargetConnection(asyncFindFuncArg: (connectionArg: ISmartServeConnectionWrapper) => Promise<boolean>): Promise<ISmartServeConnectionWrapper | undefined>;
+    /**
+     * Finds all connections with the specified tag.
+     * @server-only
+     */
+    findAllTargetConnectionsByTag<TTag extends plugins.typedrequestInterfaces.ITag = any>(keyArg: TTag['name'], payloadArg?: TTag['payload']): Promise<ISmartServeConnectionWrapper[]>;
+    /**
+     * Finds the first connection with the specified tag.
+     * @server-only
+     */
+    findTargetConnectionByTag<TTag extends plugins.typedrequestInterfaces.ITag = any>(keyArg: TTag['name'], payloadArg?: TTag['payload']): Promise<ISmartServeConnectionWrapper | undefined>;
 }