tailjng 0.0.13 → 0.0.15

package/fesm2022/tailjng.mjs

@@ -1,39 +1,647 @@
 import * as i0 from '@angular/core';
-import { Injectable, Component } from '@angular/core';
-import { Info } from 'lucide-angular';
+import { InjectionToken, Injectable, Inject, signal, computed } from '@angular/core';
+import * as i1 from '@angular/common';
+import { formatDistanceToNowStrict } from 'date-fns';
+import { es } from 'date-fns/locale';
+import { map, isObservable, firstValueFrom } from 'rxjs';
+import * as i1$1 from '@angular/common/http';
+import { HttpParams } from '@angular/common/http';
+import { Loader2, Moon, Sun, Search, SquareDashedMousePointer, ChevronDown, Eye, Upload, ImageOff, Minimize2, Scan, RefreshCcw, RotateCcw, RotateCw, ZoomOut, ZoomIn, Check, X, CircleHelp, TriangleAlert, CircleX, CircleCheck, Info } from 'lucide-angular';
 
-class TailjngService {
-    constructor() { }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: TailjngService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: TailjngService, providedIn: 'root' });
+const TAILJNG_CONFIG = new InjectionToken('TAILJNG_CONFIG');
+// providers: [
+//     provideRouter(routes),
+//     {
+//         provide: TAILJNG_CONFIG,
+//         useValue: {
+//             urlBase: environment.urlBase,
+//             socketUrl: environment.socketUrl,
+//         }
+//     }
+// ]
+
+class JCalendarService {
+    nameDaysAb = ['Dom', 'Lun', 'Mar', 'Mié', 'Jue', 'Vie', 'Sáb'];
+    nameDays = ['Domingo', 'Lunes', 'Martes', 'Miércoles', 'Jueves', 'Viernes', 'Sábado'];
+    nameMontsAb = ['Ene', 'Feb', 'Mar', 'Abr', 'May', 'Jun', 'Jul', 'Ago', 'Sep', 'Oct', 'Nov', 'Dic'];
+    nameMonts = ['Enero', 'Febrero', 'Marzo', 'Abril', 'Mayo', 'Junio', 'Julio', 'Agosto', 'Septiembre', 'Octubre', 'Noviembre', 'Diciembre'];
+    /**
+     * Get month from date
+     * @param date The date to extract the month from, can be a Date object or a string in 'YYYY-MM-DD' format.
+     * @returns The name of the month in Spanish.
+     */
+    getMonthFromDate(date) {
+        const parsedDate = typeof date === 'string' ? new Date(date) : date;
+        const monthIndex = parsedDate.getMonth();
+        return this.nameMonts[monthIndex];
+    }
+    /**
+     * Calculate the age of a person based on their birth date.
+     * @param birth The birth date as a Date object or a string in 'YYYY-MM-DD' format.
+     * @returns The age in years, or null if the birth date is invalid.
+     */
+    calculateAge(birth) {
+        if (!birth) {
+            return null;
+        }
+        const birthDate = typeof birth === 'string' ? new Date(birth) : birth;
+        const today = new Date();
+        let age = today.getFullYear() - birthDate.getFullYear();
+        const m = today.getMonth() - birthDate.getMonth();
+        if (m < 0 || (m === 0 && today.getDate() < birthDate.getDate())) {
+            age--;
+        }
+        return age;
+    }
+    /**
+     * Calculate the complete age of a person based on their birth date.
+     * @param birth The birth date as a Date object or a string in 'YYYY-MM-DD' format.
+     * @returns An object containing years, months, and days of age.
+     */
+    calculateAgeComplete(birth) {
+        const birthDate = typeof birth === 'string' ? new Date(birth) : birth;
+        const today = new Date();
+        let years = today.getFullYear() - birthDate.getFullYear();
+        let months = today.getMonth() - birthDate.getMonth();
+        let days = today.getDate() - birthDate.getDate();
+        if (days < 0) {
+            months--;
+            const previousMonth = new Date(today.getFullYear(), today.getMonth(), 0);
+            days += previousMonth.getDate();
+        }
+        if (months < 0) {
+            years--;
+            months += 12;
+        }
+        return { years, months, days };
+    }
+    /**
+     * Format a date string to a more readable format.
+     * @param date The date string in 'YYYY-MM-DD' format.
+     * @param month Optional parameter to add to the month name.
+     * @returns A formatted date string in the format 'DD de MMMM del YYYY'.
+     */
+    formatearFechaString(date, month) {
+        const partesFecha = date.split('-');
+        const año = partesFecha[0];
+        const mes = this.nameMonts[parseInt(partesFecha[1], 10) - 1];
+        const día = parseInt(partesFecha[2], 10);
+        let mes_fin;
+        if (month) {
+            mes_fin = mes + month;
+        }
+        else {
+            mes_fin = mes;
+        }
+        return `${día} de ${mes_fin} del ${año}`;
+    }
+    /**
+     * Format a Date object to a string in the format 'DD de MMMM del YYYY'.
+     * @param date The Date object to format.
+     * @param month Optional parameter to add to the month name.
+     * @returns A formatted date string.
+     */
+    formatearFechaDate(date, month) {
+        const utc_date = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+        let new_date = utc_date;
+        if (month !== undefined) {
+            new_date = new Date(new_date.setUTCMonth(new_date.getUTCMonth() + month));
+        }
+        // Get the values of the new date in UTC to avoid local time zones
+        const año = new_date.getUTCFullYear();
+        const mes = this.nameMonts[new_date.getUTCMonth()];
+        const día = new_date.getUTCDate();
+        return `${día} de ${mes} del ${año}`;
+    }
+    /**
+     * Parse a date string in the format "dd de MMMM del yyyy" to "yyyy-MM-dd".
+     * @param fechaStr The date string to parse.
+     * @returns The parsed date string in "yyyy-MM-dd" format or null if invalid.
+     */
+    parseFechaString(fechaStr) {
+        if (!fechaStr)
+            return null;
+        // Map Spanish month names to their numeric equivalents
+        const meses = {
+            'ENERO': '01',
+            'FEBRERO': '02',
+            'MARZO': '03',
+            'ABRIL': '04',
+            'MAYO': '05',
+            'JUNIO': '06',
+            'JULIO': '07',
+            'AGOSTO': '08',
+            'SEPTIEMBRE': '09',
+            'OCTUBRE': '10',
+            'NOVIEMBRE': '11',
+            'DICIEMBRE': '12'
+        };
+        const regex = /^(\d{1,2}) de (\w+) del (\d{4})$/i;
+        const match = fechaStr.trim().match(regex);
+        if (match) {
+            const day = match[1].padStart(2, '0');
+            const mesStr = match[2].toUpperCase();
+            const month = meses[mesStr] || '01';
+            const year = match[3];
+            return `${year}-${month}-${day}`;
+        }
+        return null;
+    }
+    /**
+     * Format a date to "MMM YY" format.
+     * @param date The date to format, can be a Date object.
+     * @returns The formatted date string.
+     */
+    formatMonthYear(date) {
+        const months = this.nameMontsAb.map(month => month.toUpperCase());
+        const month = months[date.getMonth()];
+        const year = date.getFullYear().toString().slice(-2);
+        return `${month} ${year}`;
+    }
+    /**
+     * Format a date to the Bogotá timezone (UTC-5).
+     * @param date The date to format, can be a Date object.
+     * @returns The formatted date string in 'yyyy-MM-ddTHH:mm:ss' format.
+     */
+    formatDateToBogota(date) {
+        const bogotaOffset = -5 * 60;
+        const localTime = date.getTime();
+        const localOffset = date.getTimezoneOffset() * 60000;
+        const utc = localTime + localOffset;
+        const bogotaTime = utc + (bogotaOffset * 60000);
+        const bogotaDate = new Date(bogotaTime);
+        // Format the date to 'yyyy-MM-ddTHH:mm:ss'
+        const year = bogotaDate.getFullYear();
+        const month = String(bogotaDate.getMonth() + 1).padStart(2, '0');
+        const day = String(bogotaDate.getDate()).padStart(2, '0');
+        const hours = String(bogotaDate.getHours()).padStart(2, '0');
+        const minutes = String(bogotaDate.getMinutes()).padStart(2, '0');
+        const seconds = String(bogotaDate.getSeconds()).padStart(2, '0');
+        return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}`;
+    }
+    /**
+     * Format a date to a relative time string.
+     * This method uses date-fns to format the date relative to now.
+     * @param date The date to format, can be a string in 'YYYY-MM-DD' format.
+     * @returns A formatted relative time string.
+     * @example "hace 2 días", "hace 1 hora", etc
+     */
+    formatRelativeDate(date) {
+        return formatDistanceToNowStrict(new Date(date), {
+            locale: {
+                ...es,
+                formatDistance: (token, count, options) => {
+                    const formatDistanceLocale = {
+                        lessThanXSeconds: 'hace menos de {{count}} segundos',
+                        xSeconds: 'hace {{count}} segundos',
+                        halfAMinute: 'hace medio minuto',
+                        lessThanXMinutes: 'hace menos de {{count}} minutos',
+                        xMinutes: 'hace {{count}} minutos',
+                        aboutXHours: 'hace aproximadamente {{count}} horas',
+                        xHours: 'hace {{count}} horas',
+                        xDays: 'hace {{count}} días',
+                        aboutXWeeks: 'hace aproximadamente {{count}} semanas',
+                        xWeeks: 'hace {{count}} semanas',
+                        aboutXMonths: 'hace aproximadamente {{count}} meses',
+                        xMonths: 'hace {{count}} meses',
+                        aboutXYears: 'hace aproximadamente {{count}} años',
+                        xYears: 'hace {{count}} años',
+                        overXYears: 'hace más de {{count}} años',
+                        almostXYears: 'hace casi {{count}} años'
+                    };
+                    let result = formatDistanceLocale[token];
+                    if (typeof count === 'number') {
+                        result = result.replace('{{count}}', count.toString());
+                        // Singulars and plurals
+                        if (token === 'xHours' && count === 1) {
+                            result = result.replace('horas', 'hora');
+                        }
+                        if (token === 'xDays' && count === 1) {
+                            result = result.replace('días', 'día');
+                        }
+                        if (token === 'xWeeks' && count === 1) {
+                            result = result.replace('semanas', 'semana');
+                        }
+                        if (token === 'xMonths' && count === 1) {
+                            result = result.replace('meses', 'mes');
+                        }
+                        if (token === 'xYears' && count === 1) {
+                            result = result.replace('años', 'año');
+                        }
+                    }
+                    return result;
+                }
+            }
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: JCalendarService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: JCalendarService, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: TailjngService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: JCalendarService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
-        }], ctorParameters: () => [] });
+        }] });
+
+class JConverterCrudService {
+    currencyPipe;
+    calendarService;
+    constructor(currencyPipe, calendarService) {
+        this.currencyPipe = currencyPipe;
+        this.calendarService = calendarService;
+    }
+    /**
+     * Get the correct sort key from the sortColumn object or string.
+     * @param sortColumn The column to sort by, can be a string or an object with a 'col' property.
+     * @returns The sort key as a string.
+     */
+    getSortKey(sortColumn) {
+        if (typeof sortColumn === 'object' && sortColumn !== null) {
+            return sortColumn.col;
+        }
+        return sortColumn;
+    }
+    /**
+     * Converter object to an array of objects with key and value for form initialization.
+     * @param formGroup The FormGroup to convert.
+     * @returns An array of objects with key and value for form initialization.
+     */
+    initializeFormControls(formGroup) {
+        const formControls = {};
+        Object.keys(formGroup.controls).forEach(key => {
+            formControls[`${key}_control`] = formGroup.get(key);
+        });
+        return formControls;
+    }
+    /**
+     * Formats data based on the column type.
+     * @param value The value to format.
+     * @param column The column definition.
+     * @return Formatted value based on the column type
+     */
+    formatData(value, column) {
+        if (column.isdollar && value !== null) {
+            const transformedValue = this.currencyPipe.transform(value, 'USD', 'symbol', '1.2-2');
+            return transformedValue ? transformedValue.replace('US', '') : null;
+        }
+        if (column.isCurrency && value !== null) {
+            return this.currencyPipe.transform(value, 'USD', 'symbol', '1.2-2');
+        }
+        if (column.isDate && value !== null) {
+            return new Date(value).toLocaleDateString();
+        }
+        if (column.isDateText && value !== null) {
+            return this.calendarService.formatearFechaString(`${value}`);
+        }
+        if (column.isDateTime && value !== null) {
+            return new Date(value).toLocaleString();
+        }
+        if (column.isDateTimeText && value !== null) {
+            return new Date(value).toString();
+        }
+        if (column.isRelativeTime && value !== null) {
+            return this.calendarService.formatRelativeDate(value);
+        }
+        if (column.isFirstWord && value !== null) {
+            return value.split(' ')[0];
+        }
+        return value;
+    }
+    /**
+     * This method converts values to appropriate types based on the column definition.
+     * It handles various formats such as currency, date, and text.
+     * @param value The value to parse.
+     * @param column The column definition.
+     * @returns The parsed value or null if invalid.
+     */
+    parseData(value, column) {
+        if (value === null || value === undefined || value === 'S/N') {
+            return null;
+        }
+        let cleaned = value;
+        // If it's text, trim whitespace
+        if (typeof cleaned === 'string') {
+            cleaned = cleaned.trim();
+        }
+        // isdollar → remove symbol and parse to number
+        if (column.isdollar && typeof cleaned === 'string') {
+            cleaned = cleaned.replace(/[^\d,.-]/g, '').replace(',', '.');
+            return cleaned ? parseFloat(cleaned) : null;
+        }
+        // isCurrency → remove symbol and parse to number
+        if (column.isCurrency && typeof cleaned === 'string') {
+            cleaned = cleaned.replace(/[^\d,.-]/g, '').replace(',', '.');
+            return cleaned ? parseFloat(cleaned) : null;
+        }
+        // isDateText → parse text from date to ISO format (yyyy-MM-dd)
+        if (column.isDateText && typeof cleaned === 'string') {
+            // Use your reverse calendarService if you have one
+            const fecha = this.calendarService.parseFechaString(cleaned);
+            return fecha ?? cleaned;
+        }
+        // isDate → parse text to Date or ISO string
+        if (column.isDate && typeof cleaned === 'string') {
+            const fecha = new Date(cleaned);
+            return isNaN(fecha.getTime()) ? cleaned : fecha.toISOString().substring(0, 10);
+        }
+        // isDateTime → parse text to DateTime
+        if (column.isDateTime && typeof cleaned === 'string') {
+            const fecha = new Date(cleaned);
+            return isNaN(fecha.getTime()) ? cleaned : fecha.toISOString();
+        }
+        // isDateTimeText → parse text to DateTime
+        if (column.isDateTimeText && typeof cleaned === 'string') {
+            const fecha = new Date(cleaned);
+            return isNaN(fecha.getTime()) ? cleaned : fecha.toISOString();
+        }
+        // isRelativeTime → impossible to reverse automatically, return text
+        if (column.isRelativeTime) {
+            return cleaned;
+        }
+        // isFirstWord → return full text, as it's unclear which part to remove
+        if (column.isFirstWord) {
+            return cleaned;
+        }
+        return cleaned;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: JConverterCrudService, deps: [{ token: i1.CurrencyPipe }, { token: JCalendarService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: JConverterCrudService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: JConverterCrudService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.CurrencyPipe }, { type: JCalendarService }] });
+
+class JParamsHttpService {
+    /**
+     * Transform Params to HttpParams
+     * @param params
+     * @returns
+     */
+    resParams(params) {
+        // Construct HttpParams
+        let httpParams = new HttpParams();
+        if (params) {
+            Object.keys(params).forEach(key => {
+                const value = params[key];
+                // If the value is an object (e.g., filter: { id_status: [1, 2] })
+                if (typeof value === 'object' && value !== null) {
+                    Object.keys(value).forEach(subKey => {
+                        const subValue = value[subKey];
+                        // If the subValue is an array (e.g., id_status: [1, 2])
+                        if (Array.isArray(subValue)) {
+                            subValue.forEach(v => {
+                                httpParams = httpParams.append(`${key}[${subKey}]`, v);
+                            });
+                        }
+                        else {
+                            // If it's a unique value
+                            httpParams = httpParams.append(`${key}[${subKey}]`, subValue);
+                        }
+                    });
+                }
+                else {
+                    // If it's a flat value (e.g., id_status: 1)
+                    httpParams = httpParams.append(key, value);
+                }
+            });
+        }
+        return httpParams;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: JParamsHttpService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: JParamsHttpService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: JParamsHttpService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class JGenericCrudService {
+    config;
+    http;
+    paramsHttpService;
+    converterCrudService;
+    constructor(config, http, paramsHttpService, converterCrudService) {
+        this.config = config;
+        this.http = http;
+        this.paramsHttpService = paramsHttpService;
+        this.converterCrudService = converterCrudService;
+    }
+    /**
+     * Method to get all records from an endpoint.
+     * @param endpoint Distinctive of the endpoint ('role', 'status', etc.)
+     * @param params Parameters of the request.
+     * @returns Observable with the API response.
+     */
+    getAll(endpoint, params) {
+        const url = `${this.config.urlBase}/${endpoint}`;
+        let httpParams;
+        if (params)
+            httpParams = this.paramsHttpService.resParams(params);
+        return this.http.get(url, { params: httpParams });
+    }
+    /**
+     * Method to get a record from an endpoint.
+     * @param endpoint Distinctive of the endpoint ('role', 'status', etc.)
+     * @param id Identifier of the record.
+     * @returns Observable with the API response.
+     */
+    getId(endpoint, id) {
+        const url = `${this.config.urlBase}/${endpoint}`;
+        return this.http.get(`${url}/${id}`).pipe(map(response => response.data[endpoint]));
+    }
+    /**
+     * Method to create a record in an endpoint.
+     * @param endpoint Distinctive of the endpoint ('role', 'status', etc.)
+     * @param data Data of the record to add.
+     * @returns Observable with the API response.
+     */
+    create(endpoint, data) {
+        const url = `${this.config.urlBase}/${endpoint}`;
+        return this.http.post(url, data);
+    }
+    /**
+     * MMethod to update a record in an endpoint.
+     * @param endpoint Distinctive of the endpoint ('role', 'status', etc.)
+     * @param id Identifier of the record.
+     * @param data Data of the record to update.
+     * @returns Observable with the API response.
+     */
+    update(endpoint, id, data) {
+        const url = `${this.config.urlBase}/${endpoint}`;
+        return this.http.put(`${url}/${id}`, data);
+    }
+    /**
+     * MMethod to delete a record from an endpoint.
+     * @param endpoint Distinctive of the endpoint ('role', 'status', etc.)
+     * @param id Identifier of the record.
+     * @returns Observable with the API response.
+     */
+    delete(endpoint, id) {
+        const url = `${this.config.urlBase}/${endpoint}`;
+        return this.http.delete(`${url}/${id}`);
+    }
+    /**
+    * Method to update the status of a record in an endpoint.
+    * @param endpoint Distinctive of the endpoint ('role', 'status', etc.)
+    * @param id Identifier of the record.
+    * @param data Data of a boolean record to update.
+    * @returns Observable with the API response.
+    */
+    enable(endpoint, id, data) {
+        const url = `${this.config.urlBase}/${endpoint}`;
+        return this.http.put(`${url}/enable/${id}`, data);
+    }
+    /**
+     * MMethod to create multiple records in an endpoint.
+     * @param endpoint Distinctive of the endpoint ('role', 'status', etc.)
+     * @param data Data of multiple records to add.
+     * @returns Observable with the API response.
+     */
+    createMultiple(endpoint, data) {
+        const url = `${this.config.urlBase}/${endpoint}/bulk`;
+        return this.http.post(url, data);
+    }
+    /**
+    * Method to get the query parameters for a table.
+    * @param page Current page number.
+    * @param limit NNumber of records per page.
+    * @param sort Object containing the column and the sorting direction.
+    * @param filters Filters applied to the query.
+    * @param defaultFilters Default filters applied to the query.
+    * @param searchQuery Search string.
+    * @param columns Columns to search.
+    * @returns
+    */
+    params({ page, limit, sort, filters, defaultFilters, searchQuery, columns }) {
+        const params = {};
+        if (page)
+            params['page'] = page.toString();
+        if (limit)
+            params['limit'] = limit.toString();
+        // Apply default filters if provided
+        Object.keys(defaultFilters ?? {}).forEach((key) => {
+            if (!filters.hasOwnProperty(key)) {
+                params[`filter[${key}]`] = defaultFilters[key];
+            }
+        });
+        // If sort is provided, get the sort key and direction
+        if (sort?.column && sort?.direction !== 'none') {
+            const sortKey = this.converterCrudService.getSortKey(sort?.column);
+            params['sortBy'] = sortKey;
+            params['sortOrder'] = sort?.direction?.toUpperCase();
+        }
+        // Apply search if provided
+        if (searchQuery && searchQuery.trim() !== '') {
+            params['search'] = searchQuery;
+            params['searchFields'] = columns?.map(col => col);
+        }
+        // Apply filters if provided
+        if (Object.keys(filters).length > 0) {
+            params['filter'] = filters;
+        }
+        return params;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: JGenericCrudService, deps: [{ token: TAILJNG_CONFIG }, { token: i1$1.HttpClient }, { token: JParamsHttpService }, { token: JConverterCrudService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: JGenericCrudService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: JGenericCrudService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TAILJNG_CONFIG]
+                }] }, { type: i1$1.HttpClient }, { type: JParamsHttpService }, { type: JConverterCrudService }] });
 
-class TailjngComponent {
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: TailjngComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.14", type: TailjngComponent, isStandalone: true, selector: "lib-tailjng", ngImport: i0, template: `
-    <p>
-      tailjng works!
-    </p>
-  `, isInline: true, styles: [""] });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: TailjngComponent, decorators: [{
-            type: Component,
-            args: [{ selector: 'lib-tailjng', imports: [], template: `
-    <p>
-      tailjng works!
-    </p>
-  ` }]
+class ErrorHandlerHttpService {
+    /**
+     * Map HTTP status codes to user-friendly messages and alert types.
+     * This mapping helps in providing consistent error messages across the application.
+     */
+    errorMappings = {
+        400: { type: 'info', title: 'Solicitud incorrecta', message: 'Los datos enviados no son válidos. Verifique e intente de nuevo.', persistent: false },
+        401: { type: 'info', title: 'No autorizado', message: 'Debe iniciar sesión para acceder a esta función.', persistent: true },
+        403: { type: 'error', title: 'Acceso denegado', message: 'No tiene permisos para realizar esta acción.', persistent: true },
+        404: { type: 'info', title: 'No encontrado', message: 'El recurso solicitado no existe o fue eliminado.', persistent: false },
+        409: { type: 'info', title: 'Conflicto', message: 'Conflicto en la solicitud. Verifique los datos ingresados.', persistent: false },
+        422: { type: 'info', title: 'Datos no procesables', message: 'Los datos son válidos, pero no pueden ser procesados en este momento.', persistent: false },
+        429: { type: 'info', title: 'Demasiadas solicitudes', message: 'Ha realizado demasiadas solicitudes. Intente más tarde.', persistent: true },
+        500: { type: 'error', title: 'Error del servidor', message: 'Ocurrió un error inesperado. Intente más tarde.', persistent: true },
+        503: { type: 'error', title: 'Servicio no disponible', message: 'El servidor está en mantenimiento o sobrecargado.', persistent: true }
+    };
+    /**
+     * Handle HTTP errors and return a structured message with alert type.
+     * @param error The error object returned from the HTTP request.
+     * @returns A structured error message.
+     */
+    handleHttpError(error) {
+        console.error('HTTP Error:', error);
+        // If no error is defined, return a generic message
+        if (!error) {
+            return {
+                type: 'error',
+                title: 'Error desconocido',
+                message: 'Ocurrió un error inesperado. Intente de nuevo más tarde.',
+                persistent: true
+            };
+        }
+        const status = error?.status || 0;
+        const backendMessage = error?.error?.msg || error?.message;
+        const errorInfo = this.errorMappings[status] || {
+            title: 'Error desconocido',
+            message: 'Ocurrió un error inesperado. Intente de nuevo más tarde.',
+            type: 'error',
+            persistent: true
+        };
+        return {
+            type: errorInfo.type,
+            title: errorInfo.title,
+            message: backendMessage || errorInfo.message,
+            persistent: errorInfo.persistent
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: ErrorHandlerHttpService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: ErrorHandlerHttpService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: ErrorHandlerHttpService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
         }] });
 
 class JIconsService {
     icons = {
-        Info,
+        info: Info,
+        success: CircleCheck,
+        error: CircleX,
+        warning: TriangleAlert,
+        question: CircleHelp,
+        close: X,
+        check: Check,
+        zoomIn: ZoomIn,
+        zoomOut: ZoomOut,
+        rotateRight: RotateCw,
+        rotateLeft: RotateCcw,
+        reset: RefreshCcw,
+        fullscreen: Scan,
+        exitFullscreen: Minimize2,
+        imageOff: ImageOff,
+        upload: Upload,
+        view: Eye,
+        chevronDown: ChevronDown,
+        squareDashedMousePointer: SquareDashedMousePointer,
+        search: Search,
+        sun: Sun,
+        moon: Moon,
+        loading: Loader2,
     };
     constructor() { }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: JIconsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
@@ -46,13 +654,283 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImpo
                 }]
         }], ctorParameters: () => [] });
 
+class JAlertDialogService {
+    isOpenSignal = signal(false);
+    configSignal = signal(null);
+    // Estados de carga para los botones
+    isLoadingConfirm = signal(false);
+    isLoadingCancel = signal(false);
+    isLoadingRetry = signal(false);
+    // Callbacks
+    onConfirmCallback;
+    onCancelCallback;
+    onRetryCallback;
+    isOpen = computed(() => this.isOpenSignal());
+    config = computed(() => this.configSignal());
+    isConfirmLoading = computed(() => this.isLoadingConfirm());
+    isCancelLoading = computed(() => this.isLoadingCancel());
+    isRetryLoading = computed(() => this.isLoadingRetry());
+    // Add a dialogs computed property that returns an array with a single dialog when open
+    dialogs = computed(() => {
+        if (!this.isOpenSignal())
+            return [];
+        return [{
+                config: this.configSignal(),
+                isConfirmLoading: this.isLoadingConfirm(),
+                isCancelLoading: this.isLoadingCancel(),
+                isRetryLoading: this.isLoadingRetry()
+            }];
+    });
+    getConfig() {
+        return this.configSignal();
+    }
+    AlertDialog(config) {
+        this.onConfirmCallback = "onConfirm" in config ? config.onConfirm : undefined;
+        this.onCancelCallback = "onCancel" in config ? config.onCancel : undefined;
+        this.onRetryCallback = "onRetry" in config ? config.onRetry : undefined;
+        // Reset loading states
+        this.isLoadingConfirm.set(false);
+        this.isLoadingCancel.set(false);
+        this.isLoadingRetry.set(false);
+        this.configSignal.set(config);
+        this.isOpenSignal.set(true);
+    }
+    closeDialog() {
+        this.isOpenSignal.set(false);
+        this.configSignal.set(null);
+    }
+    async executeAction(action) {
+        let callback;
+        let loadingSignal;
+        switch (action) {
+            case "confirm":
+                callback = this.onConfirmCallback;
+                loadingSignal = this.isLoadingConfirm;
+                break;
+            case "cancel":
+                callback = this.onCancelCallback;
+                loadingSignal = this.isLoadingCancel;
+                break;
+            case "retry":
+                callback = this.onRetryCallback;
+                loadingSignal = this.isLoadingRetry;
+                break;
+        }
+        if (!callback) {
+            this.closeDialog();
+            return;
+        }
+        loadingSignal.set(true);
+        try {
+            const result = callback();
+            // Soporte para Observable
+            if (isObservable(result)) {
+                await firstValueFrom(result);
+            }
+            // Soporte para Promise
+            if (result instanceof Promise) {
+                await result;
+            }
+            // Si es void, no hacemos nada extra
+        }
+        catch (error) {
+            console.error(`Error en la acción ${action}:`, error);
+        }
+        finally {
+            loadingSignal.set(false);
+            this.closeDialog();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: JAlertDialogService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: JAlertDialogService, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: JAlertDialogService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }] });
+
+class JAlertToastService {
+    toastsSignal = signal([]);
+    autoCloseTimers = new Map();
+    // Default auto-close delay in milliseconds
+    DEFAULT_AUTO_CLOSE_DELAY = 5000;
+    // Default action button text
+    DEFAULT_ACTION_BUTTON_TEXT = "Action";
+    // For compatibility with existing code
+    isOpenSignal = signal(false);
+    configSignal = signal(null);
+    isLoadingAction = signal(false);
+    isLoadingCancel = signal(false);
+    // Computed values for all toasts
+    toasts = computed(() => this.toastsSignal());
+    // For backward compatibility with existing code
+    isOpen = computed(() => this.isOpenSignal());
+    config = computed(() => this.configSignal());
+    isActionLoading = computed(() => this.isLoadingAction());
+    isCancelLoading = computed(() => this.isLoadingCancel());
+    getConfig() {
+        return this.configSignal();
+    }
+    AlertToast(config) {
+        const toastId = crypto.randomUUID();
+        // Store callbacks for this toast
+        const onActionCallback = "onAction" in config ? config.onAction : undefined;
+        const onCancelCallback = "onCancel" in config ? config.onCancel : undefined;
+        // Get action button text or use default
+        const actionNameButton = config.actionButtonText ?? this.DEFAULT_ACTION_BUTTON_TEXT;
+        const toast = {
+            id: toastId,
+            config,
+            isActionLoading: false,
+            isCancelLoading: false,
+            onActionCallback,
+            onCancelCallback,
+            actionNameButton, // Add the button text
+            createdAt: Date.now()
+        };
+        // Add the toast to our list
+        this.toastsSignal.update(toasts => [...toasts, toast]);
+        // Check if this toast should auto-close
+        // If autoClose is explicitly set to true OR 
+        // if it's a success toast and autoClose is not explicitly set to false
+        const shouldAutoClose = config.autoClose === true ||
+            (config.type === 'success' && config.autoClose !== false);
+        if (shouldAutoClose) {
+            // Use the provided delay or the default
+            const delay = config.autoCloseDelay ?? this.DEFAULT_AUTO_CLOSE_DELAY;
+            const timerId = setTimeout(() => {
+                this.closeToastById(toastId);
+                this.autoCloseTimers.delete(toastId);
+            }, delay);
+            this.autoCloseTimers.set(toastId, timerId);
+        }
+        return toastId;
+    }
+    closeToastById(toastId) {
+        // Clear any auto-close timer
+        if (this.autoCloseTimers.has(toastId)) {
+            clearTimeout(this.autoCloseTimers.get(toastId));
+            this.autoCloseTimers.delete(toastId);
+        }
+        this.toastsSignal.update(toasts => toasts.filter(toast => toast.id !== toastId));
+    }
+    closeAllToasts() {
+        // Clear all timers
+        this.autoCloseTimers.forEach(timerId => clearTimeout(timerId));
+        this.autoCloseTimers.clear();
+        this.toastsSignal.set([]);
+    }
+    async executeToastAction(toastId, action) {
+        const toast = this.toastsSignal().find(t => t.id === toastId);
+        if (!toast)
+            return;
+        let callback;
+        let loadingProperty;
+        switch (action) {
+            case "action":
+                callback = toast.onActionCallback;
+                loadingProperty = 'isActionLoading';
+                break;
+            case "cancel":
+                callback = toast.onCancelCallback;
+                loadingProperty = 'isCancelLoading';
+                break;
+        }
+        if (callback) {
+            // Update loading state
+            this.toastsSignal.update(toasts => toasts.map(t => t.id === toastId ? { ...t, [loadingProperty]: true } : t));
+            try {
+                await callback();
+            }
+            catch (error) {
+                console.error(`Error en la acción ${action}:`, error);
+            }
+            finally {
+                // Update loading state back to false (in case the toast hasn't been closed)
+                this.toastsSignal.update(toasts => {
+                    const updatedToasts = toasts.map(t => t.id === toastId ? { ...t, [loadingProperty]: false } : t);
+                    return updatedToasts;
+                });
+                this.closeToastById(toastId);
+            }
+        }
+        else {
+            this.closeToastById(toastId);
+        }
+    }
+    // For backward compatibility with existing code
+    closeToast() {
+        this.closeAllToasts();
+        this.isOpenSignal.set(false);
+        this.configSignal.set(null);
+    }
+    // For backward compatibility with existing code
+    async executeAction(action) {
+        let callback;
+        let loadingSignal;
+        switch (action) {
+            case "action":
+                callback = "onAction" in (this.configSignal() || {})
+                    ? this.configSignal().onAction
+                    : undefined;
+                loadingSignal = this.isLoadingAction;
+                break;
+            case "cancel":
+                callback = "onCancel" in (this.configSignal() || {})
+                    ? this.configSignal().onCancel
+                    : undefined;
+                loadingSignal = this.isLoadingCancel;
+                break;
+        }
+        if (callback) {
+            loadingSignal.set(true);
+            try {
+                await callback();
+            }
+            catch (error) {
+                console.error(`Error en la acción ${action}:`, error);
+            }
+            finally {
+                loadingSignal.set(false);
+                this.closeToast();
+            }
+        }
+        else {
+            this.closeToast();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: JAlertToastService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: JAlertToastService, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: JAlertToastService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }] });
+
+// ======================================================
+// Table Column Interface
+// This interface defines the structure of a table column in a CRUD application.
+// ======================================================
+
 /*
  * Public API Surface of tailjng
  */
+// ========================================
+// Config
+// ========================================
+// npm version patch
+// npm run build
+// cd dist/tailjng
+// npm publish --access public
+// npx tailjng add [component]
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { JIconsService, TailjngComponent, TailjngService };
+export { ErrorHandlerHttpService, JAlertDialogService, JAlertToastService, JCalendarService, JConverterCrudService, JGenericCrudService, JIconsService, JParamsHttpService, TAILJNG_CONFIG };
 //# sourceMappingURL=tailjng.mjs.map