@communecter/cocolight-api-client 1.0.141 → 1.0.143

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/Organization.ts

@@ -173,13 +173,16 @@ export class Organization extends BaseEntity<OrganizationItemNormalized> {
     if (rawAnswers && typeof rawAnswers === "object") {
       const linkedAnswers: Record<string, unknown[]> = {};
       for (const [formId, docs] of Object.entries(rawAnswers)) {
-        if (Array.isArray(docs)) {
-          linkedAnswers[formId] = docs.map((doc) =>
-            doc && typeof doc === "object"
-              ? this._linkEntity("answers", { ...(doc as Record<string, unknown>), collection: "answers" })
-              : doc
-          );
-        }
+        // Le backend renvoie tantôt un tableau `[doc, ...]`, tantôt une map indexée
+        // par id `{ answerId: doc }`. On normalise vers un tableau dans les deux cas.
+        const list = Array.isArray(docs)
+          ? docs
+          : (docs && typeof docs === "object" ? Object.values(docs) : []);
+        linkedAnswers[formId] = list.map((doc) =>
+          doc && typeof doc === "object"
+            ? this._linkEntity("answers", { ...(doc as Record<string, unknown>), collection: "answers" })
+            : doc
+        );
       }
       (data as Record<string, unknown>).answers = linkedAnswers;
     }
@@ -448,9 +451,75 @@ export class Organization extends BaseEntity<OrganizationItemNormalized> {
     return paginator.next() as Promise<PaginatorPage<User | Organization>>;
   }
 
+  /**
+   * Récupère les organisations dont **cette** organisation est membre
+   * (lien montant : réseau, fédération, collectif… dont l'orga fait partie).
+   *
+   * C'est le miroir de {@link Organization#getMembers} : `getMembers()` liste
+   * *qui* est membre de cette orga, tandis que `getMemberOf()` liste *les orgas
+   * dont cette orga est elle-même membre*.
+   *
+   * Contrairement à {@link BaseEntity#getOrganizations} (désactivée ici car pensée
+   * pour un citoyen via `GET_ORGANIZATIONS_*`), on passe par la recherche réseau
+   * globale `searchCostum` : on cible `searchType: ["organizations"]` et on filtre
+   * sur `links.members.{thisOrgId}`. Seules les adhésions **confirmées** sont
+   * retournées (les liens `toBeValidated` et `isInviting` sont exclus).
+   *
+   * La pagination (`hasNext`/`next()`) et la restauration via `restoredState`
+   * fonctionnent comme pour `searchCostum` : le filtre membership est conservé
+   * d'une page à l'autre.
+   *
+   * @param data - Paramètres de recherche/pagination additionnels (`name`, `indexStep`,
+   *   `sortBy`, `locality`, `filters` complémentaires…). Les `filters` fournis sont
+   *   fusionnés avec le filtre membership, ce dernier restant prioritaire.
+   * @param options - Options. `restoredState` pour reprendre une pagination sérialisée.
+   * @returns Première page paginée d'organisations.
+   * @throws {ApiError} Si l'organisation n'a pas d'`id`.
+   *
+   * @example
+   * // Toutes les orgas dont cette orga est membre
+   * const page = await org.getMemberOf();
+   * console.log(page.results, page.count.total);
+   *
+   * @example
+   * // Filtrer par nom + pagination plus large
+   * const page = await org.getMemberOf({ name: "réseau", indexStep: 50 });
+   * if (page.hasNext) await page.next();
+   */
+  async getMemberOf(
+    data: Parameters<BaseEntity<OrganizationItemNormalized>["searchCostum"]>[0] = {},
+    options: { restoredState?: PaginatorState } = {}
+  ): Promise<PaginatorPage<Organization>> {
+    if (!this.id) {
+      throw new ApiError("L'organisation n'est pas définie, impossible de récupérer ses adhésions", 400);
+    }
+
+    const path = `links.members.${this.id}`;
+    const membershipFilters = {
+      [path]: { $exists: true },
+      [`${path}.toBeValidated`]: { $exists: false },
+      [`${path}.isInviting`]: { $exists: false }
+    };
+    const callerFilters = (data?.filters && typeof data.filters === "object") ? data.filters : {};
+
+    const orgParam: Parameters<typeof this.searchCostum>[0] = {
+      indexMin: 0,
+      indexStep: 20,
+      notSourceKey: true,
+      ...data,
+      // Champs imposés (le caller ne peut pas casser la sémantique « adhésions »)
+      searchType: ["organizations"],
+      countType: ["organizations"],
+      count: true,
+      filters: { ...callerFilters, ...membershipFilters }
+    };
+
+    return this.searchCostum(orgParam, options) as Promise<PaginatorPage<Organization>>;
+  }
+
   /**
    * {@inheritDoc BaseEntity#getGallery}
-   * 
+   *
    * Récupère la galerie de l'organisation.
    */
   override async getGallery(data: Parameters<BaseEntity<OrganizationItemNormalized>["getGallery"]>[0] = {}) {

package/src/api/Poi.ts

@@ -3,8 +3,38 @@ import { BaseEntity } from "./BaseEntity.js";
 import { PoiItemNormalized } from "./serverDataType/Poi.js";
 import { transformEntityRefs } from "../types/transforms.js";
 
+import type { SetTypeValue } from "./BaseEntity.js";
 import type { AddPoiData } from "./EndpointApi.types.js";
 
+/**
+ * Source unique des champs « équipement sportif » (RES) éditables sur le POI :
+ *  - `schema`  : type JSON → alimente le VIRTUAL_SCHEMA (draft-allow + cohérence des types)
+ *  - `setType` : coercion backend pour `UPDATE_PATH_VALUE` (absent = string/array)
+ * On en dérive `Poi.VIRTUAL_SCHEMAS`, `Poi.CUSTOM_FIELD_HANDLERS` et `Poi.EQUIPMENT_SETTYPE`.
+ */
+const POI_EQUIPMENT_FIELDS: ReadonlyArray<{ name: string; schema: Record<string, unknown>; setType?: SetTypeValue }> = [
+  // Nombres (dimensions)
+  ...["equip_surf", "equip_larg", "equip_long"].map((name) => ({ name, schema: { type: "number" }, setType: "float" as SetTypeValue })),
+  // Dates (string côté schéma, normalisées en Date à la lecture ; isoDate à l'écriture)
+  ...["equip_maj_date", "inst_date_creation", "inst_enqu_date"].map((name) => ({ name, schema: { type: "string" }, setType: "isoDate" as SetTypeValue })),
+  // Booléens
+  ...[
+    "inst_acc_handi_bool", "inst_trans_bool", "equip_eclair", "equip_acc_libre", "inst_part_bool",
+    "equip_pmr_acc", "equip_pmr_chem", "equip_pmr_douche", "equip_pmr_sanit", "equip_pmr_trib", "equip_pmr_vest",
+    "equip_pshs_aire", "equip_pshs_chem", "equip_pshs_sanit", "equip_pshs_trib", "equip_pshs_vest", "equip_pshs_sign",
+    "equip_douche"
+  ].map((name) => ({ name, schema: { type: "boolean" }, setType: "bool" as SetTypeValue })),
+  // Strings
+  ...[
+    "categorie", "equip_type_name", "inst_nom", "equip_type_famille", "equip_nature", "equip_sol",
+    "inst_acc_handi_type", "inst_trans_type", "equip_prop_nom", "equip_prop_type", "equip_gest_type"
+  ].map((name) => ({ name, schema: { type: "string" } })),
+  // Arrays de strings
+  ...[
+    "aps_name", "inst_part_type", "equip_loc_type", "equip_utilisateur"
+  ].map((name) => ({ name, schema: { type: "array", items: { type: "string" } } }))
+];
+
 export class Poi extends BaseEntity<PoiItemNormalized> {
   static override entityType = "poi";
 
@@ -16,7 +46,8 @@ export class Poi extends BaseEntity<PoiItemNormalized> {
     "UPDATE_BLOCK_INFO",
     "UPDATE_BLOCK_LOCALITY",
     "UPDATE_BLOCK_SLUG",
-    "PROFIL_IMAGE"
+    "PROFIL_IMAGE",
+    "VIRTUAL_POI_EQUIPMENT"
   ];
 
   static ADD_BLOCKS = new Map([
@@ -32,6 +63,30 @@ export class Poi extends BaseEntity<PoiItemNormalized> {
     ["PROFIL_IMAGE", "updateImageProfil"]
   ] as const);
 
+  /**
+   * Champs « équipement sportif » (RES) éditables hors `UPDATE_BLOCK_*` : déclarés en
+   * VIRTUAL_SCHEMA (autorise l'écriture sur le draft + fixe les types) et persistés à
+   * l'update via `CUSTOM_FIELD_HANDLERS` → `updateEquipmentField` → `UPDATE_PATH_VALUE`.
+   * Même pattern qu'`Organization`/`Action`. (Ils restent aussi dans `ADD_POI` pour la création.)
+   */
+  static override VIRTUAL_SCHEMAS = {
+    VIRTUAL_POI_EQUIPMENT: {
+      type: "object",
+      properties: Object.fromEntries(POI_EQUIPMENT_FIELDS.map((f) => [f.name, f.schema]))
+    }
+  };
+
+  static override CUSTOM_FIELD_HANDLERS = new Map(
+    POI_EQUIPMENT_FIELDS.map((f) =>
+      [f.name, { updateMethod: "updateEquipmentField", schemaConstant: "VIRTUAL_POI_EQUIPMENT" }] as [string, { updateMethod: string; schemaConstant?: string }]
+    )
+  );
+
+  /** setType backend par champ équipement (consommé par `updateEquipmentField`). */
+  private static readonly EQUIPMENT_SETTYPE = new Map<string, SetTypeValue | undefined>(
+    POI_EQUIPMENT_FIELDS.map((f) => [f.name, f.setType])
+  );
+
   override defaultFields: Record<string, any> = {
     typeElement: this.getEntityType()
   };
@@ -83,6 +138,23 @@ export class Poi extends BaseEntity<PoiItemNormalized> {
     if (payload.id) delete payload.id;
     let hasChanged = false;
 
+    // 1. Champs équipement (RES) : non couverts par les UPDATE_BLOCK_*. Persistés
+    //    individuellement via CUSTOM_FIELD_HANDLERS -> updateEquipmentField -> UPDATE_PATH_VALUE
+    //    (même mécanisme qu'Organization/Action).
+    const customHandlers = Poi.CUSTOM_FIELD_HANDLERS;
+    if (customHandlers) {
+      const processedFields = new Set<string>();
+      for (const [fieldName, config] of customHandlers) {
+        if (fieldName in payload && this._hasFieldChanged(fieldName)) {
+          await this._invokeCustomFieldHandler(config.updateMethod, payload[fieldName], fieldName);
+          processedFields.add(fieldName);
+          hasChanged = true;
+        }
+      }
+      processedFields.forEach((f) => delete payload[f]);
+    }
+
+    // 2. Blocs standards (description, info, locality, slug, image).
     for (const [constant, methodName] of Array.from(Poi.UPDATE_BLOCKS)) {
       const blockData = this._extractChangedFieldsFromSchema(
         this.apiClient,
@@ -100,6 +172,34 @@ export class Poi extends BaseEntity<PoiItemNormalized> {
     return hasChanged;
   };
 
+  /**
+   * Handler générique des champs « équipement sportif » (RES), enregistré dans
+   * `CUSTOM_FIELD_HANDLERS`. Persiste un champ via `UPDATE_PATH_VALUE` avec le `setType`
+   * adéquat (lu dans `EQUIPMENT_SETTYPE`). `fieldName` est fourni par `_invokeCustomFieldHandler`.
+   *
+   * Effacement façon `Action` : `null`/`""` → on envoie `""` SANS `setType` → le backend fait
+   * `!empty($value)` → `$unset` (sinon `floatval("")=0` écraserait au lieu d'effacer).
+   */
+  async updateEquipmentField(value: unknown, fieldName: string): Promise<unknown> {
+    const setType = Poi.EQUIPMENT_SETTYPE.get(fieldName);
+    const isClear = value === null || value === "";
+    return this.updateField(fieldName, isClear ? "" : value, isClear || !setType ? {} : { setType });
+  }
+
+  /**
+   * Override confiné à `Poi` : forwarde `fieldName` au handler (2e argument) pour permettre
+   * un handler générique unique (`updateEquipmentField`) couvrant les ~39 champs équipement,
+   * sans toucher `BaseEntity._invokeCustomFieldHandler` (utilisé par les autres entités, qui
+   * ne passent que `value`). Copie volontaire du corps de base + le forward du `fieldName`.
+   */
+  protected override async _invokeCustomFieldHandler(methodName: string, value: any, fieldName: string): Promise<any> {
+    const method = (this as any)[methodName];
+    if (typeof method !== "function") {
+      throw new ApiError(`Custom handler "${methodName}" not found for field "${fieldName}"`, 500);
+    }
+    return await method.call(this, value, fieldName);
+  }
+
   async addPoi(data: Partial<AddPoiData> = {}): Promise<unknown> {
 
     // Si le parent direct n'est pas l'utilisateur connecté (ex: création via une org),

package/src/api/Project.ts

@@ -74,13 +74,16 @@ export class Project extends BaseEntity<ProjectItemNormalized> {
     if (rawAnswers && typeof rawAnswers === "object") {
       const linkedAnswers: Record<string, unknown[]> = {};
       for (const [formId, docs] of Object.entries(rawAnswers)) {
-        if (Array.isArray(docs)) {
-          linkedAnswers[formId] = docs.map((doc) =>
-            doc && typeof doc === "object"
-              ? this._linkEntity("answers", { ...(doc as Record<string, unknown>), collection: "answers" })
-              : doc
-          );
-        }
+        // Le backend renvoie tantôt un tableau `[doc, ...]`, tantôt une map indexée
+        // par id `{ answerId: doc }`. On normalise vers un tableau dans les deux cas.
+        const list = Array.isArray(docs)
+          ? docs
+          : (docs && typeof docs === "object" ? Object.values(docs) : []);
+        linkedAnswers[formId] = list.map((doc) =>
+          doc && typeof doc === "object"
+            ? this._linkEntity("answers", { ...(doc as Record<string, unknown>), collection: "answers" })
+            : doc
+        );
       }
       (data as Record<string, unknown>).answers = linkedAnswers;
     }

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";
 
@@ -16,10 +17,16 @@ import type {
   GetSubscriptionsData,
   GetOrganizationsNoAdminData,
   GetOrganizationsAdminData,
+  GetUserEligiblePlacesData,
   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;
@@ -404,6 +411,59 @@ export class User extends BaseEntity<UserItemNormalized> {
     return paginator.next() as Promise<PaginatorPage<Organization>>;
   }
 
+  /**
+   * Récupère les lieux (organizations) memberOf de l'utilisateur, filtrés
+   * côté serveur par des filters arbitraires (tags, source.key, etc.) et
+   * un flag `notSourceKey` configurables.
+   *
+   * Mirroir de `getOrganizations` mais permet de passer dynamiquement les
+   * filtres du finder du formulaire (vue collaborative coform/place), pour
+   * que la pagination soit correcte (filtrage côté serveur, pas côté client).
+   *
+   * Constant : GET_USER_ELIGIBLE_PLACES
+   */
+  async getEligiblePlaces(
+    data: Partial<GetUserEligiblePlacesData> = {},
+    options?: { restoredState?: PaginatorState }
+  ) {
+    // Force le default `searchType` ([NGO, Cooperative, ...]) — le PHP ne
+    // retourne rien si le tableau est vide / absent. Pattern aligné avec
+    // `getOrganizations`.
+    data.searchType = this._getDefaultFromEndpoint(
+      "GET_USER_ELIGIBLE_PLACES",
+      "searchType"
+    ) as GetUserEligiblePlacesData["searchType"];
+
+    const paginator = this._createPaginatorEngine({
+      initialData: data,
+      methodName: "getEligiblePlaces",
+      restoredState: options?.restoredState,
+      finalizer: async (finalData) => {
+        delete finalData?.pathParams;
+
+        // Auto-merge du filtre memberOf par défaut si l'appelant n'en pousse
+        // que des filters "métier" (tags, etc.). On garde la sémantique
+        // "uniquement les orgs où l'user est membre validé".
+        const userFilters = finalData.filters ?? {};
+        const memberOfDefaults: Record<string, unknown> = {
+          [`links.members.${this.id}`]: { "$exists": true },
+          [`links.members.${this.id}.toBeValidated`]: { "$exists": false },
+          [`links.members.${this.id}.isInviting`]: { "$exists": false },
+        };
+        finalData.filters = { ...memberOfDefaults, ...userFilters };
+
+        // Cast nécessaire : callIsMe est typé Promise<unknown>, mais l'endpoint
+        // retourne bien la shape `{ results, count }` attendue par le finalizer.
+        // Pattern aligné avec getOrganizations (cf. la branche ternaire au-dessus).
+        return this.callIsMe(() => this.endpointApi.getUserEligiblePlaces(finalData)) as ReturnType<
+          typeof this.endpointApi.getUserEligiblePlaces
+        >;
+      },
+    });
+
+    return paginator.next() as Promise<PaginatorPage<Organization>>;
+  }
+
   /**
    * {@inheritDoc BaseEntity#getProjects}
    * 
@@ -1717,6 +1777,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/Form.ts

@@ -134,3 +134,24 @@ export interface FormItemNormalized {
     useBannerImg?: boolean;
     [key: string]: unknown;
 }
+
+/**
+ * Une contribution individuelle à une table commune (commonTable) d'un coform.
+ * Retournée par `Form.getCommonTableContributors()` (endpoint GET_COFORM_COMMONTABLE_CONTRIBUTORS).
+ * Plusieurs entrées possibles pour un même `userId` (plusieurs solutions au même usage).
+ */
+export interface CoformCommonTableContributor {
+  userId: string;
+  userName?: string;
+  userSlug?: string;
+  criteriaId: string;
+  /** Nom de la solution saisie. */
+  criteria: string;
+  /** love | happySmile | neutral | sad | cry | "" */
+  happiness?: string;
+  /** Note de 0 à 5. */
+  note?: number;
+  comment?: string;
+  fromAnswerId?: string;
+  [k: string]: unknown;
+}