snapreq 0.0.4 → 0.0.5

package/{types → build}/websocket/websocket-connection.d.ts

@@ -92,3 +92,4 @@ export default class SnapReqWebSocketConnection {
     /** @returns {boolean} - Whether the connection is open. */
     isConnected(): boolean;
 }
+//# sourceMappingURL=websocket-connection.d.ts.map

package/build/websocket/websocket-connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket-connection.d.ts","sourceRoot":"","sources":["../../src/websocket/websocket-connection.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH;IACE;;;;;;;;;;;OAWG;IACH,qHAVG;QAAsD,MAAM,EAApD,OAAO,uBAAuB,EAAE,OAAO;QAC1B,YAAY,EAAzB,MAAM;QACO,cAAc,EAA3B,MAAM;QACqB,MAAM,GAAjC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;QACD,SAAS,GAA3B,MAAM,IAAI;QACiB,SAAS,GAApC,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI;QACD,YAAY,GAA9B,MAAM,IAAI;QACQ,QAAQ,GAA1B,MAAM,IAAI;QACsB,OAAO,GAAvC,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI;KAClC,EAmBA;IAjBC,gDAAoB;IACpB,qBAAgC;IAChC,uBAAoC;IACpC,4BAA0B;IAC1B,kBAXe,IAAI,CAWQ;IAC3B,mBAXgB,GAAG,KAAK,IAAI,CAWD;IAC3B,qBAXe,IAAI,CAWc;IACjC,iBAXe,IAAI,CAWM;IACzB,mBAXkB,MAAM,KAAK,IAAI,CAWV;IACvB,oBAAuB;IACvB,iBAAoB;IAEpB,kFAAkF;IAClF,OADW,OAAO,CAAC,IAAI,CAAC,CAItB;IAFA,yDAA4B;IAC5B,qCAA0B;IAI9B;;;;OAIG;IACH,iBAFa,IAAI,CAWhB;IAED;;;;;OAKG;IACH,qBAHW,GAAG,GACD,IAAI,CAKhB;IAED;;;;OAIG;IACH,uBAFa,IAAI,CAKhB;IAED;;;;OAIG;IACH,kBAFa,IAAI,CAKhB;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,IAAI,CAahB;IAED;;;;OAIG;IACH,kBAHW,GAAG,GACD,IAAI,CAYhB;IAED;;;;OAIG;IACH,SAFa,IAAI,CAmBhB;IAED,6DAA6D;IAC7D,YADc,OAAO,CACa;IAElC,2DAA2D;IAC3D,eADc,OAAO,CACoC;CAC1D"}

package/build/websocket/websocket-connection.js

@@ -0,0 +1,148 @@
+// @ts-check
+/**
+ * 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 }) {
+        this.client = client;
+        this.connectionId = connectionId;
+        this.connectionType = connectionType;
+        this.params = params || {};
+        this._onConnect = onConnect;
+        this._onMessage = onMessage;
+        this._onDisconnect = onDisconnect;
+        this._onResume = onResume;
+        this._onClose = onClose;
+        this._connected = false;
+        this._closed = false;
+        /** @type {Promise<void>} - Resolves once the server sends `connection-opened`. */
+        this.ready = new Promise((resolve, reject) => {
+            this._resolveReady = resolve;
+            this._rejectReady = reject;
+        });
+    }
+    /**
+     * Called by the client dispatcher when `{type: "connection-opened"}` arrives.
+     * Fires the user's `onConnect` and resolves `ready`.
+     * @returns {void}
+     */
+    _handleOpened() {
+        if (this._closed || this._connected)
+            return;
+        this._connected = true;
+        try {
+            this._onConnect?.();
+        }
+        finally {
+            this._resolveReady?.();
+        }
+    }
+    /**
+     * Called by the client dispatcher for each `connection-message` targeted at
+     * this connection id.
+     * @param {any} body - Message payload.
+     * @returns {void}
+     */
+    _handleMessage(body) {
+        if (this._closed)
+            return;
+        this._onMessage?.(body);
+    }
+    /**
+     * Called by the client when the underlying socket drops. The connection stays
+     * alive pending session resume.
+     * @returns {void}
+     */
+    _handleDisconnected() {
+        if (this._closed)
+            return;
+        this._onDisconnect?.();
+    }
+    /**
+     * Called by the client after `session-resumed` confirms the server still has
+     * this connection.
+     * @returns {void}
+     */
+    _handleResumed() {
+        if (this._closed)
+            return;
+        this._onResume?.();
+    }
+    /**
+     * 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) {
+        if (this._closed)
+            return;
+        this._closed = true;
+        try {
+            this._onClose?.(reason);
+        }
+        finally {
+            if (!this._connected) {
+                this._rejectReady?.(new Error(`Connection closed before open: ${reason}`));
+            }
+        }
+    }
+    /**
+     * Sends a message to the server side of this connection.
+     * @param {any} body - Message payload.
+     * @returns {void}
+     */
+    sendMessage(body) {
+        if (this._closed) {
+            throw new Error(`Cannot sendMessage on closed connection ${this.connectionId}`);
+        }
+        this.client._sendMessage({
+            type: "connection-message",
+            connectionId: this.connectionId,
+            body
+        });
+    }
+    /**
+     * Closes the connection from the client side. Fires `onClose("client_close")`
+     * locally and notifies the server. No-op if already closed.
+     * @returns {void}
+     */
+    close() {
+        if (this._closed)
+            return;
+        // Send the close frame BEFORE flipping _closed so _sendMessage doesn't
+        // refuse — and guard against a socket that's already gone so the local
+        // teardown still runs.
+        try {
+            if (this.client.isOpen()) {
+                this.client._sendMessage({ type: "connection-close", connectionId: this.connectionId });
+            }
+        }
+        catch {
+            // Socket may have closed between our check and the send; the server will
+            // see the session destroy and clean up regardless.
+        }
+        this.client._removeConnection(this.connectionId);
+        this._handleClosed("client_close");
+    }
+    /** @returns {boolean} - Whether the connection is closed. */
+    isClosed() { return this._closed; }
+    /** @returns {boolean} - Whether the connection is open. */
+    isConnected() { return this._connected && !this._closed; }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/websocket.d.ts

@@ -0,0 +1,3 @@
+export { default } from "./websocket/websocket-client.js";
+export * from "./websocket/websocket-client.js";
+//# sourceMappingURL=websocket.d.ts.map

package/build/websocket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket.d.ts","sourceRoot":"","sources":["../src/websocket.js"],"names":[],"mappings":""}

package/build/websocket.js

@@ -0,0 +1,4 @@
+// @ts-check
+export { default } from "./websocket/websocket-client.js";
+export * from "./websocket/websocket-client.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2Vic29ja2V0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL3dlYnNvY2tldC5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZO0FBRVosT0FBTyxFQUFDLE9BQU8sRUFBQyxNQUFNLGlDQUFpQyxDQUFBO0FBQ3ZELGNBQWMsaUNBQWlDLENBQUEifQ==

package/package.json

@@ -1,67 +1,31 @@
 {
   "name": "snapreq",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "Cross-platform HTTP and WebSocket client with one API across Node, web, Expo and React Native",
   "type": "module",
-  "main": "./src/snap-req.js",
-  "types": "./types/snap-req.d.ts",
+  "main": "./build/snap-req.js",
+  "types": "./build/snap-req.d.ts",
   "exports": {
     ".": {
-      "types": "./types/snap-req.d.ts",
-      "default": "./src/snap-req.js"
-    },
-    "./websocket": {
-      "types": "./types/websocket/websocket-client.d.ts",
-      "default": "./src/websocket/websocket-client.js"
-    },
-    "./errors": {
-      "types": "./types/errors.d.ts",
-      "default": "./src/errors.js"
-    },
-    "./headers": {
-      "types": "./types/headers.d.ts",
-      "default": "./src/headers.js"
-    },
-    "./response": {
-      "types": "./types/response.d.ts",
-      "default": "./src/response.js"
-    },
-    "./retry": {
-      "types": "./types/retry.d.ts",
-      "default": "./src/retry.js"
-    },
-    "./capabilities": {
-      "types": "./types/capabilities.d.ts",
-      "default": "./src/capabilities.js"
-    },
-    "./transports/select": {
-      "types": "./types/transports/select.d.ts",
-      "default": "./src/transports/select.js"
-    },
-    "./transports/fetch": {
-      "types": "./types/transports/fetch-transport.d.ts",
-      "default": "./src/transports/fetch-transport.js"
-    },
-    "./transports/xhr": {
-      "types": "./types/transports/xhr-transport.d.ts",
-      "default": "./src/transports/xhr-transport.js"
+      "types": "./build/snap-req.d.ts",
+      "default": "./build/snap-req.js"
     },
     "./*": {
-      "types": "./types/*.d.ts",
-      "default": "./src/*.js"
+      "types": "./build/*.d.ts",
+      "default": "./build/*.js"
     }
   },
   "files": [
-    "src/**",
-    "types/**"
+    "build/**"
   ],
   "scripts": {
     "all-checks": "npm run typecheck && npm run lint && npm run test",
-    "build:types": "tsc -p tsconfig.build.json",
+    "build": "rm -rf build && tsc",
     "lint": "eslint src spec",
-    "prepublishOnly": "npm run build:types",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run build",
     "release:patch": "release-patch",
-    "test": "node --test \"spec/**/*-spec.js\"",
+    "test": "npm run build && node --test \"spec/**/*-spec.js\"",
     "typecheck": "tsc --noEmit"
   },
   "keywords": [

package/src/errors.js

@@ -1,86 +0,0 @@
-// @ts-check
-
-/** Base class for every error thrown by snapreq. */
-export class SnapReqError extends Error {
-  /** @param {string} message - Human readable description. */
-  constructor(message) {
-    super(message)
-    this.name = "SnapReqError"
-  }
-}
-
-/**
- * Thrown when a request completes with a non-2xx status and the caller asked
- * snapreq to treat error statuses as failures (`throwOnError`, the default for
- * the high-level helpers). Carries enough metadata to build a friendly message
- * without re-reading the response.
- */
-export class SnapReqHttpError extends SnapReqError {
-  /**
-   * @param {object} options - Error metadata.
-   * @param {string} options.message - Human readable description.
-   * @param {string} options.method - HTTP method used for the request.
-   * @param {string} options.url - Fully resolved request URL.
-   * @param {number} options.status - HTTP status code returned by the server.
-   * @param {string} [options.statusText] - HTTP status text returned by the server.
-   * @param {string} [options.responseText] - Decoded response body, when available.
-   * @param {import("./response.js").default} [options.response] - The response that failed.
-   */
-  constructor({message, method, url, status, statusText, responseText, response}) {
-    super(message)
-    this.name = "SnapReqHttpError"
-    this.method = method
-    this.url = url
-    this.status = status
-    this.statusText = statusText
-    this.responseText = responseText
-    this.response = response
-  }
-}
-
-/**
- * Thrown when a request asks for a capability the active transport cannot
- * provide on the current platform (for example a Unix socket or request-body
- * compression in a browser). The API stays identical across platforms; this
- * error is how snapreq tells you a specific feature had to be left out.
- */
-export class SnapReqUnsupportedFeatureError extends SnapReqError {
-  /**
-   * @param {object} options - Error metadata.
-   * @param {string} options.feature - The capability that is not supported.
-   * @param {string} options.transport - Name of the active transport.
-   * @param {string} [options.detail] - Optional extra context.
-   */
-  constructor({feature, transport, detail}) {
-    super(`The "${transport}" transport does not support ${feature}${detail ? `: ${detail}` : ""}.`)
-    this.name = "SnapReqUnsupportedFeatureError"
-    this.feature = feature
-    this.transport = transport
-  }
-}
-
-/** Thrown when a request is aborted via an `AbortSignal`. */
-export class SnapReqAbortError extends SnapReqError {
-  /** @param {string} [message] - Human readable description. */
-  constructor(message = "Request aborted.") {
-    super(message)
-    this.name = "SnapReqAbortError"
-  }
-}
-
-/** Thrown when a request exceeds its configured timeout. */
-export class SnapReqTimeoutError extends SnapReqError {
-  /**
-   * @param {object} options - Error metadata.
-   * @param {string} options.method - HTTP method used for the request.
-   * @param {string} options.url - Fully resolved request URL.
-   * @param {number} options.timeoutMs - Timeout in milliseconds.
-   */
-  constructor({method, url, timeoutMs}) {
-    super(`Request timed out after ${timeoutMs}ms: ${method} ${url}`)
-    this.name = "SnapReqTimeoutError"
-    this.method = method
-    this.url = url
-    this.timeoutMs = timeoutMs
-  }
-}

package/src/headers.js

@@ -1,92 +0,0 @@
-// @ts-check
-
-/**
- * A tiny case-insensitive header bag. Works the same on every platform and
- * avoids depending on the DOM `Headers` global (absent in some runtimes) or on
- * Node's header handling. Header values are always stored as strings.
- */
-export default class SnapReqHeaders {
-  /**
-   * @param {Record<string, string | number | string[]> | SnapReqHeaders | Iterable<[string, string]>} [init] - Initial headers.
-   */
-  constructor(init) {
-    /** @type {Map<string, {name: string, value: string}>} - Keyed by lower-cased name. */
-    this._map = new Map()
-
-    if (!init) return
-
-    if (init instanceof SnapReqHeaders) {
-      for (const [name, value] of init.entries()) this.set(name, value)
-    } else if (typeof (/** @type {any} */ (init)[Symbol.iterator]) === "function") {
-      for (const [name, value] of /** @type {Iterable<[string, string]>} */ (init)) this.set(name, value)
-    } else {
-      for (const [name, value] of Object.entries(init)) {
-        if (Array.isArray(value)) {
-          this.set(name, value.join(", "))
-        } else if (value !== undefined && value !== null) {
-          this.set(name, String(value))
-        }
-      }
-    }
-  }
-
-  /**
-   * @param {string} name - Header name (case-insensitive).
-   * @param {string | number} value - Header value.
-   * @returns {void}
-   */
-  set(name, value) {
-    this._map.set(name.toLowerCase(), {name, value: String(value)})
-  }
-
-  /**
-   * @param {string} name - Header name (case-insensitive).
-   * @returns {string | null} - The header value or null when absent.
-   */
-  get(name) {
-    return this._map.get(name.toLowerCase())?.value ?? null
-  }
-
-  /**
-   * @param {string} name - Header name (case-insensitive).
-   * @returns {boolean} - Whether the header is present.
-   */
-  has(name) {
-    return this._map.has(name.toLowerCase())
-  }
-
-  /**
-   * @param {string} name - Header name (case-insensitive).
-   * @returns {void}
-   */
-  delete(name) {
-    this._map.delete(name.toLowerCase())
-  }
-
-  /**
-   * @yields {[string, string]} - Name/value pair preserving original casing.
-   * @returns {IterableIterator<[string, string]>} - Name/value pairs preserving original casing.
-   */
-  *entries() {
-    for (const {name, value} of this._map.values()) yield [name, value]
-  }
-
-  /** @returns {[string, string][]} - Name/value pairs preserving original casing. */
-  toArray() {
-    return [...this.entries()]
-  }
-
-  /**
-   * Plain object form keyed by the original header casing. Suitable for
-   * passing straight to `http.request` or `fetch`.
-   * @returns {Record<string, string>} - Header object.
-   */
-  toObject() {
-    /** @type {Record<string, string>} */
-    const object = {}
-
-    for (const {name, value} of this._map.values()) object[name] = value
-
-    return object
-  }
-}

package/src/request.js

@@ -1,104 +0,0 @@
-// @ts-check
-
-import SnapReqHeaders from "./headers.js"
-
-/**
- * @typedef {"identity" | "gzip" | "deflate" | "br" | "zstd"} CompressionEncoding
- */
-
-/**
- * @typedef {object} NormalizedBody
- * @property {"none" | "text" | "bytes" | "stream"} kind - Shape of the body payload.
- * @property {string | Uint8Array | AsyncIterable<Uint8Array> | null} value - The payload itself.
- */
-
-const ABSOLUTE_URL_REGEX = /^[a-z][a-z0-9+.-]*:\/\//i
-
-/**
- * Joins a base URL and a path and appends query parameters. `path` may be a
- * fully-qualified URL, in which case the base is ignored.
- * @param {string | undefined} baseUrl - Origin (and optional base path).
- * @param {string} path - Path or absolute URL.
- * @param {Record<string, string | number | boolean | null | undefined> | undefined} query - Query parameters.
- * @returns {string} - Resolved absolute URL.
- */
-export function buildUrl(baseUrl, path, query) {
-  /** @type {string} */
-  let resolved
-
-  if (ABSOLUTE_URL_REGEX.test(path)) {
-    resolved = path
-  } else if (baseUrl) {
-    resolved = `${baseUrl.replace(/\/$/, "")}/${path.replace(/^\//, "")}`
-  } else {
-    resolved = path
-  }
-
-  if (!query) return resolved
-
-  const params = new URLSearchParams()
-
-  for (const [key, value] of Object.entries(query)) {
-    if (value !== undefined && value !== null) params.append(key, String(value))
-  }
-
-  const queryString = params.toString()
-
-  if (!queryString) return resolved
-
-  return resolved.includes("?") ? `${resolved}&${queryString}` : `${resolved}?${queryString}`
-}
-
-/**
- * Determines whether a value should be sent as a streamed request body.
- * @param {unknown} body - Candidate body value.
- * @returns {boolean} - Whether the body is a stream.
- */
-export function isStreamBody(body) {
-  return Boolean(
-    body &&
-    typeof body === "object" &&
-    !(body instanceof Uint8Array) &&
-    !(body instanceof ArrayBuffer) &&
-    (typeof (/** @type {any} */ (body).pipe) === "function" || typeof (/** @type {any} */ (body)[Symbol.asyncIterator]) === "function")
-  )
-}
-
-/**
- * Normalizes a user-supplied body into one of a small set of shapes and applies
- * a default `Content-Type` header when the caller did not set one.
- * @param {unknown} body - Raw body value.
- * @param {SnapReqHeaders} headers - Headers to receive a default `Content-Type`.
- * @returns {NormalizedBody} - Normalized body descriptor.
- */
-export function normalizeBody(body, headers) {
-  if (body === undefined || body === null) {
-    return {kind: "none", value: null}
-  }
-
-  if (body instanceof Uint8Array) {
-    if (!headers.has("content-type")) headers.set("Content-Type", "application/octet-stream")
-
-    return {kind: "bytes", value: body}
-  }
-
-  if (body instanceof ArrayBuffer) {
-    if (!headers.has("content-type")) headers.set("Content-Type", "application/octet-stream")
-
-    return {kind: "bytes", value: new Uint8Array(body)}
-  }
-
-  if (isStreamBody(body)) {
-    if (!headers.has("content-type")) headers.set("Content-Type", "application/octet-stream")
-
-    return {kind: "stream", value: /** @type {AsyncIterable<Uint8Array>} */ (body)}
-  }
-
-  if (typeof body === "string") {
-    return {kind: "text", value: body}
-  }
-
-  if (!headers.has("content-type")) headers.set("Content-Type", "application/json")
-
-  return {kind: "text", value: JSON.stringify(body)}
-}