@supersoniks/concorde 1.1.45 → 1.1.46

package/core/mixins/Fetcher.d.ts

@@ -54,7 +54,7 @@ declare const Fetcher: <T extends Constructor<SubscriberInterface<PropsType>>, P
         /**
          * Première update, le comportement de lazyload est géré ici a l'aide d'un intersection observer.
          */
-        firstUpdated(): void;
+        handleLazyLoad(): void;
         onIntersection(entries: IntersectionObserverEntry[]): void;
         propertyMap: object;
         isConnected: boolean;
@@ -80,6 +80,7 @@ declare const Fetcher: <T extends Constructor<SubscriberInterface<PropsType>>, P
         requestUpdate(): void;
         getAttribute(name: string): string;
         hasAttribute(attributeName: string): boolean;
+        getBoundingClientRect(): DOMRect;
     };
 } & T;
 export default Fetcher;

package/core/mixins/Fetcher.js

@@ -87,29 +87,46 @@ const Fetcher = (superClass, propsType) => {
                     return;
                 // if (!this.dataProvider) return;
                 this.dispatchEvent(new CustomEvent("loading", { detail: this }));
-                this.isLoading = true;
-                this.requestUpdate();
+                if (this.getAttribute("localStorage") === "enabled") {
+                    yield PublisherManager.getInstance().isLocalStrorageReady;
+                }
+                if (!this.isConnected)
+                    return;
                 const hasLoader = this.isDefaultLoaderEnabled && !this.hasAttribute("noLoader");
-                if (hasLoader)
+                if (hasLoader) {
                     Loader.show();
+                }
                 const headerData = PublisherManager.getInstance()
                     .get(this.getAncestorAttributeValue("headersDataProvider"))
                     .get();
+                this.isLoading = true;
+                if (Objects.isObject(this.props) && Object.keys(this.props || {}).length > 0 && this.isFirstLoad) {
+                    this.dispatchEvent(new CustomEvent("load", { detail: this }));
+                    this.isFirstLoad = false;
+                    this.isLoading = false;
+                }
                 let data = yield this.api.get(this.endPoint || this.dataProvider || "", headerData);
+                if (!this.isConnected) {
+                    if (hasLoader)
+                        Loader.hide();
+                    return;
+                }
                 // Je garde ça mais normalement ça n'arrive jamais
                 if (!data) {
                     SonicToast.add({ text: "Network Error", status: "error" });
                     this.isLoading = false;
-                    if (hasLoader)
+                    if (hasLoader) {
                         Loader.hide();
+                    }
                     return;
                 }
                 // Si data ne contient que la réponse HTTP, avec un statut not ok, on affiche un message
                 else if (data._sonic_http_response_ && !data._sonic_http_response_.ok && Object.keys(data).length === 1) {
                     SonicToast.add({ text: "Network Error", status: "error" });
                 }
-                if (hasLoader)
+                if (hasLoader) {
                     Loader.hide();
+                }
                 if (this.key) {
                     const response = data._sonic_http_response_;
                     /* preserveOtherKeys s'exprime lorsque le paramètre "key" est défini
@@ -138,11 +155,10 @@ const Fetcher = (superClass, propsType) => {
         connectedCallback() {
             var _a;
             // this.noShadowDom = "";
+            super.connectedCallback();
             if (!this.isFetchEnabled) {
-                super.connectedCallback();
                 return;
             }
-            super.connectedCallback();
             this.key = this.getAttribute("key");
             if (this.props) {
                 this.publisher.set(this.props);
@@ -153,25 +169,38 @@ const Fetcher = (superClass, propsType) => {
             if (lazyLoad === null) {
                 this._fetchData();
             }
+            else {
+                this.handleLazyLoad();
+            }
         }
         /**
          * Première update, le comportement de lazyload est géré ici a l'aide d'un intersection observer.
          */
-        firstUpdated() {
+        handleLazyLoad() {
             const lazyLoad = this.getAttribute("lazyload");
             if (lazyLoad === null) {
                 return;
             }
+            const rect = this.getBoundingClientRect();
+            if (rect.x < window.innerWidth && rect.right > 0 && rect.y < window.innerHeight && rect.right > 0) {
+                this._fetchData();
+                return;
+            }
+            const boundsRatio = parseFloat(this.getAttribute("lazyBoundsRatio") || "1");
             const options = {
                 root: null,
-                rootMargin: Math.max(window.innerWidth, window.innerHeight) + "px",
+                rootMargin: Math.max(window.innerWidth * boundsRatio, window.innerHeight * boundsRatio) + "px",
             };
             this.iObserver = new IntersectionObserver((entries) => this.onIntersection(entries), options);
-            let elt = this.shadowRoot ? this.shadowRoot.children[0] : this.children[0];
+            /**
+             * on retire cette partie car finalement on mets systématiquement un span pour la détection de l'intersection
+             */
+            let elt = (this.shadowRoot ? this.shadowRoot.children[0] : this.children[0]);
             if (elt && elt.nodeName.toLocaleLowerCase() == "slot")
                 elt = elt.children[0];
             if (!elt || elt.nodeName.toLocaleLowerCase() == "template") {
                 elt = document.createElement("span");
+                // const elt = document.createElement("span");
                 this.appendChild(elt);
             }
             if (elt) {
@@ -182,9 +211,12 @@ const Fetcher = (superClass, propsType) => {
             }
         }
         onIntersection(entries) {
+            var _a;
             for (const e of entries) {
                 if (e.isIntersecting && this.isFirstLoad) {
                     this._fetchData();
+                    (_a = this.iObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
+                    break;
                 }
             }
         }

package/core/mixins/FormCheckable.d.ts

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

package/core/mixins/FormElement.d.ts

@@ -11,6 +11,7 @@ export interface FormElementInterface extends SubscriberInterface {
     getValueForFormPublisher(): FormElementValue;
     validateFormElement(): void;
     focus?: () => void;
+    forceAutoFill: boolean;
     shadowRoot?: ShadowRoot;
     error: boolean;
     autofocus: boolean;

package/core/mixins/FormElement.js

@@ -74,7 +74,8 @@ const Form = (superClass) => {
         }
         getFormPublisher() {
             if (!this.formDataProvider)
-                this.formDataProvider = this.getAncestorAttributeValue("formDataProvider");
+                this.formDataProvider =
+                    this.getAncestorAttributeValue("formDataProvider");
             if (this.formDataProvider) {
                 return PublisherManager.get(this.formDataProvider);
             }
@@ -120,7 +121,9 @@ const Form = (superClass) => {
         }
         initPublisher() {
             let formPublisher = this.getFormPublisher();
-            const value = this.hasAncestorAttribute("initFromPublisher") && this._name && formPublisher[this._name].get()
+            const value = this.hasAncestorAttribute("initFromPublisher") &&
+                this._name &&
+                formPublisher[this._name].get()
                 ? formPublisher[this._name].get()
                 : this.getAttribute("value");
             if (this._name && this.publisher)
@@ -219,6 +222,7 @@ const Form = (superClass) => {
                 if (elt && elt.focus) {
                     elt.focus();
                     e.preventDefault();
+                    e.stopPropagation();
                 }
             });
         }

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

@@ -141,18 +141,22 @@ const Subscriber = (superClass, type) => {
                 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;
@@ -260,7 +263,8 @@ const Subscriber = (superClass, type) => {
                 password = this.getAncestorAttributeValue("password");
             }
             const credentials = this.getAncestorAttributeValue("credentials") || undefined;
-            return { serviceURL, token, userName, password, authToken, 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