ywana-core8 0.1.79 → 0.1.80

package/src/html/table-summary-functions.js

@@ -0,0 +1,363 @@
+/**
+ * Funciones de sumario para DataTable2
+ * Proporciona funciones predefinidas para calcular totales, promedios, conteos, etc.
+ * según el tipo de datos de cada columna.
+ */
+
+/**
+ * Funciones numéricas
+ */
+export const numericSummaryFunctions = {
+    sum: {
+        id: 'sum',
+        label: 'Suma',
+        description: 'Suma todos los valores numéricos',
+        calculate: (values) => {
+            const numbers = values.filter(v => v != null && !isNaN(Number(v))).map(Number)
+            return numbers.length > 0 ? numbers.reduce((a, b) => a + b, 0) : 0
+        },
+        format: (value, column) => {
+            if (column.type === 'currency') {
+                return new Intl.NumberFormat('es-ES', { 
+                    style: 'currency', 
+                    currency: 'EUR' 
+                }).format(value)
+            }
+            return new Intl.NumberFormat('es-ES').format(value)
+        }
+    },
+    
+    avg: {
+        id: 'avg',
+        label: 'Promedio',
+        description: 'Promedio de todos los valores numéricos',
+        calculate: (values) => {
+            const numbers = values.filter(v => v != null && !isNaN(Number(v))).map(Number)
+            return numbers.length > 0 ? numbers.reduce((a, b) => a + b, 0) / numbers.length : 0
+        },
+        format: (value, column) => {
+            if (column.type === 'currency') {
+                return new Intl.NumberFormat('es-ES', { 
+                    style: 'currency', 
+                    currency: 'EUR' 
+                }).format(value)
+            }
+            return new Intl.NumberFormat('es-ES', { 
+                minimumFractionDigits: 2, 
+                maximumFractionDigits: 2 
+            }).format(value)
+        }
+    },
+    
+    min: {
+        id: 'min',
+        label: 'Mínimo',
+        description: 'Valor mínimo',
+        calculate: (values) => {
+            const numbers = values.filter(v => v != null && !isNaN(Number(v))).map(Number)
+            return numbers.length > 0 ? Math.min(...numbers) : 0
+        },
+        format: (value, column) => {
+            if (column.type === 'currency') {
+                return new Intl.NumberFormat('es-ES', { 
+                    style: 'currency', 
+                    currency: 'EUR' 
+                }).format(value)
+            }
+            return new Intl.NumberFormat('es-ES').format(value)
+        }
+    },
+    
+    max: {
+        id: 'max',
+        label: 'Máximo',
+        description: 'Valor máximo',
+        calculate: (values) => {
+            const numbers = values.filter(v => v != null && !isNaN(Number(v))).map(Number)
+            return numbers.length > 0 ? Math.max(...numbers) : 0
+        },
+        format: (value, column) => {
+            if (column.type === 'currency') {
+                return new Intl.NumberFormat('es-ES', { 
+                    style: 'currency', 
+                    currency: 'EUR' 
+                }).format(value)
+            }
+            return new Intl.NumberFormat('es-ES').format(value)
+        }
+    }
+}
+
+/**
+ * Funciones de texto
+ */
+export const textSummaryFunctions = {
+    count: {
+        id: 'count',
+        label: 'Contar',
+        description: 'Cuenta valores no vacíos',
+        calculate: (values) => {
+            return values.filter(v => v != null && v !== '').length
+        },
+        format: (value) => `${value} elementos`
+    },
+    
+    countUnique: {
+        id: 'countUnique',
+        label: 'Únicos',
+        description: 'Cuenta valores únicos',
+        calculate: (values) => {
+            const unique = new Set(values.filter(v => v != null && v !== ''))
+            return unique.size
+        },
+        format: (value) => `${value} únicos`
+    },
+    
+    mostCommon: {
+        id: 'mostCommon',
+        label: 'Más común',
+        description: 'Valor más frecuente',
+        calculate: (values) => {
+            const counts = {}
+            values.filter(v => v != null && v !== '').forEach(v => {
+                counts[v] = (counts[v] || 0) + 1
+            })
+            
+            let maxCount = 0
+            let mostCommon = ''
+            Object.entries(counts).forEach(([value, count]) => {
+                if (count > maxCount) {
+                    maxCount = count
+                    mostCommon = value
+                }
+            })
+            
+            return mostCommon
+        },
+        format: (value) => value || 'N/A'
+    }
+}
+
+/**
+ * Funciones de fecha
+ */
+export const dateSummaryFunctions = {
+    count: {
+        id: 'count',
+        label: 'Contar',
+        description: 'Cuenta fechas válidas',
+        calculate: (values) => {
+            return values.filter(v => v != null && v !== '' && !isNaN(Date.parse(v))).length
+        },
+        format: (value) => `${value} fechas`
+    },
+    
+    earliest: {
+        id: 'earliest',
+        label: 'Más antigua',
+        description: 'Fecha más antigua',
+        calculate: (values) => {
+            const dates = values
+                .filter(v => v != null && v !== '' && !isNaN(Date.parse(v)))
+                .map(v => new Date(v))
+            return dates.length > 0 ? new Date(Math.min(...dates)) : null
+        },
+        format: (value) => {
+            return value ? new Intl.DateTimeFormat('es-ES').format(value) : 'N/A'
+        }
+    },
+    
+    latest: {
+        id: 'latest',
+        label: 'Más reciente',
+        description: 'Fecha más reciente',
+        calculate: (values) => {
+            const dates = values
+                .filter(v => v != null && v !== '' && !isNaN(Date.parse(v)))
+                .map(v => new Date(v))
+            return dates.length > 0 ? new Date(Math.max(...dates)) : null
+        },
+        format: (value) => {
+            return value ? new Intl.DateTimeFormat('es-ES').format(value) : 'N/A'
+        }
+    }
+}
+
+/**
+ * Funciones booleanas
+ */
+export const booleanSummaryFunctions = {
+    countTrue: {
+        id: 'countTrue',
+        label: 'Verdaderos',
+        description: 'Cuenta valores verdaderos',
+        calculate: (values) => {
+            return values.filter(v => v === true || v === 'true' || v === 1 || v === '1').length
+        },
+        format: (value) => `${value} verdaderos`
+    },
+    
+    countFalse: {
+        id: 'countFalse',
+        label: 'Falsos',
+        description: 'Cuenta valores falsos',
+        calculate: (values) => {
+            return values.filter(v => v === false || v === 'false' || v === 0 || v === '0').length
+        },
+        format: (value) => `${value} falsos`
+    },
+    
+    percentage: {
+        id: 'percentage',
+        label: 'Porcentaje',
+        description: 'Porcentaje de verdaderos',
+        calculate: (values) => {
+            const total = values.filter(v => v != null).length
+            const trueCount = values.filter(v => v === true || v === 'true' || v === 1 || v === '1').length
+            return total > 0 ? (trueCount / total) * 100 : 0
+        },
+        format: (value) => `${value.toFixed(1)}%`
+    }
+}
+
+/**
+ * Mapa de funciones por tipo de columna
+ */
+export const summaryFunctionsByType = {
+    number: numericSummaryFunctions,
+    currency: numericSummaryFunctions,
+    percentage: numericSummaryFunctions,
+    text: textSummaryFunctions,
+    email: textSummaryFunctions,
+    url: textSummaryFunctions,
+    date: dateSummaryFunctions,
+    datetime: dateSummaryFunctions,
+    boolean: booleanSummaryFunctions
+}
+
+/**
+ * Obtener funciones disponibles para un tipo de columna
+ */
+export const getSummaryFunctionsForType = (columnType) => {
+    return summaryFunctionsByType[columnType] || textSummaryFunctions
+}
+
+/**
+ * Calcular sumario para una columna
+ */
+export const calculateColumnSummary = (column, rows) => {
+    if (!column.summary || !column.summary.function) {
+        return null
+    }
+    
+    // Obtener valores de la columna
+    const values = rows.map(row => row[column.id])
+    
+    // Obtener función de sumario
+    const summaryFunction = getSummaryFunction(column.summary.function, column.type)
+    if (!summaryFunction) {
+        return null
+    }
+    
+    // Calcular valor
+    const calculatedValue = summaryFunction.calculate(values)
+    
+    // Formatear resultado
+    const formattedValue = summaryFunction.format(calculatedValue, column)
+    
+    return {
+        value: calculatedValue,
+        formatted: formattedValue,
+        function: summaryFunction
+    }
+}
+
+/**
+ * Obtener función de sumario específica
+ */
+export const getSummaryFunction = (functionId, columnType) => {
+    const functions = getSummaryFunctionsForType(columnType)
+    return functions[functionId] || null
+}
+
+/**
+ * Funciones de utilidad para validación
+ */
+export const isValidSummaryFunction = (functionId, columnType) => {
+    const functions = getSummaryFunctionsForType(columnType)
+    return functionId in functions
+}
+
+/**
+ * Obtener todas las funciones disponibles
+ */
+export const getAllSummaryFunctions = () => {
+    return {
+        ...numericSummaryFunctions,
+        ...textSummaryFunctions,
+        ...dateSummaryFunctions,
+        ...booleanSummaryFunctions
+    }
+}
+
+/**
+ * Funciones de utilidad para crear sumarios personalizados
+ */
+export const createCustomSummaryFunction = (id, label, description, calculateFn, formatFn) => {
+    return {
+        id,
+        label,
+        description,
+        calculate: calculateFn,
+        format: formatFn || ((value) => String(value))
+    }
+}
+
+/**
+ * Ejemplos de uso:
+ *
+ * // Sumario básico de suma
+ * const column = {
+ *     id: 'precio',
+ *     label: 'Precio',
+ *     type: 'currency',
+ *     summary: { function: 'sum' }
+ * }
+ *
+ * // Sumario personalizado
+ * const customSummary = createCustomSummaryFunction(
+ *     'variance',
+ *     'Varianza',
+ *     'Varianza de los valores',
+ *     (values) => {
+ *         const numbers = values.filter(v => !isNaN(Number(v))).map(Number)
+ *         const mean = numbers.reduce((a, b) => a + b, 0) / numbers.length
+ *         const variance = numbers.reduce((a, b) => a + Math.pow(b - mean, 2), 0) / numbers.length
+ *         return variance
+ *     },
+ *     (value) => value.toFixed(2)
+ * )
+ *
+ * // Funciones disponibles por tipo:
+ * //
+ * // NUMÉRICAS (number, currency, percentage):
+ * // - sum: Suma total
+ * // - avg: Promedio
+ * // - min: Valor mínimo
+ * // - max: Valor máximo
+ * //
+ * // TEXTO (text, email, url):
+ * // - count: Contar valores no vacíos
+ * // - countUnique: Contar valores únicos
+ * // - mostCommon: Valor más frecuente
+ * //
+ * // FECHAS (date, datetime):
+ * // - count: Contar fechas válidas
+ * // - earliest: Fecha más antigua
+ * // - latest: Fecha más reciente
+ * //
+ * // BOOLEANAS (boolean):
+ * // - countTrue: Contar verdaderos
+ * // - countFalse: Contar falsos
+ * // - percentage: Porcentaje de verdaderos
+ */