@praxisui/manual-form 0.0.1

package/fesm2022/praxisui-manual-form.mjs

@@ -0,0 +1,1592 @@
+import { ensureIds, DynamicFormService, CONFIG_STORAGE, FieldControlType } from '@praxisui/core';
+import * as i0 from '@angular/core';
+import { inject, Optional, Inject, Injectable, input, output, ChangeDetectionStrategy, Component, Input, InjectionToken, isDevMode, ChangeDetectorRef, DestroyRef, ContentChildren, Directive, HostListener } from '@angular/core';
+import { BehaviorSubject, debounceTime } from 'rxjs';
+import * as i1 from '@angular/common';
+import { CommonModule } from '@angular/common';
+import * as i2 from '@angular/forms';
+import { FormGroupDirective, FormGroup, FormControl, Validators, ReactiveFormsModule, FormControlName, ControlContainer, FormsModule } from '@angular/forms';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import * as i3 from '@praxisui/settings-panel';
+import { SettingsPanelService, SETTINGS_PANEL_DATA, SETTINGS_PANEL_REF } from '@praxisui/settings-panel';
+
+function deepClone(value) {
+    if (typeof globalThis?.structuredClone === 'function') {
+        return globalThis.structuredClone(value);
+    }
+    try {
+        return JSON.parse(JSON.stringify(value));
+    }
+    catch {
+        if (Array.isArray(value)) {
+            return value.slice();
+        }
+        if (value && typeof value === 'object') {
+            return { ...value };
+        }
+        return value;
+    }
+}
+
+function createManualFormSeed(formId, config, options = {}) {
+    const cloned = deepClone(config);
+    const normalized = ensureIds(cloned);
+    normalized.fieldMetadata = (normalized.fieldMetadata || []).map((fm) => ({ ...fm }));
+    return {
+        formId,
+        config: normalized,
+        source: options.source ?? 'local',
+        version: options.version ?? normalized.metadata?.version,
+        context: options.context,
+    };
+}
+function toFieldMetadataMap(fieldMetadata) {
+    const map = new Map();
+    for (const meta of fieldMetadata || []) {
+        if (!meta?.name)
+            continue;
+        map.set(meta.name, { ...meta });
+    }
+    return map;
+}
+
+/**
+ * Runtime instance that keeps manual form configuration, metadata and
+ * FormGroup in sync. The instance is created through the factory below so the
+ * host applications do not need to manage storage or dynamic form services.
+ */
+class ManualFormInstance {
+    formId;
+    seed;
+    dynamicFormService;
+    storage;
+    persistenceOptions;
+    formConfig$;
+    fieldMetadata$;
+    state$;
+    formGroup;
+    boundComponents = new Map();
+    constructor(formId, seed, initialConfig, dynamicFormService, storage, persistenceOptions, externalForm) {
+        this.formId = formId;
+        this.seed = seed;
+        this.dynamicFormService = dynamicFormService;
+        this.storage = storage;
+        this.persistenceOptions = persistenceOptions;
+        const configClone = deepClone(initialConfig);
+        const metadataMap = toFieldMetadataMap(configClone.fieldMetadata);
+        this.formConfig$ = new BehaviorSubject(configClone);
+        this.fieldMetadata$ = new BehaviorSubject(metadataMap);
+        if (externalForm) {
+            this.formGroup = externalForm;
+            // Ensure controls exist and match metadata on the provided form
+            this.cloneFieldMetadata(metadataMap).forEach((meta) => {
+                try {
+                    this.dynamicFormService.updateControlFromMetadata(this.formGroup, meta, {
+                        emitEvent: false,
+                    });
+                }
+                catch {
+                    /* ignore */
+                }
+            });
+        }
+        else {
+            this.formGroup = this.dynamicFormService.createFormGroupFromMetadata(this.cloneFieldMetadata(metadataMap));
+        }
+        this.state$ = new BehaviorSubject({
+            formId: this.formId,
+            config: deepClone(configClone),
+            fields: this.cloneFieldMetadata(metadataMap),
+        });
+    }
+    /** Observable stream for consumers interested in config mutations. */
+    get stateChanges$() {
+        return this.state$.asObservable();
+    }
+    get formConfigChanges$() {
+        return this.formConfig$.asObservable();
+    }
+    get fieldMetadataChanges$() {
+        return this.fieldMetadata$.asObservable();
+    }
+    get currentConfig() {
+        return this.formConfig$.value;
+    }
+    get currentFieldMetadata() {
+        return this.fieldMetadata$.value;
+    }
+    get form() {
+        return this.formGroup;
+    }
+    /** Retrieve metadata for a specific field (cloned to avoid mutations). */
+    getFieldMetadata(fieldName) {
+        const meta = this.fieldMetadata$.value.get(fieldName);
+        return meta ? { ...meta } : undefined;
+    }
+    /**
+     * Registers a component instance to receive metadata updates for the
+     * specified field. Helpful for manual templates that wish to keep hot-update
+     * behaviour without wiring everything manually.
+     */
+    bindComponent(fieldName, componentInstance) {
+        if (!fieldName || !componentInstance) {
+            return;
+        }
+        this.boundComponents.set(fieldName, componentInstance);
+        this.refreshBoundComponent(fieldName);
+    }
+    unbindComponent(fieldName) {
+        this.boundComponents.delete(fieldName);
+    }
+    /**
+     * Applies a partial metadata patch to a field and propagates the changes to
+     * the FormConfig, runtime FormGroup and state streams.
+     */
+    patchFieldMetadata(fieldName, patch) {
+        const current = this.fieldMetadata$.value.get(fieldName);
+        if (!current) {
+            return;
+        }
+        const next = this.deepMerge(current, patch);
+        this.fieldMetadata$.value.set(fieldName, next);
+        this.fieldMetadata$.next(new Map(this.fieldMetadata$.value));
+        const configClone = deepClone(this.formConfig$.value);
+        configClone.fieldMetadata = (configClone.fieldMetadata || []).map((fm) => fm.name === fieldName ? { ...next } : fm);
+        this.publishConfig(configClone);
+        try {
+            this.dynamicFormService.updateControlFromMetadata(this.formGroup, next, {
+                emitEvent: false,
+            });
+        }
+        catch {
+            /* Defensive: control might not exist if form is customised manually. */
+        }
+        this.refreshBoundComponent(fieldName);
+    }
+    /** Replaces the entire FormConfig, typically used after reconciling with backend seeds. */
+    replaceConfig(config) {
+        const cloned = deepClone(config);
+        this.fieldMetadata$.next(toFieldMetadataMap(cloned.fieldMetadata));
+        this.publishConfig(cloned);
+        const metadataList = this.getFieldMetadataArray();
+        // Rebuild controls to ensure validators align with the new metadata.
+        metadataList.forEach((meta) => {
+            try {
+                this.dynamicFormService.updateControlFromMetadata(this.formGroup, meta, {
+                    emitEvent: false,
+                });
+            }
+            catch {
+                /* ignore */
+            }
+        });
+        // Refresh all bound components with the new metadata references.
+        for (const fieldName of this.boundComponents.keys()) {
+            this.refreshBoundComponent(fieldName);
+        }
+    }
+    /** Restores configuration back to the original seed definition. */
+    resetToSeed() {
+        this.replaceConfig(this.seed.config);
+    }
+    /**
+     * Persists the current configuration and, optionally, the provided form value
+     * using ConfigStorage. By default, stores the FormGroup raw value.
+     */
+    saveDraft(value = null) {
+        if (!this.storage) {
+            return;
+        }
+        const key = buildStorageKey(this.formId, this.persistenceOptions);
+        const payload = {
+            config: deepClone(this.formConfig$.value),
+            value: value ?? this.formGroup.getRawValue(),
+            metadata: {
+                savedAt: new Date().toISOString(),
+                savedBy: this.persistenceOptions?.profileId,
+                host: this.persistenceOptions?.namespace,
+            },
+            version: this.seed.version,
+        };
+        this.storage.saveConfig(key, payload);
+    }
+    publishConfig(config) {
+        this.formConfig$.next(config);
+        this.state$.next({
+            formId: this.formId,
+            config: deepClone(config),
+            fields: this.getFieldMetadataArray(),
+        });
+    }
+    getFieldMetadataArray() {
+        return this.cloneFieldMetadata();
+    }
+    cloneFieldMetadata(map = this.fieldMetadata$.value) {
+        return Array.from(map.values()).map((fm) => ({ ...fm }));
+    }
+    refreshBoundComponent(fieldName) {
+        const component = this.boundComponents.get(fieldName);
+        if (!component) {
+            return;
+        }
+        const metadata = this.fieldMetadata$.value.get(fieldName);
+        if (!metadata) {
+            return;
+        }
+        try {
+            if (typeof component?.setInputMetadata === 'function') {
+                component.setInputMetadata({ ...metadata });
+                // fallthrough to also apply visibility state on host
+            }
+            const metaProp = component?.metadata;
+            if (metaProp && typeof metaProp === 'object') {
+                if (typeof metaProp.set === 'function') {
+                    metaProp.set({ ...metadata });
+                    // fallthrough to also apply visibility state on host
+                }
+            }
+            if (!metaProp || typeof metaProp.set !== 'function') {
+                component.metadata = { ...metadata };
+            }
+            // Apply visibility to component and host element for manual templates
+            const isHidden = !!metadata.hidden || !!metadata.formHidden;
+            if ('visible' in component) {
+                try {
+                    component.visible = !isHidden;
+                }
+                catch { }
+            }
+            const hostEl = component?.elementRef?.nativeElement;
+            if (hostEl) {
+                hostEl.style.display = isHidden ? 'none' : '';
+                hostEl.setAttribute('aria-hidden', String(isHidden));
+            }
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    /** Deep-merge helper to preserve nested objects (e.g., clearButton.icon + enabled). */
+    deepMerge(target, source) {
+        if (source == null || typeof source !== 'object')
+            return { ...target };
+        const out = Array.isArray(target) ? [...target] : { ...target };
+        for (const [k, v] of Object.entries(source)) {
+            if (v && typeof v === 'object' && !Array.isArray(v)) {
+                out[k] = this.deepMerge(out[k] ?? {}, v);
+            }
+            else {
+                out[k] = v;
+            }
+        }
+        return out;
+    }
+}
+/**
+ * Factory service used to create ManualFormInstance objects with the required
+ * dependencies injected from Angular's DI container.
+ */
+class ManualFormInstanceFactory {
+    storage;
+    dynamicFormService = inject(DynamicFormService);
+    constructor(storage) {
+        this.storage = storage;
+    }
+    create(seed, options = {}, externalForm) {
+        const persisted = this.loadPersistedSnapshot(seed.formId, options);
+        const baseConfig = persisted?.config ?? deepClone(seed.config);
+        const instance = new ManualFormInstance(seed.formId, seed, baseConfig, this.dynamicFormService, this.storage, options, externalForm);
+        // Apply persisted value if present.
+        if (persisted?.value) {
+            instance.form.patchValue(persisted.value, { emitEvent: false });
+        }
+        return instance;
+    }
+    loadPersistedSnapshot(formId, options) {
+        if (!this.storage) {
+            return undefined;
+        }
+        const key = buildStorageKey(formId, options);
+        return this.storage.loadConfig(key) ?? undefined;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: ManualFormInstanceFactory, deps: [{ token: CONFIG_STORAGE, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: ManualFormInstanceFactory, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: ManualFormInstanceFactory, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [CONFIG_STORAGE]
+                }] }] });
+function buildStorageKey(formId, options = {}) {
+    const parts = ['manual-form', options.namespace, options.tenantId, options.profileId, formId]
+        .filter(Boolean)
+        .map((segment) => String(segment));
+    return parts.join(':');
+}
+
+class ManualFormHeaderComponent {
+    instance = input(...(ngDevMode ? [undefined, { debugName: "instance" }] : []));
+    title = input(...(ngDevMode ? [undefined, { debugName: "title" }] : []));
+    description = input(...(ngDevMode ? [undefined, { debugName: "description" }] : []));
+    saveLabel = input('Salvar customizações', ...(ngDevMode ? [{ debugName: "saveLabel" }] : []));
+    resetLabel = input('Restaurar padrão', ...(ngDevMode ? [{ debugName: "resetLabel" }] : []));
+    editModeEnabled = input(false, ...(ngDevMode ? [{ debugName: "editModeEnabled" }] : []));
+    editFormLabel = input('Editar formulário', ...(ngDevMode ? [{ debugName: "editFormLabel" }] : []));
+    save = output();
+    reset = output();
+    editForm = output();
+    fallbackTitle = 'Formulário manual';
+    get metadata() {
+        return this.instance()?.currentConfig?.metadata;
+    }
+    get firstSection() {
+        return this.instance()?.currentConfig?.sections?.[0];
+    }
+    get displayTitle() {
+        return (this.title() ||
+            this.metadata?.title ||
+            this.firstSection?.title ||
+            this.fallbackTitle);
+    }
+    get displayDescription() {
+        return (this.description() ||
+            this.metadata?.description ||
+            this.firstSection?.description ||
+            undefined);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: ManualFormHeaderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.1.4", type: ManualFormHeaderComponent, isStandalone: true, selector: "praxis-manual-form-header", inputs: { instance: { classPropertyName: "instance", publicName: "instance", isSignal: true, isRequired: false, transformFunction: null }, title: { classPropertyName: "title", publicName: "title", isSignal: true, isRequired: false, transformFunction: null }, description: { classPropertyName: "description", publicName: "description", isSignal: true, isRequired: false, transformFunction: null }, saveLabel: { classPropertyName: "saveLabel", publicName: "saveLabel", isSignal: true, isRequired: false, transformFunction: null }, resetLabel: { classPropertyName: "resetLabel", publicName: "resetLabel", isSignal: true, isRequired: false, transformFunction: null }, editModeEnabled: { classPropertyName: "editModeEnabled", publicName: "editModeEnabled", isSignal: true, isRequired: false, transformFunction: null }, editFormLabel: { classPropertyName: "editFormLabel", publicName: "editFormLabel", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { save: "save", reset: "reset", editForm: "editForm" }, ngImport: i0, template: `
+    <header class="pdx-manual-form__header">
+      <div class="pdx-manual-form__title">
+        <h2>{{ displayTitle }}</h2>
+        @if (displayDescription) {
+          <p class="pdx-manual-form__subtitle">
+            {{ displayDescription }}
+          </p>
+        }
+      </div>
+      <div class="pdx-manual-form__header-actions">
+        @if (editModeEnabled()) {
+          <button type="button" (click)="editForm.emit()" [attr.aria-label]="editFormLabel()">{{ editFormLabel() }}</button>
+        }
+        <button type="button" (click)="reset.emit()" [attr.aria-label]="resetLabel()">{{ resetLabel() }}</button>
+        <button type="button" (click)="save.emit()" [attr.aria-label]="saveLabel()">{{ saveLabel() }}</button>
+      </div>
+    </header>
+  `, isInline: true, styles: [":host{display:block}.pdx-manual-form__header{display:flex;justify-content:space-between;align-items:center;gap:1rem;margin-bottom:1.5rem}.pdx-manual-form__title h2{margin:0;font-size:1.5rem}.pdx-manual-form__subtitle{margin:.25rem 0 0;color:#0009}.pdx-manual-form__header-actions{display:flex;gap:.5rem}button[type=button]{padding:.5rem 1rem;border-radius:4px;border:1px solid rgba(15,23,42,.1);background:#fff;cursor:pointer}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: ManualFormHeaderComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'praxis-manual-form-header', standalone: true, imports: [CommonModule], template: `
+    <header class="pdx-manual-form__header">
+      <div class="pdx-manual-form__title">
+        <h2>{{ displayTitle }}</h2>
+        @if (displayDescription) {
+          <p class="pdx-manual-form__subtitle">
+            {{ displayDescription }}
+          </p>
+        }
+      </div>
+      <div class="pdx-manual-form__header-actions">
+        @if (editModeEnabled()) {
+          <button type="button" (click)="editForm.emit()" [attr.aria-label]="editFormLabel()">{{ editFormLabel() }}</button>
+        }
+        <button type="button" (click)="reset.emit()" [attr.aria-label]="resetLabel()">{{ resetLabel() }}</button>
+        <button type="button" (click)="save.emit()" [attr.aria-label]="saveLabel()">{{ saveLabel() }}</button>
+      </div>
+    </header>
+  `, changeDetection: ChangeDetectionStrategy.OnPush, styles: [":host{display:block}.pdx-manual-form__header{display:flex;justify-content:space-between;align-items:center;gap:1rem;margin-bottom:1.5rem}.pdx-manual-form__title h2{margin:0;font-size:1.5rem}.pdx-manual-form__subtitle{margin:.25rem 0 0;color:#0009}.pdx-manual-form__header-actions{display:flex;gap:.5rem}button[type=button]{padding:.5rem 1rem;border-radius:4px;border:1px solid rgba(15,23,42,.1);background:#fff;cursor:pointer}\n"] }]
+        }] });
+
+class ManualFormActionsComponent {
+    actions = input(...(ngDevMode ? [undefined, { debugName: "actions" }] : []));
+    trackByFn = null;
+    actionClick = output();
+    isVisible(action) {
+        return action ? action.visible !== false : false;
+    }
+    emit(kind, action) {
+        if (action?.action) {
+            this.actionClick.emit(action.action);
+        }
+        else {
+            this.actionClick.emit(kind);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: ManualFormActionsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.1.4", type: ManualFormActionsComponent, isStandalone: true, selector: "praxis-manual-form-actions", inputs: { actions: { classPropertyName: "actions", publicName: "actions", isSignal: true, isRequired: false, transformFunction: null }, trackByFn: { classPropertyName: "trackByFn", publicName: "trackByFn", isSignal: false, isRequired: false, transformFunction: null } }, outputs: { actionClick: "actionClick" }, ngImport: i0, template: `
+    @if (actions(); as layout) {
+      <footer class="pdx-manual-form__actions">
+        <div class="pdx-manual-form__actions-secondary">
+          @if (layout.cancel; as cancel) {
+            @if (isVisible(cancel)) {
+              <button type="button" [disabled]="cancel.disabled" (click)="emit('cancel', cancel)">
+                {{ cancel.label || 'Cancelar' }}
+              </button>
+            }
+          }
+          @if (layout.reset; as resetBtn) {
+            @if (isVisible(resetBtn)) {
+              <button type="button" [disabled]="resetBtn.disabled" (click)="emit('reset', resetBtn)">
+                {{ resetBtn.label || 'Resetar' }}
+              </button>
+            }
+          }
+          @for (action of layout.custom || []; track trackByFn ? trackByFn($index, action) : (action?.id || $index)) {
+            @if (isVisible(action)) {
+              <button type="button" [disabled]="action.disabled" (click)="emit(action.id || 'custom', action)">
+                {{ action.label || action.id || 'Ação' }}
+              </button>
+            }
+          }
+        </div>
+        <div class="pdx-manual-form__actions-primary">
+          @if (layout.submit; as submitBtn) {
+            @if (isVisible(submitBtn)) {
+              <button type="submit" [disabled]="submitBtn.disabled" (click)="emit('submit', submitBtn)">
+                {{ submitBtn.label || 'Salvar' }}
+              </button>
+            }
+          }
+        </div>
+      </footer>
+    }
+  `, isInline: true, styles: [":host{display:block}.pdx-manual-form__actions{display:flex;justify-content:space-between;align-items:center;gap:1rem;margin-top:2rem}.pdx-manual-form__actions-secondary,.pdx-manual-form__actions-primary{display:flex;gap:.5rem}button{padding:.5rem 1rem;border-radius:4px;border:1px solid rgba(15,23,42,.1);background:#fff;cursor:pointer}.pdx-manual-form__actions-primary button{background:#1d4ed8;color:#fff;border-color:#1d4ed8}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: ManualFormActionsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'praxis-manual-form-actions', standalone: true, imports: [CommonModule], template: `
+    @if (actions(); as layout) {
+      <footer class="pdx-manual-form__actions">
+        <div class="pdx-manual-form__actions-secondary">
+          @if (layout.cancel; as cancel) {
+            @if (isVisible(cancel)) {
+              <button type="button" [disabled]="cancel.disabled" (click)="emit('cancel', cancel)">
+                {{ cancel.label || 'Cancelar' }}
+              </button>
+            }
+          }
+          @if (layout.reset; as resetBtn) {
+            @if (isVisible(resetBtn)) {
+              <button type="button" [disabled]="resetBtn.disabled" (click)="emit('reset', resetBtn)">
+                {{ resetBtn.label || 'Resetar' }}
+              </button>
+            }
+          }
+          @for (action of layout.custom || []; track trackByFn ? trackByFn($index, action) : (action?.id || $index)) {
+            @if (isVisible(action)) {
+              <button type="button" [disabled]="action.disabled" (click)="emit(action.id || 'custom', action)">
+                {{ action.label || action.id || 'Ação' }}
+              </button>
+            }
+          }
+        </div>
+        <div class="pdx-manual-form__actions-primary">
+          @if (layout.submit; as submitBtn) {
+            @if (isVisible(submitBtn)) {
+              <button type="submit" [disabled]="submitBtn.disabled" (click)="emit('submit', submitBtn)">
+                {{ submitBtn.label || 'Salvar' }}
+              </button>
+            }
+          }
+        </div>
+      </footer>
+    }
+  `, changeDetection: ChangeDetectionStrategy.OnPush, styles: [":host{display:block}.pdx-manual-form__actions{display:flex;justify-content:space-between;align-items:center;gap:1rem;margin-top:2rem}.pdx-manual-form__actions-secondary,.pdx-manual-form__actions-primary{display:flex;gap:.5rem}button{padding:.5rem 1rem;border-radius:4px;border:1px solid rgba(15,23,42,.1);background:#fff;cursor:pointer}.pdx-manual-form__actions-primary button{background:#1d4ed8;color:#fff;border-color:#1d4ed8}\n"] }]
+        }], propDecorators: { trackByFn: [{
+                type: Input
+            }] } });
+
+const MANUAL_FORM_SELECTOR_TO_CONTROL_TYPE = new InjectionToken('MANUAL_FORM_SELECTOR_TO_CONTROL_TYPE');
+const MANUAL_FORM_CONSTRUCTOR_TO_CONTROL_TYPE = new InjectionToken('MANUAL_FORM_CONSTRUCTOR_TO_CONTROL_TYPE');
+
+class ManualFieldMetadataBridgeService {
+    patchSignatures = new WeakMap();
+    settingsPanel = inject(SettingsPanelService);
+    buildEditorSeed(instance, fieldName) {
+        return instance.getFieldMetadata(fieldName);
+    }
+    applyPatch(instance, fieldName, patch) {
+        instance.patchFieldMetadata(fieldName, patch);
+    }
+    async openEditor(instance, fieldName) {
+        if (!instance || !fieldName) {
+            return;
+        }
+        const seed = this.buildEditorSeed(instance, fieldName);
+        if (!seed) {
+            if (isDevMode()) {
+                try {
+                    console.warn('[ManualFieldMetadataBridge] metadata not found for field', fieldName);
+                }
+                catch { }
+            }
+            return;
+        }
+        let FieldMetadataEditorComponent;
+        try {
+            const module = await import('@praxisui/metadata-editor');
+            FieldMetadataEditorComponent = module?.FieldMetadataEditorComponent;
+            if (!FieldMetadataEditorComponent) {
+                throw new Error('FieldMetadataEditorComponent export missing');
+            }
+        }
+        catch (err) {
+            if (isDevMode()) {
+                try {
+                    console.error('[ManualFieldMetadataBridge] failed to load @praxisui/metadata-editor', err);
+                }
+                catch { }
+            }
+            return;
+        }
+        const controlType = seed?.controlType;
+        const title = this.buildPanelTitle(fieldName, seed);
+        const panelId = this.buildPanelId(instance, fieldName);
+        let ref;
+        try {
+            ref = this.settingsPanel.open({
+                id: panelId,
+                title,
+                titleIcon: this.resolveIcon(controlType),
+                content: {
+                    component: FieldMetadataEditorComponent,
+                    inputs: {
+                        controlType,
+                        seed,
+                        hostBridge: {
+                            applyPatch: (patch) => this.handlePatch(instance, fieldName, patch),
+                        },
+                    },
+                },
+            });
+        }
+        catch (err) {
+            if (isDevMode()) {
+                try {
+                    console.error('[ManualFieldMetadataBridge] failed to open settings panel', err);
+                }
+                catch { }
+            }
+            return;
+        }
+        ref.applied$.subscribe((patch) => this.handlePatch(instance, fieldName, patch));
+        ref.saved$.subscribe((patch) => this.handlePatch(instance, fieldName, patch));
+    }
+    handlePatch(instance, fieldName, patch) {
+        if (!patch || typeof patch !== 'object') {
+            return;
+        }
+        if (!this.shouldApplyPatch(instance, fieldName, patch)) {
+            return;
+        }
+        this.applyPatch(instance, fieldName, patch);
+        try {
+            instance.saveDraft();
+        }
+        catch (err) {
+            if (isDevMode()) {
+                try {
+                    console.error('[ManualFieldMetadataBridge] failed to persist draft after patch', err);
+                }
+                catch { }
+            }
+        }
+    }
+    shouldApplyPatch(instance, fieldName, patch) {
+        let fieldsMap = this.patchSignatures.get(instance);
+        if (!fieldsMap) {
+            fieldsMap = new Map();
+            this.patchSignatures.set(instance, fieldsMap);
+        }
+        const now = Date.now();
+        let signature = '';
+        try {
+            signature = JSON.stringify(patch);
+        }
+        catch {
+            signature = `${now}`;
+        }
+        const existing = fieldsMap.get(fieldName);
+        if (existing && existing.sig === signature && now - existing.at < 1200) {
+            if (isDevMode()) {
+                try {
+                    console.debug('[ManualFieldMetadataBridge] duplicate patch ignored', { fieldName });
+                }
+                catch { }
+            }
+            return false;
+        }
+        fieldsMap.set(fieldName, { sig: signature, at: now });
+        return true;
+    }
+    buildPanelTitle(fieldName, seed) {
+        const label = seed?.label || seed?.placeholder || fieldName;
+        const type = this.formatControlType(seed?.controlType);
+        return type ? `${type} — ${label}` : label;
+    }
+    buildPanelId(instance, fieldName) {
+        const formId = this.extractFormId(instance);
+        return formId ? `manual-field.${formId}.${fieldName}` : `manual-field.${fieldName}`;
+    }
+    extractFormId(instance) {
+        try {
+            return instance?.formId || instance?.seed?.formId;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    formatControlType(controlType) {
+        if (!controlType) {
+            return '';
+        }
+        return String(controlType)
+            .split(/[-_]/)
+            .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1).toLowerCase())
+            .join(' ');
+    }
+    resolveIcon(controlType) {
+        if (!controlType) {
+            return 'tune';
+        }
+        const map = {
+            INPUT: 'text_fields',
+            TEXTAREA: 'notes',
+            NUMERIC_TEXT_BOX: 'pin',
+            CURRENCY_INPUT: 'attach_money',
+            EMAIL_INPUT: 'mail',
+            PASSWORD: 'vpn_key',
+            SELECT: 'list',
+            MULTI_SELECT: 'checklist',
+            AUTO_COMPLETE: 'search',
+            RADIO: 'radio_button_checked',
+            CHECKBOX: 'check_box',
+            TOGGLE: 'toggle_on',
+            SLIDER: 'tune',
+            DATE_INPUT: 'event',
+            DATE_RANGE: 'event_repeat',
+            TIME_INPUT: 'schedule',
+            TIME_PICKER: 'schedule',
+            RATING: 'grade',
+            TREE_SELECT: 'account_tree',
+            FILE_UPLOAD: 'upload_file',
+            TRANSFER_LIST: 'compare_arrows',
+            CHIP_INPUT: 'sell',
+            CPF_CNPJ_INPUT: 'fingerprint',
+        };
+        const key = String(controlType).toUpperCase();
+        return map[key] || 'tune';
+    }
+    bindComponent(instance, fieldName, componentInstance) {
+        instance.bindComponent(fieldName, componentInstance);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: ManualFieldMetadataBridgeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: ManualFieldMetadataBridgeService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: ManualFieldMetadataBridgeService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class ManualFormComponent {
+    instanceFactory = inject(ManualFormInstanceFactory);
+    cdr = inject(ChangeDetectorRef);
+    destroyRef = inject(DestroyRef);
+    metadataBridge = inject(ManualFieldMetadataBridgeService);
+    settingsPanel = inject(SettingsPanelService);
+    selectorToControlType = inject(MANUAL_FORM_SELECTOR_TO_CONTROL_TYPE, { optional: true }) ?? DEFAULT_SELECTOR_TO_CONTROL_TYPE;
+    constructorToControlType = inject(MANUAL_FORM_CONSTRUCTOR_TO_CONTROL_TYPE, { optional: true }) ?? DEFAULT_CONSTRUCTOR_TO_CONTROL_TYPE;
+    formId = input.required(...(ngDevMode ? [{ debugName: "formId" }] : []));
+    formTitle = input(...(ngDevMode ? [undefined, { debugName: "formTitle" }] : []));
+    formDescription = input(...(ngDevMode ? [undefined, { debugName: "formDescription" }] : []));
+    actions = input(...(ngDevMode ? [undefined, { debugName: "actions" }] : []));
+    showHeader = input(true, ...(ngDevMode ? [{ debugName: "showHeader" }] : []));
+    showActions = input(true, ...(ngDevMode ? [{ debugName: "showActions" }] : []));
+    enableAutoSave = input(true, ...(ngDevMode ? [{ debugName: "enableAutoSave" }] : []));
+    // Allows editor affordances (e.g., opening metadata editor on interactions)
+    editModeEnabled = input(false, ...(ngDevMode ? [{ debugName: "editModeEnabled" }] : []));
+    persistenceOptions = input(...(ngDevMode ? [undefined, { debugName: "persistenceOptions" }] : []));
+    // When true, uses FormControlName.path (joined by '.') as FieldMetadata.name.
+    // Requires nested path support (already present in DynamicFormService).
+    usePathNames = input(false, ...(ngDevMode ? [{ debugName: "usePathNames" }] : []));
+    // Debounce interval for autosave (ms). Only used when enableAutoSave is true.
+    autoSaveDebounceMs = input(800, ...(ngDevMode ? [{ debugName: "autoSaveDebounceMs" }] : []));
+    submitted = output();
+    saved = output();
+    resetEvent = output({ alias: 'reset' });
+    metadataChange = output();
+    formControls;
+    // FormGroupDirective is applied on the component host via hostDirectives
+    hostFormGroupDirective = inject(FormGroupDirective, { self: true, optional: true });
+    instance;
+    resolvedActions;
+    formGroup = new FormGroup({});
+    registeredDirectives = [];
+    constructor() {
+        // Host-typed mode: if a FormGroupDirective is present, adopt its FormGroup without monkey patches.
+        if (this.hostFormGroupDirective) {
+            if (isDevMode())
+                console.debug('[ManualForm] Host FormGroupDirective attached early');
+            if (this.hostFormGroupDirective.form) {
+                this.formGroup = this.hostFormGroupDirective.form;
+                if (isDevMode())
+                    console.debug('[ManualForm] Using host-provided FormGroup instance');
+            }
+            else {
+                // Keep placeholder until Angular binds [formGroup]; our addControl creates missing controls if needed.
+                if (isDevMode())
+                    console.debug('[ManualForm] No host FormGroup yet; awaiting binding without interception');
+            }
+        }
+        else {
+            if (isDevMode())
+                console.debug('[ManualForm] No host FormGroupDirective detected at construction (dynamic mode)');
+        }
+    }
+    ngAfterContentInit() {
+        if (this.formControls) {
+            this.formControls.changes
+                .pipe(takeUntilDestroyed(this.destroyRef))
+                .subscribe(() => this.initialize(true));
+        }
+        queueMicrotask(() => this.initialize(false));
+    }
+    ngOnDestroy() {
+        // Output signals do not need manual completion
+    }
+    // =============================
+    // ControlContainer interface
+    // =============================
+    // Make this component act as the ControlContainer for projected children.
+    // FormControlName will call `parent.formDirective.addControl(this)` on us.
+    get formDirective() {
+        return this;
+    }
+    get control() {
+        return this.formGroup;
+    }
+    get path() {
+        return [];
+    }
+    addControl(dir) {
+        const name = typeof dir.name === 'string' ? dir.name : String(dir.name);
+        const pathSegs = Array.isArray(dir.path) && dir.path.length
+            ? dir.path
+            : (name ? [name] : []);
+        const pathStr = this.usePathNames() ? pathSegs.join('.') : name;
+        // Ensure control exists locally when host is not ready
+        if (pathStr && !this.getControlByPath(pathSegs)) {
+            this.ensureControlPath(pathSegs);
+            if (isDevMode())
+                console.debug('[ManualForm] addControl created missing control', pathStr);
+        }
+        // Delegate wiring to host FormGroupDirective when available (ensures CVA pipelines are set)
+        if (this.hostFormGroupDirective && this.hostFormGroupDirective.form) {
+            if (isDevMode())
+                console.debug('[ManualForm] Delegating addControl to host FormGroupDirective for', pathStr);
+            const ctrl = this.hostFormGroupDirective.addControl(dir);
+            this.registeredDirectives.push(dir);
+            return ctrl;
+        }
+        // Fallback minimal wiring if no host directive
+        const ctrl = this.formGroup.get(dir.path);
+        try {
+            const va = dir.valueAccessor;
+            va?.writeValue?.(ctrl?.value);
+            va?.setDisabledState?.(ctrl?.disabled ?? false);
+            va?.registerOnChange?.((value) => {
+                ctrl?.setValue(value);
+            });
+            va?.registerOnTouched?.(() => {
+                ctrl?.markAsTouched();
+            });
+        }
+        catch { }
+        dir.control = ctrl;
+        return ctrl;
+    }
+    removeControl(dir) {
+        this.hostFormGroupDirective?.removeControl(dir);
+        const idx = this.registeredDirectives.indexOf(dir);
+        if (idx >= 0)
+            this.registeredDirectives.splice(idx, 1);
+    }
+    getControl(dir) {
+        return this.formGroup.get(dir.path);
+    }
+    updateModel(dir, value) {
+        if (this.hostFormGroupDirective) {
+            this.hostFormGroupDirective.updateModel(dir, value);
+        }
+        else {
+            const ctrl = this.formGroup.get(dir.path);
+            ctrl?.setValue(value);
+        }
+    }
+    handleAction(actionId) {
+        if (actionId === 'submit') {
+            this.handleSubmit();
+        }
+        else if (actionId === 'save') {
+            this.handleSave();
+        }
+        else if (actionId === 'reset') {
+            this.handleReset();
+        }
+        else if (this.instance) {
+            this.metadataChange.emit(this.instance.currentConfig);
+        }
+    }
+    handleSubmit() {
+        if (!this.instance) {
+            return;
+        }
+        const value = this.formGroup.getRawValue();
+        if (this.enableAutoSave()) {
+            this.instance.saveDraft(value);
+        }
+        this.submitted.emit({ value, instance: this.instance });
+    }
+    handleSave() {
+        if (!this.instance) {
+            return;
+        }
+        if (this.enableAutoSave()) {
+            this.instance.saveDraft();
+        }
+        this.saved.emit(this.instance);
+        this.metadataChange.emit(this.instance.currentConfig);
+    }
+    handleReset() {
+        if (!this.instance) {
+            return;
+        }
+        this.instance.resetToSeed();
+        this.hostFormGroupDirective?.resetForm(this.instance.form.getRawValue());
+        this.resetEvent.emit(this.instance);
+    }
+    /**
+     * Attempts to open the field metadata editor respecting the component's
+     * editModeEnabled input. No-ops when disabled or without an instance.
+     */
+    tryOpenFieldEditor(fieldName) {
+        if (!this.editModeEnabled()) {
+            return;
+        }
+        const instance = this.instance;
+        if (!instance || !fieldName) {
+            return;
+        }
+        try {
+            void this.metadataBridge.openEditor(instance, fieldName);
+        }
+        catch { }
+    }
+    /** Opens a simple form-level editor listing the fields and their visibility. */
+    async openFormEditor() {
+        if (!this.editModeEnabled() || !this.instance)
+            return;
+        let ManualFormConfigEditorComponent;
+        try {
+            const module = await Promise.resolve().then(function () { return manualFormConfigEditor_component; });
+            ManualFormConfigEditorComponent = module?.ManualFormConfigEditorComponent;
+        }
+        catch {
+            return;
+        }
+        const formId = this.formId();
+        this.settingsPanel.open({
+            id: formId ? `manual-form-editor.${formId}` : 'manual-form-editor',
+            title: this.formTitle() || 'Editor do Formulário',
+            titleIcon: 'tune',
+            content: {
+                component: ManualFormConfigEditorComponent,
+                inputs: { instance: this.instance },
+            },
+        });
+    }
+    initialize(fromChanges) {
+        if (!this.formId()) {
+            return;
+        }
+        const fields = this.collectFields();
+        if (isDevMode())
+            console.debug('[ManualForm] initialize: detected fields', fields.map(f => f.name));
+        if (fields.length === 0) {
+            return;
+        }
+        const seed = this.createSeedFromFields(fields);
+        // Create runtime instance and let it populate our existing FormGroup
+        this.instance = this.instanceFactory.create(seed, this.persistenceOptions() ?? {}, this.formGroup);
+        if (isDevMode())
+            console.debug('[ManualForm] instance created with seed; current controls', Object.keys(this.formGroup.controls || {}));
+        this.applyInstanceToTemplate(fields);
+        // Auto-save value changes with debounce
+        if (this.enableAutoSave() && this.instance) {
+            this.instance.form.valueChanges
+                .pipe(debounceTime(this.autoSaveDebounceMs()), takeUntilDestroyed(this.destroyRef))
+                .subscribe(() => {
+                try {
+                    this.instance?.saveDraft();
+                }
+                catch { }
+            });
+        }
+        this.cdr.markForCheck();
+    }
+    collectFields() {
+        if (!this.formControls) {
+            return [];
+        }
+        const result = [];
+        for (const dir of this.formControls) {
+            const name = this.usePathNames()
+                ? (Array.isArray(dir.path) && dir.path.length ? dir.path.join('.') : (typeof dir.name === 'string' ? dir.name : null))
+                : (typeof dir.name === 'string' ? dir.name : null);
+            if (!name) {
+                continue;
+            }
+            const component = this.resolveValueAccessor(dir);
+            if (!component) {
+                continue;
+            }
+            result.push({
+                name,
+                control: dir.control,
+                component,
+                selector: this.resolveSelector(component, dir),
+            });
+        }
+        return result;
+    }
+    resolveValueAccessor(dir) {
+        const accessor = dir.valueAccessor;
+        if (!accessor) {
+            return undefined;
+        }
+        if (Array.isArray(accessor)) {
+            return accessor[0];
+        }
+        return accessor;
+    }
+    resolveSelector(component, dir) {
+        const cmpDef = component?.constructor?.ɵcmp;
+        if (cmpDef?.selectors?.length) {
+            const first = cmpDef.selectors[0];
+            if (Array.isArray(first) && first.length && typeof first[0] === 'string') {
+                return first[0];
+            }
+        }
+        const element = component?.elementRef?.nativeElement
+            ?? dir?._elementRef?.nativeElement;
+        return element?.tagName?.toLowerCase();
+    }
+    createSeedFromFields(fields) {
+        const metadataList = fields.map((field) => this.buildMetadataForField(field));
+        const actions = this.normalizeActions(this.actions() ?? null);
+        const currentMeta = this.instance?.currentConfig.metadata
+            ? deepClone(this.instance.currentConfig.metadata)
+            : undefined;
+        const config = {
+            sections: [
+                {
+                    id: 'auto-section',
+                    title: this.formTitle(),
+                    description: this.formDescription(),
+                    rows: [
+                        {
+                            id: 'auto-row',
+                            columns: [
+                                {
+                                    id: 'auto-column',
+                                    fields: metadataList.map((meta) => meta.name),
+                                },
+                            ],
+                        },
+                    ],
+                },
+            ],
+            fieldMetadata: metadataList,
+            metadata: currentMeta,
+            actions,
+        };
+        this.resolvedActions = actions;
+        return createManualFormSeed(this.formId(), config, {
+            source: 'generated',
+            version: '1.0.0',
+        });
+    }
+    applyInstanceToTemplate(fields) {
+        if (!this.instance) {
+            return;
+        }
+        for (const field of fields) {
+            this.instance.bindComponent(field.name, field.component);
+            // Only apply metadata manually if the component doesn't expose a standard API
+            const hasStdApi = typeof field.component?.setInputMetadata === 'function' ||
+                !!(field.component?.metadata && typeof field.component.metadata.set === 'function');
+            if (!hasStdApi) {
+                const metadata = this.instance.getFieldMetadata(field.name);
+                if (metadata) {
+                    this.applyMetadataToComponent(field.component, metadata);
+                }
+            }
+        }
+    }
+    buildMetadataForField(field) {
+        const existing = this.extractExistingMetadata(field.component);
+        const label = existing?.label ?? this.inferLabel(field, existing);
+        const controlType = existing?.controlType ?? this.inferControlType(field);
+        const validators = this.inferValidators(field.control, existing);
+        return {
+            ...(existing ?? {}),
+            name: field.name,
+            label,
+            controlType,
+            validators: { ...existing?.validators, ...validators },
+        };
+    }
+    getControlByPath(path) {
+        if (!Array.isArray(path) || path.length === 0)
+            return null;
+        return this.formGroup.get(path);
+    }
+    ensureControlPath(path) {
+        if (!Array.isArray(path) || path.length === 0)
+            return;
+        const leaf = path[path.length - 1];
+        let group = this.formGroup;
+        for (let i = 0; i < path.length - 1; i++) {
+            const seg = path[i];
+            const existing = group.get(seg);
+            if (existing instanceof FormGroup) {
+                group = existing;
+            }
+            else {
+                const next = new FormGroup({});
+                group.addControl(seg, next);
+                group = next;
+            }
+        }
+        if (!group.get(leaf)) {
+            group.addControl(leaf, new FormControl());
+        }
+    }
+    extractExistingMetadata(component) {
+        try {
+            const metaSignal = component?.metadata;
+            if (typeof metaSignal === 'function') {
+                const value = metaSignal();
+                if (value) {
+                    return deepClone(value);
+                }
+            }
+            if (typeof component?.getMetadata === 'function') {
+                const value = component.getMetadata();
+                if (value) {
+                    return deepClone(value);
+                }
+            }
+        }
+        catch { }
+        return undefined;
+    }
+    inferLabel(field, existing) {
+        if (existing?.label) {
+            return existing.label;
+        }
+        const componentLabel = field.component?.label;
+        if (typeof componentLabel === 'string' && componentLabel.trim().length > 0) {
+            return componentLabel;
+        }
+        return field.name
+            .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+            .replace(/[-_]/g, ' ')
+            .replace(/\s+/g, ' ')
+            .replace(/^\w/, (c) => c.toUpperCase());
+    }
+    inferControlType(field) {
+        const selector = field.selector?.toLowerCase();
+        if (selector && this.selectorToControlType[selector]) {
+            return this.selectorToControlType[selector];
+        }
+        const ctorName = field.component?.constructor?.name ?? '';
+        for (const [key, value] of Object.entries(this.constructorToControlType)) {
+            if (ctorName.includes(key)) {
+                return value;
+            }
+        }
+        return FieldControlType.INPUT;
+    }
+    inferValidators(control, existing) {
+        const validators = existing?.validators ? { ...existing.validators } : {};
+        if (!control) {
+            return validators;
+        }
+        const hasValidator = (fn) => {
+            const anyControl = control;
+            if (typeof anyControl.hasValidator === 'function') {
+                return anyControl.hasValidator(fn);
+            }
+            try {
+                return !!control.validator && !!control.validator({});
+            }
+            catch {
+                return false;
+            }
+        };
+        if (hasValidator(Validators.required)) {
+            validators.required = true;
+        }
+        return validators;
+    }
+    applyMetadataToComponent(component, metadata) {
+        try {
+            if (typeof component?.setInputMetadata === 'function') {
+                component.setInputMetadata(metadata);
+            }
+            const metaSignal = component?.metadata;
+            if (metaSignal && typeof metaSignal.set === 'function') {
+                metaSignal.set(metadata);
+            }
+            if ('label' in component && !component.label) {
+                component.label = metadata.label;
+            }
+            // Visibilidade: esconder/mostrar com base em hidden/formHidden, mesmo em templates manuais
+            const isHidden = !!metadata?.hidden || !!metadata?.formHidden;
+            if ('visible' in component) {
+                try {
+                    component.visible = !isHidden;
+                }
+                catch { }
+            }
+            const hostEl = component?.elementRef?.nativeElement;
+            if (hostEl) {
+                hostEl.style.display = isHidden ? 'none' : '';
+                hostEl.setAttribute('aria-hidden', String(isHidden));
+            }
+        }
+        catch { }
+    }
+    buildCurrentConfigSnapshot() {
+        const metadata = this.instance?.currentConfig.fieldMetadata ?? [];
+        return {
+            fieldMetadata: deepClone(metadata),
+            sections: this.instance?.currentConfig.sections
+                ? deepClone(this.instance.currentConfig.sections)
+                : [],
+        };
+    }
+    normalizeActions(source) {
+        const base = deepClone(DEFAULT_ACTIONS);
+        if (!source) {
+            return base;
+        }
+        return {
+            submit: mergeAction(base.submit, source.submit),
+            cancel: mergeAction(base.cancel, source.cancel),
+            reset: mergeAction(base.reset, source.reset),
+            custom: source.custom ? source.custom.map(makeAction) : base.custom,
+            position: source.position ?? base.position,
+            orientation: source.orientation ?? base.orientation,
+            spacing: source.spacing ?? base.spacing,
+            sticky: source.sticky ?? base.sticky,
+            placement: source.placement ?? base.placement,
+            mobile: source.mobile ?? base.mobile,
+            containerClassName: source.containerClassName ?? base.containerClassName,
+            containerStyles: source.containerStyles ?? base.containerStyles,
+            showSaveButton: source.showSaveButton ?? base.showSaveButton,
+            submitButtonLabel: source.submitButtonLabel ?? base.submitButtonLabel,
+            showCancelButton: source.showCancelButton ?? base.showCancelButton,
+            cancelButtonLabel: source.cancelButtonLabel ?? base.cancelButtonLabel,
+            showResetButton: source.showResetButton ?? base.showResetButton,
+            resetButtonLabel: source.resetButtonLabel ?? base.resetButtonLabel,
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: ManualFormComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.1.4", type: ManualFormComponent, isStandalone: true, selector: "praxis-manual-form", inputs: { formId: { classPropertyName: "formId", publicName: "formId", isSignal: true, isRequired: true, transformFunction: null }, formTitle: { classPropertyName: "formTitle", publicName: "formTitle", isSignal: true, isRequired: false, transformFunction: null }, formDescription: { classPropertyName: "formDescription", publicName: "formDescription", isSignal: true, isRequired: false, transformFunction: null }, actions: { classPropertyName: "actions", publicName: "actions", isSignal: true, isRequired: false, transformFunction: null }, showHeader: { classPropertyName: "showHeader", publicName: "showHeader", isSignal: true, isRequired: false, transformFunction: null }, showActions: { classPropertyName: "showActions", publicName: "showActions", isSignal: true, isRequired: false, transformFunction: null }, enableAutoSave: { classPropertyName: "enableAutoSave", publicName: "enableAutoSave", isSignal: true, isRequired: false, transformFunction: null }, editModeEnabled: { classPropertyName: "editModeEnabled", publicName: "editModeEnabled", isSignal: true, isRequired: false, transformFunction: null }, persistenceOptions: { classPropertyName: "persistenceOptions", publicName: "persistenceOptions", isSignal: true, isRequired: false, transformFunction: null }, usePathNames: { classPropertyName: "usePathNames", publicName: "usePathNames", isSignal: true, isRequired: false, transformFunction: null }, autoSaveDebounceMs: { classPropertyName: "autoSaveDebounceMs", publicName: "autoSaveDebounceMs", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { submitted: "submitted", saved: "saved", resetEvent: "reset", metadataChange: "metadataChange" }, providers: [
+            // Provide a ControlContainer at the host boundary so projected formControlName can resolve it
+            { provide: ControlContainer, useExisting: ManualFormComponent },
+        ], queries: [{ propertyName: "formControls", predicate: FormControlName, descendants: true }], ngImport: i0, template: "<div class=\"pdx-manual-form\">\n  @if (showHeader()) {\n    <praxis-manual-form-header\n      [instance]=\"instance\"\n      [title]=\"formTitle()\"\n      [description]=\"formDescription()\"\n      [editModeEnabled]=\"editModeEnabled()\"\n      (editForm)=\"openFormEditor()\"\n      (save)=\"handleSave()\"\n      (reset)=\"handleReset()\"\n    ></praxis-manual-form-header>\n  }\n\n  <form class=\"pdx-manual-form__form\" (submit)=\"handleSubmit(); $event.preventDefault()\">\n    <ng-content></ng-content>\n  </form>\n\n  @if (showActions() && resolvedActions) {\n    <praxis-manual-form-actions\n      [actions]=\"resolvedActions\"\n      (actionClick)=\"handleAction($event)\"\n    ></praxis-manual-form-actions>\n  }\n</div>\n", styles: [".pdx-manual-form{display:flex;flex-direction:column;gap:1.5rem}.pdx-manual-form__form{display:grid;gap:1rem}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i2.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i2.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "component", type: ManualFormHeaderComponent, selector: "praxis-manual-form-header", inputs: ["instance", "title", "description", "saveLabel", "resetLabel", "editModeEnabled", "editFormLabel"], outputs: ["save", "reset", "editForm"] }, { kind: "component", type: ManualFormActionsComponent, selector: "praxis-manual-form-actions", inputs: ["actions", "trackByFn"], outputs: ["actionClick"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: ManualFormComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'praxis-manual-form', standalone: true, imports: [
+                        CommonModule,
+                        ReactiveFormsModule,
+                        ManualFormHeaderComponent,
+                        ManualFormActionsComponent,
+                    ], providers: [
+                        // Provide a ControlContainer at the host boundary so projected formControlName can resolve it
+                        { provide: ControlContainer, useExisting: ManualFormComponent },
+                    ], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"pdx-manual-form\">\n  @if (showHeader()) {\n    <praxis-manual-form-header\n      [instance]=\"instance\"\n      [title]=\"formTitle()\"\n      [description]=\"formDescription()\"\n      [editModeEnabled]=\"editModeEnabled()\"\n      (editForm)=\"openFormEditor()\"\n      (save)=\"handleSave()\"\n      (reset)=\"handleReset()\"\n    ></praxis-manual-form-header>\n  }\n\n  <form class=\"pdx-manual-form__form\" (submit)=\"handleSubmit(); $event.preventDefault()\">\n    <ng-content></ng-content>\n  </form>\n\n  @if (showActions() && resolvedActions) {\n    <praxis-manual-form-actions\n      [actions]=\"resolvedActions\"\n      (actionClick)=\"handleAction($event)\"\n    ></praxis-manual-form-actions>\n  }\n</div>\n", styles: [".pdx-manual-form{display:flex;flex-direction:column;gap:1.5rem}.pdx-manual-form__form{display:grid;gap:1rem}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { formControls: [{
+                type: ContentChildren,
+                args: [FormControlName, { descendants: true }]
+            }] } });
+const DEFAULT_ACTIONS = {
+    submit: makeAction({ id: 'submit', label: 'Salvar', visible: true, type: 'submit', color: 'primary' }),
+    cancel: makeAction({ id: 'cancel', label: 'Cancelar', visible: false, type: 'button' }),
+    reset: makeAction({ id: 'reset', label: 'Restaurar', visible: true, type: 'reset' }),
+    custom: [],
+    position: 'right',
+    orientation: 'horizontal',
+    spacing: 'normal',
+};
+function makeAction(action) {
+    return {
+        id: action.id ?? 'action',
+        label: action.label ?? 'Ação',
+        visible: action.visible !== false,
+        type: action.type ?? 'button',
+        color: action.color,
+        disabled: action.disabled,
+        icon: action.icon,
+        action: action.action,
+        tooltip: action.tooltip,
+        variant: action.variant,
+        size: action.size,
+        loading: action.loading,
+        shortcut: action.shortcut,
+    };
+}
+function mergeAction(base, override) {
+    if (!override) {
+        return base;
+    }
+    return {
+        ...base,
+        ...override,
+        visible: override.visible !== undefined ? override.visible : base.visible,
+    };
+}
+const DEFAULT_SELECTOR_TO_CONTROL_TYPE = {
+    'pdx-text-input': FieldControlType.INPUT,
+    'pdx-material-textarea': FieldControlType.TEXTAREA,
+    'pdx-number-input': FieldControlType.NUMERIC_TEXT_BOX,
+    'pdx-material-currency': FieldControlType.CURRENCY_INPUT,
+    'pdx-material-datepicker': FieldControlType.DATE_PICKER,
+    'pdx-material-date-range': FieldControlType.DATE_RANGE,
+    'pdx-material-timepicker': FieldControlType.TIME_PICKER,
+    'pdx-material-colorpicker': FieldControlType.COLOR_PICKER,
+    'pdx-material-select': FieldControlType.SELECT,
+    'pdx-material-autocomplete': FieldControlType.AUTO_COMPLETE,
+    'pdx-material-checkbox-group': FieldControlType.CHECKBOX,
+    'pdx-material-radio-group': FieldControlType.RADIO,
+    'pdx-material-slide-toggle': FieldControlType.TOGGLE,
+    'pdx-material-slider': FieldControlType.SLIDER,
+    'pdx-material-range-slider': FieldControlType.RANGE_SLIDER,
+    'pdx-material-file-upload': FieldControlType.FILE_UPLOAD,
+};
+const DEFAULT_CONSTRUCTOR_TO_CONTROL_TYPE = {
+    TextInput: FieldControlType.INPUT,
+    Textarea: FieldControlType.TEXTAREA,
+    NumberInput: FieldControlType.NUMERIC_TEXT_BOX,
+    Currency: FieldControlType.CURRENCY_INPUT,
+    DatePicker: FieldControlType.DATE_PICKER,
+    DateRange: FieldControlType.DATE_RANGE,
+    TimePicker: FieldControlType.TIME_PICKER,
+    ColorPicker: FieldControlType.COLOR_PICKER,
+    SelectComponent: FieldControlType.SELECT,
+    Autocomplete: FieldControlType.AUTO_COMPLETE,
+    CheckboxGroup: FieldControlType.CHECKBOX,
+    RadioGroup: FieldControlType.RADIO,
+    SlideToggle: FieldControlType.TOGGLE,
+    SliderComponent: FieldControlType.SLIDER,
+    RangeSlider: FieldControlType.RANGE_SLIDER,
+    FileUpload: FieldControlType.FILE_UPLOAD,
+};
+
+class ManualFormConfigEditorComponent {
+    ref;
+    instance;
+    all = [];
+    filtered = [];
+    onlyHidden = false;
+    // SettingsValueProvider observables
+    isDirty$ = new BehaviorSubject(false);
+    isValid$ = new BehaviorSubject(true);
+    isBusy$ = new BehaviorSubject(false);
+    constructor(inputs, ref) {
+        this.ref = ref;
+        this.instance = inputs.instance;
+    }
+    ngOnInit() {
+        this.refresh();
+    }
+    close() { this.ref.close('cancel'); }
+    applyFilter() {
+        this.filtered = this.onlyHidden ? this.all.filter(f => !!f.hidden) : [...this.all];
+    }
+    toggleVisibility(field, checked) {
+        const visible = !!checked; // checked === visible
+        const toPatch = { hidden: !visible };
+        try {
+            this.instance.patchFieldMetadata(field.name, toPatch);
+            this.instance.saveDraft();
+            this.refresh();
+            this.isDirty$.next(true);
+        }
+        catch { }
+    }
+    toggleRequired(field, checked) {
+        const toPatch = { required: !!checked };
+        try {
+            this.instance.patchFieldMetadata(field.name, toPatch);
+            this.instance.saveDraft();
+            this.refresh();
+            this.isDirty$.next(true);
+        }
+        catch { }
+    }
+    toggleReadOnly(field, checked) {
+        const toPatch = { readOnly: !!checked };
+        try {
+            this.instance.patchFieldMetadata(field.name, toPatch);
+            this.instance.saveDraft();
+            this.refresh();
+            this.isDirty$.next(true);
+        }
+        catch { }
+    }
+    toggleDisabled(field, checked) {
+        const toPatch = { disabled: !!checked };
+        try {
+            this.instance.patchFieldMetadata(field.name, toPatch);
+            this.instance.saveDraft();
+            this.refresh();
+            this.isDirty$.next(true);
+        }
+        catch { }
+    }
+    getSettingsValue() {
+        return {
+            fieldStates: (this.instance.currentConfig.fieldMetadata || []).map((f) => ({
+                name: f.name,
+                hidden: !!f.hidden,
+                required: !!f.required,
+                readOnly: !!f.readOnly,
+                disabled: !!f.disabled,
+            })),
+        };
+    }
+    onSave() {
+        const value = this.getSettingsValue();
+        // Consider changes persisted via saveDraft; mark clean so buttons desativem se reabrir
+        this.isDirty$.next(false);
+        return value;
+    }
+    refresh() {
+        this.all = (this.instance.currentConfig.fieldMetadata || []).map(f => ({ ...f }));
+        this.applyFilter();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: ManualFormConfigEditorComponent, deps: [{ token: SETTINGS_PANEL_DATA }, { token: SETTINGS_PANEL_REF }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.1.4", type: ManualFormConfigEditorComponent, isStandalone: true, selector: "praxis-manual-form-config-editor", ngImport: i0, template: `
+    <div class="mf-editor">
+      <div class="mf-editor__toolbar">
+        <label><input type="checkbox" [(ngModel)]="onlyHidden" (change)="applyFilter()" /> Mostrar apenas ocultos</label>
+        <div class="spacer"></div>
+        <button type="button" (click)="close()">Fechar</button>
+      </div>
+
+      <div class="mf-editor__list">
+        <div class="mf-editor__row mf-editor__row--head">
+          <div class="col col--name">Campo</div>
+          <div class="col col--label">Rótulo</div>
+          <div class="col col--type">Tipo</div>
+          <div class="col col--vis">Visível</div>
+          <div class="col col--req">Obrigatório</div>
+          <div class="col col--ro">Som. leitura</div>
+          <div class="col col--dis">Desabilitado</div>
+        </div>
+
+        <div class="mf-editor__row" *ngFor="let f of filtered">
+          <div class="col col--name"><code>{{ f.name }}</code></div>
+          <div class="col col--label">{{ f.label || f.name }}</div>
+          <div class="col col--type">{{ f.controlType }}</div>
+          <div class="col col--vis">
+            <label class="toggle">
+              <input type="checkbox" [checked]="!f.hidden" (change)="toggleVisibility(f, $any($event.target).checked)" />
+              <span>{{ f.hidden ? 'Oculto' : 'Visível' }}</span>
+            </label>
+          </div>
+          <div class="col col--req">
+            <label class="toggle">
+              <input type="checkbox" [checked]="!!f.required" (change)="toggleRequired(f, $any($event.target).checked)" />
+              <span>{{ f.required ? 'Sim' : 'Não' }}</span>
+            </label>
+          </div>
+          <div class="col col--ro">
+            <label class="toggle">
+              <input type="checkbox" [checked]="!!f.readOnly" (change)="toggleReadOnly(f, $any($event.target).checked)" />
+              <span>{{ f.readOnly ? 'Sim' : 'Não' }}</span>
+            </label>
+          </div>
+          <div class="col col--dis">
+            <label class="toggle">
+              <input type="checkbox" [checked]="!!f.disabled" (change)="toggleDisabled(f, $any($event.target).checked)" />
+              <span>{{ f.disabled ? 'Sim' : 'Não' }}</span>
+            </label>
+          </div>
+        </div>
+      </div>
+    </div>
+  `, isInline: true, styles: [".mf-editor{display:grid;gap:12px;padding:12px}.mf-editor__toolbar{display:flex;align-items:center;gap:8px}.mf-editor__toolbar .spacer{flex:1}.mf-editor__list{display:grid;gap:6px}.mf-editor__row{display:grid;grid-template-columns:2fr 2fr 1fr 1fr 1fr 1fr 1fr;align-items:center;gap:8px;padding:8px 10px;border:1px solid rgba(0,0,0,.08);border-radius:6px}.mf-editor__row--head{font-weight:600;background:#0000000a}.col code{background:#0000000d;padding:2px 6px;border-radius:4px}button{padding:6px 10px;border:1px solid rgba(0,0,0,.12);background:#fff;border-radius:4px;cursor:pointer}.toggle{display:inline-flex;align-items:center;gap:6px}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i2.CheckboxControlValueAccessor, selector: "input[type=checkbox][formControlName],input[type=checkbox][formControl],input[type=checkbox][ngModel]" }, { kind: "directive", type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: ManualFormConfigEditorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'praxis-manual-form-config-editor', standalone: true, imports: [CommonModule, FormsModule], template: `
+    <div class="mf-editor">
+      <div class="mf-editor__toolbar">
+        <label><input type="checkbox" [(ngModel)]="onlyHidden" (change)="applyFilter()" /> Mostrar apenas ocultos</label>
+        <div class="spacer"></div>
+        <button type="button" (click)="close()">Fechar</button>
+      </div>
+
+      <div class="mf-editor__list">
+        <div class="mf-editor__row mf-editor__row--head">
+          <div class="col col--name">Campo</div>
+          <div class="col col--label">Rótulo</div>
+          <div class="col col--type">Tipo</div>
+          <div class="col col--vis">Visível</div>
+          <div class="col col--req">Obrigatório</div>
+          <div class="col col--ro">Som. leitura</div>
+          <div class="col col--dis">Desabilitado</div>
+        </div>
+
+        <div class="mf-editor__row" *ngFor="let f of filtered">
+          <div class="col col--name"><code>{{ f.name }}</code></div>
+          <div class="col col--label">{{ f.label || f.name }}</div>
+          <div class="col col--type">{{ f.controlType }}</div>
+          <div class="col col--vis">
+            <label class="toggle">
+              <input type="checkbox" [checked]="!f.hidden" (change)="toggleVisibility(f, $any($event.target).checked)" />
+              <span>{{ f.hidden ? 'Oculto' : 'Visível' }}</span>
+            </label>
+          </div>
+          <div class="col col--req">
+            <label class="toggle">
+              <input type="checkbox" [checked]="!!f.required" (change)="toggleRequired(f, $any($event.target).checked)" />
+              <span>{{ f.required ? 'Sim' : 'Não' }}</span>
+            </label>
+          </div>
+          <div class="col col--ro">
+            <label class="toggle">
+              <input type="checkbox" [checked]="!!f.readOnly" (change)="toggleReadOnly(f, $any($event.target).checked)" />
+              <span>{{ f.readOnly ? 'Sim' : 'Não' }}</span>
+            </label>
+          </div>
+          <div class="col col--dis">
+            <label class="toggle">
+              <input type="checkbox" [checked]="!!f.disabled" (change)="toggleDisabled(f, $any($event.target).checked)" />
+              <span>{{ f.disabled ? 'Sim' : 'Não' }}</span>
+            </label>
+          </div>
+        </div>
+      </div>
+    </div>
+  `, styles: [".mf-editor{display:grid;gap:12px;padding:12px}.mf-editor__toolbar{display:flex;align-items:center;gap:8px}.mf-editor__toolbar .spacer{flex:1}.mf-editor__list{display:grid;gap:6px}.mf-editor__row{display:grid;grid-template-columns:2fr 2fr 1fr 1fr 1fr 1fr 1fr;align-items:center;gap:8px;padding:8px 10px;border:1px solid rgba(0,0,0,.08);border-radius:6px}.mf-editor__row--head{font-weight:600;background:#0000000a}.col code{background:#0000000d;padding:2px 6px;border-radius:4px}button{padding:6px 10px;border:1px solid rgba(0,0,0,.12);background:#fff;border-radius:4px;cursor:pointer}.toggle{display:inline-flex;align-items:center;gap:6px}\n"] }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [SETTINGS_PANEL_DATA]
+                }] }, { type: i3.SettingsPanelRef, decorators: [{
+                    type: Inject,
+                    args: [SETTINGS_PANEL_REF]
+                }] }] });
+
+var manualFormConfigEditor_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    ManualFormConfigEditorComponent: ManualFormConfigEditorComponent
+});
+
+class ManualFieldDirective {
+    templateRef;
+    viewContainer;
+    fieldName;
+    instance;
+    constructor(templateRef, viewContainer) {
+        this.templateRef = templateRef;
+        this.viewContainer = viewContainer;
+    }
+    ngOnChanges(changes) {
+        if ('fieldName' in changes || 'instance' in changes) {
+            this.render();
+        }
+    }
+    render() {
+        this.viewContainer.clear();
+        if (!this.instance || !this.fieldName) {
+            return;
+        }
+        const metadata = this.instance.getFieldMetadata(this.fieldName);
+        const context = {
+            $implicit: metadata,
+            metadata,
+            fieldName: this.fieldName,
+        };
+        this.viewContainer.createEmbeddedView(this.templateRef, context);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: ManualFieldDirective, deps: [{ token: i0.TemplateRef }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.1.4", type: ManualFieldDirective, isStandalone: true, selector: "[praxisManualField]", inputs: { fieldName: ["praxisManualField", "fieldName"], instance: ["praxisManualFieldInstance", "instance"] }, usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: ManualFieldDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[praxisManualField]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i0.TemplateRef }, { type: i0.ViewContainerRef }], propDecorators: { fieldName: [{
+                type: Input,
+                args: ['praxisManualField']
+            }], instance: [{
+                type: Input,
+                args: ['praxisManualFieldInstance']
+            }] } });
+
+/**
+ * Attach to any field inside <praxis-manual-form> to open the metadata editor
+ * on double click, respecting the form's editModeEnabled state.
+ *
+ * Usage:
+ *   <pdx-text-input pdxManualEdit="nome" ...></pdx-text-input>
+ */
+class ManualFieldEditorOnDblclickDirective {
+    fieldName;
+    manualForm = inject(ManualFormComponent, { optional: true });
+    onDblClick() {
+        if (!this.fieldName)
+            return;
+        this.manualForm?.tryOpenFieldEditor(this.fieldName);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: ManualFieldEditorOnDblclickDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.1.4", type: ManualFieldEditorOnDblclickDirective, isStandalone: true, selector: "[pdxManualEdit]", inputs: { fieldName: ["pdxManualEdit", "fieldName"] }, host: { listeners: { "dblclick": "onDblClick()" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: ManualFieldEditorOnDblclickDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[pdxManualEdit]',
+                    standalone: true,
+                }]
+        }], propDecorators: { fieldName: [{
+                type: Input,
+                args: ['pdxManualEdit']
+            }], onDblClick: [{
+                type: HostListener,
+                args: ['dblclick']
+            }] } });
+
+/*
+ * Public API Surface of praxis-manual-form
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { MANUAL_FORM_CONSTRUCTOR_TO_CONTROL_TYPE, MANUAL_FORM_SELECTOR_TO_CONTROL_TYPE, ManualFieldDirective, ManualFieldEditorOnDblclickDirective, ManualFieldMetadataBridgeService, ManualFormActionsComponent, ManualFormComponent, ManualFormConfigEditorComponent, ManualFormHeaderComponent, ManualFormInstance, ManualFormInstanceFactory, createManualFormSeed, toFieldMetadataMap };
+//# sourceMappingURL=praxisui-manual-form.mjs.map