@supersoniks/concorde 1.1.43 → 1.1.45

package/core/utils/PublisherProxy.js

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-explicit-any*/
 function isComplex(value) {
     return typeof value === "object" && value != null;
 }
@@ -14,9 +15,9 @@ export class PublisherProxy {
         this._fillListeners_ = new Set();
         this._templateFillListeners_ = new Set();
         this._lockInternalMutationPublishing_ = false;
-        this.root = this;
         this._value_ = target;
         this.parent = parentProxPub || null;
+        this.root = this;
         while (this.root.parent) {
             this.root = this.root.parent;
         }
@@ -26,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();
@@ -70,7 +71,7 @@ export class PublisherProxy {
     }
     _publishTemplateFilling_(key, value) {
         this._templateFillListeners_.forEach((handler) => {
-            let desc = Object.getOwnPropertyDescriptor(handler, key);
+            const desc = Object.getOwnPropertyDescriptor(handler, key);
             if (desc && !desc.set && !desc.writable)
                 return;
             if (handler.propertyMap && handler.propertyMap[key]) {
@@ -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;
@@ -187,9 +191,9 @@ export class PublisherProxy {
          */
         if (this._value_ === newValue)
             return true;
-        if ("hasOwnProperty" in this._value_ &&
-            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;
         }
@@ -202,7 +206,7 @@ export class PublisherProxy {
          * 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;
@@ -213,7 +217,7 @@ export class PublisherProxy {
          * On met à jour leur valeur interne
          * On publie les maj au fur et a mesure de modifications
          */
-        for (let key in this._value_) {
+        for (const key in this._value_) {
             if (typeof this._value_[key] === "undefined")
                 delete this._value_[key];
         }
@@ -244,12 +248,12 @@ export class PublisherProxy {
          * 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);
+                    const newPublisher = new Publisher({}, this);
                     this._proxies_.set(key, newPublisher);
                     newPublisher._proxies_.set("_parent_", this);
                 }
@@ -263,9 +267,9 @@ export class PublisherProxy {
      * 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_;
     }
@@ -336,15 +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) {
-                oTarget;
+            get: function (publisherInstance, sKey) {
                 if ([
                     "invalidate",
                     "onInvalidate",
@@ -376,79 +378,81 @@ 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);
-                    (_a = that._proxies_.get(sKey)) === null || _a === void 0 ? void 0 : _a.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) {
-                oTarget;
-                // that._proxies_.get(sKey).set(null);
-                that._publishDynamicFilling_(sKey, null);
-                that._proxies_.delete(sKey);
-                return delete that._value_[sKey];
+            deleteProperty: function (publisherInstance, sKey) {
+                publisherInstance;
+                // publisherInstance._proxies_.get(sKey).set(null);
+                publisherInstance._publishDynamicFilling_(sKey, null);
+                publisherInstance._proxies_.delete(sKey);
+                return delete publisherInstance._value_[sKey];
             },
-            // enumerate: function (oTarget, sKey): any {
-            //   return that._value_.keys();
+            // enumerate: function (publisherInstance, sKey): CoreJSType {
+            //   return publisherInstance._value_.keys();
             // },
-            has: function (oTarget, sKey) {
-                oTarget;
-                return sKey in that._value_ && sKey != "_lockInternalMutationPublishing_";
+            has: function (publisherInstance, sKey) {
+                publisherInstance;
+                return sKey in publisherInstance._value_ && sKey != "_lockInternalMutationPublishing_";
             },
-            defineProperty: function (oTarget, sKey, oDesc) {
-                oTarget;
+            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) {
-                oTarget;
+            getOwnPropertyDescriptor: function (publisherInstance, sKey) {
+                publisherInstance;
                 sKey;
                 return {
                     enumerable: true,
                     configurable: true,
                 };
             },
-            ownKeys: function (target) {
-                target;
-                if (that._value_.__value)
-                    return Object.keys(that._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;

package/core/utils/api.d.ts

@@ -1,19 +1,30 @@
-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;
+    authToken: string | null;
     tokenProvider: string | null;
     addHTTPResponse?: boolean;
     credentials?: RequestCredentials;
 };
-declare class API<ResultType = any & {
+export type ResultTypeInterface = CoreJSType & {
     _sonic_http_response_?: Response;
-}, SendType = any> {
+    text?: string;
+};
+export type APICall = {
+    apiMethod: "get" | "send" | "submitFormData";
+    path: string;
+    additionalHeaders: HeadersInit | undefined;
+    method?: string | undefined;
+    data?: unknown;
+};
+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
      */
@@ -29,11 +40,17 @@ declare class API<ResultType = any & {
     /**
      * 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
      */
@@ -42,21 +59,27 @@ declare class API<ResultType = any & {
      * 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;
+    addHTTPResponse: boolean;
     lastResult?: Response;
     constructor(config: APIConfiguration);
-    handleResult(fetchResult: Response): Promise<ResultType & {
-        _sonic_http_response_?: Response | undefined;
-        text?: string | undefined;
-    }>;
+    handleResult(fetchResult: Response, lastCall: APICall): Promise<ResultTypeInterface>;
     /**
      * Basic auth
      */
     auth(): Promise<void>;
-    get(path: String, additionalHeaders?: HeadersInit): Promise<ResultType>;
+    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
@@ -65,38 +88,23 @@ declare class API<ResultType = any & {
     /**
      * Concatène le serviceURL et le endpoint donné en paramètre
      */
-    computeURL(path: String): string;
-    send(path: String, data: SendType, method?: string, additionalHeaders?: HeadersInit): Promise<ResultType & {
-        _sonic_http_response_?: Response | undefined;
-        text?: string | undefined;
-    }>;
+    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
      */
-    submitFormData(path: String, data: SendType | Record<string, string | Blob>, method?: string, additionalHeaders?: HeadersInit): Promise<ResultType & {
-        _sonic_http_response_?: Response | undefined;
-        text?: string | undefined;
-    }>;
+    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: SendType, additionalHeaders?: HeadersInit): Promise<ResultType & {
-        _sonic_http_response_?: Response | undefined;
-        text?: string | undefined;
-    }>;
+    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: SendType, additionalHeaders?: HeadersInit): Promise<ResultType & {
-        _sonic_http_response_?: Response | undefined;
-        text?: string | undefined;
-    }>;
+    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: SendType, additionalHeaders?: HeadersInit): Promise<ResultType & {
-        _sonic_http_response_?: Response | undefined;
-        text?: string | undefined;
-    }>;
+    delete<T, SendType = CoreJSType>(path: string, data: SendType, additionalHeaders?: HeadersInit): Promise<T & ResultTypeInterface>;
 }
 export default API;

package/core/utils/api.js

@@ -7,9 +7,33 @@ 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 "@supersoniks/concorde/core/utils/Objects";
 class API {
+    set token(token) {
+        this._token = token;
+        if (!token) {
+            API.tokens.delete(this.serviceURL);
+            return;
+        }
+        if (API.invalidTokens.includes(token))
+            return;
+        API.tokens.set(this.serviceURL, token);
+    }
+    get token() {
+        // si le token est marqué invalide, on utilise utilise la dernière version valide connue du token pour ce serviceURL
+        return API.invalidTokens.includes(this._token) ? API.tokens.get(this.serviceURL) : this._token;
+    }
+    handleInvalidToken(token) {
+        if (!token)
+            return;
+        if (API.invalidTokens.includes(token))
+            return;
+        API.invalidTokens.push(token);
+        this.token = null;
+    }
     constructor(config) {
         /**
          * Le endPoint pour obtenir le bearer token qui sera concaténé à l'url du service
@@ -20,19 +44,22 @@ class API {
             this.serviceURL = document.location.origin;
         this.userName = config.userName;
         this.password = config.password;
-        this.token = config.token;
+        if (config.token)
+            this.token = config.token;
         this.tokenProvider = config.tokenProvider;
+        this.authToken = config.authToken;
         this.addHTTPResponse = config.addHTTPResponse || false;
         this.credentials = config.credentials;
     }
-    handleResult(fetchResult) {
+    handleResult(fetchResult, lastCall) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             this.lastResult = fetchResult;
             const contentType = (_a = fetchResult.headers.get("content-type")) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+            const httpCode = fetchResult.status;
             let result = {};
-            if (contentType && contentType.indexOf("text/") == 0) {
-                let str = yield fetchResult.text();
+            if (!contentType || contentType.indexOf("text/") == 0) {
+                const str = yield fetchResult.text();
                 result = { text: str };
             }
             else {
@@ -46,6 +73,15 @@ class API {
             if (this.addHTTPResponse && Objects.isObject(result)) {
                 result._sonic_http_response_ = fetchResult;
             }
+            if (httpCode === 498 && !API.failledTokenUpdates.has(this.serviceURL)) {
+                this.handleInvalidToken(this.token);
+                if (lastCall.apiMethod === "get") {
+                    result = yield this[lastCall.apiMethod](lastCall.path, lastCall.additionalHeaders);
+                }
+                else {
+                    result = yield this[lastCall.apiMethod](lastCall.path, lastCall.data, lastCall.method, lastCall.additionalHeaders);
+                }
+            }
             return result;
         });
     }
@@ -60,37 +96,63 @@ class API {
                 this.token = API.tokens.get(this.serviceURL);
                 return;
             }
-            if (!this.userName || !this.password || !this.tokenProvider)
+            if (!this.tokenProvider)
                 return;
-            let headers = {
-                Authorization: "Basic " + window.btoa(unescape(encodeURIComponent(this.userName + ":" + this.password))),
-            };
-            let result = yield fetch(this.computeURL(this.tokenProvider), {
+            let headers = {};
+            if (this.userName && this.password) {
+                headers = {
+                    Authorization: "Basic " + window.btoa(unescape(encodeURIComponent(this.userName + ":" + this.password))),
+                };
+            }
+            else if (this.authToken) {
+                headers = {
+                    Authorization: "Bearer " + this.authToken,
+                };
+            }
+            const serviceURL = new URL(this.serviceURL);
+            const serviceHost = serviceURL.protocol + "//" + serviceURL.host;
+            const result = yield fetch(this.computeURL(this.tokenProvider, { serviceHost: serviceHost }), {
                 headers: headers,
                 credentials: this.credentials,
             });
             try {
-                let json = yield result.json();
-                this.token = json.token;
-                API.tokens.set(this.serviceURL, this.token);
+                const json = yield result.json();
+                const newToken = json.token;
+                if (newToken) {
+                    this.token = json.token;
+                }
+                else {
+                    API.failledTokenUpdates.set(this.serviceURL, true);
+                }
+            }
+            catch (e) {
+                API.failledTokenUpdates.set(this.serviceURL, true);
             }
-            catch (e) { }
         });
     }
     get(path, additionalHeaders) {
         return __awaiter(this, void 0, void 0, function* () {
-            let headers = yield this.createHeaders(additionalHeaders);
+            const lastCall = {
+                apiMethod: "get",
+                path: path,
+                additionalHeaders: 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, credentials: this.credentials });
-                    let handledResult = yield this.handleResult(result);
+            const mapKey = JSON.stringify({
+                url: url,
+                headers: headers,
+            });
+            if (!API.loadingGetPromises.has(mapKey)) {
+                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, lastCall);
                     resolve(handledResult);
                 }));
-                API.loadingGetPromises.set(url, promise);
+                API.loadingGetPromises.set(mapKey, promise);
             }
-            let result = yield API.loadingGetPromises.get(url);
-            API.loadingGetPromises.delete(url);
+            const result = (yield API.loadingGetPromises.get(mapKey));
+            API.loadingGetPromises.delete(mapKey);
             return result;
         });
     }
@@ -101,7 +163,7 @@ 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["Accept-Language"] = HTML.getLanguage();
@@ -114,24 +176,42 @@ class API {
     /**
      * Concatène le serviceURL et le endpoint donné en paramètre
      */
-    computeURL(path) {
-        return (this.serviceURL + "/" + path).replace(/([^(https?\:)])\/{2,}/g, "$1/");
+    computeURL(path, query = {}) {
+        let url = "";
+        if (path.startsWith("http"))
+            url = path;
+        else
+            url = this.serviceURL + "/" + path;
+        if (!url.startsWith("http"))
+            url = window.location.origin + url;
+        const computedUrl = new URL(url);
+        for (const key in query) {
+            computedUrl.searchParams.set(key, query[key]);
+        }
+        return computedUrl.toString().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 lastCall = {
+                apiMethod: "send",
+                path: path,
+                additionalHeaders: additionalHeaders,
+                method: method,
+                data: data,
+            };
+            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),
             });
-            return yield this.handleResult(result);
+            return (yield this.handleResult(result, lastCall));
         });
     }
     /**
@@ -139,19 +219,26 @@ class API {
      */
     submitFormData(path, data, method = "POST", additionalHeaders) {
         return __awaiter(this, void 0, void 0, function* () {
-            let headers = yield this.createHeaders(additionalHeaders);
+            const lastCall = {
+                apiMethod: "submitFormData",
+                path: path,
+                additionalHeaders: additionalHeaders,
+                method: method,
+                data: data,
+            };
+            const headers = yield this.createHeaders(additionalHeaders);
             headers["Accept"] = "application/json";
-            let formData = new FormData();
+            const formData = new FormData();
             const dynamicData = data;
-            for (let z in dynamicData)
+            for (const z in dynamicData)
                 formData.set(z, dynamicData[z]);
-            let result = yield fetch(this.computeURL(path), {
+            const result = yield fetch(this.computeURL(path), {
                 headers: headers,
                 credentials: this.credentials,
                 method: method,
                 body: formData,
             });
-            return yield this.handleResult(result);
+            return (yield this.handleResult(result, lastCall));
         });
     }
     /**
@@ -187,4 +274,12 @@ API.loadingGetPromises = new Map();
  * Tableau static des tokens stokés en memoire vive (comportement à revoir à l'occasion)
  */
 API.tokens = new Map();
+/**
+ * Tableau stockant l'ensemble des tokens invalides
+ */
+API.invalidTokens = [];
+/**
+ * Tableau static des tentatives échouées de récupération auto du token
+ */
+API.failledTokenUpdates = new Map();
 export default API;