@praxisui/table 8.0.0-beta.30 → 8.0.0-beta.32

package/fesm2022/praxisui-table-table-agentic-authoring-turn-flow-CretQI6Z.mjs

@@ -0,0 +1,847 @@
+import { firstValueFrom } from 'rxjs';
+
+class TableAgenticAuthoringTurnFlow {
+    adapter;
+    aiApi;
+    mode = 'config';
+    filterFieldLabels = new Map();
+    constructor(adapter, aiApi) {
+        this.adapter = adapter;
+        this.aiApi = aiApi;
+    }
+    async submit(request) {
+        const prompt = (request.prompt ?? '').trim();
+        if (!prompt) {
+            return {
+                state: 'listening',
+                phase: 'capture',
+                statusText: '',
+            };
+        }
+        const componentId = this.adapter.componentId || request.componentId || 'praxis-table';
+        const componentType = this.adapter.componentType || request.componentType || 'table';
+        const currentState = this.toAiJsonObject(this.adapter.getCurrentConfig());
+        const dataProfile = this.optionalJsonObject(this.adapter.getDataProfile?.());
+        const runtimeState = this.optionalJsonObject(this.adapter.getRuntimeState?.());
+        const schemaFields = this.adapter.getSchemaFields?.()
+            ?.map((field) => this.toAiJsonObject(field))
+            .filter((field) => Object.keys(field).length > 0);
+        await this.prepareAuthoringContext();
+        const contextHints = this.mergeJsonObjects(this.optionalJsonObject(this.adapter.getAuthoringContext?.()), this.optionalJsonObject(request.action?.contextHints));
+        this.filterFieldLabels = this.extractFilterFieldLabels(contextHints ?? null);
+        const response = await firstValueFrom(this.aiApi.getPatch({
+            componentId,
+            componentType,
+            userPrompt: prompt,
+            sessionId: request.sessionId,
+            clientTurnId: request.clientTurnId,
+            messages: this.toChatMessages(request.messages, prompt),
+            currentState,
+            currentStateDigest: this.buildCurrentStateDigest(currentState, dataProfile),
+            uiContextRef: {
+                componentId,
+                componentType,
+            },
+            ...(dataProfile ? { dataProfile } : {}),
+            ...(runtimeState ? { runtimeState } : {}),
+            ...(schemaFields?.length ? { schemaFields } : {}),
+            ...(contextHints ? { contextHints } : {}),
+        }));
+        return this.toTurnResult(this.compileAdapterResponse(response), request);
+    }
+    normalizePrompt(prompt) {
+        return prompt
+            .normalize('NFD')
+            .replace(/[\u0300-\u036f]/g, '')
+            .toLowerCase()
+            .trim();
+    }
+    extractResourcePath(source) {
+        if (!source)
+            return null;
+        const direct = this.nonEmptyStringValue(source['resourcePath']);
+        if (direct)
+            return direct;
+        const consultativeContext = this.toRecord(source['consultativeContext']);
+        const fromConsultative = this.nonEmptyStringValue(consultativeContext?.['resourcePath']);
+        if (fromConsultative)
+            return fromConsultative;
+        const authoringContract = this.toRecord(source['authoringContract']);
+        if (authoringContract && authoringContract !== source) {
+            return this.extractResourcePath(authoringContract);
+        }
+        return null;
+    }
+    nonEmptyStringValue(value) {
+        return typeof value === 'string' && value.trim() ? value.trim() : null;
+    }
+    async apply(request) {
+        const patch = this.toRecord(request.pendingPatch);
+        if (!patch) {
+            return {
+                state: 'error',
+                phase: 'apply',
+                assistantMessage: 'Nao ha alteracao de tabela pronta para aplicar.',
+                errorText: 'Nao ha alteracao de tabela pronta para aplicar.',
+                canApply: false,
+            };
+        }
+        const result = await this.adapter.applyPatch(patch, request.prompt);
+        if (!result.success) {
+            return {
+                state: 'error',
+                phase: 'apply',
+                assistantMessage: result.error || 'Nao foi possivel aplicar as alteracoes na tabela.',
+                errorText: result.error || 'Nao foi possivel aplicar as alteracoes na tabela.',
+                canApply: true,
+                pendingPatch: patch,
+            };
+        }
+        return {
+            state: 'success',
+            phase: 'summarize',
+            assistantMessage: 'Alteracoes aplicadas na tabela.',
+            statusText: 'Alteracoes aplicadas na tabela.',
+            canApply: false,
+            pendingPatch: null,
+            diagnostics: result.warnings?.length ? { warnings: result.warnings } : undefined,
+        };
+    }
+    cancel() {
+        return Promise.resolve({
+            state: 'listening',
+            phase: 'capture',
+            assistantMessage: 'Solicitacao cancelada.',
+            statusText: '',
+            canApply: false,
+            pendingPatch: null,
+            pendingClarification: null,
+        });
+    }
+    retry(request) {
+        const lastPrompt = [...(request.messages ?? [])].reverse()
+            .find((message) => message.role === 'user')?.text;
+        return this.submit({
+            ...request,
+            prompt: lastPrompt ?? request.prompt,
+            action: { kind: 'retry' },
+        });
+    }
+    toTurnResult(response, request) {
+        if (!response) {
+            return {
+                state: 'error',
+                phase: 'capture',
+                assistantMessage: 'Resposta vazia da IA.',
+                errorText: 'Resposta vazia da IA.',
+            };
+        }
+        if (response.sessionId && response.sessionId !== request.sessionId) {
+            request = { ...request, sessionId: response.sessionId };
+        }
+        if (response.type === 'clarification') {
+            const questions = this.toClarificationQuestions(response);
+            return {
+                state: 'clarification',
+                phase: 'clarify',
+                sessionId: response.sessionId ?? request.sessionId,
+                assistantMessage: response.message || 'Preciso de mais detalhes para continuar.',
+                clarificationQuestions: questions,
+                quickReplies: this.toQuickReplies(response),
+                canApply: false,
+            };
+        }
+        if (response.type === 'info') {
+            const message = response.message || response.explanation || 'Informacao gerada.';
+            return {
+                state: 'success',
+                phase: 'summarize',
+                sessionId: response.sessionId ?? request.sessionId,
+                assistantMessage: message,
+                statusText: message,
+                quickReplies: this.toQuickReplies(response),
+                canApply: false,
+            };
+        }
+        if (response.type === 'error') {
+            const message = response.message || 'Falha ao gerar alteracao de tabela.';
+            return {
+                state: 'error',
+                phase: 'capture',
+                sessionId: response.sessionId ?? request.sessionId,
+                assistantMessage: message,
+                errorText: message,
+                diagnostics: response.warnings?.length ? { warnings: response.warnings } : undefined,
+            };
+        }
+        if (response.patch && Object.keys(response.patch).length > 0) {
+            const warnings = response.warnings?.filter(Boolean) ?? [];
+            const quickReplies = this.toQuickReplies(response);
+            return {
+                state: 'review',
+                phase: 'review',
+                sessionId: response.sessionId ?? request.sessionId,
+                assistantMessage: this.toReviewMessage(response),
+                statusText: 'Revise a proposta antes de aplicar.',
+                quickReplies,
+                canApply: true,
+                pendingPatch: response.patch,
+                preview: {
+                    kind: 'table-config-patch',
+                    diff: response.diff ?? [],
+                },
+                diagnostics: warnings.length ? { warnings } : undefined,
+            };
+        }
+        return {
+            state: 'success',
+            phase: 'summarize',
+            sessionId: response.sessionId ?? request.sessionId,
+            assistantMessage: response.message || response.explanation || 'Nenhuma alteracao necessaria.',
+            statusText: response.message || response.explanation || 'Nenhuma alteracao necessaria.',
+            canApply: false,
+        };
+    }
+    compileAdapterResponse(response) {
+        const compiled = this.adapter.compileAiResponse?.(response);
+        if (!compiled && response.patch && Object.keys(response.patch).length > 0) {
+            return {
+                type: 'error',
+                message: 'A tabela exige componentEditPlan validado pelo manifesto antes de gerar patch local.',
+                warnings: [
+                    'free-table-patch-rejected',
+                    'Use componentEditPlan validado contra PRAXIS_TABLE_AUTHORING_MANIFEST.',
+                ],
+            };
+        }
+        if (!compiled) {
+            return response;
+        }
+        if (compiled.type === 'error') {
+            return {
+                type: 'error',
+                message: compiled.message || 'O componentEditPlan da tabela nao passou na validacao de capacidades.',
+                warnings: compiled.warnings,
+            };
+        }
+        const warnings = [
+            ...(response.warnings ?? []),
+            ...(compiled.warnings ?? []),
+        ];
+        return {
+            ...response,
+            ...compiled,
+            patch: compiled.patch,
+            warnings: warnings.length ? warnings : undefined,
+        };
+    }
+    toReviewMessage(response) {
+        const planSummaries = this.describeComponentEditPlan(response.componentEditPlan);
+        if (planSummaries.length) {
+            return [
+                'Preparei este ajuste para revisao:',
+                '',
+                ...planSummaries.map((summary) => `- ${summary}`),
+            ].join('\n');
+        }
+        return response.explanation || 'Proposta de alteracao pronta para revisar.';
+    }
+    describeComponentEditPlan(componentEditPlan) {
+        const operations = this.componentEditOperations(componentEditPlan);
+        const booleanStateSummary = this.describeBooleanStateRenderers(operations);
+        if (booleanStateSummary)
+            return [booleanStateSummary];
+        const seen = new Set();
+        return operations
+            .map((operation) => this.describeComponentEditOperation(operation))
+            .filter((summary) => {
+            if (!summary || seen.has(summary))
+                return false;
+            seen.add(summary);
+            return true;
+        });
+    }
+    componentEditOperations(componentEditPlan) {
+        const plan = this.toRecord(componentEditPlan);
+        if (!plan)
+            return [];
+        const operations = plan['operations'];
+        if (Array.isArray(operations)) {
+            return operations
+                .map((operation) => this.toRecord(operation))
+                .filter((operation) => !!operation);
+        }
+        return plan['operationId'] || plan['changeKind'] || plan['capabilityPath']
+            ? [plan]
+            : [];
+    }
+    describeBooleanStateRenderers(operations) {
+        if (operations.length < 2)
+            return null;
+        const rendererOperations = operations
+            .filter((operation) => this.stringValue(operation['operationId']) === 'column.conditionalRenderer.add')
+            .map((operation) => {
+            const target = this.toRecord(operation['target']);
+            const input = this.toRecord(operation['input']) ?? this.toRecord(operation['params']) ?? {};
+            const renderer = this.toRecord(input['renderer']);
+            const rendererType = this.stringValue(renderer?.['type']) || 'badge';
+            const visual = this.toRecord(renderer?.[rendererType]) ?? {};
+            return {
+                field: this.stringValue(target?.['field']) || this.stringValue(operation['field']) || this.stringValue(input['field']),
+                trueLabel: this.booleanConditionValue(input['condition']) === true ? this.stringValue(visual['text']) : '',
+                falseLabel: this.booleanConditionValue(input['condition']) === false ? this.stringValue(visual['text']) : '',
+                rendererType,
+            };
+        })
+            .filter((item) => item.field && (item.trueLabel || item.falseLabel));
+        if (rendererOperations.length < 2)
+            return null;
+        const field = rendererOperations[0].field;
+        if (!rendererOperations.every((item) => item.field === field))
+            return null;
+        const trueLabel = rendererOperations.find((item) => item.trueLabel)?.trueLabel;
+        const falseLabel = rendererOperations.find((item) => item.falseLabel)?.falseLabel;
+        if (!trueLabel || !falseLabel)
+            return null;
+        const rendererType = rendererOperations.find((item) => item.rendererType)?.rendererType || 'badge';
+        return `Vou mostrar a coluna **${this.humanizeField(field)}** como ${this.rendererLabel(rendererType)}: **${trueLabel}** para verdadeiro e **${falseLabel}** para falso.`;
+    }
+    describeComponentEditOperation(operation) {
+        const operationId = this.stringValue(operation['operationId']) || this.stringValue(operation['changeKind']);
+        const target = this.toRecord(operation['target']);
+        const input = this.toRecord(operation['input']) ?? this.toRecord(operation['params']) ?? {};
+        const field = this.stringValue(target?.['field'])
+            || this.stringValue(operation['field'])
+            || this.stringValue(input['field']);
+        const label = field ? this.humanizeField(field) : 'a tabela';
+        switch (operationId) {
+            case 'column.format.set':
+            case 'set_column_format':
+                return `Vou formatar a coluna **${label}** como **${this.formatLabel(input['format'] ?? operation['value'])}**.`;
+            case 'column.header.set':
+            case 'set_column_header':
+                return `Vou renomear a coluna **${label}** para **${this.stringValue(input['header'] ?? operation['value']) || label}**.`;
+            case 'column.visibility.set':
+            case 'set_column_visibility':
+                return `${this.booleanInput(input['visible'] ?? operation['value']) === false ? 'Vou ocultar' : 'Vou exibir'} a coluna **${label}**.`;
+            case 'column.sticky.set':
+                return this.describeStickyColumn(label, input['sticky'] ?? input['value'] ?? operation['value']);
+            case 'column.width.set':
+                return `Vou ajustar a largura da coluna **${label}**.`;
+            case 'column.align.set':
+                return `Vou alinhar a coluna **${label}** ${this.alignmentLabel(input['align'] ?? input['value'] ?? operation['value'])}.`;
+            case 'column.remove':
+                return `Vou remover a coluna **${label}** da tabela.`;
+            case 'column.renderer.set':
+            case 'set_column_renderer':
+                return `Vou ajustar a apresentacao visual da coluna **${label}**.`;
+            case 'column.conditionalRenderer.add':
+            case 'set_column_conditional_badge_renderers':
+                return this.describeConditionalRenderer(label, input);
+            case 'column.conditionalStyle.add':
+            case 'set_column_conditional_style':
+                return this.describeConditionalStyle(label, this.toRecord(operation['value']) ?? input);
+            case 'column.computed.add':
+            case 'column.computed.set':
+            case 'add_computed_column':
+                return `Vou criar ou atualizar a coluna calculada **${label}**.`;
+            case 'behavior.filtering.configure':
+                return 'Vou atualizar os filtros da tabela.';
+            case 'filter.advanced.configure':
+            case 'configure_advanced_filters':
+                return this.describeAdvancedFiltersConfigure(input);
+            case 'filter.advanced.fields.add':
+                return this.describeAdvancedFilterFields(input, 'add');
+            case 'filter.advanced.fields.remove':
+                return this.describeAdvancedFilterFields(input, 'remove');
+            case 'behavior.pagination.configure':
+                return 'Vou atualizar a paginacao da tabela.';
+            case 'behavior.selection.configure':
+                return 'Vou atualizar a selecao de linhas.';
+            case 'toolbar.configure':
+                return 'Vou ajustar a barra de acoes da tabela.';
+            case 'toolbar.action.add':
+            case 'add_toolbar_action':
+                return `Vou adicionar a acao **${this.stringValue(input['label']) || this.stringValue(input['id']) || 'solicitada'}** na barra da tabela.`;
+            case 'export.configure':
+                return this.describeExportConfigure(input);
+            case 'appearance.density.set':
+                return `Vou ajustar a densidade da tabela para **${this.stringValue(input['density'] ?? operation['value']) || 'o valor escolhido'}**.`;
+            default:
+                return field
+                    ? `Vou atualizar a coluna **${label}**.`
+                    : 'Vou atualizar a configuracao da tabela.';
+        }
+    }
+    describeExportConfigure(input) {
+        const scope = this.stringValue(input['scope'] ?? input['exportScope']);
+        const serialized = JSON.stringify(input).toLowerCase();
+        const selectedOnly = scope === 'selected'
+            || scope === 'selection'
+            || serialized.includes('selected')
+            || serialized.includes('selection');
+        if (selectedOnly) {
+            return 'Vou habilitar a exportacao das linhas selecionadas.';
+        }
+        return 'Vou habilitar a exportacao da tabela.';
+    }
+    describeStickyColumn(label, value) {
+        const sticky = this.stringValue(value).toLowerCase();
+        if (sticky === 'false' || sticky === 'none') {
+            return `Vou desafixar a coluna **${label}**.`;
+        }
+        if (sticky === 'end' || sticky === 'right') {
+            return `Vou fixar a coluna **${label}** no fim da tabela.`;
+        }
+        return `Vou fixar a coluna **${label}** no inicio da tabela.`;
+    }
+    alignmentLabel(value) {
+        switch (this.stringValue(value).toLowerCase()) {
+            case 'left':
+                return 'a esquerda';
+            case 'right':
+                return 'a direita';
+            case 'center':
+                return 'ao centro';
+            default:
+                return 'como solicitado';
+        }
+    }
+    describeAdvancedFiltersConfigure(input) {
+        const enabled = this.booleanInput(input['enabled']);
+        if (enabled === false) {
+            return 'Vou desativar os filtros avancados da tabela.';
+        }
+        const settings = this.toRecord(input['settings']) ?? {};
+        const fields = this.arrayOfStrings(settings['alwaysVisibleFields']);
+        if (fields.length) {
+            return `Vou ativar os filtros avancados e deixar **${fields.map((field) => this.humanizeFilterField(field)).join(', ')}** sempre visiveis.`;
+        }
+        return 'Vou ativar os filtros avancados da tabela.';
+    }
+    describeAdvancedFilterFields(input, action) {
+        const fields = this.arrayOfStrings(input['fields']);
+        if (!fields.length) {
+            return action === 'add'
+                ? 'Vou incluir novos campos nos filtros avancados.'
+                : 'Vou remover campos dos filtros avancados.';
+        }
+        const labels = fields.map((field) => this.humanizeFilterField(field)).join(', ');
+        if (action === 'remove') {
+            return `Vou remover **${labels}** dos filtros avancados.`;
+        }
+        const alwaysVisible = this.booleanInput(input['alwaysVisible']);
+        if (alwaysVisible === true) {
+            return `Vou incluir **${labels}** nos filtros avancados e deixar disponivel na area principal.`;
+        }
+        return `Vou incluir **${labels}** nos filtros avancados.`;
+    }
+    describeConditionalRenderer(label, input) {
+        const renderer = this.toRecord(input['renderer']);
+        const rendererType = this.stringValue(renderer?.['type']) || 'badge';
+        const visual = this.toRecord(renderer?.[rendererType]) ?? {};
+        const text = this.stringValue(visual['text']);
+        const description = this.stringValue(input['description']);
+        if (text) {
+            return `Vou destacar a coluna **${label}** com ${this.rendererLabel(rendererType)} **${text}** quando a condicao for atendida.`;
+        }
+        if (description) {
+            return `Vou destacar a coluna **${label}** quando **${description}**.`;
+        }
+        return `Vou destacar a coluna **${label}** quando a condicao for atendida.`;
+    }
+    describeConditionalStyle(label, input) {
+        const parts = [`Vou destacar a coluna **${label}**`];
+        const condition = this.conditionLabel(input['condition']);
+        if (condition) {
+            parts.push(`quando **${condition}**`);
+        }
+        else {
+            parts.push('quando a condicao for atendida');
+        }
+        const style = this.styleLabel(this.toRecord(input['style']));
+        if (style) {
+            parts.push(`usando ${style}`);
+        }
+        const tooltip = this.tooltipLabel(input['tooltip'] ?? input['description']);
+        if (tooltip) {
+            parts.push(`com tooltip **${tooltip}**`);
+        }
+        return `${parts.join(' ')}.`;
+    }
+    conditionLabel(condition) {
+        const record = this.toRecord(condition);
+        if (!record)
+            return null;
+        for (const operator of ['>=', '<=', '>', '<', '===', '==']) {
+            const operands = record[operator];
+            if (!Array.isArray(operands) || operands.length < 2)
+                continue;
+            const field = this.jsonLogicOperandLabel(operands[0]);
+            const value = this.jsonLogicOperandLabel(operands[1]);
+            if (field && value) {
+                return `${field} ${operator} ${value}`;
+            }
+        }
+        return null;
+    }
+    jsonLogicOperandLabel(operand) {
+        const record = this.toRecord(operand);
+        const field = this.stringValue(record?.['var']);
+        if (field)
+            return this.humanizeField(field);
+        if (typeof operand === 'string')
+            return operand;
+        if (typeof operand === 'number' || typeof operand === 'boolean')
+            return String(operand);
+        return null;
+    }
+    styleLabel(style) {
+        if (!style)
+            return null;
+        const labels = [];
+        const background = this.stringValue(style['backgroundColor'] ?? style['background-color']);
+        const color = this.stringValue(style['color']);
+        const fontWeight = this.stringValue(style['fontWeight'] ?? style['font-weight']);
+        const opacity = this.stringValue(style['opacity']);
+        const border = this.stringValue(style['border']);
+        if (background)
+            labels.push(`fundo ${this.colorLabel(background)}`);
+        if (color)
+            labels.push(`texto ${this.colorLabel(color)}`);
+        if (fontWeight)
+            labels.push('texto em destaque');
+        if (opacity)
+            labels.push(`opacidade ${opacity}`);
+        if (border)
+            labels.push('borda discreta');
+        return labels.length ? labels.join(', ') : null;
+    }
+    colorLabel(value) {
+        const normalized = value.toLowerCase();
+        if (normalized.includes('46, 125, 50') || normalized.includes('27, 94, 32') || normalized.includes('green')
+            || normalized.includes('#e8f5e9') || normalized.includes('#1b5e20')) {
+            return 'verde suave';
+        }
+        if (normalized.includes('255, 152, 0') || normalized.includes('255, 243, 224') || normalized.includes('138, 75, 0') || normalized.includes('orange')
+            || normalized.includes('#fff3e0') || normalized.includes('#ff9800') || normalized.includes('#8a4b00')) {
+            return 'laranja suave';
+        }
+        if (normalized.includes('244, 67, 54') || normalized.includes('183, 28, 28') || normalized.includes('red')
+            || normalized.includes('#ffebee') || normalized.includes('#b71c1c')) {
+            return 'vermelho suave';
+        }
+        return value;
+    }
+    tooltipLabel(value) {
+        const tooltip = this.toRecord(value);
+        const text = this.stringValue(tooltip?.['text']) || this.stringValue(value);
+        return text || null;
+    }
+    toChatMessages(messages, prompt) {
+        const supported = (messages ?? [])
+            .filter((message) => message.role === 'user' || message.role === 'assistant' || message.role === 'system')
+            .map((message) => ({
+            role: message.role,
+            content: message.text,
+        }))
+            .filter((message) => message.content.trim().length > 0);
+        return supported.length ? supported : [{ role: 'user', content: prompt }];
+    }
+    toClarificationQuestions(response) {
+        const labels = response.questions?.length
+            ? response.questions
+            : response.message
+                ? [response.message]
+                : ['Qual ajuste voce quer aplicar na tabela?'];
+        const options = this.toQuickReplies(response).map((reply) => ({
+            id: reply.id,
+            label: reply.label,
+            value: reply.prompt,
+        }));
+        return labels.map((label, index) => ({
+            id: `table-clarification-${index + 1}`,
+            type: options.length ? 'single-choice' : 'text',
+            label,
+            allowCustom: true,
+            options,
+        }));
+    }
+    toQuickReplies(response) {
+        const payloads = response.optionPayloads ?? [];
+        if (payloads.length) {
+            return payloads
+                .map((option, index) => {
+                const rawLabel = option.label?.trim() || option.value?.trim() || `Opcao ${index + 1}`;
+                const label = this.humanizeClarificationOptionLabel(rawLabel);
+                const prompt = option.value?.trim() || option.example?.trim() || label;
+                return {
+                    id: `option-${index + 1}`,
+                    label,
+                    prompt,
+                    kind: 'clarification-option',
+                    description: this.optionDescription(option),
+                    icon: this.optionIcon(option),
+                    tone: this.optionTone(option),
+                    presentation: this.optionPresentation(option) ?? this.defaultGuidedOptionPresentation(option),
+                    contextHints: this.optionContextHints(option),
+                };
+            });
+        }
+        return (response.options ?? [])
+            .filter((option) => !!option?.trim())
+            .map((option, index) => ({
+            id: `option-${index + 1}`,
+            label: this.humanizeClarificationOptionLabel(option.trim()),
+            prompt: option.trim(),
+            kind: 'clarification-option',
+            presentation: {
+                kind: 'guided-option',
+                icon: 'check',
+                ctaLabel: 'Usar esta opcao',
+            },
+        }));
+    }
+    humanizeClarificationOptionLabel(label) {
+        return label
+            .replace(/\s*\((?:column|filter|behavior|toolbar|export|appearance)\.[^)]+\)\s*$/u, '')
+            .replace(/\s*—\s*ocultar\s*$/u, ' — ocultar coluna')
+            .replace(/\s*—\s*remover completamente\s*$/u, ' — remover coluna')
+            .replace(/\s*—\s*exibir\s*$/u, ' — exibir coluna')
+            .trim();
+    }
+    defaultGuidedOptionPresentation(option) {
+        const description = this.optionDescription(option);
+        const icon = this.optionIcon(option) || 'check';
+        const tone = this.optionTone(option);
+        return {
+            kind: 'guided-option',
+            icon,
+            tone,
+            description,
+            ctaLabel: 'Usar esta opcao',
+        };
+    }
+    optionContextHints(option) {
+        return this.toRecord(option.contextHints);
+    }
+    optionPresentation(option) {
+        const hints = this.optionContextHints(option);
+        return this.toRecord(hints?.['presentation']);
+    }
+    optionDescription(option) {
+        const presentation = this.optionPresentation(option);
+        const value = presentation?.['description'];
+        return typeof value === 'string' && value.trim() ? value.trim() : null;
+    }
+    optionIcon(option) {
+        const presentation = this.optionPresentation(option);
+        const value = presentation?.['icon'];
+        return typeof value === 'string' && value.trim() ? value.trim() : null;
+    }
+    optionTone(option) {
+        const presentation = this.optionPresentation(option);
+        const value = presentation?.['tone'];
+        return typeof value === 'string' && value.trim() ? value.trim() : null;
+    }
+    booleanConditionValue(condition) {
+        const record = this.toRecord(condition);
+        if (!record)
+            return null;
+        for (const operator of ['==', '===']) {
+            const operands = record[operator];
+            if (!Array.isArray(operands))
+                continue;
+            const literal = operands.find((operand) => typeof operand === 'boolean');
+            if (typeof literal === 'boolean')
+                return literal;
+        }
+        return null;
+    }
+    booleanInput(value) {
+        return typeof value === 'boolean' ? value : null;
+    }
+    arrayOfStrings(value) {
+        return Array.isArray(value)
+            ? value.filter((item) => typeof item === 'string' && item.trim().length > 0)
+            : [];
+    }
+    formatLabel(value) {
+        const format = this.stringValue(value);
+        if (!format)
+            return 'o formato solicitado';
+        if (format === '000.000.000-00')
+            return 'CPF brasileiro';
+        if (/^BRL\b/u.test(format))
+            return 'moeda brasileira';
+        switch (format) {
+            case 'shortDate':
+                return 'data curta';
+            case 'mediumDate':
+                return 'data com mes abreviado';
+            case 'longDate':
+                return 'data por extenso';
+            case 'fullDate':
+                return 'data completa com dia da semana';
+            case 'MMM/yyyy':
+                return 'mes e ano';
+            case 'dd/MM/yyyy':
+                return 'data no padrao brasileiro';
+            case 'yyyy-MM-dd':
+                return 'data ISO';
+            case 'yyyy-MM-dd HH:mm':
+                return 'data e hora';
+            case 'shortTime':
+                return 'hora curta';
+            case 'short':
+                return 'data e hora curtas';
+        }
+        return format;
+    }
+    rendererLabel(value) {
+        switch (value.trim().toLowerCase()) {
+            case 'chip':
+                return 'chip';
+            case 'avatar':
+                return 'avatar';
+            case 'badge':
+                return 'badge';
+            default:
+                return 'indicador visual';
+        }
+    }
+    humanizeField(field) {
+        if (field.trim().toLowerCase() === 'cpf')
+            return 'CPF';
+        return field
+            .replace(/[_-]+/gu, ' ')
+            .replace(/([a-z])([A-Z])/g, '$1 $2')
+            .trim()
+            .replace(/^./u, (char) => char.toLocaleUpperCase('pt-BR'));
+    }
+    humanizeFilterField(field) {
+        const normalized = field.trim();
+        if (!normalized)
+            return 'Campo';
+        const catalogLabel = this.filterFieldLabels.get(normalized);
+        if (catalogLabel)
+            return catalogLabel;
+        if (normalized.toLowerCase() === 'cpf')
+            return 'CPF';
+        if (/between$/iu.test(normalized)) {
+            const base = normalized.replace(/Between$/iu, '');
+            return `Faixa de ${this.humanizeField(base).toLocaleLowerCase('pt-BR')}`;
+        }
+        if (/range$/iu.test(normalized)) {
+            const base = normalized.replace(/Range$/iu, '');
+            return `Periodo de ${this.humanizeFilterBase(base).toLocaleLowerCase('pt-BR')}`;
+        }
+        if (/lastDays$/iu.test(normalized)) {
+            const base = normalized.replace(/LastDays$/iu, '');
+            if (this.normalizeLabel(base) === 'data admissao') {
+                return 'Admissões recentes';
+            }
+            return `${this.humanizeFilterBase(base)} recentes`;
+        }
+        if (/IdsIn$/iu.test(normalized)) {
+            return this.humanizeField(normalized.replace(/IdsIn$/iu, ''));
+        }
+        return this.humanizeField(normalized);
+    }
+    extractFilterFieldLabels(contextHints) {
+        const labels = new Map();
+        const fields = this.filterFieldCatalogFields(contextHints);
+        for (const field of fields) {
+            const record = this.toRecord(field);
+            const name = this.stringValue(record?.['name']);
+            const label = this.stringValue(record?.['label']);
+            if (name && label) {
+                labels.set(name, label);
+            }
+        }
+        return labels;
+    }
+    filterFieldCatalogFields(contextHints) {
+        const authoringContract = this.toRecord(contextHints?.['authoringContract']);
+        const componentEditPlan = this.toRecord(authoringContract?.['componentEditPlan']);
+        const nestedCatalog = this.toRecord(componentEditPlan?.['filterFieldCatalog']);
+        const nestedFields = nestedCatalog?.['fields'];
+        if (Array.isArray(nestedFields))
+            return nestedFields;
+        const directCatalog = this.toRecord(authoringContract?.['filterFieldCatalog'])
+            ?? this.toRecord(contextHints?.['filterFieldCatalog']);
+        const directFields = directCatalog?.['fields'];
+        return Array.isArray(directFields) ? directFields : [];
+    }
+    humanizeFilterBase(field) {
+        const label = this.humanizeField(field).replace(/^Data\s+/iu, '');
+        if (this.normalizeLabel(label) === 'admissao')
+            return 'admissão';
+        return label;
+    }
+    normalizeLabel(value) {
+        return value
+            .normalize('NFD')
+            .replace(/\p{Diacritic}/gu, '')
+            .replace(/[_-]+/gu, ' ')
+            .replace(/([a-z])([A-Z])/g, '$1 $2')
+            .trim()
+            .toLocaleLowerCase('pt-BR')
+            .replace(/\s+/gu, ' ');
+    }
+    stringValue(value) {
+        return typeof value === 'string' ? value.trim() : '';
+    }
+    buildCurrentStateDigest(currentState, dataProfile) {
+        const columns = Array.isArray(currentState['columns'])
+            ? currentState['columns']
+                .map((column) => this.toRecord(column)?.['field'])
+                .filter((field) => typeof field === 'string' && field.length > 0)
+            : undefined;
+        const rowCount = typeof dataProfile?.['rowCount'] === 'number' ? dataProfile['rowCount'] : undefined;
+        return {
+            ...(columns?.length ? { columns } : {}),
+            ...(rowCount !== undefined ? { rowCount } : {}),
+        };
+    }
+    optionalJsonObject(value) {
+        if (value === undefined || value === null) {
+            return undefined;
+        }
+        const object = this.toAiJsonObject(value);
+        return Object.keys(object).length ? object : undefined;
+    }
+    async prepareAuthoringContext() {
+        const adapter = this.adapter;
+        await adapter.prepareAuthoringContext?.();
+    }
+    mergeJsonObjects(base, overlay) {
+        if (!base)
+            return overlay;
+        if (!overlay)
+            return base;
+        return {
+            ...base,
+            ...overlay,
+        };
+    }
+    toAiJsonObject(value) {
+        const record = this.toRecord(value);
+        if (!record) {
+            return {};
+        }
+        try {
+            return JSON.parse(JSON.stringify(record));
+        }
+        catch {
+            return {};
+        }
+    }
+    toRecord(value) {
+        return value && typeof value === 'object' && !Array.isArray(value)
+            ? value
+            : null;
+    }
+}
+
+export { TableAgenticAuthoringTurnFlow };