@poolse/sdk 1.0.1-beta.0 → 1.0.1

package/README.md

@@ -48,12 +48,14 @@ chat.destroy();
 
 ## What it covers
 
-- **REST resources**: `me`, `conversations` (incl. members), `messages` (send / edit / delete / replies / reactions / mark-read), `attachments` (presigned upload + download + delete).
+- **REST resources**: `me`, `conversations` (incl. members), `messages` (send / edit / delete / replies / reactions / mark-read / quote-replies), `attachments` (presigned upload + download + delete with upload progress), `users` (customer-supplied profile cache).
 - **Realtime channels**: `message:new`, `message:updated`, `message:deleted`, `typing:start/stop`, `reaction:added/removed`, presence state + diff, per-user `mention:new` + `conversation:created`.
 - **Token caching** — `getToken` is called once per JWT lifetime, not per request. Auto-invalidates on 401 and re-issues.
 - **Idempotency** — every non-GET request carries an auto-generated `Idempotency-Key`, so retries (network or 5xx) never insert duplicates.
 - **Backoff** — exponential with full jitter, honors `Retry-After` on 429, never retries `AbortError`.
 - **Typed errors** — `AuthError` / `ApiError` / `NetworkError` / `RateLimitedError`, all `instanceof`-checkable.
+- **Upload progress** — pass `onProgress` to `attachments.upload(...)` and the SDK switches to XHR for the PUT so byte-level progress events fire during the upload to your storage backend.
+- **User resolution** — pass `userResolver(userId)` and `chat.users.get(userId)` returns customer-supplied `{ displayName, avatarUrl }` (in-memory cached + dedup'd). The React UI components pick this up automatically; vanilla callers can read it directly.
 
 ## Architecture pattern
 

package/dist/index.cjs

@@ -232,9 +232,32 @@ var ConversationChannel = class {
   // per event name (no matter how many JS listeners) and fan out
   // ourselves — much cheaper than re-binding on every subscription.
   listeners = /* @__PURE__ */ new Map();
+  // Phoenix.Presence pushes `presence_state` exactly ONCE right after
+  // join, then `presence_diff` for every change. Late subscribers
+  // (MemberList mounted after ConversationView has already joined the
+  // channel) would otherwise never see the initial snapshot and stay
+  // empty until somebody else joins or leaves. We cache the running
+  // state here and replay it on subscribe.
+  presenceState = {};
+  presenceStateSeen = false;
   constructor(conversationId, channel) {
     this.conversationId = conversationId;
     this.channel = channel;
+    channel.on("presence_state", (payload) => {
+      this.presenceState = payload ?? {};
+      this.presenceStateSeen = true;
+      const listeners = this.listeners.get("presence_state");
+      if (listeners) listeners.forEach((l) => l(this.presenceState));
+    });
+    channel.on("presence_diff", (payload) => {
+      const diff = payload ?? {};
+      const next = { ...this.presenceState };
+      if (diff.joins) for (const [k, v] of Object.entries(diff.joins)) next[k] = v;
+      if (diff.leaves) for (const k of Object.keys(diff.leaves)) delete next[k];
+      this.presenceState = next;
+      const listeners = this.listeners.get("presence_diff");
+      if (listeners) listeners.forEach((l) => l(payload));
+    });
   }
   /** New message pushed to the conversation. */
   onMessage(fn) {
@@ -268,11 +291,24 @@ var ConversationChannel = class {
     return this.subscribe("member:read", fn);
   }
   onPresenceState(fn) {
-    return this.subscribe("presence_state", fn);
+    let set = this.listeners.get("presence_state");
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set("presence_state", set);
+    }
+    set.add(fn);
+    if (this.presenceStateSeen) fn(this.presenceState);
+    return () => {
+      set.delete(fn);
+    };
   }
   onPresenceDiff(fn) {
     return this.subscribe("presence_diff", fn);
   }
+  /** Current presence snapshot for sync access — usually used in tests. */
+  getPresenceState() {
+    return this.presenceState;
+  }
   /** Send a typing ping to the server. Debounced server-side. */
   sendTyping() {
     this.channel.push("typing", {});
@@ -421,6 +457,14 @@ var AttachmentsResource = class {
       ...input.filename !== void 0 ? { original_filename: input.filename } : {}
     };
     const { attachment, upload } = await this.requestUpload(req, opts);
+    if (opts.onProgress && typeof XMLHttpRequest !== "undefined") {
+      await xhrPut(upload.url, upload.method.toUpperCase(), upload.headers, input.body, {
+        byteSize: input.byteSize,
+        onProgress: opts.onProgress,
+        ...opts.signal ? { signal: opts.signal } : {}
+      });
+      return attachment;
+    }
     const putInit = {
       method: upload.method.toUpperCase(),
       headers: upload.headers,
@@ -472,6 +516,39 @@ var AttachmentHandle = class {
     });
   }
 };
+function xhrPut(url, method, headers, body, opts) {
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    xhr.open(method, url);
+    for (const [k, v] of Object.entries(headers)) {
+      try {
+        xhr.setRequestHeader(k, v);
+      } catch {
+      }
+    }
+    xhr.upload.onprogress = (e) => {
+      const total = e.lengthComputable ? e.total : opts.byteSize;
+      opts.onProgress({ loaded: e.loaded, total });
+    };
+    xhr.onload = () => {
+      if (xhr.status >= 200 && xhr.status < 300) resolve();
+      else
+        reject(new Error(`Poolse: presigned upload PUT failed (${xhr.status} ${xhr.statusText})`));
+    };
+    xhr.onerror = () => reject(new Error("Poolse: presigned upload PUT failed (network error)"));
+    xhr.onabort = () => {
+      reject(new DOMException("Upload aborted", "AbortError"));
+    };
+    if (opts.signal) {
+      if (opts.signal.aborted) {
+        xhr.abort();
+        return;
+      }
+      opts.signal.addEventListener("abort", () => xhr.abort(), { once: true });
+    }
+    xhr.send(body);
+  });
+}
 
 // src/resources/messages.ts
 var ConversationMessages = class {
@@ -1095,7 +1172,7 @@ var Poolse = class {
 };
 
 // src/version.ts
-var version = "0.0.1";
+var version = "1.0.1";
 
 exports.ApiError = ApiError;
 exports.AttachmentHandle = AttachmentHandle;