@kispi/chat 0.2.0 → 0.2.2

package/dist/index.cjs

@@ -204,6 +204,13 @@ var Timeline = class {
   shared = false;
   /** The `loadOlder` in flight, so a scroll handler firing twice asks once. */
   older;
+  /**
+   * The lowest seq the room still keeps (`minSeq` from the subscribe ack;
+   * 1 until told). Below it there is nothing to read, whatever seq says.
+   */
+  floor = 1;
+  /** A `loadOlder` came back short: the top of what the server keeps was reached. */
+  exhausted = false;
   constructor(options) {
     this.options = options;
   }
@@ -212,6 +219,22 @@ var Timeline = class {
     this.shared = true;
     return this.items;
   }
+  /**
+   * Whether `loadOlder()` would find anything, answered without asking.
+   *
+   * `loadOlder()`의 `hasMore`와 같은 판정이다: 맨 위 행이 방의 보존 하한
+   * (`minSeq`, seq는 1부터 구멍 없이 붙는다)보다 위에 있고, 앞선 `loadOlder`가
+   * 덜 찬 페이지로 끝을 알린 적이 없으면 더 있다. 첫 `loadOlder()` 전에 "이전
+   * 메시지 더 보기"를 그릴지 정할 수 있게 한다. 목록이 비었으면 false다.
+   */
+  get hasOlder() {
+    const first = this.items[0];
+    return !this.exhausted && first !== void 0 && first.seq > this.floor;
+  }
+  /** Records the room's retention floor (`minSeq`). */
+  setFloor(minSeq) {
+    this.floor = Math.max(1, minSeq);
+  }
   /** The highest seq this timeline holds, hole or no hole. */
   get highestSeq() {
     return this.items.at(-1)?.seq ?? 0;
@@ -256,6 +279,7 @@ var Timeline = class {
     this.fills.clear();
     this.pendingDeletes.clear();
     this.items = [];
+    this.exhausted = false;
     this.shared = false;
     this.changed();
   }
@@ -283,6 +307,7 @@ var Timeline = class {
     const page = [...messages].sort((a, b) => a.seq - b.seq);
     const top = page.at(-1)?.seq ?? 0;
     this.items = [...page, ...this.items.filter((m) => m.seq > top)];
+    this.exhausted = false;
     this.shared = false;
     for (const m of this.items) {
       if (this.pendingDeletes.has(m.id)) this.applyDelete(m.id);
@@ -333,20 +358,35 @@ var Timeline = class {
    *
    * The server sends the new `count` with the event, so this is a
    * replacement rather than an increment: two clients reacting at once
-   * cannot drift the way `+1`/`-1` would.
+   * cannot drift the way `+1`/`-1` would. `count` undefined leaves the
+   * aggregate alone (the react ack path); `mine` undefined leaves
+   * `myReactions` alone (somebody else's event).
    */
-  reaction(messageId, emoji, count) {
+  reaction(messageId, emoji, count, mine) {
     const at = this.items.findIndex((m) => m.id === messageId);
     if (at === -1) return;
     const current = this.items[at];
-    const existing = current.reactions ?? [];
-    const slot = existing.findIndex((r) => r.emoji === emoji);
-    let next;
-    if (count <= 0) next = existing.filter((r) => r.emoji !== emoji);
-    else if (slot === -1) next = [...existing, { emoji, count }];
-    else next = existing.map((r, i) => i === slot ? { emoji, count } : r);
+    let reactions = current.reactions;
+    if (count !== void 0) {
+      const existing = current.reactions ?? [];
+      const slot = existing.findIndex((r) => r.emoji === emoji);
+      if (count <= 0) reactions = existing.filter((r) => r.emoji !== emoji);
+      else if (slot === -1) reactions = [...existing, { emoji, count }];
+      else reactions = existing.map((r, i) => i === slot ? { emoji, count } : r);
+    }
+    let myReactions = current.myReactions;
+    if (mine !== void 0) {
+      const held = current.myReactions ?? [];
+      const has = held.includes(emoji);
+      if (mine && !has) myReactions = [...held, emoji];
+      else if (!mine && has) myReactions = held.filter((e) => e !== emoji);
+    }
+    if (reactions === current.reactions && myReactions === current.myReactions) return;
+    const next = { ...current };
+    if (reactions !== void 0) next.reactions = reactions;
+    if (myReactions !== void 0) next.myReactions = myReactions;
     this.own();
-    this.items[at] = { ...current, reactions: next };
+    this.items[at] = next;
     this.changed();
   }
   /** Applies a `thread.updated` to the root message's aggregate. */
@@ -383,14 +423,16 @@ var Timeline = class {
   }
   async readOlder(limit) {
     const first = this.items[0];
-    if (first === void 0 || first.seq <= 1) return { messages: [], hasMore: false };
+    if (first === void 0 || first.seq <= this.floor) return { messages: [], hasMore: false };
     const epoch = this.epoch;
     const page = await this.options.fetchRange({ after: 0, before: first.seq, limit });
     if (this.epoch !== epoch) return { messages: [], hasMore: true };
     for (const m of page) this.insert(m, false);
     if (page.length > 0) this.changed();
     const top = page[0];
-    return { messages: page, hasMore: page.length >= limit && top !== void 0 && top.seq > 1 };
+    const hasMore = page.length >= limit && top !== void 0 && top.seq > this.floor;
+    this.exhausted = !hasMore;
+    return { messages: page, hasMore };
   }
   /**
    * Fetches everything between what we have and `upTo`.
@@ -481,6 +523,8 @@ function createTimeline(options) {
 
 // src/room.ts
 var HistoryPageSize = 100;
+var MaxRepairs = 5;
+var RepairBaseMs = 1e3;
 var Room = class extends Emitter {
   /** Resolved on subscribe when the room was addressed by key. */
   id;
@@ -518,6 +562,9 @@ var Room = class extends Emitter {
    */
   wanted = false;
   subscribing;
+  /** Self-repair: the armed retry, and how many have run since the last success. */
+  repairTimer;
+  repairs = 0;
   constructor(chat, rest, address) {
     super();
     this.chat = chat;
@@ -533,6 +580,17 @@ var Room = class extends Emitter {
       onChange: (messages) => this.emit("messages", messages)
     });
   }
+  /**
+   * Whether older history exists above the first message held -- what
+   * `loadOlder()` would report as `hasMore`, known before calling it.
+   *
+   * Derived from the first row's seq against the room's retention floor
+   * (the subscribe ack's `minSeq`), and false once a `loadOlder()` came
+   * back short. False while nothing is loaded. Re-read it on `messages`.
+   */
+  get hasOlder() {
+    return this.timeline.hasOlder;
+  }
   /** Everything this client knows about the room, in seq order. A new array whenever it changes. */
   get messages() {
     return this.timeline.messages;
@@ -584,7 +642,12 @@ var Room = class extends Emitter {
     this.wanted = true;
     if (this.subscribing !== void 0) return this.subscribing;
     if (this.subscribed) return;
-    const attempt = this.doSubscribe().finally(() => {
+    const attempt = this.doSubscribe().then(() => {
+      const successor = this.subscribing;
+      if (successor !== void 0 && successor !== attempt) return successor;
+      if (this.subscribed) this.repairs = 0;
+      return void 0;
+    }).finally(() => {
       if (this.subscribing === attempt) this.subscribing = void 0;
     });
     this.subscribing = attempt;
@@ -593,6 +656,10 @@ var Room = class extends Emitter {
   async doSubscribe() {
     const gen = this.generation;
     const current = () => gen === this.generation;
+    if (this.chat.state !== "open") {
+      await this.chat.whenOpen();
+      if (!current()) return;
+    }
     const data = this.id !== void 0 ? { roomId: this.id } : { key: this.key };
     const since = this.timeline.contiguousSeq;
     if (since > 0) data["since"] = since;
@@ -602,6 +669,7 @@ var Room = class extends Emitter {
     this.id = ack.roomId;
     this.chat.registerRoomId(ack.roomId, this);
     this.lastSeq = ack.lastSeq;
+    if (typeof ack.minSeq === "number") this.timeline.setFloor(ack.minSeq);
     if (ack.presence !== void 0) this.presence = ack.presence;
     if (attempt.wasReset) {
       await this.loadRecent(current);
@@ -645,12 +713,20 @@ var Room = class extends Emitter {
     });
     return page.messages;
   }
-  /** Adds a reaction. Idempotent, like the frame. */
+  /**
+   * Adds a reaction. Idempotent, like the frame.
+   *
+   * The ack updates the row's `myReactions` (not its count -- see below),
+   * so the "I reacted" state is right even if the broadcast is missed.
+   */
   async react(messageId, emoji) {
     await this.chat.send("react", { roomId: await this.resolveId("reacting"), messageId, emoji, op: "add" });
+    this.timeline.reaction(messageId, emoji, void 0, true);
   }
+  /** Removes a reaction. Idempotent; the ack clears it from `myReactions`. */
   async unreact(messageId, emoji) {
     await this.chat.send("react", { roomId: await this.resolveId("reacting"), messageId, emoji, op: "remove" });
+    this.timeline.reaction(messageId, emoji, void 0, false);
   }
   /**
    * Moves this user's read cursor.
@@ -722,13 +798,33 @@ var Room = class extends Emitter {
    * transient 500 takes a room out of the live feed for the life of the
    * page.
    */
-  async resume() {
+  async resume(restart = true) {
     if (!this.wanted) return;
+    if (!restart) return this.subscribe();
     this.generation++;
     this.subscribing = void 0;
     this.subscribed = false;
     await this.subscribe();
   }
+  /**
+   * Reports a failure no caller was waiting for, and repairs.
+   *
+   * 백그라운드 실패(재접속 뒤 다시 구독, 구멍 메우기)에는 거절을 받을 호출자가
+   * 없다. 이벤트만 내고 두면 방은 다음 재접속이나 탭 복귀까지 구멍을 안고 —
+   * 구독 프레임부터 실패했다면 라이브 피드 밖에서 — 머문다. 그래서 스스로 다시
+   * 구독한다. 횟수를 묶는 것은 고칠 수 없는 실패(권한, 없어진 방)가 서버를
+   * 계속 두드리지 않게 하려는 것이고, 그 뒤는 재접속과 `subscribe()`의 몫이다.
+   */
+  failed(err) {
+    this.emit("error", err instanceof Error ? err : new Error(String(err)));
+    if (this.repairTimer !== void 0 || this.repairs >= MaxRepairs) return;
+    const delay = RepairBaseMs * 2 ** this.repairs++;
+    this.repairTimer = setTimeout(() => {
+      this.repairTimer = void 0;
+      if (!this.wanted || this.subscribed || this.chat.state !== "open") return;
+      this.subscribe().catch((e) => this.failed(e));
+    }, delay);
+  }
   /**
    * Sends `subscribe` and recovers from the one error it has an answer
    * for.
@@ -810,7 +906,7 @@ var Room = class extends Emitter {
         if (data.seq > this.lastSeq) this.lastSeq = data.seq;
         this.timeline.add(data).catch((err) => {
           this.subscribed = false;
-          this.emit("error", err instanceof Error ? err : new Error(String(err)));
+          this.failed(err);
         });
         break;
       case "message.updated":
@@ -825,7 +921,9 @@ var Room = class extends Emitter {
       case "reaction.added":
       case "reaction.removed": {
         const r = data;
-        this.timeline.reaction(r.messageId, r.emoji, r.count);
+        const me = this.chat.user?.id;
+        const mine = me !== void 0 && r.userId === me ? type === "reaction.added" : void 0;
+        this.timeline.reaction(r.messageId, r.emoji, r.count, mine);
         break;
       }
       case "thread.updated": {
@@ -879,8 +977,11 @@ var ChatClient = class extends Emitter {
   heartbeat;
   retryTimer;
   attempt = 0;
-  /** Set by close(), and the only thing that stops the reconnect loop. */
-  closedByCaller = false;
+  /**
+   * The reconnect loop is off: set by close(), and by a failure that
+   * retrying cannot fix (see `stop`). Cleared by connect().
+   */
+  stopped = false;
   nextFrameId = 0;
   opening;
   rest;
@@ -958,7 +1059,7 @@ var ChatClient = class extends Emitter {
    *   gap-filled via REST.
    */
   async resume() {
-    if (this.closedByCaller) return;
+    if (this.stopped) return;
     if (this.state !== "open" || this.socket === void 0) {
       this.clearTimers();
       return this.connect();
@@ -970,9 +1071,7 @@ var ChatClient = class extends Emitter {
       return this.connect();
     }
     for (const room of this.handles.values()) {
-      void room.resume().catch((err) => {
-        room.emit("error", err instanceof Error ? err : new Error(String(err)));
-      });
+      void room.resume().catch((err) => room.failed(err));
     }
   }
   /** The account-level routes: the rooms this user is in, and unread. */
@@ -1064,7 +1163,7 @@ var ChatClient = class extends Emitter {
   }
   /** Opens the connection and resolves when `hello` arrives. */
   async connect() {
-    this.closedByCaller = false;
+    this.stopped = false;
     if (this.opening !== void 0) return this.opening;
     if (this.state === "open" && this.socket !== void 0) return;
     this.clearTimers();
@@ -1073,15 +1172,58 @@ var ChatClient = class extends Emitter {
     });
     return this.opening;
   }
+  /**
+   * Re-authenticates: calls `token()` again and replaces the socket, keeping
+   * every room handle and every subscription.
+   *
+   * For when the identity the server holds has to change mid-session --
+   * a nickname change, a new avatar, fresh claims. The server reads the
+   * token once, at `auth`, so `sender.name` on the next message is the old
+   * one until the connection is re-authenticated. `close()` + `connect()`
+   * does that too, but passes through `closed` (a consumer's "you are
+   * offline" screen) and tears down the page listeners.
+   *
+   * States: `open` → `reconnecting` → `open`, never `closed`. Rooms
+   * resubscribe from what they hold and catch up the gap, as after any
+   * drop; `messages` is kept. Frames awaiting an ack on the old socket are
+   * rejected with `closed`. `chat.user` is the new identity once this
+   * resolves. If `token()` fails the client keeps retrying in the
+   * background like any reconnect (and this rejects); a `ChatError` from
+   * `token()` stops it at `closed`, as on connect.
+   *
+   * On a client that is not connected (never connected, or `close()`d) it
+   * is `connect()`.
+   */
+  async reconnect() {
+    if (this.opening !== void 0) await this.opening.catch(() => {
+    });
+    const socket = this.socket;
+    if (socket === void 0 || this.state !== "open") return this.connect();
+    this.clearTimers();
+    this.retired.add(socket);
+    this.socket = void 0;
+    this.failPending(new ChatError("closed", "the connection was replaced by reconnect()"));
+    try {
+      socket.close(1e3, "client reconnecting");
+    } catch {
+    }
+    this.opening = this.openOnce("reconnecting").finally(() => {
+      this.opening = void 0;
+    });
+    return this.opening;
+  }
+  /** Sockets `reconnect()` replaced: their late events are not this client's any more. */
+  retired = /* @__PURE__ */ new WeakSet();
   /**
    * Closes for good.
    *
    * The distinction from a dropped socket is the whole point of the state
-   * machine: this is the only path that reaches `closed`, and a consumer
-   * showing "disconnected, retrying" versus "disconnected" needs it.
+   * machine: `closed` means nothing is coming back, and a consumer showing
+   * "disconnected, retrying" versus "disconnected" needs it. The other
+   * ways to reach it are refusals retrying cannot fix -- see `stop`.
    */
   async close() {
-    this.closedByCaller = true;
+    this.stopped = true;
     this.teardowns.forEach((t) => {
       try {
         t();
@@ -1098,7 +1240,53 @@ var ChatClient = class extends Emitter {
       } catch {
       }
     }
+    this.settleOpenWaiters(new ChatError("closed", "the connection is closed"));
+    this.setState("closed");
+  }
+  /**
+   * Stops for a reason retrying cannot fix, and says which.
+   *
+   * `close()` without the teardown of the page listeners -- a consumer
+   * that logs back in calls `connect()` on the same client -- and with an
+   * `error` event, because on a reconnect there is no caller to reject.
+   */
+  stop(err) {
+    this.stopped = true;
+    this.clearTimers();
+    const socket = this.socket;
+    this.socket = void 0;
+    if (socket !== void 0) {
+      try {
+        socket.close(1e3, "client stopped");
+      } catch {
+      }
+    }
+    this.failPending(err);
+    this.settleOpenWaiters(new ChatError("closed", "the connection is closed"));
     this.setState("closed");
+    this.emit("error", err);
+  }
+  /**
+   * Resolves once the connection is open. Used by `Room.subscribe`.
+   *
+   * 연결 전에 부른 `subscribe()`를 `closed`로 거절하면 소비자는 "언제 다시
+   * 부를지"를 스스로 알아내야 하고, 첫 connect가 실패했다면 그 때는 영영 오지
+   * 않는다. 붙을 때까지 기다리면 그 신호가 필요 없다. 멈춘 클라이언트(close,
+   * 인증 거절)는 붙을 일이 없으니 거절한다.
+   */
+  whenOpen() {
+    if (this.state === "open" && this.socket !== void 0) return Promise.resolve();
+    if (this.stopped) return Promise.reject(new ChatError("closed", "the connection is closed"));
+    return new Promise((resolve, reject) => void this.openWaiters.push({ resolve, reject }));
+  }
+  openWaiters = [];
+  settleOpenWaiters(err) {
+    const waiters = this.openWaiters;
+    this.openWaiters = [];
+    for (const w of waiters) {
+      if (err === void 0) w.resolve();
+      else w.reject(err);
+    }
   }
   /** Sends a frame and resolves with its ack, or rejects with its error. */
   send(type, data, timeoutMs = 15e3) {
@@ -1139,16 +1327,20 @@ var ChatClient = class extends Emitter {
     this.state = next;
     this.emit("state", next);
   }
-  async openOnce() {
-    this.setState(this.attempt === 0 ? "connecting" : "reconnecting");
+  async openOnce(state = this.attempt === 0 ? "connecting" : "reconnecting") {
+    this.setState(state);
     let authData;
     try {
       authData = await this.authData();
     } catch (err) {
+      if (isChatError(err)) {
+        this.stop(err);
+        throw err;
+      }
       this.scheduleReconnect();
       throw err;
     }
-    if (this.closedByCaller) {
+    if (this.stopped) {
       throw new ChatError("closed", "the client was closed while connecting");
     }
     const socket = new this.makeSocket(`${this.options.url}/v1/ws?v=1`);
@@ -1162,6 +1354,7 @@ var ChatClient = class extends Emitter {
         else reject(err);
       };
       socket.addEventListener("message", (ev) => {
+        if (this.retired.has(socket)) return;
         const frame = JSON.parse(String(ev.data));
         if (frame.type === "hello") {
           this.onHello(frame.data);
@@ -1169,14 +1362,20 @@ var ChatClient = class extends Emitter {
           return;
         }
         if (frame.type === "error" && !settled) {
-          this.closedByCaller = true;
-          this.setState("closed");
-          finish(errorFrom(frame.data));
+          const err = errorFrom(frame.data);
+          if (err.code === "rate_limited" || err.code === "internal") {
+            if (err.retryAfterMs !== void 0 && err.retryAfterMs > 0) this.plannedDelayMs = err.retryAfterMs;
+            finish(err);
+            return;
+          }
+          finish(err);
+          this.stop(err);
           return;
         }
         this.onFrame(frame);
       });
       socket.addEventListener("close", () => {
+        if (this.retired.has(socket)) return;
         if (this.socket !== void 0 && this.socket !== socket) return;
         this.clearTimers();
         this.socket = void 0;
@@ -1204,12 +1403,11 @@ var ChatClient = class extends Emitter {
     const reconnected = this.everOpened;
     this.everOpened = true;
     this.setState("open");
-    if (reconnected) {
-      for (const room of this.handles.values()) {
-        void room.resume().catch((err) => {
-          room.emit("error", err instanceof Error ? err : new Error(String(err)));
-        });
-      }
+    this.settleOpenWaiters();
+    for (const room of this.handles.values()) {
+      void room.resume(reconnected).catch((err) => {
+        room.failed(err);
+      });
     }
   }
   onFrame(frame) {
@@ -1279,7 +1477,7 @@ var ChatClient = class extends Emitter {
     }, Math.max(1e3, intervalMs));
   }
   scheduleReconnect() {
-    if (this.closedByCaller) return;
+    if (this.stopped) return;
     this.setState("reconnecting");
     const delay = this.nextDelay();
     this.retryTimer = setTimeout(() => {
@@ -1331,6 +1529,9 @@ var ChatClient = class extends Emitter {
         const token = await this.options.token();
         this.lastToken = token;
         return token;
+      } catch (err) {
+        if (isChatError(err)) this.stop(err);
+        throw err;
       } finally {
         this.refreshing = void 0;
       }
@@ -1352,6 +1553,9 @@ var ChatClient = class extends Emitter {
     this.retryTimer = void 0;
   }
 };
+function isChatError(err) {
+  return err instanceof ChatError || err instanceof Error && err.name === "ChatError";
+}
 function createChatClient(options) {
   return new ChatClient(options);
 }