@noverachat/sdk-react 0.3.0

package/src/room-list-store.ts

@@ -0,0 +1,227 @@
+import type {
+  MemberPreview,
+  NoveraChat,
+  UnreadRoomItem,
+  WsChatReceive,
+} from "@noverachat/sdk-web";
+
+/**
+ * One row of a chat-room list screen.
+ *
+ * A live-updatable view over `UnreadRoomItem`: same fields, plus
+ * `lastMessageAtMs` which is filled from realtime messages as they arrive
+ * (the initial REST load doesn't carry a timestamp yet) and
+ * `anyMemberOnline` for the green presence dot.
+ */
+export interface RoomListItem {
+  roomId: string;
+  name: string | null;
+  roomType: string | null;
+  unreadCount: number;
+  lastMessageId: string | null;
+  lastMessagePreview: string | null;
+  memberCount: number;
+  members: MemberPreview[];
+  /** unix ms of the last message — filled from realtime frames onward. */
+  lastMessageAtMs: number | null;
+  /** Green dot — true when any preview member is online (as of the last
+   *  list load). */
+  anyMemberOnline: boolean;
+}
+
+function itemFromUnread(r: UnreadRoomItem): RoomListItem {
+  const members = r.membersPreview ?? [];
+  return {
+    roomId: r.roomId,
+    name: r.name,
+    roomType: r.roomType ?? null,
+    unreadCount: r.unreadCount,
+    lastMessageId: r.lastMessageId ?? null,
+    lastMessagePreview: r.lastMessagePreview ?? null,
+    memberCount: r.memberCount ?? 0,
+    members,
+    lastMessageAtMs: null,
+    anyMemberOnline: members.some((m) => m.isOnline === true),
+  };
+}
+
+export interface RoomListSnapshot {
+  /** Rooms, most-recently-active first. */
+  rooms: RoomListItem[];
+  /** Sum of every room's unread badge (for a bottom-tab badge). */
+  totalUnread: number;
+}
+
+export interface RoomListStoreOptions {
+  /** Incoming message → list preview string. Default: `content`, or "📎"
+   *  for file messages. */
+  previewBuilder?: (m: WsChatReceive) => string;
+  /** Return true while the user is looking at the given room, so its new
+   *  messages don't bump the badge (the room screen's `markRead` owns the
+   *  read state then). */
+  isRoomVisible?: (roomId: string) => boolean;
+}
+
+/**
+ * Chat-room list state — the data behind a KakaoTalk-style "채팅" tab.
+ *
+ * Loads the room list from `chat.unreadSummary()` (rooms come back
+ * most-recently-active first) and keeps it live:
+ *   - a new message in any room bumps that room to the top, replaces its
+ *     preview, and (unless `isRoomVisible` says the user is looking at it)
+ *     increments its unread badge;
+ *   - room membership events and cross-device read syncs trigger a
+ *     debounced reload.
+ *
+ * When coming back from a room screen, call `markRead(roomId)` to clear
+ * the badge. Previews of the user's own sends are picked up by the reload
+ * on return (`load()` is idempotent-safe to call again).
+ */
+export class RoomListStore {
+  private readonly chat: NoveraChat;
+  private readonly opts: RoomListStoreOptions;
+  private readonly listeners = new Set<() => void>();
+
+  private rooms: RoomListItem[] = [];
+  private index = new Map<string, number>(); // roomId → rooms position
+  private roomSubs: Array<() => void> = [];
+  private clientSub: (() => void) | null = null;
+  private reloadTimer: ReturnType<typeof setTimeout> | null = null;
+  private snapshot: RoomListSnapshot = { rooms: [], totalUnread: 0 };
+  private attached = false;
+
+  constructor(chat: NoveraChat, opts: RoomListStoreOptions = {}) {
+    this.chat = chat;
+    this.opts = opts;
+  }
+
+  /** Subscribe to client-level room events. Idempotent. */
+  attach(): void {
+    if (this.attached) return;
+    this.attached = true;
+    // 방 생성·초대·강퇴 등 멤버십 변화 → 목록 자체가 달라질 수 있으니 reload
+    this.clientSub = this.chat.on("roomEvent", () => this.scheduleReload());
+  }
+
+  /** Unsubscribe everything (list state is kept for a later `attach`). */
+  dispose(): void {
+    if (!this.attached) return;
+    this.attached = false;
+    if (this.reloadTimer) clearTimeout(this.reloadTimer);
+    this.reloadTimer = null;
+    for (const u of this.roomSubs.splice(0)) u();
+    this.clientSub?.();
+    this.clientSub = null;
+  }
+
+  // ── external-store contract ─────────────────────────────────────
+
+  readonly subscribe = (fn: () => void): (() => void) => {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  };
+
+  readonly getSnapshot = (): RoomListSnapshot => this.snapshot;
+
+  private emit(): void {
+    this.snapshot = {
+      rooms: [...this.rooms],
+      totalUnread: this.rooms.reduce((n, r) => n + r.unreadCount, 0),
+    };
+    for (const fn of this.listeners) fn();
+  }
+
+  // ── actions ─────────────────────────────────────────────────────
+
+  /** Reload the room list and re-hook the realtime subscriptions. */
+  async load(): Promise<void> {
+    const summary = await this.chat.unreadSummary();
+    if (!this.attached) return;
+    this.rooms = summary.rooms.map(itemFromUnread);
+    this.reindex();
+    this.resubscribe();
+    this.emit();
+  }
+
+  /** Hide a room (카톡 "숨기기") — optimistically remove it from the list
+   *  and send `hide` to the server. On failure the next `load` brings it
+   *  back; new activity may re-surface it per server policy (arrives via
+   *  roomEvent → reload). */
+  async hideRoom(roomId: string): Promise<void> {
+    const i = this.index.get(roomId);
+    if (i !== undefined) {
+      this.rooms.splice(i, 1);
+      this.reindex();
+      this.emit();
+    }
+    await this.chat.room(roomId).hide();
+  }
+
+  /** Undo `hideRoom` — send `unhide` and reload the list. */
+  async unhideRoom(roomId: string): Promise<void> {
+    await this.chat.room(roomId).unhide();
+    await this.load();
+  }
+
+  /** Mark a room read — drop its badge to 0 and advance the client's
+   *  last-seen watermark. */
+  markRead(roomId: string): void {
+    const i = this.index.get(roomId);
+    if (i === undefined) return;
+    const item = this.rooms[i]!;
+    if (item.lastMessageId) this.chat.setLastSeen(roomId, item.lastMessageId);
+    if (item.unreadCount !== 0) {
+      this.rooms[i] = { ...item, unreadCount: 0 };
+      this.emit();
+    }
+  }
+
+  // ── internals ───────────────────────────────────────────────────
+
+  private reindex(): void {
+    this.index = new Map(this.rooms.map((r, i) => [r.roomId, i]));
+  }
+
+  private resubscribe(): void {
+    for (const u of this.roomSubs.splice(0)) u();
+    for (const item of this.rooms) {
+      const room = this.chat.room(item.roomId);
+      this.roomSubs.push(
+        room.on("message", (m) => this.onIncoming(item.roomId, m)),
+        room.on("syncTick", () => this.scheduleReload()),
+        room.on("messagesCleared", () => this.scheduleReload()),
+      );
+    }
+  }
+
+  private onIncoming(roomId: string, m: WsChatReceive): void {
+    const i = this.index.get(roomId);
+    if (i === undefined) return;
+    const cur = this.rooms[i]!;
+    const visible = this.opts.isRoomVisible?.(roomId) ?? false;
+    const preview =
+      this.opts.previewBuilder?.(m) ??
+      m.content ??
+      (m.file_id || m.file || (m.files && m.files.length > 0) ? "📎" : "");
+    const updated: RoomListItem = {
+      ...cur,
+      unreadCount: visible ? cur.unreadCount : cur.unreadCount + 1,
+      lastMessageId: m.message_id,
+      lastMessagePreview: preview,
+      lastMessageAtMs: m.created_at,
+    };
+    // Bump the active room to the top.
+    this.rooms.splice(i, 1);
+    this.rooms.unshift(updated);
+    this.reindex();
+    this.emit();
+  }
+
+  private scheduleReload(): void {
+    if (this.reloadTimer) clearTimeout(this.reloadTimer);
+    this.reloadTimer = setTimeout(() => {
+      this.reloadTimer = null;
+      if (this.attached) void this.load();
+    }, 500);
+  }
+}

package/src/room-settings-store.ts

@@ -0,0 +1,200 @@
+import type {
+  InviteToken,
+  JoinRequestOut,
+  NoveraChat,
+  PushTrigger,
+  Room,
+} from "@noverachat/sdk-web";
+
+export interface RoomSettingsSnapshot {
+  /** Invite tokens minted for this room (operator view), newest first.
+   *  Empty until `loadInvites`. */
+  invites: InviteToken[];
+  /** Pending join requests (operator inbox). Empty until
+   *  `loadJoinRequests`. */
+  joinRequests: JoinRequestOut[];
+}
+
+/**
+ * Actions and state behind a room-settings screen (대화방 설정): per-room
+ * mute, invite links, join-request inbox, leave / clear-history, and
+ * operator moderation.
+ *
+ * Mostly a thin, typed facade over `Room`'s one-shot REST calls — the only
+ * held state is the invite / join-request lists. Read the caller's
+ * *current* push trigger from their own row in `MemberListStore` (the
+ * server has no standalone "get my settings" endpoint).
+ */
+export class RoomSettingsStore {
+  private readonly chat: NoveraChat;
+  readonly roomId: string;
+  private readonly listeners = new Set<() => void>();
+
+  private invites: InviteToken[] = [];
+  private joinRequests: JoinRequestOut[] = [];
+  private attached = false;
+  private snapshot: RoomSettingsSnapshot = { invites: [], joinRequests: [] };
+
+  constructor(chat: NoveraChat, roomId: string) {
+    this.chat = chat;
+    this.roomId = roomId;
+  }
+
+  private get room(): Room {
+    return this.chat.room(this.roomId);
+  }
+
+  /** No realtime subscriptions — kept for lifecycle symmetry with the
+   *  other stores (guards in-flight results after unmount). */
+  attach(): void {
+    this.attached = true;
+  }
+
+  dispose(): void {
+    this.attached = false;
+  }
+
+  // ── external-store contract ─────────────────────────────────────
+
+  readonly subscribe = (fn: () => void): (() => void) => {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  };
+
+  readonly getSnapshot = (): RoomSettingsSnapshot => this.snapshot;
+
+  private emit(): void {
+    this.snapshot = {
+      invites: [...this.invites],
+      joinRequests: [...this.joinRequests],
+    };
+    for (const fn of this.listeners) fn();
+  }
+
+  // ── notifications ───────────────────────────────────────────────
+
+  /** Convenience mute toggle: `true` → `OFF`, `false` → `ALL`. */
+  setMuted(muted: boolean): Promise<void> {
+    return this.room.setPushTrigger(muted ? "OFF" : "ALL");
+  }
+
+  /** Fine-grained per-room push trigger: `ALL` | `MENTION_ONLY` | `OFF`. */
+  setPushTrigger(trigger: PushTrigger): Promise<void> {
+    return this.room.setPushTrigger(trigger);
+  }
+
+  // ── invite links ────────────────────────────────────────────────
+
+  /** Fetch the invite list (operator-only server-side). */
+  async loadInvites(): Promise<void> {
+    const list = await this.room.listInvites();
+    if (!this.attached) return;
+    this.invites = list;
+    this.emit();
+  }
+
+  /** Mint a new invite link and prepend it to `invites`. */
+  async createInvite(opts?: {
+    expiresInHours?: number | null;
+    maxUses?: number | null;
+  }): Promise<InviteToken> {
+    const token = await this.room.createInvite(opts);
+    if (this.attached) {
+      this.invites = [token, ...this.invites];
+      this.emit();
+    }
+    return token;
+  }
+
+  /** Revoke a token and drop it from `invites`. */
+  async revokeInvite(token: string): Promise<void> {
+    await this.room.revokeInvite(token);
+    if (this.attached) {
+      this.invites = this.invites.filter((t) => t.token !== token);
+      this.emit();
+    }
+  }
+
+  // ── join requests (operator inbox) ──────────────────────────────
+
+  /** Fetch pending join requests (operator-only server-side). */
+  async loadJoinRequests(): Promise<void> {
+    const page = await this.room.listJoinRequests();
+    if (!this.attached) return;
+    this.joinRequests = page.items;
+    this.emit();
+  }
+
+  /** Approve a pending request and drop it from `joinRequests`. */
+  async approveJoinRequest(userId: string, reason?: string): Promise<void> {
+    await this.room.approveJoinRequest(userId, reason);
+    if (this.attached) {
+      this.joinRequests = this.joinRequests.filter((r) => r.userId !== userId);
+      this.emit();
+    }
+  }
+
+  /** Reject a pending request and drop it from `joinRequests`. */
+  async rejectJoinRequest(userId: string, reason?: string): Promise<void> {
+    await this.room.rejectJoinRequest(userId, reason);
+    if (this.attached) {
+      this.joinRequests = this.joinRequests.filter((r) => r.userId !== userId);
+      this.emit();
+    }
+  }
+
+  // ── history / membership ────────────────────────────────────────
+
+  /** Per-user "clear chat" — hides existing messages for the caller only. */
+  clearHistory(): Promise<void> {
+    return this.room.clearHistory();
+  }
+
+  /** Leave the room. `deleteMessages`: `"none"` (default) | `"mine"` |
+   *  `"all"` — see `Room.leave`. */
+  leave(options?: { deleteMessages?: "none" | "mine" | "all" }): Promise<void> {
+    return this.room.leave(options);
+  }
+
+  /** Delete every message the caller sent (without leaving). Returns the
+   *  cleared count. */
+  async deleteMyMessages(): Promise<number> {
+    const r = await this.room.deleteMyMessages();
+    return r.cleared;
+  }
+
+  // ── operator moderation ─────────────────────────────────────────
+
+  /** **Destructive, operator-only** — wipe every message in the room. */
+  deleteAllMessages(): Promise<{
+    cleared: number;
+    upToMessageId: string | null;
+  }> {
+    return this.room.deleteAllMessages();
+  }
+
+  /** Operator: block non-operator sends (`ROOM_FROZEN` server-side). */
+  freeze(): Promise<void> {
+    return this.room.freeze();
+  }
+
+  /** Operator: reopen the room to sends. */
+  unfreeze(): Promise<void> {
+    return this.room.unfreeze();
+  }
+
+  /** Operator: toggle open-chat visibility. */
+  setPublic(isPublic: boolean): Promise<void> {
+    return this.room.setPublic(isPublic);
+  }
+
+  /** Operator: mute a member (`durationMinutes` null → indefinite). */
+  muteMember(userId: string, durationMinutes: number | null): Promise<void> {
+    return this.room.muteMember(userId, durationMinutes);
+  }
+
+  /** Operator: clear a member's mute. */
+  unmuteMember(userId: string): Promise<void> {
+    return this.room.unmuteMember(userId);
+  }
+}