@praxisui/table 1.0.0-beta.8 → 3.0.0-beta.0

package/fesm2022/praxisui-table-table-ai.adapter-C5rjLb8E.mjs

@@ -0,0 +1,822 @@
+import { firstValueFrom } from 'rxjs';
+import { BaseAiAdapter } from '@praxisui/ai';
+import { deepMerge } from '@praxisui/core';
+import { TABLE_AI_CAPABILITIES, TASK_PRESETS } from './praxisui-table.mjs';
+
+/**
+ * Analisa uma amostra de dados da tabela para gerar estatísticas
+ * que ajudem a IA a sugerir renderers e formatos adequados.
+ */
+class TableDataProfiler {
+    static SAMPLE_LIMIT = 3; // Analisa no máximo 3 linhas para performance
+    static VALUE_TRUNCATE = 50; // Trunca strings longas no contexto
+    static profile(data, config, options) {
+        const sampleLimit = options?.sampleLimit ?? this.SAMPLE_LIMIT;
+        const rowCount = options?.rowCountOverride ?? data.length;
+        const profile = {
+            rowCount,
+            columns: {},
+            generatedAt: Date.now()
+        };
+        if (!data || data.length === 0 || !config.columns) {
+            return profile;
+        }
+        // 1. Selecionar amostra (início, meio e fim se possível, ou apenas slice)
+        // Para simplicidade e estabilidade, pegamos os primeiros N itens.
+        const sample = data.slice(0, sampleLimit);
+        // 2. Iterar colunas configuradas
+        for (const col of config.columns) {
+            if (!col || !col.field)
+                continue;
+            const values = sample.map(row => this.getValue(row, col.field)).filter(v => v !== null && v !== undefined && v !== '');
+            const stats = {
+                field: col.field,
+                header: col.header,
+                inferredType: 'empty',
+                cardinality: 0,
+                hasNulls: values.length < sample.length,
+                topValues: []
+            };
+            if (values.length > 0) {
+                stats.inferredType = this.inferType(values);
+                stats.cardinality = new Set(values.map(v => String(v))).size;
+                // Coletar Top Values (frequência)
+                const freqMap = new Map();
+                values.forEach(v => {
+                    const k = String(v);
+                    freqMap.set(k, (freqMap.get(k) || 0) + 1);
+                });
+                stats.topValues = Array.from(freqMap.entries())
+                    .sort((a, b) => b[1] - a[1]) // Sort by count desc
+                    .slice(0, 5)
+                    .map(([val]) => this.sanitizeValue(val, stats.inferredType));
+                // Stats específicas por tipo
+                if (stats.inferredType === 'number') {
+                    const nums = values.map(v => Number(v)).filter(n => !isNaN(n));
+                    if (nums.length) {
+                        stats.min = Math.min(...nums);
+                        stats.max = Math.max(...nums);
+                    }
+                }
+                else if (stats.inferredType === 'date') {
+                    const dates = values.map(v => new Date(v).getTime()).filter(t => !isNaN(t));
+                    if (dates.length) {
+                        stats.dateRange = {
+                            start: new Date(Math.min(...dates)).toISOString(),
+                            end: new Date(Math.max(...dates)).toISOString()
+                        };
+                    }
+                }
+                else if (stats.inferredType === 'string') {
+                    const strVal = String(values[0]);
+                    stats.isUrl = strVal.startsWith('http');
+                    stats.isEmail = strVal.includes('@') && strVal.includes('.');
+                    stats.isLongText = values.some(v => String(v).length > 50);
+                }
+            }
+            profile.columns[col.field] = stats;
+        }
+        return profile;
+    }
+    static getValue(row, path) {
+        if (!path || typeof path !== 'string')
+            return undefined;
+        return path.split('.').reduce((obj, key) => obj?.[key], row);
+    }
+    static inferType(values) {
+        const first = values[0];
+        if (typeof first === 'number')
+            return 'number';
+        if (typeof first === 'boolean')
+            return 'boolean';
+        if (first instanceof Date)
+            return 'date';
+        // Check string formats
+        const str = String(first);
+        if (!isNaN(Number(str)) && str.trim() !== '')
+            return 'number';
+        if (!isNaN(Date.parse(str)) && str.length > 5)
+            return 'date'; // length check avoids short strings being parsed as dates
+        return 'string';
+    }
+    static sanitizeValue(val, type) {
+        if (type === 'string' && val.length > this.VALUE_TRUNCATE) {
+            return val.substring(0, this.VALUE_TRUNCATE) + '...';
+        }
+        return val;
+    }
+}
+
+/**
+ * Adapter that connects the AI Engine to a specific PraxisTable instance.
+ * Implements two-step intent flow + heuristics for contextual suggestions.
+ */
+class TableAiAdapter extends BaseAiAdapter {
+    table;
+    aiService;
+    componentName = 'Data Table';
+    componentId = 'praxis-table';
+    componentType = 'table';
+    constructor(table, aiService) {
+        super();
+        this.table = table;
+        this.aiService = aiService;
+    }
+    // -------- Core contract --------
+    getCurrentConfig() {
+        try {
+            return structuredClone(this.table.config);
+        }
+        catch {
+            return JSON.parse(JSON.stringify(this.table.config));
+        }
+    }
+    getCapabilities() {
+        return TABLE_AI_CAPABILITIES.capabilities;
+    }
+    getTaskPresets() {
+        return TASK_PRESETS;
+    }
+    getRuntimeState() {
+        return {
+            rowsTotal: this.table.dataSource.data.length,
+            rowsVisible: this.table.paginator ? this.table.paginator.pageSize : this.table.dataSource.data.length,
+            pageIndex: this.table.paginator ? this.table.paginator.pageIndex : 0,
+            sort: this.table.sort ? { active: this.table.sort.active, direction: this.table.sort.direction } : null,
+            filters: this.table.filterCriteria,
+            selectionCount: this.table.selection.selected.length,
+            isLoading: false // TODO: expose real loading flag
+        };
+    }
+    getSuggestionContext() {
+        const config = this.getCurrentConfig();
+        const behavior = config.behavior || {};
+        const actions = config.actions || {};
+        const availableFeatures = [];
+        const missingCapabilities = [];
+        if (!this.table.resourcePath) {
+            availableFeatures.push('data-connection');
+        }
+        if (!this.table.idField) {
+            availableFeatures.push('bindings.idField');
+        }
+        if (!behavior.filtering?.enabled) {
+            availableFeatures.push('behavior.filtering');
+            missingCapabilities.push('filtering');
+        }
+        if (!behavior.sorting?.enabled) {
+            availableFeatures.push('behavior.sorting');
+            missingCapabilities.push('sorting');
+        }
+        if (!behavior.pagination?.enabled) {
+            availableFeatures.push('behavior.pagination');
+            missingCapabilities.push('pagination');
+        }
+        if (!behavior.selection?.enabled) {
+            availableFeatures.push('behavior.selection');
+            missingCapabilities.push('selection');
+        }
+        if (!config.toolbar?.visible) {
+            availableFeatures.push('toolbar');
+            missingCapabilities.push('toolbar');
+        }
+        if (!actions.row?.enabled) {
+            availableFeatures.push('actions.row');
+            missingCapabilities.push('actions');
+        }
+        if (!actions.bulk?.enabled) {
+            availableFeatures.push('actions.bulk');
+            missingCapabilities.push('actions');
+        }
+        if (!actions.context?.enabled) {
+            availableFeatures.push('actions.context');
+            missingCapabilities.push('actions');
+        }
+        if (!config.export?.enabled) {
+            availableFeatures.push('export');
+            missingCapabilities.push('export');
+        }
+        if (!config.localization) {
+            availableFeatures.push('localization');
+            missingCapabilities.push('localization');
+        }
+        if (!config.messages) {
+            availableFeatures.push('messages');
+            missingCapabilities.push('messages');
+        }
+        if (!config.performance) {
+            availableFeatures.push('performance');
+            missingCapabilities.push('performance');
+        }
+        if (!config.accessibility) {
+            availableFeatures.push('accessibility');
+            missingCapabilities.push('accessibility');
+        }
+        if (!config.rowConditionalStyles || config.rowConditionalStyles.length === 0) {
+            availableFeatures.push('row-conditional-styles');
+            missingCapabilities.push('conditional');
+        }
+        return {
+            authoringContract: {
+                kind: 'praxis.table.editor',
+                usesBindings: true,
+                bindingsPaths: ['bindings.resourcePath', 'bindings.idField', 'bindings.horizontalScroll'],
+                runtimeConfigProjection: 'TableConfig',
+            },
+            availableFeatures,
+            missingCapabilities: Array.from(new Set(missingCapabilities)),
+            inputs: {
+                resourcePath: this.table.resourcePath || null,
+                idField: this.table.getIdField?.() || null,
+                horizontalScroll: this.table.horizontalScroll || null,
+            },
+        };
+    }
+    getDataProfile() {
+        const data = this.table.dataSource.data || [];
+        return TableDataProfiler.profile(data, this.table.config);
+    }
+    getSchemaFields() {
+        try {
+            return this.table.getSchemaFieldsSnapshot();
+        }
+        catch {
+            return [];
+        }
+    }
+    createSnapshot() {
+        return this.getCurrentConfig();
+    }
+    async restoreSnapshot(snapshot) {
+        if (!snapshot)
+            return;
+        this.applyConfig(snapshot);
+    }
+    async applyPatch(patch, intent) {
+        const current = this.getCurrentConfig();
+        const normalizedPatch = this.normalizePatch(patch);
+        const nextConfig = this.smartMergeTableConfig(current, normalizedPatch);
+        this.applyConfig(nextConfig);
+        return { success: true };
+    }
+    // -------- Context & suggestions --------
+    /**
+     * Human-friendly summary for prompt/context (columns + feature flags + data stats).
+     */
+    getContextDescription(contextOverride) {
+        // 1. Generate Data Profile
+        const data = this.table.dataSource.data || [];
+        const effectiveConfig = contextOverride ? deepMerge(this.table.config, contextOverride) : this.table.config;
+        const profile = TableDataProfiler.profile(data, effectiveConfig);
+        // 2. Format Column Stats
+        const colDetails = Object.values(profile.columns).map(stats => {
+            let desc = `${stats.field} (${stats.inferredType})`;
+            if (stats.cardinality > 0 && stats.cardinality < 10) {
+                desc += `, values=[${stats.topValues.join(', ')}]`;
+            }
+            else if (stats.inferredType === 'number' && stats.min !== undefined) {
+                desc += `, range=[${stats.min}-${stats.max}]`;
+            }
+            // Check existing config to see if it has renderer/format
+            const colCfg = effectiveConfig.columns?.find(c => c.field === stats.field);
+            if (colCfg?.renderer)
+                desc += ` [has-renderer: ${colCfg.renderer.type}]`;
+            if (colCfg?.format)
+                desc += ` [has-format]`;
+            return desc;
+        });
+        // 3. Active Features
+        const behaviorFlags = [];
+        const b = this.table.config?.behavior;
+        if (b?.filtering?.enabled)
+            behaviorFlags.push('filtering');
+        if (b?.sorting?.enabled)
+            behaviorFlags.push('sorting');
+        if (b?.pagination?.enabled)
+            behaviorFlags.push('pagination');
+        if (b?.selection?.enabled)
+            behaviorFlags.push('selection');
+        return `
+Dataset: ${profile.rowCount} rows.
+Active Features: ${behaviorFlags.join(', ') || 'None'}.
+Columns Analysis:
+- ${colDetails.join('\n- ')}
+    `.trim();
+    }
+    /**
+     * Dynamic suggestions based on current config/data.
+     * Uses AI Service if available, otherwise falls back to heuristics.
+     */
+    async getSuggestions(forceReload = false) {
+        const storage = this.table?.asyncConfigStorage;
+        const key = this.suggestionsKey();
+        // 1. Try cache
+        if (storage && !forceReload) {
+            try {
+                const cached = await firstValueFrom(storage.loadConfig(key));
+                if (cached && Array.isArray(cached) && cached.length) {
+                    return cached;
+                }
+            }
+            catch { }
+        }
+        let suggestions = [];
+        // 2. Clear cache explicitly when forcing reload
+        if (forceReload && storage && typeof storage.clearConfig === 'function') {
+            try {
+                await firstValueFrom(storage.clearConfig(key));
+            }
+            catch { }
+        }
+        // 3. Try AI Generation (if service available)
+        if (this.aiService) {
+            try {
+                const filtered = this.filterCompletedColumnsFromContext();
+                suggestions = await this.generateAiSuggestions(filtered);
+            }
+            catch (err) {
+                console.warn('[TableAiAdapter] AI suggestion failed, falling back to heuristics', err);
+            }
+        }
+        // 4. Fallback to Heuristics if AI failed or not available
+        if (!suggestions.length) {
+            suggestions = this.getHeuristicSuggestions();
+        }
+        // 5. Save to cache
+        const sorted = suggestions.sort((a, b) => (b.score || 0) - (a.score || 0));
+        if (storage && sorted.length > 0) {
+            try {
+                await firstValueFrom(storage.saveConfig(key, sorted));
+            }
+            catch { }
+        }
+        return sorted;
+    }
+    async generateAiSuggestions(contextOverride) {
+        if (!this.aiService)
+            return [];
+        const prompt = `
+      Analyze the following data table context and stats.
+      Suggest 3 to 5 specific UX/UI improvements based on the data distribution and active features.
+      
+      Guidelines for Suggestions:
+      - Focus on: Data formatting (dates/currency), Visual indicators (badges/icons for low-cardinality or mapped fields), Filter types, and missing critical features (pagination/export).
+      - Prefer explicit metadata (column types, value mappings, data stats). Avoid guessing semantics from field names.
+      - Intents MUST be actionable user commands, not just labels.
+      
+      Intent Examples:
+      [GOOD]: "Format column 'birthDate' as dd/MM/yyyy", "Use badges for column 'state' (3 distinct values)", "Enable pagination with 10 rows".
+      [BAD]: "Improve formatting", "Add badges", "Pagination settings".
+
+      Context:
+      ${this.getContextDescription(contextOverride)}
+      
+      Return a JSON array of suggestions with: id, label, description, icon, group, intent (the actionable command), and score (0-1).
+    `;
+        const result = await firstValueFrom(this.aiService.generateJson(prompt, undefined, {
+            type: 'OBJECT',
+            properties: {
+                suggestions: {
+                    type: 'ARRAY',
+                    items: {
+                        type: 'OBJECT',
+                        properties: {
+                            id: { type: 'STRING' },
+                            label: { type: 'STRING' },
+                            description: { type: 'STRING' },
+                            icon: { type: 'STRING' },
+                            group: { type: 'STRING' },
+                            intent: { type: 'STRING' },
+                            score: { type: 'NUMBER' }
+                        },
+                        required: ['id', 'label', 'intent']
+                    }
+                }
+            }
+        }));
+        return result?.suggestions || [];
+    }
+    getHeuristicSuggestions() {
+        const suggestions = [];
+        const config = this.table.config;
+        const data = this.table.dataSource.data || [];
+        const columns = config.columns || [];
+        const profile = TableDataProfiler.profile(data, config);
+        const profileColumns = profile.columns || {};
+        const capabilities = this.getCapabilities?.() || [];
+        const categorySet = new Set(capabilities
+            .map((cap) => String(cap?.category || '').toLowerCase())
+            .filter((cat) => cat.length > 0));
+        const allowCategory = (categories) => {
+            if (!categorySet.size)
+                return false;
+            return categories.some((cat) => categorySet.has(cat));
+        };
+        // Pagination if many rows and disabled
+        if (allowCategory(['pagination', 'behavior']) && !config.behavior?.pagination?.enabled && data.length > 20) {
+            suggestions.push({
+                id: 'enable-paging',
+                label: 'Habilitar Paginação',
+                description: `Tabela tem ${data.length} linhas. Paginação melhora a performance.`,
+                icon: 'list_alt',
+                group: 'Performance',
+                intent: 'Habilitar paginação com 10 itens por página',
+                score: 0.9
+            });
+        }
+        // Modo compacto se muitas colunas visíveis
+        const visibleCols = columns.filter((c) => c.visible !== false).length;
+        if (allowCategory(['appearance']) && visibleCols > 8 && config.appearance?.density !== 'compact') {
+            suggestions.push({
+                id: 'compact-mode',
+                label: 'Modo Compacto',
+                description: 'Muitas colunas visíveis. Modo compacto exibe mais dados.',
+                icon: 'compress',
+                group: 'Visual',
+                intent: 'Usar densidade compacta',
+                score: 0.8
+            });
+        }
+        // Badge/Icon para valores discretos
+        const badgeCardinalityMax = 6;
+        const badgeCol = columns.find((col) => {
+            if (!col || col.renderer || !col.field)
+                return false;
+            const stats = profileColumns[col.field];
+            const inferredType = stats?.inferredType;
+            const cardinality = stats?.cardinality ?? -1;
+            const isLongText = stats?.isLongText ?? false;
+            const hasValueMapping = !!col.valueMapping && Object.keys(col.valueMapping).length > 0;
+            const typeMatch = col.type === 'boolean'
+                || col.type === 'string'
+                || inferredType === 'boolean'
+                || inferredType === 'string';
+            const lowCardinality = cardinality > 0 && cardinality <= badgeCardinalityMax;
+            return !isLongText && (hasValueMapping || (typeMatch && lowCardinality));
+        });
+        if (allowCategory(['renderer', 'columns']) && badgeCol) {
+            suggestions.push({
+                id: 'status-badge',
+                label: `Badges para ${badgeCol.header || badgeCol.field}`,
+                description: 'Destacar valores com badges ou ícones.',
+                icon: 'verified',
+                group: 'Visual',
+                intent: `Usar renderer badge para a coluna ${badgeCol.field}`,
+                score: 0.7
+            });
+        }
+        // Datas sem format
+        const dateCol = columns.find((c) => c.type === 'date' && !c.format);
+        if (allowCategory(['format', 'columns']) && dateCol) {
+            suggestions.push({
+                id: 'date-format',
+                label: `Formatar ${dateCol.header || dateCol.field}`,
+                description: 'Padronizar exibição de data.',
+                icon: 'calendar_today',
+                group: 'Formatação',
+                intent: `Formatar coluna ${dateCol.field} como dd/MM/yyyy`,
+                score: 0.6
+            });
+        }
+        return suggestions;
+    }
+    /**
+     * Remove colunas já formatadas/tipadas para evitar sugestões redundantes (ex.: salário já em currency)
+     */
+    filterCompletedColumnsFromContext() {
+        const cfg = this.getCurrentConfig();
+        const filteredCols = (cfg.columns || []).filter((col) => {
+            // Keep if missing type or format (needs suggestion)
+            if (!col.type)
+                return true;
+            if (col.type === 'currency' && col.format)
+                return false;
+            if (col.type === 'date' && col.format)
+                return false;
+            return true;
+        });
+        return { ...cfg, columns: filteredCols };
+    }
+    // -------- Two-step flow helpers --------
+    getFilteredCapabilities(category) {
+        const all = TABLE_AI_CAPABILITIES.capabilities;
+        if (!category || category === 'unknown')
+            return all;
+        const categoryMap = {
+            columns: ['columns', 'format', 'mapping', 'renderer', 'conditional'],
+            appearance: ['appearance', 'conditional'],
+            conditional: ['conditional', 'renderer', 'columns'], // Include 'columns' to allow field context
+            behavior: ['behavior', 'pagination', 'sorting', 'filtering', 'selection', 'interaction'],
+            actions: ['actions', 'toolbar', 'export']
+        };
+        const targets = categoryMap[category] || [category];
+        return all.filter((c) => targets.includes(c.category));
+    }
+    suggestionsKey() {
+        const id = this.table.tableId || 'default';
+        const rp = this.table.resourcePath || 'default';
+        // bump version to invalidate old cached suggestions
+        return `ai-suggestions:v3:${id}:${rp}`;
+    }
+    getColumnNames() {
+        return (this.table.config?.columns || [])
+            .map((c) => c.field)
+            .filter((f) => !!f);
+    }
+    extractContextForIntent(intent) {
+        const fullConfig = this.getCurrentConfig();
+        if ((intent.category === 'columns' || intent.category === 'conditional') && intent.targetField) {
+            const col = fullConfig.columns?.find((c) => c.field === intent.targetField);
+            if (col) {
+                return { desc: `Contexto focado na coluna '${intent.targetField}'.`, config: { columns: [col] } };
+            }
+        }
+        if (intent.category === 'behavior' && fullConfig.behavior) {
+            return { desc: 'Contexto focado em Comportamento (pagination/sorting/filtering/selection).', config: { behavior: fullConfig.behavior } };
+        }
+        if (intent.category === 'appearance' && fullConfig.appearance) {
+            return { desc: 'Contexto focado em Aparência.', config: { appearance: fullConfig.appearance } };
+        }
+        if (intent.category === 'actions' && (fullConfig.actions || fullConfig.toolbar)) {
+            return { desc: 'Contexto focado em Ações e Toolbar.', config: { actions: fullConfig.actions, toolbar: fullConfig.toolbar } };
+        }
+        return { desc: 'Contexto completo da tabela.', config: fullConfig };
+    }
+    /**
+     * Two-step flow: classify intent, build focused context, call enriched prompt.
+     * Returns the patch WITHOUT applying, so the UI can review.
+     */
+    async processUserIntent(userInput, aiService // Use interface type
+    ) {
+        const classification = await firstValueFrom(aiService.classifyIntent(userInput, this.getColumnNames()));
+        if (classification?.needsClarification) {
+            return {
+                type: 'clarification',
+                message: 'Preciso de mais detalhes para continuar.',
+                options: classification.options || []
+            };
+        }
+        // Handle QA intent
+        if (classification?.intent === 'ask_about_config') {
+            const answer = await firstValueFrom(aiService.answerQuestion(userInput, this.getCurrentConfig()));
+            return {
+                type: 'info',
+                message: answer,
+                explanation: answer // Map to explanation for UI compatibility if needed, or UI should handle 'info' type
+            };
+        }
+        const context = this.extractContextForIntent(classification);
+        const caps = this.getFilteredCapabilities(classification?.category);
+        const result = await firstValueFrom(aiService.executeEnrichedPrompt(userInput, context.desc, context.config, caps));
+        if (!result || !result.patch) {
+            return { type: 'error', message: 'Nenhum patch gerado.' };
+        }
+        const { sanitized, warnings } = this.validateAndSanitizePatch(result.patch, caps);
+        // Passar warnings para o retorno, para que o UI possa mostrá-los
+        // Se o patch estiver vazio após sanitização, informar ao usuário
+        // Se sobrou algo válido
+        if (Object.keys(sanitized).length > 0) {
+            const explanation = result.explanation + (warnings.length ? ` (Ajustado: ${warnings.length} itens inválidos removidos)` : '');
+            return { patch: sanitized, explanation, warnings };
+        }
+        else {
+            return { type: 'error', message: 'O patch gerado não continha configurações válidas permitidas.', warnings };
+        }
+    }
+    validateAndSanitizePatch(patch, allowedCaps) {
+        const allowedPaths = new Set(allowedCaps.map(c => c.path));
+        const warnings = [];
+        // Some schema-driven nodes are intentionally open objects and must be preserved as-is.
+        const passthroughObjectPaths = new Set([
+            'behavior.expansion.detail.source.inlineSchema',
+            'behavior.expansion.detail.source.resourcePath.paramsMap',
+        ]);
+        const recurse = (obj, currentPath) => {
+            if (typeof obj !== 'object' || obj === null)
+                return obj;
+            if (Array.isArray(obj)) {
+                // Se estamos em um array conhecido (ex: columns), o path vira columns[]
+                // Se não, assume que é valor final (ex: options: [1,2])
+                const isRootArray = currentPath && (allowedPaths.has(currentPath + '[]') || Array.from(allowedPaths).some(p => p.startsWith(currentPath + '[].')));
+                if (!isRootArray)
+                    return obj; // É um valor array (ex: tags), retorna direto
+                return obj.map(item => recurse(item, currentPath + '[]'));
+            }
+            const cleanObj = {};
+            for (const key of Object.keys(obj)) {
+                const newPath = currentPath ? `${currentPath}.${key}` : key;
+                // Verifica se este path exato é permitido OU se é um prefixo de algo permitido
+                // Ex: 'columns' é permitido se 'columns[].width' existe
+                // Special case: 'columns[].field' is identity, always allow it if we are inside columns[]
+                const isIdentityField = currentPath === 'columns[]' && key === 'field';
+                const exactMatch = allowedPaths.has(newPath) || isIdentityField;
+                const prefixMatch = Array.from(allowedPaths).some(p => p.startsWith(newPath + '.') || p.startsWith(newPath + '['));
+                if (exactMatch || prefixMatch) {
+                    if (exactMatch
+                        && passthroughObjectPaths.has(newPath)
+                        && typeof obj[key] === 'object'
+                        && obj[key] !== null) {
+                        cleanObj[key] = obj[key];
+                        continue;
+                    }
+                    const val = recurse(obj[key], newPath);
+                    if (newPath === 'columns[].computed.expression') {
+                        if (typeof val !== 'string') {
+                            warnings.push(`Computed expression inválida: ${newPath} (não é string)`);
+                            continue;
+                        }
+                        const trimmed = val.trim();
+                        if (!trimmed) {
+                            warnings.push(`Computed expression vazia: ${newPath}`);
+                            continue;
+                        }
+                        if (trimmed.length > 200) {
+                            warnings.push(`Computed expression muito longa: ${newPath}`);
+                            continue;
+                        }
+                        cleanObj[key] = trimmed;
+                        continue;
+                    }
+                    // Se for objeto vazio após limpeza, não inclui (salvo se for intenção explicita de limpar config, mas patch geralmente é aditivo)
+                    if (typeof val === 'object' && val !== null && !Array.isArray(val) && Object.keys(val).length === 0) {
+                        // ignora
+                    }
+                    else {
+                        cleanObj[key] = val;
+                    }
+                }
+                else {
+                    warnings.push(`Campo ignorado: ${newPath}`);
+                }
+            }
+            return cleanObj;
+        };
+        const sanitized = recurse(patch, '');
+        return { sanitized, warnings };
+    }
+    // -------- Internal helpers --------
+    /**
+     * Specialized merge for TableConfig that handles Array reconciliation safely.
+     * - 'columns': merges by 'field' ID.
+     */
+    smartMergeTableConfig(base, patch) {
+        const result = deepMerge(base, patch);
+        if (patch.columns && Array.isArray(patch.columns)) {
+            const originalCols = base.columns || [];
+            const patchCols = patch.columns;
+            const mergedCols = originalCols.map((origCol) => {
+                const match = patchCols.find((p) => p.field === origCol.field);
+                return match ? deepMerge(origCol, match) : origCol;
+            });
+            patchCols.forEach((pCol) => {
+                if (!originalCols.find((o) => o.field === pCol.field)) {
+                    mergedCols.push(pCol);
+                }
+            });
+            result.columns = mergedCols;
+        }
+        return result;
+    }
+    applyConfig(config) {
+        const prev = this.table.config;
+        this.table.config = config;
+        this.table.ngOnChanges({
+            config: {
+                previousValue: prev,
+                currentValue: config,
+                firstChange: false,
+                isFirstChange: () => false
+            }
+        });
+    }
+    /**
+     * If a patch adds only a currency format, ensure the column type is set to 'currency'
+     * so the formatter runs. Avoid overriding an explicit non-currency type.
+     */
+    normalizePatch(patch) {
+        if (!patch.columns || !Array.isArray(patch.columns))
+            return patch;
+        const cols = patch.columns.map((col) => this.normalizeColumn(col));
+        return { ...patch, columns: cols };
+    }
+    looksLikeCurrencyFormat(format) {
+        if (!format)
+            return false;
+        const fmt = format.trim();
+        return /^[A-Z]{3}(\|.*)?$/.test(fmt);
+    }
+    looksLikeDateFormat(format) {
+        if (!format)
+            return false;
+        const fmt = format.trim();
+        // Heuristics: contains date tokens like d/M/y or common date separators
+        return /(d|M|y){2,}/i.test(fmt) || fmt.includes('/') || fmt.includes('-');
+    }
+    isIconRendererHint(renderer) {
+        if (!renderer)
+            return false;
+        if (renderer.type && renderer.type !== 'icon')
+            return false;
+        const icon = renderer.icon || renderer.name || renderer.iconName;
+        return typeof icon === 'string' || typeof renderer.color === 'string' || typeof renderer.size === 'number';
+    }
+    normalizeColumn(col) {
+        if (!col)
+            return col;
+        const next = { ...col };
+        // Normalize formats
+        if (next.format && !next.type) {
+            if (this.looksLikeCurrencyFormat(next.format)) {
+                next.type = 'currency';
+            }
+            else if (this.looksLikeDateFormat(next.format)) {
+                next.type = 'date';
+            }
+        }
+        // Normalize renderer structure (icon shorthand)
+        if (next.renderer) {
+            next.renderer = this.normalizeRenderer(next.renderer);
+        }
+        // Normalize conditional renderers
+        if (Array.isArray(next.conditionalRenderers)) {
+            next.conditionalRenderers = next.conditionalRenderers.map((r) => {
+                if (!r)
+                    return r;
+                const out = { ...r };
+                if (out.renderer)
+                    out.renderer = this.normalizeRenderer(out.renderer);
+                return out;
+            });
+        }
+        return next;
+    }
+    normalizeRenderer(renderer) {
+        if (!renderer)
+            return renderer;
+        const out = { ...renderer };
+        if (out.type === 'icon') {
+            // Move icon shorthand to renderer.icon.*
+            const iconObj = { ...(out.icon || {}) };
+            if (renderer.icon && typeof renderer.icon === 'string')
+                iconObj.name = renderer.icon;
+            if (renderer.icon?.name)
+                iconObj.name = renderer.icon.name;
+            if (renderer.icon?.color)
+                iconObj.color = renderer.icon.color;
+            if (renderer.icon?.size)
+                iconObj.size = renderer.icon.size;
+            if (renderer.color && !iconObj.color)
+                iconObj.color = renderer.color;
+            if (renderer.size && !iconObj.size)
+                iconObj.size = renderer.size;
+            out.icon = iconObj;
+            delete out.color;
+            delete out.size;
+        }
+        // Badge shorthand (allow badge.color/variant/icon/text via renderer.badge or root)
+        if (out.type === 'badge') {
+            const badge = { ...(out.badge || {}) };
+            if (renderer.color && !badge.color)
+                badge.color = renderer.color;
+            if (renderer.variant && !badge.variant)
+                badge.variant = renderer.variant;
+            if (renderer.text && !badge.text)
+                badge.text = renderer.text;
+            if (renderer.icon && !badge.icon && typeof renderer.icon === 'string')
+                badge.icon = renderer.icon;
+            out.badge = badge;
+            delete out.color;
+            delete out.variant;
+            delete out.text;
+            if (typeof out.icon === 'string')
+                delete out.icon;
+        }
+        // Chip shorthand
+        if (out.type === 'chip') {
+            const chip = { ...(out.chip || {}) };
+            if (renderer.color && !chip.color)
+                chip.color = renderer.color;
+            if (renderer.variant && !chip.variant)
+                chip.variant = renderer.variant;
+            if (renderer.text && !chip.text)
+                chip.text = renderer.text;
+            if (renderer.icon && !chip.icon && typeof renderer.icon === 'string')
+                chip.icon = renderer.icon;
+            out.chip = chip;
+            delete out.color;
+            delete out.variant;
+            delete out.text;
+            if (typeof out.icon === 'string')
+                delete out.icon;
+        }
+        // Link shorthand
+        if (out.type === 'link' && typeof renderer.href === 'string') {
+            out.link = { ...(out.link || {}), href: renderer.href };
+            delete out.href;
+        }
+        return out;
+    }
+}
+
+export { TableAiAdapter };
+//# sourceMappingURL=praxisui-table-table-ai.adapter-C5rjLb8E.mjs.map