@geogirafe/lib-geoportal 1.3.0-dev.2930448000 → 1.3.0-dev.2937711922

package/package.json

@@ -5,7 +5,7 @@
     "name": "GeoGirafe PSC",
     "url": "https://doc.geogirafe.org"
   },
-  "version": "1.3.0-dev.2930448000",
+  "version": "1.3.0-dev.2937711922",
   "type": "module",
   "engines": {
     "node": ">=20.19.0"

package/templates/public/about.json

@@ -1 +1 @@
-{"version":"1.3.0-dev.2930448000", "build":"2930448000", "date":"09/10/2026"}
+{"version":"1.3.0-dev.2937711922", "build":"2937711922", "date":"12/10/2026"}

package/tools/feedback/feedbackmanager.js

@@ -50,16 +50,16 @@ class FeedbackManager extends GirafeSingleton {
     }
     initializeFeedbackOnComponents() {
         this.config.feedback?.components?.forEach((component) => {
+            // Do nothing if a feedback was already given
             if (this.gaveFeedbackFor[component.name]) {
                 return;
             }
-            const componentsByName = this.context.componentManager.getComponentsByName(component.name);
-            for (const girafeHTMLElement of componentsByName) {
+            this.context.componentManager.registerComponentCallback(component.name, (girafeHTMLElement) => {
                 girafeHTMLElement.insertFeedbackTemplate(HTML_TEMPLATE.replace('${component-name}', component.name)
                     .replace('${question}', component.question)
                     .replace('${placement}', component.placement)
                     .replace('${margins}', component.margins ?? ''));
-            }
+            });
         });
     }
 }

package/tools/state/componentManager.d.ts

@@ -4,10 +4,11 @@ type Callback = (elem: GirafeHTMLElement) => unknown;
 type Constructor<T> = new (...args: never[]) => T;
 export default class ComponentManager extends GirafeSingleton {
     private readonly components;
-    private readonly registeredCallbacks;
-    private readonly registeredCallbacksClasses;
+    private readonly componentsCallbacks;
     registerComponent(component: GirafeHTMLElement): void;
+    registerComponentCallback(componentName: string, callback: Callback): void;
     registerComponentCallback(component: Constructor<GirafeHTMLElement>, callback: Callback): void;
+    private getRegisteredComponentsForEntry;
     getComponents<T extends GirafeHTMLElement>(type: Constructor<T>): T[];
     getComponentsByName(name: string): GirafeHTMLElement[];
 }

package/tools/state/componentManager.js

@@ -1,20 +1,41 @@
 import GirafeSingleton from '../../base/GirafeSingleton.js';
 export default class ComponentManager extends GirafeSingleton {
     components = {};
-    registeredCallbacks = [];
-    registeredCallbacksClasses = [];
+    componentsCallbacks = [];
     registerComponent(component) {
         this.components[component.name] ??= [];
         this.components[component.name].push(component);
-        for (let i = 0; i < this.registeredCallbacksClasses.length; i++) {
-            if (component instanceof this.registeredCallbacksClasses[i]) {
-                this.registeredCallbacks[i].forEach((callback) => callback(component));
+        for (const componentCallbacks of this.componentsCallbacks) {
+            if ((componentCallbacks.componentType && component instanceof componentCallbacks.componentType) ||
+                (componentCallbacks.componentName && componentCallbacks.componentName === component.name)) {
+                componentCallbacks.callbacks.forEach((callback) => callback(component));
             }
         }
     }
-    registerComponentCallback(component, callback) {
-        this.registeredCallbacksClasses.push(component);
-        this.registeredCallbacks.push([callback]);
+    registerComponentCallback(componentOrName, callback) {
+        const componentType = typeof componentOrName !== 'string' ? componentOrName : undefined;
+        const componentName = typeof componentOrName === 'string' ? componentOrName : undefined;
+        let entry = this.componentsCallbacks.find((c) => c.componentType === componentType && c.componentName === componentName);
+        if (entry) {
+            entry.callbacks.push(callback);
+        }
+        else {
+            entry = { componentType, componentName, callbacks: [callback] };
+            this.componentsCallbacks.push(entry);
+        }
+        // If some components were already registered, the callback is called directly on them.
+        for (const registeredComponent of this.getRegisteredComponentsForEntry(componentType, componentName)) {
+            callback(registeredComponent);
+        }
+    }
+    getRegisteredComponentsForEntry(componentType, componentName) {
+        if (componentName) {
+            return this.components[componentName] ?? [];
+        }
+        if (componentType) {
+            return this.getComponents(componentType);
+        }
+        return [];
     }
     getComponents(type) {
         return Object.values(this.components)