@supersoniks/concorde 4.8.0 → 4.9.1

package/src/core/utils/AncestorAttributeObserver.ts

@@ -0,0 +1,199 @@
+import HTML, { SearchableDomElement } from "./HTML";
+
+/**
+ * Observateur pour `@ancestorAttribute({ dynamic: true })`.
+ *
+ * Un MutationObserver sur `document` ne voit pas les mutations dans les shadow
+ * roots (Lit par défaut). Chaque abonnement observe donc directement les nœuds
+ * de sa chaîne d'ancêtres (composant → parent → … → host shadow), comme
+ * `watchScopedConfiguration` dans `api.ts`.
+ *
+ * Après un `childList` (wrapper plus proche, reparenting), la chaîne est
+ * recalculée pour écouter les nouveaux ancêtres.
+ */
+
+type SyncOptions = {
+  /** En mode dynamique : écrire `null` si l'attribut ancêtre disparaît. */
+  assignNull: boolean;
+};
+
+type Subscription = {
+  component: HTMLElement;
+  attributeName: string;
+  propertyKey: string;
+  syncOptions: SyncOptions;
+  disconnectObservers: (() => void) | null;
+};
+
+/** Chaîne composant → ancêtres, en traversant les shadow roots. */
+function walkAncestorElements(node: Node): Element[] {
+  const elements: Element[] = [];
+  let current: Node | null = node;
+  while (current) {
+    if (current instanceof Element) {
+      elements.push(current);
+    }
+    const parent: Node | null =
+      current.parentNode || ((current as ShadowRoot).host ?? null);
+    current = parent;
+  }
+  return elements;
+}
+
+/**
+ * Observe attributs + enfants directs de chaque ancêtre.
+ * Retourne une fonction de nettoyage (disconnect).
+ */
+function attachAncestorChainObservers(
+  subscription: Subscription,
+  onMutation: () => void,
+): () => void {
+  const observers: MutationObserver[] = [];
+  let disconnected = false;
+  const attributeFilter = HTML.scopeAttributeNames(subscription.attributeName);
+
+  const reconnect = () => {
+    for (const observer of observers) {
+      observer.disconnect();
+    }
+    observers.length = 0;
+    if (disconnected) return;
+
+    for (const element of walkAncestorElements(subscription.component)) {
+      const observer = new MutationObserver((records) => {
+        if (disconnected) return;
+        if (records.some((record) => record.type === "childList")) {
+          reconnect();
+        }
+        onMutation();
+      });
+      observer.observe(element, {
+        attributes: true,
+        attributeFilter,
+        childList: true,
+        subtree: false,
+      });
+      observers.push(observer);
+    }
+  };
+
+  reconnect();
+
+  return () => {
+    disconnected = true;
+    for (const observer of observers) {
+      observer.disconnect();
+    }
+    observers.length = 0;
+  };
+}
+
+/**
+ * Point unique de synchronisation DOM → propriété du composant.
+ * N'assigne que si la valeur change (`Object.is`) pour limiter les re-renders Lit
+ * et éviter de reboucler inutilement `observeDynamicProperty` (@bind / @subscribe).
+ */
+export function syncAncestorAttributeValue(
+  component: object,
+  attributeName: string,
+  propertyKey: string,
+  options: SyncOptions,
+): void {
+  const record = component as Record<string, unknown>;
+  const value = HTML.getAncestorAttributeValue(
+    component as unknown as SearchableDomElement,
+    attributeName,
+  );
+  if (!options.assignNull && value === null) return;
+  if (!Object.is(record[propertyKey], value)) {
+    record[propertyKey] = value;
+  }
+}
+
+export default class AncestorAttributeObserver {
+  private static subscriptions = new Set<Subscription>();
+  private static pendingRefresh = new Set<Subscription>();
+  private static animationFrameId: number | null = null;
+
+  /**
+   * Enregistre un composant en mode `{ dynamic: true }`.
+   * Le `unsubscribe` retourné doit être appelé au `disconnectedCallback`.
+   */
+  static subscribe(
+    component: HTMLElement,
+    attributeName: string,
+    propertyKey: string,
+    syncOptions: SyncOptions = { assignNull: true },
+  ): () => void {
+    const subscription: Subscription = {
+      component,
+      attributeName,
+      propertyKey,
+      syncOptions,
+      disconnectObservers: null,
+    };
+
+    subscription.disconnectObservers = attachAncestorChainObservers(
+      subscription,
+      () => {
+        if (!AncestorAttributeObserver.subscriptions.has(subscription)) return;
+        AncestorAttributeObserver.pendingRefresh.add(subscription);
+        AncestorAttributeObserver.scheduleRefresh();
+      },
+    );
+
+    AncestorAttributeObserver.subscriptions.add(subscription);
+
+    return () => {
+      AncestorAttributeObserver.unsubscribe(subscription);
+    };
+  }
+
+  /** Coupe les observateurs et retire l'abonnement (pas de fuite après disconnect). */
+  private static unsubscribe(subscription: Subscription): void {
+    if (!AncestorAttributeObserver.subscriptions.has(subscription)) return;
+
+    subscription.disconnectObservers?.();
+    subscription.disconnectObservers = null;
+
+    AncestorAttributeObserver.subscriptions.delete(subscription);
+    AncestorAttributeObserver.pendingRefresh.delete(subscription);
+
+    if (AncestorAttributeObserver.subscriptions.size === 0) {
+      AncestorAttributeObserver.cancelScheduledRefresh();
+    }
+  }
+
+  private static scheduleRefresh(): void {
+    if (AncestorAttributeObserver.pendingRefresh.size === 0) return;
+    if (AncestorAttributeObserver.animationFrameId !== null) return;
+    AncestorAttributeObserver.animationFrameId = requestAnimationFrame(() => {
+      AncestorAttributeObserver.flushRefresh();
+    });
+  }
+
+  private static cancelScheduledRefresh(): void {
+    if (AncestorAttributeObserver.animationFrameId !== null) {
+      cancelAnimationFrame(AncestorAttributeObserver.animationFrameId);
+      AncestorAttributeObserver.animationFrameId = null;
+    }
+    AncestorAttributeObserver.pendingRefresh.clear();
+  }
+
+  private static flushRefresh(): void {
+    AncestorAttributeObserver.animationFrameId = null;
+    const subscriptions = Array.from(AncestorAttributeObserver.pendingRefresh);
+    AncestorAttributeObserver.pendingRefresh.clear();
+
+    for (const subscription of subscriptions) {
+      if (!AncestorAttributeObserver.subscriptions.has(subscription)) continue;
+      if (!subscription.component.isConnected) continue;
+      syncAncestorAttributeValue(
+        subscription.component,
+        subscription.attributeName,
+        subscription.propertyKey,
+        subscription.syncOptions,
+      );
+    }
+  }
+}

package/src/core/utils/HTML.ts

@@ -60,21 +60,15 @@ class HTML {
   }
 
   /** Noms d'attribut DOM à tester (Lit reflect → minuscules, ex. serviceURL → serviceurl). */
-  private static scopeAttributeNames(attributeName: string): string[] {
+  static scopeAttributeNames(attributeName: string): string[] {
     const lower = attributeName.toLowerCase();
     return lower === attributeName ? [attributeName] : [attributeName, lower];
   }
 
-  private static readScopeValueOnElement(
+  private static readScopeAttributeOnElement(
     element: HTMLElement,
     attributeName: string,
   ): string | null {
-    // Lit : la propriété est fiable avant le reflect ; un attribut vide (serviceurl="")
-    // ne doit pas masquer la propriété.
-    const prop = (element as unknown as Record<string, unknown>)[attributeName];
-    if (typeof prop === "string" && prop.length > 0) {
-      return prop;
-    }
     for (const attrName of HTML.scopeAttributeNames(attributeName)) {
       if (element.hasAttribute(attrName)) {
         const attr = element.getAttribute(attrName);
@@ -88,8 +82,6 @@ class HTML {
 
   /**
    * Va de parent en parent en partant de node pour trouver un attribut.
-   * Si l'attribut n'est pas encore reflété (ex. Lit `@property({ reflect: true })`
-   * au premier `connectedCallback`), lit la propriété homonyme sur l'élément.
    * @param attributeName nom de l'attribut
    * @returns valeur de l'attribut ou null si l'attribut n'est pas trouvé
    */
@@ -101,7 +93,7 @@ class HTML {
     let current: SearchableDomElement | null = node;
     while (current) {
       if (current instanceof HTMLElement) {
-        const value = HTML.readScopeValueOnElement(current, attributeName);
+        const value = HTML.readScopeAttributeOnElement(current, attributeName);
         if (value != null && value.length > 0) {
           return value;
         }

package/src/core/utils/PublisherProxy.ts

@@ -481,8 +481,7 @@ export class PublisherProxy<T = any> {
    */
   _cachedGet_?: T;
   get(): T {
-    if (PublisherManager.modifiedCollectore.length > 0)
-      PublisherManager.modifiedCollectore[0].add(this);
+    trackModifiedPublisher(this);
     if (this._cachedGet_ !== undefined) return this._cachedGet_;
     if (Object.prototype.hasOwnProperty.call(this._value_, "__value")) {
       const v = (this._value_ as any).__value;
@@ -519,6 +518,20 @@ export class PublisherProxy<T = any> {
  *
  */
 
+const modifiedCollectore: Set<any>[] = [];
+
+function trackModifiedPublisher(proxy: any) {
+  if (modifiedCollectore.length > 0) modifiedCollectore[0].add(proxy);
+}
+
+export function collectModifiedPublisher() {
+  modifiedCollectore.unshift(new Set<any>());
+}
+
+export function getModifiedPublishers() {
+  return modifiedCollectore.shift() as Set<any>;
+}
+
 export class PublisherManager {
   static buildDate = __BUILD_DATE__;
   static changed = false;
@@ -541,9 +554,19 @@ export class PublisherManager {
     if (PublisherManager.instance != null) throw "Singleton / use getInstance";
     PublisherManager.instance = this;
     this.isLocalStrorageReady = this.cleanStorageData() as Promise<boolean>;
+    PublisherManager.initPageShowHandler();
+  }
+
+  private static pageShowHandlerInitialized = false;
+  private static initPageShowHandler() {
+    if (PublisherManager.pageShowHandlerInitialized) return;
+    PublisherManager.pageShowHandlerInitialized = true;
+    window.addEventListener("pageshow", (e) => {
+      if (e.persisted) PublisherManager.getInstance().invalidateAll();
+    });
   }
 
-  invalidateAll() {
+  private invalidateAll() {
     this.publishers.forEach((publisher) => {
       if (!publisher._invalidate_on_page_show_) {
         return;
@@ -617,16 +640,6 @@ export class PublisherManager {
     return PublisherManager.instance;
   }
 
-  static registerInstance(id: string, instance: PublisherManager) {
-    if (PublisherManager.instances.has(id)) {
-      console.warn(
-        "PublisherManager instance already registered with id: ",
-        id,
-      );
-    }
-    PublisherManager.instances.set(id, instance);
-  }
-
   /**
    * shortcut static pour obtenir un publisher vias sont id/adresse sans taper getInstance.
    * Si le publisher n'existe pas, il est créé.
@@ -638,22 +651,6 @@ export class PublisherManager {
     return PublisherManager.getInstance().get(id, options);
   }
 
-  public static modifiedCollectore: Set<any>[] = [];
-  public static collectModifiedPublisher() {
-    PublisherManager.modifiedCollectore.unshift(new Set<any>());
-  }
-  public static getModifiedPublishers() {
-    return PublisherManager.modifiedCollectore.shift() as Set<any>;
-  }
-
-  /**
-   * shortcut static pour supprimer un publisher de la liste et appel également delete sur le publisher ce qui le supprime, de même que ses sous publishers
-   */
-  static delete(id: string | null) {
-    if (!id) return false;
-    return PublisherManager.getInstance().delete(id);
-  }
-
   /**
    * Obtenir un publisher vias sont id/adresse
    * Si le publisher n'existe pas, il est créé.
@@ -1063,9 +1060,9 @@ export const getObservables = <T = any>(
 ): Set<DataProvider<T>> => {
   if (typeof observable === "function") {
     const func = observable as () => any;
-    PublisherManager.collectModifiedPublisher();
+    collectModifiedPublisher();
     func();
-    return PublisherManager.getModifiedPublishers() as Set<DataProvider<T>>;
+    return getModifiedPublishers() as Set<DataProvider<T>>;
   }
   if (typeof observable === "string") {
     const split = observable.split(".");
@@ -1187,9 +1184,3 @@ export function set<T>(id: string | DataProviderKey<T>, value: T): void {
   getObservables(path).values().next().value?.set(value);
 }
 
-/**
- * next back handling data invalidation
- */
-window.addEventListener("pageshow", (e) => {
-  if (e.persisted) PublisherManager.getInstance().invalidateAll();
-});

package/src/core/utils/api.ts

@@ -50,7 +50,7 @@ export type ApiResult<T> = {
 export type ApiGetResult<T> = ApiResult<T>;
 
 /** Extrait le corps typé depuis le résultat traité par `handleResult`. */
-export function extractTypedApiResult<T>(
+function extractTypedApiResult<T>(
   processed: ResultTypeInterface | null | undefined,
 ): T {
   if (processed == null || typeof processed !== "object") {
@@ -67,7 +67,7 @@ class API {
   /**
    * Ce tableau static permet de ne pas appeler plusieurs fois le même service lors d'appel concurrents en GET.
    */
-  static loadingGetPromises: Map<string, Promise<unknown>> = new Map();
+  private static loadingGetPromises: Map<string, Promise<unknown>> = new Map();
   /**
    * L'url de base du service sans endpoint
    */
@@ -123,14 +123,14 @@ class API {
   /**
    * Tableau static des tokens stokés en memoire vive (comportement à revoir à l'occasion)
    */
-  static tokens = new Map<string | null, string | null | undefined>();
+  private static tokens = new Map<string | null, string | null | undefined>();
 
   /**
    * Tableau stockant l'ensemble des tokens invalides
    */
-  static invalidTokens: (string | null | undefined)[] = [];
+  private static invalidTokens: (string | null | undefined)[] = [];
 
-  handleInvalidToken(token: string | null | undefined) {
+  private handleInvalidToken(token: string | null | undefined) {
     if (!token) return;
 
     if (API.invalidTokens.includes(token)) return;
@@ -142,11 +142,11 @@ class API {
   /**
    * Tableau static des tentatives échouées de récupération auto du token
    */
-  static failledTokenUpdates = new Map<string | null, true>();
+  private static failledTokenUpdates = new Map<string | null, true>();
   /**
    * Tableau static des flags pour savoir si le premier appel a été fait pour chaque serviceURL
    */
-  static firstCallDoneFlags = new Map<string | null, CallState>();
+  private static firstCallDoneFlags = new Map<string | null, CallState>();
 
   /**
    * Le endPoint pour obtenir le bearer token qui sera concaténé à l'url du service
@@ -174,7 +174,7 @@ class API {
     this.cache = config.cache || "default";
     this.keepAlive = config.keepAlive || false;
   }
-  async handleResult(
+  private async handleResult(
     fetchResult: Response,
     lastCall: APICall,
   ): Promise<ResultTypeInterface> {
@@ -231,7 +231,7 @@ class API {
   /**
    * Basic auth
    */
-  async auth() {
+  private async auth() {
     if (this.token) return;
     if (API.tokens.has(this.serviceURL)) {
       this.token = API.tokens.get(this.serviceURL);
@@ -362,7 +362,7 @@ class API {
   /**
    * firstCallDone is a function that returns a promise that is resolved when the first call to the API is done for each serviceURL whatever api instance is used
    */
-  firstCallDone() {
+  private firstCallDone() {
     return new Promise((resolve) => {
       if (!API.firstCallDoneFlags.has(this.serviceURL)) {
         API.firstCallDoneFlags.set(this.serviceURL, "loading");

package/src/css.d.ts

@@ -0,0 +1,19 @@
+declare module "*.css" {
+  const css: import("lit").CSSResult;
+  export default css;
+}
+
+declare module "*.css?inline" {
+  const css: string;
+  export default css;
+}
+
+declare module "*.scss" {
+  const css: import("lit").CSSResult;
+  export default css;
+}
+
+declare module "*.scss?inline" {
+  const css: string;
+  export default css;
+}

package/src/directives.ts

@@ -1,5 +1,6 @@
 import * as directives from "@supersoniks/concorde/core/directives/DataProvider";
 import {dp as pubDp, dataProvider as pubDataProvider, get as pubGet, set as pubSet} from "@supersoniks/concorde/core/utils/PublisherProxy";
+import type {DirectiveResult} from "lit/async-directive.js";
 
 import {ConcordeWindow} from "./core/_types/types";
 /**
@@ -10,8 +11,8 @@ export const dp = pubDp;
  * @deprecated @see pubDataProvider
  */
 export const dataProvider = pubDataProvider;
-export const subscribe = directives.subscribe;
-export const sub = directives.sub;
+export const subscribe = directives.subscribe as DirectiveResult;
+export const sub = directives.sub as DirectiveResult;
 
 /**
  * @deprecated @see pubGet

package/src/docs/_decorators/ancestor-attribute.md

@@ -18,7 +18,7 @@ import { ancestorAttribute } from "@supersoniks/concorde/decorators";
 
 ### Basic example
 
-The component reads `dataProvider` and `testAttribute` from its ancestor wrapper.
+The component reads `dataProvider` and `testAttribute` from its ancestor wrapper. By default (`dynamic: false`), values are read once at connect.
 
 <sonic-code language="typescript">
   <template>
@@ -36,10 +36,8 @@ export class DemoAncestorAttribute extends LitElement {
 
   render() {
     return html`
-      <section>
-        <p>dataProvider: <strong>${this.dataProvider || "null"}</strong></p>
-        <p>testAttribute: <strong>${this.testAttribute || "null"}</strong></p>
-      </section>
+      <p>dataProvider: <strong>${this.dataProvider ?? "null"}</strong></p>
+      <p>testAttribute: <strong>${this.testAttribute ?? "null"}</strong></p>
     `;
   }
 }
@@ -55,7 +53,6 @@ export class DemoAncestorAttribute extends LitElement {
   </template>
 </sonic-code>
 
-
 ## Use cases
 
 This decorator is particularly useful for:
@@ -68,9 +65,60 @@ This decorator is particularly useful for:
 ## Behavior
 
 - The search starts from the current element and traverses up the DOM tree
-- If the attribute is not found, the property will be assigned `null`
 - The injection happens automatically at the time of `connectedCallback`
-- The value is not reactive: it is only updated once when the element is connected to the DOM
+- By default (`dynamic: false`), the value is read once at connect time and is not updated afterward
+- With `{ dynamic: true }`, the property stays in sync when:
+  - an ancestor **changes** the attribute value
+  - a **closer** ancestor **gains** the attribute (that value wins)
+  - the **nearest** ancestor **loses** the attribute (falls back to the next one up, or `null`)
+- When `dynamic` is enabled, updates also propagate to `@subscribe` / `@bind` paths that depend on the decorated property (e.g. `${dataProvider}`)
+
+### Dynamic mode
+
+Use `{ dynamic: true }` when the decorated property must follow the DOM. With Lit, add **`@state()`** on the same property so template updates are visible when the observer assigns a new value.
+
+The live demo below shows only the resolved attribute value — no store, no reparenting.
+
+<sonic-code language="typescript">
+  <template>
+@customElement("demo-ancestor-attribute-dynamic")
+export class DemoAncestorAttributeDynamic extends LitElement {
+  @ancestorAttribute("dataProvider", { dynamic: true })
+  @state()
+  dataProvider: string | null = null;
+
+  render() {
+    return html`
+      &lt;p&gt;Nearest ancestor: &lt;strong&gt;${this.dataProvider ?? "null"}&lt;/strong&gt;&lt;/p&gt;
+    `;
+  }
+}
+  </template>
+</sonic-code>
+
+Try in the demo:
+
+- **parent-a** / **parent-b** — change the value on the direct parent
+- **Remove parent attr** — falls back to **outer**
+- **Add closer** — a wrapper with `from-closer` becomes the nearest ancestor
+- **Remove closer** — back to parent or outer
+- **Remove outer attr** — if parent has no attribute either, the child shows `null`
+
+<sonic-code>
+  <template>
+    <docs-demo-sources for="demo-ancestor-attribute-dynamic-section"></docs-demo-sources>
+    <demo-ancestor-attribute-dynamic-section></demo-ancestor-attribute-dynamic-section>
+  </template>
+</sonic-code>
+
+Static mode (default) — read once at connect, no observer:
+
+<sonic-code language="typescript">
+  <template>
+@ancestorAttribute("dataProvider")
+dataProvider: string | null = null;
+  </template>
+</sonic-code>
 
 ## Notes
 

package/src/docs/_decorators/get.md

@@ -13,10 +13,53 @@ Pass an [`Endpoint<T>`](#docs/_misc/endpoint.md/endpoint) as the first argument.
 
 `${prop}` on the endpoint or config key is resolved on the host. While a placeholder is `null` or `undefined`, no GET runs. Optional `skipEmptyPlaceholder: true` also blocks `""` (empty string only). Details: [Dynamic path placeholders](#docs/_misc/dynamic-path.md/dynamic-path).
 
+## Options (`GetOptions`)
+
+Pass as the **second** argument (scoped config) or **third** (with a configuration key). Same shape as send decorators where applicable:
+
+| Option | Description |
+|--------|-------------|
+| `skipEmptyPlaceholder` | Treat `""` as not ready (see [Dynamic path](#docs/_misc/dynamic-path.md/dynamic-path)). |
+| `refetchEveryMs` | Automatic polling interval (ms). `0` or omitted = no polling. |
+| `triggerKey` | `DataProviderKey` — `PublisherManager.get(...).invalidate()` on that publisher re-runs the GET. |
+
+### Manual refetch (`triggerKey`)
+
+Same pattern as [@post](#docs/_decorators/post.md/post): a publisher acts as a **signal**, independent of the response payload.
+
+```typescript
+import { get, type ApiResult } from "@supersoniks/concorde/decorators";
+import { Endpoint } from "@supersoniks/concorde/utils/endpoint";
+import { DataProviderKey } from "@supersoniks/concorde/dataProviderKey";
+import { dp } from "@supersoniks/concorde/core/utils/PublisherProxy";
+
+const geoCommunesEndpoint = new Endpoint<GeoCommuneRow[]>(
+  "communes?limit=5&fields=nom,code",
+);
+const geoCommunesRefreshKey = new DataProviderKey<void>(
+  "docsDemoGeoCommunesRefresh",
+);
+
+@get(geoCommunesEndpoint, apiConfigurationKey, {
+  triggerKey: geoCommunesRefreshKey,
+})
+@state()
+payload: ApiResult<GeoCommuneRow[]> | null = null;
+
+// Same component or anywhere else:
+dp(geoCommunesRefreshKey).invalidate();
+```
+
+Prefer `triggerKey` over mutating the API configuration publisher when you only want to **reload the same URL** — no need to touch `serviceURL`, tokens, etc.
+
+The docs mock adds an **`X-Fetched-At`** response header on `/docs-mock-api/geo/communes` so live demos can show when the last fetch happened (`response.headers.get("X-Fetched-At")`).
+
 ## When the GET runs again
 
 - A referenced Lit property changes (endpoint path and/or config key contains `${...}`).
 - `set` on the active configuration publisher (`onInternalMutation`).
+- `triggerKey` publisher `invalidate()`.
+- `refetchEveryMs` polling (after each successful fetch).
 
 ## Import
 
@@ -42,6 +85,8 @@ payload: ApiResult<User> | null = null;
 
 ## Live demos
 
+`@get` with **`triggerKey`** — refresh button + `X-Fetched-At` timestamp in the UI:
+
 <sonic-code>
   <template>
     <docs-demo-sources for="demo-api-get"></docs-demo-sources>
@@ -49,12 +94,13 @@ payload: ApiResult<User> | null = null;
   </template>
 </sonic-code>
 
-Dynamic config and endpoint path (`demo-api-get-configuration-key` in doc sources):
+Dynamic config and endpoint path. Manual refetch is triggered **from a separate component** (same `triggerKey` publisher):
 
 <sonic-code>
   <template>
     <docs-demo-sources for="demo-api-get-configuration-key"></docs-demo-sources>
     <demo-api-get-configuration-key></demo-api-get-configuration-key>
+    <demo-api-get-refresh-remote></demo-api-get-refresh-remote>
   </template>
 </sonic-code>
 

package/src/docs/components/docs-demo-sources.ts

@@ -255,10 +255,15 @@ export const DOCS_DEMO_SOURCE_REGISTRY: Record<string, DocsSource[]> = {
   "demo-api-get-configuration-key": [
     {
       path: "src/docs/example/decorators-demo-subscribe-publish-get-demos.ts",
-      line: 126,
+      line: 147,
       label: "demo-api-get-configuration-key",
     },
-    { path: "src/docs/example/decorators-demo-geo.ts", label: "geo API" },
+    {
+      path: "src/docs/example/decorators-demo-subscribe-publish-get-demos.ts",
+      line: 239,
+      label: "demo-api-get-refresh-remote",
+    },
+    { path: "src/docs/example/decorators-demo-geo.ts", label: "geo API + triggerKey" },
   ],
   "demo-api-get-publish-subscribe": [
     {
@@ -329,7 +334,19 @@ export const DOCS_DEMO_SOURCE_REGISTRY: Record<string, DocsSource[]> = {
     { path: "src/docs/example/decorators-demo-init.ts", label: "demo data" },
   ],
   "demo-ancestor-attribute": [
-    { path: "src/docs/example/decorators-demo.ts", line: 19, label: "demo-ancestor-attribute" },
+    { path: "src/docs/example/decorators-demo.ts", line: 35, label: "demo-ancestor-attribute" },
+  ],
+  "demo-ancestor-attribute-dynamic-section": [
+    {
+      path: "src/docs/example/decorators-demo.ts",
+      line: 60,
+      label: "demo-ancestor-attribute-dynamic",
+    },
+    {
+      path: "src/docs/example/decorators-demo.ts",
+      line: 81,
+      label: "demo-ancestor-attribute-dynamic-section",
+    },
   ],
   "demo-on-assign": [
     { path: "src/docs/example/decorators-demo.ts", line: 43, label: "demo-on-assign" },

package/src/docs/example/decorators-demo-geo.ts

@@ -49,3 +49,8 @@ export const geoCommunesApiGetEndpointDynamic = new Endpoint<GeoCommuneRow[]>(
 export const geoCommunesApiGetPublishKey = new DataProviderKey<
   ApiResult<GeoCommuneRow[]>
 >(geoCommunesApiGetEndpoint.path);
+
+/** Signal de refetch manuel pour les démos `@get` (voir `triggerKey`). */
+export const docsDemoGeoCommunesRefreshKey = new DataProviderKey<void>(
+  "docsDemoGeoCommunesRefresh",
+);