snapreq 0.0.1 → 0.0.4

package/types/websocket/websocket-connection.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Client-side handle for a 1:1 connection opened via
+ * `SnapReqWebSocketClient.openConnection()`. Mirrors the server's connection
+ * lifecycle — `onConnect` / `onMessage` / `onClose` plus `sendMessage` /
+ * `close`.
+ */
+export default class SnapReqWebSocketConnection {
+    /**
+     * @param {object} args - Connection arguments.
+     * @param {import("./websocket-client.js").default} args.client - Owning client.
+     * @param {string} args.connectionId - Generated id unique within the session.
+     * @param {string} args.connectionType - Name the server registered the class under.
+     * @param {Record<string, any>} [args.params] - Opaque params forwarded to the server.
+     * @param {() => void} [args.onConnect] - Fired after the server confirms `connection-opened`.
+     * @param {(body: any) => void} [args.onMessage] - Fired on each `connection-message` from the server.
+     * @param {() => void} [args.onDisconnect] - Fired when the socket drops; connection is preserved pending resume.
+     * @param {() => void} [args.onResume] - Fired when the session successfully resumes after a drop.
+     * @param {(reason: string) => void} [args.onClose] - Fired exactly once when the handle closes permanently.
+     */
+    constructor({ client, connectionId, connectionType, params, onConnect, onMessage, onDisconnect, onResume, onClose }: {
+        client: import("./websocket-client.js").default;
+        connectionId: string;
+        connectionType: string;
+        params?: Record<string, any>;
+        onConnect?: () => void;
+        onMessage?: (body: any) => void;
+        onDisconnect?: () => void;
+        onResume?: () => void;
+        onClose?: (reason: string) => void;
+    });
+    client: import("./websocket-client.js").default;
+    connectionId: string;
+    connectionType: string;
+    params: Record<string, any>;
+    _onConnect: () => void;
+    _onMessage: (body: any) => void;
+    _onDisconnect: () => void;
+    _onResume: () => void;
+    _onClose: (reason: string) => void;
+    _connected: boolean;
+    _closed: boolean;
+    /** @type {Promise<void>} - Resolves once the server sends `connection-opened`. */
+    ready: Promise<void>;
+    _resolveReady: (value: void | PromiseLike<void>) => void;
+    _rejectReady: (reason?: any) => void;
+    /**
+     * Called by the client dispatcher when `{type: "connection-opened"}` arrives.
+     * Fires the user's `onConnect` and resolves `ready`.
+     * @returns {void}
+     */
+    _handleOpened(): void;
+    /**
+     * Called by the client dispatcher for each `connection-message` targeted at
+     * this connection id.
+     * @param {any} body - Message payload.
+     * @returns {void}
+     */
+    _handleMessage(body: any): void;
+    /**
+     * Called by the client when the underlying socket drops. The connection stays
+     * alive pending session resume.
+     * @returns {void}
+     */
+    _handleDisconnected(): void;
+    /**
+     * Called by the client after `session-resumed` confirms the server still has
+     * this connection.
+     * @returns {void}
+     */
+    _handleResumed(): void;
+    /**
+     * Called by the client dispatcher when the connection closes for any reason.
+     * Fires `onClose(reason)` at most once.
+     * @param {string} reason - Why the connection closed.
+     * @returns {void}
+     */
+    _handleClosed(reason: string): void;
+    /**
+     * Sends a message to the server side of this connection.
+     * @param {any} body - Message payload.
+     * @returns {void}
+     */
+    sendMessage(body: any): void;
+    /**
+     * Closes the connection from the client side. Fires `onClose("client_close")`
+     * locally and notifies the server. No-op if already closed.
+     * @returns {void}
+     */
+    close(): void;
+    /** @returns {boolean} - Whether the connection is closed. */
+    isClosed(): boolean;
+    /** @returns {boolean} - Whether the connection is open. */
+    isConnected(): boolean;
+}

package/src/index.js

@@ -1,22 +0,0 @@
-// @ts-check
-
-import SnapReq from "./snap-req.js"
-
-export default SnapReq
-export {default as SnapReq} from "./snap-req.js"
-export {default as SnapReqResponse} from "./response.js"
-export {default as SnapReqHeaders} from "./headers.js"
-export {
-  SnapReqError,
-  SnapReqHttpError,
-  SnapReqUnsupportedFeatureError,
-  SnapReqAbortError
-} from "./errors.js"
-export {defaultRetryableError} from "./retry.js"
-export {detectRuntime, selectTransport} from "./transports/select.js"
-export {default as FetchTransport} from "./transports/fetch-transport.js"
-export {default as XhrTransport} from "./transports/xhr-transport.js"
-
-// The WebSocket client is exported from its own module so importing the HTTP
-// client never pulls WebSocket code into a bundle that does not need it.
-export {default as SnapReqWebSocketClient} from "./websocket/websocket-client.js"