@arsedizioni/ars-utils 22.5.36 → 22.5.38

package/types/arsedizioni-ars-utils-ui.controls.d.ts

@@ -421,5 +421,38 @@ declare class CalendarEmptyHeader<D> {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<CalendarEmptyHeader<any>, "ng-component", never, {}, {}, never, never, true, never>;
 }
 
-export { ButtonSelectorComponent, ButtonToggleComponent, CalendarEmptyHeader, ChipsSelectorComponent, TreePickerComponent };
+/**
+ * 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: _angular_core.ɵɵFactoryDeclaration<MatDatepickerParseErrorFixDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MatDatepickerParseErrorFixDirective, "input[matDatepicker], input[matStartDate], input[matEndDate]", never, {}, {}, never, never, true, never>;
+}
+
+export { ButtonSelectorComponent, ButtonToggleComponent, CalendarEmptyHeader, ChipsSelectorComponent, MatDatepickerParseErrorFixDirective, TreePickerComponent };
 export type { ButtonToggleInfo };

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.
      */