@supersoniks/concorde 1.0.7 → 1.0.8

package/core/utils/LocationHandler.js

@@ -0,0 +1,96 @@
+/**
+ * Gestionnaire d'écoute des modifications sur l'url courante.
+ * On peut s'y abonner via la methode statique onChange()
+ * Utilisé par sonic-bouton pour lm'affichage de l'état actif et par le router.
+ */
+export default class LocationHandler {
+    static listen() {
+        if (!LocationHandler.listening) {
+            return;
+        }
+        let newURL = document.location.href.replace(document.location.origin, "");
+        if (LocationHandler.prevURL && LocationHandler.prevURL != newURL) {
+            LocationHandler.prevURL = newURL;
+            LocationHandler.listeners.forEach((listener) => {
+                listener.location = newURL;
+            });
+        }
+        window.requestAnimationFrame(LocationHandler.listen);
+    }
+    /**
+     * Arrête l'écoute des changements de location pour le listener fournit
+     */
+    static offChange(listener) {
+        let idx = LocationHandler.listeners.indexOf(listener);
+        if (idx == -1)
+            return;
+        LocationHandler.listeners.splice(idx, 1);
+        if (LocationHandler.listeners.length == 0)
+            LocationHandler.listening = false;
+    }
+    /**
+     * Ecoute les changements de location et l'assigne à la propriété location de chaque listener
+     */
+    static onChange(listener) {
+        if (!LocationHandler.listening) {
+            LocationHandler.listening = true;
+            LocationHandler.listen();
+        }
+        LocationHandler.listeners.push(listener);
+    }
+    /**
+     *
+     * @param component HTMLElement
+     * Recupère la proprité to ou href de l'élément et lance la navigation
+     * Si l'attribut pushState est présent la naviguation se fait via un pushState
+     * 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) {
+        let to = component.getAttribute("to");
+        if (!to)
+            to = component.href;
+        if (!to)
+            return;
+        if (to.indexOf("#") == 0) {
+            document.location.hash = to.substring(1);
+            return;
+        }
+        let url = new URL(to, document.location.href);
+        let split = url.pathname.split("/");
+        let newPathName = [];
+        let prevSp = "";
+        for (let sp of split) {
+            if (sp != prevSp)
+                newPathName.push(sp);
+            prevSp = sp;
+        }
+        to = "/" + newPathName.join("/") + url.search + (url.hash ? +url.hash : "");
+        if (component.hasAttribute("pushState")) {
+            history.pushState(null, "", to);
+        }
+        else if (component.hasAttribute("replaceState")) {
+            history.replaceState(null, "", to);
+        }
+        else
+            document.location.href = to;
+    }
+    /**
+     *
+     * @param component ActivableLink
+     * Ajoute l'attribut "active" à l'élément si l'url correspond à la location
+     */
+    static updateComponentActiveState(component) {
+        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);
+            if (url1.pathname == url2.pathname && url1.hash == url2.hash && url1.search == url2.search)
+                component.setAttribute("active", "true");
+            else
+                component.removeAttribute("active");
+        }
+    }
+}
+LocationHandler.listeners = [];
+LocationHandler.listening = false;
+LocationHandler.prevURL = document.location.href.replace(document.location.origin, "");

package/core/utils/Objects.d.ts

@@ -0,0 +1,23 @@
+declare class Objects {
+    /**
+     * Effectue une comparaison d'égalité non profonde entre deux objets.
+     */
+    static shallowEqual(object1: any, object2: any): boolean;
+    /**
+     * Effectue une comparaison d'égalité profonde entre deux objets.
+     */
+    static deepEqual(object1: any, object2: any): 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;
+    /**
+     * @returns true si l'argument est null ou undefined
+     */
+    static isUndefindOrNull(object: any): boolean;
+    /**
+     * traverse l'objet pour obtenir la valeur a l'adresse donnée via le tableau de clés pathArray.
+     */
+    static traverse(obj: any, pathArray: string[]): any;
+}
+export default Objects;

package/core/utils/Objects.js

@@ -0,0 +1,63 @@
+class Objects {
+    /**
+     * Effectue une comparaison d'égalité non profonde entre deux objets.
+     */
+    static shallowEqual(object1, object2) {
+        const keys1 = Object.keys(object1);
+        const keys2 = Object.keys(object2);
+        if (keys1.length !== keys2.length) {
+            return false;
+        }
+        for (let key of keys1) {
+            if (object1[key] !== object2[key]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Effectue une comparaison d'égalité profonde entre deux objets.
+     */
+    static deepEqual(object1, object2) {
+        const keys1 = Object.keys(object1);
+        const keys2 = Object.keys(object2);
+        if (keys1.length !== keys2.length) {
+            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)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * @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) {
+        return object != null && typeof object === "object";
+    }
+    /**
+     * @returns true si l'argument est null ou undefined
+     */
+    static isUndefindOrNull(object) {
+        return object === null || object === undefined;
+    }
+    /**
+     * traverse l'objet pour obtenir la valeur a l'adresse donnée via le tableau de clés pathArray.
+     */
+    static traverse(obj, pathArray) {
+        for (let key of pathArray) {
+            let newObj = obj[key];
+            if (newObj === undefined) {
+                return undefined;
+            }
+            obj = obj[key];
+        }
+        return obj;
+    }
+}
+export default Objects;

package/core/utils/PublisherProxy.d.mts

@@ -0,0 +1,110 @@
+/**
+ * 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;
+    _assignListeners_: Set<any>;
+    _mutationListeners_: Set<any>;
+    _fillListeners_: Set<any>;
+    _templateFillListeners_: Set<any>;
+    _lockInternalMutationPublishing_: boolean;
+    parent: any;
+    root: any;
+    /**
+     * Supprime le proxy et ses sous proxy
+     * Supprime les écouteurs associés
+     */
+    delete(): void;
+    /**
+     * Utile pour savoir si quelque chose est en écoute d'une modification sur le proxy via une des methodes associées
+     */
+    hasListener(): boolean;
+    _publishInternalMutation_(lockInternalMutationsTransmission?: boolean): void;
+    _publishAssignement_(lockInternalMutationsTransmission?: boolean): void;
+    _publishDynamicFilling_(key: any, value: any): void;
+    _publishTemplateFilling_(key: any, 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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
+     */
+    startTemplateFilling(handler: any): void;
+    /**
+     * Arrête  de maintenir le remplissage de l'objet / tableau "handler" passé en paramètre avec les valeurs du proxy
+     */
+    stopTemplateFilling(handler: any): void;
+    /**
+     * Maintient le remplissage de l'objet / tableau "handler" passé en paramètre avec les valeurs du proxy
+     * Remplit toute valeur qu'elle soit présente ou pas initialement dans l'objet
+     */
+    startDynamicFilling(handler: any): void;
+    stopDynamicFilling(handler: any): void;
+    /**
+     * 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;
+    /**
+     * Extraire la valeur actuelle du proxy
+     */
+    get(): any;
+}
+/**
+ * Utilitaires de gestion des Publisher
+ * Obtenir, replacer ou supprimer un Publisher
+ *
+*/
+export class PublisherManager {
+    static instance: null;
+    /**
+     * PublisherManager est un singleton
+     */
+    static getInstance(): 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;
+    /**
+     * 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>;
+    /**
+     * Obtenir un publisher vias sont id/adresse
+     * Si le publisher n'existe pas, il est créé.
+     */
+    get(id: any): any;
+    /**
+     * Remplace un publisher pour l'id fourni par un autre.
+     * L'autre publisher n'est pas supprimé.
+     */
+    set(id: any, publisher: any): 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;
+}
+/**
+ * Le Proxy Javascript
+ */
+export default class Publisher extends PublisherProxy {
+}

package/core/utils/PublisherProxy.mjs

@@ -0,0 +1,365 @@
+/**
+ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ * Merci de laisser ce fichier sans la moindre dépendance.
+ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ * **/
+function isComplex(value) {
+    return typeof value === "object" && value != null;
+}
+/**
+ * Custom Proxy contient les méthodes des publishers retournés par PublisherManager.get(publisherId) qui seront utilisées couramment
+ */
+export class PublisherProxy {
+    constructor(target, parentProxPub = null) {
+        this._proxies_ = new Map();
+        this._value_ = target;
+        this._assignListeners_ = new Set();
+        this._mutationListeners_ = new Set();
+        this._fillListeners_ = new Set();
+        this._templateFillListeners_ = new Set();
+        this._lockInternalMutationPublishing_ = false;
+        this.parent = parentProxPub;
+        this.root = this;
+        while (this.root.parent) {
+            this.root = this.root.parent;
+        }
+    }
+    /**
+     * Supprime le proxy et ses sous proxy
+     * Supprime les écouteurs associés
+     */
+    delete() {
+        for (let proxy of this._proxies_.values()) {
+            proxy.delete();
+        }
+        this._assignListeners_.clear();
+        this._mutationListeners_.clear();
+        this._fillListeners_.clear();
+        this._templateFillListeners_.clear();
+        this._proxies_.clear();
+    }
+    /**
+     * Utile pour savoir si quelque chose est en écoute d'une modification sur le proxy via une des methodes associées
+     */
+    hasListener() {
+        return (this._templateFillListeners_.size > 0 ||
+            this._assignListeners_.size > 0 ||
+            this._mutationListeners_.size > 0 ||
+            this._fillListeners_.size > 0);
+    }
+    _publishInternalMutation_(lockInternalMutationsTransmission = false) {
+        this._mutationListeners_.forEach((handler) => handler());
+        if (lockInternalMutationsTransmission)
+            return;
+        if (this.parent) {
+            this.parent._publishInternalMutation_();
+        }
+    }
+    _publishAssignement_(lockInternalMutationsTransmission = false) {
+        this._assignListeners_.forEach((handler) => handler(this._value_.__value ? this._value_.__value : this._value_));
+        this._publishInternalMutation_(lockInternalMutationsTransmission);
+    }
+    _publishDynamicFilling_(key, value) {
+        this._fillListeners_.forEach((handler) => {
+            if (handler[key] !== value)
+                handler[key] = value;
+        });
+        this._publishTemplateFilling_(key, value);
+    }
+    _publishTemplateFilling_(key, value) {
+        this._templateFillListeners_.forEach((handler) => {
+            if (typeof handler[key] != "undefined" && handler[key] !== value) {
+                handler[key] = value;
+            }
+        });
+    }
+    /**
+     * 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) {
+        if (typeof handler != "function")
+            return;
+        this._assignListeners_.add(handler);
+        handler(this._value_.__value ? this._value_.__value : this._value_);
+    }
+    /**
+     * 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) {
+        this._assignListeners_.delete(handler);
+    }
+    /**
+     * 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) {
+        if (typeof handler != "function")
+            return;
+        this._mutationListeners_.add(handler);
+        handler();
+    }
+    /**
+     * 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) {
+        this._mutationListeners_.delete(handler);
+    }
+    /**
+     * 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
+     */
+    startTemplateFilling(handler) {
+        this._templateFillListeners_.add(handler);
+        for (var z in this._value_) {
+            const value = this._value_[z];
+            if (typeof handler[z] != "undefined" && handler[z] !== value) {
+                handler[z] = value;
+            }
+        }
+    }
+    /**
+     * Arrête  de maintenir le remplissage de l'objet / tableau "handler" passé en paramètre avec les valeurs du proxy
+     */
+    stopTemplateFilling(handler) {
+        this._templateFillListeners_.delete(handler);
+    }
+    /**
+     * Maintient le remplissage de l'objet / tableau "handler" passé en paramètre avec les valeurs du proxy
+     * Remplit toute valeur qu'elle soit présente ou pas initialement dans l'objet
+     */
+    startDynamicFilling(handler) {
+        this._fillListeners_.add(handler);
+        for (var z in this._value_) {
+            const value = this._value_[z];
+            if (handler[z] !== value)
+                handler[z] = value;
+        }
+    }
+    /*
+     * Arrête  de maintenir le remplissage de l'objet / tableau "handler" passé en paramètre avec les valeurs du proxy
+     */
+    stopDynamicFilling(handler) {
+        this._fillListeners_.delete(handler);
+    }
+    /**
+     * Assigne une nouvelle valeur au proxy ce qui déclenche la transmission de la donnée en fonction des "écouteurs" associés
+     */
+    set(newValue, lockInternalMutationsTransmission = false) {
+        if (this._value_ === newValue)
+            return true;
+        if (this._value_.hasOwnProperty("__value") &&
+            newValue.hasOwnProperty("__value") &&
+            this._value_.__value === newValue.__value) {
+            return true;
+        }
+        this._value_ = newValue;
+        if (this._value_.hasOwnProperty("__value")) {
+            this._publishAssignement_(lockInternalMutationsTransmission);
+            return true;
+        }
+        Array.from(this._proxies_.keys()).forEach((key) => {
+            // delete this._value_[key];
+            if (!this._value_[key] && this._proxies_.has(key) && !this._proxies_.get(key).hasListener()) {
+                this._proxies_.delete(key);
+            }
+        });
+        if (isComplex(this._value_)) {
+            for (let key in this._value_) {
+                let v = newValue[key];
+                let isVComplex = isComplex(v);
+                let valueV = isVComplex ? v : { __value: v };
+                if (!this._proxies_.has(key)) {
+                    let newPublisher = new Publisher(valueV, this);
+                    this._proxies_.set(key, newPublisher, true);
+                    newPublisher._proxies_.set("_parent_", this);
+                }
+                this._proxies_.get(key).set(valueV, true);
+                this._publishDynamicFilling_(key, v);
+            }
+        }
+        this._publishAssignement_();
+        return true;
+    }
+    /**
+     * Extraire la valeur actuelle du proxy
+     */
+    get() {
+        if (this._value_.__value)
+            return this._value_.__value;
+        return this._value_;
+    }
+}
+/**
+ * Utilitaires de gestion des Publisher
+ * Obtenir, replacer ou supprimer un Publisher
+ *
+*/
+export class PublisherManager {
+    constructor() {
+        if (PublisherManager.instance != null)
+            throw "Singleton / use getInstance";
+        PublisherManager.instance = this;
+        this.publishers = new Map();
+    }
+    /**
+     * PublisherManager est un singleton
+     */
+    static getInstance() {
+        if (PublisherManager.instance == null)
+            return new PublisherManager();
+        return PublisherManager.instance;
+    }
+    /**
+     * 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) {
+        return PublisherManager.getInstance().get(id);
+    }
+    /**
+     * 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) {
+        return PublisherManager.getInstance().delete(id);
+    }
+    /**
+     * Obtenir un publisher vias sont id/adresse
+     * Si le publisher n'existe pas, il est créé.
+     */
+    get(id) {
+        if (!this.publishers.has(id))
+            this.publishers.set(id, new Publisher({}));
+        return this.publishers.get(id);
+    }
+    /**
+     * Remplace un publisher pour l'id fourni par un autre.
+     * L'autre publisher n'est pas supprimé.
+     */
+    set(id, publisher) {
+        this.publishers.set(id, publisher);
+    }
+    /**
+     * 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) {
+        if (!this.publishers.has(id))
+            return false;
+        const publisher = this.publishers.get(id);
+        this.publishers.delete(id);
+    }
+}
+PublisherManager.instance = null;
+/**
+ * Le Proxy Javascript
+ */
+export default class Publisher extends PublisherProxy {
+    constructor(target, parentProxPub = null) {
+        super(target, parentProxPub);
+        let that = this;
+        let thisProxy = new Proxy(this, {
+            /**
+             * Lorsque l'on écrit monConteneur =  publisher.maClef ou monConteneur = publisher["maClef"] monConteneur contient :
+             * Les methodes de PublisherProxy (onAssign... : voir liste dans kle tableaus si dessous), si la clef est une méthode de PublisherProxy,,
+             * Sinon un autre proxy qui a comme valeur interne la valeur corespondante à la clef dans l'objet.
+             */
+            get: function (oTarget, sKey) {
+                if ([
+                    "onAssign",
+                    "offAssign",
+                    "startDynamicFilling",
+                    "stopDynamicFilling",
+                    "startTemplateFilling",
+                    "stopTemplateFilling",
+                    "onInternalMutation",
+                    "offInternalMutation",
+                    "set",
+                    "get",
+                    "_templateFillListeners_",
+                    "_fillListeners_",
+                    "_assignListeners_",
+                    "_publishInternalMutation_",
+                    "hasListener",
+                    "delete",
+                    "_mutationListeners_",
+                    "_publishDynamicFilling_",
+                    "_publishTemplateFilling_",
+                    "_publishAssignement_",
+                    "_proxies_",
+                    "parent",
+                    "_value_",
+                    "_lockInternalMutationPublishing_",
+                ].includes(sKey))
+                    return that[sKey];
+                if (!that._proxies_.has(sKey)) {
+                    let vValue = that._value_[sKey];
+                    let newPublisher = new Publisher(isComplex(vValue) ? vValue : { __value: vValue }, that);
+                    newPublisher._proxies_.set("_parent_", thisProxy);
+                    that._proxies_.set(sKey, newPublisher);
+                }
+                return that._proxies_.get(sKey);
+            },
+            /**
+             * Lorsque l'on écrit publisher.maClef = value ou publisher["maClef"] = value, on assigne la valeur à la clef dans l'objet interne.
+             * Les gestionnairs associés sopnt déclenchés en conséquence de manière profonde et remontante si nécessaire.
+             */
+            set: function (oTarget, sKey, vValue) {
+                if (sKey == "_value_") {
+                    oTarget._value_ = vValue;
+                    return oTarget._value_;
+                }
+                const isValueComplex = isComplex(vValue);
+                if (!that._proxies_.has(sKey)) {
+                    let newPublisher = new Publisher(isValueComplex ? vValue : { __value: vValue }, that);
+                    newPublisher._proxies_.set("_parent_", thisProxy);
+                    that._proxies_.set(sKey, newPublisher);
+                }
+                if (that._value_[sKey] === vValue && isValueComplex)
+                    return vValue;
+                const prevValue = that._value_[sKey];
+                if (prevValue !== vValue) {
+                    that._value_[sKey] = vValue;
+                    that._publishDynamicFilling_(sKey, vValue);
+                }
+                that._proxies_.get(sKey).set(isComplex(vValue) ? vValue : { __value: vValue });
+                return that._proxies_.get(sKey);
+            },
+            /**
+             * Autres propriétés classiques d'un objet implémentées par le proxy
+             */
+            deleteProperty: function (oTarget, sKey) {
+                that._proxies_.get(sKey).set(null);
+                that._publishDynamicFilling_(sKey, null);
+                that._proxies_.delete(sKey);
+                return delete that._value_[sKey];
+            },
+            enumerate: function (oTarget, sKey) {
+                return that._value_.keys();
+            },
+            has: function (oTarget, sKey) {
+                return sKey in that._value_ && sKey != "_lockInternalMutationPublishing_";
+            },
+            defineProperty: function (oTarget, sKey, oDesc) {
+                if (oDesc && "value" in oDesc) {
+                    that._value_[sKey] = oDesc.value;
+                }
+                return that._value_;
+            },
+            getOwnPropertyDescriptor: function (oTarget, sKey) {
+                var vValue = that._value_[sKey];
+                return {
+                    enumerable: true,
+                    configurable: true,
+                };
+            },
+            ownKeys: function (target) {
+                if (that._value_.__value)
+                    return Object.keys(this._value_.__value);
+                return Object.keys(that._value_);
+            },
+        });
+        return thisProxy;
+    }
+}
+if (typeof module != "undefined")
+    module.exports = { Publisher: Publisher, PublisherManager: PublisherManager };