@praxisui/metadata-editor 0.0.1

package/index.d.ts

@@ -0,0 +1,237 @@
+import { ValidatorFn, FormBuilder, FormGroup, AbstractControl } from '@angular/forms';
+import { FieldControlType, FieldDefinition, FieldMetadata, IconPickerService } from '@praxisui/core';
+import * as i0 from '@angular/core';
+import { Type, OnChanges, SimpleChanges, OnInit, EventEmitter } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { BehaviorSubject } from 'rxjs';
+
+/** Descreve uma propriedade editável do FieldDefinition alvo. */
+interface EditorProperty {
+    name: string;
+    label: string;
+    editorType: 'text' | 'number' | 'textarea' | 'select' | 'checkbox' | string;
+    defaultValue?: any;
+    placeholder?: string;
+    hint?: string;
+    required?: boolean;
+    options?: Array<{
+        value: any;
+        text: string;
+    }> | {
+        type: 'static' | 'http' | 'fn';
+        config?: any;
+    };
+    validators?: ValidatorFn[];
+    visibleWhen?: (formValue: any) => boolean;
+    group?: string;
+    row?: string;
+    inline?: boolean;
+    order?: number;
+    [key: string]: any;
+}
+type ConfigMap = Record<FieldControlType, EditorProperty[]>;
+
+declare class ConfigRegistryService {
+    private readonly map;
+    register(controlType: FieldControlType, props: EditorProperty[]): void;
+    getProperties(controlType: FieldControlType): EditorProperty[];
+    list(): Array<{
+        controlType: FieldControlType;
+        count: number;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigRegistryService>;
+}
+
+declare class ContextValidatorRegistryService {
+    private readonly map;
+    register(controlType: FieldControlType, validator: ValidatorFn): void;
+    get(controlType: FieldControlType): ValidatorFn[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextValidatorRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ContextValidatorRegistryService>;
+}
+
+declare class SchemaNormalizerService {
+    /** Normaliza propriedades e aplica defaultValue resolvendo do seed por dot-path. */
+    normalize(properties: EditorProperty[], seed?: Partial<FieldDefinition>): EditorProperty[];
+    /** Lê valor por dot-path */
+    private getByPath;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SchemaNormalizerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SchemaNormalizerService>;
+}
+
+declare class DynamicFormFactoryService {
+    private fb;
+    private ctxValidators;
+    constructor(fb: FormBuilder, ctxValidators: ContextValidatorRegistryService);
+    createEditorForm(controlType: FieldControlType, props: EditorProperty[], seed?: Partial<FieldDefinition>): FormGroup;
+    getControlByPath(form: FormGroup, path: string): AbstractControl | null;
+    setValueByPath(form: FormGroup, path: string, value: any): void;
+    extractPatch(form: FormGroup): Partial<FieldDefinition>;
+    mergeIntoFieldDefinition(base: FieldDefinition, patch: Partial<FieldDefinition>): FieldDefinition;
+    private assignControlByPath;
+    private deepMerge;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormFactoryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DynamicFormFactoryService>;
+}
+
+declare class EditorComponentRegistryService {
+    private readonly registry;
+    private readonly cache;
+    register(editorType: string, loader: () => Promise<Type<any>>): void;
+    get(editorType: string): Promise<Type<any> | null>;
+    isRegistered(editorType: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditorComponentRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EditorComponentRegistryService>;
+}
+
+declare class DynamicEditorRendererComponent implements OnChanges {
+    private dialog;
+    private iconPicker;
+    properties: EditorProperty[];
+    form: FormGroup;
+    fields: FieldMetadata[];
+    groupFields: Record<string, FieldMetadata[]>;
+    groupOrder: string[];
+    groupRows: Record<string, FieldMetadata[][]>;
+    ready: boolean;
+    ngOnChanges(changes: SimpleChanges): void;
+    private toFieldMetadata;
+    private groupWeight;
+    isInitiallyExpanded(_group: string): boolean;
+    rowClass(row: FieldMetadata[]): string;
+    private mapEditorType;
+    groupIcon(group: string): string;
+    constructor(dialog: MatDialog, iconPicker: IconPickerService);
+    isIconField(path: string): boolean;
+    openRegexHelp(): void;
+    openIconPicker(path: string): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicEditorRendererComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicEditorRendererComponent, "praxis-dynamic-editor-renderer", never, { "properties": { "alias": "properties"; "required": false; }; "form": { "alias": "form"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class FieldMetadataEditorComponent implements OnInit {
+    private registry;
+    private normalizer;
+    private factory;
+    private ctxValidators;
+    controlType: FieldControlType;
+    seed?: Partial<FieldDefinition>;
+    applied: EventEmitter<Partial<FieldDefinition>>;
+    cancel: EventEmitter<void>;
+    form: FormGroup;
+    normalizedProps: any[];
+    private initialSnapshot;
+    private baselineReady;
+    typeOptions: Array<{
+        value: FieldControlType;
+        label: string;
+    }>;
+    isDirty$: BehaviorSubject<boolean>;
+    isValid$: BehaviorSubject<boolean>;
+    isBusy$: BehaviorSubject<boolean>;
+    constructor(registry: ConfigRegistryService, normalizer: SchemaNormalizerService, factory: DynamicFormFactoryService, ctxValidators: ContextValidatorRegistryService);
+    ngOnInit(): void;
+    private rebuildEditorForType;
+    apply(): void;
+    onSave(): Partial<FieldDefinition> | undefined;
+    getSettingsValue(): Partial<FieldDefinition>;
+    /**
+     * Constrói um patch delta a partir do valor atual do form, removendo
+     * chaves não alteradas e valores nulos/strings vazias (exceto boolean/zero).
+     */
+    private buildDeltaPatch;
+    reset(): void;
+    onControlTypeChange(next: FieldControlType): void;
+    onControlTypeChangeEvent(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FieldMetadataEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FieldMetadataEditorComponent, "praxis-field-metadata-editor", never, { "controlType": { "alias": "controlType"; "required": false; }; "seed": { "alias": "seed"; "required": false; }; }, { "applied": "applied"; "cancel": "cancel"; }, never, never, true, never>;
+}
+
+interface CascadeRuleViewModel {
+    targetField: string;
+    dependencyFields: string[];
+    enableDependencyCascade: boolean;
+    resetOnDependentChange: boolean;
+    dependencyFilterMap?: Record<string, any> | null;
+    dependencyValuePath?: string | Record<string, string> | null;
+    dependencyMergeStrategy?: 'merge' | 'replace';
+    dependencyDebounceMs?: number | null;
+    dependencyLoadOnChange?: 'respectLoadOn' | 'immediate' | 'manual';
+}
+declare class CascadeRulesService {
+    getFieldLabelMap(fields: Array<FieldDefinition | FieldMetadata>): Map<string, string>;
+    hydrateRule(field: FieldDefinition | FieldMetadata): CascadeRuleViewModel | null;
+    dehydratePatch(rule: CascadeRuleViewModel): Partial<FieldDefinition>;
+    /** Suggest a basic mapping dep->dep and a default valuePath */
+    suggest(rule: CascadeRuleViewModel, inferredValueKey?: string): CascadeRuleViewModel;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CascadeRulesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CascadeRulesService>;
+}
+
+declare class CascadeManagerTabComponent implements OnChanges {
+    private readonly svc;
+    fields: Array<FieldDefinition | FieldMetadata>;
+    connections?: Array<{
+        toFieldName: string;
+        toInputPath: string;
+    }>;
+    apply: EventEmitter<Record<string, Partial<FieldDefinition>>>;
+    cancel: EventEmitter<void>;
+    searchTerm: string;
+    private searchTimer;
+    private searchValue;
+    private readonly rules;
+    private readonly selectedFieldSig;
+    readonly editing: i0.WritableSignal<boolean>;
+    editDepCsv: string;
+    editEnable: boolean;
+    editReset: boolean;
+    editMerge: 'merge' | 'replace';
+    editLoadOn: 'respectLoadOn' | 'immediate' | 'manual';
+    editDebounce: number | null;
+    editValuePath: string;
+    editFilterMapJson: string;
+    importMode: boolean;
+    importJson: string;
+    editMapRows: Array<{
+        dep: string;
+        key: string;
+        valuePath?: string;
+    }>;
+    constructor(svc: CascadeRulesService);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    filteredFields(): Array<FieldDefinition | FieldMetadata>;
+    labelFor(name: string): string;
+    selectedField(): string | null;
+    selectField(name: string): void;
+    hasRule(name: string): boolean;
+    ruleFor(name: string): CascadeRuleViewModel | null;
+    isCascadeEnabled(name: string): boolean;
+    loadOnChange(name: string): 'respectLoadOn' | 'immediate' | 'manual';
+    hasConflict(name: string): boolean;
+    startEdit(name: string): void;
+    edit(name: string): void;
+    cancelEdit(): void;
+    saveEdit(name: string): void;
+    remove(name: string): void;
+    quickSet(name: string, action: 'disable' | 'manual'): void;
+    private emitPatch;
+    onSearchChange(val: string): void;
+    onFieldKeydown(event: KeyboardEvent, name: string): void;
+    hasField(name: string): boolean;
+    toggleImport(): void;
+    exportRules(): void;
+    applyImport(): void;
+    startTemplate(name: string, tpl: 'rota-destino' | 'rota-destino-propriedade'): void;
+    buildMapRowsFromDeps(): void;
+    buildValuePathOverrides(deps: string[]): string | Record<string, string>;
+    buildPreview(): string;
+    copyPreview(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CascadeManagerTabComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CascadeManagerTabComponent, "praxis-cascade-manager-tab", never, { "fields": { "alias": "fields"; "required": false; }; "connections": { "alias": "connections"; "required": false; }; }, { "apply": "apply"; "cancel": "cancel"; }, never, never, true, never>;
+}
+
+export { CascadeManagerTabComponent, CascadeRulesService, ConfigRegistryService, ContextValidatorRegistryService, DynamicEditorRendererComponent, DynamicFormFactoryService, EditorComponentRegistryService, FieldMetadataEditorComponent, SchemaNormalizerService };
+export type { CascadeRuleViewModel, ConfigMap, EditorProperty };

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@praxisui/metadata-editor",
+  "version": "0.0.1",
+  "peerDependencies": {
+    "@angular/common": "^20.0.0",
+    "@angular/core": "^20.0.0"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/codexrodrigues/praxis"
+  },
+  "homepage": "https://github.com/codexrodrigues/praxis#readme",
+  "bugs": {
+    "url": "https://github.com/codexrodrigues/praxis/issues"
+  },
+  "sideEffects": false,
+  "module": "fesm2022/praxisui-metadata-editor.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./fesm2022/praxisui-metadata-editor.mjs"
+    }
+  }
+}