@praxisui/table 8.0.0-beta.100 → 8.0.0-beta.102

package/fesm2022/{praxisui-table-praxisui-table-MXizgJYx.mjs → praxisui-table-praxisui-table-DDUl1Vav.mjs}

@@ -80,7 +80,7 @@ import { A11yModule } from '@angular/cdk/a11y';
 import * as i6$2 from '@angular/router';
 import * as i11$1 from '@angular/cdk/scrolling';
 import { ScrollingModule } from '@angular/cdk/scrolling';
-import { sanitizePraxisAssistantText, createPraxisAssistantViewportLayout, AiBackendApiService, PraxisAssistantSessionRegistryService, PraxisAssistantTurnOrchestratorService, PraxisAiAssistantShellComponent } from '@praxisui/ai';
+import { sanitizePraxisAssistantText, createPraxisAssistantViewportLayout, AiBackendApiService, AgenticAuthoringTurnClientService, PraxisAssistantSessionRegistryService, PraxisAssistantTurnOrchestratorService, PraxisAiAssistantShellComponent } from '@praxisui/ai';
 import * as i6$3 from '@praxisui/dialog';
 
 const PRAXIS_TABLE_RUNTIME_I18N_NAMESPACE = 'praxisTableRuntime';
@@ -39318,6 +39318,7 @@ class PraxisTable {
     aiAssistantController = null;
     aiAssistantStateSubscription = null;
     aiApi = inject(AiBackendApiService);
+    agenticTurnClient = inject(AgenticAuthoringTurnClientService);
     assistantSessions = inject(PraxisAssistantSessionRegistryService);
     aiTurnOrchestrator = inject(PraxisAssistantTurnOrchestratorService);
     aiAssistantSessionEffect = effect(() => {
@@ -39947,7 +39948,7 @@ class PraxisTable {
         if (this.aiAdapter || this.aiAdapterLoadStarted)
             return;
         this.aiAdapterLoadStarted = true;
-        import('./praxisui-table-table-ai.adapter-DFyMRt4g.mjs')
+        import('./praxisui-table-table-ai.adapter-D1VAQO63.mjs')
             .then(({ TableAiAdapter }) => {
             this.aiAdapter = new TableAiAdapter(this);
             this.initializeAiAssistantController();
@@ -40087,20 +40088,32 @@ class PraxisTable {
         if (!controller)
             return;
         const state = controller.snapshot();
-        const contextHints = reply.contextHints ? { ...reply.contextHints } : undefined;
-        const actionValue = reply.value ?? reply.prompt;
+        const visualPresentationPrompt = this.resolveAiAssistantVisualPresentationQuickReplyPrompt(reply, state);
+        const visualPresentationContextHints = visualPresentationPrompt
+            ? this.resolveAiAssistantVisualPresentationQuickReplyContextHints(reply, state)
+            : null;
+        const contextHints = this.mergeAiAssistantQuickReplyContextHints(reply.contextHints, visualPresentationContextHints);
+        const semanticPrompt = typeof reply.prompt === 'string' && reply.prompt.trim()
+            ? reply.prompt.trim()
+            : '';
+        const semanticValue = visualPresentationPrompt
+            || semanticPrompt
+            || (typeof reply.value === 'string' && reply.value.trim() ? reply.value.trim() : '')
+            || reply.label;
+        const actionValue = reply.value ?? semanticValue;
         const next$ = state.state === 'clarification'
             ? controller.answerClarification({
                 id: reply.id,
                 label: reply.label,
-                value: typeof reply.value === 'string' && reply.value.trim() ? reply.value.trim() : reply.prompt,
+                value: semanticValue,
+                displayPrompt: reply.label,
                 description: reply.description ?? undefined,
                 contextHints,
             })
-            : controller.submitPrompt(reply.prompt, {
+            : controller.submitPrompt(semanticValue, {
                 kind: reply.kind || 'quick-reply',
                 id: reply.id,
-                value: actionValue,
+                value: semanticValue || actionValue,
                 displayPrompt: reply.label,
                 contextHints,
             });
@@ -40111,6 +40124,105 @@ class PraxisTable {
             this.cdr.markForCheck();
         });
     }
+    mergeAiAssistantQuickReplyContextHints(base, generated) {
+        const baseRecord = this.asPlainRecord(base);
+        if (!baseRecord && !generated)
+            return undefined;
+        return {
+            ...(baseRecord ?? {}),
+            ...(generated ?? {}),
+        };
+    }
+    resolveAiAssistantVisualPresentationQuickReplyPrompt(reply, state) {
+        const renderer = this.resolveAiAssistantVisualPresentationRenderer(reply);
+        if (!renderer)
+            return null;
+        const field = this.resolveAiAssistantVisualPresentationTargetField(reply, state);
+        return field
+            ? `Aplique a apresentacao visual ${renderer} na coluna ${field}.`
+            : `Aplique a apresentacao visual ${renderer}.`;
+    }
+    resolveAiAssistantVisualPresentationQuickReplyContextHints(reply, state) {
+        const renderer = this.resolveAiAssistantVisualPresentationRenderer(reply);
+        if (!renderer)
+            return null;
+        const field = this.resolveAiAssistantVisualPresentationTargetField(reply, state);
+        const selected = {
+            selection: {
+                mode: 'renderer',
+                ...(field ? { field } : {}),
+                value: renderer,
+            },
+        };
+        if (field) {
+            selected['targetField'] = field;
+        }
+        return {
+            optionSelected: selected,
+            presentation: {
+                kind: 'guided-option',
+                ctaLabel: 'Aplicar opção',
+                icon: renderer === 'two_lines' ? 'format_line_spacing' : 'check',
+                tone: 'primary',
+            },
+        };
+    }
+    resolveAiAssistantVisualPresentationRenderer(reply) {
+        const raw = [
+            typeof reply.value === 'string' ? reply.value : '',
+            reply.prompt,
+            reply.label,
+        ].filter(Boolean).join(' ');
+        const normalized = this.normalizeFieldAlias(raw);
+        if (!normalized)
+            return null;
+        if (normalized.includes('two lines')
+            || normalized.includes('two line')
+            || normalized.includes('two-line')
+            || normalized.includes('twolines')
+            || normalized.includes('twoline')
+            || normalized.includes('duas linhas')
+            || normalized.includes('duaslinhas')
+            || normalized.includes('duas_linhas')
+            || normalized.includes('segunda linha')
+            || normalized.includes('segundalinha')) {
+            return 'two_lines';
+        }
+        if (normalized.includes('badge'))
+            return 'badge';
+        if (normalized.includes('icon') || normalized.includes('icone'))
+            return 'icon';
+        if (normalized.includes('alignment') || normalized.includes('alinhamento'))
+            return 'alignment';
+        return null;
+    }
+    resolveAiAssistantVisualPresentationTargetField(reply, state) {
+        const contextHints = this.asPlainRecord(reply.contextHints);
+        const optionSelected = this.asPlainRecord(contextHints?.['optionSelected']);
+        const selection = this.asPlainRecord(optionSelected?.['selection']);
+        const hintedField = typeof selection?.['field'] === 'string' ? selection['field'].trim() : '';
+        if (hintedField)
+            return hintedField;
+        const sourcePrompt = state.pendingClarification?.sourcePrompt ?? '';
+        const normalizedSource = this.normalizeFieldAlias(sourcePrompt);
+        const columns = this.config?.columns ?? this.visibleColumns ?? [];
+        const matched = columns
+            .map((column) => {
+            const field = column?.field?.trim();
+            if (!field)
+                return null;
+            const header = column.header?.trim() || field;
+            const score = Math.max(this.aiAssistantVisualPresentationTargetScore(normalizedSource, field), this.aiAssistantVisualPresentationTargetScore(normalizedSource, header));
+            return score > 0 ? { field, score } : null;
+        })
+            .filter((entry) => !!entry)
+            .sort((a, b) => b.score - a.score)[0];
+        return matched?.field || null;
+    }
+    aiAssistantVisualPresentationTargetScore(normalizedSource, value) {
+        const normalized = this.normalizeFieldAlias(value);
+        return normalized && normalizedSource.includes(normalized) ? normalized.length : 0;
+    }
     getAiAssistantRecommendedIntents() {
         const locale = this.assistantContextRuntimeLocale();
         const intents = [];
@@ -40566,11 +40678,11 @@ class PraxisTable {
     initializeAiAssistantController() {
         if (!this.aiAdapter || this.aiAssistantController)
             return;
-        import('./praxisui-table-table-agentic-authoring-turn-flow-BJWah3jp.mjs')
+        import('./praxisui-table-table-agentic-authoring-turn-flow-CC5bOKf5.mjs')
             .then(({ TableAgenticAuthoringTurnFlow }) => {
             if (this.aiAssistantController || !this.aiAdapter)
                 return;
-            const flow = new TableAgenticAuthoringTurnFlow(this.aiAdapter, this.aiApi);
+            const flow = new TableAgenticAuthoringTurnFlow(this.aiAdapter, this.aiApi, this.agenticTurnClient);
             const controller = this.aiTurnOrchestrator.createController(flow, {
                 componentId: this.aiAdapter.componentId || 'praxis-table',
                 componentType: this.aiAdapter.componentType || 'table',
@@ -49694,14 +49806,32 @@ class PraxisTable {
         const size = this.evaluateValueExpr(raw, _row, 'number');
         return size ? { fontSize: `${size}px`, width: `${size}px`, height: `${size}px` } : null;
     }
-    getIconAriaLabel(_row, column) {
-        return this.getEffectiveRenderer(_row, column)?.icon?.ariaLabel || null;
+    getIconAriaLabel(row, column) {
+        const cfg = this.getEffectiveRenderer(row, column)?.icon;
+        if (!cfg)
+            return null;
+        const configured = cfg.ariaLabel;
+        const evaluated = this.evaluateValueExpr(configured, row, 'string');
+        if (evaluated != null && evaluated !== '')
+            return String(evaluated);
+        if (typeof configured === 'string' && configured.trim())
+            return configured;
+        return this.getIconText(row, column);
+    }
+    getIconText(row, column) {
+        const cfg = this.getEffectiveRenderer(row, column)?.icon;
+        if (!cfg)
+            return null;
+        const text = Object.prototype.hasOwnProperty.call(cfg, 'text')
+            ? cfg.text
+            : cfg.textField ? this.getRendererTextFieldValue(row, column, cfg.textField) : null;
+        return text != null ? String(text) : null;
     }
     getIconRichContentNodes(row, column) {
         const icon = this.getIconName(row, column);
         if (!icon)
             return [];
-        return [
+        const nodes = [
             {
                 type: 'icon',
                 icon,
@@ -49709,6 +49839,15 @@ class PraxisTable {
                 className: 'pfx-icon-renderer__icon',
             },
         ];
+        const text = this.getIconText(row, column);
+        if (text) {
+            nodes.push({
+                type: 'text',
+                text,
+                className: 'pfx-icon-renderer__label',
+            });
+        }
+        return nodes;
     }
     /**
      * Lightweight, controlled evaluator for string/number expressions using row context.
@@ -50304,7 +50443,18 @@ class PraxisTable {
         const field = this.getComposeItemField(item);
         if (!field)
             return this.getCellValue(row, base);
-        return this.getCellValue(row, { ...base, field });
+        return this.getCellValue(row, this.asComposeValueItemColumn(base, field));
+    }
+    asComposeValueItemColumn(base, field) {
+        const itemColumn = { ...base, field };
+        if (field !== base.field) {
+            delete itemColumn.computed;
+            delete itemColumn._generatedValueGetter;
+            delete itemColumn.expression;
+            delete itemColumn.formula;
+            delete itemColumn.calculated;
+        }
+        return itemColumn;
     }
     asItemColumn(base, item) {
         // Create a lightweight faux column reusing helpers by type
@@ -50335,9 +50485,9 @@ class PraxisTable {
             r.rating = item.rating;
         if (item?.compose)
             r.compose = item.compose;
+        const field = this.getComposeItemField(item) || base.field;
         return {
-            ...base,
-            field: this.getComposeItemField(item) || base.field,
+            ...this.asComposeValueItemColumn(base, field),
             header: base.header,
             renderer: r,
             conditionalRenderers: undefined,
@@ -55671,6 +55821,103 @@ const PRAXIS_TABLE_AUTHORING_MANIFEST = {
         'maintain-renderer-precedence',
         'preserve-meta-ids'
     ],
+    presentationAffordances: {
+        version: '0.1.0',
+        componentId: 'praxis-table',
+        defaultTargetKind: 'column',
+        sourceRef: 'praxis-ui-angular:projects/praxis-table/src/lib/ai/praxis-table-authoring-manifest.ts#presentationAffordances',
+        affordances: [
+            {
+                id: 'table.column.text-formatting',
+                targetKind: 'column',
+                category: 'format',
+                description: 'Text transforms and masks for textual table columns.',
+                options: [
+                    'none',
+                    'uppercase',
+                    'lowercase',
+                    'titlecase',
+                    'capitalize',
+                    'uppercase|truncate|50|...',
+                    '000.000.000-00'
+                ],
+                appliesToTypes: ['string', 'text', 'unknown'],
+                unknownCompatible: true
+            },
+            {
+                id: 'table.column.numeric-formatting',
+                targetKind: 'column',
+                category: 'format',
+                description: 'Decimal, currency and percentage formats for numeric table columns.',
+                options: [
+                    '1.0-0',
+                    '1.1-1',
+                    '1.2-2',
+                    '1.0-3',
+                    '1.0-0|nosep',
+                    'BRL|symbol|2',
+                    'USD|symbol|2',
+                    'EUR|symbol|2',
+                    'BRL|code|2',
+                    'USD|code|0',
+                    'BRL|symbol|2|nosep',
+                    'EUR|symbol|2|nosep',
+                    '1.0-0|x100',
+                    '1.1-1|x100',
+                    '1.2-2|x100'
+                ],
+                appliesToTypes: ['number', 'currency', 'percentage'],
+                unknownCompatible: false
+            },
+            {
+                id: 'table.column.date-formatting',
+                targetKind: 'column',
+                category: 'format',
+                description: 'Date and time formats for date-like table columns.',
+                options: [
+                    'shortDate',
+                    'mediumDate',
+                    'longDate',
+                    'fullDate',
+                    'MMM/yyyy',
+                    'shortTime',
+                    'short',
+                    'yyyy-MM-dd',
+                    'dd/MM/yyyy',
+                    'yyyy-MM-dd HH:mm'
+                ],
+                appliesToTypes: ['date', 'datetime', 'time'],
+                unknownCompatible: false
+            },
+            {
+                id: 'table.column.boolean-formatting',
+                targetKind: 'column',
+                category: 'format',
+                description: 'Boolean label formats for true/false table columns.',
+                options: ['true-false', 'yes-no', 'active-inactive', 'on-off', 'enabled-disabled', 'custom|Sim|Nao'],
+                appliesToTypes: ['boolean'],
+                unknownCompatible: false
+            },
+            {
+                id: 'table.column.semantic-renderers',
+                targetKind: 'column',
+                category: 'renderer',
+                description: 'Visual renderers for categorical, status or action-oriented table columns.',
+                options: ['badge', 'chip', 'icon', 'link', 'button', 'progress', 'avatar', 'toggle', 'menu', 'rating', 'compose'],
+                appliesToTypes: ['string', 'text', 'boolean', 'number', 'currency', 'percentage', 'date', 'datetime', 'unknown'],
+                unknownCompatible: true
+            },
+            {
+                id: 'table.column.alignment-layout',
+                targetKind: 'column',
+                category: 'layout',
+                description: 'Column alignment and composed cell layout options.',
+                options: ['align:start', 'align:center', 'align:end', 'compose:row', 'compose:column', 'secondary-line', 'prefix', 'suffix'],
+                appliesToTypes: ['string', 'text', 'boolean', 'number', 'currency', 'percentage', 'date', 'datetime', 'unknown'],
+                unknownCompatible: true
+            }
+        ]
+    },
     examples: [
         {
             id: 'add-schema-column',
@@ -57908,6 +58155,7 @@ const FORMAT_PRESETS = Array.from(new Set([
     ...FORMAT_BOOLEAN_PRESETS,
 ]));
 const RENDERER_COMPOSE_ITEM_TYPES = [
+    'value',
     'icon',
     'image',
     'badge',
@@ -60658,6 +60906,13 @@ function validateComposeRendererValue(rawCompose, originalValue) {
         if (!itemType || itemType === 'compose') {
             return { failureCodes: [`compose renderer item type is not allowed: ${itemType || '(empty)'}`] };
         }
+        if (itemType === 'value') {
+            const valueValidation = validateComposeValueItem(itemRecord);
+            if (valueValidation.failureCodes.length > 0) {
+                return valueValidation;
+            }
+            continue;
+        }
         const itemValidation = validateRendererValue(itemRecord);
         if (itemValidation.failureCodes.length > 0) {
             return itemValidation;
@@ -60665,6 +60920,15 @@ function validateComposeRendererValue(rawCompose, originalValue) {
     }
     return { value: originalValue, failureCodes: [] };
 }
+function validateComposeValueItem(item) {
+    for (const key of ['field', 'textField', 'valueField', 'text']) {
+        const value = item[key];
+        if (value !== undefined && typeof value !== 'string') {
+            return { failureCodes: [`compose value item ${key} must be a string`] };
+        }
+    }
+    return { value: item, failureCodes: [] };
+}
 function validateBadgeRendererValue(rawValue) {
     if (!rawValue || typeof rawValue !== 'object' || Array.isArray(rawValue)) {
         return { failureCodes: ['badge renderer value must be an object'] };