@supersoniks/concorde 4.7.0 → 4.7.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supersoniks/concorde",
-  "version": "4.7.0",
+  "version": "4.7.3",
   "license": "MIT",
   "type": "module",
   "main": "",

package/src/core/decorators/api.spec.ts

@@ -22,6 +22,13 @@ async function flushGetMicrotasks() {
   await Promise.resolve();
 }
 
+/** @get scoped : scheduleAfterHostReady diffère le fetch (rAF ou updateComplete Lit). */
+async function flushScopedGet() {
+  await flushGetMicrotasks();
+  await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
+  await flushGetMicrotasks();
+}
+
 function mockPayload<T>(result: T) {
   return {
     request: new Request("https://api.example.test/items/1"),
@@ -113,7 +120,7 @@ describe("get", () => {
     wrap.appendChild(el);
     document.body.appendChild(wrap);
 
-    await flushGetMicrotasks();
+    await flushScopedGet();
 
     expect(API.prototype.getDetailed).toHaveBeenCalledWith("scoped-endpoint");
     expect(el.payload?.result).toEqual({ id: "loaded" });

package/src/core/decorators/api.ts

@@ -47,11 +47,108 @@ function resolveScopedConfiguration(
   return HTML.getApiConfiguration(host);
 }
 
+function isScopedConfigurationReady(
+  config: APIConfiguration | null,
+): config is APIConfiguration {
+  return typeof config?.serviceURL === "string" && config.serviceURL.length > 0;
+}
+
+/** Attributs scope dont la présence peut déclencher un GET différé (Lit → minuscules). */
+const SCOPE_WATCH_ATTRIBUTES = [
+  "serviceURL",
+  "serviceurl",
+  "token",
+  "credentials",
+  "tokenProvider",
+  "tokenprovider",
+  "userName",
+  "username",
+  "password",
+  "eventsApiToken",
+  "eventsapitoken",
+] as const;
+
+type LitHost = HTMLElement & { updateComplete?: Promise<unknown> };
+
+function isLitHost(component: unknown): component is LitHost {
+  return (
+    component instanceof HTMLElement &&
+    typeof (component as LitHost).updateComplete !== "undefined"
+  );
+}
+
+function scheduleAfterHostReady(
+  component: unknown,
+  callback: () => void,
+): () => void {
+  if (isLitHost(component)) {
+    let cancelled = false;
+    void component.updateComplete!.then(() => {
+      if (!cancelled) callback();
+    });
+    return () => {
+      cancelled = true;
+    };
+  }
+  const rafId = requestAnimationFrame(() => callback());
+  return () => cancelAnimationFrame(rafId);
+}
+
+/**
+ * Attend que la config scope soit lisible (attributs DOM ou propriétés Lit reflect).
+ */
+function watchScopedConfiguration(
+  component: unknown,
+  onReady: () => void,
+): () => void {
+  const host = asSearchableHost(component);
+  if (!host) return () => {};
+
+  let settled = false;
+  const tryNotify = () => {
+    if (settled) return;
+    if (!isScopedConfigurationReady(resolveScopedConfiguration(component))) {
+      return;
+    }
+    settled = true;
+    onReady();
+  };
+
+  tryNotify();
+  if (settled) return () => {};
+
+  const cleanups: Array<() => void> = [];
+
+  const rafId = requestAnimationFrame(() => tryNotify());
+  cleanups.push(() => cancelAnimationFrame(rafId));
+
+  queueMicrotask(() => tryNotify());
+
+  const observer = new MutationObserver(() => tryNotify());
+  let node: SearchableDomElement | null = host;
+  while (node) {
+    if (node instanceof Element) {
+      observer.observe(node, {
+        attributes: true,
+        attributeFilter: [...SCOPE_WATCH_ATTRIBUTES],
+      });
+    }
+    node = (node.parentNode || (node as ShadowRoot).host) as SearchableDomElement;
+  }
+  cleanups.push(() => observer.disconnect());
+
+  return () => {
+    settled = true;
+    cleanups.forEach((cleanup) => cleanup());
+  };
+}
+
 type ApiGetState = {
   cleanupWatchers: Array<() => void>;
   requestGeneration: number;
   configPublisher: DataProvider | null;
   configMutationHandler: (() => void) | null;
+  scopeWatchCleanup: (() => void) | null;
 };
 
 function detachConfigPublisher(state: ApiGetState): void {
@@ -68,7 +165,8 @@ function detachConfigPublisher(state: ApiGetState): void {
  * Le path est un `Endpoint<T, Ue>` ; les placeholders `${nomPropriété}` sont résolus sur l'instance (`Ue` contraint l’hôte).
  *
  * **Scoped (défaut)** : `HTML.getApiConfiguration(host)` avec `host` = l’élément connecté
- * (`HTMLElement` / `ShadowRoot`). Sans hôte DOM valide, la propriété reste inchangée jusqu’à connexion.
+ * (`HTMLElement` / `ShadowRoot`). Si `serviceURL` n’est pas encore disponible (reflect Lit, scope
+ * ancêtre), le GET est différé jusqu’à ce que la config soit prête.
  *
  * **Deuxième paramètre** : `DataProviderKey<APIConfiguration>` — la config est lue via
  * `PublisherManager` sur le chemin résolu (même syntaxe dynamique que `@subscribe`).
@@ -138,6 +236,7 @@ export function get<T, Ue = any, Uk = any>(
           requestGeneration: 0,
           configPublisher: null,
           configMutationHandler: null,
+          scopeWatchCleanup: null,
         };
         comp[stateKey] = state;
       }
@@ -166,8 +265,15 @@ export function get<T, Ue = any, Uk = any>(
         } else {
           config = resolveScopedConfiguration(component);
         }
-        if (!config) {
-          comp[propertyKey] = undefined;
+        if (!isScopedConfigurationReady(config)) {
+          if (!usesPublisherConfig && !state.scopeWatchCleanup) {
+            const scopeWatch = watchScopedConfiguration(component, runFetch);
+            state.scopeWatchCleanup = scopeWatch;
+            state.cleanupWatchers.push(() => {
+              scopeWatch();
+              state.scopeWatchCleanup = null;
+            });
+          }
           return;
         }
         const generation = ++state.requestGeneration;
@@ -214,19 +320,24 @@ export function get<T, Ue = any, Uk = any>(
         }
         rebindPublisherConfig();
       } else {
-        if (isDynamicPath) {
-          for (const dependency of endpointDynamicDependencies) {
-            const unsubscribe = observeDynamicProperty(
-              getDynamicWatchKeys.watcherStore,
-              getDynamicWatchKeys.hooked,
-              component,
-              dependency,
-              () => runFetch(),
-            );
-            state.cleanupWatchers.push(unsubscribe);
+        const startScopedFetch = () => {
+          if (isDynamicPath) {
+            for (const dependency of endpointDynamicDependencies) {
+              const unsubscribe = observeDynamicProperty(
+                getDynamicWatchKeys.watcherStore,
+                getDynamicWatchKeys.hooked,
+                component,
+                dependency,
+                () => runFetch(),
+              );
+              state.cleanupWatchers.push(unsubscribe);
+            }
           }
-        }
-        runFetch();
+          runFetch();
+        };
+        state.cleanupWatchers.push(
+          scheduleAfterHostReady(component, startScopedFetch),
+        );
       }
     });
 

package/src/core/utils/HTML.ts

@@ -59,8 +59,37 @@ class HTML {
     return null;
   }
 
+  /** Noms d'attribut DOM à tester (Lit reflect → minuscules, ex. serviceURL → serviceurl). */
+  private static scopeAttributeNames(attributeName: string): string[] {
+    const lower = attributeName.toLowerCase();
+    return lower === attributeName ? [attributeName] : [attributeName, lower];
+  }
+
+  private static readScopeValueOnElement(
+    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);
+        if (attr != null && attr.length > 0) {
+          return attr;
+        }
+      }
+    }
+    return null;
+  }
+
   /**
-   * Va de parent en parent en partant de node pour trouver un attribut
+   * 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é
    */
@@ -69,16 +98,19 @@ class HTML {
     attributeName: string
   ): string | null {
     if (!node) return null;
-    while (!("hasAttribute" in node && node.hasAttribute(attributeName))) {
-      const newNode = node.parentNode || (node as ShadowRoot).host;
-      if (!newNode) break;
-      node = (node.parentNode ||
-        (node as ShadowRoot).host) as SearchableDomElement;
-    }
-    if (!("hasAttribute" in node)) {
-      return null;
+    let current: SearchableDomElement | null = node;
+    while (current) {
+      if (current instanceof HTMLElement) {
+        const value = HTML.readScopeValueOnElement(current, attributeName);
+        if (value != null && value.length > 0) {
+          return value;
+        }
+      }
+      const parent = current.parentNode || (current as ShadowRoot).host;
+      if (!parent) break;
+      current = parent as SearchableDomElement;
     }
-    return node.getAttribute(attributeName);
+    return null;
   }
 
   /**