@praxisui/metadata-editor 8.0.0-beta.8 → 8.0.0-beta.9

package/fesm2022/praxisui-metadata-editor.mjs

@@ -1054,6 +1054,61 @@ const inputProperties = [
     { name: 'defaultValue', label: 'Valor padrão', editorType: 'text', group: 'Geral' },
 ];
 
+const arrayProperties = [
+    { name: 'label', label: 'Label', editorType: 'text', group: 'Geral' },
+    { name: 'hint', label: 'Hint', editorType: 'text', group: 'Geral' },
+    { name: 'defaultValue', label: 'Valor inicial (JSON array)', editorType: 'textarea', group: 'Geral' },
+    {
+        name: 'array.itemType',
+        label: 'Tipo do item',
+        editorType: 'select',
+        group: 'Colecao',
+        defaultValue: 'object',
+        options: [
+            { value: 'object', text: 'Objeto' },
+        ],
+    },
+    {
+        name: 'array.mode',
+        label: 'Modo',
+        editorType: 'select',
+        group: 'Colecao',
+        defaultValue: 'cards',
+        options: [
+            { value: 'cards', text: 'Cards' },
+        ],
+    },
+    { name: 'array.itemSchemaRef', label: 'Schema do item ($ref)', editorType: 'text', group: 'Colecao' },
+    { name: 'array.itemIdentityField', label: 'Campo de identidade', editorType: 'text', group: 'Colecao' },
+    { name: 'array.addLabel', label: 'Texto do botao adicionar', editorType: 'text', group: 'Colecao' },
+    { name: 'array.emptyState', label: 'Texto vazio', editorType: 'text', group: 'Colecao' },
+    { name: 'array.itemTitleTemplate', label: 'Template do titulo do item', editorType: 'text', group: 'Colecao', hint: 'Ex.: {{nome}} - {{cargo}}' },
+    { name: 'array.minItems', label: 'Minimo de itens', editorType: 'number', group: 'Validacao' },
+    { name: 'array.maxItems', label: 'Maximo de itens', editorType: 'number', group: 'Validacao' },
+    {
+        name: 'array.deleteMode',
+        label: 'Modo de exclusao',
+        editorType: 'select',
+        group: 'Operacoes',
+        defaultValue: 'removeFromPayload',
+        options: [
+            { value: 'removeFromPayload', text: 'Remover do payload' },
+        ],
+    },
+    { name: 'array.operations.add', label: 'Permitir adicionar', editorType: 'checkbox', group: 'Operacoes', defaultValue: true },
+    { name: 'array.operations.edit', label: 'Permitir editar', editorType: 'checkbox', group: 'Operacoes', defaultValue: true },
+    { name: 'array.operations.remove', label: 'Permitir remover', editorType: 'checkbox', group: 'Operacoes', defaultValue: true },
+    { name: 'array.collectionValidation.uniqueBy', label: 'Unico por campos', editorType: 'textarea', group: 'Validacao', hint: 'JSON array ou uma linha por campo. Ex.: ["email"]' },
+    { name: 'array.collectionValidation.exactlyOne.field', label: 'Exatamente um: campo', editorType: 'text', group: 'Validacao' },
+    { name: 'array.collectionValidation.exactlyOne.value', label: 'Exatamente um: valor tipado', editorType: 'text', group: 'Validacao', hint: 'Use true/false, numero ou texto. Ex.: true, 1, PRINCIPAL.' },
+    { name: 'array.collectionValidation.exactlyOne.message', label: 'Mensagem: exatamente um', editorType: 'text', group: 'Validacao' },
+    { name: 'array.collectionValidation.atLeastOne.field', label: 'Pelo menos um: campo', editorType: 'text', group: 'Validacao' },
+    { name: 'array.collectionValidation.atLeastOne.value', label: 'Pelo menos um: valor tipado', editorType: 'text', group: 'Validacao', hint: 'Use true/false, numero ou texto. Ex.: true, 1, ACTIVE.' },
+    { name: 'array.collectionValidation.atLeastOne.message', label: 'Mensagem: pelo menos um', editorType: 'text', group: 'Validacao' },
+    { name: 'array.itemSchema.fields', label: 'Subcampos (JSON)', editorType: 'textarea', group: 'Subcampos', hint: 'Lista FieldMetadata[] usada quando nao houver itemSchemaRef resolvido.' },
+    { name: 'required', label: 'Obrigatorio', editorType: 'checkbox', group: 'Validacao' },
+];
+
 // Editor de metadados para componentes SELECT-like
 // Paridade com INPUT: grupos, linhas e propriedades canônicas
 const selectProperties = [
@@ -1215,6 +1270,302 @@ const selectProperties = [
     { name: 'dataAttributes', label: 'Data attributes (JSON)', editorType: 'textarea', group: 'Acessibilidade', hint: '{ "testId": "select-a" }' },
 ];
 
+function cloneProperty$7(prop) {
+    return {
+        ...prop,
+        options: Array.isArray(prop.options)
+            ? prop.options.map((opt) => typeof opt === 'object' && opt !== null ? { ...opt } : opt)
+            : prop.options,
+    };
+}
+const entityLookupProperties = [
+    ...selectProperties.map((prop) => cloneProperty$7(prop)),
+    {
+        name: 'optionSource.key',
+        label: 'Option source key',
+        editorType: 'text',
+        group: 'Fonte de entidade',
+        required: true,
+        hint: 'Chave publicada pelo backend para filtrar e reidratar a entidade.',
+    },
+    {
+        name: 'optionSource.type',
+        label: 'Tipo da fonte',
+        editorType: 'select',
+        group: 'Fonte de entidade',
+        defaultValue: 'RESOURCE_ENTITY',
+        options: [
+            { value: 'RESOURCE_ENTITY', text: 'RESOURCE_ENTITY' },
+            { value: 'LIGHT_LOOKUP', text: 'LIGHT_LOOKUP' },
+        ],
+        hint: 'Use RESOURCE_ENTITY para entidades reais de dominio.',
+    },
+    {
+        name: 'optionSource.entityKey',
+        label: 'Entity key',
+        editorType: 'text',
+        group: 'Fonte de entidade',
+        hint: 'Identificador semantico da entidade, por exemplo supplier, customer ou contract.',
+    },
+    {
+        name: 'optionSource.resourcePath',
+        label: 'Resource path',
+        editorType: 'text',
+        group: 'Fonte de entidade',
+        hint: 'Caminho base do recurso que publica option-sources e by-ids.',
+    },
+    {
+        name: 'optionSource.filterField',
+        label: 'Campo de filtro principal',
+        editorType: 'text',
+        group: 'Fonte de entidade',
+        hint: 'Campo usado por fontes derivadas quando houver filtro simples no backend.',
+    },
+    {
+        name: 'optionSource.propertyPath',
+        label: 'Property path',
+        editorType: 'text',
+        group: 'Fonte de entidade',
+        hint: 'Caminho de propriedade usado por fontes derivadas ou projeções leves.',
+    },
+    {
+        name: 'optionSource.valuePropertyPath',
+        label: 'Campo de valor',
+        editorType: 'text',
+        group: 'Fonte de entidade',
+        defaultValue: 'id',
+        hint: 'Campo canonico salvo no payload do formulario.',
+    },
+    {
+        name: 'optionSource.labelPropertyPath',
+        label: 'Campo de label',
+        editorType: 'text',
+        group: 'Fonte de entidade',
+        defaultValue: 'label',
+        hint: 'Campo principal exibido para o usuario.',
+    },
+    {
+        name: 'optionSource.codePropertyPath',
+        label: 'Campo de codigo',
+        editorType: 'text',
+        group: 'Exibicao de entidade',
+        hint: 'Codigo curto exibido antes do label, por exemplo FOR-8742.',
+    },
+    {
+        name: 'optionSource.descriptionPropertyPaths',
+        label: 'Campos de descricao',
+        editorType: 'textarea',
+        group: 'Exibicao de entidade',
+        hint: 'JSON array ou uma linha por campo. Ex.: ["documentNumber", "city", "state"].',
+    },
+    {
+        name: 'optionSource.statusPropertyPath',
+        label: 'Campo de status',
+        editorType: 'text',
+        group: 'Exibicao de entidade',
+        hint: 'Campo que informa status operacional da entidade.',
+    },
+    {
+        name: 'optionSource.disabledPropertyPath',
+        label: 'Campo disabled',
+        editorType: 'text',
+        group: 'Exibicao de entidade',
+        hint: 'Campo booleano que indica bloqueio visual ou operacional da entidade.',
+    },
+    {
+        name: 'optionSource.disabledReasonPropertyPath',
+        label: 'Campo de motivo bloqueado',
+        editorType: 'text',
+        group: 'Exibicao de entidade',
+        hint: 'Campo opcional com mensagem de bloqueio quando selectable=false.',
+    },
+    {
+        name: 'optionSource.searchPropertyPaths',
+        label: 'Campos de busca',
+        editorType: 'textarea',
+        group: 'Busca',
+        hint: 'JSON array ou uma linha por campo pesquisavel.',
+    },
+    {
+        name: 'optionSource.searchMode',
+        label: 'Modo de busca',
+        editorType: 'select',
+        group: 'Busca',
+        options: [
+            { value: 'contains', text: 'contains' },
+            { value: 'startsWith', text: 'startsWith' },
+            { value: 'exact', text: 'exact' },
+        ],
+        hint: 'Semantica de busca publicada pelo backend para esta fonte.',
+    },
+    {
+        name: 'optionSource.pageSize',
+        label: 'Tamanho da pagina',
+        editorType: 'number',
+        group: 'Busca',
+        hint: 'Quantidade sugerida de resultados por pagina.',
+    },
+    {
+        name: 'optionSource.includeIds',
+        label: 'Incluir IDs selecionados',
+        editorType: 'checkbox',
+        group: 'Busca',
+        defaultValue: true,
+        hint: 'Mantem entidades ja selecionadas visiveis durante busca paginada.',
+    },
+    {
+        name: 'optionSource.dependsOn',
+        label: 'Dependencias',
+        editorType: 'textarea',
+        group: 'Dependencias',
+        hint: 'JSON array ou uma linha por campo do formulario que filtra o lookup.',
+    },
+    {
+        name: 'optionSource.dependencyFilterMap',
+        label: 'Mapa de filtros',
+        editorType: 'textarea',
+        group: 'Dependencias',
+        hint: 'JSON object. Ex.: { "empresaId": "companyId", "fornecedorId": "supplierId" }.',
+    },
+    {
+        name: 'optionSource.selectionPolicy.statusPropertyPath',
+        label: 'Politica: campo de status',
+        editorType: 'text',
+        group: 'Politica de selecao',
+        hint: 'Campo usado para aplicar allowedStatuses ou blockedStatuses.',
+    },
+    {
+        name: 'optionSource.selectionPolicy.selectablePropertyPath',
+        label: 'Politica: campo selectable',
+        editorType: 'text',
+        group: 'Politica de selecao',
+        hint: 'Campo booleano publicado pelo backend para indicar se a entidade pode ser selecionada.',
+    },
+    {
+        name: 'optionSource.selectionPolicy.allowedStatuses',
+        label: 'Status permitidos',
+        editorType: 'textarea',
+        group: 'Politica de selecao',
+        hint: 'JSON array ou uma linha por status. Ex.: ACTIVE, SIGNED.',
+    },
+    {
+        name: 'optionSource.selectionPolicy.blockedStatuses',
+        label: 'Status bloqueados',
+        editorType: 'textarea',
+        group: 'Politica de selecao',
+        hint: 'JSON array ou uma linha por status.',
+    },
+    {
+        name: 'optionSource.selectionPolicy.disabledReasonTemplate',
+        label: 'Template de motivo bloqueado',
+        editorType: 'text',
+        group: 'Politica de selecao',
+        hint: 'Mensagem template exibida quando a entidade nao pode ser selecionada.',
+    },
+    {
+        name: 'optionSource.selectionPolicy.validationMessageTemplate',
+        label: 'Template de validacao',
+        editorType: 'text',
+        group: 'Politica de selecao',
+        hint: 'Mensagem template usada em validacoes de selecao.',
+    },
+    {
+        name: 'optionSource.selectionPolicy.allowRetainInvalidExistingValue',
+        label: 'Manter valor invalido existente',
+        editorType: 'checkbox',
+        group: 'Politica de selecao',
+        hint: 'Exibe entidade historica ja salva mesmo quando nao pode ser selecionada em novos registros.',
+    },
+    {
+        name: 'optionSource.capabilities.filter',
+        label: 'Capability: filter',
+        editorType: 'checkbox',
+        group: 'Capabilities',
+        defaultValue: true,
+    },
+    {
+        name: 'optionSource.capabilities.byIds',
+        label: 'Capability: by-ids',
+        editorType: 'checkbox',
+        group: 'Capabilities',
+        defaultValue: true,
+    },
+    {
+        name: 'optionSource.capabilities.navigateToDetail',
+        label: 'Capability: detalhe',
+        editorType: 'checkbox',
+        group: 'Capabilities',
+    },
+    {
+        name: 'optionSource.capabilities.detail',
+        label: 'Capability: endpoint de detalhe',
+        editorType: 'checkbox',
+        group: 'Capabilities',
+    },
+    {
+        name: 'optionSource.capabilities.edit',
+        label: 'Capability: editar',
+        editorType: 'checkbox',
+        group: 'Capabilities',
+    },
+    {
+        name: 'optionSource.capabilities.create',
+        label: 'Capability: criar',
+        editorType: 'checkbox',
+        group: 'Capabilities',
+    },
+    {
+        name: 'optionSource.capabilities.multiSelect',
+        label: 'Capability: multi-select',
+        editorType: 'checkbox',
+        group: 'Capabilities',
+    },
+    {
+        name: 'optionSource.capabilities.recent',
+        label: 'Capability: recentes',
+        editorType: 'checkbox',
+        group: 'Capabilities',
+    },
+    {
+        name: 'optionSource.capabilities.favorites',
+        label: 'Capability: favoritos',
+        editorType: 'checkbox',
+        group: 'Capabilities',
+    },
+    {
+        name: 'optionSource.capabilities.auditSnapshot',
+        label: 'Capability: snapshot de auditoria',
+        editorType: 'checkbox',
+        group: 'Capabilities',
+    },
+    {
+        name: 'optionSource.detail.hrefTemplate',
+        label: 'Template de detalhe',
+        editorType: 'text',
+        group: 'Navegacao',
+        hint: 'Template de detalhe, por exemplo /contracts/{id}.',
+    },
+    {
+        name: 'optionSource.detail.routeTemplate',
+        label: 'Template de rota',
+        editorType: 'text',
+        group: 'Navegacao',
+        hint: 'Template de rota de detalhe, por exemplo /contracts/:id.',
+    },
+    {
+        name: 'optionSource.detail.openDetailMode',
+        label: 'Modo de detalhe',
+        editorType: 'select',
+        group: 'Navegacao',
+        options: [
+            { value: 'route', text: 'Rota' },
+            { value: 'drawer', text: 'Drawer' },
+            { value: 'dialog', text: 'Dialog' },
+            { value: 'external', text: 'Externo' },
+        ],
+    },
+];
+
 const transferListProperties = [
     // Geral
     { name: 'label', label: 'Label', editorType: 'text', group: 'Geral' },
@@ -5323,7 +5674,7 @@ const INLINE_FILTER_EDITOR_PROPERTIES_BY_CONTROL_TYPE = Object.freeze({
     [INLINE_FILTER_CONTROL_TYPES.SELECT]: selectProperties,
     [INLINE_FILTER_CONTROL_TYPES.SEARCHABLE_SELECT]: selectProperties,
     [INLINE_FILTER_CONTROL_TYPES.ASYNC_SELECT]: selectProperties,
-    [INLINE_FILTER_CONTROL_TYPES.ENTITY_LOOKUP]: selectProperties,
+    [INLINE_FILTER_CONTROL_TYPES.ENTITY_LOOKUP]: entityLookupProperties,
     [INLINE_FILTER_CONTROL_TYPES.AUTOCOMPLETE]: selectProperties,
     [INLINE_FILTER_CONTROL_TYPES.MULTI_SELECT]: selectProperties,
     [INLINE_FILTER_CONTROL_TYPES.INPUT]: inputProperties,
@@ -5380,10 +5731,12 @@ class FieldMetadataEditorComponent {
         { value: FieldControlType.URL_INPUT, label: 'URL' },
         { value: FieldControlType.SEARCH_INPUT, label: 'Busca' },
         { value: FieldControlType.PHONE, label: 'Telefone' },
+        { value: FieldControlType.ARRAY_INPUT, label: 'Colecao editavel' },
         { value: FieldControlType.SELECT, label: 'Seleção (Select)' },
         { value: FieldControlType.MULTI_SELECT, label: 'Seleção múltipla' },
         { value: FieldControlType.SEARCHABLE_SELECT, label: 'Seleção buscável' },
         { value: FieldControlType.ASYNC_SELECT, label: 'Seleção assíncrona' },
+        { value: FieldControlType.ENTITY_LOOKUP, label: 'Entity Lookup' },
         { value: FieldControlType.AUTO_COMPLETE, label: 'Auto-completar' },
         { value: FieldControlType.SELECTION_LIST, label: 'Lista de seleção' },
         { value: FieldControlType.TREE_SELECT, label: 'Árvore (Tree Select)' },
@@ -5471,9 +5824,12 @@ class FieldMetadataEditorComponent {
             return inlineProps;
         if (controlType === FieldControlType.INPUT)
             return inputProperties;
+        if (controlType === FieldControlType.ARRAY_INPUT)
+            return arrayProperties;
+        if (controlTypeToken === 'entitylookup')
+            return entityLookupProperties;
         if (controlTypeToken === 'searchableselect' ||
-            controlTypeToken === 'asyncselect' ||
-            controlTypeToken === 'entitylookup')
+            controlTypeToken === 'asyncselect')
             return selectProperties;
         if (controlType === FieldControlType.NUMERIC_TEXT_BOX)
             return numberProperties;
@@ -5518,6 +5874,8 @@ class FieldMetadataEditorComponent {
             controlType === FieldControlType.AUTO_COMPLETE ||
             controlType === FieldControlType.SELECTION_LIST)
             return selectProperties;
+        if (controlType === FieldControlType.ENTITY_LOOKUP)
+            return entityLookupProperties;
         if (controlType === FieldControlType.TEXTAREA)
             return textareaProperties;
         if (controlType === FieldControlType.TRANSFER_LIST)
@@ -5594,11 +5952,14 @@ class FieldMetadataEditorComponent {
                 this.registry.register(this.controlType, inputProperties);
                 props = inputProperties;
             }
+            else if (controlTypeToken === 'entitylookup') {
+                this.registry.register(this.controlType, entityLookupProperties);
+                props = entityLookupProperties;
+            }
             else if (
             // Aliases for select-like
             controlTypeToken === 'searchableselect' ||
-                controlTypeToken === 'asyncselect' ||
-                controlTypeToken === 'entitylookup') {
+                controlTypeToken === 'asyncselect') {
                 this.registry.register(this.controlType, selectProperties);
                 props = selectProperties;
             }
@@ -5683,6 +6044,10 @@ class FieldMetadataEditorComponent {
                 this.registry.register(this.controlType, selectProperties);
                 props = selectProperties;
             }
+            else if (this.controlType === FieldControlType.ENTITY_LOOKUP) {
+                this.registry.register(this.controlType, entityLookupProperties);
+                props = entityLookupProperties;
+            }
             else if (this.controlType === FieldControlType.TEXTAREA) {
                 this.registry.register(this.controlType, textareaProperties);
                 props = textareaProperties;
@@ -5844,7 +6209,7 @@ class FieldMetadataEditorComponent {
                 const name = p?.name;
                 if (!name)
                     continue;
-                const val = getByPath(this.seed, name);
+                const val = this.toEditorControlValue(p, getByPath(this.seed, name));
                 // Preserve false/0; skip only null/undefined
                 if (val !== undefined && val !== null) {
                     this.factory.setValueByPath(this.form, name, val);
@@ -6154,6 +6519,97 @@ class FieldMetadataEditorComponent {
                 patch.links = parsedLinks;
             }
         }
+        this.normalizeEntityLookupPatchValues(patch);
+        this.normalizeArrayPatchValues(patch);
+    }
+    normalizeEntityLookupPatchValues(patch) {
+        const optionSource = patch?.optionSource;
+        if (!optionSource || typeof optionSource !== 'object') {
+            return;
+        }
+        this.normalizeStringListProperty(optionSource, 'descriptionPropertyPaths');
+        this.normalizeStringListProperty(optionSource, 'searchPropertyPaths');
+        this.normalizeStringListProperty(optionSource, 'dependsOn');
+        this.normalizeJsonObjectProperty(optionSource, 'dependencyFilterMap');
+        const selectionPolicy = optionSource.selectionPolicy;
+        if (selectionPolicy && typeof selectionPolicy === 'object') {
+            this.normalizeStringListProperty(selectionPolicy, 'allowedStatuses');
+            this.normalizeStringListProperty(selectionPolicy, 'blockedStatuses');
+        }
+    }
+    normalizeStringListProperty(target, key) {
+        if (!target || typeof target !== 'object' || typeof target[key] !== 'string') {
+            return;
+        }
+        const parsed = this.parseStringListTextarea(target[key]);
+        if (parsed) {
+            target[key] = parsed;
+        }
+    }
+    normalizeJsonObjectProperty(target, key) {
+        if (!target || typeof target !== 'object' || typeof target[key] !== 'string') {
+            return;
+        }
+        const parsed = this.tryParseJson(String(target[key]).trim());
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            target[key] = parsed;
+        }
+    }
+    normalizeArrayPatchValues(patch) {
+        const arrayPatch = patch?.array;
+        if (!arrayPatch || typeof arrayPatch !== 'object') {
+            return;
+        }
+        const collectionValidation = arrayPatch.collectionValidation;
+        if (collectionValidation &&
+            typeof collectionValidation === 'object' &&
+            typeof collectionValidation.uniqueBy === 'string') {
+            const parsedUniqueBy = this.parseStringListTextarea(collectionValidation.uniqueBy);
+            if (parsedUniqueBy) {
+                collectionValidation.uniqueBy = parsedUniqueBy;
+            }
+        }
+        this.normalizeArrayCountRuleValue(collectionValidation?.exactlyOne);
+        this.normalizeArrayCountRuleValue(collectionValidation?.atLeastOne);
+        const itemSchema = arrayPatch.itemSchema;
+        if (itemSchema &&
+            typeof itemSchema === 'object' &&
+            typeof itemSchema.fields === 'string') {
+            const parsedFields = this.parseArrayTextarea(itemSchema.fields);
+            if (parsedFields) {
+                itemSchema.fields = parsedFields;
+            }
+        }
+        if (typeof patch.defaultValue === 'string') {
+            const parsedDefaultValue = this.parseArrayTextarea(patch.defaultValue);
+            if (parsedDefaultValue) {
+                patch.defaultValue = parsedDefaultValue;
+            }
+        }
+    }
+    normalizeArrayCountRuleValue(rule) {
+        if (!rule || typeof rule !== 'object' || typeof rule.value !== 'string') {
+            return;
+        }
+        const raw = rule.value.trim();
+        if (!raw) {
+            return;
+        }
+        try {
+            rule.value = JSON.parse(raw);
+        }
+        catch {
+            rule.value = raw;
+        }
+    }
+    toEditorControlValue(prop, value) {
+        if (prop?.editorType === 'textarea' &&
+            value !== undefined &&
+            value !== null &&
+            typeof value !== 'string') {
+            return JSON.stringify(value, null, 2);
+        }
+        return value;
     }
     /**
      * Interpreta textarea como lista simples de strings:
@@ -6267,15 +6723,19 @@ class CascadeRulesService {
         return map;
     }
     hydrateRule(field) {
-        const deps = field.dependencyFields;
+        const deps = (field.dependencyFields ??
+            field.optionSource?.dependsOn);
         if (!deps || deps.length === 0)
             return null;
+        const dependencyFilterMap = field.dependencyFilterMap ??
+            field.optionSource?.dependencyFilterMap ??
+            null;
         const vm = {
             targetField: field.name,
             dependencyFields: [...deps],
             enableDependencyCascade: field.enableDependencyCascade === false ? false : true,
             resetOnDependentChange: !!field.resetOnDependentChange,
-            dependencyFilterMap: field.dependencyFilterMap || null,
+            dependencyFilterMap,
             dependencyValuePath: field.dependencyValuePath || null,
             dependencyMergeStrategy: field.dependencyMergeStrategy || 'merge',
             dependencyDebounceMs: field.dependencyDebounceMs != null

package/index.d.ts

@@ -153,6 +153,12 @@ declare class FieldMetadataEditorComponent implements OnInit {
      * Evita persistir strings cruas quando o componente espera arrays.
      */
     private normalizeKnownTextareaPatchValues;
+    private normalizeEntityLookupPatchValues;
+    private normalizeStringListProperty;
+    private normalizeJsonObjectProperty;
+    private normalizeArrayPatchValues;
+    private normalizeArrayCountRuleValue;
+    private toEditorControlValue;
     /**
      * Interpreta textarea como lista simples de strings:
      * - JSON array de strings

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@praxisui/metadata-editor",
-  "version": "8.0.0-beta.8",
+  "version": "8.0.0-beta.9",
   "description": "Metadata editor for Praxis UI fields and components with runtime integration.",
   "peerDependencies": {
     "@angular/common": "^20.0.0",