@factor_ec/utils 5.0.9 → 6.0.0

package/fesm2022/factor_ec-utils.mjs

@@ -1,10 +1,33 @@
 import * as i0 from '@angular/core';
-import { Injectable, PLATFORM_ID, Inject } from '@angular/core';
+import { Injectable, inject, PLATFORM_ID, InjectionToken, signal, computed } from '@angular/core';
 import { isPlatformBrowser } from '@angular/common';
-import * as i1 from '@angular/router';
-import { NavigationEnd } from '@angular/router';
+import { Router, NavigationEnd } from '@angular/router';
+import { HttpClient, HttpErrorResponse, HttpHeaders } from '@angular/common/http';
+import { MatDialog } from '@angular/material/dialog';
+import { BehaviorSubject, switchMap, throwError, catchError, share, finalize, filter, take, lastValueFrom, tap } from 'rxjs';
 
-class ArrayService {
+/**
+ * Utility service for array operations.
+ *
+ * @remarks
+ * Provides helper methods for common array manipulation tasks.
+ */
+class ArrayUtil {
+    /**
+     * Merges multiple arrays into a single array, combining objects with the same property value.
+     *
+     * @param arrays - Array of arrays to merge
+     * @param prop - Property name to use as the key for merging objects
+     * @returns Merged array with combined objects
+     *
+     * @example
+     * ```typescript
+     * const arr1 = [{ id: 1, name: 'John' }];
+     * const arr2 = [{ id: 1, age: 30 }];
+     * const result = arrayUtil.merge([arr1, arr2], 'id');
+     * // Returns: [{ id: 1, name: 'John', age: 30 }]
+     * ```
+     */
     merge(arrays, prop) {
         const merged = {};
         arrays.forEach(arr => {
@@ -14,17 +37,31 @@ class ArrayService {
         });
         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' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: ArrayUtil, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: ArrayUtil, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: ArrayService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: ArrayUtil, decorators: [{
             type: Injectable,
             args: [{
-                    providedIn: 'root'
+                    providedIn: 'root',
                 }]
         }] });
 
-class ColorService {
+/**
+ * Utility service for color operations and hash-based color generation.
+ *
+ * @remarks
+ * Provides methods to generate consistent colors from strings using hash algorithms,
+ * and convert between different color formats (HSL, RGB, HEX).
+ *
+ * @example
+ * ```typescript
+ * const colorUtil = inject(ColorUtil);
+ * const hexColor = colorUtil.hex('username');
+ * // Returns: '#a1b2c3' (consistent color for the same string)
+ * ```
+ */
+class ColorUtil {
     L;
     S;
     hueRanges;
@@ -53,9 +90,13 @@ class ColorService {
         });
     }
     /**
-     * BKDR Hash (modified version)
+     * Generates a hash value from a string using BKDR hash algorithm (modified version).
+     *
+     * @param str - The string to hash
+     * @returns A numeric hash value
      *
-     * @param str string to hash
+     * @remarks
+     * This is a modified BKDR hash algorithm optimized for short strings.
      */
     hash(str) {
         let seed = 131;
@@ -74,10 +115,10 @@ class ColorService {
         return hash;
     }
     /**
-     * Convert RGB Array to HEX
+     * Converts an RGB array to a hexadecimal color string.
      *
-     * @param RGBArray - [R, G, B]
-     * @returns 6 digits hex starting with #
+     * @param RGBArray - Array with [R, G, B] values (0-255)
+     * @returns Hexadecimal color string starting with # (e.g., '#a1b2c3')
      */
     rgb2hex(RGBArray) {
         let hex = '#';
@@ -90,13 +131,14 @@ class ColorService {
         return hex;
     }
     /**
-     * Convert HSL to RGB
+     * Converts HSL color values to RGB array.
+     *
+     * @param H - Hue value in range [0, 360)
+     * @param S - Saturation value in range [0, 1]
+     * @param L - Lightness value in range [0, 1]
+     * @returns Array with [R, G, B] values in range [0, 255]
      *
      * @see {@link http://zh.wikipedia.org/wiki/HSL和HSV色彩空间} for further information.
-     * @param H Hue ∈ [0, 360)
-     * @param S Saturation ∈ [0, 1]
-     * @param L Lightness ∈ [0, 1]
-     * @returns R, G, B ∈ [0, 255]
      */
     hsl2rgb(H, S, L) {
         H /= 360;
@@ -125,11 +167,10 @@ class ColorService {
         });
     }
     /**
-     * Returns the hash in [h, s, l].
-     * Note that H ∈ [0, 360); S ∈ [0, 1]; L ∈ [0, 1];
+     * Generates HSL color values from a string hash.
      *
-     * @param str string to hash
-     * @returns [h, s, l]
+     * @param str - The string to generate color from
+     * @returns Array with [H, S, L] values where H ∈ [0, 360), S ∈ [0, 1], L ∈ [0, 1]
      */
     hsl(str) {
         let H;
@@ -155,86 +196,135 @@ class ColorService {
         return [H, S, L];
     }
     /**
-     * Returns the hash in [r, g, b].
-     * Note that R, G, B ∈ [0, 255]
+     * Generates RGB color values from a string hash.
      *
-     * @param str string to hash
-     * @returns [r, g, b]
+     * @param str - The string to generate color from
+     * @returns Array with [R, G, B] values in range [0, 255]
      */
     rgb(str) {
         let hsl = this.hsl(str);
         return this.hsl2rgb(hsl[0], hsl[1], hsl[2]);
     }
     /**
-     * Returns the hash in hex
+     * Generates a hexadecimal color string from a string hash.
+     *
+     * @param str - The string to generate color from
+     * @returns Hexadecimal color string starting with # (e.g., '#a1b2c3')
      *
-     * @param str string to hash
-     * @returns hex with #
+     * @example
+     * ```typescript
+     * const color = colorUtil.hex('username');
+     * // Returns: '#a1b2c3' (same string always returns same color)
+     * ```
      */
     hex(str) {
         let rgb = this.rgb(str);
         return this.rgb2hex(rgb);
     }
-    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' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: ColorUtil, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: ColorUtil, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: ColorService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: ColorUtil, 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
+/**
+ * Default configuration constants for CSV export operations.
+ */
+const CSV_CONFIG = {
+    /** End of line character for CSV */
+    EOL: '\r\n',
+    /** Byte Order Mark for UTF-8 encoding */
+    BOM: '\ufeff',
+    /** Default field separator character */
+    DEFAULT_FIELD_SEPARATOR: ',',
+    /** Default decimal separator */
+    DEFAULT_DECIMAL_SEPARATOR: '.',
+    /** Default quote character for strings */
+    DEFAULT_QUOTE: '"',
+    /** Default value for showing title */
+    DEFAULT_SHOW_TITLE: false,
+    /** Default title text */
+    DEFAULT_TITLE: 'My Generated Report',
+    /** Default filename (without extension) */
+    DEFAULT_FILENAME: 'generated',
+    /** Default value for showing column labels */
+    DEFAULT_SHOW_LABELS: false,
+    /** Default value for using text file format */
+    DEFAULT_USE_TEXT_FILE: false,
+    /** Default value for including BOM */
+    DEFAULT_USE_BOM: true,
+    /** Default header array (empty) */
+    DEFAULT_HEADER: [],
+    /** Default value for using object keys as headers */
+    DEFAULT_KEYS_AS_HEADERS: false
 };
-class CsvService {
+
+/**
+ * Service for exporting data to CSV format and parsing CSV content.
+ *
+ * @remarks
+ * Provides functionality to generate CSV files from JSON data with customizable options,
+ * and to parse CSV content back into structured data.
+ *
+ * @example
+ * ```typescript
+ * const csvExporter = inject(CsvExporter);
+ * csvExporter.options = { filename: 'export', showLabels: true };
+ * csvExporter.generate([{ name: 'John', age: 30 }]);
+ * ```
+ */
+class CsvExporter {
     _data = [];
     _options;
     _csv = '';
+    configDefaults = {
+        filename: CSV_CONFIG.DEFAULT_FILENAME,
+        fieldSeparator: CSV_CONFIG.DEFAULT_FIELD_SEPARATOR,
+        quoteStrings: CSV_CONFIG.DEFAULT_QUOTE,
+        decimalSeparator: CSV_CONFIG.DEFAULT_DECIMAL_SEPARATOR,
+        showLabels: CSV_CONFIG.DEFAULT_SHOW_LABELS,
+        showTitle: CSV_CONFIG.DEFAULT_SHOW_TITLE,
+        title: CSV_CONFIG.DEFAULT_TITLE,
+        useTextFile: CSV_CONFIG.DEFAULT_USE_TEXT_FILE,
+        useBom: CSV_CONFIG.DEFAULT_USE_BOM,
+        headers: [...CSV_CONFIG.DEFAULT_HEADER],
+        useKeysAsHeaders: CSV_CONFIG.DEFAULT_KEYS_AS_HEADERS
+    };
     get options() {
         return this._options;
     }
     set options(options) {
-        this._options = this.objectAssign({}, ConfigDefaults, options);
+        this._options = this.objectAssign({}, this.configDefaults, options);
     }
     constructor() {
-        this._options = this.objectAssign({}, ConfigDefaults);
+        this._options = this.objectAssign({}, this.configDefaults);
     }
     /**
-     * Generate and Download Csv
+     * Generates a CSV file from JSON data and optionally downloads it.
+     *
+     * @param jsonData - The data to export (array of objects or JSON string)
+     * @param shouldReturnCsv - If true, returns the CSV string instead of downloading
+     * @returns The CSV string if shouldReturnCsv is true, otherwise void
+     *
+     * @example
+     * ```typescript
+     * // Download CSV
+     * csvExporter.generate([{ name: 'John', age: 30 }]);
+     *
+     * // Get CSV string
+     * const csvString = csvExporter.generate([{ name: 'John' }], true);
+     * ```
      */
     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;
+            this._csv += CSV_CONFIG.BOM;
         }
         if (this._options.showTitle) {
             this._csv += this._options.title + '\r\n\n';
@@ -257,8 +347,6 @@ class CsvService {
         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');
@@ -268,7 +356,9 @@ class CsvService {
         document.body.removeChild(link);
     }
     /**
-     * Create Headers
+     * Creates CSV headers row based on configuration.
+     *
+     * @private
      */
     _getHeaders() {
         if (!this._options.showLabels && !this._options.useKeysAsHeaders) {
@@ -284,11 +374,13 @@ class CsvService {
                 row += headers[keyPos] + this._options.fieldSeparator;
             }
             row = row.slice(0, -1);
-            this._csv += row + CsvConfigConsts.EOL;
+            this._csv += row + CSV_CONFIG.EOL;
         }
     }
     /**
-     * Create Body
+     * Creates CSV body rows from the data.
+     *
+     * @private
      */
     _getBody() {
         const keys = Object.keys(this._data[0]);
@@ -300,12 +392,15 @@ class CsvService {
                     this._formatData(this._data[i][key]) + this._options.fieldSeparator;
             }
             row = row.slice(0, -1);
-            this._csv += row + CsvConfigConsts.EOL;
+            this._csv += row + CSV_CONFIG.EOL;
         }
     }
     /**
-     * Format Data
-     * @param {any} data
+     * Formats data for CSV output according to configuration.
+     *
+     * @param data - The data value to format
+     * @returns The formatted data as a string
+     * @private
      */
     _formatData(data) {
         if (this._options.decimalSeparator === 'locale' && this._isFloat(data)) {
@@ -330,27 +425,32 @@ class CsvService {
         return data;
     }
     /**
-     * Check if is Float
-     * @param {any} input
+     * Checks if a value is a floating point number.
+     *
+     * @param input - The value to check
+     * @returns True if the value is a float, false otherwise
+     * @private
      */
     _isFloat(input) {
         return +input === input && (!isFinite(input) || Boolean(input % 1));
     }
     /**
-     * Parse the collection given to it
+     * Parses JSON data into an array format.
      *
+     * @param jsonData - The JSON data to parse (object, array, or JSON string)
+     * @returns Parsed array of data
      * @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
+     * Converts a value to an object, throwing an error for null or undefined.
+     *
+     * @param val - The value to convert
+     * @returns The value as an object
+     * @throws {TypeError} If val is null or undefined
      */
     toObject(val) {
         if (val === null || val === undefined) {
@@ -359,9 +459,11 @@ class CsvService {
         return Object(val);
     }
     /**
-     * Assign data  to new Object
-     * @param {any}   target
-     * @param {any[]} ...source
+     * Assigns properties from source objects to a target object (similar to Object.assign).
+     *
+     * @param target - The target object to assign properties to
+     * @param source - One or more source objects to copy properties from
+     * @returns The target object with assigned properties
      */
     objectAssign(target, ...source) {
         let from;
@@ -387,6 +489,18 @@ class CsvService {
         }
         return to;
     }
+    /**
+     * Parses CSV content into a structured format with headers and content rows.
+     *
+     * @param csvContent - The CSV string to parse
+     * @returns An object containing the header array and content rows array
+     *
+     * @example
+     * ```typescript
+     * const parsed = csvExporter.read('name,age\nJohn,30\nJane,25');
+     * // Returns: { header: ['name', 'age'], content: [['John', '30'], ['Jane', '25']] }
+     * ```
+     */
     read(csvContent) {
         const lines = csvContent.split('\n');
         let header;
@@ -396,7 +510,7 @@ class CsvService {
                 return this.parseLine(line.trim());
             });
             header = csv[0];
-            // Si encuentra una linea en blanco ya no sigue leyendo las siguientes líneas
+            // If a blank line is found, stop reading subsequent lines
             let breakIndex;
             csv.some((row, index) => {
                 const isBlankLine = row.every((column) => column.trim() === '');
@@ -417,236 +531,189 @@ class CsvService {
             content
         };
     }
+    /**
+     * Parses a single CSV line into an array of values.
+     *
+     * @param csvLine - A single line of CSV content
+     * @returns Array of parsed values from the line
+     *
+     * @remarks
+     * Handles quoted values and different quote styles (single and double quotes).
+     */
     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
+            values.push(match[1] || match[2] || match[3]); // Extract the correct value
         }
         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' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: CsvExporter, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: CsvExporter, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: CsvService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: CsvExporter, decorators: [{
             type: Injectable,
             args: [{
-                    providedIn: 'root'
+                    providedIn: 'root',
                 }]
         }], ctorParameters: () => [] });
 
-class DateService {
+/**
+ * Utility service for date operations.
+ *
+ * @remarks
+ * Provides helper methods for date parsing and manipulation.
+ */
+class DateUtil {
+    /**
+     * Parses a date string in ISO format (YYYY-MM-DD or YYYY-MM-DDTHH:mm:ss) and returns a Date object.
+     *
+     * @param date - The date string to parse (ISO format)
+     * @returns A Date object representing the parsed date
+     *
+     * @example
+     * ```typescript
+     * const date = dateUtil.getDate('2025-01-15');
+     * // Returns: Date object for January 15, 2025
+     * ```
+     */
     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' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: DateUtil, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: DateUtil, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: DateService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }] });
-
-class FilesService {
-    callback;
-    fileInput;
-    pickerClosed = false;
-    constructor() {
-        this.fileInput = document.createElement('input');
-        this.fileInput.type = 'file';
-        this.fileInput.addEventListener('change', (event) => {
-            this.pickerClosed = true;
-            this.loadValue(event.currentTarget.files);
-        });
-    }
-    loadValue(files) {
-        if (files && files.length > 0) {
-            let data = [];
-            for (let i = 0; i < files.length; i++) {
-                const file = files.item(i);
-                const reader = new FileReader();
-                reader.readAsDataURL(file);
-                reader.onload = () => {
-                    data.push(Object.assign(file, {
-                        data: reader.result,
-                    }));
-                    if (data.length == files.length) {
-                        this.callback(data.length > 0 ? data : null);
-                        this.fileInput.value = '';
-                    }
-                    else {
-                        this.callback(null);
-                    }
-                };
-            }
-        }
-    }
-    open(callback, options) {
-        this.pickerClosed = false;
-        // Detectar cuando el usuario vuelve a la ventana después de abrir el picker
-        const onFocus = () => {
-            setTimeout(() => {
-                if (!this.pickerClosed) {
-                    console.log('El usuario cerró el file picker sin seleccionar archivos.');
-                    this.loadValue(null);
-                }
-                window.removeEventListener('focus', onFocus);
-            }, 500); // Esperamos un poco para asegurarnos de que onchange haya tenido oportunidad de ejecutarse
-        };
-        window.addEventListener('focus', onFocus);
-        this.fileInput.accept = options?.accept ? options.accept : '';
-        this.fileInput.multiple = options?.multiple || false;
-        this.fileInput.click();
-        if (callback) {
-            this.callback = callback;
-        }
-    }
-    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: "19.0.6", ngImport: i0, type: FilesService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: DateUtil, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: () => [] });
+        }] });
 
-class FilePickerService {
-    pickerClosed = false;
+/**
+ * Service for opening file picker dialogs and reading file contents.
+ *
+ * @remarks
+ * Provides a programmatic way to open file selection dialogs and read file data as base64.
+ */
+class FilePicker {
+    /**
+     * Opens a file picker dialog and returns the selected files with their data as base64.
+     *
+     * @param options - Optional configuration for the file picker
+     * @param options.accept - File types to accept (e.g., 'image/*', '.pdf')
+     * @param options.multiple - Whether to allow multiple file selection
+     * @returns Promise that resolves to an array of files with data property, or null if cancelled
+     *
+     * @example
+     * ```typescript
+     * const files = await filePicker.open({ accept: 'image/*', multiple: true });
+     * if (files) {
+     *   files.forEach(file => console.log(file.data)); // base64 data
+     * }
+     * ```
+     */
     async open(options) {
         return new Promise((resolve, reject) => {
             const fileInput = document.createElement('input');
             fileInput.type = 'file';
-            fileInput.addEventListener('change', (event) => {
-                this.pickerClosed = true;
-                const files = event.currentTarget.files;
-                if (files && files.length > 0) {
-                    let data = [];
-                    for (let i = 0; i < files.length; i++) {
-                        const file = files.item(i);
-                        const reader = new FileReader();
-                        reader.readAsDataURL(file);
-                        reader.onload = () => {
-                            data.push(Object.assign(file, {
-                                data: reader.result
-                            }));
-                            if (data.length == files.length) {
-                                fileInput.value = '';
-                                resolve(data.length > 0 ? data : null);
-                            }
-                            else {
-                                resolve(null);
-                            }
-                        };
-                    }
+            fileInput.style.display = 'none';
+            if (options?.accept) {
+                fileInput.accept = options.accept;
+            }
+            fileInput.multiple = options?.multiple ?? false;
+            document.body.appendChild(fileInput);
+            let changeHandled = false;
+            const cleanUp = () => {
+                window.removeEventListener('focus', onFocus);
+                document.removeEventListener('visibilitychange', onVisibilityChange);
+                if (fileInput.parentNode) {
+                    document.body.removeChild(fileInput);
                 }
-            });
-            this.pickerClosed = false;
-            // Detectar cuando el usuario vuelve a la ventana después de abrir el picker
+            };
             const onFocus = () => {
                 setTimeout(() => {
-                    if (!this.pickerClosed) {
-                        reject(null);
+                    if (!changeHandled) {
+                        cleanUp();
+                        resolve(null);
                     }
-                    window.removeEventListener('focus', onFocus);
-                }, 500); // Esperamos un poco para asegurarnos de que onchange haya tenido oportunidad de ejecutarse
+                }, 1500);
             };
+            const onVisibilityChange = () => {
+                if (document.visibilityState === 'visible') {
+                    setTimeout(() => {
+                        if (!changeHandled) {
+                            cleanUp();
+                            resolve(null);
+                        }
+                    }, 1500);
+                }
+            };
+            fileInput.addEventListener('change', async (event) => {
+                changeHandled = true;
+                const files = Array.from(event.target.files || []);
+                if (!files.length) {
+                    cleanUp();
+                    resolve(null);
+                    return;
+                }
+                try {
+                    const result = await Promise.all(files.map(file => {
+                        return new Promise((res, rej) => {
+                            const reader = new FileReader();
+                            reader.onload = () => {
+                                res(Object.assign(file, { data: reader.result }));
+                            };
+                            reader.onerror = (err) => {
+                                rej(reader.error);
+                            };
+                            reader.readAsDataURL(file);
+                        });
+                    }));
+                    cleanUp();
+                    resolve(result);
+                }
+                catch (error) {
+                    cleanUp();
+                    reject(error);
+                }
+            });
             window.addEventListener('focus', onFocus);
-            fileInput.accept = options?.accept ? options.accept : '';
-            fileInput.multiple = options?.multiple || false;
+            document.addEventListener('visibilitychange', onVisibilityChange);
             fileInput.click();
         });
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: FilePickerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: FilePickerService, providedIn: 'root' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: FilePicker, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: FilePicker, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: FilePickerService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: FilePicker, decorators: [{
             type: Injectable,
             args: [{
-                    providedIn: 'root'
+                    providedIn: 'root',
                 }]
         }] });
 
-class GoogleTagManagerService {
-    platformId;
-    router;
-    trackingId;
-    constructor(platformId, router) {
-        this.platformId = platformId;
-        this.router = router;
-    }
-    appendTrackingCode(trackingId, options) {
-        try {
-            if (isPlatformBrowser(this.platformId) && trackingId) {
-                this.trackingId = trackingId;
-                const s1 = document.createElement('script');
-                s1.innerHTML = `
-          (function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
-          new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
-          j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'',p='${options?.environment?.preview
-                    ? '&gtm_auth=' + options?.environment.auth + '&gtm_preview=' + options?.environment.preview
-                    : ''}';j.async=true;j.src=
-          'https://www.googletagmanager.com/gtm.js?id='+i+dl+p;f.parentNode.insertBefore(j,f);
-          })(window,document,'script','dataLayer','${trackingId}');
-        `;
-                document.head.appendChild(s1);
-                const s2 = document.createElement('noscript');
-                const s3 = document.createElement('iframe');
-                s3.width = '0';
-                s3.height = '0';
-                s3.style.display = 'none';
-                s3.style.visibility = 'hidden';
-                s3.src = `//www.googletagmanager.com/ns.html?id=${trackingId}`;
-                s2.appendChild(s3);
-                document.body.prepend(s2);
-                this.initSubscribers();
-            }
-        }
-        catch (ex) {
-            console.error('Error appending google tag manager');
-            console.error(ex);
-        }
-    }
-    addVariable(variable) {
-        if (isPlatformBrowser(this.platformId) && this.trackingId) {
-            window.dataLayer = window.dataLayer || [];
-            window.dataLayer.push(variable);
-        }
-    }
-    initSubscribers() {
-        this.router.events.subscribe(event => {
-            try {
-                if (event instanceof NavigationEnd && this.trackingId) {
-                    this.addVariable({
-                        event: 'router.NavigationEnd',
-                        pageTitle: document.title,
-                        pagePath: event.urlAfterRedirects
-                    });
-                }
-            }
-            catch (e) {
-                console.error(e);
-            }
-        });
-    }
-    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: "19.0.6", ngImport: i0, type: GoogleTagManagerService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [{ type: Object, decorators: [{
-                    type: Inject,
-                    args: [PLATFORM_ID]
-                }] }, { type: i1.Router }] });
-
-class ObjectService {
+/**
+ * Utility service for object operations.
+ *
+ * @remarks
+ * Provides helper methods for object manipulation and transformation.
+ */
+class ObjectUtil {
+    /**
+     * Filters out null, undefined, and 'undefined' string properties from an object.
+     *
+     * @param obj - The object to filter
+     * @returns A new object with null/undefined properties removed
+     *
+     * @example
+     * ```typescript
+     * const filtered = objectUtil.filterNullProperties({ a: 1, b: null, c: undefined });
+     * // Returns: { a: 1 }
+     * ```
+     */
     filterNullProperties(obj) {
         const mappedObj = {};
         Object.keys(obj).forEach((key) => {
@@ -656,6 +723,22 @@ class ObjectService {
         });
         return mappedObj;
     }
+    /**
+     * Performs a deep merge of two objects, combining nested properties.
+     *
+     * @param target - The target object to merge into
+     * @param source - The source object to merge from
+     * @returns A new object with deeply merged properties
+     *
+     * @remarks
+     * Uses structuredClone to avoid mutating the original objects.
+     *
+     * @example
+     * ```typescript
+     * const merged = objectUtil.deepMerge({ a: { b: 1 } }, { a: { c: 2 } });
+     * // Returns: { a: { b: 1, c: 2 } }
+     * ```
+     */
     deepMerge(target, source) {
         source = structuredClone(source);
         target = structuredClone(target);
@@ -666,23 +749,34 @@ class ObjectService {
         }
         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' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: ObjectUtil, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: ObjectUtil, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: ObjectService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: ObjectUtil, decorators: [{
             type: Injectable,
             args: [{
-                    providedIn: 'root'
+                    providedIn: 'root',
                 }]
         }] });
 
-class StorageService {
-    platformId;
-    //TODO: Replace with Map object it is more efficient
-    memoryStorage;
-    constructor(platformId) {
-        this.platformId = platformId;
-    }
+/**
+ * Service for managing browser storage (localStorage, sessionStorage, and memory storage).
+ *
+ * @remarks
+ * Provides a unified interface for storing and retrieving data from different storage types.
+ * Automatically handles JSON serialization/deserialization and platform detection.
+ *
+ * @example
+ * ```typescript
+ * const storage = inject(Storage);
+ * storage.set('key', { data: 'value' }, 'local');
+ * const value = storage.get('key', 'local');
+ * ```
+ */
+class Storage {
+    // TODO: Replace with Map object it is more efficient
+    memoryStorage = {};
+    platformId = inject(PLATFORM_ID);
     getValue(key, storage) {
         let value;
         if (!storage || typeof storage == 'string') {
@@ -703,6 +797,12 @@ class StorageService {
         }
         return value;
     }
+    /**
+     * Deletes a value from the specified storage.
+     *
+     * @param key - The key of the value to delete
+     * @param storage - The storage type ('local', 'session', or 'memory'). Defaults to 'session'
+     */
     delete(key, storage) {
         if (isPlatformBrowser(this.platformId)) {
             if (!storage || typeof storage == 'string') {
@@ -723,6 +823,16 @@ class StorageService {
             }
         }
     }
+    /**
+     * Retrieves a value from the specified storage.
+     *
+     * @param key - The key of the value to retrieve
+     * @param storage - The storage type ('local', 'session', or 'memory'). Defaults to 'session'
+     * @returns The parsed value (if JSON) or the raw value, or undefined if not found
+     *
+     * @remarks
+     * Automatically attempts to parse JSON values. If parsing fails, returns the raw string.
+     */
     get(key, storage) {
         let parsedValue;
         if (isPlatformBrowser(this.platformId)) {
@@ -735,6 +845,16 @@ class StorageService {
         }
         return parsedValue;
     }
+    /**
+     * Stores a value in the specified storage.
+     *
+     * @param key - The key to store the value under
+     * @param value - The value to store (will be JSON stringified)
+     * @param storage - The storage type ('local', 'session', or 'memory'). Defaults to 'session'
+     *
+     * @remarks
+     * Values are automatically JSON stringified before storage.
+     */
     set(key, value, storage) {
         if (isPlatformBrowser(this.platformId)) {
             const valueString = JSON.stringify(value);
@@ -753,20 +873,36 @@ class StorageService {
             }
         }
     }
-    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' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: Storage, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: Storage, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: StorageService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: Storage, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: () => [{ type: Object, decorators: [{
-                    type: Inject,
-                    args: [PLATFORM_ID]
-                }] }] });
+        }] });
 
-class StringService {
+/**
+ * Utility service for string operations.
+ *
+ * @remarks
+ * Provides helper methods for common string manipulation and formatting tasks.
+ */
+class StringUtil {
+    /**
+     * Decodes HTML entities in a string.
+     *
+     * @param text - The string containing HTML entities to decode
+     * @returns The decoded string
+     *
+     * @example
+     * ```typescript
+     * const encoded = '&lt;div&gt;Hello&lt;/div&gt;';
+     * const decoded = stringUtil.decodeHTML(encoded);
+     * // Returns: '<div>Hello</div>'
+     * ```
+     */
     decodeHTML(text) {
         const span = document.createElement('span');
         return text.replace(/&[#A-Za-z0-9]+;/gi, (entity) => {
@@ -775,9 +911,16 @@ class StringService {
         });
     }
     /**
-     * Normaliza un texto para evitar el Case y los acentos
-     * @param text texto a normalizar
-     * @returns texto normalizado
+     * Normalizes a text by converting to lowercase and removing accents.
+     *
+     * @param text - The text to normalize
+     * @returns The normalized text without accents and in lowercase
+     *
+     * @example
+     * ```typescript
+     * const normalized = stringUtil.normalize('Café');
+     * // Returns: 'cafe'
+     * ```
      */
     normalize(text) {
         if (!text)
@@ -787,37 +930,179 @@ class StringService {
             .normalize("NFD")
             .replace(/[\u0300-\u036f]/g, "");
     }
+    /**
+     * Normalizes a name by trimming whitespace and capitalizing the first letter.
+     *
+     * @param text - The name text to normalize
+     * @returns The normalized name with first letter capitalized
+     *
+     * @example
+     * ```typescript
+     * const normalized = stringUtil.normalizeName('  john doe  ');
+     * // Returns: 'John doe'
+     * ```
+     */
     normalizeName(text) {
         text = text.trim();
         text = text.charAt(0).toUpperCase() + text.slice(1);
         return text;
     }
     /**
-     * Te da el tiempo en milisegundos que toma leer un texto dado
-     * @param text texto a leer
-     * @return number Tiempo en milisegundos
+     * Calculates the estimated reading time in milliseconds for a given text.
+     *
+     * @param text - The text to calculate reading time for
+     * @returns The estimated reading time in milliseconds
+     *
+     * @remarks
+     * Uses a reading speed of 1200 characters per minute.
+     *
+     * @example
+     * ```typescript
+     * const readingTime = stringUtil.calculateReadingTime('Long text here...');
+     * // Returns: estimated milliseconds
+     * ```
      */
     calculateReadingTime(text) {
-        // Caracteres por minuto
+        // Characters per minute
         const cpm = 1200;
-        // Calcular el número de caracteres en el texto
+        // Calculate the number of characters in the text
         const numCharacters = text.length;
-        // Calcular el tiempo de lectura en minutos
+        // Calculate reading time in minutes
         const readingTimeMinutes = numCharacters / cpm;
-        // Convertir el tiempo de lectura de minutos a milisegundos
+        // Convert reading time from minutes to milliseconds
         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' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: StringUtil, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: StringUtil, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.6", ngImport: i0, type: StringService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: StringUtil, decorators: [{
             type: Injectable,
             args: [{
-                    providedIn: 'root'
+                    providedIn: 'root',
+                }]
+        }] });
+
+/**
+ * Service for integrating Google Tag Manager (GTM) tracking.
+ *
+ * @remarks
+ * Handles GTM script injection, variable tracking, and automatic route change tracking.
+ *
+ * @example
+ * ```typescript
+ * const gtm = inject(GoogleTagManager);
+ * gtm.appendTrackingCode('GTM-XXXXXXX');
+ * gtm.addVariable({ event: 'customEvent', data: 'value' });
+ * ```
+ */
+class GoogleTagManager {
+    trackingId;
+    platformId = inject(PLATFORM_ID);
+    router = inject(Router);
+    /**
+     * Appends Google Tag Manager tracking code to the page.
+     *
+     * @param trackingId - The GTM container ID (e.g., 'GTM-XXXXXXX')
+     * @param options - Optional configuration for GTM environment
+     * @param options.environment - Environment configuration for preview mode
+     * @param options.environment.auth - Authentication token for preview
+     * @param options.environment.preview - Preview container ID
+     *
+     * @remarks
+     * Automatically subscribes to router navigation events for page view tracking.
+     */
+    appendTrackingCode(trackingId, options) {
+        try {
+            if (isPlatformBrowser(this.platformId) && trackingId) {
+                this.trackingId = trackingId;
+                const s1 = document.createElement('script');
+                s1.innerHTML = `
+          (function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
+          new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
+          j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'',p='${options?.environment?.preview
+                    ? '&gtm_auth=' + options?.environment.auth + '&gtm_preview=' + options?.environment.preview
+                    : ''}';j.async=true;j.src=
+          'https://www.googletagmanager.com/gtm.js?id='+i+dl+p;f.parentNode.insertBefore(j,f);
+          })(window,document,'script','dataLayer','${trackingId}');
+        `;
+                document.head.appendChild(s1);
+                const s2 = document.createElement('noscript');
+                const s3 = document.createElement('iframe');
+                s3.width = '0';
+                s3.height = '0';
+                s3.style.display = 'none';
+                s3.style.visibility = 'hidden';
+                s3.src = `//www.googletagmanager.com/ns.html?id=${trackingId}`;
+                s2.appendChild(s3);
+                document.body.prepend(s2);
+                this.initSubscribers();
+            }
+        }
+        catch (ex) {
+            console.error('Error appending google tag manager');
+            console.error(ex);
+        }
+    }
+    /**
+     * Pushes a variable or event to the GTM dataLayer.
+     *
+     * @param variable - The variable or event object to push to dataLayer
+     *
+     * @example
+     * ```typescript
+     * gtm.addVariable({ event: 'purchase', value: 100 });
+     * ```
+     */
+    addVariable(variable) {
+        if (isPlatformBrowser(this.platformId) && this.trackingId) {
+            window.dataLayer = window.dataLayer || [];
+            window.dataLayer.push(variable);
+        }
+    }
+    /**
+     * Initializes router event subscribers for automatic page view tracking.
+     *
+     * @private
+     */
+    initSubscribers() {
+        this.router.events.subscribe(event => {
+            try {
+                if (event instanceof NavigationEnd && this.trackingId) {
+                    this.addVariable({
+                        event: 'router.NavigationEnd',
+                        pageTitle: document.title,
+                        pagePath: event.urlAfterRedirects
+                    });
+                }
+            }
+            catch (e) {
+                console.error(e);
+            }
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: GoogleTagManager, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: GoogleTagManager, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: GoogleTagManager, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
                 }]
         }] });
 
+/**
+ * Constants for CRUD operation types.
+ */
+const OPERATION_TYPE = {
+    /** Create operation */
+    CREATE: 'create',
+    /** Update operation */
+    UPDATE: 'update',
+    /** Delete operation */
+    DELETE: 'delete'
+};
+
 function lengthValidator(number, digits) {
     let value = true;
     if (number.trim() === '') { // No puede estar vacio
@@ -938,6 +1223,18 @@ function storeCodeValidator(number) {
     }
     return value;
 }
+/**
+ * Determines the type of Ecuadorian identification number.
+ *
+ * @param number - The identification number to analyze
+ * @returns The identification type ('cedula', 'ruc_natural', 'ruc_privada', 'ruc_publica') or null if invalid
+ *
+ * @example
+ * ```typescript
+ * const type = getIdentificationType('1234567890');
+ * // Returns: 'cedula' or null
+ * ```
+ */
 function getIdentificationType(number) {
     let type = null;
     if (lengthValidator(number, 10) &&
@@ -972,6 +1269,23 @@ function getIdentificationType(number) {
     return type;
 }
 
+/**
+ * Creates a validator function for Ecuadorian identification numbers (cédula or RUC).
+ *
+ * @param type - The type of identification to validate
+ *   - 'cedula': Validates cédula (10 digits)
+ *   - 'ruc_natural': Validates RUC for natural persons (13 digits)
+ *   - 'ruc_privada': Validates RUC for private companies (13 digits)
+ *   - 'ruc_publica': Validates RUC for public companies (13 digits)
+ *   - 'ruc': Validates any type of RUC
+ *   - 'id': Validates any valid identification type
+ * @returns A validator function that returns an error object if validation fails
+ *
+ * @example
+ * ```typescript
+ * const control = new FormControl('', [identificationValidator('cedula')]);
+ * ```
+ */
 function identificationValidator(type) {
     return (control) => {
         const number = String(control.value);
@@ -1001,9 +1315,440 @@ function identificationValidator(type) {
     };
 }
 
+class AuthProvider {
+}
+
+/**
+ * Injection token for auth configuration.
+ * Provide this in app.config with values from environment.
+ *
+ * @example
+ * ```typescript
+ * import { AUTH_CONFIG } from 'auth-core';
+ * import { environment } from '@/environments/environment';
+ *
+ * providers: [
+ *   { provide: AUTH_CONFIG, useValue: environment }
+ * ]
+ * ```
+ */
+const AUTH_CONFIG = new InjectionToken('AUTH_CONFIG');
+
+/**
+ * Concrete authentication provider responsible for handling session lifecycle,
+ * secure token refresh, and profile management concerns across the app.
+ *
+ * @remarks
+ * The service extends {@link AuthProvider} to leverage core session helpers while
+ * adding stateful logic for dialogs, social login, and settings synchronization.
+ */
+class AuthService extends AuthProvider {
+    // Dependency injection
+    config = inject(AUTH_CONFIG);
+    dialog = inject(MatDialog);
+    httpClient = inject(HttpClient);
+    _user = signal(null, ...(ngDevMode ? [{ debugName: "_user" }] : /* istanbul ignore next */ []));
+    /** Session token key */
+    TOKEN_KEY = `${this.config.sessionPrefix}_sess`;
+    user = computed(() => this._user(), ...(ngDevMode ? [{ debugName: "user" }] : /* istanbul ignore next */ []));
+    constructor() {
+        super();
+        if (this.isLoggedIn()) {
+            this._user.set(this.extractUserFromToken(this.getToken()?.token ?? ''));
+        }
+    }
+    /**
+     * Flag indicating whether the access token is being refreshed
+     */
+    refreshTokenInProgress = false;
+    /**
+     * Manages the access token refresh flow
+     */
+    refreshTokenSubject = new BehaviorSubject(null);
+    /**
+     * Sends the authentication token to the server
+     * @param request HTTP request
+     * @returns
+     */
+    addAuthenticationToken(request) {
+        const token = this.getToken();
+        // If the access token is null, the user is not logged in; return the original request
+        if (!token ||
+            request.url.includes(this.config.auth.signinUrl) ||
+            (this.config.auth.refreshTokenUrl && request.url.includes(this.config.auth.refreshTokenUrl))) {
+            return request;
+        }
+        // Clone the request, because the original request is immutable
+        return request.clone({
+            setHeaders: {
+                Authorization: `Bearer ${token.token}`
+            }
+        });
+    }
+    async connect(client) {
+        const isChrome = navigator.userAgentData?.brands?.some((b) => b.brand === 'Google Chrome') ?? false;
+        if (this.config.fedcm &&
+            isChrome &&
+            'credentials' in navigator &&
+            navigator.credentials &&
+            'get' in navigator.credentials) {
+            try {
+                const fedcm = this.config.fedcm[client];
+                if (!fedcm) {
+                    throw new Error('No auth client exists');
+                }
+                const credential = await navigator.credentials.get({
+                    identity: {
+                        mode: 'active',
+                        providers: [
+                            {
+                                configURL: fedcm.configURL,
+                                clientId: fedcm.clientId,
+                                fields: ['name', 'email', 'picture'],
+                                params: {
+                                    fetch_basic_profile: true,
+                                    response_type: 'permission id_token',
+                                    scope: 'email profile openid',
+                                    include_granted_scopes: true,
+                                    nonce: 'notprovided'
+                                }
+                            }
+                        ]
+                    },
+                    mediation: 'required'
+                });
+                if (!credential) {
+                    throw new Error('No credential obtained');
+                }
+                const fedcmCredential = credential;
+                // Send the ID token to the backend
+                const response = await fetch(fedcm.tokenUrl, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        id_token: JSON.parse(fedcmCredential.token).id_token
+                    })
+                });
+                const data = await response.json();
+                this.setToken(data.token);
+                this._user.set(data.user);
+                location.href = this.config.appPath;
+            }
+            catch (e) {
+                console.error('FedCM error: ', e);
+                return false;
+            }
+        }
+        else {
+            const url = this.config.auth.clients[client];
+            if (url) {
+                location.href = url;
+            }
+        }
+        return true;
+    }
+    /**
+     * Extracts user claims from a JWT token payload.
+     * Maps common JWT claims (sub, email, given_name, family_name, etc.) to the User model.
+     * @param jwtToken The JWT token string
+     * @returns User object or null if parsing fails
+     */
+    extractUserFromToken(jwtToken) {
+        if (!jwtToken)
+            return null;
+        try {
+            const jwtParts = jwtToken.split('.');
+            if (jwtParts.length !== 3)
+                return null;
+            const payload = JSON.parse(window.atob(jwtParts[1]));
+            const roles = Array.isArray(payload['roles'])
+                ? payload['roles']
+                : typeof payload['role'] === 'string'
+                    ? [payload['role']]
+                    : [];
+            return {
+                username: (payload['sub'] ??
+                    payload['preferred_username'] ??
+                    payload['username'] ??
+                    ''),
+                roles
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Extracts the expiration timestamp from a JWT token
+     * @param jwtToken The JWT token string
+     * @returns The expiration timestamp in seconds (JWT exp format) or undefined if not found/invalid
+     */
+    extractExpirationFromToken(jwtToken) {
+        if (!jwtToken) {
+            return undefined;
+        }
+        try {
+            const jwtParts = jwtToken.split('.');
+            if (jwtParts.length === 3) {
+                const payload = JSON.parse(window.atob(jwtParts[1]));
+                if (payload.exp) {
+                    // Store timestamp in seconds (JWT exp format)
+                    return payload.exp;
+                }
+            }
+        }
+        catch {
+            // If JWT parsing fails, return undefined
+        }
+        return undefined;
+    }
+    /**
+     * Handles the flow of refreshing the access token or redirecting to sign-in
+     * @param err HTTP error
+     * @param request HTTP request sent
+     * @param next HTTP handler
+     */
+    handle401Error(err, request, next) {
+        const token = this.getToken();
+        if (token && token.refresh_token && this.config.auth.refreshTokenUrl) {
+            if (!this.refreshTokenInProgress) {
+                this.refreshTokenInProgress = true;
+                this.refreshTokenSubject.next(null);
+                return this.refreshToken().pipe(switchMap((newToken) => {
+                    if (newToken) {
+                        this.refreshTokenSubject.next(newToken);
+                        return next(this.addAuthenticationToken(request));
+                    }
+                    // If we don't get a new token, logout.
+                    this.logout();
+                    return throwError(() => new HttpErrorResponse({
+                        error: {},
+                        headers: new HttpHeaders(),
+                        status: 401,
+                        statusText: '',
+                        url: undefined
+                    }));
+                }), catchError((error) => {
+                    // It can't replace the access token; set error status 401 to continue flow
+                    return throwError(() => new HttpErrorResponse({
+                        error: error.error,
+                        headers: error.headers,
+                        status: 401,
+                        statusText: error.statusText,
+                        url: error.url || undefined
+                    }));
+                }), share(), finalize(() => {
+                    this.refreshTokenInProgress = false;
+                }));
+            }
+            else {
+                return this.refreshTokenSubject.pipe(filter((token) => token != null), take(1), switchMap(() => {
+                    return next(this.addAuthenticationToken(request));
+                }));
+            }
+        }
+        else {
+            // No refresh token flow
+            if (this.isLoggedIn()) {
+                this.logout();
+            }
+            return throwError(() => err);
+        }
+    }
+    /**
+     * Sends sign-in to the server and obtains the authentication token
+     * @param data Authentication data
+     * @returns
+     */
+    async login(data) {
+        const token = await lastValueFrom(this.httpClient.post(this.config.auth.signinUrl, data));
+        this.setToken(token);
+        return true;
+    }
+    /**
+     * Logs out the user
+     */
+    async logout() {
+        this.dialog.closeAll();
+        this.clearToken();
+        this.clearUser();
+        location.href =
+            window.innerWidth < 1000 ? `${this.config.appPath}/auth` : `${this.config.appPath}/signin`;
+        return true;
+    }
+    async signup(data, options) {
+        return lastValueFrom(this.httpClient.post(this.config.auth.signupUrl, data, options));
+    }
+    /**
+     * If a refresh token is implemented, send it to obtain a new access token
+     * @returns Access token
+     */
+    refreshToken() {
+        const token = this.getToken();
+        return this.httpClient
+            .post(this.config.auth.refreshTokenUrl, { refresh_token: token?.refresh_token })
+            .pipe(tap((token) => {
+            this.setToken(token);
+        }), catchError((error) => {
+            this.logout();
+            return throwError(() => new Error(error));
+        }));
+    }
+    /**
+     * Reads the session token from the Secure cookie (client-side storage).
+     * @internal
+     */
+    getToken() {
+        if (typeof document === 'undefined' || !document.cookie)
+            return null;
+        const match = document.cookie.match(new RegExp('(?:^|; )' + this.TOKEN_KEY.replace(/([.*+?^${}()|[\]\\])/g, '\\$1') + '=([^;]*)'));
+        const raw = match ? decodeURIComponent(match[1]) : null;
+        if (!raw)
+            return null;
+        try {
+            const data = JSON.parse(raw);
+            return data?.token ? data : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Sets the authentication token in session state and in a Secure cookie (client-side).
+     * Cookie: Path=/; SameSite=Strict; Secure on HTTPS; Max-Age from expiresAt or 1 day.
+     *
+     * @param token - The authentication token object to store
+     */
+    setToken(token) {
+        const copy = token ? { ...token } : null;
+        if (copy && typeof document !== 'undefined') {
+            const expiresAt = this.extractExpirationFromToken(copy.token);
+            const value = encodeURIComponent(JSON.stringify(copy));
+            const maxAge = expiresAt
+                ? Math.max(0, expiresAt - Math.round(Date.now() / 1000))
+                : 24 * 60 * 60;
+            let cookie = `${this.TOKEN_KEY}=${value}; Path=/; Max-Age=${maxAge}; SameSite=Strict`;
+            if (typeof location !== 'undefined' && location.protocol === 'https:')
+                cookie += '; Secure';
+            document.cookie = cookie;
+            this._user.set(this.extractUserFromToken(copy.token) ?? null);
+        }
+    }
+    /**
+     * Clears the authentication token from session state and removes the cookie.
+     */
+    clearToken() {
+        if (typeof document !== 'undefined') {
+            document.cookie = `${this.TOKEN_KEY}=; Path=/; Max-Age=0`;
+        }
+        this.clearUser();
+    }
+    /**
+     * Clears the current user from session state
+     */
+    clearUser() {
+        this._user.set(null);
+    }
+    /**
+     * Computed signal indicating whether a user is currently logged in
+     * Based on the presence and validity of the authentication token
+     *
+     * For JWT tokens, validates expiration. For other token types, only checks existence.
+     *
+     * @returns true if a valid token exists, false otherwise
+     */
+    isLoggedIn = computed(() => {
+        // Depend on _user so computed re-evaluates when setToken/clearToken updates state
+        this._user();
+        const token = this.getToken();
+        if (!token)
+            return false;
+        const expiresAt = this.extractExpirationFromToken(token.token);
+        if (expiresAt) {
+            const currentTimestamp = Math.round(Date.now() / 1000);
+            return expiresAt > currentTimestamp;
+        }
+        return true;
+    }, ...(ngDevMode ? [{ debugName: "isLoggedIn" }] : /* istanbul ignore next */ []));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: AuthService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: AuthService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: AuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+
+const authGuard = async (route, state) => {
+    const config = inject(AUTH_CONFIG);
+    const router = inject(Router);
+    const authProvider = inject(AuthProvider);
+    const storageService = inject(Storage);
+    if (!authProvider.isLoggedIn()) {
+        storageService.set(`${config.sessionPrefix}_rdi`, state.url);
+        return router.createUrlTree([window.innerWidth < 1000 ? '/auth' : '/signin']);
+    }
+    return true;
+};
+const loginGuard = () => {
+    const authProvider = inject(AuthProvider);
+    const router = inject(Router);
+    return authProvider.isLoggedIn() ? router.createUrlTree(['/']) : true;
+};
+const resetGuard = (route) => {
+    const authProvider = inject(AuthProvider);
+    const router = inject(Router);
+    const token = route.queryParamMap.get('token');
+    if (token && !authProvider.isLoggedIn()) {
+        return true;
+    }
+    else if (authProvider.isLoggedIn()) {
+        return router.createUrlTree(['/']);
+    }
+    else {
+        router.navigateByUrl(`/error/403`, { skipLocationChange: true });
+        return false;
+    }
+};
+
+const authInterceptor = (req, next) => {
+    const authConfig = inject(AUTH_CONFIG);
+    const authProvider = inject(AuthProvider);
+    const authReq = authProvider.addAuthenticationToken(req);
+    return next(authReq).pipe(catchError((error) => {
+        if (error instanceof HttpErrorResponse) {
+            switch (error.status) {
+                case 401:
+                    if (!req.url.includes(authConfig.auth.refreshTokenUrl)) {
+                        return authProvider.handle401Error(error, req, next);
+                    }
+                    else {
+                        authProvider.logout();
+                        return throwError(() => error);
+                    }
+                default:
+                    return throwError(() => error);
+            }
+        }
+        else {
+            return throwError(() => error);
+        }
+    }));
+};
+
+/*
+ * Public API exports for utils library
+ */
+// Services/Utils
+
+/*
+ * Public API Surface of utils
+ */
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { ArrayService, ColorService, ConfigDefaults, CsvConfigConsts, CsvService, DateService, FilePickerService, FilesService, GoogleTagManagerService, ObjectService, StorageService, StringService, getIdentificationType, identificationValidator };
+export { AUTH_CONFIG, ArrayUtil, AuthProvider, AuthService, CSV_CONFIG, ColorUtil, CsvExporter, DateUtil, FilePicker, GoogleTagManager, OPERATION_TYPE, ObjectUtil, Storage, StringUtil, authGuard, authInterceptor, getIdentificationType, identificationValidator, loginGuard, resetGuard };
 //# sourceMappingURL=factor_ec-utils.mjs.map