@communecter/cocolight-api-client 1.0.141 → 1.0.142

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@communecter/cocolight-api-client",
-    "version": "1.0.141",
+    "version": "1.0.142",
     "description": "Client Axios simplifié pour l'API cocolight",
     "repository": {
         "type": "git",

package/src/api/Notifications.ts

@@ -0,0 +1,196 @@
+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);
+  }
+}

package/src/api/User.ts

@@ -1,5 +1,6 @@
 import { ApiError } from "../error.js";
 import { BaseEntity } from "./BaseEntity.js";
+import { Notifications } from "./Notifications.js";
 import { UserMixin } from "../mixin/UserMixin.js";
 import { createSocialTransform } from "../types/transforms.js";
 
@@ -17,9 +18,14 @@ import type {
   GetOrganizationsNoAdminData,
   GetOrganizationsAdminData,
   GetFriendsAdminData,
-  DemoteAdminData
+  DemoteAdminData,
+  GetNotificationsData,
+  GetNotificationsCountData,
+  NotificationUpdateData,
+  MarkNotificationAsReadData
 } from "./EndpointApi.types.js";
 import type { Organization } from "./Organization.js";
+import type { NotificationItemData } from "./serverDataType/Notification.js";
 import type { EntityTypes } from "@/types/entities.js";
 
 type ApiClient = import("../ApiClient.js").default;
@@ -1717,6 +1723,71 @@ export class User extends BaseEntity<UserItemNormalized> {
     return retour;
   }
 
+  // ===========================================================================
+  // Notifications (sous-ressource de l'utilisateur connecté)
+  // ===========================================================================
+
+  /** Gestionnaire de notifications, créé paresseusement et mis en cache. */
+  private _notifications?: Notifications;
+
+  /**
+   * Point d'entrée `me.notifications` (composition, PAS une entité BaseEntity).
+   * Sûr : endpointApi/apiClient sont initialisés dans le constructeur avant tout accès getter.
+   */
+  get notifications(): Notifications {
+    return (this._notifications ??= new Notifications(this));
+  }
+
+  /**
+   * Récupère les notifications (mode liste). STATELESS + plat (`NotificationItemData[]`),
+   * idéal comme `queryFn` React Query / prefetch SSR — ne touche PAS le manager réactif
+   * (`me.notifications`). `ApiClient._transformData` garantit `notif` = tableau (map -> array
+   * + `id` injecté), donc on fait confiance à la normalisation amont.
+   * pathParams.id est OBLIGATOIRE : le défaut "@userId" ne matche pas le pattern de l'endpoint.
+   */
+  async fetchNotifications({ indexMin }: { indexMin?: number } = {}): Promise<NotificationItemData[]> {
+    const res = (await this.callIsMe(() => {
+      const data: GetNotificationsData = {
+        pathParams: { type: "citoyens", id: this.userId! },
+        ...(indexMin != null ? { indexMin } : {})
+      };
+      return this.endpointApi.getNotifications(data);
+    })) as { notif?: NotificationItemData[] };
+    return Array.isArray(res?.notif) ? res.notif : [];
+  }
+
+  /**
+   * Compte les notifications NON VUES (badge). STATELESS. refreshTimestamp = maintenant ->
+   * le serveur renvoie `countNotif` (total non-vus) + une liste vide.
+   */
+  async fetchNotificationsCount(): Promise<number> {
+    const res = (await this.callIsMe(() => {
+      const data: GetNotificationsCountData = {
+        pathParams: { type: "citoyens", id: this.userId! },
+        refreshTimestamp: Math.floor(Date.now() / 1000)
+      };
+      return this.endpointApi.getNotificationsCount(data);
+    })) as { countNotif?: number };
+    return typeof res?.countNotif === "number" ? res.countNotif : 0;
+  }
+
+  /** Marque une notification comme lue (MARK_NOTIFICATION_AS_READ). */
+  async markNotificationAsRead(id: string): Promise<unknown> {
+    const data: MarkNotificationAsReadData = { id };
+    return this.callIsMe(() => this.endpointApi.markNotificationAsRead(data));
+  }
+
+  /** Marque toutes les notifications comme vues/lues (NOTIFICATION_UPDATE). */
+  async markAllNotifications(action: "seen" | "read"): Promise<unknown> {
+    const data: NotificationUpdateData = { action, all: true };
+    return this.callIsMe(() => this.endpointApi.notificationUpdate(data));
+  }
+
+  /** Supprime toutes les notifications de l'utilisateur (REMOVE_ALL_NOTIFICATIONS). */
+  async removeAllNotifications(): Promise<unknown> {
+    return this.callIsMe(() => this.endpointApi.removeAllNotifications());
+  }
+
 }
 
 // Incorporation des mixins dans User

package/src/api/serverDataType/Notification.ts

@@ -0,0 +1,81 @@
+import type { DateValue, IdObject } from "./common.js";
+import type EJSONType from "../../EJSONType.js";
+
+// L'_id peut arriver sous 3 formes selon le chemin d'appel :
+//  - instance ObjectID (transform + _fromJSONValue actif — cas observé sur User.getNotifications)
+//  - { $id } (forme normalisée non-revivée)
+//  - string hex (24)
+type ObjectIDInstance = InstanceType<typeof EJSONType["ObjectID"]>;
+export type NotificationId = ObjectIDInstance | IdObject | string;
+
+/** Auteur APRÈS aplatissement par _transformData (la map oid->objet devient un objet). */
+export interface NotificationAuthor {
+  id?: string;
+  type?: string;
+  name: string;
+  profilThumbImageUrl?: string; // complété en URL absolue par la normalisation image
+  [k: string]: unknown;
+}
+
+export interface NotificationTarget {
+  type: string;
+  id: string;
+  parent?: { id: string; type: string };
+}
+
+/** État lu/vu, par destinataire. Un champ ABSENT (clé unset côté serveur) = état "faux". */
+export interface NotificationReadState {
+  isUnread?: boolean;
+  isUnseen?: boolean;
+}
+
+export interface NotificationNotify {
+  objectType?: string;
+  /** keyé par oid de destinataire -> état lu/vu de CE destinataire. */
+  id: Record<string, NotificationReadState>;
+  displayName?: string;
+  icon?: string;
+  url?: string;
+  label?: string;
+  labelArray?: Record<string, string[]>;
+  labelAuthorObject?: string;
+  repeat?: boolean;
+  [k: string]: unknown;
+}
+
+/** Un élément du tableau `notif` (forme transformée). created/updated : Date instance OU {sec,usec}. */
+export interface NotificationItemData {
+  id: string;                 // injecté depuis la clé de la map notif (= oid hex)
+  _id: NotificationId;
+  type: string;
+  verb: string;
+  author: NotificationAuthor;
+  created: Date | DateValue;
+  updated: Date | DateValue;
+  target: NotificationTarget;
+  notify: NotificationNotify;
+  timestamp?: number;         // ajouté serveur (= updated.sec)
+  timeAgo?: string;           // présent en brut, retiré au transform
+  [k: string]: unknown;
+}
+
+/**
+ * Réponse de GET_NOTIFICATIONS (mode liste, body indexMin) APRÈS transform :
+ * `notif` est un tableau (la map oid->item est convertie). Vide => [].
+ */
+export interface GetNotificationsResult {
+  notif: NotificationItemData[];
+  [k: string]: unknown;
+}
+
+/**
+ * Réponse de GET_NOTIFICATIONS_COUNT (mode badge, body refreshTimestamp non-nul) :
+ * `notif` = notifications mises à jour APRÈS le timestamp (souvent [] si timestamp = maintenant),
+ * `countNotif` = nombre TOTAL de notifications NON VUES (isUnseen) — indépendant du timestamp.
+ * countNotif n'est présent QUE si refreshTimestamp est fourni et non-nul (sinon mode liste).
+ */
+export interface GetNotificationsCountResult {
+  notif: NotificationItemData[];
+  countNotif?: number;
+  [k: string]: unknown;
+}

package/src/index.ts

@@ -41,6 +41,9 @@ const cocolightApiClient = {
 
 export default cocolightApiClient;
 
+// Helpers réactifs en exports nommés (permet `import { effect, subscribeTo } from "..."`)
+export { batch, computed, effect, getSignals, isReactive, isSignal, reactive, subscribeTo, watch } from "./utils/reactive.js";
+
 // Export des types pour faciliter l'utilisation
 
 // Classes principales
@@ -101,6 +104,10 @@ export type * from "./api/serverDataType/Action.js";
 export type * from "./api/serverDataType/common.js";
 export type * from "./api/serverDataType/Country.js";
 export type * from "./api/serverDataType/Zone.js";
+export type * from "./api/serverDataType/Notification.js";
+
+// Classes notifications (type-only, comme les entités) — instances obtenues via me.notifications
+export type { Notification, Notifications } from "./api/Notifications.js";
 
 // Types utilitaires BaseEntity
 export type {

package/types/api/Notifications.d.ts

@@ -0,0 +1,79 @@
+import type { NotificationAuthor, NotificationItemData } from "./serverDataType/Notification.js";
+type User = import("./User.js").User;
+/**
+ * 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 declare class Notification {
+    private readonly _data;
+    private readonly _owner;
+    private _manager;
+    private readonly _state;
+    constructor(data: NotificationItemData, owner: User, manager?: Notifications | null);
+    static fromData(data: NotificationItemData, owner: User, manager?: Notifications | null): Notification;
+    /** Lie l'item à son manager (appelé par le manager au wrap). */
+    _attach(manager: Notifications): this;
+    get id(): string;
+    get isUnread(): boolean;
+    get isUnseen(): boolean;
+    get data(): NotificationItemData;
+    get author(): NotificationAuthor;
+    get createdAt(): Date;
+    _setReadLocal(): void;
+    _setSeenLocal(): void;
+    _restoreLocal(unread: boolean, unseen: boolean): void;
+    /** Marque CET item comme lu : optimiste + rollback + recount manager. */
+    markRead(): Promise<void>;
+    /** Pas d'endpoint "seen" par item : flip local uniquement. */
+    markSeen(): void;
+    toJSON(): NotificationItemData;
+}
+/**
+ * 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 declare class Notifications {
+    private readonly _owner;
+    private readonly _pageSize;
+    private _items;
+    private readonly _state;
+    constructor(owner: User, pageSize?: number);
+    get items(): Notification[];
+    get loadedUnreadCount(): number;
+    get unseenTotal(): number;
+    get hasMore(): boolean;
+    _recount(): void;
+    private _wrap;
+    private _commit;
+    /** Première page (reset le curseur). Tri serveur : updated desc, 15/page. */
+    list({ indexMin }?: {
+        indexMin?: number;
+    }): Promise<Notification[]>;
+    /** Page suivante (curseur indexMin = nb d'items déjà chargés). Concatène par réassignation. */
+    loadMore(): Promise<Notification[]>;
+    /** Recharge depuis le début. */
+    refresh(): Promise<Notification[]>;
+    /**
+     * Badge : total des NON-VUS via GET_NOTIFICATIONS_COUNT (refreshTimestamp = maintenant ->
+     * liste vide + countNotif). Met à jour unseenTotal et le retourne.
+     */
+    count(): Promise<number>;
+    /**
+     * 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[];
+    markAllRead(): Promise<void>;
+    markAllSeen(): Promise<void>;
+    private _bulk;
+    /** Supprime toutes les notifications de l'utilisateur + vide l'état local. */
+    clear(): Promise<void>;
+    toJSON(): NotificationItemData[];
+    restore(rawItems: NotificationItemData[]): this;
+    static restore(rawItems: NotificationItemData[], owner: User): Notifications;
+}
+export {};

package/types/api/User.d.ts

@@ -1,8 +1,10 @@
 import { BaseEntity } from "./BaseEntity.js";
+import { Notifications } from "./Notifications.js";
 import type { Badge } from "./Badge.js";
 import type { PaginatorPage, PaginatorState } from "./BaseEntity.js";
 import type { ChangePasswordData, DeleteAccountData, GetSubscriptionsAdminData, GetSubscriptionsData, GetOrganizationsNoAdminData, GetOrganizationsAdminData, GetFriendsAdminData } from "./EndpointApi.types.js";
 import type { Organization } from "./Organization.js";
+import type { NotificationItemData } from "./serverDataType/Notification.js";
 import type { EntityTypes } from "@/types/entities.js";
 type ApiClient = import("../ApiClient.js").default;
 type UserItemNormalized = import("./serverDataType/User.js").UserItemNormalized;
@@ -786,5 +788,33 @@ export declare class User extends BaseEntity<UserItemNormalized> {
      * ```
      */
     demoteFromAdmin(): Promise<unknown>;
+    /** Gestionnaire de notifications, créé paresseusement et mis en cache. */
+    private _notifications?;
+    /**
+     * Point d'entrée `me.notifications` (composition, PAS une entité BaseEntity).
+     * Sûr : endpointApi/apiClient sont initialisés dans le constructeur avant tout accès getter.
+     */
+    get notifications(): Notifications;
+    /**
+     * Récupère les notifications (mode liste). STATELESS + plat (`NotificationItemData[]`),
+     * idéal comme `queryFn` React Query / prefetch SSR — ne touche PAS le manager réactif
+     * (`me.notifications`). `ApiClient._transformData` garantit `notif` = tableau (map -> array
+     * + `id` injecté), donc on fait confiance à la normalisation amont.
+     * pathParams.id est OBLIGATOIRE : le défaut "@userId" ne matche pas le pattern de l'endpoint.
+     */
+    fetchNotifications({ indexMin }?: {
+        indexMin?: number;
+    }): Promise<NotificationItemData[]>;
+    /**
+     * Compte les notifications NON VUES (badge). STATELESS. refreshTimestamp = maintenant ->
+     * le serveur renvoie `countNotif` (total non-vus) + une liste vide.
+     */
+    fetchNotificationsCount(): Promise<number>;
+    /** Marque une notification comme lue (MARK_NOTIFICATION_AS_READ). */
+    markNotificationAsRead(id: string): Promise<unknown>;
+    /** Marque toutes les notifications comme vues/lues (NOTIFICATION_UPDATE). */
+    markAllNotifications(action: "seen" | "read"): Promise<unknown>;
+    /** Supprime toutes les notifications de l'utilisateur (REMOVE_ALL_NOTIFICATIONS). */
+    removeAllNotifications(): Promise<unknown>;
 }
 export {};

package/types/api/serverDataType/Notification.d.ts

@@ -0,0 +1,73 @@
+import type { DateValue, IdObject } from "./common.js";
+import type EJSONType from "../../EJSONType.js";
+type ObjectIDInstance = InstanceType<typeof EJSONType["ObjectID"]>;
+export type NotificationId = ObjectIDInstance | IdObject | string;
+/** Auteur APRÈS aplatissement par _transformData (la map oid->objet devient un objet). */
+export interface NotificationAuthor {
+    id?: string;
+    type?: string;
+    name: string;
+    profilThumbImageUrl?: string;
+    [k: string]: unknown;
+}
+export interface NotificationTarget {
+    type: string;
+    id: string;
+    parent?: {
+        id: string;
+        type: string;
+    };
+}
+/** État lu/vu, par destinataire. Un champ ABSENT (clé unset côté serveur) = état "faux". */
+export interface NotificationReadState {
+    isUnread?: boolean;
+    isUnseen?: boolean;
+}
+export interface NotificationNotify {
+    objectType?: string;
+    /** keyé par oid de destinataire -> état lu/vu de CE destinataire. */
+    id: Record<string, NotificationReadState>;
+    displayName?: string;
+    icon?: string;
+    url?: string;
+    label?: string;
+    labelArray?: Record<string, string[]>;
+    labelAuthorObject?: string;
+    repeat?: boolean;
+    [k: string]: unknown;
+}
+/** Un élément du tableau `notif` (forme transformée). created/updated : Date instance OU {sec,usec}. */
+export interface NotificationItemData {
+    id: string;
+    _id: NotificationId;
+    type: string;
+    verb: string;
+    author: NotificationAuthor;
+    created: Date | DateValue;
+    updated: Date | DateValue;
+    target: NotificationTarget;
+    notify: NotificationNotify;
+    timestamp?: number;
+    timeAgo?: string;
+    [k: string]: unknown;
+}
+/**
+ * Réponse de GET_NOTIFICATIONS (mode liste, body indexMin) APRÈS transform :
+ * `notif` est un tableau (la map oid->item est convertie). Vide => [].
+ */
+export interface GetNotificationsResult {
+    notif: NotificationItemData[];
+    [k: string]: unknown;
+}
+/**
+ * Réponse de GET_NOTIFICATIONS_COUNT (mode badge, body refreshTimestamp non-nul) :
+ * `notif` = notifications mises à jour APRÈS le timestamp (souvent [] si timestamp = maintenant),
+ * `countNotif` = nombre TOTAL de notifications NON VUES (isUnseen) — indépendant du timestamp.
+ * countNotif n'est présent QUE si refreshTimestamp est fourni et non-nul (sinon mode liste).
+ */
+export interface GetNotificationsCountResult {
+    notif: NotificationItemData[];
+    countNotif?: number;
+    [k: string]: unknown;
+}
+export {};

package/types/index.d.ts

@@ -37,6 +37,7 @@ declare const cocolightApiClient: {
     OfflineClientManager: typeof OfflineClientManager;
 };
 export default cocolightApiClient;
+export { batch, computed, effect, getSignals, isReactive, isSignal, reactive, subscribeTo, watch } from "./utils/reactive.js";
 export type { default as Api } from "./Api.js";
 export type { default as ApiClient } from "./ApiClient.js";
 export type { default as EndpointApi } from "./api/EndpointApi.js";
@@ -78,6 +79,8 @@ export type * from "./api/serverDataType/Action.js";
 export type * from "./api/serverDataType/common.js";
 export type * from "./api/serverDataType/Country.js";
 export type * from "./api/serverDataType/Zone.js";
+export type * from "./api/serverDataType/Notification.js";
+export type { Notification, Notifications } from "./api/Notifications.js";
 export type { PaginatorPage, PaginatorState, FundingEnvelopeResult, FundingEnvelopeProjectItem, SearchCostumVariant, SetTypeValue, CostumContextFields, WithCostumContext, EntityType, CoformThematicValue, CoformFilterByPathResult, } from "./api/BaseEntity.js";
 export { UPDATE_PATH_MAGIC } from "./api/BaseEntity.js";
 export type { AllStepsData, PendingUploadValue, PendingUpload, ProcessUploadsOptions, AnswerGetOptions, UploadAnswerFileOptions, UploadAnswerFileResult, GetFilesOptions, AnswerFileItem, } from "./api/Answer.js";