@dojo-ng/websocket 0.1.2 → 0.2.0

package/README.md

@@ -1,12 +1,11 @@
 # @dojo-ng/websocket
 
-A framework-agnostic WebSocket client: a raw-socket wrapper (`WSocket`) and a convenience
-dispatcher on top of it (`WSDispatcher`) with request/response correlation, an offline send
-queue, reconnect with backoff, and a heartbeat watchdog. The reasoning behind each non-obvious
-behavior below is in the header comments of `src/wsocket.ts` and `src/wsdispatcher.ts`.
+A WebSocket client that reconnects, queues messages while offline, and matches each response to
+its request. Events flow through a [`@dojo-ng/pubsub`](https://www.npmjs.com/package/@dojo-ng/pubsub)
+bus in both directions.
 
-Part of the [Dojo NG framework](../../README.md) monorepo (the non-Lit runtime that complements
-`components`). BSD-3-Clause.
+Part of the [Dojo NG framework](https://foss.heptapod.net/dojo-ng/framework) packages: plain ESM
+and no Lit. BSD-3-Clause.
 
 ## Install
 
@@ -14,97 +13,125 @@ Part of the [Dojo NG framework](../../README.md) monorepo (the non-Lit runtime t
 npm install @dojo-ng/websocket
 ```
 
-## `WSocket`
+## Usage
 
-Canonicalizes differences across `WebSocket` implementations: out-of-sync detection (a live
-re-check of `socket.readyState` on every send, since the browser's own state can move before its
-event fires), backpressure (`bufferedAmount > 0` returns `BUFFERING` instead of sending),
-listener teardown before close (the reconnect-storm fix), and `open(force)` semantics.
-
-```ts
-import { WSocket, SendState } from "@dojo-ng/websocket";
+```js
+import { createPubSub } from "@dojo-ng/pubsub";
+import { WSDispatcher } from "@dojo-ng/websocket";
 
-const ws = new WSocket("wss://example.test");
-ws.addEventListener("open", () => console.log("open"));
-ws.addEventListener("message", (e) => console.log(e.detail.data));
-ws.open();
+const bus = createPubSub();
+const server = new WSDispatcher({
+  url: "wss://example.com/ws",
+  pubsub: bus,                   // share the app's bus; without this you get a private one
+  onConnect: () => [{ action: "event", id: 0, data: { event: "hello", params: { user: 7 } } }],
+});
 
-const state = ws.send("hello"); // SendState.OKAY | NOT_READY | BUFFERING | SEND_ERROR
-```
+server.open();
 
-Most apps want `WSDispatcher`, below, rather than `WSocket` directly — it's the layer that
-carries the actual value (queueing, correlation, reconnect, heartbeat). `WSocket` is exported
-because it's a complete, independently useful primitive on its own, not because most callers need
-to reach for it.
+// Request and response. Sent now if the socket is open, otherwise queued.
+const user = await server.call({ method: "getUser", args: [7] });
 
-## `WSDispatcher`
+// Events from the server arrive on the bus under their own name.
+bus.subscribe("chat:message", (msg) => console.log(msg), { replay: false });
 
-```ts
-import { WSDispatcher } from "@dojo-ng/websocket";
+// Publishing to the outbound topic sends an event to the server.
+bus.publish("notify:event", { event: "chat:message", params: { text: "Hi" } });
+```
 
-const dispatcher = new WSDispatcher({
-	url: "wss://example.test/ws",
-	// Sent on every (re)connect, before the offline queue flushes. The app owns what identity
-	// means here — this package has no opinion beyond "send these frames first."
-	onConnect: () => [{ action: "event", id: 0, data: { event: "identify", params: { sessionId } } }],
+## What WSDispatcher handles
+
+- `onConnect` returns messages to send first on every connect and reconnect, before the queue.
+  Use it to tell the server who the user is.
+- Messages sent while the connection is down wait in a queue. A message leaves the queue only
+  after it is sent, so a failed send does not lose it.
+- After a lost connection, the client waits longer before each new try (Fibonacci backoff). A
+  successful connect resets the delay. After `close()`, it does not reconnect.
+- `reconnectBase` (seconds, default 15) is added to every reconnect delay. Lower it when the
+  server is on the same machine, where a disconnect is usually a quick restart. Keep it high for
+  a public site, so a server restart is not met by every tab at once.
+- `url` can be a function (sync or async) instead of a string. It is called before every open,
+  the first connect and each reconnect, and what it returns is the URL for that attempt only.
+  Use it when the URL carries a single-use credential, such as a ticket in the query string
+  (a browser cannot set a header on a WebSocket). If the function throws or rejects, that counts
+  as a failed attempt and is retried through the backoff. To stop for good, call `close()` and
+  then throw. A string `url` works exactly as before.
+
+```js
+const server = new WSDispatcher({
+  reconnectBase: 2,
+  url: async () => {
+    const res = await fetch("/api/ws-ticket", { method: "POST" });
+    if (res.status === 401) {
+      server.close(); // the credential was refused; do not retry
+      throw new Error("not authorized");
+    }
+    const { ticket } = await res.json();
+    return `wss://example.com/ws?ticket=${ticket}`;
+  },
 });
+```
+- When the server sends `ping` messages, the client expects one at least every 40 seconds. If
+  none arrives, it closes and reconnects through the same backoff. A server that never sends a
+  ping turns this check off.
+- `call()` has no timeout. If the server never answers, the promise never settles. Use
+  `Promise.race` with a timer if you need a limit.
+- Publishing to `outboundTopic` sends an event to the server. The default topic is
+  `"notify:event"`.
+- `simulate("disconnect")` and `simulate("connect")` let you test your reconnect handling without
+  a real outage.
 
-dispatcher.open();
+## The wire format
 
-// A correlated request/response, queued if the socket isn't open yet and flushed on connect.
-const result = await dispatcher.call({ method: "getUser", args: [42] });
+Every message is one JSON object with `action`, `id`, and `data`. A `call` response sends back the
+same `id`, and its `data` becomes the value of the promise. An `event` carries the topic name and
+the payload.
 
-// Events flow through pub/sub in both directions — dispatcher.pubsub is a @dojo-ng/pubsub
-// instance (the caller's own, if one was passed via options.pubsub, otherwise a private one).
-// Inbound "event" frames publish under their own name; publishing to options.outboundTopic
-// (default "notify:event") sends one outbound. No new subscription concept invented.
-dispatcher.pubsub.subscribe("chat:message", (payload) => render(payload));
-dispatcher.pubsub.publish("notify:event", { event: "chat:message", params: { text: "hi" } });
+```json
+{ "action": "call",  "id": 12, "data": { "method": "getUser", "args": [7] } }
+{ "action": "event", "id": 0,  "data": { "event": "chat:message", "params": { "text": "Hi" } } }
+{ "action": "ping",  "id": 0,  "data": null }
 ```
 
-What it carries, and why each exists, is documented at length in the header comment of
-`src/wsdispatcher.ts` — request/response correlation via `Promise.withResolvers()`, an offline
-send queue that peeks and dequeues only on a confirmed send, Fibonacci-backoff reconnect (reset
-only on a successful open, suppressed entirely by an explicit `close()`), and a heartbeat
-watchdog that closes and reopens — through the same backoff path, not a bypass — if the server
-goes quiet for 40s. `dispatcher.simulate("disconnect" | "connect")` is a deliberate testing
-affordance; the playground (below) uses it.
+The full rules are in
+[the JSON Schema](https://foss.heptapod.net/dojo-ng/framework/-/blob/branch/default/packages/websocket/schema/envelope.schema.json).
+The object form was chosen after measuring: with compression, a typical session is only about
+3% larger than with a positional array.
 
-## The wire format
+## WSocket, the thinner layer
 
-`schema/envelope.schema.json` (JSON Schema draft-07) specifies the `{action, id, data}` frame
-`WSDispatcher` sends and receives, independently of the TypeScript `Envelope` type that binds it
-— the schema is the source of truth, the type is one binding of it. The object form was chosen
-over a positional-array form (`[action, id, data]`) by measurement, not argument: compressed (raw
-DEFLATE, context carried across a session — the realistic case), the object form is only 3.4%
-larger than positional over a representative session. `spike/measure-envelope.mjs` reproduces
-the measurement.
+Most apps want `WSDispatcher`. If you only want a thin wrapper, the package also exports `WSocket`.
 
-## Playground
+- It smooths over differences between WebSocket implementations.
+- `send()` returns a `SendState`: `OKAY`, `NOT_READY`, `BUFFERING`, or `SEND_ERROR`. It reports
+  `BUFFERING` instead of sending while the browser still has unsent data.
+- It removes its listeners before closing, so a reconnect does not stack old handlers.
 
-A live connection against a local echo server, demonstrating queued sends while disconnected, a
-real reconnect with Fibonacci backoff, and the heartbeat watchdog — each one driven by a control
-a real client can't perform on itself (the server dropping the connection with no handshake;
-the server going silent without closing the socket), because `simulate("disconnect")` alone
-proves the opposite case: an explicit close schedules no reconnect at all.
+```js
+import { WSocket, SendState } from "@dojo-ng/websocket";
 
-```bash
-npm run playground
-# → http://localhost:8901/packages/websocket/playground/index.html
+const ws = new WSocket("wss://example.com");
+ws.addEventListener("open", () => console.log("open"));
+ws.addEventListener("message", (e) => console.log(e.detail.data));
+ws.open();
+
+const state = ws.send("hello"); // SendState.OKAY, NOT_READY, BUFFERING, or SEND_ERROR
 ```
 
-See the comment at the top of `playground/index.html` for exactly what each button demonstrates.
+## Learn more
 
-## Testing
+The [framework runtime guide](https://dojo-ng.com/docs/framework/) shows the client together with
+[`@dojo-ng/framework`](https://www.npmjs.com/package/@dojo-ng/framework) and
+[`@dojo-ng/pubsub`](https://www.npmjs.com/package/@dojo-ng/pubsub).
 
-| Command | What it runs |
-|---|---|
-| `npm test` | `node --test` over `test/*.test.mjs` — `Queue`, `WSocket`, `WSDispatcher`, and the envelope schema, against fake sockets and (for the reconnect/heartbeat cases) `node:test`'s built-in fake timers |
-| `npm run typecheck` | `tsc --noEmit` |
+## Development
 
-No real network in any test — `test/helpers/fake-websocket.mjs` is a synchronous fake shared
-across the `WSocket` and `WSDispatcher` suites.
+- `npm test` runs the unit tests with `node --test`, against a fake socket and fake timers. No
+  test uses the network.
+- `npm run typecheck` runs `tsc --noEmit`.
+- `npm run playground` starts a local echo server and a demo page at
+  `http://localhost:8901/packages/websocket/playground/index.html`. Its buttons show the offline
+  queue, a real reconnect with backoff, and the heartbeat check.
 
 ## License
 
-BSD-3-Clause. See [LICENSE](../../LICENSE).
+BSD-3-Clause. See [LICENSE](https://foss.heptapod.net/dojo-ng/framework/-/blob/branch/default/LICENSE).

package/dist/wsdispatcher.d.ts

@@ -1,7 +1,28 @@
 import { type PubSub } from "@dojo-ng/pubsub";
 import { WSocket } from "./wsocket.js";
 export interface WSDispatcherOptions {
-    url: string;
+    /**
+     * The socket URL, or a function returning it (sync or async). A function is called before every
+     * open, first connect and every reconnect alike, and its result is the URL for that attempt only
+     * — use it when the URL carries a single-use credential such as a ticket. A function that throws
+     * or rejects counts as a failed attempt and is retried through the reconnect backoff. To stop
+     * for good (say the credential was refused), call `close()` and then throw.
+     *
+     * ```ts
+     * url: async () => {
+     *   const res = await fetch("/api/ws-ticket", { method: "POST" });
+     *   if (res.status === 401) { dispatcher.close(); throw new Error("not authorized"); }
+     *   return `wss://example.com/ws?ticket=${(await res.json()).ticket}`;
+     * }
+     * ```
+     */
+    url: string | (() => string | Promise<string>);
+    /**
+     * Seconds added to every reconnect delay, on top of the Fibonacci step. Default 15. Lower it for
+     * a client on the same machine as its server (a daemon restart); keep it high for a public site
+     * so a server restart is not met by every tab at once.
+     */
+    reconnectBase?: number;
     /** Frames to send first on every (re)connect, before the offline queue flushes. */
     onConnect?: () => unknown[];
     /** Shared with the rest of the app if given; otherwise a private instance is created. */
@@ -16,6 +37,7 @@ export interface WSDispatcherOptions {
 export declare class WSDispatcher {
     #private;
     constructor(options: WSDispatcherOptions);
+    /** The most recent URL opened; empty until a URL provider has resolved once. */
     get url(): string;
     /** The underlying `WSocket`, for connection-state inspection. */
     get socket(): WSocket;

package/dist/wsdispatcher.js

@@ -7,8 +7,14 @@
 // - Offline send queue (`#drain`): peeks and sends, dequeuing only on a confirmed OKAY send, so a
 //   failed send never drops the message. BUFFERING retries at 50ms; a confirmed send immediately
 //   tries the next one.
-// - Reconnect with Fibonacci backoff (`#scheduleReopen`): `TIMEOUT_BASE` 15s plus the step table,
-//   counter reset only on a successful open, suppressed entirely while `#closing` is true.
+// - Reconnect with Fibonacci backoff (`#scheduleReopen`): `reconnectBase` (default 15s) plus the
+//   step table, counter reset only on a successful open, suppressed entirely while `#closing` is
+//   true.
+// - URL provider: `url` may be a function, called before EVERY open (first connect and each
+//   reconnect) so a single-use ticket in the query string is fresh each time. A provider that
+//   throws or rejects is a failed attempt and goes through `#scheduleReopen`; one that wants to stop
+//   for good calls `close()` before throwing. `#closing` is rechecked after the provider resolves,
+//   so a `close()` that lands mid-await wins.
 // - Heartbeat watchdog (`#armHeartbeat`): each inbound "ping" frame arms a 40s timer. On expiry:
 //   close, wait 2s, then go through the SAME backoff-aware reopen path as any other reconnect —
 //   not a bypass. `TIMEOUT_STEP`'s reset-only-on-success rule means a heartbeat failure right after
@@ -42,11 +48,11 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _WSDispatcher_instances, _WSDispatcher_url, _WSDispatcher_ws, _WSDispatcher_pubsub, _WSDispatcher_onConnect, _WSDispatcher_msgQueue, _WSDispatcher_cbqueue, _WSDispatcher_closing, _WSDispatcher_reopenCount, _WSDispatcher_nextId, _WSDispatcher_pingTimer, _WSDispatcher_scheduleReopen, _WSDispatcher_flushQueue, _WSDispatcher_enqueue, _WSDispatcher_drain, _WSDispatcher_dispatch, _WSDispatcher_armHeartbeat;
+var _WSDispatcher_instances, _WSDispatcher_urlSource, _WSDispatcher_reconnectBase, _WSDispatcher_ws, _WSDispatcher_pubsub, _WSDispatcher_onConnect, _WSDispatcher_msgQueue, _WSDispatcher_cbqueue, _WSDispatcher_closing, _WSDispatcher_resolvingUrl, _WSDispatcher_reopenCount, _WSDispatcher_nextId, _WSDispatcher_pingTimer, _WSDispatcher_openResolved, _WSDispatcher_scheduleReopen, _WSDispatcher_flushQueue, _WSDispatcher_enqueue, _WSDispatcher_drain, _WSDispatcher_dispatch, _WSDispatcher_armHeartbeat;
 import { createPubSub } from "@dojo-ng/pubsub";
 import { Queue } from "./queue.js";
 import { WSocket, SendState } from "./wsocket.js";
-const TIMEOUT_BASE = 15;
+const DEFAULT_RECONNECT_BASE = 15;
 const TIMEOUT_STEP = [0, 0, 0, 0, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233];
 const PING_TIMEOUT_MS = 40000;
 const PING_RECOVERY_DELAY_MS = 2000;
@@ -57,20 +63,23 @@ const PING_RECOVERY_DELAY_MS = 2000;
 export class WSDispatcher {
     constructor(options) {
         _WSDispatcher_instances.add(this);
-        _WSDispatcher_url.set(this, void 0);
+        _WSDispatcher_urlSource.set(this, void 0);
+        _WSDispatcher_reconnectBase.set(this, void 0);
         _WSDispatcher_ws.set(this, void 0);
         _WSDispatcher_pubsub.set(this, void 0);
         _WSDispatcher_onConnect.set(this, void 0);
         _WSDispatcher_msgQueue.set(this, new Queue());
         _WSDispatcher_cbqueue.set(this, new Map());
         _WSDispatcher_closing.set(this, false);
+        _WSDispatcher_resolvingUrl.set(this, false);
         _WSDispatcher_reopenCount.set(this, 0);
         _WSDispatcher_nextId.set(this, 1);
         _WSDispatcher_pingTimer.set(this, null);
-        __classPrivateFieldSet(this, _WSDispatcher_url, options.url, "f");
+        __classPrivateFieldSet(this, _WSDispatcher_urlSource, options.url, "f");
+        __classPrivateFieldSet(this, _WSDispatcher_reconnectBase, options.reconnectBase ?? DEFAULT_RECONNECT_BASE, "f");
         __classPrivateFieldSet(this, _WSDispatcher_onConnect, options.onConnect, "f");
         __classPrivateFieldSet(this, _WSDispatcher_pubsub, options.pubsub ?? createPubSub(), "f");
-        __classPrivateFieldSet(this, _WSDispatcher_ws, new WSocket(__classPrivateFieldGet(this, _WSDispatcher_url, "f")), "f");
+        __classPrivateFieldSet(this, _WSDispatcher_ws, new WSocket(typeof __classPrivateFieldGet(this, _WSDispatcher_urlSource, "f") === "string" ? __classPrivateFieldGet(this, _WSDispatcher_urlSource, "f") : ""), "f");
         __classPrivateFieldGet(this, _WSDispatcher_ws, "f").addEventListener("message", (event) => {
             __classPrivateFieldGet(this, _WSDispatcher_instances, "m", _WSDispatcher_dispatch).call(this, event.detail.data);
         });
@@ -84,8 +93,9 @@ export class WSDispatcher {
         const outboundTopic = options.outboundTopic ?? "notify:event";
         __classPrivateFieldGet(this, _WSDispatcher_pubsub, "f").subscribe(outboundTopic, (payload) => __classPrivateFieldGet(this, _WSDispatcher_instances, "m", _WSDispatcher_enqueue).call(this, { action: "event", id: 0, data: payload }), { replay: false });
     }
+    /** The most recent URL opened; empty until a URL provider has resolved once. */
     get url() {
-        return __classPrivateFieldGet(this, _WSDispatcher_url, "f");
+        return __classPrivateFieldGet(this, _WSDispatcher_ws, "f").url;
     }
     /** The underlying `WSocket`, for connection-state inspection. */
     get socket() {
@@ -100,7 +110,14 @@ export class WSDispatcher {
     }
     open(force = false) {
         __classPrivateFieldSet(this, _WSDispatcher_closing, false, "f");
-        __classPrivateFieldGet(this, _WSDispatcher_ws, "f").open(force);
+        if (typeof __classPrivateFieldGet(this, _WSDispatcher_urlSource, "f") === "string") {
+            __classPrivateFieldGet(this, _WSDispatcher_ws, "f").open(force);
+            return;
+        }
+        // A second open while the provider is pending would spend a second single-use URL.
+        if (__classPrivateFieldGet(this, _WSDispatcher_resolvingUrl, "f"))
+            return;
+        void __classPrivateFieldGet(this, _WSDispatcher_instances, "m", _WSDispatcher_openResolved).call(this, __classPrivateFieldGet(this, _WSDispatcher_urlSource, "f"), force);
     }
     close() {
         __classPrivateFieldSet(this, _WSDispatcher_closing, true, "f");
@@ -126,12 +143,28 @@ export class WSDispatcher {
         }
     }
 }
-_WSDispatcher_url = new WeakMap(), _WSDispatcher_ws = new WeakMap(), _WSDispatcher_pubsub = new WeakMap(), _WSDispatcher_onConnect = new WeakMap(), _WSDispatcher_msgQueue = new WeakMap(), _WSDispatcher_cbqueue = new WeakMap(), _WSDispatcher_closing = new WeakMap(), _WSDispatcher_reopenCount = new WeakMap(), _WSDispatcher_nextId = new WeakMap(), _WSDispatcher_pingTimer = new WeakMap(), _WSDispatcher_instances = new WeakSet(), _WSDispatcher_scheduleReopen = function _WSDispatcher_scheduleReopen() {
+_WSDispatcher_urlSource = new WeakMap(), _WSDispatcher_reconnectBase = new WeakMap(), _WSDispatcher_ws = new WeakMap(), _WSDispatcher_pubsub = new WeakMap(), _WSDispatcher_onConnect = new WeakMap(), _WSDispatcher_msgQueue = new WeakMap(), _WSDispatcher_cbqueue = new WeakMap(), _WSDispatcher_closing = new WeakMap(), _WSDispatcher_resolvingUrl = new WeakMap(), _WSDispatcher_reopenCount = new WeakMap(), _WSDispatcher_nextId = new WeakMap(), _WSDispatcher_pingTimer = new WeakMap(), _WSDispatcher_instances = new WeakSet(), _WSDispatcher_openResolved = async function _WSDispatcher_openResolved(provider, force) {
+    __classPrivateFieldSet(this, _WSDispatcher_resolvingUrl, true, "f");
+    let url;
+    try {
+        url = await provider();
+    }
+    catch {
+        __classPrivateFieldSet(this, _WSDispatcher_resolvingUrl, false, "f");
+        __classPrivateFieldGet(this, _WSDispatcher_instances, "m", _WSDispatcher_scheduleReopen).call(this);
+        return;
+    }
+    __classPrivateFieldSet(this, _WSDispatcher_resolvingUrl, false, "f");
+    // A close() that landed while the provider was pending must win.
+    if (__classPrivateFieldGet(this, _WSDispatcher_closing, "f"))
+        return;
+    __classPrivateFieldGet(this, _WSDispatcher_ws, "f").open(force, url);
+}, _WSDispatcher_scheduleReopen = function _WSDispatcher_scheduleReopen() {
     var _a;
     if (__classPrivateFieldGet(this, _WSDispatcher_closing, "f"))
         return;
     const step = Math.min(__classPrivateFieldGet(this, _WSDispatcher_reopenCount, "f"), TIMEOUT_STEP.length - 1);
-    const timeoutSeconds = TIMEOUT_STEP[step] + TIMEOUT_BASE;
+    const timeoutSeconds = TIMEOUT_STEP[step] + __classPrivateFieldGet(this, _WSDispatcher_reconnectBase, "f");
     __classPrivateFieldSet(this, _WSDispatcher_reopenCount, (_a = __classPrivateFieldGet(this, _WSDispatcher_reopenCount, "f"), _a++, _a), "f");
     setTimeout(() => {
         this.open();

package/dist/wsocket.d.ts

@@ -33,8 +33,11 @@ export declare class WSocket extends EventTarget {
     get socket(): WebSocket | null;
     /** Our own tracked state, not a live re-check of `socket.readyState` — see `send()` for why. */
     isOpen(): boolean;
-    /** With no existing socket, or `force: true`, tears down any prior socket and opens a fresh one. */
-    open(force?: boolean): void;
+    /**
+     * With no existing socket, or `force: true`, tears down any prior socket and opens a fresh one.
+     * A `url` replaces the stored one for this socket and onward, so `url` reports the latest.
+     */
+    open(force?: boolean, url?: string): void;
     close(code?: number, reason?: string): void;
     send(message: string | Blob | BufferSource): SendState;
 }

package/dist/wsocket.js

@@ -73,8 +73,11 @@ export class WSocket extends EventTarget {
     isOpen() {
         return __classPrivateFieldGet(this, _WSocket_socket, "f") !== null && __classPrivateFieldGet(this, _WSocket_state, "f") === ReadyState.OPEN;
     }
-    /** With no existing socket, or `force: true`, tears down any prior socket and opens a fresh one. */
-    open(force = false) {
+    /**
+     * With no existing socket, or `force: true`, tears down any prior socket and opens a fresh one.
+     * A `url` replaces the stored one for this socket and onward, so `url` reports the latest.
+     */
+    open(force = false, url) {
         if (__classPrivateFieldGet(this, _WSocket_socket, "f")) {
             if (!force)
                 return;
@@ -86,6 +89,8 @@ export class WSocket extends EventTarget {
                 stale.close();
             __classPrivateFieldSet(this, _WSocket_socket, null, "f");
         }
+        if (url !== undefined)
+            __classPrivateFieldSet(this, _WSocket_url, url, "f");
         __classPrivateFieldSet(this, _WSocket_state, ReadyState.CONNECTING, "f");
         const socket = (__classPrivateFieldSet(this, _WSocket_socket, new WebSocket(__classPrivateFieldGet(this, _WSocket_url, "f")), "f"));
         // Pre-open error: straight to close, no `error` event — see the file header.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dojo-ng/websocket",
-  "version": "0.1.2",
-  "description": "Dojo NG websocket client",
+  "version": "0.2.0",
+  "description": "Dojo NG WebSocket client that reconnects, queues messages while offline, and matches responses to requests",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -12,7 +12,7 @@
   ],
   "license": "BSD-3-Clause",
   "dependencies": {
-    "@dojo-ng/pubsub": "^0.1.2"
+    "@dojo-ng/pubsub": "^0.1.3"
   },
   "devDependencies": {
     "ajv": "^8.20.0",