ngx-dynamic-entity 1.1.0 → 1.3.0

package/lib/field-types/array-field.component.d.ts

@@ -1,8 +1,14 @@
 import { AbstractControl, FormArray } from '@angular/forms';
 import type { NestedFieldConfig, EntityFormConfig } from '@dynamic-entity/core';
 import * as i0 from "@angular/core";
-/** ADR-008: ArrayFieldComponent — renders repeating rows for FormArray with + Add Item and Remove */
+/** Renders repeating rows for a FormArray, with Add Item and Remove. */
 export declare class ArrayFieldComponent {
+    /**
+     * addItem/removeItem are public and may be called from outside this component's template,
+     * which under OnPush would not re-render. The host also watches the control, but this
+     * keeps the component correct on its own.
+     */
+    private readonly cdr;
     field: NestedFieldConfig;
     control: AbstractControl;
     config: EntityFormConfig;

package/lib/field-types/date-time-field.component.d.ts

@@ -0,0 +1,30 @@
+import { AbstractControl } from '@angular/forms';
+import type { NestedFieldConfig } from '@dynamic-entity/core';
+import * as i0 from "@angular/core";
+/**
+ * Date & Time field: a single `datetime-local` input.
+ *
+ * The type is stored as ISO 8601 UTC, per the same convention `date` follows, while the
+ * input works in the viewer's local zone — `datetime-local` has no offset, so the two
+ * conversions here are what keep a value stable across a round trip.
+ */
+export declare class DateTimeFieldComponent {
+    field: NestedFieldConfig;
+    control: AbstractControl;
+    language: string;
+    readonly: boolean;
+    masked: boolean;
+    get label(): string;
+    /** Stored ISO 8601 → the `YYYY-MM-DDTHH:mm` local form the input requires. */
+    get inputValue(): string;
+    /** The input's local `YYYY-MM-DDTHH:mm` → stored ISO 8601 UTC. */
+    onInput(value: string): void;
+    /**
+     * Displays date *and* time. `DateFieldComponent` used `toLocaleDateString()` here, so a
+     * datetime read back through the field showed no time while the same value in the record
+     * summary — which goes through core's `formatDisplayValue` — showed it.
+     */
+    formatDateTime(value: unknown): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateTimeFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DateTimeFieldComponent, "ngx-date-time-field", never, { "field": { "alias": "field"; "required": false; }; "control": { "alias": "control"; "required": false; }; "language": { "alias": "language"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "masked": { "alias": "masked"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/field-types/dropdown-field.component.d.ts

@@ -3,6 +3,7 @@ import type { NestedFieldConfig } from '@dynamic-entity/core';
 import * as i0 from "@angular/core";
 export declare class DropdownFieldComponent {
     private readonly lookups;
+    private readonly messages;
     private _field;
     private _language;
     /** Setter-based so options resolve however the input is set — see `refreshChoiceOptions`. */

package/lib/field-types/entity-ref-field.component.d.ts

@@ -29,7 +29,17 @@ export declare class EntityRefFieldComponent implements OnInit {
     ngOnInit(): void;
     /** Reload options against the parent's current value. */
     reload(): Promise<void>;
-    onSelectionChange(): void;
+    /**
+     * Publish the selected option so autoPatch can copy from its record.
+     *
+     * Driven from `valueChanges` rather than the select's `change` event: that event is the
+     * same one the `formControl` directive listens to, so reading the control inside a
+     * template `(change)` handler can see the previous value. `valueChanges` fires after the
+     * model has updated — including Playwright `selectOption`, which updates the control
+     * through the value accessor.
+     */
+    onSelectionChange(value?: string): void;
+    private publishSelection;
     getLabel(value: any): string;
     private parentValue;
     /** Reload (and drop a stale selection) whenever the parent control changes. */

package/lib/field-types/field-component.contract.d.ts

@@ -0,0 +1,49 @@
+import type { AbstractControl } from '@angular/forms';
+import type { NestedFieldConfig } from '@dynamic-entity/core';
+/**
+ * What a field component must accept to be registered with `provideFieldTypes`.
+ *
+ * The renderer instantiates a field component dynamically and assigns exactly these five
+ * inputs — no more, no less — so any component satisfying this interface can stand in for a
+ * built-in type or add a new one.
+ *
+ * Implement it explicitly and TypeScript will tell you when you have missed one:
+ *
+ * ```typescript
+ * @Component({
+ *   selector: 'app-signature-field',
+ *   standalone: true,
+ *   template: `<canvas [attr.aria-label]="field.id"></canvas>`,
+ * })
+ * export class SignatureFieldComponent implements DynamicFieldComponentContract {
+ *   @Input() field!: NestedFieldConfig;
+ *   @Input() control!: AbstractControl;
+ *   @Input() language = 'en';
+ *   @Input() readonly = false;
+ *   @Input() masked = false;
+ * }
+ *
+ * provideFieldTypes({ signature: SignatureFieldComponent });
+ * ```
+ *
+ * Two implementation notes that are easy to get wrong:
+ *
+ * - Declare the inputs with definite assignment (`field!: …`) or an initialiser. The
+ *   renderer sets them through `ComponentRef.setInput()` after construction, so they are
+ *   genuinely undefined until the first assignment.
+ * - `masked` means the value must not be displayed. Render a placeholder rather than the
+ *   control's value. This is presentational: the real value stays in the control and is
+ *   included in the submitted record, so it is not an access-control boundary.
+ */
+export interface DynamicFieldComponentContract {
+    /** The field's schema entry: id, type, label, validators, options, and so on. */
+    field: NestedFieldConfig;
+    /** The reactive control backing this field. A `FormGroup` for `group`, `FormArray` for `array`. */
+    control: AbstractControl;
+    /** Active language, for resolving `LocalizedText` labels, placeholders and options. */
+    language: string;
+    /** Render the value as text rather than an editable control. */
+    readonly: boolean;
+    /** Hide the value from display. See the note above — presentational only. */
+    masked: boolean;
+}

package/lib/field-types/group-field.component.d.ts

@@ -1,7 +1,7 @@
 import { AbstractControl } from '@angular/forms';
 import type { NestedFieldConfig, EntityFormConfig } from '@dynamic-entity/core';
 import * as i0 from "@angular/core";
-/** ADR-008: GroupFieldComponent — renders nested fieldset container for group.children */
+/** Renders a nested fieldset container for a group field's children. */
 export declare class GroupFieldComponent {
     field: NestedFieldConfig;
     control: AbstractControl;

package/lib/field-types/number-field.component.d.ts

@@ -2,6 +2,7 @@ import { AbstractControl } from '@angular/forms';
 import type { NestedFieldConfig } from '@dynamic-entity/core';
 import * as i0 from "@angular/core";
 export declare class NumberFieldComponent {
+    private readonly messages;
     field: NestedFieldConfig;
     control: AbstractControl;
     language: string;

package/lib/field-types/text-field.component.d.ts

@@ -1,12 +1,20 @@
+import { OnDestroy } from '@angular/core';
 import { AbstractControl } from '@angular/forms';
 import type { NestedFieldConfig } from '@dynamic-entity/core';
 import * as i0 from "@angular/core";
-export declare class TextFieldComponent {
+export declare class TextFieldComponent implements OnDestroy {
+    private readonly messages;
+    private displaySub?;
     field: NestedFieldConfig;
-    control: AbstractControl;
+    set control(value: AbstractControl);
+    get control(): AbstractControl;
+    private _control;
     language: string;
     readonly: boolean;
     masked: boolean;
+    /** Readonly markup reads this signal so an external patch (autoPatch) is visible under OnPush. */
+    readonly displayValue: import("@angular/core").WritableSignal<unknown>;
+    ngOnDestroy(): void;
     get label(): string;
     get placeholder(): string;
     get errorMessage(): string;

package/lib/field-types/time-field.component.d.ts

@@ -0,0 +1,27 @@
+import { AbstractControl } from '@angular/forms';
+import type { NestedFieldConfig } from '@dynamic-entity/core';
+import * as i0 from "@angular/core";
+/**
+ * Time field: a bare time of day, with no date and no zone attached.
+ *
+ * Stored as `HH:mm` — exactly the value `<input type="time">` reads and writes, so the
+ * control binds straight through with no conversion. That is the whole reason this is a
+ * separate type from `datetime`: a recurring 09:00 opening time is not a moment in time,
+ * and converting it to UTC would move it whenever the offset changed.
+ */
+export declare class TimeFieldComponent {
+    field: NestedFieldConfig;
+    control: AbstractControl;
+    language: string;
+    readonly: boolean;
+    masked: boolean;
+    get label(): string;
+    /**
+     * Defers to core rather than parsing `HH:mm` locally. The other date-ish components each
+     * grew their own formatter, and `datetime` ended up showing one thing in the field and
+     * another in the record summary because the two drifted apart.
+     */
+    formatTime(value: unknown): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimeFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TimeFieldComponent, "ngx-time-field", never, { "field": { "alias": "field"; "required": false; }; "control": { "alias": "control"; "required": false; }; "language": { "alias": "language"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "masked": { "alias": "masked"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/form/dynamic-field/dynamic-field.component.d.ts

@@ -1,16 +1,17 @@
-import { OnChanges, SimpleChanges } from '@angular/core';
+import { OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
 import { AbstractControl } from '@angular/forms';
 import type { NestedFieldConfig, EntityFormConfig } from '@dynamic-entity/core';
 import * as i0 from "@angular/core";
 /**
  * DynamicFieldComponent — mounts the correct field component for a given NestedFieldConfig.
- * Uses ViewContainerRef.createComponent() and passes inputs via setInput() (ADR-008).
+ * Uses ViewContainerRef.createComponent() and passes inputs via setInput(); see
+ * DynamicFieldComponentContract for the five inputs every field component receives.
  * Never add field-type-specific logic here — this component must remain generic.
  *
  * The 5 inputs (field, control, language, readonly, masked) are passed to every mounted
  * component uniformly — no special-casing per type.
  */
-export declare class DynamicFieldComponent implements OnChanges {
+export declare class DynamicFieldComponent implements OnChanges, OnDestroy {
     field: NestedFieldConfig;
     control: AbstractControl;
     config: EntityFormConfig;
@@ -21,6 +22,12 @@ export declare class DynamicFieldComponent implements OnChanges {
     private readonly fieldHost;
     private readonly fieldRegistry;
     private readonly rbacService;
+    /**
+     * Passed into `createComponent` so a hosted field sees this host's injector — including
+     * `DynamicFormComponent`'s scoped `EntityRefSelectionService`. Without it, a standalone
+     * field resolves the root bus and `autoPatch` never runs.
+     */
+    private readonly injector;
     private componentRef;
     ngOnChanges(_changes: SimpleChanges): void;
     private mountField;
@@ -32,7 +39,35 @@ export declare class DynamicFieldComponent implements OnChanges {
     private warnUnresolved;
     private static readonly warnedTypes;
     /**
-     * Pass all 5 contract inputs via ComponentRef.setInput() — uniform for all types (ADR-008).
+     * Re-check the hosted field component.
+     *
+     * The field components are OnPush, so they re-render on an input change, an event from
+     * their own template, or a signal they read. `form.markAllAsTouched()` is none of those —
+     * it flips `touched` from outside, and every field's error message depends on it. Without
+     * this, a blocked submit would mark the form touched and no error would appear.
+     */
+    refresh(): void;
+    /**
+     * Re-check the hosted component whenever its control changes from outside.
+     *
+     * The field components are OnPush, so they re-render on an input change or an event from
+     * their own template. A control mutated externally is neither — and that is not an edge
+     * case: patchForm, reset, autoPatch and patchOnTrue all do exactly that. Without this, a
+     * field patched from a record would keep rendering its previous value.
+     *
+     * `detectChanges()` rather than `markForCheck()`: a selection that arrives from a native
+     * `change` event (or Playwright) may not be followed by another Angular tick, so a dirty
+     * flag would never be flushed. Running CD on the hosted component now is the copy showing up.
+     *
+     * Done here rather than in each of the eighteen field components: the host owns the
+     * component reference, so one subscription covers every type including custom ones.
+     */
+    private watchControl;
+    private controlSub?;
+    ngOnDestroy(): void;
+    /**
+     * Pass all 5 contract inputs via ComponentRef.setInput() — uniform for all types.
+     * The public shape is DynamicFieldComponentContract.
      * Must use setInput(), not property assignment: the field components declare inputs with
      * definite assignment and no initializer, and the lib compiles with
      * useDefineForClassFields:false, so `'field' in instance` is false until first set.

package/lib/form/dynamic-form.component.d.ts

@@ -10,7 +10,21 @@ import * as i0 from "@angular/core";
  * keyboard shortcuts (Ctrl+S, Esc), and RBAC-gated submission.
  */
 export declare class DynamicFormComponent implements OnInit, OnChanges, OnDestroy {
-    config: EntityFormConfig;
+    /**
+     * The schema to render.
+     *
+     * An accessor pair rather than a plain field: `ngOnChanges` normalises the option shape,
+     * and that result is kept here instead of being written back over the input. Reassigning
+     * an `@Input` works, but it mutates what the parent handed us — and a parent using OnPush
+     * or signals would never observe the replacement anyway.
+     *
+     * Reads of `this.config` get the normalised copy once it exists, so every internal caller
+     * is unaffected.
+     */
+    set config(value: EntityFormConfig);
+    get config(): EntityFormConfig;
+    private rawConfig;
+    private normalizedConfig?;
     rules?: FormRule[];
     initialData?: Record<string, any>;
     /** Session-original values for `VALUE_CHANGED` rules. Captured from the first build when omitted. */
@@ -43,6 +57,15 @@ export declare class DynamicFormComponent implements OnInit, OnChanges, OnDestro
     formReset: EventEmitter<void>;
     /** The visible tab changed. Lets a host track it without reaching into this component. */
     activeTabChange: EventEmitter<string>;
+    /**
+     * Emitted when a `beforeSave` hook aborted the save — by returning false or throwing.
+     * `formSubmit` does not fire in that case.
+     */
+    saveRejected: EventEmitter<{
+        reason: string;
+        error?: unknown;
+    }>;
+    private readonly cdr;
     private readonly fb;
     private readonly validatorRegistry;
     private readonly hookRegistry;
@@ -60,8 +83,13 @@ export declare class DynamicFormComponent implements OnInit, OnChanges, OnDestro
     readonly sessionBaseline: import("@angular/core").WritableSignal<Record<string, any>>;
     /** Critical fields the user has explicitly unlocked for editing. */
     readonly unlockedFields: import("@angular/core").WritableSignal<ReadonlySet<string>>;
+    /** The active tab's field panel, focused after a tab switch. */
+    private formPanel?;
+    /** The hosted field components, so an external control-state change can reach them. */
+    private fieldHosts?;
     form: FormGroup;
     private valueSub?;
+    private statusSub?;
     private selectionSub?;
     /** Previous values, for detecting `patchOnTrue` false→true transitions. */
     private previousValues;
@@ -121,6 +149,14 @@ export declare class DynamicFormComponent implements OnInit, OnChanges, OnDestro
     get ruleValidationErrors(): Record<string, string>;
     /** True when a `validation` rule is currently blocking submission. */
     get hasRuleErrors(): boolean;
+    /**
+     * True while an async validator is still running.
+     *
+     * Angular reports a control with an outstanding async check as `pending`, and `invalid` is
+     * false until it settles — so without this a form could be submitted in the gap before a
+     * uniqueness check came back.
+     */
+    get isValidating(): boolean;
     /** Single source of truth for both the submit guard and the button's disabled state. */
     get submitBlocked(): boolean;
     ngOnInit(): void;
@@ -152,6 +188,13 @@ export declare class DynamicFormComponent implements OnInit, OnChanges, OnDestro
      */
     createArrayRow(field: NestedFieldConfig, value?: unknown): AbstractControl;
     private buildArrayRow;
+    /**
+     * Mark every control touched, then re-check the field components.
+     *
+     * They are OnPush and `touched` is flipped from outside their own template, so the second
+     * half is what makes the error messages actually appear.
+     */
+    private markAllTouched;
     /**
      * Bring a record up to the config's `version` before it reaches the form.
      *
@@ -223,9 +266,28 @@ export declare class DynamicFormComponent implements OnInit, OnChanges, OnDestro
     private baseline;
     private sameValue;
     getControl(fieldId: string, currentTabId?: string): AbstractControl | null;
+    /**
+     * Move focus into the newly shown panel.
+     *
+     * Activating a tab replaces everything below it while focus stays on the tab button, so a
+     * screen-reader or keyboard user is given no indication that the content changed and must
+     * tab back through the strip to reach it. Deferred a frame because the panel's contents
+     * are rendered by the change detection this call is part of.
+     */
+    private focusActivePanel;
+    /** Accessible name for the field panel — it is the tabpanel for the active tab. */
+    get activeTabLabel(): string;
+    /**
+     * Why a referenced field is flagged.
+     *
+     * `hasDrift` was written by the builder and read by nothing at runtime, so a field whose
+     * source definition had changed since it was linked looked entirely normal to the person
+     * filling the form in.
+     */
+    driftHint(field: NestedFieldConfig): string;
     resolveTabLabel(tab: NestedTabConfig): string;
     submit(): Promise<void>;
     reset(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormComponent, "ngx-dynamic-form", never, { "config": { "alias": "config"; "required": false; }; "rules": { "alias": "rules"; "required": false; }; "initialData": { "alias": "initialData"; "required": false; }; "originalData": { "alias": "originalData"; "required": false; }; "userRoles": { "alias": "userRoles"; "required": false; }; "language": { "alias": "language"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "readOnlyFields": { "alias": "readOnlyFields"; "required": false; }; "showInfoBanners": { "alias": "showInfoBanners"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "error": { "alias": "error"; "required": false; }; "changeDebounceMs": { "alias": "changeDebounceMs"; "required": false; }; "preview": { "alias": "preview"; "required": false; }; }, { "formSubmit": "formSubmit"; "formChange": "formChange"; "formReset": "formReset"; "activeTabChange": "activeTabChange"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormComponent, "ngx-dynamic-form", never, { "config": { "alias": "config"; "required": false; }; "rules": { "alias": "rules"; "required": false; }; "initialData": { "alias": "initialData"; "required": false; }; "originalData": { "alias": "originalData"; "required": false; }; "userRoles": { "alias": "userRoles"; "required": false; }; "language": { "alias": "language"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "readOnlyFields": { "alias": "readOnlyFields"; "required": false; }; "showInfoBanners": { "alias": "showInfoBanners"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "error": { "alias": "error"; "required": false; }; "changeDebounceMs": { "alias": "changeDebounceMs"; "required": false; }; "preview": { "alias": "preview"; "required": false; }; }, { "formSubmit": "formSubmit"; "formChange": "formChange"; "formReset": "formReset"; "activeTabChange": "activeTabChange"; "saveRejected": "saveRejected"; }, never, never, true, never>;
 }

package/lib/form/dynamic-record-form.component.d.ts

@@ -39,6 +39,8 @@ export declare class DynamicRecordFormComponent implements OnChanges {
     }>;
     dynamicFormComp?: DynamicFormComponent;
     private readonly rulesEvaluation;
+    private readonly host;
+    private readonly injector;
     readonly currentData: import("@angular/core").WritableSignal<Record<string, any>>;
     readonly originalBaseline: import("@angular/core").WritableSignal<Record<string, any>>;
     /**
@@ -174,6 +176,23 @@ export declare class DynamicRecordFormComponent implements OnChanges {
     formatFieldLabel(field: NestedFieldConfig): string;
     /** Summary values render through the shared core formatter, not a local stringifier. */
     formatFieldValue(field: NestedFieldConfig): string;
+    /**
+     * Finds which tab — and, where the field lives one level down, which sub-tab — owns a
+     * field. The walk used to check top-level `fields` only, so every field in a sub-tab was
+     * simply not found and the jump did nothing at all.
+     */
+    private locateField;
+    /**
+     * Switches to the tab holding `fieldId`, then scrolls it into view and moves focus to it.
+     *
+     * The wait for the new tab to render used to be a 50 ms `setTimeout`, which was wrong three
+     * ways: `document` is undefined on a server render, 50 ms is a guess that a large tab can
+     * outrun, and nothing cancelled the timer if the component went away first.
+     * `afterNextRender` fixes all three — it never runs on the server, it runs when the panel
+     * has actually rendered rather than when a guess expires, and it is tied to the injector so
+     * destroying the component cancels it. The query is scoped to this component's own element,
+     * so the library no longer reaches for the global `document` at all.
+     */
     jumpToField(fieldId: string): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DynamicRecordFormComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<DynamicRecordFormComponent, "ngx-dynamic-record-form", never, { "config": { "alias": "config"; "required": false; }; "rules": { "alias": "rules"; "required": false; }; "initialData": { "alias": "initialData"; "required": false; }; "userRoles": { "alias": "userRoles"; "required": false; }; "language": { "alias": "language"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "error": { "alias": "error"; "required": false; }; "isReadOnly": { "alias": "isReadOnly"; "required": false; }; "readOnlyFields": { "alias": "readOnlyFields"; "required": false; }; "viewMode": { "alias": "viewMode"; "required": false; }; }, { "formSubmit": "formSubmit"; "formChange": "formChange"; "formReset": "formReset"; "sectionSave": "sectionSave"; }, never, never, true, never>;

package/lib/providers/provide-ngx-dynamic-entity.d.ts

@@ -7,7 +7,7 @@ export interface NgxDynamicEntityConfig {
     /** Custom field type components keyed by type string */
     fieldTypes?: Record<string, Type<any>>;
     /**
-     * Entity-ref option loaders keyed by entity key (ADR-006).
+     * Entity-ref option loaders keyed by entity key.
      * Each receives `{ parentValue, filters, lang }` and may return an array, Promise, or Observable.
      */
     entityRefs?: Record<string, EntityReferenceLoader>;
@@ -17,6 +17,22 @@ export interface NgxDynamicEntityConfig {
      * a loader for anything fetched, so an unused list is never loaded.
      */
     lookups?: Record<string, LookupListSource>;
+    /**
+     * Override the messages shown under invalid fields, keyed by Angular error key. A value is
+     * a string, or a function receiving `(language, error)` when it needs the error's detail.
+     * Unlisted keys keep their English default.
+     */
+    validationMessages?: Record<string, string | ((language: string, error: any) => string)>;
+    /**
+     * Async validator functions keyed by name, for checks that need a server — uniqueness,
+     * availability, a remote rule. Name them from a schema with
+     * `validators: { customAsync: ['uniqueEmail'] }`.
+     *
+     * Each is an Angular `AsyncValidatorFn`: it receives the control and returns a Promise or
+     * Observable of `ValidationErrors | null`. The control is `pending` while it runs, and the
+     * form cannot be submitted until every pending check settles.
+     */
+    asyncValidators?: Record<string, any>;
     /** Custom validator functions keyed by validator name */
     validators?: Record<string, any>;
     /** Hook functions keyed by hook name */

package/lib/services/cascade-data.service.d.ts

@@ -3,7 +3,7 @@ import * as i0 from "@angular/core";
 /**
  * CascadeDataService — loads entity-reference options and applies parent→child cascades.
  *
- * Loaders come from the registry only (ADR-006). This service owns the three things a
+ * Loaders come from the registry only. This service owns the three things a
  * field component should not: resolving the loader, coercing whatever it returned
  * (array | Promise | Observable) into a Promise, and filtering by the parent's value.
  */

package/lib/services/entity-ref-registry.service.d.ts

@@ -2,7 +2,7 @@ import type { EntityReferenceLoader } from '@dynamic-entity/core';
 import * as i0 from "@angular/core";
 /**
  * EntityRefRegistryService — resolves entity-ref option loader functions.
- * ADR-006: Entity-ref options come ONLY from this registry.
+ * Entity-ref options come ONLY from this registry.
  * Never pass loaders via @Input() on field components.
  *
  * Consumers register loaders via provideNgxDynamicEntity({ entityRefs: { clients: () => [...] } }).

package/lib/services/lookup-registry.service.d.ts

@@ -81,7 +81,7 @@ export interface ChoiceOptionHost {
  * Point a choice component's `options` signal at the right source (parity plan §6.3).
  *
  * Called from the `field` / `language` input setters of `dropdown`, `radio` and `multiSelect` —
- * the wiring is theirs, the decision is the service's, which is what keeps the ADR-008
+ * the wiring is theirs, the decision is the service's, which is what keeps the field
  * five-input contract intact: options are never pushed in as a sixth input.
  *
  * Setters rather than `ngOnChanges` on purpose. `ngOnChanges` only fires for inputs Angular

package/lib/services/validation-messages.service.d.ts

@@ -0,0 +1,43 @@
+import type { ValidationErrors } from '@angular/forms';
+import * as i0 from "@angular/core";
+/**
+ * Resolves an Angular `ValidationErrors` object to the message shown under a field.
+ *
+ * These strings used to be hardcoded English literals inside each field component, so a
+ * German form meant re-implementing every field type — the labels honoured `language` while
+ * the errors underneath them did not.
+ *
+ * A message is a plain string, or a function when it needs the error's own detail
+ * (`minlength.requiredLength`, `min.min`, and so on). The active `language` is passed
+ * through, so one registration can serve every locale:
+ *
+ * ```typescript
+ * provideNgxDynamicEntity({
+ *   validationMessages: {
+ *     required: lang => (lang === 'de' ? 'Pflichtfeld.' : 'This field is required.'),
+ *     minlength: (lang, err) => `Mindestens ${err['requiredLength']} Zeichen.`,
+ *   },
+ * });
+ * ```
+ *
+ * Unregistered keys fall back to the defaults below, so overriding one message does not
+ * mean supplying them all.
+ */
+export type ValidationMessage = string | ((language: string, error: any) => string);
+/** The built-in English messages. Every key here can be overridden individually. */
+export declare const DEFAULT_VALIDATION_MESSAGES: Record<string, ValidationMessage>;
+export declare class ValidationMessagesService {
+    private readonly overrides;
+    /**
+     * The message for the first error present, in the order the caller lists.
+     *
+     * Order is the caller's because it is field-specific: a dropdown wants
+     * `requiredSelection` where a text input wants `required`, and the first match wins so the
+     * most specific message is the one shown.
+     */
+    resolve(errors: ValidationErrors | null | undefined, language: string, order: readonly (string | readonly [errorKey: string, messageKey: string])[], fallbackKey?: string): string;
+    /** One message by key, honouring an override before the default. */
+    messageFor(key: string, language: string, error: unknown): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ValidationMessagesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ValidationMessagesService>;
+}

package/lib/services/validator-registry.service.d.ts

@@ -1,4 +1,4 @@
-import { ValidatorFn } from '@angular/forms';
+import { AsyncValidatorFn, ValidatorFn } from '@angular/forms';
 import type { FieldValidators } from '@dynamic-entity/core';
 import * as i0 from "@angular/core";
 /**
@@ -6,6 +6,7 @@ import * as i0 from "@angular/core";
  */
 export declare class ValidatorRegistryService {
     private readonly consumerRegistry;
+    private readonly asyncRegistry;
     /**
      * Resolve a validator key string to a ValidatorFn.
      * Supports parameterized built-ins like 'min:0', 'maxLength:255'.
@@ -15,6 +16,17 @@ export declare class ValidatorRegistryService {
     resolveAll(validatorKeys?: string[]): ValidatorFn[];
     /** Resolve a FieldValidators object or string[] into ValidatorFn[] */
     resolveFromConfig(config?: FieldValidators | string[]): ValidatorFn[];
+    /**
+     * Resolve the async validators a field names, in `validators.customAsync`.
+     *
+     * Async validators are deliberately a separate registry and a separate config key: Angular
+     * attaches them through `setAsyncValidators`, runs them only once the synchronous ones
+     * pass, and holds the control in `pending` until they settle. Mixing them into the
+     * synchronous list would silently never run them.
+     *
+     * An unknown name is skipped rather than throwing, matching the synchronous behaviour.
+     */
+    resolveAsyncFromConfig(config?: FieldValidators | string[]): AsyncValidatorFn[];
     static ɵfac: i0.ɵɵFactoryDeclaration<ValidatorRegistryService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ValidatorRegistryService>;
 }

package/lib/tokens/injection-tokens.d.ts

@@ -1,7 +1,7 @@
 import { InjectionToken } from '@angular/core';
 import type { Type } from '@angular/core';
 import { type EntityRefCacheStore } from '../services/entity-ref-cache';
-/** Roles that see XXXXXXXXX for masked fields (ADR-003) */
+/** Roles that see XXXXXXXXX for masked fields. Presentational only — enforce authz server-side. */
 export declare const MASKED_ROLES: InjectionToken<string[]>;
 /**
  * Consumer **overrides**: fieldType string → Angular component class.
@@ -58,8 +58,25 @@ export declare const LOOKUP_REGISTRY: InjectionToken<Map<string, LookupListSourc
  * })
  */
 export declare const RECORD_MIGRATIONS: InjectionToken<RecordMigration[]>;
+/**
+ * Overrides for the messages shown under an invalid field, keyed by Angular error key
+ * (`required`, `minlength`, `pattern`, …) plus a few field-specific keys.
+ *
+ * The built-in messages are English literals. Registering here is what makes a non-English
+ * form possible without re-implementing every field component; unlisted keys keep their
+ * default, so overriding one does not mean supplying them all.
+ */
+export declare const VALIDATION_MESSAGES: InjectionToken<Record<string, any>>;
 /** Registry: validator key → ValidatorFn */
 export declare const VALIDATOR_REGISTRY: InjectionToken<Map<string, any>>;
+/**
+ * Registry: validator key → AsyncValidatorFn.
+ *
+ * Kept separate from VALIDATOR_REGISTRY because Angular applies the two differently: an async
+ * validator runs only once the synchronous ones pass, and puts the control into `pending`
+ * while it does. Name them from a schema with `validators: { customAsync: ['uniqueEmail'] }`.
+ */
+export declare const ASYNC_VALIDATOR_REGISTRY: InjectionToken<Map<string, any>>;
 /**
  * A registered hook: receives the payload, returns it (or a replacement), sync or async.
  *
@@ -104,10 +121,6 @@ export declare const UPLOAD_HANDLER: InjectionToken<FileUploadHandler>;
  * { provide: ENTITY_REF_CACHE_STORE, useClass: SessionStorageRefCache }
  */
 export declare const ENTITY_REF_CACHE_STORE: InjectionToken<EntityRefCacheStore>;
-/**
- * Consumer-provided predicate function to check whether user roles can edit system default tabs or fields.
- * Defaults to allowing edits if not provided.
- */
 /**
  * Consumer-provided predicate function to check whether user roles can edit system default tabs or fields.
  * Defaults to allowing edits if not provided.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ngx-dynamic-entity",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "Angular standalone UI library for rendering dynamic entity forms.",
   "//typings": "Local workspace resolution only: ng-packagr overwrites this with the correct in-tarball path ('index.d.ts') when generating dist/package.json. Do NOT add a 'main' field here — ng-packagr does not generate one, so it would be copied verbatim and resolve to dist/dist/... in the published package.",
   "typings": "index.d.ts",
@@ -8,7 +8,7 @@
     "@angular/common": "^17.0.0 || ^18.0.0 || ^19.0.0 || ^20.0.0 || ^21.0.0 || ^22.0.0",
     "@angular/core": "^17.0.0 || ^18.0.0 || ^19.0.0 || ^20.0.0 || ^21.0.0 || ^22.0.0",
     "@angular/forms": "^17.0.0 || ^18.0.0 || ^19.0.0 || ^20.0.0 || ^21.0.0 || ^22.0.0",
-    "@dynamic-entity/core": "^1.1.0",
+    "@dynamic-entity/core": "^1.3.0",
     "rxjs": "^7.0.0"
   },
   "keywords": [

package/public-api.d.ts

@@ -13,9 +13,11 @@ export * from './lib/services/lookup-registry.service';
 export * from './lib/services/rbac.service';
 export * from './lib/services/rules-evaluation.service';
 export * from './lib/services/config-source.service';
+export * from './lib/services/validation-messages.service';
 export * from './lib/form/dynamic-form.component';
 export * from './lib/form/dynamic-record-form.component';
 export * from './lib/form/dynamic-field/dynamic-field.component';
+export * from './lib/field-types/field-component.contract';
 export * from './lib/field-types/text-field.component';
 export * from './lib/field-types/textarea-field.component';
 export * from './lib/field-types/number-field.component';
@@ -25,6 +27,8 @@ export * from './lib/field-types/password-field.component';
 export * from './lib/field-types/checkbox-field.component';
 export * from './lib/field-types/boolean-field.component';
 export * from './lib/field-types/date-field.component';
+export * from './lib/field-types/date-time-field.component';
+export * from './lib/field-types/time-field.component';
 export * from './lib/field-types/month-year-field.component';
 export * from './lib/field-types/dropdown-field.component';
 export * from './lib/field-types/radio-field.component';