@praxisui/table 8.0.0-beta.19 → 8.0.0-beta.20

package/fesm2022/praxisui-table.mjs

@@ -33,7 +33,7 @@ import * as i12 from '@angular/cdk/drag-drop';
 import { moveItemInArray, DragDropModule } from '@angular/cdk/drag-drop';
 import { Subject, debounceTime, takeUntil, of, firstValueFrom, BehaviorSubject, take as take$1 } from 'rxjs';
 import * as i1 from '@praxisui/core';
-import { LoggerService, createCorporateLoggerConfig, ConsoleLoggerSink, PraxisJsonLogicService, PraxisIconDirective, PraxisI18nService, isTableConfigV2, providePraxisI18nConfig, PRAXIS_GLOBAL_ACTION_CATALOG, SURFACE_OPEN_I18N_NAMESPACE, isRequiredGlobalActionPayloadMissing, getGlobalActionUiSchema, getRequiredGlobalActionPayloadKeys, hasMeaningfulGlobalActionPayloadValue, SurfaceOpenActionEditorComponent, SURFACE_OPEN_I18N_CONFIG, INLINE_FILTER_CONTROL_TYPES, INLINE_FILTER_CONTROL_TYPE_VALUES, FieldControlType, normalizeControlTypeToken, ASYNC_CONFIG_STORAGE, resolveControlTypeAlias, mapFieldDefinitionsToMetadata, PraxisJsonLogicError, GLOBAL_ACTION_CATALOG, GenericCrudService, validateGlobalActionRefs, getGlobalActionCatalog, TableConfigService, createDefaultTableConfig, fillUndefined, deepMerge, INLINE_FILTER_ALIAS_TOKENS, GlobalConfigService, buildSchemaId, MemoryCacheAdapter, LocalStorageCacheAdapter, SchemaMetadataClient, resolveInlineFilterControlType, fetchWithETag, ComponentMetadataRegistry, PraxisCollectionExportService, ResourceQuickConnectComponent, translateResourceAvailabilityReason, assertPraxisCollectionExportArtifact, PRAXIS_LOADING_CTX, translateResourceDiscoveryText, supportsImplicitValuePresentation, resolveValuePresentation, translateUnavailableWorkflowMessage, CONNECTION_STORAGE, PRAXIS_LOADING_RENDERER, EmptyStateCardComponent, RESOURCE_DISCOVERY_I18N_CONFIG, AnalyticsStatsRequestBuilderService, buildApiUrl, normalizePraxisDataQueryContext, API_URL } from '@praxisui/core';
+import { LoggerService, createCorporateLoggerConfig, ConsoleLoggerSink, PraxisJsonLogicService, PraxisIconDirective, PraxisI18nService, isTableConfigV2, providePraxisI18nConfig, PRAXIS_GLOBAL_ACTION_CATALOG, SURFACE_OPEN_I18N_NAMESPACE, isRequiredGlobalActionPayloadMissing, getGlobalActionUiSchema, getRequiredGlobalActionPayloadKeys, hasMeaningfulGlobalActionPayloadValue, SurfaceOpenActionEditorComponent, SURFACE_OPEN_I18N_CONFIG, INLINE_FILTER_CONTROL_TYPES, INLINE_FILTER_CONTROL_TYPE_VALUES, FieldControlType, normalizeControlTypeToken, ASYNC_CONFIG_STORAGE, resolveControlTypeAlias, mapFieldDefinitionsToMetadata, PraxisJsonLogicError, GLOBAL_ACTION_CATALOG, GenericCrudService, validateGlobalActionRefs, getGlobalActionCatalog, TableConfigService, createDefaultTableConfig, fillUndefined, deepMerge, INLINE_FILTER_ALIAS_TOKENS, GlobalConfigService, buildSchemaId, MemoryCacheAdapter, LocalStorageCacheAdapter, SchemaMetadataClient, resolveInlineFilterControlType, fetchWithETag, serializeEntityLookupValueForPayload, ComponentMetadataRegistry, PraxisCollectionExportService, ResourceQuickConnectComponent, translateResourceAvailabilityReason, assertPraxisCollectionExportArtifact, PRAXIS_LOADING_CTX, translateResourceDiscoveryText, supportsImplicitValuePresentation, resolveValuePresentation, translateUnavailableWorkflowMessage, CONNECTION_STORAGE, PRAXIS_LOADING_RENDERER, EmptyStateCardComponent, RESOURCE_DISCOVERY_I18N_CONFIG, AnalyticsStatsRequestBuilderService, buildApiUrl, normalizePraxisDataQueryContext, API_URL } from '@praxisui/core';
 import { PraxisRichContent } from '@praxisui/rich-content';
 import * as i2 from '@angular/material/toolbar';
 import { MatToolbarModule } from '@angular/material/toolbar';
@@ -35857,7 +35857,7 @@ class PraxisFilter {
     cleanFilterPayload(source) {
         const cleaned = {};
         Object.keys(source || {}).forEach((key) => {
-            const value = source[key];
+            const value = this.normalizeFilterFieldValue(key, source[key]);
             if (!this.isEffectivelyEmptyFilterValue(value)) {
                 cleaned[key] = value;
             }
@@ -35865,11 +35865,43 @@ class PraxisFilter {
         return cleaned;
     }
     upsertDtoValue(key, value) {
-        if (this.isEffectivelyEmptyFilterValue(value)) {
+        const normalizedValue = this.normalizeFilterFieldValue(key, value);
+        if (this.isEffectivelyEmptyFilterValue(normalizedValue)) {
             delete this.dto[key];
             return;
         }
-        this.dto[key] = value;
+        this.dto[key] = normalizedValue;
+    }
+    normalizeFilterFieldValue(key, value) {
+        const meta = this.getFilterFieldMetaByName(key);
+        if (!this.isEntityLookupFilterField(meta)) {
+            return value;
+        }
+        return serializeEntityLookupValueForPayload(value, {
+            payloadMode: meta?.payloadMode,
+            multiple: meta?.multiple === true,
+            entityType: String(meta?.optionSource?.entityKey || '').trim() || undefined,
+        });
+    }
+    getFilterFieldMetaByName(fieldName) {
+        const normalizedFieldName = String(fieldName || '').trim();
+        if (!normalizedFieldName)
+            return null;
+        return (this.schemaMetas?.find((meta) => meta.name === normalizedFieldName) ||
+            (this.fieldMetadata || []).find((meta) => meta.name === normalizedFieldName) ||
+            this.getEditableFieldMeta(normalizedFieldName)) ?? null;
+    }
+    isEntityLookupFilterField(meta) {
+        if (!meta)
+            return false;
+        const controlType = meta.controlType;
+        const normalizedControlType = String(controlType || '').toLowerCase();
+        const controlTypeToken = normalizeControlTypeToken(controlType);
+        return (controlType === FieldControlType.ENTITY_LOOKUP ||
+            normalizedControlType === 'entitylookup' ||
+            controlTypeToken === 'entitylookup' ||
+            controlTypeToken === normalizeControlTypeToken(INLINE_ENTITY_LOOKUP_CONTROL_TYPE) ||
+            meta?.entityLookup === true);
     }
     isEffectivelyEmptyFilterValue(value) {
         if (value === null || value === undefined)
@@ -41638,6 +41670,13 @@ class PraxisTable {
             const payload = Object.prototype.hasOwnProperty.call(runtimeOptions || {}, 'payload')
                 ? runtimeOptions?.payload
                 : { row };
+            const resolvedGlobalAction = this.resolveConfiguredGlobalActionRef(actionConfig.globalAction, {
+                sourceId: this.tableId || this.componentInstanceId || 'praxis-table',
+                output: 'rowAction',
+                payload,
+                runtime: { row },
+                meta: { actionId: action, actionConfig },
+            });
             await this.executeConfiguredGlobalAction(actionConfig, {
                 sourceId: this.tableId || this.componentInstanceId || 'praxis-table',
                 output: 'rowAction',
@@ -41796,7 +41835,7 @@ class PraxisTable {
         const ref = actionConfig?.globalAction;
         if (!ref)
             return false;
-        const result = await this.globalActions.executeRef(ref, context);
+        const result = await this.globalActions.executeRef(this.resolveConfiguredGlobalActionRef(ref, context) || ref, context);
         if (!result.success) {
             this.warnLog('[PraxisTable] global action execution failed', { actionId: ref.actionId, error: result.error }, { actionId: ref.actionId });
             this.showActionFeedbackMessage('errors', ref.actionId, {
@@ -41808,6 +41847,70 @@ class PraxisTable {
         }
         return true;
     }
+    resolveConfiguredGlobalActionRef(ref, context) {
+        if (!ref || ref.payloadExpr !== undefined || !Object.prototype.hasOwnProperty.call(ref, 'payload')) {
+            return ref;
+        }
+        return {
+            ...ref,
+            payload: this.resolveGlobalActionPayload(ref.payload, context),
+        };
+    }
+    resolveGlobalActionPayload(raw, context) {
+        const root = this.buildGlobalActionTemplateContext(context);
+        return this.resolveGlobalActionTemplateValue(raw, root);
+    }
+    buildGlobalActionTemplateContext(context) {
+        return {
+            context,
+            payload: context?.payload,
+            runtime: context?.runtime,
+            meta: context?.meta,
+            pageContext: context?.pageContext,
+            row: context?.runtime?.row,
+            item: context?.runtime?.item,
+            selection: context?.runtime?.selection,
+            formData: context?.runtime?.formData,
+            value: context?.runtime?.value,
+            state: context?.runtime?.state,
+            actionConfig: context?.meta?.actionConfig,
+            actionId: context?.meta?.actionId,
+        };
+    }
+    resolveGlobalActionTemplateValue(raw, ctx, key) {
+        if (this.isDeferredTemplateExpressionKey(key) && typeof raw === 'string') {
+            return raw;
+        }
+        if (typeof raw === 'string') {
+            return this.interpolateGlobalActionTemplate(raw, ctx);
+        }
+        if (Array.isArray(raw)) {
+            return raw.map((value) => this.resolveGlobalActionTemplateValue(value, ctx, key));
+        }
+        if (raw && typeof raw === 'object') {
+            const out = {};
+            for (const [childKey, value] of Object.entries(raw)) {
+                out[childKey] = this.resolveGlobalActionTemplateValue(value, ctx, childKey);
+            }
+            return out;
+        }
+        return raw;
+    }
+    isDeferredTemplateExpressionKey(key) {
+        if (!key)
+            return false;
+        return key === 'expr' || key.endsWith('Expr');
+    }
+    interpolateGlobalActionTemplate(template, ctx) {
+        const single = String(template || '').match(/^\$\{([^}]+)\}$/);
+        if (single) {
+            return this.getNestedPropertyValue(ctx, single[1].trim());
+        }
+        return String(template || '').replace(/\$\{([^}]+)\}/g, (_match, path) => {
+            const value = this.getNestedPropertyValue(ctx, String(path).trim());
+            return value == null ? '' : String(value);
+        });
+    }
     shouldEmitLocalForGlobalAction(actionConfig) {
         return actionConfig?.emitLocal === true || actionConfig?.globalAction?.meta?.emitLocal === true;
     }
@@ -43808,7 +43911,7 @@ class PraxisTable {
             // Only verify when we already have columns configured (bootstrap handled by loadSchema)
             if ((this.config?.columns?.length ?? 0) === 0)
                 return;
-            // Build request to /schemas/filtered for grid (path=/.../all, operation=get, schemaType=response)
+            // Build request to /schemas/filtered for grid using the governed search/list surface.
             const baseUrl = this.crudService.getSchemasFilteredBaseUrl();
             let derived = '';
             try {
@@ -43818,8 +43921,8 @@ class PraxisTable {
                 return;
             }
             const u = new URL(baseUrl);
-            u.searchParams.set('path', `${derived}/all`);
-            u.searchParams.set('operation', 'get');
+            u.searchParams.set('path', `${derived}/filter`);
+            u.searchParams.set('operation', 'post');
             u.searchParams.set('schemaType', 'response');
             u.searchParams.set('includeInternalSchemas', 'false');
             const serverHash = this.runtimeSchemaMeta.serverHash;
@@ -44850,7 +44953,68 @@ class PraxisTable {
                 this.errorLog('PTABLE:format:error', { error, value, column });
             }
         }
-        return value;
+        return this.normalizeReadonlyEntityLookupCellValue(value);
+    }
+    normalizeReadonlyEntityLookupCellValue(value) {
+        if (Array.isArray(value)) {
+            const normalizedItems = value
+                .map((item) => this.toEntityLookupDisplayToken(item))
+                .filter((item) => !!item);
+            const hasStructuredEntries = value.some((item) => this.isEntityLookupDisplayCandidate(item));
+            if (hasStructuredEntries && normalizedItems.length > 0) {
+                return normalizedItems.join(', ');
+            }
+            return value;
+        }
+        const normalized = this.toEntityLookupDisplayToken(value);
+        return normalized ?? value;
+    }
+    toEntityLookupDisplayToken(value) {
+        if (!this.isEntityLookupDisplayCandidate(value)) {
+            return null;
+        }
+        const record = value;
+        const extra = record['extra'] && typeof record['extra'] === 'object' && !Array.isArray(record['extra'])
+            ? record['extra']
+            : null;
+        const code = this.toEntityLookupDisplayPrimitive(record['code'] ?? extra?.['code'] ?? record['resourceKey'] ?? record['externalId']);
+        const label = this.toEntityLookupDisplayPrimitive(record['label']
+            ?? record['displayName']
+            ?? record['name']
+            ?? record['title']
+            ?? extra?.['label']);
+        const id = this.toEntityLookupDisplayPrimitive(record['id']);
+        if (code && label && code !== label) {
+            return `${code} · ${label}`;
+        }
+        return label || code || id || null;
+    }
+    isEntityLookupDisplayCandidate(value) {
+        if (!value || typeof value !== 'object' || Array.isArray(value) || value instanceof Date) {
+            return false;
+        }
+        const record = value;
+        return (Object.prototype.hasOwnProperty.call(record, 'label') ||
+            Object.prototype.hasOwnProperty.call(record, 'displayName') ||
+            Object.prototype.hasOwnProperty.call(record, 'name') ||
+            Object.prototype.hasOwnProperty.call(record, 'title') ||
+            Object.prototype.hasOwnProperty.call(record, 'id') ||
+            Object.prototype.hasOwnProperty.call(record, 'type') ||
+            Object.prototype.hasOwnProperty.call(record, 'code') ||
+            Object.prototype.hasOwnProperty.call(record, 'extra'));
+    }
+    toEntityLookupDisplayPrimitive(value) {
+        if (value === null || value === undefined) {
+            return null;
+        }
+        if (typeof value === 'string') {
+            const trimmed = value.trim();
+            return trimmed ? trimmed : null;
+        }
+        if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') {
+            return String(value);
+        }
+        return null;
     }
     resolveImplicitFormat(column) {
         if (!column?.type || !supportsImplicitValuePresentation(column.type)) {
@@ -49336,7 +49500,11 @@ const tableFilteringSchema = {
                 enabled: { type: 'boolean' },
                 settings: {
                     type: 'object',
-                    properties: { mode: { enum: ['filter'] } }
+                    properties: {
+                        mode: { enum: ['filter'] },
+                        showAdvanced: { type: 'boolean' },
+                        allowSaveTags: { type: 'boolean' }
+                    }
                 }
             }
         },
@@ -50200,7 +50368,26 @@ const PRAXIS_TABLE_AUTHORING_MANIFEST = {
                     label: { type: 'string' },
                     action: { type: 'string' },
                     icon: { type: 'string' },
-                    type: { enum: ['button', 'icon', 'menu'], default: 'button' }
+                    type: { enum: ['button', 'icon', 'menu'], default: 'button' },
+                    globalAction: {
+                        type: 'object',
+                        properties: {
+                            actionId: {
+                                type: 'string',
+                                enum: [
+                                    'toast.success',
+                                    'toast.error',
+                                    'dialog.alert',
+                                    'dialog.open',
+                                    'navigation.openExternal',
+                                    'navigation.openRoute',
+                                    'api.post',
+                                    'api.patch',
+                                ],
+                            },
+                            payload: { type: 'object' },
+                        },
+                    },
                 }
             },
             effects: [{ kind: 'append-unique', path: 'toolbar.actions[]', key: 'id' }],
@@ -50223,7 +50410,26 @@ const PRAXIS_TABLE_AUTHORING_MANIFEST = {
                     label: { type: 'string' },
                     action: { type: 'string' },
                     icon: { type: 'string' },
-                    color: { type: 'string' }
+                    color: { type: 'string' },
+                    globalAction: {
+                        type: 'object',
+                        properties: {
+                            actionId: {
+                                type: 'string',
+                                enum: [
+                                    'toast.success',
+                                    'toast.error',
+                                    'dialog.alert',
+                                    'dialog.open',
+                                    'navigation.openExternal',
+                                    'navigation.openRoute',
+                                    'api.post',
+                                    'api.patch',
+                                ],
+                            },
+                            payload: { type: 'object' },
+                        },
+                    },
                 }
             },
             effects: [{ kind: 'append-unique', path: 'actions.row.actions[]', key: 'id' }],
@@ -50232,6 +50438,48 @@ const PRAXIS_TABLE_AUTHORING_MANIFEST = {
             submissionImpact: 'config-only',
             preconditions: ['config-initialized']
         },
+        {
+            operationId: 'bulkAction.add',
+            title: 'Adicionar ação em lote',
+            scope: 'global',
+            targetKind: 'bulkAction',
+            target: { kind: 'bulkAction', resolver: 'action-in-bulk-config', ambiguityPolicy: 'fail', required: false },
+            inputSchema: {
+                type: 'object',
+                required: ['id', 'label', 'action'],
+                properties: {
+                    id: { type: 'string' },
+                    label: { type: 'string' },
+                    action: { type: 'string' },
+                    icon: { type: 'string' },
+                    color: { type: 'string' },
+                    globalAction: {
+                        type: 'object',
+                        properties: {
+                            actionId: {
+                                type: 'string',
+                                enum: [
+                                    'toast.success',
+                                    'toast.error',
+                                    'dialog.alert',
+                                    'dialog.open',
+                                    'navigation.openExternal',
+                                    'navigation.openRoute',
+                                    'api.post',
+                                    'api.patch',
+                                ],
+                            },
+                            payload: { type: 'object' },
+                        },
+                    },
+                }
+            },
+            effects: [{ kind: 'append-unique', path: 'actions.bulk.actions[]', key: 'id' }],
+            validators: ['bulk-action-id-unique'],
+            affectedPaths: ['actions.bulk.actions[]'],
+            submissionImpact: 'config-only',
+            preconditions: ['config-initialized']
+        },
         // --- BEHAVIOR & PERFORMANCE ---
         {
             operationId: 'export.enabled.set',
@@ -50264,8 +50512,16 @@ const PRAXIS_TABLE_AUTHORING_MANIFEST = {
                 required: ['enabled'],
                 properties: {
                     enabled: { type: 'boolean' },
-                    showAdvanced: { type: 'boolean' },
-                    allowSaveTags: { type: 'boolean' }
+                    queryBuilder: { type: 'boolean' },
+                    savePresets: { type: 'boolean' },
+                    settings: {
+                        type: 'object',
+                        properties: {
+                            mode: { enum: ['filter'] },
+                            showAdvanced: { type: 'boolean' },
+                            allowSaveTags: { type: 'boolean' }
+                        }
+                    }
                 }
             },
             effects: [
@@ -51001,6 +51257,12 @@ const PRAXIS_TABLE_AUTHORING_MANIFEST = {
             code: 'TB011',
             description: 'O id da row action deve ser único em actions.row.actions[]. O efeito append-unique usa este id como chave de deduplicação.'
         },
+        {
+            validatorId: 'bulk-action-id-unique',
+            level: 'error',
+            code: 'TB017',
+            description: 'O id da ação em lote deve ser único em actions.bulk.actions[]. O efeito append-unique usa este id como chave de deduplicação.'
+        },
         {
             validatorId: 'format-preset-supported',
             level: 'error',
@@ -51084,6 +51346,25 @@ const PRAXIS_TABLE_AUTHORING_MANIFEST = {
             params: { id: 'delete', label: 'Excluir', action: 'delete', icon: 'delete', color: 'warn' },
             isPositive: true
         },
+        {
+            id: 'add-row-action-open-route',
+            request: 'Adicionar botão de linha para abrir detalhe com navegação interna',
+            operationId: 'rowAction.add',
+            params: {
+                id: 'details',
+                label: 'Detalhes',
+                action: 'navigation.openRoute',
+                icon: 'open_in_new',
+                globalAction: {
+                    actionId: 'navigation.openRoute',
+                    payload: {
+                        path: '/clientes/detalhe',
+                        query: { id: '${row.id}' }
+                    }
+                }
+            },
+            isPositive: true
+        },
         {
             id: 'group-by-field',
             request: 'Agrupar a tabela por departamento',
@@ -53404,11 +53685,17 @@ const TABLE_AI_CAPABILITIES = {
         { path: 'actions.row.display', category: 'actions', valueKind: 'enum', allowedValues: ENUMS.rowActionDisplay, description: 'Modo de exibição das ações (menu/buttons/icons).', dependsOn: 'actions.row.enabled' },
         { path: 'actions.row.trigger', category: 'actions', valueKind: 'enum', allowedValues: ENUMS.rowActionTrigger, description: 'Como as ações aparecem (hover/always/click).', dependsOn: 'actions.row.enabled' },
         { path: 'actions.row.discovery.enabled', category: 'actions', valueKind: 'boolean', description: 'Controla se a tabela enriquece ações por linha com discovery contextual de HATEOAS/capabilities.', dependsOn: 'actions.row.enabled', safetyNotes: 'Use false quando a experiência precisar mostrar apenas ações curadas pelo host.' },
+        { path: 'actions.row.actions[].globalAction.[actionId]', category: 'actions', valueKind: 'string', description: 'Identificador canônico de global action para a ação por linha (ex.: "navigation.openRoute", "surface.open", "toast.success").', dependsOn: 'actions.row.enabled', intentExamples: ['navegar para detalhe interno ao clicar na linha', 'abrir drawer com surface.open', 'mostrar toast de sucesso'] },
+        { path: 'actions.row.actions[].globalAction.payload', category: 'actions', valueKind: 'object', description: 'Payload estruturado da global action por linha. Para `navigation.openRoute`, templates como `${row.id}` são resolvidos antes da navegação; para ações como `surface.open`, `payload.*` continua sendo o envelope canônico do evento consumido pelo destino.', dependsOn: 'actions.row.actions[].globalAction.[actionId]', intentExamples: ['abrir detalhe com query.id da linha', 'passar state.selectedId usando a linha atual'], example: '{ "path": "/clientes/detalhe", "query": { "id": "${row.id}" }, "state": { "selectedId": "${row.id}" } }' },
         { path: 'actions.bulk.enabled', category: 'actions', valueKind: 'boolean', description: 'Habilita ações em lote.', critical: true, intentExamples: ['ativar ações em lote', 'permitir excluir em massa'], safetyNotes: 'Combine com selection.persistSelection e limites de maxSelections.' },
         { path: 'actions.bulk.position', category: 'actions', valueKind: 'enum', allowedValues: ENUMS.bulkActionPosition, description: 'Posição das ações em lote.', dependsOn: 'actions.bulk.enabled' },
+        { path: 'actions.bulk.actions[].globalAction.[actionId]', category: 'actions', valueKind: 'string', description: 'Identificador canônico de global action para a ação em lote.', dependsOn: 'actions.bulk.enabled', intentExamples: ['disparar ação global com a seleção atual', 'abrir surface corporativa a partir do bulk action'] },
+        { path: 'actions.bulk.actions[].globalAction.payload', category: 'actions', valueKind: 'object', description: 'Payload estruturado da global action em lote. Deve permanecer alinhado ao schema da action escolhida e ao contexto da seleção atual.', dependsOn: 'actions.bulk.actions[].globalAction.[actionId]' },
         { path: 'actions.context.enabled', category: 'actions', valueKind: 'boolean', description: 'Habilita menu de contexto (clique direito/long press).', critical: true, intentExamples: ['ativar menu de contexto'] },
         { path: 'actions.context.trigger', category: 'actions', valueKind: 'enum', allowedValues: ENUMS.contextTrigger, description: 'Trigger para abrir o menu de contexto.', dependsOn: 'actions.context.enabled' },
         { path: 'actions.confirmations.default', category: 'actions', valueKind: 'object', description: 'Texto padrão de confirmação para ações perigosas.', critical: true, example: '{ title: "Confirmar exclusão", message: "Deseja remover o item?", confirmText: "Remover" }' },
+        { path: 'toolbar.actions[].globalAction.[actionId]', category: 'toolbar', valueKind: 'string', description: 'Identificador canônico de global action para ações da toolbar (ex.: "navigation.openRoute", "surface.open", "dialog.open").', dependsOn: 'toolbar.visible', intentExamples: ['abrir rota interna pela toolbar', 'abrir surface pela toolbar'] },
+        { path: 'toolbar.actions[].globalAction.payload', category: 'toolbar', valueKind: 'object', description: 'Payload estruturado da global action da toolbar. Para `surface.open`, preserve a semântica canônica do catálogo compartilhado: `payload.*` representa o envelope do evento e `runtime.*` referencia estado exposto diretamente pelo host.', dependsOn: 'toolbar.actions[].globalAction.[actionId]' },
         // Export
         { path: 'export.enabled', category: 'export', valueKind: 'boolean', description: 'Habilita funcionalidades de exportação.', critical: true, intentExamples: ['permitir exportar', 'desativar exportação'], safetyNotes: 'Avaliar políticas de dados sensíveis antes de habilitar.' },
         { path: 'export.formats', category: 'export', valueKind: 'array', description: 'Formatos permitidos.', allowedValues: ENUMS.exportFormat, example: '["csv","excel"]', intentExamples: ['exportar para excel', 'download em csv'] },

package/index.d.ts

@@ -744,6 +744,9 @@ declare class PraxisFilter implements OnInit, OnChanges, AfterViewInit, OnDestro
     private persistTags;
     private cleanFilterPayload;
     private upsertDtoValue;
+    private normalizeFilterFieldValue;
+    private getFilterFieldMetaByName;
+    private isEntityLookupFilterField;
     private isEffectivelyEmptyFilterValue;
     private syncFormsToDto;
     private updateDisplayedTags;
@@ -1380,6 +1383,12 @@ declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterCont
     private showActionFeedbackMessage;
     private emitEventWithActionFeedback;
     private executeConfiguredGlobalAction;
+    private resolveConfiguredGlobalActionRef;
+    private resolveGlobalActionPayload;
+    private buildGlobalActionTemplateContext;
+    private resolveGlobalActionTemplateValue;
+    private isDeferredTemplateExpressionKey;
+    private interpolateGlobalActionTemplate;
     private shouldEmitLocalForGlobalAction;
     private resolveBulkValidationMessage;
     private hasValidBulkSelectionCount;
@@ -1554,6 +1563,10 @@ declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterCont
      * 3. format (data formatting like dates, numbers, currency)
      */
     getCellValue(rowData: any, column: ColumnDefinition): any;
+    private normalizeReadonlyEntityLookupCellValue;
+    private toEntityLookupDisplayToken;
+    private isEntityLookupDisplayCandidate;
+    private toEntityLookupDisplayPrimitive;
     private resolveImplicitFormat;
     getCellClasses(rowData: any, column: ColumnDefinition): string[] | undefined;
     getCellNgStyle(rowData: any, column: ColumnDefinition): Record<string, string> | undefined;

package/package.json

@@ -1,18 +1,24 @@
 {
   "name": "@praxisui/table",
-  "version": "8.0.0-beta.19",
+  "version": "8.0.0-beta.20",
   "description": "Advanced data table for Angular (Praxis UI) with editing, filtering, sorting, virtualization, and settings panel integration.",
   "peerDependencies": {
     "@angular/common": "^20.0.0",
     "@angular/core": "^20.0.0",
-    "@praxisui/ai": "^8.0.0-beta.19",
-    "@praxisui/core": "^8.0.0-beta.19",
-    "@praxisui/dynamic-fields": "^8.0.0-beta.19",
-    "@praxisui/dynamic-form": "^8.0.0-beta.19",
-    "@praxisui/metadata-editor": "^8.0.0-beta.19",
-    "@praxisui/rich-content": "^8.0.0-beta.19",
-    "@praxisui/settings-panel": "^8.0.0-beta.19",
-    "@praxisui/table-rule-builder": "^8.0.0-beta.19"
+    "@praxisui/ai": "^8.0.0-beta.20",
+    "@praxisui/core": "^8.0.0-beta.20",
+    "@praxisui/dynamic-fields": "^8.0.0-beta.20",
+    "@praxisui/dynamic-form": "^8.0.0-beta.20",
+    "@praxisui/metadata-editor": "^8.0.0-beta.20",
+    "@praxisui/rich-content": "^8.0.0-beta.20",
+    "@praxisui/settings-panel": "^8.0.0-beta.20",
+    "@praxisui/table-rule-builder": "^8.0.0-beta.20",
+    "@angular/cdk": "^20.0.0",
+    "@angular/forms": "^20.0.0",
+    "@angular/material": "^20.0.0",
+    "@angular/router": "^20.0.0",
+    "@praxisui/dialog": "^8.0.0-beta.20",
+    "rxjs": "~7.8.0"
   },
   "dependencies": {
     "tslib": "^2.3.0"