@supersoniks/concorde 2.0.2 → 2.0.4

package/core/utils/PublisherProxy.js

@@ -1,7 +1,12 @@
-/* eslint-disable @typescript-eslint/no-explicit-any*/
+import HTML from "./HTML";
 function isComplex(value) {
     return typeof value === "object" && value != null;
 }
+const queueTaskPromise = async () => {
+    return new Promise((resolve) => {
+        window.queueMicrotask(() => resolve(null));
+    });
+};
 /**
  * Custom Proxy contient les méthodes des publishers retournés par PublisherManager.get(publisherId) qui seront utilisées couramment
  */
@@ -16,6 +21,7 @@ export class PublisherProxy {
         this._templateFillListeners_ = new Set();
         this._lockInternalMutationPublishing_ = false;
         this._instanceCounter_ = 0;
+        this._assignmentId_ = 0;
         this._value_ = target;
         this.parent = parentProxPub || null;
         this.root = this;
@@ -52,20 +58,26 @@ export class PublisherProxy {
     }
     _publishInternalMutation_(lockInternalMutationsTransmission = false) {
         this._mutationListeners_.forEach((handler) => handler());
-        if (lockInternalMutationsTransmission)
-            return;
-        if (!PublisherManager.changed && this._is_savable_) {
+        if (this._is_savable_ && !PublisherManager.changed) {
             PublisherManager.changed = true;
             PublisherManager.saveId++;
             const saveId = PublisherManager.saveId;
             setTimeout(() => PublisherManager.getInstance().saveToLocalStorage(saveId), 1000);
         }
+        if (lockInternalMutationsTransmission)
+            return;
         if (this.parent) {
             this.parent._publishInternalMutation_();
         }
     }
-    _publishAssignement_(lockInternalMutationsTransmission = false) {
-        this._assignListeners_.forEach((handler) => handler(this.get()));
+    async _publishAssignement_(lockInternalMutationsTransmission = false) {
+        this._assignmentId_++;
+        const currentId = this._assignmentId_;
+        await queueTaskPromise();
+        if (currentId !== this._assignmentId_)
+            return;
+        const newValue = this.get();
+        this._assignListeners_.forEach((handler) => handler(newValue));
         this._publishInternalMutation_(lockInternalMutationsTransmission);
     }
     _publishInvalidation_() {
@@ -98,6 +110,8 @@ export class PublisherProxy {
     onAssign(handler, directHandlerCall = true) {
         if (typeof handler != "function")
             return;
+        if (this._assignListeners_.has(handler))
+            return;
         this._assignListeners_.add(handler);
         if (directHandlerCall)
             handler(this.get());
@@ -194,7 +208,7 @@ 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, lockInternalMutationsTransmission = false) {
+    async set(newValue, lockInternalMutationsTransmission = false) {
         /**
          * On retounre tout de suite si la valeur n'a pas changé
          */
@@ -211,13 +225,14 @@ export class PublisherProxy {
          */
         const prevValue = this._value_;
         this._value_ = isComplex(newValue) ? newValue : { __value: newValue };
+        this._cachedGet_ = undefined;
         /**
          * Si il s'agit d'une valeur primitive (un entier, une chaine ) la valeure en renseignée par un objet contenant la vaeur {__value}
          * On publie juste et on sen va.
          */
         const isPrimitiveValue = Object.prototype.hasOwnProperty.call(this._value_, "__value");
         if (isPrimitiveValue) {
-            this._publishAssignement_(lockInternalMutationsTransmission);
+            await this._publishAssignement_(lockInternalMutationsTransmission);
             return true;
         }
         /**
@@ -227,30 +242,28 @@ export class PublisherProxy {
          * On publie les maj au fur et a mesure de modifications
          */
         for (const key in this._value_) {
-            if (typeof this._value_[key] === "undefined")
+            if (this._value_[key] === undefined)
                 delete this._value_[key];
         }
-        Array.from(this._proxies_.keys()).forEach((key) => {
+        this._proxies_.forEach((_subProxy, key) => {
             /**
              * On supprime les proxys qui ne sont plus dans la nouvelle valeur si ils n'on pas d'écouteurs
              **/
-            if (typeof this._value_[key] === "undefined" && this._proxies_.has(key)) {
-                const subProxy = this._proxies_.get(key);
-                if (!subProxy?.hasListener()) {
-                    this._proxies_.delete(key);
-                }
-                else {
-                    if (key != "_parent_") {
-                        if (prevValue[key])
-                            this._value_[key] = null;
-                    }
+            if (this._value_[key] === undefined) {
+                // if (!_subProxy?.hasListener()) {
+                //   // this._proxies_.delete(key);
+                // } else {
+                if (key != "_parent_") {
+                    if (prevValue[key])
+                        this._value_[key] = null;
                 }
+                // }
             }
         });
         /**
          * On prévient les écouteurs que la valeur a changé
          */
-        this._publishAssignement_();
+        await this._publishAssignement_();
         /**
          * Si la donnée est complexe (objet, tableau)
          * on crée les proxys pour les sous-éléments qui n'en on pas
@@ -262,27 +275,29 @@ export class PublisherProxy {
                 const isVComplex = isComplex(v);
                 const valueV = isVComplex ? v : { __value: v };
                 if (!this._proxies_.has(key)) {
-                    const newPublisher = new Publisher({}, this);
-                    this._proxies_.set(key, newPublisher);
-                    newPublisher._proxies_.set("_parent_", this);
+                    // A surveiller ancienne version
+                    // const newPublisher = new Publisher({}, this);
+                    // this._proxies_.set(key, newPublisher);
+                    // newPublisher._proxies_.set("_parent_", this);
+                    this._publishDynamicFilling_(key, v);
+                    continue;
                 }
-                this._proxies_.get(key)?.set(valueV, true);
+                await this._proxies_.get(key)?.set(valueV, true);
                 this._publishDynamicFilling_(key, v);
             }
         }
         return true;
     }
-    /**
-     * Extraire la valeur actuelle du proxy
-     */
     get() {
+        if (this._cachedGet_ !== undefined)
+            return this._cachedGet_;
         if (PublisherManager.modifiedCollectore.length > 0)
             PublisherManager.modifiedCollectore[0].add(this);
         if (Object.prototype.hasOwnProperty.call(this._value_, "__value")) {
             const v = this._value_.__value;
-            return (v != undefined ? v : null);
+            return (this._cachedGet_ = (v != undefined ? v : null));
         }
-        return this._value_;
+        return (this._cachedGet_ = this._value_);
     }
     /**
      * retourner le webcomponent auquel le proxy est associé
@@ -299,11 +314,9 @@ export class PublisherProxy {
 }
 PublisherProxy.instances = new Map();
 PublisherProxy.instancesCounter = 0;
-/**
- * Utilitaires de gestion des Publisher
- * Obtenir, replacer ou supprimer un Publisher
- *
- */
+if (typeof __BUILD_DATE__ === "undefined") {
+    window.__BUILD_DATE__ = "No build date";
+}
 export class PublisherManager {
     constructor() {
         this.enabledLocaStorageProxies = [];
@@ -383,6 +396,8 @@ export class PublisherManager {
      * 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) {
+        if (!id)
+            return false;
         return PublisherManager.getInstance().delete(id);
     }
     /**
@@ -391,7 +406,7 @@ export class PublisherManager {
      */
     async setLocalData(publisher, id) {
         await this.isLocalStrorageReady;
-        publisher.set(this.localStorageData[id + "¤page:>" + document.location.pathname]?.data || publisher.get());
+        publisher.set(this.localStorageData[id + "¤lang_" + HTML.getLanguage()]?.data || publisher.get());
     }
     get(id, options) {
         const hasLocalStorage = options?.localStorageMode === "enabled";
@@ -416,7 +431,15 @@ export class PublisherManager {
         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
+     * @warning
+     * !!!!! ATTENTION !!!!!
+     * Il est fort à aprier que vous ne voulez pas utiliser cette methode
+     * Il s'agit d'une supression complete
+     * * du publisher de la liste
+     * * des bindings
+     * * de même que ses sous publishers
+     *
+     * UTILISEZ PLUTÔT la méthode publisher.set({}) pour réinitialiser un publisher sans perdre les ecouteurs
      */
     delete(id) {
         if (!this.publishers.has(id))
@@ -445,7 +468,7 @@ export class PublisherManager {
                 const data = publisher?.get();
                 if (!data)
                     continue;
-                this.localStorageData[key + "¤page:>" + document.location.pathname] = {
+                this.localStorageData[key + "¤lang_" + HTML.getLanguage()] = {
                     lastModifiationMS: new Date().getTime(),
                     data: data,
                 };
@@ -495,11 +518,48 @@ export class PublisherManager {
         return new TextDecoder().decode(result);
     }
 }
+PublisherManager.buildDate = __BUILD_DATE__;
 PublisherManager.changed = false;
 PublisherManager.saving = false;
 PublisherManager.saveId = 0;
 PublisherManager.instance = null;
 PublisherManager.modifiedCollectore = [];
+const internalProps = new Set([
+    "invalidate",
+    "onInvalidate",
+    "offInvalidate",
+    "onAssign",
+    "offAssign",
+    "startDynamicFilling",
+    "stopDynamicFilling",
+    "startTemplateFilling",
+    "stopTemplateFilling",
+    "onInternalMutation",
+    "offInternalMutation",
+    "set",
+    "get",
+    "$tag",
+    "_cachedGet_",
+    "_templateFillListeners_",
+    "_fillListeners_",
+    "_assignListeners_",
+    "_invalidateListeners_",
+    "_publishInternalMutation_",
+    "hasListener",
+    "delete",
+    "_mutationListeners_",
+    "_publishDynamicFilling_",
+    "_publishInvalidation_",
+    "_publishTemplateFilling_",
+    "_publishAssignement_",
+    "_proxies_",
+    "parent",
+    "_value_",
+    "_is_savable_",
+    "_lockInternalMutationPublishing_",
+    "_instanceCounter_",
+    "_assignmentId_",
+]);
 /**
  * Le Proxy Javascript
  */
@@ -516,40 +576,7 @@ export default class Publisher extends PublisherProxy {
                 if (sKey == Symbol.toPrimitive) {
                     return () => thisProxy.get();
                 }
-                if ([
-                    "invalidate",
-                    "onInvalidate",
-                    "offInvalidate",
-                    "onAssign",
-                    "offAssign",
-                    "startDynamicFilling",
-                    "stopDynamicFilling",
-                    "startTemplateFilling",
-                    "stopTemplateFilling",
-                    "onInternalMutation",
-                    "offInternalMutation",
-                    "set",
-                    "get",
-                    "$tag",
-                    "_templateFillListeners_",
-                    "_fillListeners_",
-                    "_assignListeners_",
-                    "_invalidateListeners_",
-                    "_publishInternalMutation_",
-                    "hasListener",
-                    "delete",
-                    "_mutationListeners_",
-                    "_publishDynamicFilling_",
-                    "_publishInvalidation_",
-                    "_publishTemplateFilling_",
-                    "_publishAssignement_",
-                    "_proxies_",
-                    "parent",
-                    "_value_",
-                    "_is_savable_",
-                    "_lockInternalMutationPublishing_",
-                    "_instanceCounter_",
-                ].includes(sKey))
+                if (internalProps.has(sKey))
                     return publisherInstance[sKey];
                 if (!publisherInstance._proxies_.has(sKey)) {
                     const vValue = publisherInstance._value_[sKey];
@@ -569,6 +596,14 @@ export default class Publisher extends PublisherProxy {
                     publisherInstance._value_ = vValue;
                     return true;
                 }
+                if (sKey == "_cachedGet_") {
+                    publisherInstance._cachedGet_ = vValue;
+                    return true;
+                }
+                if (sKey == "_assignmentId_") {
+                    publisherInstance._assignmentId_ = vValue;
+                    return true;
+                }
                 if (sKey == "_is_savable_") {
                     publisherInstance._is_savable_ = vValue;
                     return true;
@@ -599,9 +634,12 @@ export default class Publisher extends PublisherProxy {
              */
             deleteProperty: function (publisherInstance, sKey) {
                 publisherInstance;
-                // publisherInstance._proxies_.get(sKey).set(null);
                 publisherInstance._publishDynamicFilling_(sKey, null);
-                publisherInstance._proxies_.delete(sKey);
+                // if (!publisherInstance._proxies_.get(sKey)?.hasListener()) {
+                //   publisherInstance._proxies_.delete(sKey);
+                // } else {
+                publisherInstance._proxies_.get(sKey)?.set(null);
+                // }
                 return delete publisherInstance._value_[sKey];
             },
             // enumerate: function (publisherInstance, sKey): CoreJSType {

package/core/utils/Utils.d.ts

@@ -1,3 +1,4 @@
 export default class Utils {
+    static queueTaskPromise(): Promise<unknown>;
     static delayPromise(timeoutMs: number): Promise<unknown>;
 }

package/core/utils/Utils.js

@@ -1,4 +1,9 @@
 export default class Utils {
+    static async queueTaskPromise() {
+        return new Promise((resolve) => {
+            window.queueMicrotask(() => resolve(null));
+        });
+    }
     static async delayPromise(timeoutMs) {
         return new Promise((resolve) => {
             setTimeout(resolve, timeoutMs);

package/core/utils/api.d.ts

@@ -1,6 +1,8 @@
 import { CoreJSType } from "@supersoniks/concorde/core/_types/types";
 export type APIConfiguration = {
     serviceURL: string | null;
+    /** un flag pour indiquer de bloquer les appels suivant au même serviceurl tant que celuis-ci n'a pas terminé */
+    blockUntilDone?: boolean;
     token: string | null;
     userName: string | null;
     password: string | null;
@@ -10,6 +12,7 @@ export type APIConfiguration = {
     credentials?: RequestCredentials;
     cache?: RequestCache;
 };
+export type CallState = "loading" | "done" | "error" | undefined;
 export type ResultTypeInterface = CoreJSType & {
     _sonic_http_response_?: Response;
     text?: string;
@@ -70,18 +73,37 @@ declare class API {
      * Tableau static des tentatives échouées de récupération auto du token
      */
     static failledTokenUpdates: Map<string | null, true>;
+    /**
+     * Tableau static des flags pour savoir si le premier appel a été fait pour chaque serviceURL
+     */
+    static firstCallDoneFlags: Map<string | null, CallState>;
     /**
      * Le endPoint pour obtenir le bearer token qui sera concaténé à l'url du service
      */
     addHTTPResponse: boolean;
     cache: RequestCache;
     lastResult?: Response;
+    isServiceSimulated: boolean;
+    blockUntilDone: boolean;
     constructor(config: APIConfiguration);
     handleResult(fetchResult: Response, lastCall: APICall): Promise<ResultTypeInterface>;
     /**
      * Basic auth
      */
     auth(): Promise<void>;
+    /**
+     * avec localget, on ne passe pas par le système de token
+     * on recupère path sans les searchparams nommée pathWithoutSearchParams
+     * on cherche dans PublisherManager.get(pathWithoutSearchParams).get() les données qui matchent les searchparams présents dans path
+     * on retourne les données selon le même format que le retour de get
+     *
+     * @todo netttoyer
+     */
+    localGet<T>(dataProvider: string, searchString: string): Promise<T & ResultTypeInterface>;
+    /**
+     * firstCallDone is a function that returns a promise that is resolved when the first call to the API is done for each serviceURL whatever api instance is used
+     */
+    firstCallDone(): Promise<unknown>;
     get<T>(path: string, additionalHeaders?: HeadersInit): Promise<T & ResultTypeInterface>;
     /**
      * Création du header, avec authentification si besoin
@@ -105,6 +127,10 @@ declare class API {
      * Appel send en utilisant le méthode POST
      */
     post<T, SendType = CoreJSType>(path: string, data: SendType, additionalHeaders?: HeadersInit): Promise<T & ResultTypeInterface>;
+    /**
+     * Appel send en utilisant le méthode PATCH
+     */
+    patch<T, SendType = CoreJSType>(path: string, data: SendType, additionalHeaders?: HeadersInit): Promise<T & ResultTypeInterface>;
     /**
      * Appel send en utilisant le méthode delete
      */

package/core/utils/api.js

@@ -2,6 +2,7 @@
 /* eslint no-async-promise-executor: 0 */ // --> OFF
 import HTML from "@supersoniks/concorde/core/utils/HTML";
 import Objects from "@supersoniks/concorde/core/utils/Objects";
+import { PublisherManager } from "./PublisherProxy";
 class API {
     set token(token) {
         this._token = token;
@@ -31,7 +32,13 @@ class API {
          */
         this.addHTTPResponse = false;
         this.cache = "default";
+        this.isServiceSimulated = false;
+        this.blockUntilDone = false;
         this.serviceURL = config.serviceURL;
+        this.blockUntilDone = config.blockUntilDone || false;
+        if (this.serviceURL == "publisher://") {
+            this.isServiceSimulated = true;
+        }
         if (!this.serviceURL)
             this.serviceURL = document.location.origin;
         this.userName = config.userName;
@@ -45,6 +52,7 @@ class API {
         this.cache = config.cache || "default";
     }
     async handleResult(fetchResult, lastCall) {
+        API.firstCallDoneFlags.set(this.serviceURL, "done");
         this.lastResult = fetchResult;
         const contentType = fetchResult.headers.get("content-type")?.toLowerCase();
         const httpCode = fetchResult.status;
@@ -118,7 +126,116 @@ class API {
             API.failledTokenUpdates.set(this.serviceURL, true);
         }
     }
+    /**
+     * avec localget, on ne passe pas par le système de token
+     * on recupère path sans les searchparams nommée pathWithoutSearchParams
+     * on cherche dans PublisherManager.get(pathWithoutSearchParams).get() les données qui matchent les searchparams présents dans path
+     * on retourne les données selon le même format que le retour de get
+     *
+     * @todo netttoyer
+     */
+    async localGet(dataProvider, searchString) {
+        const publisher = PublisherManager.get(dataProvider);
+        console.log(publisher);
+        const searchParams = new URLSearchParams(searchString.split("?")[1] || "");
+        const dataObject = publisher.get();
+        let data = [];
+        if (!Array.isArray(dataObject)) {
+            data = [dataObject];
+        }
+        else {
+            data = dataObject;
+        }
+        const result = [];
+        let limit = Number.POSITIVE_INFINITY;
+        let offset = 0;
+        let limitOffsetparams = 0;
+        if (searchParams.has("limit")) {
+            limit = parseInt(searchParams.get("limit") || "0");
+            limitOffsetparams++;
+        }
+        if (searchParams.has("offset")) {
+            offset = parseInt(searchParams.get("offset") || "0");
+            limitOffsetparams++;
+        }
+        if (limitOffsetparams > 0) {
+            searchParams.delete("limit");
+            searchParams.delete("offset");
+        }
+        if (searchParams.size === 0)
+            return data.slice(offset, offset + limit);
+        for (const [key, value] of searchParams.entries()) {
+            const values = value.split(",").map((s) => s.trim());
+            for (const v of values) {
+                for (const item of data) {
+                    //si l'item est une valeur primitive on regarde si vaue correspond à item simplement
+                    if (typeof item !== "object") {
+                        if (!isNaN(+value)) {
+                            if (item == value) {
+                                result.push(item);
+                            }
+                        }
+                        else if (item.toString().includes(value)) {
+                            result.push(item);
+                        }
+                    }
+                    else {
+                        const record = item;
+                        //si l'item est un objet
+                        //faire un comparaison de la version string de la même clef dans item pour voir si elle contient value
+                        if (!record[key])
+                            continue;
+                        //si la valeur est un nombre, on compare les valeurs directement
+                        if (!isNaN(+v)) {
+                            if (record[key] == v) {
+                                result.push(item);
+                            }
+                        }
+                        else {
+                            if (record[key]?.toString().toLowerCase().includes(v.toLowerCase())) {
+                                result.push(item);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return result.slice(offset, offset + limit);
+    }
+    /**
+     * firstCallDone is a function that returns a promise that is resolved when the first call to the API is done for each serviceURL whatever api instance is used
+     */
+    firstCallDone() {
+        return new Promise((resolve) => {
+            if (!API.firstCallDoneFlags.has(this.serviceURL)) {
+                API.firstCallDoneFlags.set(this.serviceURL, "loading");
+                resolve(true);
+            }
+            else {
+                const loop = () => {
+                    if (![undefined, "loading"].includes(API.firstCallDoneFlags.get(this.serviceURL))) {
+                        resolve(true);
+                    }
+                    else {
+                        window.requestAnimationFrame(loop);
+                    }
+                };
+                loop();
+            }
+        });
+    }
     async get(path, additionalHeaders) {
+        await this.firstCallDone();
+        if (this.blockUntilDone) {
+            API.firstCallDoneFlags.set(this.serviceURL, "loading");
+        }
+        const regExp = /dataProvider\((.*?)\)(.*?)$/;
+        if (regExp.test(path)) {
+            const match = path.match(regExp);
+            if (!match)
+                throw new Error("dataProvider path is not valid");
+            return await this.localGet(match[1], match[2]);
+        }
         const lastCall = {
             apiMethod: "get",
             path: path,
@@ -132,9 +249,14 @@ class API {
         });
         if (!API.loadingGetPromises.has(mapKey)) {
             const promise = new Promise(async (resolve) => {
-                const result = await fetch(url, { headers: headers, credentials: this.credentials, cache: this.cache });
-                const handledResult = await this.handleResult(result, lastCall);
-                resolve(handledResult);
+                try {
+                    const result = await fetch(url, { headers: headers, credentials: this.credentials, cache: this.cache });
+                    const handledResult = await this.handleResult(result, lastCall);
+                    resolve(handledResult);
+                }
+                catch (e) {
+                    resolve(null);
+                }
             });
             API.loadingGetPromises.set(mapKey, promise);
         }
@@ -233,6 +355,12 @@ class API {
     async post(path, data, additionalHeaders) {
         return this.send(path, data, "POST", additionalHeaders);
     }
+    /**
+     * Appel send en utilisant le méthode PATCH
+     */
+    async patch(path, data, additionalHeaders) {
+        return this.send(path, data, "PATCH", additionalHeaders);
+    }
     /**
      * Appel send en utilisant le méthode delete
      */
@@ -256,4 +384,8 @@ API.invalidTokens = [];
  * Tableau static des tentatives échouées de récupération auto du token
  */
 API.failledTokenUpdates = new Map();
+/**
+ * Tableau static des flags pour savoir si le premier appel a été fait pour chaque serviceURL
+ */
+API.firstCallDoneFlags = new Map();
 export default API;

package/core/utils/url-pattern.d.ts

@@ -0,0 +1,2 @@
+import UrlPattern from "url-pattern";
+export default UrlPattern;

package/core/utils/url-pattern.js

@@ -0,0 +1,2 @@
+import UrlPattern from "url-pattern";
+export default UrlPattern;