@dflat-core/web 1.0.0-beta

package/fesm2022/dflat-core-web-core.mjs

@@ -0,0 +1,743 @@
+import { CommonModule } from '@angular/common';
+import { provideHttpClient, withInterceptorsFromDi, HttpResponseBase, HttpResponse, HttpErrorResponse } from '@angular/common/http';
+import * as i0 from '@angular/core';
+import { Optional, SkipSelf, NgModule, Injectable } from '@angular/core';
+import moment from 'moment';
+
+class EnsureModuleLoadedOnceGuard {
+    constructor(targetModule) {
+        if (targetModule) {
+            throw new Error(`${targetModule.constructor.name} has already been loaded. Import this module in the AppModule only.`);
+        }
+    }
+}
+
+// IMPORTANT : DANS LE BUT DE FACILITER LES MERGE ET LA LECTURE DU CODE.
+// 1. TOUJOURS CONSERVER LE TRI SUR LES IMPORTS
+// UTILISER L'EXTENSION "TypeScript Import Sorter" DANS VSCODE.
+// CONFIGURER L'EXTENSION POUR ACTIVER LA MISE EN FORME AUTOMATIQUE A LA SAUVEGARDE 
+// 2. UTILISER CTRL-SHIFT O POUR SUPPRIMER AUTOMATIQUEMENT LES IMPORTS INUTILES
+// 3. TRIER LES COMPOSANTS OU DEPENDANCES DANS  LES DECLARATIONS (IMPORTS, EXPORTS)
+// SELECTION DU TEXTE PUIS CTRL-SHIFT P, "Sort Lines Ascending"
+// ON PEUT PARAMETRER DES RACCOURCIS CLAVIER DANS VSCODE
+// PAR EXEMPLE : CTRL-T UP (TRI CROISSANT) ou CTRL-T DOWN (TRI DECDROISSANT)
+// Ensure that CoreModule is only loaded into AppModule
+class CoreModule extends EnsureModuleLoadedOnceGuard {
+    // Looks for the module in the parent injector to see if it's already been loaded (only want it loaded once)
+    constructor(parentModule) {
+        super(parentModule);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: CoreModule, deps: [{ token: CoreModule, optional: true, skipSelf: true }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.4", ngImport: i0, type: CoreModule, imports: [CommonModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: CoreModule, providers: [provideHttpClient(withInterceptorsFromDi())], imports: [CommonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: CoreModule, decorators: [{
+            type: NgModule,
+            args: [{ exports: [],
+                    declarations: [], imports: [CommonModule], providers: [provideHttpClient(withInterceptorsFromDi())] }]
+        }], ctorParameters: () => [{ type: CoreModule, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }] });
+
+const isArray = Array.isArray || ((x) => x && typeof x.length === 'number');
+function isNumeric(val) {
+    // parseFloat NaNs numeric-cast false positives (null|true|false|"")
+    // ...but misinterprets leading-number strings, particularly hex literals ("0x...")
+    // subtraction forces infinities to NaN
+    // adding 1 corrects loss of precision from parseFloat (#15100)
+    return !isArray(val) && (val - parseFloat(val) + 1) >= 0;
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+class Utilities {
+    static delay(arg0) {
+        throw new Error("Method not implemented.");
+    }
+    static { this.captionAndMessageSeparator = ":"; }
+    static { this.noNetworkMessageCaption = "No Network"; }
+    static { this.noNetworkMessageDetail = "The server cannot be reached"; }
+    static { this.accessDeniedMessageCaption = "Access Denied!"; }
+    static { this.accessDeniedMessageDetail = ""; }
+    static getHttpResponseMessage(data) {
+        let responses = [];
+        if (data instanceof HttpResponseBase) {
+            if (this.checkNoNetwork(data)) {
+                responses.push(`${this.noNetworkMessageCaption}${this.captionAndMessageSeparator} ${this.noNetworkMessageDetail}`);
+            }
+            else {
+                let responseObject = this.getResponseBody(data);
+                if (responseObject && (typeof responseObject === 'object' || responseObject instanceof Object)) {
+                    for (let key in responseObject) {
+                        if (key)
+                            responses.push(`${key}${this.captionAndMessageSeparator} ${responseObject[key]}`);
+                        else if (responseObject[key])
+                            responses.push(responseObject[key].toString());
+                    }
+                }
+            }
+            if (!responses.length && this.getResponseBody(data))
+                responses.push(`${data.statusText}: ${this.getResponseBody(data).toString()}`);
+        }
+        if (!responses.length)
+            responses.push(data.toString());
+        if (this.checkAccessDenied(data))
+            responses.splice(0, 0, `${this.accessDeniedMessageCaption}${this.captionAndMessageSeparator} ${this.accessDeniedMessageDetail}`);
+        return responses;
+    }
+    static findHttpResponseMessage(messageToFind, data, seachInCaptionOnly = true, includeCaptionInResult = false) {
+        let searchString = messageToFind.toLowerCase();
+        let httpMessages = this.getHttpResponseMessage(data);
+        for (let message of httpMessages) {
+            let fullMessage = Utilities.splitInTwo(message, this.captionAndMessageSeparator);
+            if (fullMessage.firstPart && fullMessage.firstPart.toLowerCase().indexOf(searchString) != -1) {
+                return includeCaptionInResult ? message : fullMessage.secondPart || fullMessage.firstPart;
+            }
+        }
+        if (!seachInCaptionOnly) {
+            for (let message of httpMessages) {
+                if (message.toLowerCase().indexOf(searchString) != -1) {
+                    if (includeCaptionInResult) {
+                        return message;
+                    }
+                    else {
+                        let fullMessage = Utilities.splitInTwo(message, this.captionAndMessageSeparator);
+                        return fullMessage.secondPart || fullMessage.firstPart;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    static getResponseBody(response) {
+        if (response instanceof HttpResponse)
+            return response.body;
+        if (response instanceof HttpErrorResponse)
+            return response.error || response.message || response.statusText;
+    }
+    static checkNoNetwork(response) {
+        if (response instanceof HttpResponseBase) {
+            return response.status == 0;
+        }
+        return false;
+    }
+    static checkAccessDenied(response) {
+        if (response instanceof HttpResponseBase) {
+            return response.status == 403;
+        }
+        return false;
+    }
+    static checkNotFound(response) {
+        if (response instanceof HttpResponseBase) {
+            return response.status == 404;
+        }
+        return false;
+    }
+    static checkIsLocalHost(url, base) {
+        if (url) {
+            let location = new URL(url, base);
+            return location.hostname === "localhost" || location.hostname === "127.0.0.1";
+        }
+        return false;
+    }
+    static getQueryParamsFromString(paramString) {
+        if (!paramString)
+            return null;
+        let params = {};
+        for (let param of paramString.split("&")) {
+            let keyValue = Utilities.splitInTwo(param, "=");
+            params[keyValue.firstPart] = keyValue.secondPart;
+        }
+        return params;
+    }
+    static splitInTwo(text, separator) {
+        let separatorIndex = text.indexOf(separator);
+        if (separatorIndex == -1)
+            return { firstPart: text, secondPart: null };
+        let part1 = text.substr(0, separatorIndex).trim();
+        let part2 = text.substr(separatorIndex + 1).trim();
+        return { firstPart: part1, secondPart: part2 };
+    }
+    static safeStringify(object) {
+        let result;
+        try {
+            result = JSON.stringify(object);
+            return result;
+        }
+        catch (error) {
+        }
+        let simpleObject = {};
+        for (let prop in object) {
+            if (!object.hasOwnProperty(prop)) {
+                continue;
+            }
+            if (typeof (object[prop]) == 'object') {
+                continue;
+            }
+            if (typeof (object[prop]) == 'function') {
+                continue;
+            }
+            simpleObject[prop] = object[prop];
+        }
+        result = "[***Sanitized Object***]: " + JSON.stringify(simpleObject);
+        return result;
+    }
+    static JSonTryParse(value) {
+        try {
+            return JSON.parse(value);
+        }
+        catch (e) {
+            if (value === "undefined")
+                return void 0;
+            return value;
+        }
+    }
+    static isNonEmptyString(str) {
+        return str && str.length > 0;
+    }
+    static isEmptyString(str) {
+        return Utilities.IsNil(str) || str.length === 0;
+    }
+    static areValuesEqual(a, b) {
+        if (a === b)
+            return true;
+        if (a instanceof Date && b instanceof Date) {
+            return a.getTime() === b.getTime();
+        }
+        if (a?.valueOf && b?.valueOf) {
+            return a.valueOf() === b.valueOf();
+        }
+        if (typeof a !== 'object' && typeof b !== 'object') {
+            return a === b;
+        }
+        return JSON.stringify(a) === JSON.stringify(b);
+    }
+    static TestIsObjectEmpty(obj) {
+        for (let prop in obj) {
+            if (obj.hasOwnProperty(prop)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    static IsUndefined(value) {
+        return typeof value === 'undefined';
+    }
+    static IsNil(value) {
+        return (value == null) || value === undefined || typeof value === 'undefined';
+    }
+    static TestIsString(value) {
+        return typeof value === 'string' || value instanceof String;
+    }
+    static capitalizeFirstLetter(text) {
+        if (text)
+            return text.charAt(0).toUpperCase() + text.slice(1);
+        else
+            return text;
+    }
+    static toTitleCase(text) {
+        return text.replace(/\w\S*/g, (subString) => {
+            return subString.charAt(0).toUpperCase() + subString.substr(1).toLowerCase();
+        });
+    }
+    static toLowerCase(items) {
+        if (items instanceof Array) {
+            let loweredRoles = [];
+            for (let i = 0; i < items.length; i++) {
+                loweredRoles[i] = items[i].toLowerCase();
+            }
+            return loweredRoles;
+        }
+        else if (typeof items === 'string' || items instanceof String) {
+            return items.toLowerCase();
+        }
+    }
+    static uniqueId() {
+        return this.randomNumber(1000000, 9000000).toString();
+    }
+    static randomNumber(min, max) {
+        return Math.floor(Math.random() * (max - min + 1) + min);
+    }
+    static baseUrl() {
+        let base = '';
+        if (window.location.origin)
+            base = window.location.origin;
+        else
+            base = window.location.protocol + "//" + window.location.hostname + (window.location.port ? ':' + window.location.port : '');
+        return base.replace(/\/$/, '');
+    }
+    static printDateOnly(date) {
+        date = new Date(date);
+        let dayNames = new Array("Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday");
+        let monthNames = new Array("January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December");
+        let dayOfWeek = date.getDay();
+        let dayOfMonth = date.getDate();
+        let sup = "";
+        let month = date.getMonth();
+        let year = date.getFullYear();
+        if (dayOfMonth == 1 || dayOfMonth == 21 || dayOfMonth == 31) {
+            sup = "st";
+        }
+        else if (dayOfMonth == 2 || dayOfMonth == 22) {
+            sup = "nd";
+        }
+        else if (dayOfMonth == 3 || dayOfMonth == 23) {
+            sup = "rd";
+        }
+        else {
+            sup = "th";
+        }
+        let dateString = dayNames[dayOfWeek] + ", " + dayOfMonth + sup + " " + monthNames[month] + " " + year;
+        return dateString;
+    }
+    static printTimeOnly(date) {
+        date = new Date(date);
+        let period = "";
+        let minute = date.getMinutes().toString();
+        let hour = date.getHours();
+        period = hour < 12 ? "AM" : "PM";
+        if (hour == 0) {
+            hour = 12;
+        }
+        if (hour > 12) {
+            hour = hour - 12;
+        }
+        if (minute.length == 1) {
+            minute = "0" + minute;
+        }
+        let timeString = hour + ":" + minute + " " + period;
+        return timeString;
+    }
+    static printDate(date, separator = "at") {
+        return `${Utilities.printDateOnly(date)} ${separator} ${Utilities.printTimeOnly(date)}`;
+    }
+    static printFriendlyDate(date, separator = "-") {
+        let today = new Date();
+        today.setHours(0, 0, 0, 0);
+        let yesterday = new Date(today);
+        yesterday.setDate(yesterday.getDate() - 1);
+        let test = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+        if (test.toDateString() == today.toDateString())
+            return `Today ${separator} ${Utilities.printTimeOnly(date)}`;
+        if (test.toDateString() == yesterday.toDateString())
+            return `Yesterday ${separator} ${Utilities.printTimeOnly(date)}`;
+        else
+            return Utilities.printDate(date, separator);
+    }
+    static printShortDate(date, separator = "/", dateTimeSeparator = "-") {
+        var day = date.getDate().toString();
+        var month = (date.getMonth() + 1).toString();
+        var year = date.getFullYear();
+        if (day.length == 1)
+            day = "0" + day;
+        if (month.length == 1)
+            month = "0" + month;
+        return `${month}${separator}${day}${separator}${year} ${dateTimeSeparator} ${Utilities.printTimeOnly(date)}`;
+    }
+    static parseDate(date) {
+        if (date) {
+            if (date instanceof Date) {
+                return date;
+            }
+            if (typeof date === 'string' || date instanceof String) {
+                if (date.search(/[a-su-z+]/i) == -1)
+                    date = date + "Z";
+                return new Date(date);
+            }
+            if (typeof date === 'number' || date instanceof Number) {
+                return new Date(date);
+            }
+        }
+    }
+    static Format2Digits(n) {
+        return n > 9 ? "" + n : "0" + n;
+    }
+    static printDuration(start, end) {
+        start = new Date(start);
+        end = new Date(end);
+        // get total seconds between the times
+        let delta = Math.abs(start.valueOf() - end.valueOf()) / 1000;
+        // calculate (and subtract) whole days
+        let days = Math.floor(delta / 86400);
+        delta -= days * 86400;
+        // calculate (and subtract) whole hours
+        let hours = Math.floor(delta / 3600) % 24;
+        delta -= hours * 3600;
+        // calculate (and subtract) whole minutes
+        let minutes = Math.floor(delta / 60) % 60;
+        delta -= minutes * 60;
+        // what's left is seconds
+        let seconds = delta % 60; // in theory the modulus is not required
+        let printedDays = "";
+        if (days)
+            printedDays = `${days} days`;
+        if (hours)
+            printedDays += printedDays ? `, ${hours} hours` : `${hours} hours`;
+        if (minutes)
+            printedDays += printedDays ? `, ${minutes} minutes` : `${minutes} minutes`;
+        if (seconds)
+            printedDays += printedDays ? ` and ${seconds} seconds` : `${seconds} seconds`;
+        if (!printedDays)
+            printedDays = "0";
+        return printedDays;
+    }
+    static getAge(birthDate, otherDate) {
+        birthDate = new Date(birthDate);
+        otherDate = new Date(otherDate);
+        let years = (otherDate.getFullYear() - birthDate.getFullYear());
+        if (otherDate.getMonth() < birthDate.getMonth() ||
+            otherDate.getMonth() == birthDate.getMonth() && otherDate.getDate() < birthDate.getDate()) {
+            years--;
+        }
+        return years;
+    }
+    static isDateAEarlierThanDateB(dateA, dateB) {
+        return dateA.getFullYear() < dateB.getFullYear()
+            || (dateA.getFullYear() == dateB.getFullYear() && dateA.getMonth() < dateB.getMonth())
+            || (dateA.getMonth() == dateB.getMonth() && dateA.getDate() < dateB.getDate());
+    }
+    static searchArray(searchTerm, caseSensitive, ...values) {
+        if (!searchTerm)
+            return true;
+        if (!caseSensitive)
+            searchTerm = searchTerm.toLowerCase();
+        for (let value of values) {
+            if (value != null) {
+                let strValue = value.toString();
+                if (!caseSensitive)
+                    strValue = strValue.toLowerCase();
+                if (strValue.indexOf(searchTerm) !== -1)
+                    return true;
+            }
+        }
+        return false;
+    }
+    static moveArrayItem(array, oldIndex, newIndex) {
+        while (oldIndex < 0) {
+            oldIndex += this.length;
+        }
+        while (newIndex < 0) {
+            newIndex += this.length;
+        }
+        if (newIndex >= this.length) {
+            var k = newIndex - this.length;
+            while ((k--) + 1) {
+                array.push(undefined);
+            }
+        }
+        array.splice(newIndex, 0, array.splice(oldIndex, 1)[0]);
+    }
+    static expandCamelCase(text) {
+        if (!text)
+            return text;
+        return text.replace(/([A-Z][a-z]+)/g, " $1")
+            .replace(/([A-Z][A-Z]+)/g, " $1")
+            .replace(/([^A-Za-z ]+)/g, " $1");
+    }
+    static testIsAbsoluteUrl(url) {
+        let r = new RegExp('^(?:[a-z]+:)?//', 'i');
+        return r.test(url);
+    }
+    static convertToAbsoluteUrl(url) {
+        return Utilities.testIsAbsoluteUrl(url) ? url : '//' + url;
+    }
+    static removeNulls(obj) {
+        let isArray = obj instanceof Array;
+        for (let k in obj) {
+            if (obj[k] === null) {
+                isArray ? obj.splice(k, 1) : delete obj[k];
+            }
+            else if (typeof obj[k] == "object") {
+                Utilities.removeNulls(obj[k]);
+            }
+            if (isArray && obj.length == k) {
+                Utilities.removeNulls(obj);
+            }
+        }
+        return obj;
+    }
+    static debounce(func, wait, immediate) {
+        var timeout;
+        return function () {
+            var context = this;
+            var args_ = arguments;
+            var later = function () {
+                timeout = null;
+                if (!immediate)
+                    func.apply(context, args_);
+            };
+            var callNow = immediate && !timeout;
+            clearTimeout(timeout);
+            timeout = setTimeout(later, wait);
+            if (callNow)
+                func.apply(context, args_);
+        };
+    }
+    static { this.cookies = {
+        getItem: (sKey) => {
+            return decodeURIComponent(document.cookie.replace(new RegExp("(?:(?:^|.*;)\\s*" + encodeURIComponent(sKey).replace(/[\-\.\+\*]/g, "\\$&") + "\\s*\\=\\s*([^;]*).*$)|^.*$"), "$1")) || null;
+        },
+        setItem: (sKey, sValue, vEnd, sPath, sDomain, bSecure) => {
+            if (!sKey || /^(?:expires|max\-age|path|domain|secure)$/i.test(sKey)) {
+                return false;
+            }
+            var sExpires = "";
+            if (vEnd) {
+                switch (vEnd.constructor) {
+                    case Number:
+                        sExpires = vEnd === Infinity ? "; expires=Fri, 31 Dec 9999 23:59:59 GMT" : "; max-age=" + vEnd;
+                        break;
+                    case String:
+                        sExpires = "; expires=" + vEnd;
+                        break;
+                    case Date:
+                        sExpires = "; expires=" + vEnd.toUTCString();
+                        break;
+                }
+            }
+            document.cookie = encodeURIComponent(sKey) + "=" + encodeURIComponent(sValue) + sExpires + (sDomain ? "; domain=" + sDomain : "") + (sPath ? "; path=" + sPath : "") + (bSecure ? "; secure" : "");
+            return true;
+        },
+        removeItem: (sKey, sPath, sDomain) => {
+            if (!sKey) {
+                return false;
+            }
+            document.cookie = encodeURIComponent(sKey) + "=; expires=Thu, 01 Jan 1970 00:00:00 GMT" + (sDomain ? "; domain=" + sDomain : "") + (sPath ? "; path=" + sPath : "");
+            return true;
+        },
+        hasItem: (sKey) => {
+            return (new RegExp("(?:^|;\\s*)" + encodeURIComponent(sKey).replace(/[\-\.\+\*]/g, "\\$&") + "\\s*\\=")).test(document.cookie);
+        },
+        keys: () => {
+            var aKeys = document.cookie.replace(/((?:^|\s*;)[^\=]+)(?=;|$)|^\s*|\s*(?:\=[^;]*)?(?:\1|$)/g, "").split(/\s*(?:\=[^;]*)?;\s*/);
+            for (var nIdx = 0; nIdx < aKeys.length; nIdx++) {
+                aKeys[nIdx] = decodeURIComponent(aKeys[nIdx]);
+            }
+            return aKeys;
+        }
+    }; }
+    static isNumber(field) {
+        return (typeof field === 'number' || field instanceof Number);
+    }
+    static changeName(item) {
+        if (item)
+            return item.replace(/[&\/\\#,+()$~%.'":*?<>{}]/g, '');
+        return item;
+    }
+    static transform(value, args = null) {
+        return Object.keys(value).map(k => {
+            return { key: k, value: value[k] };
+        });
+    }
+    static GetChannel(entityTypeKey) {
+        if (this.IsNil(entityTypeKey))
+            return entityTypeKey;
+        let k = entityTypeKey.toLowerCase();
+        switch (k) {
+            case "shipment":
+                return "SHP";
+            case "dataimport":
+                return "INP";
+            case "request":
+                return "RQT";
+            case "synchronizedcompany":
+                return "CPY";
+            case "sellingorder":
+                return "ORD";
+            case "purchaseorder":
+                return "ORD";
+            default:
+                return entityTypeKey;
+        }
+    }
+    static getProp(object, property) {
+        return object[property];
+    }
+    /**
+     * static getCustomDvalue: stringate
+     */
+    static getCustomDate(value) {
+        let m;
+        if (value.split("/").length > 1)
+            m = moment.utc(value, "DD/MM/YYYY");
+        else
+            m = moment.utc(value);
+        let date = new Date(m.year(), m.month(), m.date());
+        return isNaN(date.valueOf()) ? null : date;
+    }
+    static isLowerThan(value1, value2) {
+        let d1, d2;
+        if (typeof value1 === 'string')
+            d1 = this.getCustomDate(value1);
+        else
+            d1 = value1;
+        if (typeof value2 === 'string')
+            d2 = this.getCustomDate(value2);
+        else
+            d2 = value2;
+        return d1 < d2;
+    }
+    static getLogClass(log) {
+        let regexInfo = /INFO/g;
+        let regexData = /DATA/g;
+        let regexError = /ERROR/g;
+        let regexWarn = /WARNING/g;
+        if (regexInfo.test(log)) {
+            return "log-info";
+        }
+        if (regexData.test(log)) {
+            return "log-data";
+        }
+        if (regexError.test(log)) {
+            return "log-error";
+        }
+        if (regexWarn.test(log)) {
+            return "log-warning";
+        }
+        return "";
+    }
+    static deepCopy(obj) {
+        var copy;
+        // Handle the 3 simple types, and null or undefined
+        if (null == obj || "object" != typeof obj)
+            return obj;
+        // Handle Date
+        if (obj instanceof Date) {
+            copy = new Date();
+            copy.setTime(obj.getTime());
+            return copy;
+        }
+        // Handle Array
+        if (obj instanceof Array) {
+            copy = [];
+            for (var i = 0, len = obj.length; i < len; i++) {
+                copy[i] = Utilities.deepCopy(obj[i]);
+            }
+            return copy;
+        }
+        // Handle Object
+        if (obj instanceof Object) {
+            copy = {};
+            for (var attr in obj) {
+                if (obj.hasOwnProperty(attr))
+                    copy[attr] = Utilities.deepCopy(obj[attr]);
+            }
+            return copy;
+        }
+        throw new Error("Unable to copy obj! Its type isn't supported.");
+    }
+    static getCleanNumber(initial) {
+        // Si la chaine est vide, on renvoie 0
+        let value = initial.replace(',', '.');
+        if (!isNumeric(value)) {
+            // On supprime tous les caractères qui ne sont pas des chiffres.
+            value = '';
+            let hasSeparator = false;
+            for (var i = 0; i < initial.length; i++) {
+                let ch = initial[i];
+                if (isNumeric(ch)) {
+                    value = value + ch;
+                }
+                else if (!hasSeparator && (ch == '.' || ch == ',')) {
+                    value = value + ch;
+                    hasSeparator = true;
+                }
+            }
+            value = value.replace(',', '.');
+            if (!isNumeric(value))
+                return 0;
+        }
+        let n = Number.parseFloat(value);
+        return n;
+    }
+    static addDays(date, days) {
+        var date = new Date(date.valueOf());
+        date.setDate(date.getDate() + days);
+        return date;
+    }
+    static getFormattedParams(params) {
+        // Dans le cas d'un tableau, parcours tous les éléments du tableau pour formatter les
+        let result;
+        if (Array.isArray(params)) {
+            if (params.length > 0 && typeof (params[0]) === 'number')
+                return JSON.stringify(params);
+            result = [];
+            params.forEach(entity => {
+                result.push(this.getFormattedParams(entity));
+            });
+            return JSON.stringify(result);
+        }
+        result = {};
+        for (let key in params) {
+            if (params.hasOwnProperty(key)) {
+                let val = params[key];
+                if (val !== undefined && val !== null) {
+                    //Handle the Date javascript object
+                    if (val instanceof Date) {
+                        val = `${Utilities.Format2Digits(val.getFullYear())}-${Utilities.Format2Digits(val.getMonth() + 1)}-${Utilities.Format2Digits(val.getDate())}T00:00:00.000Z`;
+                    }
+                    result[key] = val;
+                }
+            }
+        }
+        return result;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: Utilities, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: Utilities }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: Utilities, decorators: [{
+            type: Injectable
+        }] });
+
+function nameof(f) {
+    var p = new Proxy({}, {
+        get: (target, key) => key
+    });
+    return f(p);
+}
+
+// export function groupBy<TItem>(xs: TItem[], key: string) : {[key: string]: TItem[]}{
+//     return xs.reduce(function(rv, x) {
+//       (rv[x[key]] = rv[x[key]] || []).push(x);
+//       return rv;
+//     }, {});
+//   };
+function groupBy(xs, key) {
+    return xs.reduce(function (rv, x) {
+        (rv[x[key]] = rv[x[key]] || []).push(x);
+        return rv;
+    }, {});
+}
+;
+function groupByFunc(xs, func) {
+    return xs.reduce(function (rv, x) {
+        let k = func(x);
+        (rv[k] = rv[k] || []).push(x);
+        return rv;
+    }, {});
+}
+;
+function sumOf(xs, func) {
+    return xs.map(func).reduce((a, b) => a + b);
+}
+// https://codereview.stackexchange.com/a/100843
+function distinct(array) {
+    return array.reduce(function (carry, item) {
+        if (item && !~carry.indexOf(item))
+            carry.push(item);
+        return carry;
+    }, []);
+}
+
+class EnvironmentBase {
+}
+;
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { CoreModule, EnsureModuleLoadedOnceGuard, EnvironmentBase, Utilities, distinct, groupBy, groupByFunc, isArray, isNumeric, nameof, sleep, sumOf };
+//# sourceMappingURL=dflat-core-web-core.mjs.map