@supersoniks/concorde 4.7.0 → 4.7.4

package/package.json

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

package/public/robots.txt

@@ -0,0 +1,2 @@
+User-agent: *
+Disallow: /

package/src/core/components/ui/captcha/captcha.md

@@ -10,15 +10,3 @@
   </template>
 </sonic-code>
                 
-
-
-<sonic-code>
-  <template>
-  <sonic-captcha formDataProvider="captchaTestDataProvider">  
-    <sonic-submit serviceURL="https://atelier.julien.supersoniks.pro" endPoint="php/some-service.php" onclick>
-      <sonic-button class="mt-4">Submit with captcha</sonic-button>
-    </sonic-submit>
-  </sonic-captcha>
-  </template>
-</sonic-code>
-                

package/src/core/decorators/api.ts

@@ -47,11 +47,110 @@ 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;
+    };
+  }
+  // HTMLElement classique : config ancêtre déjà lisible ; sinon watchScopedConfiguration.
+  callback();
+  return () => {};
+}
+
+/**
+ * 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 +167,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 +238,7 @@ export function get<T, Ue = any, Uk = any>(
           requestGeneration: 0,
           configPublisher: null,
           configMutationHandler: null,
+          scopeWatchCleanup: null,
         };
         comp[stateKey] = state;
       }
@@ -166,8 +267,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 +322,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;
   }
 
   /**

package/php/get-challenge.php

@@ -1,34 +0,0 @@
-<?php
-/* *
- * Call get-challenge on auto-hosted latcha service at  https://altcha.supersoniks.org
- * */
-
-// Autoriser toutes les origines
-header("Access-Control-Allow-Origin: *");
-
-// Autoriser les méthodes HTTP spécifiques
-header("Access-Control-Allow-Methods: GET, POST, OPTIONS");
-
-// Autoriser certains en-têtes spécifiques
-header("Access-Control-Allow-Headers: Content-Type, Authorization");
-
-// Si la méthode est OPTIONS, terminer la requête ici
-if ($_SERVER['REQUEST_METHOD'] === 'OPTIONS') {
-    http_response_code(200);
-    exit();
-}
-
-function getChallenge($key){
-    $maxNumber=20000;
-    $queryString = $params = [
-        'key' => $key,
-        'maxNumber' => $maxNumber
-    ];
-    // Générer la chaîne de requête
-    $queryString = http_build_query($params);
-    $url = "https://altcha.supersoniks.org/get-challenge?key=".$queryString;
-    $response = file_get_contents($url);
-    return $response;
-}
-
-echo getChallenge($_GET['key']);

package/php/some-service.php

@@ -1,42 +0,0 @@
-<?php
-/* *
- * Call verify-solution on auto-hosted latcha service at  https://altcha.supersoniks.org
- * */ 
-
-
-// Autoriser toutes les origines
-header("Access-Control-Allow-Origin: *");
-
-// Autoriser les méthodes HTTP spécifiques
-header("Access-Control-Allow-Methods: GET, POST, OPTIONS");
-
-// Autoriser certains en-têtes spécifiques
-header("Access-Control-Allow-Headers: Content-Type, Authorization, x-altcha-spam-filter");
-
-// Si la méthode est OPTIONS, terminer la requête ici
-if ($_SERVER['REQUEST_METHOD'] === 'OPTIONS') {
-    http_response_code(200);
-    exit();
-}
-
-function verifySolution($key, $solution){
-    $queryString = $params = [
-        'key' => $key,
-        'altcha' => $solution
-    ];
-    // Générer la chaîne de requête
-    $queryString = http_build_query($params);
-    $url = "https://altcha.supersoniks.org/verify-solution?".$queryString;
-    $response = file_get_contents($url);
-    return $response;
-}
-
-/**
- * Get json posted data
- */
-
-// Get the posted data
-
-$data = json_decode(file_get_contents("php://input"));
-
-echo verifySolution($data->captchakey, $data->captchatoken);