@supersoniks/concorde 1.1.42 → 1.1.44

package/core/utils/{PublisherProxy.mjs → PublisherProxy.js}

@@ -1,8 +1,4 @@
-/**
- * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
- * Merci de laisser ce fichier sans la moindre dépendance.
- * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
- * **/
+/* eslint-disable @typescript-eslint/no-explicit-any*/
 function isComplex(value) {
     return typeof value === "object" && value != null;
 }
@@ -10,16 +6,17 @@ function isComplex(value) {
  * 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) {
+    constructor(target, parentProxPub) {
         this._proxies_ = new Map();
-        this._value_ = target;
+        this._key_ = "";
         this._invalidateListeners_ = new Set();
         this._assignListeners_ = new Set();
         this._mutationListeners_ = new Set();
         this._fillListeners_ = new Set();
         this._templateFillListeners_ = new Set();
         this._lockInternalMutationPublishing_ = false;
-        this.parent = parentProxPub;
+        this._value_ = target;
+        this.parent = parentProxPub || null;
         this.root = this;
         while (this.root.parent) {
             this.root = this.root.parent;
@@ -30,7 +27,7 @@ export class PublisherProxy {
      * Supprime les écouteurs associés
      */
     delete() {
-        for (let proxy of this._proxies_.values()) {
+        for (const proxy of this._proxies_.values()) {
             proxy.delete();
         }
         this._invalidateListeners_.clear();
@@ -74,8 +71,8 @@ export class PublisherProxy {
     }
     _publishTemplateFilling_(key, value) {
         this._templateFillListeners_.forEach((handler) => {
-            let desc = Object.getOwnPropertyDescriptor(handler, key);
-            if (desc && !desc.set)
+            const desc = Object.getOwnPropertyDescriptor(handler, key);
+            if (desc && !desc.set && !desc.writable)
                 return;
             if (handler.propertyMap && handler.propertyMap[key]) {
                 key = handler.propertyMap[key];
@@ -113,12 +110,14 @@ export class PublisherProxy {
      * Stop les appels de la fonction "handler" (passée en paramettre) lorsque la donnée est flaggée comme invalide
      */
     offInvalidate(handler) {
+        if (typeof handler != "function")
+            return;
         this._invalidateListeners_.delete(handler);
     }
     /**
      * Flag les données comme étant invalides
      */
-    invalidate(handler) {
+    invalidate() {
         this._publishInvalidation_();
     }
     /**
@@ -135,6 +134,8 @@ export class PublisherProxy {
      * 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) {
+        if (typeof handler != "function")
+            return;
         this._mutationListeners_.delete(handler);
     }
     /**
@@ -143,13 +144,16 @@ export class PublisherProxy {
      */
     startTemplateFilling(handler) {
         this._templateFillListeners_.add(handler);
-        for (var z in this._value_) {
+        if (typeof this._value_ != "object")
+            return;
+        for (const z in this._value_) {
+            let valueKey = z;
             const value = this._value_[z];
             if (handler.propertyMap && handler.propertyMap[z]) {
-                z = handler.propertyMap[z];
+                valueKey = handler.propertyMap[z];
             }
             if (typeof handler[z] != "undefined" && handler[z] !== value) {
-                handler[z] = value;
+                handler[valueKey] = value;
             }
         }
     }
@@ -165,7 +169,7 @@ export class PublisherProxy {
      */
     startDynamicFilling(handler) {
         this._fillListeners_.add(handler);
-        for (var z in this._value_) {
+        for (const z in this._value_) {
             const value = this._value_[z];
             if (handler[z] !== value)
                 handler[z] = value;
@@ -181,25 +185,28 @@ 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) {
+        var _a;
         /**
          * On retounre tout de suite si la valeur n'a pas changé
          */
         if (this._value_ === newValue)
             return true;
-        if (this._value_.hasOwnProperty("__value") &&
-            newValue.hasOwnProperty("__value") &&
+        if (this._value_ &&
+            Object.prototype.hasOwnProperty.call(this._value_, "__value") &&
+            Object.prototype.hasOwnProperty.call(newValue, "__value") &&
             this._value_.__value === newValue.__value) {
             return true;
         }
         /**
          * On assigne la nouvelle valeur
          */
-        this._value_ = newValue;
+        const prevValue = this._value_;
+        this._value_ = isComplex(newValue) ? newValue : { __value: newValue };
         /**
          * 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 = this._value_.hasOwnProperty("__value");
+        const isPrimitiveValue = Object.prototype.hasOwnProperty.call(this._value_, "__value");
         if (isPrimitiveValue) {
             this._publishAssignement_(lockInternalMutationsTransmission);
             return true;
@@ -210,46 +217,59 @@ export class PublisherProxy {
          * On met à jour leur valeur interne
          * On publie les maj au fur et a mesure de modifications
          */
+        for (const key in this._value_) {
+            if (typeof this._value_[key] === "undefined")
+                delete this._value_[key];
+        }
         Array.from(this._proxies_.keys()).forEach((key) => {
             /**
              * On supprime les proxys qui ne sont plus dans la nouvelle valeur si ils n'on pas d'écouteurs
              **/
-            if (!this._value_[key] && this._proxies_.has(key) && !this._proxies_.get(key).hasListener()) {
-                this._proxies_.delete(key);
+            if (typeof this._value_[key] === "undefined" && this._proxies_.has(key)) {
+                const subProxy = this._proxies_.get(key);
+                if (!(subProxy === null || subProxy === void 0 ? void 0 : 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_();
         /**
          * Si la donnée est complexe (objet, tableau)
          * on crée les proxys pour les sous-éléments qui n'en on pas
          * On renseigne les nouvelles valeurs internes des proxies
          */
         if (isComplex(this._value_)) {
-            for (let key in this._value_) {
-                let v = newValue[key];
-                let isVComplex = isComplex(v);
-                let valueV = isVComplex ? v : { __value: v };
+            for (const key in this._value_) {
+                const v = newValue[key];
+                const isVComplex = isComplex(v);
+                const valueV = isVComplex ? v : { __value: v };
                 if (!this._proxies_.has(key)) {
-                    let newPublisher = new Publisher({}, this);
-                    this._proxies_.set(key, newPublisher, true);
+                    const newPublisher = new Publisher({}, this);
+                    this._proxies_.set(key, newPublisher);
                     newPublisher._proxies_.set("_parent_", this);
                 }
-                this._proxies_.get(key).set(valueV, true);
+                (_a = this._proxies_.get(key)) === null || _a === void 0 ? void 0 : _a.set(valueV, true);
                 this._publishDynamicFilling_(key, v);
             }
         }
-        /**
-         * On prévient les écouteurs que la valeur a changé
-         */
-        this._publishAssignement_();
         return true;
     }
     /**
      * Extraire la valeur actuelle du proxy
      */
     get() {
-        if (this._value_.hasOwnProperty("__value")) {
-            let v = this._value_.__value;
-            return v != undefined ? v : null;
+        if (Object.prototype.hasOwnProperty.call(this._value_, "__value")) {
+            const v = this._value_.__value;
+            return (v != undefined ? v : null);
         }
         return this._value_;
     }
@@ -261,10 +281,10 @@ export class PublisherProxy {
  */
 export class PublisherManager {
     constructor() {
+        this.publishers = new Map();
         if (PublisherManager.instance != null)
             throw "Singleton / use getInstance";
         PublisherManager.instance = this;
-        this.publishers = new Map();
     }
     /**
      * PublisherManager est un singleton
@@ -309,8 +329,8 @@ export class PublisherManager {
     delete(id) {
         if (!this.publishers.has(id))
             return false;
-        const publisher = this.publishers.get(id);
         this.publishers.delete(id);
+        return true;
     }
 }
 PublisherManager.instance = null;
@@ -320,14 +340,13 @@ PublisherManager.instance = null;
 export default class Publisher extends PublisherProxy {
     constructor(target, parentProxPub = null) {
         super(target, parentProxPub);
-        let that = this;
-        let thisProxy = new Proxy(this, {
+        const 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) {
+            get: function (publisherInstance, sKey) {
                 if ([
                     "invalidate",
                     "onInvalidate",
@@ -359,77 +378,88 @@ export default class Publisher extends PublisherProxy {
                     "_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);
+                    return publisherInstance[sKey];
+                if (!publisherInstance._proxies_.has(sKey)) {
+                    const vValue = publisherInstance._value_[sKey];
+                    const newPublisher = new Publisher(isComplex(vValue) ? vValue : { __value: vValue }, publisherInstance);
                     newPublisher._proxies_.set("_parent_", thisProxy);
-                    that._proxies_.set(sKey, newPublisher);
+                    publisherInstance._proxies_.set(sKey, newPublisher);
                 }
-                return that._proxies_.get(sKey);
+                return publisherInstance._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) {
+            set: function (publisherInstance, sKey, vValue) {
+                var _a;
                 //Fonctionnement pour la donnée interne pas de dispatch;
                 if (sKey == "_value_") {
-                    oTarget._value_ = vValue;
-                    return oTarget._value_;
+                    publisherInstance._value_ = vValue;
+                    // return publisherInstance._value_;
+                    return true;
                 }
                 //Création du publisher si il n'existe pas
-                if (!that._proxies_.has(sKey)) {
-                    let newPublisher = new Publisher({}, that);
+                if (!publisherInstance._proxies_.has(sKey)) {
+                    const newPublisher = new Publisher({}, publisherInstance);
                     newPublisher._proxies_.set("_parent_", thisProxy);
-                    that._proxies_.set(sKey, newPublisher);
+                    publisherInstance._proxies_.set(sKey, newPublisher);
                 }
                 //mis à jour et publication de la donnée si elle a changé
-                const prevValue = that._value_[sKey];
+                const prevValue = publisherInstance._value_[sKey];
                 if (prevValue !== vValue) {
-                    that._value_[sKey] = vValue;
-                    that._publishDynamicFilling_(sKey, vValue);
-                    that._proxies_.get(sKey).set(isComplex(vValue) ? vValue : { __value: vValue });
+                    publisherInstance._value_[sKey] = vValue;
+                    publisherInstance._publishDynamicFilling_(sKey, vValue);
+                    (_a = publisherInstance._proxies_.get(sKey)) === null || _a === void 0 ? void 0 : _a.set(isComplex(vValue) ? vValue : { __value: vValue });
                 }
                 //on retourne  le proxy pour pouvoir chainer les assignements
-                return that._proxies_.get(sKey);
+                // return publisherInstance._proxies_.get(sKey);
+                return true;
             },
             /**
              * 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();
+            deleteProperty: function (publisherInstance, sKey) {
+                publisherInstance;
+                // publisherInstance._proxies_.get(sKey).set(null);
+                publisherInstance._publishDynamicFilling_(sKey, null);
+                publisherInstance._proxies_.delete(sKey);
+                return delete publisherInstance._value_[sKey];
             },
-            has: function (oTarget, sKey) {
-                return sKey in that._value_ && sKey != "_lockInternalMutationPublishing_";
+            // enumerate: function (publisherInstance, sKey): CoreJSType {
+            //   return publisherInstance._value_.keys();
+            // },
+            has: function (publisherInstance, sKey) {
+                publisherInstance;
+                return sKey in publisherInstance._value_ && sKey != "_lockInternalMutationPublishing_";
             },
-            defineProperty: function (oTarget, sKey, oDesc) {
+            defineProperty: function (publisherInstance, sKey, oDesc) {
+                publisherInstance;
                 if (oDesc && "value" in oDesc) {
-                    that._value_[sKey] = oDesc.value;
+                    publisherInstance._value_[sKey] = oDesc.value;
                 }
-                return that._value_;
+                return true;
+                // return publisherInstance._value_;
             },
-            getOwnPropertyDescriptor: function (oTarget, sKey) {
-                var vValue = that._value_[sKey];
+            getOwnPropertyDescriptor: function (publisherInstance, sKey) {
+                publisherInstance;
+                sKey;
                 return {
                     enumerable: true,
                     configurable: true,
                 };
             },
-            ownKeys: function (target) {
-                if (that._value_.__value)
-                    return Object.keys(this._value_.__value);
-                return Object.keys(that._value_);
+            ownKeys: function (publisherInstance) {
+                if (publisherInstance._value_.__value)
+                    return Object.keys(publisherInstance._value_.__value);
+                return Object.keys(publisherInstance._value_);
             },
         });
         return thisProxy;
     }
+    getProperty(o, propertyName) {
+        return o[propertyName]; // o[propertyName] is of type T[K]
+    }
 }
 if (typeof module != "undefined")
     module.exports = { Publisher: Publisher, PublisherManager: PublisherManager };

package/core/utils/Utils.d.ts

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

package/core/utils/Utils.js

@@ -0,0 +1,18 @@
+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());
+    });
+};
+export default class Utils {
+    static delayPromise(timeoutMs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => {
+                setTimeout(resolve, timeoutMs);
+            });
+        });
+    }
+}

package/core/utils/api.d.ts

@@ -1,15 +1,22 @@
-export declare type APIConfiguration = {
+import { CoreJSType } from "@supersoniks/concorde/core/_types/types";
+export type APIConfiguration = {
     serviceURL: string | null;
     token: string | null;
     userName: string | null;
     password: string | null;
     tokenProvider: string | null;
+    addHTTPResponse?: boolean;
+    credentials?: RequestCredentials;
+};
+export type ResultTypeInterface = CoreJSType & {
+    _sonic_http_response_?: Response;
+    text?: string;
 };
 declare class API {
     /**
      * Ce tableau static permet de ne pas appeler plusieurs fois le même service lors d'appel concurrents en GET.
      */
-    static loadingGetPromises: Map<string, Promise<any>>;
+    static loadingGetPromises: Map<string, Promise<unknown>>;
     /**
      * L'url de base du service sans endpoint
      */
@@ -30,16 +37,26 @@ declare class API {
      * Le endPoint pour obtenir le bearer token qui sera concaténé à l'url du service
      */
     tokenProvider: string | null;
+    /**
+     * credentials
+     */
+    credentials?: RequestCredentials;
     /**
      * Tableau static des tokens stokés en memoire vive (comportement à revoir à l'occasion)
      */
     static tokens: Map<string | null, string | null | undefined>;
+    /**
+     * Le endPoint pour obtenir le bearer token qui sera concaténé à l'url du service
+     */
+    addHTTPResponse: boolean;
+    lastResult?: Response;
     constructor(config: APIConfiguration);
+    handleResult(fetchResult?: Response): Promise<ResultTypeInterface>;
     /**
      * Basic auth
      */
     auth(): Promise<void>;
-    get(path: String, additionalHeaders?: HeadersInit): Promise<any>;
+    get<T>(path: string, additionalHeaders?: HeadersInit): Promise<T & ResultTypeInterface>;
     /**
      * Création du header, avec authentification si besoin
      * ajout du language via le header accept-language qui contient le langue du navigateur
@@ -48,23 +65,23 @@ declare class API {
     /**
      * Concatène le serviceURL et le endpoint donné en paramètre
      */
-    computeURL(path: String): string;
-    send(path: String, data: any, method?: string, additionalHeaders?: HeadersInit): Promise<any>;
+    computeURL(path: 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
      */
-    submitFormData(path: String, data: any, method?: string, additionalHeaders?: HeadersInit): Promise<any>;
+    submitFormData<T, SendType = CoreJSType>(path: string, data: SendType, method?: string, additionalHeaders?: HeadersInit): Promise<T & ResultTypeInterface>;
     /**
      * Appel send en utilisant le méthode PUT
      */
-    put(path: String, data: any, additionalHeaders?: HeadersInit): Promise<any>;
+    put<T, SendType = CoreJSType>(path: string, data: SendType, additionalHeaders?: HeadersInit): Promise<T & ResultTypeInterface>;
     /**
      * Appel send en utilisant le méthode POST
      */
-    post(path: String, data: any, additionalHeaders?: HeadersInit): Promise<any>;
+    post<T, SendType = CoreJSType>(path: string, data: SendType, additionalHeaders?: HeadersInit): Promise<T & ResultTypeInterface>;
     /**
      * Appel send en utilisant le méthode delete
      */
-    delete(path: String, data: any, additionalHeaders?: HeadersInit): Promise<any>;
+    delete<T, SendType = CoreJSType>(path: string, data: SendType, additionalHeaders?: HeadersInit): Promise<T & ResultTypeInterface>;
 }
 export default API;

package/core/utils/api.js

@@ -7,10 +7,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+// on désactive une regle eslint pour ce fichier
+/* eslint no-async-promise-executor: 0 */ // --> OFF
 import HTML from "@supersoniks/concorde/core/utils/HTML";
-import Objects from "./Objects";
+import Objects from "@supersoniks/concorde/core/utils/Objects";
 class API {
     constructor(config) {
+        /**
+         * Le endPoint pour obtenir le bearer token qui sera concaténé à l'url du service
+         */
+        this.addHTTPResponse = false;
         this.serviceURL = config.serviceURL;
         if (!this.serviceURL)
             this.serviceURL = document.location.origin;
@@ -18,6 +24,32 @@ class API {
         this.password = config.password;
         this.token = config.token;
         this.tokenProvider = config.tokenProvider;
+        this.addHTTPResponse = config.addHTTPResponse || false;
+        this.credentials = config.credentials;
+    }
+    handleResult(fetchResult) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            this.lastResult = fetchResult;
+            const contentType = (_a = fetchResult === null || fetchResult === void 0 ? void 0 : fetchResult.headers.get("content-type")) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+            let result = {};
+            if (contentType && contentType.indexOf("text/") == 0) {
+                const str = yield (fetchResult === null || fetchResult === void 0 ? void 0 : fetchResult.text());
+                result = { text: str };
+            }
+            else {
+                try {
+                    result = yield (fetchResult === null || fetchResult === void 0 ? void 0 : fetchResult.json());
+                }
+                catch (e) {
+                    result = {};
+                }
+            }
+            if (this.addHTTPResponse && Objects.isObject(result)) {
+                result._sonic_http_response_ = fetchResult;
+            }
+            return result;
+        });
     }
     /**
      * Basic auth
@@ -32,39 +64,36 @@ class API {
             }
             if (!this.userName || !this.password || !this.tokenProvider)
                 return;
-            let headers = {
+            const headers = {
                 Authorization: "Basic " + window.btoa(unescape(encodeURIComponent(this.userName + ":" + this.password))),
             };
-            let result = yield fetch(this.computeURL(this.tokenProvider), { headers: headers });
+            const result = yield fetch(this.computeURL(this.tokenProvider), {
+                headers: headers,
+                credentials: this.credentials,
+            });
             try {
-                let json = yield result.json();
+                const json = yield result.json();
                 this.token = json.token;
                 API.tokens.set(this.serviceURL, this.token);
             }
-            catch (e) { }
+            catch (e) {
+                console.log("Problème au moment du parsing du json au retour de l'authentification");
+            }
         });
     }
     get(path, additionalHeaders) {
         return __awaiter(this, void 0, void 0, function* () {
-            let headers = yield this.createHeaders(additionalHeaders);
+            const headers = yield this.createHeaders(additionalHeaders);
             const url = this.computeURL(path);
             if (!API.loadingGetPromises.has(url)) {
-                let promise = new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
-                    let result = yield fetch(url, { headers: headers });
-                    try {
-                        let json = yield result.json();
-                        if (Objects.isObject(json)) {
-                            json._sonic_http_response_ = result;
-                        }
-                        resolve(json);
-                    }
-                    catch (e) {
-                        resolve({ _sonic_http_response_: result });
-                    }
+                const promise = new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+                    const result = yield fetch(url, { headers: headers, credentials: this.credentials });
+                    const handledResult = yield this.handleResult(result);
+                    resolve(handledResult);
                 }));
                 API.loadingGetPromises.set(url, promise);
             }
-            let result = yield API.loadingGetPromises.get(url);
+            const result = (yield API.loadingGetPromises.get(url));
             API.loadingGetPromises.delete(url);
             return result;
         });
@@ -76,10 +105,9 @@ class API {
     createHeaders(additionalHeaders) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.auth();
-            let headers = {};
+            const headers = {};
             if (this.token)
                 headers.Authorization = "Bearer " + this.token;
-            headers.credentials = "include";
             headers["Accept-Language"] = HTML.getLanguage();
             if (additionalHeaders) {
                 Object.assign(headers, additionalHeaders);
@@ -91,29 +119,23 @@ class API {
      * Concatène le serviceURL et le endpoint donné en paramètre
      */
     computeURL(path) {
-        return (this.serviceURL + "/" + path).replace(/([^(https?\:)])\/{2,}/g, "$1/");
+        return (this.serviceURL + "/" + path).replace(/([^(https?:)])\/{2,}/g, "$1/");
     }
     /*
      * Envoie des données au endPoint passé en paramètre. par défaut en POST
      */
     send(path, data, method = "POST", additionalHeaders) {
         return __awaiter(this, void 0, void 0, function* () {
-            let headers = yield this.createHeaders(additionalHeaders);
+            const headers = yield this.createHeaders(additionalHeaders);
             headers["Accept"] = "application/json";
             headers["Content-Type"] = "application/json";
-            let result = yield fetch(this.computeURL(path), {
+            const result = yield fetch(this.computeURL(path), {
                 headers: headers,
+                credentials: this.credentials,
                 method: method,
                 body: JSON.stringify(data),
             });
-            try {
-                let json = yield result.json();
-                json._sonic_http_response_ = result;
-                return json;
-            }
-            catch (e) {
-                return { _sonic_http_response_: result };
-            }
+            return (yield this.handleResult(result));
         });
     }
     /**
@@ -121,24 +143,19 @@ class API {
      */
     submitFormData(path, data, method = "POST", additionalHeaders) {
         return __awaiter(this, void 0, void 0, function* () {
-            let headers = yield this.createHeaders(additionalHeaders);
+            const headers = yield this.createHeaders(additionalHeaders);
             headers["Accept"] = "application/json";
-            let formData = new FormData();
-            for (let z in data)
-                formData.set(z, data[z]);
-            let result = yield fetch(this.computeURL(path), {
+            const formData = new FormData();
+            const dynamicData = data;
+            for (const z in dynamicData)
+                formData.set(z, dynamicData[z]);
+            const result = yield fetch(this.computeURL(path), {
                 headers: headers,
+                credentials: this.credentials,
                 method: method,
                 body: formData,
             });
-            try {
-                let json = yield result.json();
-                json._sonic_http_response_ = result;
-                return json;
-            }
-            catch (e) {
-                return { _sonic_http_response_: result };
-            }
+            return (yield this.handleResult(result));
         });
     }
     /**