@malva-ui/core 0.1.12

package/form-utils/lib/form-control-base/signal-form-control-base.d.ts

@@ -0,0 +1,159 @@
+import type { ModelSignal, Signal } from '@angular/core';
+import type { FormCheckboxControl, FormValueControl, ValidationError } from '@angular/forms/signals';
+import type { MlvFormState } from '../models/form-state';
+import type { BooleanInput } from '@angular/cdk/coercion';
+import type { MlvFormControl } from '../models/form-control-connector';
+import { MlvFormControlAppend } from '../form-control-sides';
+import { MlvFormControlInset } from '../form-control-sides';
+import { MlvFormControlPrepend } from '../form-control-sides';
+import * as i0 from "@angular/core";
+/**
+ * Shared, forms-transport-agnostic surface for **signal-forms** Malva controls.
+ * Owns everything EXCEPT the value/checked model: the
+ * Malva field surface (`state`, `label`, `hint`, `message`, `clearable`,
+ * `id`, prepend/append slots), the wrapper connector contract
+ * ({@link MlvFormControl}), and the signal-forms field↔control bindings —
+ * `errors` / `disabled` / `readonly` / `touched` / `dirty` input signals the
+ * `[formField]` directive binds automatically, plus the `touch` output the
+ * control emits when the user leaves the field.
+ *
+ * Per the signal-forms contract a component must NOT implement both
+ * `ControlValueAccessor` and `FormValueControl`; controls therefore adopt
+ * either {@link MlvSignalFormControlBase} or {@link MlvSignalCheckboxControlBase}
+ * atomically. Reactive (`[formControl]`)
+ * and template-driven (`ngModel`) bindings keep working — Angular binds the
+ * signal contract from those directives without extra compatibility code.
+ */
+export declare abstract class MlvSignalFormUiControlBase implements MlvFormControl {
+    /** @protected Backing signal for {@link focused}. */
+    protected readonly _focused: import("@angular/core").WritableSignal<boolean>;
+    /** Whether the control currently has focus (drives the wrapper's focus ring). */
+    readonly focused: Signal<boolean>;
+    /** Sets the control's focus state (wired to the focus target's focus/blur). */
+    setFocused(value: boolean): void;
+    /** Explicit consumer-authored visual validation state. */
+    readonly state: import("@angular/core").InputSignal<MlvFormState>;
+    /**
+     * Whether the control is read-only. Also a signal-forms field binding: when
+     * bound via `[formField]`, a `readonly` schema rule drives this input.
+     */
+    readonly readonly: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether the control is disabled. Also a signal-forms field binding: when
+     * bound via `[formField]`, the field's disabled state drives this input.
+     */
+    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether the control must be filled in. Renders the required marker in
+     * `mlv-label` and sets `aria-required` on the control's focus target. Also a
+     * signal-forms field binding: when bound via `[formField]`, a `required()`
+     * schema rule drives this input.
+     */
+    readonly required: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /** Whether the control shows its loading affordance. */
+    readonly loading: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** Whether the control renders a clear (X) affordance while it has a value. */
+    readonly clearable: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Fully rounded (stadium) control container. Shared by every control that
+     * renders through `mlv-form-control-wrapper`, mirroring `shape="pill"` on
+     * buttons and the pill action bar.
+     */
+    readonly pill: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Signal-forms field binding: current validation errors of the bound field
+     * (`[formField]` binds them automatically). Empty when unbound.
+     */
+    readonly errors: import("@angular/core").InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
+    /** Signal-forms field binding: whether the bound field is touched. */
+    readonly touched: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /** Signal-forms field binding: whether the bound field is dirty. */
+    readonly dirty: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Effective visual state exposed through the Malva form-control connector.
+     * An explicit non-default state wins; otherwise a signal-form validation
+     * error becomes visible after the field is touched, matching the default
+     * `MlvFormField` error-display strategy.
+     */
+    readonly resolvedState: Signal<MlvFormState>;
+    /**
+     * Emits when the user finishes interacting with the field (blur) — the
+     * signal-forms replacement for the CVA `onTouched` callback; `[formField]`
+     * subscribes and marks the bound field touched.
+     */
+    readonly touch: import("@angular/core").OutputEmitterRef<void>;
+    /**
+     * Whether the control currently holds a clearable (non-empty) value.
+     */
+    abstract readonly hasValue: Signal<boolean>;
+    /** HTML id applied to the control's focus target. */
+    readonly id: import("@angular/core").InputSignal<string>;
+    /** Label text rendered above the control. */
+    readonly label: import("@angular/core").InputSignal<string>;
+    /** Hint text rendered inside the label. */
+    readonly hint: import("@angular/core").InputSignal<string>;
+    /**
+     * Persistent help text rendered **below** the control, in front of the
+     * validation message. Unlike {@link hint} (a short inline aside inside the
+     * label) this is meant for sentence-length descriptions, and it stays
+     * visible while {@link message} is shown. Referenced by `aria-describedby`.
+     */
+    readonly description: import("@angular/core").InputSignal<string>;
+    /** Validation/status message rendered below the control. */
+    readonly message: import("@angular/core").InputSignal<string>;
+    /**
+     * Accessible name applied to the control's focus target (`aria-label`).
+     * Use it when the control renders no visible `<mlv-label>`.
+     */
+    readonly ariaLabel: import("@angular/core").InputSignal<string | null>;
+    /** @protected Id of the rendered `<mlv-description>` element. */
+    protected readonly _descriptionId: Signal<string>;
+    /** @protected Id of the rendered `<mlv-message>` element. */
+    protected readonly _messageId: Signal<string>;
+    /**
+     * @protected Space-separated `aria-describedby` value covering the rendered
+     * description and message elements — `null` when neither is rendered, so no
+     * dangling IDREF is emitted.
+     */
+    protected readonly _describedBy: Signal<string | null>;
+    /** Projected prefix slot. */
+    readonly prepend: Signal<MlvFormControlPrepend | undefined>;
+    /** Projected suffix slot. */
+    readonly append: Signal<MlvFormControlAppend | undefined>;
+    /** Projected full-width content rendered inside the control border. */
+    readonly inset: Signal<MlvFormControlInset | undefined>;
+    /**
+     * Effective disabled state. In the signal base there is no CVA
+     * `setDisabledState` side channel — the `disabled` input is the single
+     * source (consumer-bound or field-bound), kept as a computed so existing
+     * control templates retain one consistent disabled-state signal.
+     */
+    readonly computedDisabled: Signal<boolean>;
+    /** @protected Notifies the field that the user left the control. */
+    protected _markTouched(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvSignalFormUiControlBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvSignalFormUiControlBase, never, never, { "state": { "alias": "state"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "pill": { "alias": "pill"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "touch": "touch"; }, ["prepend", "append", "inset"], never, true, never>;
+}
+/**
+ * Signal-forms base for **value** controls: adds the required
+ * `value: ModelSignal<T>` of the `FormValueControl` contract. Each control
+ * supplies the model itself (`readonly value = model<T>(initial)`), mirroring
+ * how `hasValue` is supplied.
+ */
+export declare abstract class MlvSignalFormControlBase<T> extends MlvSignalFormUiControlBase implements FormValueControl<T> {
+    /** The control's value — kept in sync with the bound field by `[formField]`. */
+    abstract readonly value: ModelSignal<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvSignalFormControlBase<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvSignalFormControlBase<any>, never, never, {}, {}, never, never, true, never>;
+}
+/**
+ * Signal-forms base for **checkbox-shaped** controls (checkbox, switch): adds
+ * the required `checked: ModelSignal<boolean>` of the `FormCheckboxControl`
+ * contract. The contract forbids a `value` member on this variant.
+ */
+export declare abstract class MlvSignalCheckboxControlBase extends MlvSignalFormUiControlBase implements FormCheckboxControl {
+    /** The control's checked state — kept in sync with the bound field by `[formField]`. */
+    abstract readonly checked: ModelSignal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvSignalCheckboxControlBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvSignalCheckboxControlBase, never, never, {}, {}, never, never, true, never>;
+}

package/form-utils/lib/form-control-sides.d.ts

@@ -0,0 +1,20 @@
+import { MlvStructural } from '@malva-ui/cdk/utils';
+import * as i0 from "@angular/core";
+export declare class MlvFormControlPrepend extends MlvStructural {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvFormControlPrepend, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvFormControlPrepend, "[mlvFormControlPrepend]", never, {}, {}, never, never, true, never>;
+}
+export declare class MlvFormControlAppend extends MlvStructural {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvFormControlAppend, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvFormControlAppend, "[mlvFormControlAppend]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Full-width content rendered inside the bordered control, after its main row.
+ *
+ * Use for secondary, non-interactive control presentation such as strength
+ * meters. Prefix and suffix actions remain in their dedicated slots.
+ */
+export declare class MlvFormControlInset extends MlvStructural {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvFormControlInset, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvFormControlInset, "[mlvFormControlInset]", never, {}, {}, never, never, true, never>;
+}

package/form-utils/lib/form-control-wrapper/form-control-wrapper-control.d.ts

@@ -0,0 +1,6 @@
+import { MlvStructural } from '@malva-ui/cdk/utils';
+import * as i0 from "@angular/core";
+export declare class MlvFormControlWrapperControl extends MlvStructural {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvFormControlWrapperControl, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvFormControlWrapperControl, "[mlvFormControlWrapperControl]", never, {}, {}, never, never, true, never>;
+}

package/form-utils/lib/form-control-wrapper/form-control-wrapper.d.ts

@@ -0,0 +1,20 @@
+import { MlvFormControlWrapperControl } from './form-control-wrapper-control';
+import * as i0 from "@angular/core";
+export declare class MlvFormControlWrapper {
+    /** @protected Optional injected form control connector for state/focus/disabled bindings. */
+    protected readonly formControl: import("@malva-ui/core/form-utils").MlvFormControl | null;
+    /** @protected Computed BEM state modifier class derived from the control's validation state. */
+    protected readonly _stateClass: import("@angular/core").Signal<string>;
+    /** @protected Required projected control-slot directive rendered inside the wrapper. */
+    protected readonly renderer: import("@angular/core").Signal<MlvFormControlWrapperControl>;
+    /** @protected The component's i18n strings signal. */
+    protected readonly _i18n: import("@angular/core").Signal<import("@malva-ui/i18n").MlvFormUtilsI18n>;
+    /**
+     * Clear event emitter. Emits when user clicks on clear button
+     */
+    readonly clear: import("@angular/core").OutputEmitterRef<void>;
+    /** @protected Handles the clear-button click by emitting the `clear` output. */
+    protected _onClearClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvFormControlWrapper, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvFormControlWrapper, "mlv-form-control-wrapper", never, {}, { "clear": "clear"; }, ["renderer"], ["mlv-label", "mlv-description", "mlv-message", "[mlvFormControlWrapperAside]"], true, never>;
+}

package/form-utils/lib/form-field/form-field.d.ts

@@ -0,0 +1,68 @@
+import type { MlvFormState } from '../models/form-state';
+import type { MlvErrorDisplayStrategy } from '../models/error-display-strategy';
+import * as i0 from "@angular/core";
+export declare class MlvFormField {
+    /** Visual state of the field. Overridden to `'error'` when an auto error message is shown. */
+    readonly state: import("@angular/core").InputSignal<MlvFormState>;
+    /** Custom validator-key → message map (string or factory) overriding the built-in defaults. */
+    readonly errorMessages: import("@angular/core").InputSignal<Record<string, string | ((err: unknown) => string)>>;
+    /** Controls when validation errors become visible. */
+    readonly displayStrategy: import("@angular/core").InputSignal<MlvErrorDisplayStrategy>;
+    /**
+     * @private The form-utils i18n strings. Optional so `mlv-form-field` keeps
+     * rendering in applications that never called `provideMlvI18n()`.
+     */
+    private readonly _i18n;
+    /** @private The projected `NgControl` whose validation state this field reflects. */
+    private readonly _ngControl;
+    /**
+     * @private The projected signal-forms `[formField]` directive, when the
+     * child control is bound through `@angular/forms/signals` instead of an
+     * `NgControl`. Takes precedence over the NgControl path when present.
+     */
+    private readonly _signalField;
+    /**
+     * @private The bound signal-forms `FieldState`, or `null` while no
+     * `[formField]` child is projected. `field()` is the `FieldTree`; calling it
+     * yields the reactive `FieldState`.
+     */
+    private readonly _signalFieldState;
+    /** @private The ancestor form directive, used to observe submission state. */
+    private readonly _formDirective;
+    /** @private Current validation errors of the projected control. */
+    private readonly _controlErrors;
+    /** @private Whether the projected control has been touched. */
+    private readonly _controlTouched;
+    /** @private Whether the projected control is dirty. */
+    private readonly _controlDirty;
+    /** @private Whether the ancestor form has been submitted. */
+    private readonly _formSubmitted;
+    constructor();
+    /** @private Whether validation errors should currently be displayed, per {@link displayStrategy}. */
+    private readonly _shouldDisplay;
+    /**
+     * @private Unified error view: `[key, errorPayload]` pairs from whichever
+     * forms API the projected control is bound through. Signal-forms
+     * `ValidationError`s are keyed by their lower-cased `kind` (matching the
+     * legacy reactive keys: `minLength` → `minlength`); the payload is the
+     * error object itself (it carries `message` when a rule supplied one).
+     */
+    private readonly _errorEntries;
+    /** The resolved auto error message for the projected control, or `''` when none should show. */
+    readonly autoErrorMessage: import("@angular/core").Signal<string>;
+    /**
+     * @private Neutral, translated message shown when a validator key has no
+     * consumer-supplied, rule-supplied or built-in message.
+     */
+    private readonly _genericErrorMessage;
+    /**
+     * @private The currently displayed validator key that has no mapped message
+     * and therefore falls back to {@link _genericErrorMessage} — `null` when a
+     * specific message applies. Drives the dev-mode warning only.
+     */
+    private readonly _unmappedErrorKey;
+    /** The effective visual state: `'error'` when an auto error message is shown, otherwise {@link state}. */
+    readonly resolvedState: import("@angular/core").Signal<MlvFormState>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvFormField, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvFormField, "mlv-form-field", never, { "state": { "alias": "state"; "required": false; "isSignal": true; }; "errorMessages": { "alias": "errorMessages"; "required": false; "isSignal": true; }; "displayStrategy": { "alias": "displayStrategy"; "required": false; "isSignal": true; }; }, {}, ["_ngControl", "_signalField"], ["mlv-label", "*", "mlv-message"], true, never>;
+}

package/form-utils/lib/hint/hint.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class MlvHint {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvHint, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvHint, "mlv-hint", never, {}, {}, never, ["*"], true, never>;
+}

package/form-utils/lib/label/label.d.ts

@@ -0,0 +1,22 @@
+import type { BooleanInput } from '@angular/cdk/coercion';
+import * as i0 from "@angular/core";
+export declare class MlvLabel {
+    /** Id of the control this label names, rendered as the native `for` attribute. */
+    readonly for: import("@angular/core").InputSignal<string>;
+    /**
+     * Whether the labelled control is required. Renders a visual `*` marker plus
+     * a visually-hidden, translated "required" word so the requirement is
+     * announced even where `aria-required` is not surfaced. Controls extending
+     * `MlvSignalFormUiControlBase` forward their own `required` input here.
+     */
+    readonly required: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * @private The form-utils i18n strings. Optional so a bare `mlv-label` still
+     * renders in applications that never called `provideMlvI18n()`.
+     */
+    private readonly _i18n;
+    /** @protected Translated word announced after the label of a required control. */
+    protected readonly _requiredText: import("@angular/core").Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvLabel, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvLabel, "mlv-label", never, { "for": { "alias": "for"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; }, {}, never, ["*", "mlv-hint"], true, never>;
+}

package/form-utils/lib/message/message.d.ts

@@ -0,0 +1,7 @@
+import type { MlvFormState } from '../models/form-state';
+import * as i0 from "@angular/core";
+export declare class MlvMessage {
+    readonly state: import("@angular/core").InputSignal<MlvFormState>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvMessage, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvMessage, "mlv-message", never, { "state": { "alias": "state"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/form-utils/lib/models/error-display-strategy.d.ts

@@ -0,0 +1 @@
+export type MlvErrorDisplayStrategy = 'touched' | 'dirty' | 'submit' | 'immediate';

package/form-utils/lib/models/form-control-connector.d.ts

@@ -0,0 +1,41 @@
+import type { Signal } from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import type { MlvFormState } from './form-state';
+import type { MlvFormControlPrepend } from '../form-control-sides';
+import type { MlvFormControlAppend } from '../form-control-sides';
+import type { MlvFormControlInset } from '../form-control-sides';
+export interface MlvFormControl {
+    readonly focused: Signal<boolean>;
+    readonly disabled: Signal<boolean>;
+    readonly readonly: Signal<boolean>;
+    readonly state: Signal<MlvFormState>;
+    /**
+     * Effective state after field-bound errors/touched state are considered.
+     * Signal-form controls provide this; legacy controls fall back to `state`.
+     */
+    readonly resolvedState?: Signal<MlvFormState>;
+    readonly loading: Signal<boolean>;
+    readonly clearable: Signal<boolean>;
+    /**
+     * Fully rounded (stadium) control container. Optional — absent means the
+     * regular radius.
+     */
+    readonly pill?: Signal<boolean>;
+    /**
+     * Whether the control currently holds a clearable (non-empty) value. The
+     * wrapper renders the clear button only while `clearable() && hasValue()` —
+     * an empty control never shows a dangling X.
+     */
+    readonly hasValue: Signal<boolean>;
+    /**
+     * When `true`, the control renders its own clear button inside its template
+     * (e.g. select/combobox place it before the chevron) and the wrapper must
+     * NOT render its default one. Optional — absent means wrapper-rendered.
+     */
+    readonly ownsClearButton?: Signal<boolean>;
+    readonly prepend: Signal<MlvFormControlPrepend | undefined>;
+    readonly append: Signal<MlvFormControlAppend | undefined>;
+    /** Optional full-width content rendered inside the control border. */
+    readonly inset: Signal<MlvFormControlInset | undefined>;
+}
+export declare const MLV_FORM_CONTROL: InjectionToken<MlvFormControl>;

package/form-utils/lib/models/form-state.d.ts

@@ -0,0 +1 @@
+export type MlvFormState = 'default' | 'success' | 'info' | 'warning' | 'error';

package/form-utils/lib/selection.service.d.ts

@@ -0,0 +1,27 @@
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class MlvSelectionService<T = unknown> {
+    readonly multiple: import("@angular/core").WritableSignal<boolean>;
+    readonly selectedValues: import("@angular/core").WritableSignal<T[]>;
+    readonly focusFirst$: Subject<void>;
+    /**
+     * Equality predicate used for all membership checks (`isSelected`,
+     * `deselect`, and the `select`/`toggle` de-dup path). Defaults to reference
+     * equality (`a === b`). Set a custom comparator (e.g. compare by id) so object
+     * values written via `writeValue` after deserialization match the option
+     * instances and check-marks / display value stay in agreement.
+     */
+    readonly compareWith: import("@angular/core").WritableSignal<(a: T, b: T) => boolean>;
+    readonly displayValue: import("@angular/core").Signal<string>;
+    /** @private Index of `value` within the current selection, or `-1`. */
+    private _indexOf;
+    select(value: T): void;
+    deselect(value: T): void;
+    isSelected(value: T): boolean;
+    clear(): void;
+    setValues(values: T[]): void;
+    toggle(value: T): void;
+    requestFocusFirst(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvSelectionService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MlvSelectionService<any>>;
+}

package/form-utils/malva-ui-core-form-utils.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@malva-ui/core/form-utils" />
+export * from './index';

package/form-utils/testing/index.d.ts

@@ -0,0 +1 @@
+export * from './lib/forms-binding-matrix';

package/form-utils/testing/lib/forms-binding-matrix.d.ts

@@ -0,0 +1,47 @@
+/**
+ * One binding mode's view of the form side while running the bindings matrix.
+ * Concrete adapters are built by the control's spec for each of the three
+ * binding modes (reactive `[formControl]`, template-driven `ngModel`, signal
+ * forms `[formField]`), so the shared {@link verifyFormsBinding} assertions
+ * stay identical across modes and across controls.
+ */
+export interface MlvFormsBindingAdapter<T> {
+    /** Mode label used in assertion messages. */
+    readonly mode: 'reactive' | 'template-driven' | 'signal-forms';
+    /** Writes a value from the FORM side into the control. */
+    setValue(value: T): void | Promise<void>;
+    /** Reads the form side's current value. */
+    getValue(): T;
+    /** Whether the form side considers the control touched. */
+    isTouched(): boolean;
+    /** Disables from the form side. Omit when the mode cannot express it. */
+    setDisabled?(disabled: boolean): void | Promise<void>;
+    /** Whether the COMPONENT reports disabled (e.g. `computedDisabled()`). */
+    isDisabled?(): boolean;
+}
+/**
+ * Options for one {@link verifyFormsBinding} run.
+ */
+export interface MlvFormsBindingMatrixOptions<T> {
+    /** The mode adapter under test. */
+    adapter: MlvFormsBindingAdapter<T>;
+    /** Value written from the form side; must round-trip unchanged. */
+    sample: T;
+    /**
+     * Simulates a USER interaction on the rendered control that must surface on
+     * the form side as {@link expectedAfterInteraction}.
+     */
+    interact: () => void | Promise<void>;
+    /** Form-side value expected after {@link interact}. */
+    expectedAfterInteraction: T;
+    /** Simulates the user leaving the field; drives the touched assertion. */
+    blur?: () => void | Promise<void>;
+}
+/**
+ * Shared assertion driver for the forms bindings matrix: form→control value
+ * write, control→form user interaction, touched propagation on blur, and
+ * disabled propagation — identical expectations for every binding mode. A
+ * control's spec calls this once per mode; a migrated control (CVA →
+ * FormValueControl) must keep all three runs green.
+ */
+export declare function verifyFormsBinding<T>(options: MlvFormsBindingMatrixOptions<T>): Promise<void>;

package/form-utils/testing/malva-ui-core-form-utils-testing.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@malva-ui/core/form-utils/testing" />
+export * from './index';

package/index.d.ts

@@ -0,0 +1,69 @@
+export * from '@malva-ui/core/alert';
+export * from '@malva-ui/core/autocomplete';
+export * from '@malva-ui/core/calendar';
+export * from '@malva-ui/core/chat';
+export * from '@malva-ui/core/checkbox';
+export * from '@malva-ui/core/color-picker';
+export * from '@malva-ui/core/combobox';
+export * from '@malva-ui/core/copy-to-clipboard';
+export * from '@malva-ui/core/date-range-picker';
+export * from '@malva-ui/core/day-picker';
+export * from '@malva-ui/core/dropdown';
+export * from '@malva-ui/core/filter';
+export * from '@malva-ui/core/form';
+export * from '@malva-ui/core/form-utils';
+export * from '@malva-ui/core/input';
+export * from '@malva-ui/core/number-input';
+export * from '@malva-ui/core/radio';
+export * from '@malva-ui/core/select';
+export * from '@malva-ui/core/slider';
+export * from '@malva-ui/core/switch';
+export * from '@malva-ui/core/tokenizer';
+export * from '@malva-ui/core/action-bar';
+export * from '@malva-ui/core/avatar';
+export * from '@malva-ui/core/avatar-group';
+export * from '@malva-ui/core/badge';
+export * from '@malva-ui/core/button';
+export * from '@malva-ui/core/card';
+export * from '@malva-ui/core/chip';
+export * from '@malva-ui/core/data-table';
+export * from '@malva-ui/core/dialog';
+export * from '@malva-ui/core/drawer';
+export * from '@malva-ui/core/accordion';
+export * from '@malva-ui/core/expand';
+export * from '@malva-ui/core/layout';
+export * from '@malva-ui/core/link';
+export * from '@malva-ui/core/list';
+export * from '@malva-ui/core/loader';
+export * from '@malva-ui/core/progress';
+export * from '@malva-ui/core/notification';
+export * from '@malva-ui/core/pagination';
+export * from '@malva-ui/core/popup';
+export * from '@malva-ui/core/scrollbar';
+export * from '@malva-ui/core/search-field';
+export * from '@malva-ui/core/segmented';
+export * from '@malva-ui/core/sidebar';
+export * from '@malva-ui/core/status-indicator';
+export * from '@malva-ui/core/tabs';
+export * from '@malva-ui/core/tile';
+export * from '@malva-ui/core/title';
+export * from '@malva-ui/core/toast';
+export * from '@malva-ui/core/textarea';
+export * from '@malva-ui/core/toolbar';
+export * from '@malva-ui/core/menu';
+export * from '@malva-ui/core/tooltip';
+export * from '@malva-ui/core/breadcrumb';
+export * from '@malva-ui/core/divider';
+export * from '@malva-ui/core/stepper';
+export * from '@malva-ui/core/skeleton';
+export * from '@malva-ui/core/timeline';
+export * from '@malva-ui/core/split-pane';
+export * from '@malva-ui/core/empty-state';
+export * from '@malva-ui/core/kbd';
+export * from '@malva-ui/core/page';
+export * from '@malva-ui/core/bottom-nav';
+export * from '@malva-ui/core/file-upload';
+export * from '@malva-ui/core/pin-input';
+export * from '@malva-ui/core/rating';
+export * from '@malva-ui/core/time-picker';
+export * from '@malva-ui/core/tree';

package/input/index.d.ts

@@ -0,0 +1,3 @@
+export * from './lib/input/input';
+export * from './lib/input/input-native';
+export * from './lib/input/password-strength';

package/input/lib/input/input-native.d.ts

@@ -0,0 +1,36 @@
+import { ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Marks a consumer-provided native `<input>` that should be adopted as the
+ * control element of a `<mlv-input projectControl>`.
+ *
+ * `mlv-input` normally renders and owns its own internal `<input>`. Some
+ * headless behaviours — most notably `@angular/aria`'s combobox family, whose
+ * trigger directive (`[ngCombobox]`, formerly `input[ngComboboxInput]`) must
+ * sit directly on the interactive `<input>` element — need to attach their own
+ * attribute directives to that input. Because Angular cannot attach an external
+ * directive to a component's *internal* template element, `mlv-input` instead
+ * exposes an opt-in projection slot: set `projectControl` on `<mlv-input>` and
+ * project your own `<input mlvInputNative …>` carrying whatever directives you
+ * need. This directive applies the shared `mlv-input__native` styling hook and
+ * makes the element discoverable to the host `mlv-input` so focus/selection
+ * helpers keep working.
+ *
+ * @example
+ * ```html
+ * <mlv-input bare projectControl>
+ *   <input mlvInputNative ngCombobox [(value)]="query" [(expanded)]="open" />
+ * </mlv-input>
+ * ```
+ */
+export declare class MlvInputNative {
+    /**
+     * @protected The projected native `<input>` element reference, used by the
+     * host `mlv-input` to forward `focus()` / `select()` calls.
+     */
+    protected readonly _elementRef: ElementRef<HTMLInputElement>;
+    /** The projected native `<input>` element. */
+    get nativeElement(): HTMLInputElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvInputNative, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvInputNative, "input[mlvInputNative]", ["mlvInputNative"], {}, {}, never, never, true, never>;
+}

package/input/lib/input/input-value-accessor.d.ts

@@ -0,0 +1,11 @@
+import type { Signal } from '@angular/core';
+import { InjectionToken } from '@angular/core';
+/**
+ * @internal Minimal host contract consumed by input-attached behavior
+ * directives without importing the concrete input component.
+ */
+export interface MlvInputValueAccessor {
+    readonly value: Signal<string>;
+}
+/** @internal Injection token for the active input value signal. */
+export declare const MLV_INPUT_VALUE: InjectionToken<MlvInputValueAccessor>;