@communecter/cocolight-api-client 1.0.155 → 1.0.157

package/src/api/Notifications.ts

@@ -1,196 +0,0 @@
-import { batch, reactive } from "../utils/reactive.js";
-
-import type {
-  NotificationAuthor,
-  NotificationItemData
-} from "./serverDataType/Notification.js";
-
-type User = import("./User.js").User; // backref ; User porte __entityTag donc non proxifié par reactive()
-
-/** Taille de page côté serveur (ActivityStream::getNotificationsByStep indexStep=15). */
-const DEFAULT_PAGE_SIZE = 15;
-
-/** isUnread/isUnseen de CE destinataire (le serveur unset la clé quand lu/vu -> absence = faux). */
-function stateFor(data: NotificationItemData, userId: string | null, key: "isUnread" | "isUnseen"): boolean {
-  if (!userId) return false;
-  return data?.notify?.id?.[userId]?.[key] === true;
-}
-
-/**
- * Item de notification fin. N'étend PAS BaseEntity : il garde la donnée brute, un backref
- * User (pour router les appels via callIsMe + endpointApi) et un backref manager (pour le recount).
- * Les drapeaux lu/vu sont réactifs (objet reactive({...}) — surface scalaire fiable).
- */
-export class Notification {
-  private readonly _data: NotificationItemData;
-  private readonly _owner: User;
-  private _manager: Notifications | null;
-  private readonly _state: { isUnread: boolean; isUnseen: boolean };
-
-  constructor(data: NotificationItemData, owner: User, manager: Notifications | null = null) {
-    this._data = data;
-    this._owner = owner;
-    this._manager = manager;
-    const uid = owner.userId;
-    this._state = reactive({
-      isUnread: stateFor(data, uid, "isUnread"),
-      isUnseen: stateFor(data, uid, "isUnseen")
-    });
-  }
-
-  static fromData(data: NotificationItemData, owner: User, manager: Notifications | null = null): Notification {
-    return new Notification(data, owner, manager);
-  }
-
-  /** Lie l'item à son manager (appelé par le manager au wrap). */
-  _attach(manager: Notifications): this { this._manager = manager; return this; }
-
-  get id(): string { return this._data.id; }   // injecté par ApiClient._transformData (clé de la map = hex)
-  get isUnread(): boolean { return this._state.isUnread; }   // lecture réactive
-  get isUnseen(): boolean { return this._state.isUnseen; }
-  get data(): NotificationItemData { return this._data; }
-  get author(): NotificationAuthor { return this._data.author; }
-  get createdAt(): Date {
-    // ApiClient._transformData rend `created` en Date. La string ISO survient après un
-    // round-trip toJSON()->JSON.parse->restore(). On fait confiance à la normalisation amont.
-    const c = this._data.created;
-    return c instanceof Date ? c : new Date(c as string | number);
-  }
-
-  // setters locaux (utilisés par l'optimiste, sans appel réseau)
-  _setReadLocal(): void { this._state.isUnread = false; }
-  _setSeenLocal(): void { this._state.isUnseen = false; }
-  _restoreLocal(unread: boolean, unseen: boolean): void { this._state.isUnread = unread; this._state.isUnseen = unseen; }
-
-  /** Marque CET item comme lu : optimiste + rollback + recount manager. */
-  async markRead(): Promise<void> {
-    if (!this._state.isUnread) return;
-    const pu = this._state.isUnread, ps = this._state.isUnseen;
-    this._setReadLocal();
-    this._manager?._recount();
-    try {
-      await this._owner.markNotificationAsRead(this.id);
-    } catch (err) {
-      this._restoreLocal(pu, ps);
-      this._manager?._recount();
-      throw err;
-    }
-  }
-
-  /** Pas d'endpoint "seen" par item : flip local uniquement. */
-  markSeen(): void { this._setSeenLocal(); this._manager?._recount(); }
-
-  toJSON(): NotificationItemData { return this._data; }
-}
-
-/**
- * Gestionnaire de notifications de l'utilisateur connecté. Accroché à User via `me.notifications`.
- * N'étend PAS BaseEntity. Items dans un tableau SIMPLE (jamais proxifié) ; seuls les scalaires
- * vivent dans un reactive({...}) (loadedUnreadCount, unseenTotal, cursor, hasMore, version).
- * Aucun effect/computed créé ici (pas d'API de dispose -> pas de fuite).
- */
-export class Notifications {
-  private readonly _owner: User;
-  private readonly _pageSize: number;
-  private _items: Notification[] = [];
-  private readonly _state: {
-    loadedUnreadCount: number;   // non-lus PARMI les items chargés (dérivé)
-    unseenTotal: number;         // total NON-VUS côté serveur (countNotif) — badge cloche
-    cursor: number;              // offset indexMin (nb d'items déjà chargés)
-    hasMore: boolean;
-    version: number;             // bump à chaque mutation de liste -> réactivité de `items`
-  };
-
-  constructor(owner: User, pageSize: number = DEFAULT_PAGE_SIZE) {
-    this._owner = owner;
-    this._pageSize = pageSize;
-    this._state = reactive({ loadedUnreadCount: 0, unseenTotal: 0, cursor: 0, hasMore: true, version: 0 });
-  }
-
-  // surface réactive consommateur
-  get items(): Notification[] { void this._state.version; return this._items; }
-  get loadedUnreadCount(): number { return this._state.loadedUnreadCount; }
-  get unseenTotal(): number { return this._state.unseenTotal; }   // badge "non vus"
-  get hasMore(): boolean { return this._state.hasMore; }
-
-  _recount(): void { this._state.loadedUnreadCount = this._items.filter((n) => n.isUnread).length; }
-  private _wrap(raw: NotificationItemData[]): Notification[] { return raw.map((d) => Notification.fromData(d, this._owner, this)); }
-  private _commit(items: Notification[]): void { this._items = items; this._state.version++; this._recount(); }
-
-  /** Première page (reset le curseur). Tri serveur : updated desc, 15/page. */
-  async list({ indexMin = 0 }: { indexMin?: number } = {}): Promise<Notification[]> {
-    const next = this._wrap(await this._owner.fetchNotifications({ indexMin }));
-    this._commit(next);
-    this._state.cursor = next.length;
-    this._state.hasMore = next.length >= this._pageSize;
-    return next;
-  }
-
-  /** Page suivante (curseur indexMin = nb d'items déjà chargés). Concatène par réassignation. */
-  async loadMore(): Promise<Notification[]> {
-    if (!this._state.hasMore) return [];
-    const page = this._wrap(await this._owner.fetchNotifications({ indexMin: this._state.cursor }));
-    this._commit([...this._items, ...page]);
-    this._state.cursor += page.length;
-    this._state.hasMore = page.length >= this._pageSize;
-    return page;
-  }
-
-  /** Recharge depuis le début. */
-  async refresh(): Promise<Notification[]> { this._state.cursor = 0; this._state.hasMore = true; return this.list(); }
-
-  /**
-   * Badge : total des NON-VUS via GET_NOTIFICATIONS_COUNT (refreshTimestamp = maintenant ->
-   * liste vide + countNotif). Met à jour unseenTotal et le retourne.
-   */
-  async count(): Promise<number> {
-    this._state.unseenTotal = await this._owner.fetchNotificationsCount();
-    return this._state.unseenTotal;
-  }
-
-  /**
-   * PUR : convertit des `NotificationItemData[]` plats (ex. cache React Query après
-   * hydratation SSR) en `Notification[]` liées à l'utilisateur, SANS modifier l'état du
-   * manager. À utiliser dans un `select` React Query (cache plat -> instances vivantes).
-   */
-  toItems(data: NotificationItemData[]): Notification[] {
-    return this._wrap(data);
-  }
-
-  async markAllRead(): Promise<void> { await this._bulk("read"); }
-  async markAllSeen(): Promise<void> { await this._bulk("seen"); }
-
-  private async _bulk(action: "seen" | "read"): Promise<void> {
-    const snap = this._items.map((n) => ({ n, u: n.isUnread, s: n.isUnseen }));
-    batch(() => { for (const { n } of snap) { if (action === "read") n._setReadLocal(); else n._setSeenLocal(); } });
-    if (action === "seen") this._state.unseenTotal = 0;
-    this._recount();
-    try {
-      await this._owner.markAllNotifications(action);
-    } catch (err) {
-      batch(() => { for (const { n, u, s } of snap) n._restoreLocal(u, s); });
-      this._recount();
-      throw err;
-    }
-  }
-
-  /** Supprime toutes les notifications de l'utilisateur + vide l'état local. */
-  async clear(): Promise<void> {
-    await this._owner.removeAllNotifications();
-    this._commit([]);
-    this._state.cursor = 0;
-    this._state.hasMore = false;
-    this._state.unseenTotal = 0;
-  }
-
-  // sérialisation (donnée brute ; le backref owner + l'état réactif sont re-construits au restore)
-  toJSON(): NotificationItemData[] { return this._items.map((n) => n.toJSON()); }
-  restore(rawItems: NotificationItemData[]): this {
-    this._commit(this._wrap(rawItems));
-    this._state.cursor = rawItems.length;
-    return this;
-  }
-  static restore(rawItems: NotificationItemData[], owner: User): Notifications {
-    return new Notifications(owner).restore(rawItems);
-  }
-}