@factor_ec/utils 3.0.3 → 5.0.1

package/fesm2022/factor_ec-utils.mjs

@@ -1,10 +1,38 @@
 import * as i0 from '@angular/core';
-import { Injectable, PLATFORM_ID, Inject } from '@angular/core';
+import { Injectable, PLATFORM_ID, Inject, InjectionToken, inject } from '@angular/core';
 import { isPlatformBrowser } from '@angular/common';
 import * as i1 from '@angular/router';
 import { NavigationEnd } from '@angular/router';
+import { Apollo, APOLLO_OPTIONS, gql } from 'apollo-angular';
+import { HttpLink } from 'apollo-angular/http';
+import { InMemoryCache } from '@apollo/client/core';
+import { lastValueFrom } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+
+class ArrayService {
+    merge(arrays, prop) {
+        const merged = {};
+        arrays.forEach(arr => {
+            arr.forEach((item) => {
+                merged[item[prop]] = Object.assign({}, merged[item[prop]], item);
+            });
+        });
+        return Object.values(merged);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: ArrayService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: ArrayService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: ArrayService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
 
 class ColorService {
+    L;
+    S;
+    hueRanges;
     constructor() {
         const options = {};
         let LS = [options.lightness, options.saturation].map(function (param) {
@@ -25,7 +53,7 @@ class ColorService {
         this.hueRanges = options.hue.map(function (range) {
             return {
                 min: typeof range.min === 'undefined' ? 0 : range.min,
-                max: typeof range.max === 'undefined' ? 360 : range.max
+                max: typeof range.max === 'undefined' ? 360 : range.max,
             };
         });
     }
@@ -50,7 +78,6 @@ class ColorService {
         }
         return hash;
     }
-    ;
     /**
      * Convert RGB Array to HEX
      *
@@ -67,7 +94,6 @@ class ColorService {
         });
         return hex;
     }
-    ;
     /**
      * Convert HSL to RGB
      *
@@ -103,7 +129,6 @@ class ColorService {
             return Math.round(color * 255);
         });
     }
-    ;
     /**
      * Returns the hash in [h, s, l].
      * Note that H ∈ [0, 360); S ∈ [0, 1]; L ∈ [0, 1];
@@ -119,7 +144,11 @@ class ColorService {
         if (this.hueRanges.length) {
             let range = this.hueRanges[hash % this.hueRanges.length];
             let hueResolution = 727; // note that 727 is a prime
-            H = ((hash / this.hueRanges.length) % hueResolution) * (range.max - range.min) / hueResolution + range.min;
+            H =
+                (((hash / this.hueRanges.length) % hueResolution) *
+                    (range.max - range.min)) /
+                    hueResolution +
+                    range.min;
         }
         else {
             H = hash % 359; // note that 359 is a prime
@@ -130,7 +159,6 @@ class ColorService {
         L = this.L[hash % this.L.length];
         return [H, S, L];
     }
-    ;
     /**
      * Returns the hash in [r, g, b].
      * Note that R, G, B ∈ [0, 255]
@@ -142,7 +170,6 @@ class ColorService {
         let hsl = this.hsl(str);
         return this.hsl2rgb(hsl[0], hsl[1], hsl[2]);
     }
-    ;
     /**
      * Returns the hash in hex
      *
@@ -153,18 +180,285 @@ class ColorService {
         let rgb = this.rgb(str);
         return this.rgb2hex(rgb);
     }
-    ;
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: ColorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: ColorService, providedIn: 'root' }); }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: ColorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: ColorService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: ColorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+class CsvConfigConsts {
+    static EOL = '\r\n';
+    static BOM = '\ufeff';
+    static DEFAULT_FIELD_SEPARATOR = ',';
+    static DEFAULT_DECIMAL_SEPARATOR = '.';
+    static DEFAULT_QUOTE = '"';
+    static DEFAULT_SHOW_TITLE = false;
+    static DEFAULT_TITLE = 'My Generated Report';
+    static DEFAULT_FILENAME = 'generated';
+    static DEFAULT_SHOW_LABELS = false;
+    static DEFAULT_USE_TEXT_FILE = false;
+    static DEFAULT_USE_BOM = true;
+    static DEFAULT_HEADER = [];
+    static DEFAULT_KEYS_AS_HEADERS = false;
+}
+const ConfigDefaults = {
+    filename: CsvConfigConsts.DEFAULT_FILENAME,
+    fieldSeparator: CsvConfigConsts.DEFAULT_FIELD_SEPARATOR,
+    quoteStrings: CsvConfigConsts.DEFAULT_QUOTE,
+    decimalSeparator: CsvConfigConsts.DEFAULT_DECIMAL_SEPARATOR,
+    showLabels: CsvConfigConsts.DEFAULT_SHOW_LABELS,
+    showTitle: CsvConfigConsts.DEFAULT_SHOW_TITLE,
+    title: CsvConfigConsts.DEFAULT_TITLE,
+    useTextFile: CsvConfigConsts.DEFAULT_USE_TEXT_FILE,
+    useBom: CsvConfigConsts.DEFAULT_USE_BOM,
+    headers: CsvConfigConsts.DEFAULT_HEADER,
+    useKeysAsHeaders: CsvConfigConsts.DEFAULT_KEYS_AS_HEADERS
+};
+class CsvService {
+    _data = [];
+    _options;
+    _csv = '';
+    get options() {
+        return this._options;
+    }
+    set options(options) {
+        this._options = this.objectAssign({}, ConfigDefaults, options);
+    }
+    constructor() {
+        this._options = this.objectAssign({}, ConfigDefaults);
+    }
+    /**
+     * Generate and Download Csv
+     */
+    generate(jsonData, shouldReturnCsv = false) {
+        // Make sure to reset csv data on each run
+        this._csv = '';
+        this._parseData(jsonData);
+        if (this._options.useBom) {
+            this._csv += CsvConfigConsts.BOM;
+        }
+        if (this._options.showTitle) {
+            this._csv += this._options.title + '\r\n\n';
+        }
+        this._getHeaders();
+        this._getBody();
+        if (this._csv == '') {
+            console.log('Invalid data');
+            return;
+        }
+        // When the consumer asks for the data, exit the function
+        // by returning the CSV data built at this point
+        if (shouldReturnCsv) {
+            return this._csv;
+        }
+        // Create CSV blob to download if requesting in the browser and the
+        // consumer doesn't set the shouldReturnCsv param
+        const FileType = this._options.useTextFile ? 'plain' : 'csv';
+        const fileExtension = this._options.useTextFile ? '.txt' : '.csv';
+        const blob = new Blob([this._csv], {
+            type: 'text/' + FileType + ';charset=utf8;'
+        });
+        //const attachmentType = this._options.useTextFile ? 'text' : 'csv';
+        // const uri = 'data:attachment/' + attachmentType + ';charset=utf-8,' + encodeURI(this._csv);
+        const link = document.createElement('a');
+        link.href = URL.createObjectURL(blob);
+        link.setAttribute('visibility', 'hidden');
+        link.download = this._options.filename.replace(/ /g, '_') + fileExtension;
+        document.body.appendChild(link);
+        link.click();
+        document.body.removeChild(link);
+    }
+    /**
+     * Create Headers
+     */
+    _getHeaders() {
+        if (!this._options.showLabels && !this._options.useKeysAsHeaders) {
+            return;
+        }
+        const useKeysAsHeaders = this._options.useKeysAsHeaders;
+        const headers = useKeysAsHeaders
+            ? Object.keys(this._data[0])
+            : this._options.headers;
+        if (headers.length > 0) {
+            let row = '';
+            for (let keyPos = 0; keyPos < headers.length; keyPos++) {
+                row += headers[keyPos] + this._options.fieldSeparator;
+            }
+            row = row.slice(0, -1);
+            this._csv += row + CsvConfigConsts.EOL;
+        }
+    }
+    /**
+     * Create Body
+     */
+    _getBody() {
+        const keys = Object.keys(this._data[0]);
+        for (var i = 0; i < this._data.length; i++) {
+            let row = '';
+            for (let keyPos = 0; keyPos < keys.length; keyPos++) {
+                const key = keys[keyPos];
+                row +=
+                    this._formatData(this._data[i][key]) + this._options.fieldSeparator;
+            }
+            row = row.slice(0, -1);
+            this._csv += row + CsvConfigConsts.EOL;
+        }
+    }
+    /**
+     * Format Data
+     * @param {any} data
+     */
+    _formatData(data) {
+        if (this._options.decimalSeparator === 'locale' && this._isFloat(data)) {
+            return data.toLocaleString();
+        }
+        if (this._options.decimalSeparator !== '.' && this._isFloat(data)) {
+            return data.toString().replace('.', this._options.decimalSeparator);
+        }
+        if (typeof data === 'string') {
+            data = data.replace(/"/g, '""');
+            if (this._options.quoteStrings ||
+                data.indexOf(',') > -1 ||
+                data.indexOf('\n') > -1 ||
+                data.indexOf('\r') > -1) {
+                data = this._options.quoteStrings + data + this._options.quoteStrings;
+            }
+            return data;
+        }
+        if (typeof data === 'boolean') {
+            return data ? 'TRUE' : 'FALSE';
+        }
+        return data;
+    }
+    /**
+     * Check if is Float
+     * @param {any} input
+     */
+    _isFloat(input) {
+        return +input === input && (!isFinite(input) || Boolean(input % 1));
+    }
+    /**
+     * Parse the collection given to it
+     *
+     * @private
+     * @param {*} jsonData
+     * @returns {any[]}
+     * @memberof ExportToCsv
+     */
+    _parseData(jsonData) {
+        this._data = typeof jsonData != 'object' ? JSON.parse(jsonData) : jsonData;
+        return this._data;
+    }
+    /**
+     * Convet to Object
+     * @param {any} val
+     */
+    toObject(val) {
+        if (val === null || val === undefined) {
+            throw new TypeError('Object.assign cannot be called with null or undefined');
+        }
+        return Object(val);
+    }
+    /**
+     * Assign data  to new Object
+     * @param {any}   target
+     * @param {any[]} ...source
+     */
+    objectAssign(target, ...source) {
+        let from;
+        const to = this.toObject(target);
+        let symbols;
+        let hasOwnProperty = Object.prototype.hasOwnProperty;
+        let propIsEnumerable = Object.prototype.propertyIsEnumerable;
+        for (var s = 1; s < arguments.length; s++) {
+            from = Object(arguments[s]);
+            for (var key in from) {
+                if (hasOwnProperty.call(from, key)) {
+                    to[key] = from[key];
+                }
+            }
+            if (Object.getOwnPropertySymbols) {
+                symbols = Object.getOwnPropertySymbols(from);
+                for (let i = 0; i < symbols.length; i++) {
+                    if (propIsEnumerable.call(from, symbols[i])) {
+                        to[symbols[i]] = from[symbols[i]];
+                    }
+                }
+            }
+        }
+        return to;
+    }
+    read(csvContent) {
+        const lines = csvContent.split('\n');
+        let header;
+        let content;
+        if (lines.length > 0) {
+            const csv = lines.map((line) => {
+                return this.parseLine(line.trim());
+            });
+            header = csv[0];
+            // Si encuentra una linea en blanco ya no sigue leyendo las siguientes líneas
+            let breakIndex;
+            csv.some((row, index) => {
+                const isBlankLine = row.every((column) => column.trim() === '');
+                if (isBlankLine) {
+                    breakIndex = index;
+                    return true;
+                }
+                return false;
+            });
+            content = csv.slice(1, breakIndex);
+        }
+        else {
+            header = [];
+            content = [];
+        }
+        return {
+            header,
+            content
+        };
+    }
+    parseLine(csvLine) {
+        const values = [];
+        const regex = /(?:"([^"]*)"|'([^']*)'|([^,]+))(?:,|\r?$)/g;
+        let match;
+        while ((match = regex.exec(csvLine)) !== null) {
+            values.push(match[1] || match[2] || match[3]); // Extraer el valor correcto
+        }
+        return values;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: CsvService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: CsvService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: CsvService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+
+class DateService {
+    getDate(date) {
+        const dateParts = date.split('T')[0].split('-');
+        return new Date(Number(dateParts[0]), Number(dateParts[1]) - 1, Number(dateParts[2]));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: DateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: DateService, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: ColorService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: DateService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
-        }], ctorParameters: function () { return []; } });
+        }] });
 
 class FilesService {
+    callback;
+    fileInput;
     constructor() {
         this.fileInput = document.createElement('input');
         this.fileInput.type = 'file';
@@ -199,17 +493,20 @@ class FilesService {
             this.callback = callback;
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: FilesService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: FilesService, providedIn: 'root' }); }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: FilesService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: FilesService, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: FilesService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: FilesService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
-        }], ctorParameters: function () { return []; } });
+        }], ctorParameters: () => [] });
 
 class GoogleTagManagerService {
+    platformId;
+    router;
+    trackingId;
     constructor(platformId, router) {
         this.platformId = platformId;
         this.router = router;
@@ -266,20 +563,302 @@ class GoogleTagManagerService {
             }
         });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: GoogleTagManagerService, deps: [{ token: PLATFORM_ID }, { token: i1.Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: GoogleTagManagerService, providedIn: 'root' }); }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: GoogleTagManagerService, deps: [{ token: PLATFORM_ID }, { token: i1.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: GoogleTagManagerService, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: GoogleTagManagerService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: GoogleTagManagerService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
-        }], ctorParameters: function () { return [{ type: Object, decorators: [{
+        }], ctorParameters: () => [{ type: Object, decorators: [{
                     type: Inject,
                     args: [PLATFORM_ID]
-                }] }, { type: i1.Router }]; } });
+                }] }, { type: i1.Router }] });
+
+const UTILS_OPTIONS = new InjectionToken('UTILS_OPTIONS');
+
+class UtilsService {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    get() {
+        return this.options;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: UtilsService, deps: [{ token: UTILS_OPTIONS }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: UtilsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: UtilsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [UTILS_OPTIONS]
+                }] }] });
+
+function apolloOptionsFactory() {
+    const httpLink = inject(HttpLink);
+    const options = inject(UtilsService);
+    return {
+        link: httpLink.create({ uri: options.get().graphqlEndpoint }),
+        cache: new InMemoryCache(),
+    };
+}
+const graphqlProvider = [
+    Apollo,
+    {
+        provide: APOLLO_OPTIONS,
+        useFactory: apolloOptionsFactory,
+    },
+];
+
+class StringService {
+    decodeHTML(text) {
+        const span = document.createElement('span');
+        return text.replace(/&[#A-Za-z0-9]+;/gi, (entity) => {
+            span.innerHTML = entity;
+            return span.innerText;
+        });
+    }
+    /**
+     * Normaliza un texto para evitar el Case y los acentos
+     * @param text texto a normalizar
+     * @returns texto normalizado
+     */
+    normalize(text) {
+        if (!text)
+            return '';
+        return text
+            .toLowerCase()
+            .normalize("NFD")
+            .replace(/[\u0300-\u036f]/g, "");
+    }
+    normalizeName(text) {
+        text = text.trim();
+        text = text.charAt(0).toUpperCase() + text.slice(1);
+        return text;
+    }
+    calculateReadingTime(text) {
+        // Caracteres por minuto
+        const cpm = 1000;
+        // Calcular el número de caracteres en el texto
+        const numCharacters = text.length;
+        // Calcular el tiempo de lectura en minutos
+        const readingTimeMinutes = numCharacters / cpm;
+        // Convertir el tiempo de lectura de minutos a milisegundos
+        const readingTimeMilliseconds = readingTimeMinutes * 60 * 1000;
+        return readingTimeMilliseconds;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: StringService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: StringService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: StringService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class GraphqlService {
+    apollo = inject(Apollo);
+    stringService = inject(StringService);
+    mutation(operation, type, entity) {
+        let mutation;
+        const capitalizedType = this.stringService.normalizeName(type);
+        switch (operation) {
+            case 'create':
+                entity.uuid = entity.id ? entity.id.split('/').pop() : crypto.randomUUID();
+                delete entity.createdBy;
+                delete entity.updatedBy;
+                delete entity.id;
+                mutation = this.apollo.mutate({
+                    mutation: gql `
+          mutation Create${capitalizedType}($entity: create${capitalizedType}Input!) {
+            create${capitalizedType}(input: $entity) {
+              ${type} {
+                id
+              }
+            }
+          }
+        `,
+                    variables: {
+                        entity
+                    }
+                });
+                break;
+            case 'delete':
+                mutation = this.apollo.mutate({
+                    mutation: gql `
+          mutation Delete${capitalizedType}($id: ID!) {
+            delete${capitalizedType}(input: {id: $id}) {
+              clientMutationId
+            }
+          }
+        `,
+                    variables: {
+                        id: entity.id
+                    }
+                });
+                break;
+            case 'update':
+                delete entity.createdBy;
+                delete entity.updatedBy;
+                mutation = this.apollo.mutate({
+                    mutation: gql `
+          mutation Update${capitalizedType}($entity: update${capitalizedType}Input!) {
+            update${capitalizedType}(input: $entity) {
+              ${type} {
+                id
+              }
+            }
+          }
+        `,
+                    variables: {
+                        entity
+                    }
+                });
+                break;
+        }
+        return lastValueFrom(mutation);
+    }
+    parseQuery(query) {
+        if (query !== null) {
+            const data = {};
+            for (const property in query) {
+                if (query[property]?.edges) {
+                    data[property] = this.parseEdges(query[property].edges);
+                }
+                else if (query[property]?.node) {
+                    data[property] = this.parseQuery(query[property].node);
+                }
+                else if (Array.isArray(query[property])) {
+                    // Si es un arreglo simple no lo parsea
+                    if (typeof query[property][0] === 'object') {
+                        data[property] = query[property].map((node) => {
+                            return this.parseQuery(node);
+                        });
+                    }
+                    else {
+                        data[property] = query[property];
+                    }
+                }
+                else if (typeof query[property] === 'object') {
+                    data[property] = this.parseQuery(query[property]);
+                }
+                else if (property !== '__typename') {
+                    data[property] = query[property];
+                }
+            }
+            return data;
+        }
+        else {
+            return query;
+        }
+    }
+    parseEdges(edges) {
+        return edges.map((entity) => {
+            return this.parseQuery(entity?.node || entity);
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: GraphqlService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: GraphqlService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: GraphqlService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class ObjectService {
+    filterNullProperties(obj) {
+        const mappedObj = {};
+        Object.keys(obj).forEach((key) => {
+            if (obj[key] !== null && obj[key] !== undefined && obj[key] !== 'undefined') {
+                mappedObj[key] = obj[key];
+            }
+        });
+        return mappedObj;
+    }
+    deepMerge(target, source) {
+        source = structuredClone(source);
+        target = structuredClone(target);
+        for (const key of Object.keys(source)) {
+            if (source[key] instanceof Object && key in target) {
+                Object.assign(source[key], this.deepMerge(target[key], source[key]));
+            }
+        }
+        return { ...target, ...source };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: ObjectService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: ObjectService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: ObjectService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class RestService {
+    http = inject(HttpClient);
+    options = inject(UtilsService);
+    delete(resourcePath, id) {
+        const url = `${this.getApiPath(resourcePath)}${resourcePath}/${id}`;
+        return this.http.delete(url);
+    }
+    find(resourcePath, params, options) {
+        const url = `${this.getApiPath(resourcePath)}${resourcePath}`;
+        return this.http.get(url, { ...{ params }, ...options });
+    }
+    get(resourcePath, id, params, options) {
+        let url;
+        if (id) {
+            url = `${this.getApiPath(resourcePath)}${resourcePath}/${id}`;
+        }
+        else {
+            return this.find(`${this.getApiPath(resourcePath)}${resourcePath}`, params, options);
+        }
+        return this.http.get(url, { ...{ params }, ...options });
+    }
+    patch(resourcePath, id, data, options) {
+        const url = `${this.getApiPath(resourcePath)}${resourcePath}${id ? '/' : ''}${id || ''}`;
+        return this.http.patch(url, data, options);
+    }
+    post(resourcePath, data, options) {
+        const url = `${this.getApiPath(resourcePath)}${resourcePath}`;
+        return this.http.post(url, data, options);
+    }
+    put(resourcePath, id, data) {
+        const url = `${this.getApiPath(resourcePath)}${resourcePath}${id ? '/' : ''}${id || ''}`;
+        return this.http.put(url, data);
+    }
+    getApiPath(resourcePath) {
+        return this.isAbsoluteUrl(resourcePath) ? '' : `${this.options.get().restApiPath}/`;
+    }
+    isAbsoluteUrl(resourcePath) {
+        //const expression = /[-a-zA-Z0-9@:%._~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_.~#?&//=]*)?/gi;
+        const expression = /^(https?:\/\/)/i;
+        const regex = new RegExp(expression);
+        return regex.test(resourcePath);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: RestService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: RestService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: RestService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
 
 class StorageService {
+    platformId;
+    //TODO: Replace with Map object it is more efficient
+    memoryStorage;
     constructor(platformId) {
         this.platformId = platformId;
     }
@@ -353,18 +932,18 @@ class StorageService {
             }
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: StorageService, deps: [{ token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: StorageService, providedIn: 'root' }); }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: StorageService, deps: [{ token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: StorageService, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: StorageService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: StorageService, decorators: [{
             type: Injectable,
             args: [{
-                    providedIn: 'root'
+                    providedIn: 'root',
                 }]
-        }], ctorParameters: function () { return [{ type: Object, decorators: [{
+        }], ctorParameters: () => [{ type: Object, decorators: [{
                     type: Inject,
                     args: [PLATFORM_ID]
-                }] }]; } });
+                }] }] });
 
 function lengthValidator(number, digits) {
     let value = true;
@@ -549,13 +1128,9 @@ function identificationValidator(type) {
     };
 }
 
-/*
- * Public API Surface of utils
- */
-
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { ColorService, FilesService, GoogleTagManagerService, StorageService, getIdentificationType, identificationValidator };
+export { ArrayService, ColorService, ConfigDefaults, CsvConfigConsts, CsvService, DateService, FilesService, GoogleTagManagerService, GraphqlService, ObjectService, RestService, StorageService, StringService, apolloOptionsFactory, getIdentificationType, graphqlProvider, identificationValidator };
 //# sourceMappingURL=factor_ec-utils.mjs.map