@arsedizioni/ars-utils 22.5.35 → 22.5.37

package/types/arsedizioni-ars-utils-core.d.ts

@@ -188,21 +188,62 @@ interface LoginResult<T> extends ApiResult<boolean> {
  * The two shapes differ in one systematic way. A DTO leaves out what it does not have: a place
  * with no phone number simply has no `phone`. A form model cannot afford that — signal forms only
  * build a child field for a key whose value is defined, and the string validators need a `string`
- * rather than `string | undefined` — so every editable field is present, holding its empty value
- * (`''` for text and for the boxes of a datepicker, `false` for a checkbox, `0` for a counter).
+ * rather than `string | undefined` — so every editable field is present, holding its empty value.
  *
  * Doing that conversion by hand means a `?? ''` per field on the way in and a `|| undefined` per
- * field on the way out, twice per form, kept in sync forever. {@link DtoUtils.fromModel} and
- * {@link DtoUtils.toModel} do it once, driven by a single "empty model" constant that also serves as
+ * field on the way out, twice per form, kept in sync forever. {@link DtoUtils.toForm} and
+ * {@link DtoUtils.toPayload} do it once, driven by a single "empty model" constant that also serves as
  * the initial value of the form and as what a "clear" button restores.
+ *
+ * ## The convention
+ *
+ * 1. **A component that edits a DTO owns a form model of its own.** `ProfileEditComponent`
+ *    receiving a `ProfileModel` declares a `ProfileForm`, derived from it — never binds the DTO
+ *    to the form directly. The DTO stays free to say "absent"; the form is not.
+ * 2. **What is optional in the DTO becomes `| null` in the form model.** `phone?: string` becomes
+ *    `phone: string` holding `''`, `level?: Level` becomes `level: Level | null`. The optionality
+ *    is not lost, it moves into the empty value, and {@link Dto} gives it back on the way out.
+ * 3. **A date field is `Date | null`.** Always a `Date`, never a `Date | string`; `null` is its
+ *    empty value, because that is what Material's date accessors — the single datepicker and both
+ *    boxes of a `mat-date-range-picker` — write when an input is cleared.
+ * 4. **The empty model is named `_EMPTY_ITEM`.** One constant per form, next to its interface.
+ * 5. **The two conversions are called `toForm()` and `toPayload()`, and are written one after the
+ *    other.** When a component builds more than one payload, the others are `toPayloadXxx()` and
+ *    the main one keeps the bare name.
+ * 6. **A payload always goes through `toPayload()` before it reaches the API.** When the payload
+ *    needs adjustments the generic conversion cannot make — a bitmask to rebuild, dates to
+ *    normalize, a number to coerce, fields the model does not own — the component declares its own
+ *    `toPayload()` and calls {@link DtoUtils.toPayload} inside it for the field-by-field part.
+ *
+ * @example
+ * ```ts
+ * interface ProfileForm {
+ *   name: string;          // name?: string  in ProfileModel
+ *   level: Level | null;   // level?: Level
+ *   from: Date | null;     // fromDate?: Date, bound to a mat-date-range-picker
+ *   to: Date | null;       // toDate?: Date
+ *   active: boolean;
+ * }
+ *
+ * const _EMPTY_ITEM: ProfileForm = { name: '', level: null, from: null, to: null, active: false };
+ *
+ * private toForm(dto?: ProfileModel): ProfileForm {
+ *   return DtoUtils.toForm(_EMPTY_ITEM, dto as Partial<ProfileForm>);
+ * }
+ *
+ * private toPayload(): ProfileModel {
+ *   const { from, to, ...rest } = this.model();
+ *   return { ...DtoUtils.toPayload(rest), fromDate: from ?? undefined, toDate: to ?? undefined };
+ * }
+ * ```
  */
 /**
  * The DTO shape of a form model: the same fields, without the values that stand for "empty".
  *
- * It mirrors what {@link DtoUtils.toModel} does at runtime, so the payload type says the truth. It
- * only works when the empty value is a literal type — `Date | '' | null` narrows to `Date`, while
- * a field typed `Date | string` cannot be narrowed, because `string` is not assignable to `''`.
- * That is the reason the convention is `| ''` and not `| string`.
+ * It mirrors what {@link DtoUtils.toPayload} does at runtime, so the payload type says the truth. It
+ * only works when the empty value is `''` or `null` — `Date | null` narrows to `Date`, and
+ * `string` (which is what `''` widens to) narrows to `string`. That is the reason a date field is
+ * `Date | null` and never `Date | string`: the latter could not be narrowed at all.
  */
 type Dto<TModel> = {
     [K in keyof TModel]: Exclude<TModel[K], '' | null>;
@@ -224,11 +265,8 @@ declare class DtoUtils {
      *                one takes when the DTO does not carry it.
      * @param dto   - The object coming from the API, or `undefined` when creating a new record.
      * @returns A new model, never the same reference as `empty` nor as `dto`.
-     * @example
-     * const EMPTY_PLACE: PlaceForm = { name: '', city: '', phone: '', disabled: false };
-     * this.form().reset(DtoUtils.fromModel(EMPTY_PLACE, r.value));
      */
-    static fromModel<TModel extends object>(empty: TModel, dto?: Partial<TModel> | null): TModel;
+    static toForm<TModel extends object>(empty: TModel, dto?: Partial<TModel> | null): TModel;
     /**
      * Builds the payload for the API from the current form model.
      *
@@ -248,10 +286,8 @@ declare class DtoUtils {
      *
      * @param model - The current form model.
      * @returns A shallow copy without the empty fields.
-     * @example
-     * this.scmService.places.savePlace(DtoUtils.toModel(this.model()));
      */
-    static toModel<TModel extends object>(model: TModel): Dto<TModel>;
+    static toPayload<TModel extends object>(model: TModel): Dto<TModel>;
 }
 
 declare const UtilsMessages: {

package/types/arsedizioni-ars-utils-core.date.d.ts

@@ -191,7 +191,7 @@ declare class DateFnsAdapter extends DateAdapter<Date, Locale> {
     static ɵprov: i0.ɵɵInjectableDeclaration<DateFnsAdapter>;
 }
 /**
- * Standalone providers for the ARS date-fns adapter.
+ * Standalone providers for the SCM date-fns adapter.
  *
  * Configures Angular Material to use {@link DateFnsAdapter} (Europe/Rome timezone)
  * and the matching {@link MAT_DATE_FNS_FORMATS}. Also supports `mat-timepicker` since
@@ -199,10 +199,10 @@ declare class DateFnsAdapter extends DateAdapter<Date, Locale> {
  *
  * @example
  * bootstrapApplication(AppComponent, {
- *   providers: [provideArsDateFns()]
+ *   providers: [provideScmDateFns()]
  * });
  */
-declare function provideArsDateFns(): EnvironmentProviders;
+declare function provideScmDateFns(): EnvironmentProviders;
 
 /** Default application timezone: all dates are serialised as Europe/Rome wall-clock values. */
 declare const DEFAULT_TIME_ZONE = "Europe/Rome";
@@ -301,4 +301,37 @@ declare function toLocalDateOnlyString(value?: Date | null, timeZone?: string):
  */
 declare function toLocalDateTimeString(value?: Date | null, timeZone?: string): string | undefined;
 
-export { ARS_TIME_ZONE, ArsLocalDateInterceptor, DEFAULT_TIME_ZONE, DateFnsAdapter, MAT_DATE_FNS_FORMATS, arsLocalDateInterceptor, provideArsDateFns, provideArsLocalDates, toLocalDateOnlyString, toLocalDateTimeString };
+/**
+ * Works around a MatDatepicker/Signal Forms interop bug.
+ *
+ * `MatDatepickerInputBase._onInput()` only notifies its registered validator-change
+ * callback from the branch it does not take when the parsed date is null. Signal
+ * Forms recomputes CVA parse errors from that callback or from a model value
+ * change, and neither happens while the user erases an unparseable date one
+ * character at a time (the model is already `null`, so the signal write is a
+ * no-op). The stale `matDatepickerParse` error therefore survives on an empty
+ * field. Notifying on every keystroke re-runs the datepicker validators.
+ */
+declare class MatDatepickerParseErrorFixDirective {
+    private readonly singleDate;
+    private readonly startDate;
+    private readonly endDate;
+    /**
+     * Re-runs the datepicker validators after Material has updated its internal
+     * parse flag.
+     *
+     * @returns Nothing.
+     */
+    protected onInput(): void;
+    /**
+   * Notifies the validator-change callback of this input and, for range parts,
+   * of the sibling input as well.
+   *
+   * @returns Nothing.
+   */
+    private revalidate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatDatepickerParseErrorFixDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatDatepickerParseErrorFixDirective, "input[matDatepicker], input[matStartDate], input[matEndDate]", never, {}, {}, never, never, true, never>;
+}
+
+export { ARS_TIME_ZONE, ArsLocalDateInterceptor, DEFAULT_TIME_ZONE, DateFnsAdapter, MAT_DATE_FNS_FORMATS, MatDatepickerParseErrorFixDirective, arsLocalDateInterceptor, provideArsLocalDates, provideScmDateFns, toLocalDateOnlyString, toLocalDateTimeString };

package/types/arsedizioni-ars-utils-ui.dialogs.auth.d.ts

@@ -124,6 +124,23 @@ interface CredentialsDialogData {
     mode?: 'email' | 'user' | 'otp';
     appearance?: MatFormFieldAppearance;
 }
+/**
+ * Form model of the credentials dialog.
+ *
+ * {@link CredentialsDialogResult} is the DTO: every field of it is optional, so it
+ * cannot back a signal form directly. Here every field is present and holds its empty
+ * value, and {@link DtoUtils.toPayload} turns the model back into the DTO on the way out.
+ */
+interface CredentialsForm {
+    /** The account name or email; `''` when the input is empty. */
+    user: string;
+    /** The password; `''` when the input is empty or the dialog is in `otp` mode. */
+    password: string;
+    /** Whether the session should be remembered. */
+    rememberMe: boolean;
+    /** The 6-digit OTP code; `''` outside `otp` mode. */
+    code: string;
+}
 declare class CredentialsDialogComponent {
     /** Error text of a field: the message declared in the schema, or the shared fallback. */
     protected readonly getErrorMessage: typeof SignalsUtils.getFieldErrorMessage;
@@ -135,13 +152,26 @@ declare class CredentialsDialogComponent {
     protected readonly dialogData: _angular_core.WritableSignal<CredentialsDialogData>;
     /** Model backing the signal form, pre-filled with the user name from dialog data when provided. */
     private readonly model;
+    /**
+     * Builds the form model from the dialog data, which may carry the account name to
+     * pre-fill.
+     * @returns A fresh form model.
+     */
+    private toForm;
+    /**
+     * Builds the dialog result from the current form model. The fields the active mode
+     * does not use are left empty by the template and dropped here, so they travel as
+     * absent instead of as empty strings.
+     * @returns The credentials to emit through `done` or `recoveringPassword`.
+     */
+    private toPayload;
     /**
      * Signal form for the credentials. Validators follow the active mode: the user
      * field is a required email in `email` mode and plain required in `user` mode,
      * the password is required outside `otp` mode, and the OTP code is a required
      * complete 6-digit code in `otp` mode.
      */
-    protected readonly form: _angular_forms_signals.FieldTree<CredentialsDialogResult, string | number, "writable">;
+    protected readonly form: _angular_forms_signals.FieldTree<CredentialsForm, string | number, "writable">;
     /** Whether the password field is currently shown as plain text. */
     protected readonly showPassword: _angular_core.WritableSignal<boolean>;
     /**
@@ -171,6 +201,29 @@ interface ResetPasswordDialogData {
     userEmail?: string;
     appearance?: MatFormFieldAppearance;
 }
+/**
+ * Form model of the password-reset dialog.
+ *
+ * {@link ResetPasswordDialogResult} is the DTO: every field of it is optional, so it
+ * cannot back a signal form directly. Here every field is present — `userId` included,
+ * which is carried through untouched — and an absent value becomes `null` for the
+ * numeric id and `''` for the text fields, the empty states signal forms and the string
+ * validators work with.
+ */
+interface ResetPasswordForm {
+    /** Id of the account whose password is being reset; `null` in the modes that identify it by email. */
+    userId: number | null;
+    /** Email of the account; `''` outside the modes that ask for it. */
+    userEmail: string;
+    /** The current password, asked for in `old` mode; `''` elsewhere. */
+    oldPassword: string;
+    /** The new password. */
+    password: string;
+    /** Confirmation of the new password; `''` in `admin` mode, where it is not asked for. */
+    password2: string;
+    /** The 6-digit OTP code, asked for in `otp` mode; `''` elsewhere. */
+    code: string;
+}
 declare class ResetPasswordDialogComponent {
     /** Error text of a field: the message declared in the schema, or the shared fallback. */
     protected readonly getErrorMessage: typeof SignalsUtils.getFieldErrorMessage;
@@ -182,6 +235,19 @@ declare class ResetPasswordDialogComponent {
     protected readonly dialogData: _angular_core.WritableSignal<ResetPasswordDialogData>;
     /** Model backing the signal form. */
     private readonly model;
+    /**
+     * Builds the form model from the dialog data, which identifies the account either by
+     * id or by email depending on the mode.
+     * @returns A fresh form model.
+     */
+    private toForm;
+    /**
+     * Builds the dialog result from the current form model. The fields the active mode
+     * does not use are left empty by the template and dropped here, so they travel as
+     * absent instead of as empty strings.
+     * @returns The reset data to emit through `done`.
+     */
+    private toPayload;
     /**
      * Signal form for the password reset. Validators follow the active mode:
      * the email is required in `forgot` mode, the old password in `old` mode,
@@ -189,7 +255,7 @@ declare class ResetPasswordDialogComponent {
      * required, at least 10 characters and strong enough, and its confirmation
      * (required outside `admin` mode) must match it.
      */
-    protected readonly form: _angular_forms_signals.FieldTree<ResetPasswordDialogResult, string | number, "writable">;
+    protected readonly form: _angular_forms_signals.FieldTree<ResetPasswordForm, string | number, "writable">;
     /** Whether the old-password field is currently shown as plain text. */
     protected readonly showOldPassword: _angular_core.WritableSignal<boolean>;
     /** Whether the new-password field is currently shown as plain text. */
@@ -212,6 +278,19 @@ declare class ResetPasswordDialogComponent {
 interface RecoverPasswordDialogData {
     appearance?: MatFormFieldAppearance;
 }
+/**
+ * Form model of the password-recovery dialog.
+ *
+ * {@link RecoverPasswordDialogResult} is the DTO: every field of it is optional, so it
+ * cannot back a signal form directly. Here every field is present and holds its empty
+ * value, and {@link DtoUtils.toPayload} turns the model back into the DTO on the way out.
+ */
+interface RecoverPasswordForm {
+    /** The email the recovery link is sent to; `''` when the input is empty. */
+    email: string;
+    /** Whether the recaptcha challenge has been solved. */
+    recaptcha: boolean;
+}
 declare class RecoverPasswordDialogComponent {
     /** Error text of a field: the message declared in the schema, or the shared fallback. */
     protected readonly getErrorMessage: typeof SignalsUtils.getFieldErrorMessage;
@@ -221,10 +300,22 @@ declare class RecoverPasswordDialogComponent {
     protected readonly dialogData: _angular_core.WritableSignal<RecoverPasswordDialogData>;
     /** Model backing the signal form. */
     private readonly model;
+    /**
+     * Builds the form model. The dialog is always opened empty, so the model is the
+     * neutral one.
+     * @returns A fresh form model.
+     */
+    private toForm;
+    /**
+     * Builds the dialog result from the current form model, dropping the email when it
+     * was left empty.
+     * @returns The result to emit through `done`.
+     */
+    private toPayload;
     /**
      * Signal form for the recovery request: the email is required and must be valid.
      */
-    protected readonly form: _angular_forms_signals.FieldTree<RecoverPasswordDialogResult, string | number, "writable">;
+    protected readonly form: _angular_forms_signals.FieldTree<RecoverPasswordForm, string | number, "writable">;
     /**
      * Emits the current form result to trigger the password-recovery flow.
      */
@@ -233,20 +324,39 @@ declare class RecoverPasswordDialogComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<RecoverPasswordDialogComponent, "ng-component", never, {}, { "done": "done"; }, never, never, true, never>;
 }
 
+/**
+ * Form model of the OTP dialog.
+ *
+ * {@link PromptOtpDialogResult} is the DTO: it leaves the code out when there is none.
+ * The form cannot, so the field is always present and holds `''` when empty.
+ */
+interface PromptOtpForm {
+    /** The 6-digit OTP code; `''` while the user has not completed it. */
+    value: string;
+}
 declare class PromptOtpDialogComponent {
     readonly done: _angular_core.OutputEmitterRef<PromptOtpDialogResult>;
     private readonly dialogService;
     protected readonly dialogData: _angular_core.WritableSignal<PromptDialogData>;
     /** Model backing the signal form. `value` holds the 6-digit OTP code. */
     private readonly model;
+    /**
+     * Builds the form model. The dialog has no incoming value, so the model is the
+     * neutral one.
+     * @returns A fresh form model.
+     */
+    private toForm;
+    /**
+     * Builds the dialog result from the current form model, dropping the empty code.
+     * @returns The result carrying the entered OTP code.
+     */
+    private toPayload;
     /**
      * Signal form for the OTP code. The code is always required here; the
      * "complete 6 digits" rule comes from the OtpInputComponent validator,
      * honoured through the ControlValueAccessor interop.
      */
-    protected readonly form: _angular_forms_signals.FieldTree<{
-        value: string;
-    }, string | number, "writable">;
+    protected readonly form: _angular_forms_signals.FieldTree<PromptOtpForm, string | number, "writable">;
     /**
      * Validates the form and emits the OTP result, or shows an error if validation fails.
      */

package/types/arsedizioni-ars-utils-ui.dialogs.prompt.d.ts

@@ -3,6 +3,17 @@ import * as _angular_core from '@angular/core';
 import { PromptDialogResult, PromptDialogData, PromptDateDialogResult, PromptTimeDialogData } from '@arsedizioni/ars-utils/ui';
 import { SignalsUtils } from '@arsedizioni/ars-utils/core.validators';
 
+/**
+ * Form model of the generic prompt.
+ *
+ * The DTO side is {@link PromptDialogData.initialValue} on the way in and
+ * {@link PromptDialogResult.value} on the way out; both may be absent, while the form
+ * always owns the field. `value` stays `any` because its shape follows the prompt type.
+ */
+interface PromptForm {
+    /** The prompted value: `''` for textual types, `null` for the number and list types. */
+    value: any;
+}
 declare class PromptDialogComponent {
     /** Error text of a field: the message declared in the schema, or the shared fallback. */
     protected readonly getErrorMessage: typeof SignalsUtils.getFieldErrorMessage;
@@ -11,13 +22,31 @@ declare class PromptDialogComponent {
     protected readonly dialogData: _angular_core.WritableSignal<PromptDialogData>;
     /** Model backing the signal form. `value` type depends on the prompt type. */
     private readonly model;
+    /**
+     * Builds the form model from the value carried by the dialog data.
+     *
+     * Ad-hoc because the empty value follows the prompt type: native inputs bound via
+     * `[formField]` report an empty number or an unselected option as `null`, while a
+     * text, date or textarea input reports `''`. The list type never takes an initial
+     * value: its options are matched by the template.
+     * @returns A fresh form model.
+     */
+    private toForm;
+    /**
+     * Builds the dialog result from the current form model.
+     *
+     * Ad-hoc because the result also carries the prompt type and the caller's `options`,
+     * which are not part of the form model; the value itself goes through
+     * {@link DtoUtils.toPayload}, so an input left empty travels as absent instead of as
+     * an empty string or a `null`.
+     * @returns The result to emit through `done`.
+     */
+    private toPayload;
     /**
      * Signal form for the prompt value. Validators mirror the previous template-driven
      * form: `required` follows the dialog data, `min`/`max` apply to the Number type.
      */
-    protected readonly form: _angular_forms_signals.FieldTree<{
-        value: any;
-    }, string | number, "writable">;
+    protected readonly form: _angular_forms_signals.FieldTree<PromptForm, string | number, "writable">;
     /**
      * Validates the form and emits the result, or shows an error if validation fails.
      */
@@ -26,6 +55,23 @@ declare class PromptDialogComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<PromptDialogComponent, "ng-component", never, {}, { "done": "done"; }, never, never, true, never>;
 }
 
+/**
+ * Form model of the date prompt.
+ *
+ * The DTO side is {@link PromptDialogData.initialValue} on the way in and
+ * {@link PromptDateDialogResult.value} on the way out; both leave the value out when
+ * there is none, while the form always owns every field. Dates are always `Date | null`
+ * — never a `Date | string` — because `null` is what Material's date accessors write
+ * when a datepicker input is cleared.
+ */
+interface PromptDateForm {
+    /** Value of the single-date type; `null` when the input is empty. */
+    date: Date | null;
+    /** Start of the range of the date-interval type; `null` when the input is empty. */
+    from: Date | null;
+    /** End of the range of the date-interval type; `null` when the input is empty. */
+    to: Date | null;
+}
 declare class PromptDateDialogComponent {
     /** Error text of a field: the message declared in the schema, or the shared fallback. */
     protected readonly getErrorMessage: typeof SignalsUtils.getFieldErrorMessage;
@@ -53,16 +99,29 @@ declare class PromptDateDialogComponent {
      * input as `null` anyway; values are normalized to `undefined` on emit.
      */
     private readonly model;
+    /**
+     * Builds the form model from the value carried by the dialog data: a `Date` for the
+     * single-date type, a {@link DateInterval} for the date-interval one.
+     * @returns A fresh form model, empty when the dialog was opened without a value.
+     */
+    private toForm;
+    /**
+     * Builds the dialog result from the current form model.
+     *
+     * Ad-hoc because the two prompt types produce different values out of the same model
+     * — a `Date` or a {@link DateInterval} — and because the result also carries the type
+     * and the caller's `options`, which are not part of the form model. The dates
+     * themselves go through {@link DtoUtils.toPayload}, so a bound left empty travels as
+     * absent instead of as `null`.
+     * @returns The result to emit through `done`.
+     */
+    private toPayload;
     /**
      * Signal form for the date value(s). `required` follows the dialog data and only
      * applies to the fields of the active prompt type; the datepicker's own parse
      * validators are picked up through the ControlValueAccessor interop.
      */
-    protected readonly form: _angular_forms_signals.FieldTree<{
-        date: Date | null;
-        from: Date | null;
-        to: Date | null;
-    }, string | number, "writable">;
+    protected readonly form: _angular_forms_signals.FieldTree<PromptDateForm, string | number, "writable">;
     /** Debounced stream of keyup events on the interval inputs (shorthand typing support). */
     private readonly intervalKeyup;
     constructor();
@@ -90,6 +149,17 @@ declare class PromptDateDialogComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<PromptDateDialogComponent, "ng-component", never, {}, { "done": "done"; }, never, never, true, never>;
 }
 
+/**
+ * Form model of the time prompt.
+ *
+ * The DTO side is {@link PromptTimeDialogData.initialValue} on the way in and
+ * {@link PromptDialogResult.value} on the way out; both leave the value out when there
+ * is none, while the form always owns the field and holds `''` when empty.
+ */
+interface PromptTimeForm {
+    /** The `"HH:MM"` time value; `''` when the input is empty. */
+    value: string;
+}
 declare class PromptTimeDialogComponent {
     /** Error text of a field: the message declared in the schema, or the shared fallback. */
     protected readonly getErrorMessage: typeof SignalsUtils.getFieldErrorMessage;
@@ -98,13 +168,25 @@ declare class PromptTimeDialogComponent {
     protected readonly dialogData: _angular_core.WritableSignal<PromptTimeDialogData>;
     /** Model backing the signal form. The value is a `"HH:MM"` time string. */
     private readonly model;
+    /**
+     * Builds the form model from the value carried by the dialog data.
+     * @returns A fresh form model, empty when the dialog was opened without a value.
+     */
+    private toForm;
+    /**
+     * Builds the dialog result from the current form model.
+     *
+     * Ad-hoc because the result also carries the caller's `options`, which are not part
+     * of the form model; the time itself goes through {@link DtoUtils.toPayload}, so an
+     * empty input travels as absent instead of as an empty string.
+     * @returns The result to emit through `done`.
+     */
+    private toPayload;
     /**
      * Signal form for the time value: `required` follows the dialog data and the
      * time validator enforces format and the optional allowed slots.
      */
-    protected readonly form: _angular_forms_signals.FieldTree<{
-        value: string;
-    }, string | number, "writable">;
+    protected readonly form: _angular_forms_signals.FieldTree<PromptTimeForm, string | number, "writable">;
     /**
      * Validates the form and emits the result, or shows an error if validation fails.
      */

package/types/arsedizioni-ars-utils-ui.dialogs.select.d.ts

@@ -273,6 +273,21 @@ declare class SelectTreeDialogComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<SelectTreeDialogComponent, "ng-component", never, {}, { "done": "done"; "append": "append"; }, never, never, true, never>;
 }
 
+/**
+ * Form model of the send-to dialog.
+ *
+ * {@link SendToDialogResult} is the DTO: every field of it is optional, so it cannot
+ * back a signal form directly. Here every editable field is present and holds `''` when
+ * empty; `options` is not editable and is only added back by {@link toPayload}.
+ */
+interface SendToForm {
+    /** Semicolon-separated recipient list; `''` when the input is empty. */
+    recipients: string;
+    /** Subject of the message; `''` when the input is empty. */
+    subject: string;
+    /** Body of the message; `''` when the input is empty. */
+    text: string;
+}
 interface SendToDialogData {
     count: number;
     canPopulate?: boolean;
@@ -294,11 +309,24 @@ declare class SendToDialogComponent implements ISendToDialog {
     protected readonly dialogData: _angular_core.WritableSignal<SendToDialogData>;
     /** Model backing the signal form. */
     private readonly model;
+    /**
+     * Builds the form model from the dialog data, which may pre-fill subject and body.
+     * @returns A fresh form model.
+     */
+    private toForm;
+    /**
+     * Builds the dialog result from the current form model.
+     *
+     * Ad-hoc because the result also carries the caller's `options`, which the dialog
+     * only passes through and are therefore not part of the form model.
+     * @returns The message to emit through `done` or `populate`.
+     */
+    private toPayload;
     /**
      * Signal form for the send-to fields: recipients (a required, valid,
      * semicolon-separated email list), subject and text are all required.
      */
-    protected readonly form: _angular_forms_signals.FieldTree<SendToDialogResult, string | number, "writable">;
+    protected readonly form: _angular_forms_signals.FieldTree<SendToForm, string | number, "writable">;
     /**
      * Confirm the form and emit the result.
      */