@supersoniks/concorde 1.1.42 → 1.1.43

package/core/utils/DataBindObserver.js

@@ -1,7 +1,8 @@
 import Format from "@supersoniks/concorde/core/utils/Format";
 import HTML from "@supersoniks/concorde/core/utils/HTML";
-import { PublisherManager } from "@supersoniks/concorde/core/utils/PublisherProxy.mjs";
+import { PublisherManager } from "@supersoniks/concorde/core/utils/PublisherProxy";
 /**
+ *
  * En appelant DataBindObserver.observe(HTMLElement) sun un élément html, tout les éléments peuvent être liés à au publisher a l'adresse déterminée parl'attribut dataProvider de l'un de ses ancêtres.
  * Pour cela un MutationObserver est créé pour observer les changements d'attributs de l'élément.
  * On peut alors ecrire ce genre de choses de manière a lier dynamiquement les données du publisher à l'élément html.
@@ -30,7 +31,9 @@ export default class DataBindObserver {
         opt.attributes = true;
         opt.attributeFilter = ["data-bind"];
         obs.observe(element, opt);
-        element.querySelectorAll("[data-bind]").forEach((e) => DataBindObserver.addPublisherListeners(e));
+        element
+            .querySelectorAll("[data-bind]")
+            .forEach((e) => DataBindObserver.addPublisherListeners(e));
         DataBindObserver.observedElements.set(element, obs);
     }
     /**
@@ -57,9 +60,7 @@ export default class DataBindObserver {
         if (elt.hasAttribute && elt.hasAttribute("data-bind"))
             DataBindObserver.removePublisherListeners(elt);
         if (elt.querySelectorAll)
-            elt
-                .querySelectorAll("[data-bind]")
-                .forEach((e) => DataBindObserver.removePublisherListeners(e));
+            elt.querySelectorAll("[data-bind]").forEach((e) => DataBindObserver.removePublisherListeners(e));
         else
             elt.childNodes.forEach((elt) => DataBindObserver.onRemoved(elt));
     }
@@ -94,7 +95,8 @@ export default class DataBindObserver {
             return;
         DataBindObserver.publisherListeners.delete(target);
         conf.forEach((currentConf) => {
-            currentConf.publisher.offAssign(currentConf.onAssign);
+            var _a;
+            (_a = currentConf.publisher) === null || _a === void 0 ? void 0 : _a.offAssign(currentConf.onAssign);
         });
     }
     /**
@@ -128,6 +130,8 @@ export default class DataBindObserver {
      * * Propriété "bindedVariablesDescriptor" du DataBindItem : voir la fonction getVariablesDescriptor
      */
     static getDataBindItems(element) {
+        if (!("attributes" in element))
+            return [];
         return Array.from(element.attributes)
             .filter((attribute) => attribute.name.indexOf("::") == 0)
             .map((e) => {
@@ -145,9 +149,13 @@ export default class DataBindObserver {
      * Il y a toujours un publisher quelque soit l'adresse ce qui permet de cibler des valeurs qui n'existent pas encore
      */
     static getSubPublisher(pub, pathArray) {
+        if (!pathArray)
+            return pub;
         for (let key of pathArray) {
             if (key == "_self_")
                 continue;
+            if (!pub)
+                return null;
             pub = pub[key];
         }
         return pub;
@@ -161,8 +169,7 @@ export default class DataBindObserver {
         /**
          * On récupère le publisher viea le dataProvider d'un ancêtre de l'élément.
          */
-        let node = target;
-        let dataProviderId = HTML.getAncestorAttributeValue(node.parentNode || node.host || node, "dataProvider");
+        let dataProviderId = HTML.getAncestorAttributeValue((target.parentNode || target.host || target), "dataProvider");
         if (!dataProviderId)
             return;
         let publisher = PublisherManager.getInstance().get(dataProviderId);
@@ -187,7 +194,8 @@ export default class DataBindObserver {
                     publisher: pub,
                     onAssign: () => {
                         let values = bindedVariablesDescriptor.variables.map((dataPath) => {
-                            return DataBindObserver.getSubPublisher(publisher, dataPath).get();
+                            var _a;
+                            return (_a = DataBindObserver.getSubPublisher(publisher, dataPath)) === null || _a === void 0 ? void 0 : _a.get();
                         });
                         let expression = bindedVariablesDescriptor.expression;
                         let hasUndeterminatedValue = false;
@@ -214,24 +222,12 @@ export default class DataBindObserver {
                         for (let i = 0; i < values.length; i++) {
                             let value = values[i];
                             let variable = bindedVariablesDescriptor.variables[i];
-                            if (value === null
-                            // Objects.isObject(value) &&
-                            // value.hasOwnProperty("__value") &&
-                            // Objects.isUndefindOrNull(value.__value)
-                            ) {
+                            if (value === null) {
                                 hasUndeterminatedValue = true;
                                 value = undefined;
                             }
                             expression = expression.replace("$" + variable.join("."), value);
                         }
-                        /**
-                         * Ce bout de code doit être un relicat
-                         */
-                        // if (Objects.isObject(expression) && !expression.hasOwnProperty("__value")) {
-                        //   rec[propertyToUpdate] = expression;
-                        //   return;
-                        // } else if (Objects.isObject(expression) && !expression.__value) expression = "";
-                        // else
                         if (expression.indexOf("|") != -1) {
                             let funcDelimiterIdx = expression.indexOf("|");
                             if (funcDelimiterIdx == 0) {
@@ -240,8 +236,8 @@ export default class DataBindObserver {
                             else {
                                 let funcName = expression.substring(0, funcDelimiterIdx);
                                 let funcArgs = expression.substring(funcDelimiterIdx + 1);
-                                let fmt = Format;
-                                expression = hasUndeterminatedValue ? "" : fmt[funcName] ? fmt[funcName](funcArgs) : expression;
+                                let fmtFunc = Format[funcName];
+                                expression = hasUndeterminatedValue ? "" : fmtFunc ? fmtFunc(funcArgs) : expression;
                             }
                         }
                         else {
@@ -250,7 +246,7 @@ export default class DataBindObserver {
                         rec[propertyToUpdate] = expression;
                     },
                 };
-                pub.onAssign(currentConf.onAssign);
+                pub === null || pub === void 0 ? void 0 : pub.onAssign(currentConf.onAssign);
                 conf.push(currentConf);
             }
         });
@@ -267,6 +263,5 @@ DataBindObserver.observedElements = new Map();
 DataBindObserver.enabled = true;
 DataBindObserver.publisherListeners = new Map();
 DataBindObserver.observe(document.documentElement);
-let win = window;
-if (!win.SonicDataBindObserver)
-    win.SonicDataBindObserver = DataBindObserver;
+if (!window.SonicDataBindObserver)
+    window.SonicDataBindObserver = DataBindObserver;

package/core/utils/Electron.d.ts

@@ -1,3 +1,7 @@
 export default class Electron {
-    static fixBlankLink(link: any): void;
+    static fixBlankLink(link: {
+        target: string | null;
+        href: string;
+        addEventListener: (type: string, callback: (e?: Event) => void) => void;
+    }): void;
 }

package/core/utils/Electron.js

@@ -1,9 +1,11 @@
 export default class Electron {
     static fixBlankLink(link) {
         const electronStr = "electron";
-        const electron = typeof require == 'undefined' ? null : require(electronStr);
+        const electron = typeof require == "undefined" ? null : require(electronStr);
         if (typeof electron && link.target == "_blank") {
-            link.addEventListener("click", () => { electron === null || electron === void 0 ? void 0 : electron.shell.openExternal(link.href); });
+            link.addEventListener("click", () => {
+                electron === null || electron === void 0 ? void 0 : electron.shell.openExternal(link.href);
+            });
         }
     }
 }

package/core/utils/HTML.d.ts

@@ -1,15 +1,22 @@
+export declare type SearchableDomElement = HTMLElement | ShadowRoot;
 declare class HTML {
     /**
      * retourne la langue de la page courante telle que défini via l'attribut lang de la balise html
      */
     static getLanguage(): string;
-    static getCookies(): any;
+    static getCookies(): Record<string, string>;
     /**
      * Va de parent en parent en partant de node pour trouver un attribut
      * @param attributeName nom de l'attribut
      * @returns valeur de l'attribut ou null si l'attribut n'est pas trouvé
      */
-    static getAncestorAttributeValue(node: any, attributeName: string): string | null;
+    static getAncestorAttributeValue(node: SearchableDomElement | null, attributeName: string): string | null;
+    /**
+     * Va de parent en parent en partant de node pour trouver un attribut
+     * @param attributeName nom de l'attribut
+     * @returns valeur de l'attribut ou null si l'attribut n'est pas trouvé
+     */
+    static getClosestForm(node: SearchableDomElement): SearchableDomElement | null;
     /**
      * Lance le chargement d'un js et retourne une promise qui resoud à true lorsque le chargement à réussi et à false, sinon.
      * */

package/core/utils/HTML.js

@@ -27,17 +27,36 @@ class HTML {
      * @returns valeur de l'attribut ou null si l'attribut n'est pas trouvé
      */
     static getAncestorAttributeValue(node, attributeName) {
-        while (!(node.hasAttribute && node.hasAttribute(attributeName))) {
+        if (!node)
+            return null;
+        while (!("hasAttribute" in node && node.hasAttribute(attributeName))) {
             const newNode = node.parentNode || node.host;
             if (!newNode)
                 break;
-            node = node.parentNode || node.host;
+            node = (node.parentNode || node.host);
         }
-        if (!node.hasAttribute) {
+        if (!("hasAttribute" in node)) {
             return null;
         }
         return node.getAttribute(attributeName);
     }
+    /**
+     * Va de parent en parent en partant de node pour trouver un attribut
+     * @param attributeName nom de l'attribut
+     * @returns valeur de l'attribut ou null si l'attribut n'est pas trouvé
+     */
+    static getClosestForm(node) {
+        while (!(node.nodeName && node.nodeName.toLowerCase() === "form")) {
+            const newNode = node.parentNode || node.host;
+            if (!newNode)
+                break;
+            node = (node.parentNode || node.host);
+        }
+        if (!node.nodeName) {
+            return null;
+        }
+        return node;
+    }
     /**
      * Lance le chargement d'un js et retourne une promise qui resoud à true lorsque le chargement à réussi et à false, sinon.
      * */

package/core/utils/LocationHandler.d.ts

@@ -1,10 +1,11 @@
 declare type Listener = {
     location: string;
 };
-declare type ActivableLink = {
-    location: string;
-    href: string;
-    autoActive: "strict" | "partial" | "disabled";
+declare type ActivableLink = HTMLElement & {
+    location?: string;
+    href?: string;
+    goBack?: string | null;
+    autoActive?: "strict" | "partial" | "disabled";
     setAttribute(name: string, value: string): void;
     removeAttribute(name: string): void;
 };
@@ -34,7 +35,7 @@ export default class LocationHandler {
      * Si l'attribut replaceState est présent la naviguation se fait via un replaceState
      * Voir link et button pour les exemples d'implémentation
      **/
-    static changeFromComponent(component: any): void;
+    static changeFromComponent(component: ActivableLink): void;
     /**
      *
      * @param component ActivableLink

package/core/utils/LocationHandler.js

@@ -39,6 +39,7 @@ export default class LocationHandler {
             LocationHandler.listen();
         }
         LocationHandler.listeners.push(listener);
+        listener.location = this.prevURL;
     }
     /**
      *
@@ -49,24 +50,34 @@ export default class LocationHandler {
      * Voir link et button pour les exemples d'implémentation
      **/
     static changeFromComponent(component) {
-        if (component.goBack !== null) {
+        const goBack = component.goBack;
+        const referrer = document.referrer;
+        if (goBack !== null && goBack !== undefined) {
             const origin = document.location.origin;
-            let urlDest = component.goBack || origin;
-            if ((document.referrer.indexOf("http") != 0 || new URL(document.referrer).origin != origin) && urlDest != document.location.href) {
+            let urlDest = goBack || origin;
+            const isHTTP = referrer.indexOf("http") == 0;
+            const isNotSameOrigin = isHTTP ? new URL(referrer).origin != origin : false;
+            const isReferrerEmpty = referrer == "";
+            const isFirstPage = history.length < 3; // imparfait mais variabsle selon les situations
+            const isFallbackNoReferer = isReferrerEmpty && isFirstPage; // fallback pour ff qui a parfois un referer nulle ex : drupal 9
+            const isNotSameURL = urlDest != document.location.href;
+            const goToURLDest = (isNotSameOrigin && isNotSameURL) || isFallbackNoReferer;
+            if (goToURLDest) {
                 let state = history.state || {};
                 state.concorde = state.concorde || {};
-                state.concorde.hasDoneHistoryBack = true; // maybe for debugging
+                state.concorde.hasDoneHistoryBack = true;
                 history.pushState(state, document.title);
                 history.back();
                 document.location.replace(urlDest);
             }
-            else
+            else {
                 history.back();
+            }
             return;
         }
-        let to = component.getAttribute("to");
+        let to = component.getAttribute("to") || "";
         if (!to)
-            to = component.href;
+            to = component.href || "";
         if (!to)
             return;
         if (to.indexOf("#") == 0) {
@@ -102,7 +113,7 @@ export default class LocationHandler {
             return;
         if (component.href && component.href.indexOf("http") != 0) {
             let url1 = new URL(component.href, document.location.href);
-            let url2 = new URL(component.location, document.location.origin);
+            let url2 = new URL(component.location || "", document.location.origin);
             let isActive = false;
             if (component.autoActive == "strict") {
                 isActive = url1.pathname == url2.pathname && url1.hash == url2.hash && url1.search == url2.search;

package/core/utils/Objects.d.ts

@@ -1,24 +1,27 @@
+import { TypeAndRecordOfType } from "../_types/types";
 declare class Objects {
     /**
      * Effectue une comparaison d'égalité non profonde entre deux objets.
      */
-    static shallowEqual(object1: any, object2: any): boolean;
+    static shallowEqual(object1: any, object2: any, useStrictComparaison?: boolean): boolean;
     /**
      * Effectue une comparaison d'égalité profonde entre deux objets.
      */
-    static deepEqual(object1: any, object2: any): boolean;
+    static deepEqual(object1: any, object2: any, useStrictComparaison?: boolean): boolean;
     /**
      * @returns true si l'objet est un objet ou un tableau (qui est un objet). mais false si null (car sinon typeof null "object")
      */
-    static isObject(object: any): boolean;
+    static isObject<T>(object: T): boolean;
     /**
      * @returns true si l'argument est null ou undefined
      */
-    static isUndefindOrNull(object: any): boolean;
+    static isUndefindOrNull<T>(object: T): boolean;
     /**
      * traverse l'objet pour obtenir la valeur a l'adresse donnée via le tableau de clés pathArray.
      * Si extendValues = true, les propriétés des objets parents sont copiées au fur et a mesure de la descente dans la hierarchie, avant l'assignation des propriétés de l'objet lui même.
      */
     static traverse(obj: any, pathArray: string[], extendValues?: boolean): any;
+    static getURLSearchArray(sourceObject?: TypeAndRecordOfType<string>, prefix?: string): string[];
+    static getURLSearchString(sourceObject: TypeAndRecordOfType<string>): string;
 }
 export default Objects;

package/core/utils/Objects.js

@@ -2,14 +2,17 @@ class Objects {
     /**
      * Effectue une comparaison d'égalité non profonde entre deux objets.
      */
-    static shallowEqual(object1, object2) {
+    static shallowEqual(object1, object2, useStrictComparaison = true) {
         const keys1 = Object.keys(object1);
         const keys2 = Object.keys(object2);
-        if (keys1.length !== keys2.length) {
+        if (keys1.length !== keys2.length && useStrictComparaison) {
             return false;
         }
         for (let key of keys1) {
-            if (object1[key] !== object2[key]) {
+            const val1 = object1[key];
+            const val2 = object2[key];
+            const areEqual = useStrictComparaison ? val1 !== val2 : val1 != val2;
+            if (areEqual) {
                 return false;
             }
         }
@@ -18,17 +21,18 @@ class Objects {
     /**
      * Effectue une comparaison d'égalité profonde entre deux objets.
      */
-    static deepEqual(object1, object2) {
+    static deepEqual(object1, object2, useStrictComparaison = true) {
         const keys1 = Object.keys(object1);
         const keys2 = Object.keys(object2);
-        if (keys1.length !== keys2.length) {
+        if (keys1.length !== keys2.length && useStrictComparaison) {
             return false;
         }
         for (const key of keys1) {
             const val1 = object1[key];
             const val2 = object2[key];
             const areObjects = Objects.isObject(val1) && Objects.isObject(val2);
-            if ((areObjects && !Objects.deepEqual(val1, val2)) || (!areObjects && val1 !== val2)) {
+            const areEqual = useStrictComparaison ? val1 !== val2 : val1 != val2;
+            if ((areObjects && !Objects.deepEqual(val1, val2)) || (!areObjects && areEqual)) {
                 return false;
             }
         }
@@ -65,5 +69,23 @@ class Objects {
         }
         return obj;
     }
+    static getURLSearchArray(sourceObject, prefix = "") {
+        let arr = [];
+        for (let key in sourceObject) {
+            let value = sourceObject[key];
+            if (prefix)
+                key = prefix + "[" + key + "]";
+            if (Objects.isObject(value)) {
+                arr = [...arr, ...this.getURLSearchArray(value, key)];
+            }
+            else {
+                arr.push(`${key}=${value}`);
+            }
+        }
+        return arr;
+    }
+    static getURLSearchString(sourceObject) {
+        return Objects.getURLSearchArray(sourceObject, "").join("&");
+    }
 }
 export default Objects;

package/core/utils/{PublisherProxy.d.mts → PublisherProxy.d.ts}

@@ -1,18 +1,23 @@
+declare type CoreJSType = Object | string | number | boolean | BigInt | undefined | null | symbol;
+declare type PublisherContentType = CoreJSType & {
+    __value?: any;
+} & Record<string, any>;
 /**
  * Custom Proxy contient les méthodes des publishers retournés par PublisherManager.get(publisherId) qui seront utilisées couramment
  */
-export class PublisherProxy {
-    constructor(target: any, parentProxPub?: null);
-    _proxies_: Map<any, any>;
-    _value_: any;
-    _invalidateListeners_: Set<any>;
-    _assignListeners_: Set<any>;
-    _mutationListeners_: Set<any>;
-    _fillListeners_: Set<any>;
-    _templateFillListeners_: Set<any>;
+export declare class PublisherProxy<T extends PublisherContentType = any> {
+    _proxies_: Map<string, PublisherProxy>;
+    _value_: T;
+    _key_: string;
+    _invalidateListeners_: Set<VoidFunction>;
+    _assignListeners_: Set<(value: T) => void>;
+    _mutationListeners_: Set<VoidFunction>;
+    _fillListeners_: Set<unknown>;
+    _templateFillListeners_: Set<unknown>;
     _lockInternalMutationPublishing_: boolean;
-    parent: any;
-    root: any;
+    parent: PublisherProxy | null;
+    root: PublisherProxy;
+    constructor(target: T, parentProxPub: PublisherProxy | null);
     /**
      * Supprime le proxy et ses sous proxy
      * Supprime les écouteurs associés
@@ -25,38 +30,38 @@ export class PublisherProxy {
     _publishInternalMutation_(lockInternalMutationsTransmission?: boolean): void;
     _publishAssignement_(lockInternalMutationsTransmission?: boolean): void;
     _publishInvalidation_(): void;
-    _publishDynamicFilling_(key: any, value: any): void;
-    _publishTemplateFilling_(key: any, value: any): void;
+    _publishDynamicFilling_(key: string, value: any): void;
+    _publishTemplateFilling_(key: string, value: any): void;
     /**
      * Appel la fonction "handler" (passée en paramettre) lorsque la valeur gérée par le proxy change par assignation
      * hanlder reçois alors la nouvelle valeur interne du proxy en paramètre
      */
-    onAssign(handler: any): void;
+    onAssign(handler: (value: T) => void): void;
     /**
      * Stop les appels de la fonction "handler" (passée en paramettre) lorsque la valeur gérée par le proxy change par assignation
      */
-    offAssign(handler: any): void;
+    offAssign(handler: (value: T) => void): void;
     /**
      * Appel la fonction "handler" (passée en paramettre) lorsque la donnée est flaggée comme invalide
      */
-    onInvalidate(handler: any): void;
+    onInvalidate(handler: VoidFunction | undefined): void;
     /**
      * Stop les appels de la fonction "handler" (passée en paramettre) lorsque la donnée est flaggée comme invalide
      */
-    offInvalidate(handler: any): void;
+    offInvalidate(handler: VoidFunction | undefined): void;
     /**
      * Flag les données comme étant invalides
      */
-    invalidate(handler: any): void;
+    invalidate(): void;
     /**
      * Appel la fonction "handler" (passée en paramettre) lorsque quelque chose change la valeur gérée par le proxy quelque soit la profondeur de la donnée
      *
      */
-    onInternalMutation(handler: any): void;
+    onInternalMutation(handler: VoidFunction | undefined): void;
     /**
      * Stop les Appels de la fonction "handler" (passée en paramettre) lorsque quelque chose change la valeur gérée par le proxy quelque soit la profondeur de la donnée
      */
-    offInternalMutation(handler: any): void;
+    offInternalMutation(handler: VoidFunction | undefined): void;
     /**
      * Maintient le remplissage de l'objet / tableau "handler" passé en paramètre avec les valeurs du proxy
      * Remplit uniquement les valeurs déjà présentes dans l'objet / tableau passé en paramètre
@@ -75,19 +80,21 @@ export class PublisherProxy {
     /**
      * Assigne une nouvelle valeur au proxy ce qui déclenche la transmission de la donnée en fonction des "écouteurs" associés
      */
-    set(newValue: any, lockInternalMutationsTransmission?: boolean): boolean;
+    set(newValue: T, lockInternalMutationsTransmission?: boolean): boolean;
     /**
      * Extraire la valeur actuelle du proxy
      */
-    get(): any;
+    get(): T;
 }
 /**
  * Utilitaires de gestion des Publisher
  * Obtenir, replacer ou supprimer un Publisher
  *
  */
-export class PublisherManager {
-    static instance: null;
+export declare class PublisherManager {
+    static instance: PublisherManager | null;
+    publishers: Map<string, Publisher<any>>;
+    constructor();
     /**
      * PublisherManager est un singleton
      */
@@ -96,29 +103,31 @@ export class PublisherManager {
      * shortcut static pour obtenir un publisher vias sont id/adresse sans taper getInstance.
      * Si le publisher n'existe pas, il est créé.
      */
-    static get(id: any): any;
+    static get(id: string): 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: any): false | undefined;
-    publishers: Map<any, any>;
+    static delete(id: string): boolean;
     /**
      * Obtenir un publisher vias sont id/adresse
      * Si le publisher n'existe pas, il est créé.
      */
-    get(id: any): any;
+    get(id: string): any;
     /**
      * Remplace un publisher pour l'id fourni par un autre.
      * L'autre publisher n'est pas supprimé.
      */
-    set(id: any, publisher: any): void;
+    set(id: string, publisher: Publisher): void;
     /**
      * supprimer un publisher de la liste et appel également delete sur le publisher ce qui le supprime, de même que ses sous publishers
      */
-    delete(id: any): false | undefined;
+    delete(id: string): boolean;
 }
 /**
  * Le Proxy Javascript
  */
-export default class Publisher extends PublisherProxy {
+export default class Publisher<T extends PublisherContentType = any> extends PublisherProxy<T> {
+    constructor(target: T, parentProxPub?: PublisherProxy | null);
+    getProperty<U, K extends keyof U>(o: U, propertyName: K): U[K];
 }
+export {};