@supersoniks/concorde 1.1.44 → 1.1.46

package/core/mixins/FormInput.d.ts

@@ -65,6 +65,7 @@ declare const Form: <T extends Constructor<FormElementInterface>>(superClass: T)
         getAttribute(name: string): string;
         hasAttribute(attributeName: string): boolean;
         disconnectedCallback(): void;
+        getBoundingClientRect(): DOMRect;
     };
 } & T;
 export default Form;

package/core/mixins/Subscriber.d.ts

@@ -30,6 +30,7 @@ export interface SubscriberInterface<PropsType = CoreJSType> {
     getAttribute(name: string): string;
     hasAttribute(attributeName: string): boolean;
     disconnectedCallback(): void;
+    getBoundingClientRect(): DOMRect;
 }
 declare const Subscriber: <PropsType = CoreJSType, T extends Constructor<LitElement> = Constructor<LitElement>>(superClass: T, type?: PropsType | undefined) => Constructor<SubscriberInterface<PropsType>> & T;
 export default Subscriber;

package/core/mixins/Subscriber.js

@@ -54,7 +54,7 @@ const Subscriber = (superClass, type) => {
             this.noAutoFill = false;
             this.forceAutoFill = false;
             /**
-             *
+             * Passer ce paramètre à true permet de ne pas mettre à jour le composant lors d'un changement de interne de la propriété nommé props.
              */
             this.renderOnPropsInternalChange = false;
             /**
@@ -132,27 +132,31 @@ const Subscriber = (superClass, type) => {
         }
         updated(_changedProperties) {
             super.updated(_changedProperties);
-            let ref = this.shadowRoot || this;
+            const ref = this.shadowRoot || this;
             const children = [...ref.children].filter((child) => child.tagName != "STYLE");
-            let display = this.displayContents ? "contents" : children.length == 0 ? "none" : null;
+            const display = this.displayContents ? "contents" : children.length == 0 ? "none" : null;
             if (display)
                 this.style.display = display;
             else
                 this.style.removeProperty("display");
         }
         connectedCallback() {
+            SubscriberElement.instanceCounter++;
             if (this.hasAttribute("lazyRendering")) {
                 const options = {
                     root: null,
-                    rootMargin: Math.max(window.innerWidth * 0.1, window.innerHeight * 0.1) + "px",
+                    rootMargin: Math.max(window.innerWidth, window.innerHeight) + "px",
                 };
                 let firstView = true;
                 const iObserver = new IntersectionObserver((entries) => {
                     for (const e of entries) {
                         if (firstView && e.isIntersecting) {
+                            this.addDebugger();
                             firstView = false;
                             this.initWording();
                             this.initPublisher();
+                            iObserver.disconnect();
+                            break;
                         }
                     }
                 }, options);
@@ -161,10 +165,9 @@ const Subscriber = (superClass, type) => {
             else {
                 this.initWording();
                 this.initPublisher();
+                this.addDebugger();
             }
-            this.addDebugger();
             super.connectedCallback();
-            SubscriberElement.instanceCounter++;
         }
         disconnectedCallback() {
             var _a;
@@ -253,14 +256,15 @@ const Subscriber = (superClass, type) => {
             const serviceURL = this.getAncestorAttributeValue("serviceURL");
             let userName = null;
             let password = null;
-            let tokenProvider = null;
+            const tokenProvider = this.getAncestorAttributeValue("tokenProvider");
+            const authToken = this.getAncestorAttributeValue("eventsApiToken");
             if (!token) {
                 userName = this.getAncestorAttributeValue("userName");
                 password = this.getAncestorAttributeValue("password");
-                tokenProvider = this.getAncestorAttributeValue("tokenProvider");
             }
             const credentials = this.getAncestorAttributeValue("credentials") || undefined;
-            return { serviceURL, token, userName, password, tokenProvider, addHTTPResponse, credentials };
+            const cache = (this.getAttribute("cache") || undefined) || undefined;
+            return { serviceURL, token, userName, password, authToken, tokenProvider, addHTTPResponse, credentials, cache };
         }
         initWording() {
             return __awaiter(this, void 0, void 0, function* () {
@@ -274,16 +278,17 @@ const Subscriber = (superClass, type) => {
                 }
                 if (!hasWording)
                     return;
-                const publisher = PublisherManager.getInstance().get("sonic-wording");
+                const publisher = PublisherManager.get("sonic-wording");
                 const wordingProvider = this.getAncestorAttributeValue("wordingProvider");
                 const api = new API(this.getApiConfiguration());
                 if (wordingProvider) {
                     const wordings = [];
                     const wordingsAll = [];
+                    const publisherValue = publisher.get();
                     for (const p of propNames) {
                         if (p.indexOf("wording_") == 0) {
                             const p8 = p.substring(8);
-                            if (!publisher.get()[p]) {
+                            if (!publisherValue[p]) {
                                 publisher[p] = "...";
                                 wordings.push(p8);
                             }
@@ -334,7 +339,7 @@ const Subscriber = (superClass, type) => {
                 if (this.bindPublisher) {
                     mng.set(publisherId, this.bindPublisher());
                 }
-                let pub = mng.get(publisherId);
+                let pub = mng.get(publisherId, { localStorageMode: this.getAttribute("localStorage") || "disabled" });
                 this.dataProvider = publisherId;
                 if (this.hasAttribute("subDataProvider")) {
                     const dataPath = this.getAttribute("subDataProvider");

package/core/utils/PublisherProxy.d.ts

@@ -3,7 +3,7 @@
  * Merci de laisser ce fichier sans la moindre dépendance en dehors de types du ceur.
  * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  * **/
-import { CoreJSType, PublisherContentType } from "../_types/types";
+import { PublisherInterface, CoreJSType, PublisherContentType } from "../_types/types";
 type DynamicFillingListener = any;
 type TemplateFillingListener = {
     propertyMap: Record<string, string>;
@@ -12,15 +12,19 @@ type TemplateFillingListener = {
  * Custom Proxy contient les méthodes des publishers retournés par PublisherManager.get(publisherId) qui seront utilisées couramment
  */
 export declare class PublisherProxy<T = any> {
+    static instances: Map<number, PublisherProxy<any>>;
+    static instancesCounter: number;
     _proxies_: Map<string, PublisherProxy>;
     _value_: T;
     _key_: string;
+    _is_savable_: boolean;
     _invalidateListeners_: Set<VoidFunction>;
     _assignListeners_: Set<(value: T) => void>;
     _mutationListeners_: Set<VoidFunction>;
     _fillListeners_: Set<Record<string, CoreJSType>>;
     _templateFillListeners_: Set<any>;
     _lockInternalMutationPublishing_: boolean;
+    _instanceCounter_: number;
     parent: PublisherProxy | null;
     root: PublisherProxy;
     constructor(target: T, parentProxPub: PublisherProxy | null);
@@ -91,6 +95,10 @@ export declare class PublisherProxy<T = any> {
      * Extraire la valeur actuelle du proxy
      */
     get(): T;
+    /**
+     * retourner le webcomponent auquel le proxy est associé
+     */
+    get $tag(): string;
 }
 /**
  * Utilitaires de gestion des Publisher
@@ -98,9 +106,19 @@ export declare class PublisherProxy<T = any> {
  *
  */
 export declare class PublisherManager {
+    static changed: boolean;
+    static saving: boolean;
+    static saveId: number;
     static instance: PublisherManager | null;
+    enabledLocaStorageProxies: string[];
     publishers: Map<string, Publisher<PublisherContentType>>;
+    localStorageData: Record<string, {
+        lastModifiationMS: number;
+        data: PublisherContentType;
+    }>;
+    isLocalStrorageReady: Promise<boolean> | null;
     constructor();
+    cleanStorageData(): Promise<unknown>;
     /**
      * PublisherManager est un singleton
      */
@@ -109,7 +127,9 @@ export declare 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: string): any;
+    static get(id: string, options?: {
+        localStorageMode?: 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
      */
@@ -118,7 +138,11 @@ export declare class PublisherManager {
      * Obtenir un publisher vias sont id/adresse
      * Si le publisher n'existe pas, il est créé.
      */
-    get(id: string): any;
+    setLocalData(publisher: PublisherInterface, id: string): Promise<void>;
+    initialisedData: string[];
+    get(id: string, options?: {
+        localStorageMode?: string;
+    }): any;
     /**
      * Remplace un publisher pour l'id fourni par un autre.
      * L'autre publisher n'est pas supprimé.
@@ -128,6 +152,9 @@ export declare class PublisherManager {
      * 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: string): boolean;
+    saveToLocalStorage(saveId?: number): Promise<void>;
+    compress(string: string, encoding: string): Promise<string>;
+    decompress(str: string, encoding: string): Promise<string>;
 }
 /**
  * Le Proxy Javascript

package/core/utils/PublisherProxy.js

@@ -1,4 +1,13 @@
 /* eslint-disable @typescript-eslint/no-explicit-any*/
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 function isComplex(value) {
     return typeof value === "object" && value != null;
 }
@@ -9,15 +18,18 @@ export class PublisherProxy {
     constructor(target, parentProxPub) {
         this._proxies_ = new Map();
         this._key_ = "";
+        this._is_savable_ = false;
         this._invalidateListeners_ = new Set();
         this._assignListeners_ = new Set();
         this._mutationListeners_ = new Set();
         this._fillListeners_ = new Set();
         this._templateFillListeners_ = new Set();
         this._lockInternalMutationPublishing_ = false;
+        this._instanceCounter_ = 0;
         this._value_ = target;
         this.parent = parentProxPub || null;
         this.root = this;
+        this._instanceCounter_ = 0;
         while (this.root.parent) {
             this.root = this.root.parent;
         }
@@ -36,6 +48,7 @@ export class PublisherProxy {
         this._fillListeners_.clear();
         this._templateFillListeners_.clear();
         this._proxies_.clear();
+        PublisherProxy.instances.delete(this._instanceCounter_);
     }
     /**
      * Utile pour savoir si quelque chose est en écoute d'une modification sur le proxy via une des methodes associées
@@ -51,6 +64,12 @@ export class PublisherProxy {
         this._mutationListeners_.forEach((handler) => handler());
         if (lockInternalMutationsTransmission)
             return;
+        if (!PublisherManager.changed && this._is_savable_) {
+            PublisherManager.changed = true;
+            PublisherManager.saveId++;
+            const saveId = PublisherManager.saveId;
+            setTimeout(() => PublisherManager.getInstance().saveToLocalStorage(saveId), 1000);
+        }
         if (this.parent) {
             this.parent._publishInternalMutation_();
         }
@@ -273,7 +292,21 @@ export class PublisherProxy {
         }
         return this._value_;
     }
+    /**
+     * retourner le webcomponent auquel le proxy est associé
+     */
+    get $tag() {
+        if (!this._instanceCounter_) {
+            PublisherProxy.instancesCounter++;
+            this._instanceCounter_ = PublisherProxy.instancesCounter;
+        }
+        PublisherProxy.instances.set(this._instanceCounter_, this);
+        const str = '<reactive-publisher-proxy publisher="' + this._instanceCounter_ + '"></reactive-publisher-proxy>';
+        return str;
+    }
 }
+PublisherProxy.instances = new Map();
+PublisherProxy.instancesCounter = 0;
 /**
  * Utilitaires de gestion des Publisher
  * Obtenir, replacer ou supprimer un Publisher
@@ -281,10 +314,59 @@ export class PublisherProxy {
  */
 export class PublisherManager {
     constructor() {
+        this.enabledLocaStorageProxies = [];
         this.publishers = new Map();
+        this.localStorageData = {};
+        this.isLocalStrorageReady = null;
+        this.initialisedData = [];
         if (PublisherManager.instance != null)
             throw "Singleton / use getInstance";
         PublisherManager.instance = this;
+        this.isLocalStrorageReady = this.cleanStorageData();
+    }
+    cleanStorageData() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => {
+                const doiIt = () => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        let compressedData = localStorage.getItem("publisher-proxies-data");
+                        let localStorageJSON = null;
+                        if (compressedData)
+                            localStorageJSON = yield this.decompress(compressedData, "gzip");
+                        if (localStorageJSON) {
+                            try {
+                                this.localStorageData = JSON.parse(localStorageJSON);
+                            }
+                            catch (e) {
+                                this.localStorageData = {};
+                            }
+                        }
+                        else {
+                            compressedData = yield this.compress("{}", "gzip");
+                            localStorage.setItem("publisher-proxies-data", compressedData);
+                            this.localStorageData = {};
+                        }
+                        const expires = new Date().getTime() - 1000 * 60 * 60 * 12;
+                        for (const key in this.localStorageData) {
+                            const item = this.localStorageData[key];
+                            if (item.lastModifiationMS < expires) {
+                                delete this.localStorageData[key];
+                            }
+                        }
+                        resolve(true);
+                        // compressedData = await this.compress(JSON.stringify(this.localStorageData), "gzip");
+                        // localStorage.setItem("publisher-proxies-data", compressedData);
+                    }
+                    catch (e) {
+                        window.requestAnimationFrame(() => {
+                            resolve(false);
+                        });
+                        console.log("no publisher cache in this browser");
+                    }
+                });
+                doiIt();
+            });
+        });
     }
     /**
      * PublisherManager est un singleton
@@ -298,8 +380,8 @@ 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) {
-        return PublisherManager.getInstance().get(id);
+    static get(id, options) {
+        return PublisherManager.getInstance().get(id, options);
     }
     /**
      * 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
@@ -311,9 +393,26 @@ export class PublisherManager {
      * 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({}));
+    setLocalData(publisher, id) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.isLocalStrorageReady;
+            publisher.set(((_a = this.localStorageData[id + "¤page:>" + document.location.pathname]) === null || _a === void 0 ? void 0 : _a.data) || publisher.get());
+        });
+    }
+    get(id, options) {
+        const hasLocalStorage = (options === null || options === void 0 ? void 0 : options.localStorageMode) === "enabled";
+        if (!this.publishers.has(id)) {
+            const data = {};
+            const publisher = new Publisher(data);
+            this.set(id, publisher);
+        }
+        const publisher = this.publishers.get(id);
+        if (hasLocalStorage && this.initialisedData.indexOf(id) === -1) {
+            publisher._is_savable_ = true;
+            this.initialisedData.push(id);
+            this.setLocalData(publisher, id);
+        }
         return this.publishers.get(id);
     }
     /**
@@ -332,7 +431,86 @@ export class PublisherManager {
         this.publishers.delete(id);
         return true;
     }
+    saveToLocalStorage(saveId = 0) {
+        return __awaiter(this, void 0, void 0, function* () {
+            /**
+             * si l'id a changé et que ce n'est pas un multiple de 10, on ne sauve pas
+             * on sauvegarde quand même tous les 10 au cas ou on aurrait des changements en continue, par exemple à chaque frame
+             */
+            if (saveId !== PublisherManager.saveId && saveId % 10 != 0)
+                return;
+            try {
+                if (!PublisherManager.changed || PublisherManager.saving)
+                    return;
+                PublisherManager.saving = true;
+                PublisherManager.changed = false;
+                const keys = Array.from(this.publishers.keys());
+                let hasChanged = false;
+                for (const key of keys) {
+                    const publisher = this.publishers.get(key);
+                    if (!(publisher === null || publisher === void 0 ? void 0 : publisher._is_savable_))
+                        continue;
+                    const data = publisher === null || publisher === void 0 ? void 0 : publisher.get();
+                    if (!data)
+                        continue;
+                    this.localStorageData[key + "¤page:>" + document.location.pathname] = {
+                        lastModifiationMS: new Date().getTime(),
+                        data: data,
+                    };
+                    hasChanged = true;
+                }
+                // on enregistre les données
+                if (hasChanged) {
+                    const compressedData = yield this.compress(JSON.stringify(this.localStorageData), "gzip");
+                    localStorage.setItem("publisher-proxies-data", compressedData);
+                }
+                PublisherManager.saving = false;
+                if (PublisherManager.changed) {
+                    PublisherManager.saveId++;
+                    const saveId = PublisherManager.saveId;
+                    setTimeout(() => this.saveToLocalStorage(saveId), 1000);
+                }
+            }
+            catch (e) {
+                PublisherManager.saving = false;
+            }
+        });
+    }
+    compress(string, encoding) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const byteArray = new TextEncoder().encode(string);
+            const win = window;
+            const cs = new win.CompressionStream(encoding);
+            const writer = cs.writable.getWriter();
+            writer.write(byteArray);
+            writer.close();
+            const result = yield new Response(cs.readable).arrayBuffer();
+            const arrayBufferView = new Uint8Array(result);
+            let str = "";
+            for (let i = 0; i < arrayBufferView.length; i++) {
+                str += String.fromCharCode(arrayBufferView[i]);
+            }
+            return btoa(str);
+        });
+    }
+    decompress(str, encoding) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const decodedString = atob(str);
+            const arrayBufferViewFromLocalStorage = Uint8Array.from(decodedString, (c) => c.charCodeAt(0));
+            const byteArray = arrayBufferViewFromLocalStorage.buffer;
+            const win = window;
+            const cs = new win.DecompressionStream(encoding);
+            const writer = cs.writable.getWriter();
+            writer.write(byteArray);
+            writer.close();
+            const result = yield new Response(cs.readable).arrayBuffer();
+            return new TextDecoder().decode(result);
+        });
+    }
 }
+PublisherManager.changed = false;
+PublisherManager.saving = false;
+PublisherManager.saveId = 0;
 PublisherManager.instance = null;
 /**
  * Le Proxy Javascript
@@ -361,6 +539,7 @@ export default class Publisher extends PublisherProxy {
                     "offInternalMutation",
                     "set",
                     "get",
+                    "$tag",
                     "_templateFillListeners_",
                     "_fillListeners_",
                     "_assignListeners_",
@@ -376,7 +555,9 @@ export default class Publisher extends PublisherProxy {
                     "_proxies_",
                     "parent",
                     "_value_",
+                    "_is_savable_",
                     "_lockInternalMutationPublishing_",
+                    "_instanceCounter_",
                 ].includes(sKey))
                     return publisherInstance[sKey];
                 if (!publisherInstance._proxies_.has(sKey)) {
@@ -396,7 +577,14 @@ export default class Publisher extends PublisherProxy {
                 //Fonctionnement pour la donnée interne pas de dispatch;
                 if (sKey == "_value_") {
                     publisherInstance._value_ = vValue;
-                    // return publisherInstance._value_;
+                    return true;
+                }
+                if (sKey == "_is_savable_") {
+                    publisherInstance._is_savable_ = vValue;
+                    return true;
+                }
+                if (sKey == "_instanceCounter_") {
+                    publisherInstance._instanceCounter_ = vValue;
                     return true;
                 }
                 //Création du publisher si il n'existe pas
@@ -463,3 +651,27 @@ export default class Publisher extends PublisherProxy {
 }
 if (typeof module != "undefined")
     module.exports = { Publisher: Publisher, PublisherManager: PublisherManager };
+// /**
+//  * A custom webcomponent wich will be linked to a publisher via its attribute "publisher"
+//  * the publisher will be found via PublisherManager.get(publisherId) and will be used to fill the component using the onAssign method
+//  */
+class PublisherWebComponent extends HTMLElement {
+    constructor() {
+        super();
+        this.publisherId = "";
+        this.onAssign = (value) => {
+            this.innerHTML = value.toString();
+        };
+    }
+    connectedCallback() {
+        var _a;
+        this.publisherId = this.getAttribute("publisher") || "";
+        this.publisher = PublisherProxy.instances.get(parseInt(this.publisherId));
+        (_a = this.publisher) === null || _a === void 0 ? void 0 : _a.onAssign(this.onAssign);
+    }
+    disconnectedCallback() {
+        var _a;
+        (_a = this.publisher) === null || _a === void 0 ? void 0 : _a.offAssign(this.onAssign);
+    }
+}
+customElements.define("reactive-publisher-proxy", PublisherWebComponent);

package/core/utils/api.d.ts

@@ -4,14 +4,24 @@ export type APIConfiguration = {
     token: string | null;
     userName: string | null;
     password: string | null;
+    authToken: string | null;
     tokenProvider: string | null;
     addHTTPResponse?: boolean;
     credentials?: RequestCredentials;
+    cache?: RequestCache;
 };
 export type ResultTypeInterface = CoreJSType & {
     _sonic_http_response_?: Response;
     text?: string;
 };
+export type APICall = {
+    apiMethod: "get" | "send" | "submitFormData";
+    path: string;
+    additionalHeaders: HeadersInit | undefined;
+    method?: string | undefined;
+    data?: unknown;
+    cache?: RequestCache;
+};
 declare class API {
     /**
      * Ce tableau static permet de ne pas appeler plusieurs fois le même service lors d'appel concurrents en GET.
@@ -32,11 +42,17 @@ declare class API {
     /**
      * le bearer token a passer pour les appels REST
      */
-    token: string | null | undefined;
+    private _token;
+    set token(token: string | null | undefined);
+    get token(): string | null | undefined;
     /**
      * Le endPoint pour obtenir le bearer token qui sera concaténé à l'url du service
      */
     tokenProvider: string | null;
+    /**
+     * le bearer token à passer pour un éventuel renouvellement de token automatique
+     */
+    authToken: string | null;
     /**
      * credentials
      */
@@ -45,13 +61,23 @@ declare class API {
      * Tableau static des tokens stokés en memoire vive (comportement à revoir à l'occasion)
      */
     static tokens: Map<string | null, string | null | undefined>;
+    /**
+     * Tableau stockant l'ensemble des tokens invalides
+     */
+    static invalidTokens: (string | null | undefined)[];
+    handleInvalidToken(token: string | null | undefined): void;
+    /**
+     * Tableau static des tentatives échouées de récupération auto du token
+     */
+    static failledTokenUpdates: Map<string | null, true>;
     /**
      * Le endPoint pour obtenir le bearer token qui sera concaténé à l'url du service
      */
     addHTTPResponse: boolean;
+    cache: RequestCache;
     lastResult?: Response;
     constructor(config: APIConfiguration);
-    handleResult(fetchResult?: Response): Promise<ResultTypeInterface>;
+    handleResult(fetchResult: Response, lastCall: APICall): Promise<ResultTypeInterface>;
     /**
      * Basic auth
      */
@@ -65,7 +91,7 @@ declare class API {
     /**
      * Concatène le serviceURL et le endpoint donné en paramètre
      */
-    computeURL(path: string): string;
+    computeURL(path: string, query?: Record<string, string>): string;
     send<T, SendType = CoreJSType>(path: string, data: SendType, method?: string, additionalHeaders?: HeadersInit): Promise<T & ResultTypeInterface>;
     /**
      * Agit comme une soumission de formulaire, mais attends un json en réponse