@supersoniks/concorde 1.1.41 → 1.1.43

package/core/utils/LocationHandler.js

@@ -39,6 +39,7 @@ export default class LocationHandler {
             LocationHandler.listen();
         }
         LocationHandler.listeners.push(listener);
+        listener.location = this.prevURL;
     }
     /**
      *
@@ -49,24 +50,34 @@ export default class LocationHandler {
      * Voir link et button pour les exemples d'implémentation
      **/
     static changeFromComponent(component) {
-        if (component.goBack !== null) {
+        const goBack = component.goBack;
+        const referrer = document.referrer;
+        if (goBack !== null && goBack !== undefined) {
             const origin = document.location.origin;
-            let urlDest = component.goBack || origin;
-            if ((document.referrer.indexOf("http") != 0 || new URL(document.referrer).origin != origin) && urlDest != document.location.href) {
+            let urlDest = goBack || origin;
+            const isHTTP = referrer.indexOf("http") == 0;
+            const isNotSameOrigin = isHTTP ? new URL(referrer).origin != origin : false;
+            const isReferrerEmpty = referrer == "";
+            const isFirstPage = history.length < 3; // imparfait mais variabsle selon les situations
+            const isFallbackNoReferer = isReferrerEmpty && isFirstPage; // fallback pour ff qui a parfois un referer nulle ex : drupal 9
+            const isNotSameURL = urlDest != document.location.href;
+            const goToURLDest = (isNotSameOrigin && isNotSameURL) || isFallbackNoReferer;
+            if (goToURLDest) {
                 let state = history.state || {};
                 state.concorde = state.concorde || {};
-                state.concorde.hasDoneHistoryBack = true; // maybe for debugging
+                state.concorde.hasDoneHistoryBack = true;
                 history.pushState(state, document.title);
                 history.back();
                 document.location.replace(urlDest);
             }
-            else
+            else {
                 history.back();
+            }
             return;
         }
-        let to = component.getAttribute("to");
+        let to = component.getAttribute("to") || "";
         if (!to)
-            to = component.href;
+            to = component.href || "";
         if (!to)
             return;
         if (to.indexOf("#") == 0) {
@@ -102,7 +113,7 @@ export default class LocationHandler {
             return;
         if (component.href && component.href.indexOf("http") != 0) {
             let url1 = new URL(component.href, document.location.href);
-            let url2 = new URL(component.location, document.location.origin);
+            let url2 = new URL(component.location || "", document.location.origin);
             let isActive = false;
             if (component.autoActive == "strict") {
                 isActive = url1.pathname == url2.pathname && url1.hash == url2.hash && url1.search == url2.search;

package/core/utils/Objects.d.ts

@@ -1,24 +1,27 @@
+import { TypeAndRecordOfType } from "../_types/types";
 declare class Objects {
     /**
      * Effectue une comparaison d'égalité non profonde entre deux objets.
      */
-    static shallowEqual(object1: any, object2: any): boolean;
+    static shallowEqual(object1: any, object2: any, useStrictComparaison?: boolean): boolean;
     /**
      * Effectue une comparaison d'égalité profonde entre deux objets.
      */
-    static deepEqual(object1: any, object2: any): boolean;
+    static deepEqual(object1: any, object2: any, useStrictComparaison?: boolean): boolean;
     /**
      * @returns true si l'objet est un objet ou un tableau (qui est un objet). mais false si null (car sinon typeof null "object")
      */
-    static isObject(object: any): boolean;
+    static isObject<T>(object: T): boolean;
     /**
      * @returns true si l'argument est null ou undefined
      */
-    static isUndefindOrNull(object: any): boolean;
+    static isUndefindOrNull<T>(object: T): boolean;
     /**
      * traverse l'objet pour obtenir la valeur a l'adresse donnée via le tableau de clés pathArray.
      * Si extendValues = true, les propriétés des objets parents sont copiées au fur et a mesure de la descente dans la hierarchie, avant l'assignation des propriétés de l'objet lui même.
      */
     static traverse(obj: any, pathArray: string[], extendValues?: boolean): any;
+    static getURLSearchArray(sourceObject?: TypeAndRecordOfType<string>, prefix?: string): string[];
+    static getURLSearchString(sourceObject: TypeAndRecordOfType<string>): string;
 }
 export default Objects;

package/core/utils/Objects.js

@@ -2,14 +2,17 @@ class Objects {
     /**
      * Effectue une comparaison d'égalité non profonde entre deux objets.
      */
-    static shallowEqual(object1, object2) {
+    static shallowEqual(object1, object2, useStrictComparaison = true) {
         const keys1 = Object.keys(object1);
         const keys2 = Object.keys(object2);
-        if (keys1.length !== keys2.length) {
+        if (keys1.length !== keys2.length && useStrictComparaison) {
             return false;
         }
         for (let key of keys1) {
-            if (object1[key] !== object2[key]) {
+            const val1 = object1[key];
+            const val2 = object2[key];
+            const areEqual = useStrictComparaison ? val1 !== val2 : val1 != val2;
+            if (areEqual) {
                 return false;
             }
         }
@@ -18,17 +21,18 @@ class Objects {
     /**
      * Effectue une comparaison d'égalité profonde entre deux objets.
      */
-    static deepEqual(object1, object2) {
+    static deepEqual(object1, object2, useStrictComparaison = true) {
         const keys1 = Object.keys(object1);
         const keys2 = Object.keys(object2);
-        if (keys1.length !== keys2.length) {
+        if (keys1.length !== keys2.length && useStrictComparaison) {
             return false;
         }
         for (const key of keys1) {
             const val1 = object1[key];
             const val2 = object2[key];
             const areObjects = Objects.isObject(val1) && Objects.isObject(val2);
-            if ((areObjects && !Objects.deepEqual(val1, val2)) || (!areObjects && val1 !== val2)) {
+            const areEqual = useStrictComparaison ? val1 !== val2 : val1 != val2;
+            if ((areObjects && !Objects.deepEqual(val1, val2)) || (!areObjects && areEqual)) {
                 return false;
             }
         }
@@ -65,5 +69,23 @@ class Objects {
         }
         return obj;
     }
+    static getURLSearchArray(sourceObject, prefix = "") {
+        let arr = [];
+        for (let key in sourceObject) {
+            let value = sourceObject[key];
+            if (prefix)
+                key = prefix + "[" + key + "]";
+            if (Objects.isObject(value)) {
+                arr = [...arr, ...this.getURLSearchArray(value, key)];
+            }
+            else {
+                arr.push(`${key}=${value}`);
+            }
+        }
+        return arr;
+    }
+    static getURLSearchString(sourceObject) {
+        return Objects.getURLSearchArray(sourceObject, "").join("&");
+    }
 }
 export default Objects;

package/core/utils/{PublisherProxy.d.mts → PublisherProxy.d.ts}

@@ -1,18 +1,23 @@
+declare type CoreJSType = Object | string | number | boolean | BigInt | undefined | null | symbol;
+declare type PublisherContentType = CoreJSType & {
+    __value?: any;
+} & Record<string, any>;
 /**
  * Custom Proxy contient les méthodes des publishers retournés par PublisherManager.get(publisherId) qui seront utilisées couramment
  */
-export class PublisherProxy {
-    constructor(target: any, parentProxPub?: null);
-    _proxies_: Map<any, any>;
-    _value_: any;
-    _invalidateListeners_: Set<any>;
-    _assignListeners_: Set<any>;
-    _mutationListeners_: Set<any>;
-    _fillListeners_: Set<any>;
-    _templateFillListeners_: Set<any>;
+export declare class PublisherProxy<T extends PublisherContentType = any> {
+    _proxies_: Map<string, PublisherProxy>;
+    _value_: T;
+    _key_: string;
+    _invalidateListeners_: Set<VoidFunction>;
+    _assignListeners_: Set<(value: T) => void>;
+    _mutationListeners_: Set<VoidFunction>;
+    _fillListeners_: Set<unknown>;
+    _templateFillListeners_: Set<unknown>;
     _lockInternalMutationPublishing_: boolean;
-    parent: any;
-    root: any;
+    parent: PublisherProxy | null;
+    root: PublisherProxy;
+    constructor(target: T, parentProxPub: PublisherProxy | null);
     /**
      * Supprime le proxy et ses sous proxy
      * Supprime les écouteurs associés
@@ -25,38 +30,38 @@ export class PublisherProxy {
     _publishInternalMutation_(lockInternalMutationsTransmission?: boolean): void;
     _publishAssignement_(lockInternalMutationsTransmission?: boolean): void;
     _publishInvalidation_(): void;
-    _publishDynamicFilling_(key: any, value: any): void;
-    _publishTemplateFilling_(key: any, value: any): void;
+    _publishDynamicFilling_(key: string, value: any): void;
+    _publishTemplateFilling_(key: string, value: any): void;
     /**
      * Appel la fonction "handler" (passée en paramettre) lorsque la valeur gérée par le proxy change par assignation
      * hanlder reçois alors la nouvelle valeur interne du proxy en paramètre
      */
-    onAssign(handler: any): void;
+    onAssign(handler: (value: T) => void): void;
     /**
      * Stop les appels de la fonction "handler" (passée en paramettre) lorsque la valeur gérée par le proxy change par assignation
      */
-    offAssign(handler: any): void;
+    offAssign(handler: (value: T) => void): void;
     /**
      * Appel la fonction "handler" (passée en paramettre) lorsque la donnée est flaggée comme invalide
      */
-    onInvalidate(handler: any): void;
+    onInvalidate(handler: VoidFunction | undefined): void;
     /**
      * Stop les appels de la fonction "handler" (passée en paramettre) lorsque la donnée est flaggée comme invalide
      */
-    offInvalidate(handler: any): void;
+    offInvalidate(handler: VoidFunction | undefined): void;
     /**
      * Flag les données comme étant invalides
      */
-    invalidate(handler: any): void;
+    invalidate(): void;
     /**
      * Appel 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
      *
      */
-    onInternalMutation(handler: any): void;
+    onInternalMutation(handler: VoidFunction | undefined): void;
     /**
      * 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: any): void;
+    offInternalMutation(handler: VoidFunction | undefined): void;
     /**
      * Maintient le remplissage de l'objet / tableau "handler" passé en paramètre avec les valeurs du proxy
      * Remplit uniquement les valeurs déjà présentes dans l'objet / tableau passé en paramètre
@@ -75,19 +80,21 @@ 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: any, lockInternalMutationsTransmission?: boolean): boolean;
+    set(newValue: T, lockInternalMutationsTransmission?: boolean): boolean;
     /**
      * Extraire la valeur actuelle du proxy
      */
-    get(): any;
+    get(): T;
 }
 /**
  * Utilitaires de gestion des Publisher
  * Obtenir, replacer ou supprimer un Publisher
  *
  */
-export class PublisherManager {
-    static instance: null;
+export declare class PublisherManager {
+    static instance: PublisherManager | null;
+    publishers: Map<string, Publisher<any>>;
+    constructor();
     /**
      * PublisherManager est un singleton
      */
@@ -96,29 +103,31 @@ export class PublisherManager {
      * shortcut static pour obtenir un publisher vias sont id/adresse sans taper getInstance.
      * Si le publisher n'existe pas, il est créé.
      */
-    static get(id: any): any;
+    static get(id: 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
      */
-    static delete(id: any): false | undefined;
-    publishers: Map<any, any>;
+    static delete(id: string): boolean;
     /**
      * Obtenir un publisher vias sont id/adresse
      * Si le publisher n'existe pas, il est créé.
      */
-    get(id: any): any;
+    get(id: string): any;
     /**
      * Remplace un publisher pour l'id fourni par un autre.
      * L'autre publisher n'est pas supprimé.
      */
-    set(id: any, publisher: any): void;
+    set(id: string, publisher: Publisher): void;
     /**
      * 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: any): false | undefined;
+    delete(id: string): boolean;
 }
 /**
  * Le Proxy Javascript
  */
-export default class Publisher extends PublisherProxy {
+export default class Publisher<T extends PublisherContentType = any> extends PublisherProxy<T> {
+    constructor(target: T, parentProxPub?: PublisherProxy | null);
+    getProperty<U, K extends keyof U>(o: U, propertyName: K): U[K];
 }
+export {};

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

@@ -1,8 +1,3 @@
-/**
- * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
- * Merci de laisser ce fichier sans la moindre dépendance.
- * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
- * **/
 function isComplex(value) {
     return typeof value === "object" && value != null;
 }
@@ -10,17 +5,18 @@ 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.root = this;
+        this._value_ = target;
+        this.parent = parentProxPub || null;
         while (this.root.parent) {
             this.root = this.root.parent;
         }
@@ -75,7 +71,7 @@ export class PublisherProxy {
     _publishTemplateFilling_(key, value) {
         this._templateFillListeners_.forEach((handler) => {
             let desc = Object.getOwnPropertyDescriptor(handler, key);
-            if (desc && !desc.set)
+            if (desc && !desc.set && !desc.writable)
                 return;
             if (handler.propertyMap && handler.propertyMap[key]) {
                 key = handler.propertyMap[key];
@@ -113,12 +109,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 +133,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);
     }
     /**
@@ -181,12 +181,14 @@ 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") &&
+        if ("hasOwnProperty" in this._value_ &&
+            this._value_.hasOwnProperty("__value") &&
             newValue.hasOwnProperty("__value") &&
             this._value_.__value === newValue.__value) {
             return true;
@@ -194,7 +196,8 @@ export class PublisherProxy {
         /**
          * 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.
@@ -210,14 +213,31 @@ 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_) {
+            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
@@ -230,17 +250,13 @@ export class PublisherProxy {
                 let valueV = isVComplex ? v : { __value: v };
                 if (!this._proxies_.has(key)) {
                     let newPublisher = new Publisher({}, this);
-                    this._proxies_.set(key, newPublisher, true);
+                    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;
     }
     /**
@@ -261,10 +277,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 +325,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;
@@ -328,6 +344,7 @@ export default class Publisher extends PublisherProxy {
              * Sinon un autre proxy qui a comme valeur interne la valeur corespondante à la clef dans l'objet.
              */
             get: function (oTarget, sKey) {
+                oTarget;
                 if ([
                     "invalidate",
                     "onInvalidate",
@@ -373,6 +390,7 @@ export default class Publisher extends PublisherProxy {
              * 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) {
+                var _a;
                 //Fonctionnement pour la donnée interne pas de dispatch;
                 if (sKey == "_value_") {
                     oTarget._value_ = vValue;
@@ -389,7 +407,7 @@ export default class Publisher extends PublisherProxy {
                 if (prevValue !== vValue) {
                     that._value_[sKey] = vValue;
                     that._publishDynamicFilling_(sKey, vValue);
-                    that._proxies_.get(sKey).set(isComplex(vValue) ? vValue : { __value: vValue });
+                    (_a = that._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);
@@ -398,38 +416,46 @@ export default class Publisher extends PublisherProxy {
              * 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];
             },
-            enumerate: function (oTarget, sKey) {
-                return that._value_.keys();
-            },
+            // enumerate: function (oTarget, sKey): any {
+            //   return that._value_.keys();
+            // },
             has: function (oTarget, sKey) {
+                oTarget;
                 return sKey in that._value_ && sKey != "_lockInternalMutationPublishing_";
             },
             defineProperty: function (oTarget, sKey, oDesc) {
+                oTarget;
                 if (oDesc && "value" in oDesc) {
                     that._value_[sKey] = oDesc.value;
                 }
                 return that._value_;
             },
             getOwnPropertyDescriptor: function (oTarget, sKey) {
-                var vValue = that._value_[sKey];
+                oTarget;
+                sKey;
                 return {
                     enumerable: true,
                     configurable: true,
                 };
             },
             ownKeys: function (target) {
+                target;
                 if (that._value_.__value)
-                    return Object.keys(this._value_.__value);
+                    return Object.keys(that._value_.__value);
                 return Object.keys(that._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

@@ -4,8 +4,12 @@ export declare type APIConfiguration = {
     userName: string | null;
     password: string | null;
     tokenProvider: string | null;
+    addHTTPResponse?: boolean;
+    credentials?: RequestCredentials;
 };
-declare class API {
+declare class API<ResultType = any & {
+    _sonic_http_response_?: Response;
+}, SendType = any> {
     /**
      * Ce tableau static permet de ne pas appeler plusieurs fois le même service lors d'appel concurrents en GET.
      */
@@ -30,16 +34,29 @@ 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<ResultType & {
+        _sonic_http_response_?: Response | undefined;
+        text?: string | undefined;
+    }>;
     /**
      * Basic auth
      */
     auth(): Promise<void>;
-    get(path: String, additionalHeaders?: HeadersInit): Promise<any>;
+    get(path: String, additionalHeaders?: HeadersInit): Promise<ResultType>;
     /**
      * Création du header, avec authentification si besoin
      * ajout du language via le header accept-language qui contient le langue du navigateur
@@ -49,22 +66,37 @@ 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>;
+    send(path: String, data: SendType, method?: string, additionalHeaders?: HeadersInit): Promise<ResultType & {
+        _sonic_http_response_?: Response | undefined;
+        text?: string | undefined;
+    }>;
     /**
      * 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(path: String, data: SendType | Record<string, string | Blob>, method?: string, additionalHeaders?: HeadersInit): Promise<ResultType & {
+        _sonic_http_response_?: Response | undefined;
+        text?: string | undefined;
+    }>;
     /**
      * Appel send en utilisant le méthode PUT
      */
-    put(path: String, data: any, additionalHeaders?: HeadersInit): Promise<any>;
+    put(path: String, data: SendType, additionalHeaders?: HeadersInit): Promise<ResultType & {
+        _sonic_http_response_?: Response | undefined;
+        text?: string | undefined;
+    }>;
     /**
      * Appel send en utilisant le méthode POST
      */
-    post(path: String, data: any, additionalHeaders?: HeadersInit): Promise<any>;
+    post(path: String, data: SendType, additionalHeaders?: HeadersInit): Promise<ResultType & {
+        _sonic_http_response_?: Response | undefined;
+        text?: string | undefined;
+    }>;
     /**
      * Appel send en utilisant le méthode delete
      */
-    delete(path: String, data: any, additionalHeaders?: HeadersInit): Promise<any>;
+    delete(path: String, data: SendType, additionalHeaders?: HeadersInit): Promise<ResultType & {
+        _sonic_http_response_?: Response | undefined;
+        text?: string | undefined;
+    }>;
 }
 export default API;