@forgeroute/ui 0.4.69 → 0.4.70

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgeroute/ui",
-  "version": "0.4.69",
+  "version": "0.4.70",
   "peerDependencies": {
     "@angular/common": ">=22.0.0",
     "@angular/core": ">=22.0.0",

package/types/forgeroute-ui-messaging.d.ts

@@ -115,7 +115,7 @@ export declare class TemplatePickerComponent {
   private readonly host;
   private readonly search$;
   /** Filter results to a specific channel: 'email', 'text', or omit for all. */
-  readonly channel: import("@angular/core").InputSignal<"" | "text" | "email">;
+  readonly channel: import("@angular/core").InputSignal<"" | "email" | "text">;
   readonly selectedId: import("@angular/core").InputSignal<string | null>;
   readonly label: import("@angular/core").InputSignal<string>;
   /** Shows the red required asterisk (same as the library inputs) — e.g. when a template must be picked to send. */
@@ -543,7 +543,7 @@ export declare class DocumentSendOptionsComponent implements UiFieldValidity {
   /** API root from FORGEROUTE_CONFIG (e.g. a cross-origin prod API); falls back to same-origin `/api`. */
   private readonly apiBase;
   /** `email` → purpose select + attachment allowed; `text` → link only (purpose fixed to e-signature). */
-  readonly channel: import("@angular/core").InputSignal<"text" | "email">;
+  readonly channel: import("@angular/core").InputSignal<"email" | "text">;
   readonly label: import("@angular/core").InputSignal<string>;
   /** When true, at least one document must be chosen. The message forms leave it false: documents are optional there. */
   readonly required: import("@angular/core").InputSignal<boolean>;
@@ -608,7 +608,7 @@ export declare class DocumentSendOptionsComponent implements UiFieldValidity {
   /** Roles of documents whose row had no `signerRoles` and that the host resolves (`signers().resolveRoles`). */
   readonly roleStates: import("@angular/core").WritableSignal<Record<string, RoleState>>;
   /** The envelope's documents: `loading` / `error` while the panel reads them (`loadDocuments`), `ready` once known. */
-  readonly envelopeStatus: import("@angular/core").WritableSignal<"error" | "loading" | "ready" | "idle">;
+  readonly envelopeStatus: import("@angular/core").WritableSignal<"idle" | "loading" | "ready" | "error">;
   private envelopeSub;
   private readonly roleSubs;
   /** The sender opened the collapsed "Signing options" line. */
@@ -1997,7 +1997,7 @@ export declare class SendMessagePanelComponent {
   readonly activeContact: import("@angular/core").WritableSignal<MessageContact | null>;
   /** What the sender should know about the picked contact before sending (why a channel is missing, what to add). */
   readonly contactNotices: import("@angular/core").Signal<string[]>;
-  readonly channel: import("@angular/core").WritableSignal<"text" | "email">;
+  readonly channel: import("@angular/core").WritableSignal<"email" | "text">;
   readonly valid: import("@angular/core").WritableSignal<boolean>;
   /** Bumped on every fresh open / new contact — re-creates the email and text forms so no draft carries over. */
   readonly formEpoch: import("@angular/core").WritableSignal<number>;

package/types/forgeroute-ui-stripe.d.ts

@@ -1300,7 +1300,7 @@ export declare class StripeConnectComponent {
   readonly navigateTab: import("@angular/core").InputSignal<((url: string) => void) | null>;
   protected readonly visible: import("@angular/core").Signal<boolean>;
   /** Which screen the card shows. */
-  protected readonly state: import("@angular/core").Signal<"complete" | "verifying" | "incomplete" | "none">;
+  protected readonly state: import("@angular/core").Signal<"none" | "complete" | "verifying" | "incomplete">;
   /** What the persistent status region says: the current state, plus "Loading." while a request runs. Empty while nothing is shown. */
   protected readonly liveText: import("@angular/core").Signal<string>;
   /** The user pressed a button that started a request: when the screen then changes, focus moves to the new screen (the pressed button is gone). */

package/types/forgeroute-ui.d.ts

@@ -1,7 +1,7 @@
 import * as i0 from "@angular/core";
 import { EnvironmentProviders, InjectionToken, OnDestroy, OnInit, Signal, TemplateRef, WritableSignal } from "@angular/core";
 import { UrlTree } from "@angular/router";
-import { Observable } from "rxjs";
+import { Observable, Subject } from "rxjs";
 import { AbstractControl, ControlValueAccessor, FormControl, ValidationErrors, Validator, ValidatorFn } from "@angular/forms";
 import { HttpInterceptorFn } from "@angular/common/http";
 import { SafeHtml } from "@angular/platform-browser";
@@ -2387,6 +2387,54 @@ export declare class ModalComponent implements OnInit, OnDestroy {
   }, never, ["[modal-header-end]", "*", "[modal-footer-left]", "[modal-footer-center]", "[modal-footer-right]"], true, never>;
 }
 export type ToastType = 'success' | 'error' | 'info';
+/** A button on a toast (e.g. "View Contact", "Call Back"). */
+export interface ToastAction {
+  /** Identifies the button in `onAction` and in the `(action)` output; also the test id suffix (`toast-action-<id>`). */
+  id: string;
+  label: string;
+  /** Look of the button. Default `secondary`. */
+  variant?: 'primary' | 'secondary' | 'danger';
+  disabled?: boolean;
+  /** Keep the toast open after this button is used. Default `false`: using a button closes the toast. */
+  keepOpen?: boolean;
+}
+/** What `(action)` / `ToastService.action$` emit when a toast button is used. */
+export interface ToastActionEvent {
+  /** The `id` of the button. */
+  id: string;
+  /** The `key` of the toast it belongs to, when the toast had one. */
+  key?: string;
+}
+/**
+ * Per-message options for `show()` / `success()` / `info()` / `error()` / `notify()`. Every field is optional; a call without any of them is a plain
+ * toast exactly as before.
+ */
+export interface ToastOptions {
+  /** Only `notify()` reads this (`show` / `success` / `info` / `error` fix their own type). Default `success`. */
+  type?: ToastType;
+  /** How long it stays, in ms. Default: 3000 (4000 for errors). */
+  duration?: number;
+  /** A bold first line above the message. */
+  title?: string;
+  /** Buttons under the message. */
+  actions?: readonly ToastAction[];
+  /** Show "Dismissing in Ns" and a shrinking bar for this toast. Default: the outlet's / app's `countdown` setting (off). */
+  countdown?: boolean;
+  /** When another toast is showing, wait for it to finish instead of replacing it. Default: the outlet's / app's `queue` setting (off). */
+  queue?: boolean;
+  /** Identifies the toast: while one with the same key is showing or waiting, another one with that key is not added again (e.g. one per call id). */
+  key?: string;
+  /** Called with the `id` of a button when it is used (before the toast closes). */
+  onAction?: (actionId: string) => void;
+}
+/** What is known about the toast on screen beyond its message and type; `null` for a plain toast. */
+export interface ToastDetails {
+  title?: string;
+  actions: readonly ToastAction[];
+  countdown: boolean;
+  key?: string;
+  onAction?: (actionId: string) => void;
+}
 export declare class ToastService implements OnDestroy {
   readonly message: import("@angular/core").WritableSignal<string | null>;
   readonly type: import("@angular/core").WritableSignal<ToastType>;
@@ -2402,18 +2450,42 @@ export declare class ToastService implements OnDestroy {
    * Set once per app with `provideForgerouteToast({ persistentLiveRegion: true })`, or per outlet with `<ui-toast [persistentLiveRegion]="true" />`.
    */
   readonly persistentLiveRegion: import("@angular/core").WritableSignal<boolean>;
+  /** The title, buttons, countdown flag, key and callback of the toast on screen; `null` for a plain toast or none. */
+  readonly details: import("@angular/core").WritableSignal<ToastDetails | null>;
+  /** How many toasts are waiting behind the one on screen (queue mode). */
+  readonly queuedCount: import("@angular/core").WritableSignal<number>;
+  /** Default for `ToastOptions.queue`: new toasts wait for the one on screen instead of replacing it. Set with `provideForgerouteToast({ queue: true })` or `<ui-toast [queue]="true" />`. */
+  readonly queueDefault: import("@angular/core").WritableSignal<boolean>;
+  /** Default for `ToastOptions.countdown`. Set with `provideForgerouteToast({ countdown: true })` or `<ui-toast [countdown]="true" />`. */
+  readonly countdownDefault: import("@angular/core").WritableSignal<boolean>;
+  /** Most toasts that may wait; further ones are dropped. Default 20. Set with `provideForgerouteToast({ maxQueued })` or `<ui-toast [maxQueued]="n" />`. */
+  readonly maxQueued: import("@angular/core").WritableSignal<number>;
+  /** Time left of the toast on screen, in ms; only kept up to date for a toast with a countdown. */
+  readonly remainingMs: import("@angular/core").WritableSignal<number>;
+  /** The full time the toast on screen was given, in ms (the denominator of the countdown bar). */
+  readonly totalMs: import("@angular/core").WritableSignal<number>;
+  /** Emits when a toast button is used. */
+  readonly action$: Subject<ToastActionEvent>;
   private _timer;
+  private _ticker;
+  private _advanceTimer;
   private _deadline;
   private _remaining;
   private _paused;
-  show(msg: string, duration?: number): void;
+  private _queue;
+  /** Green success toast. `durationOrOptions` is the time in ms (default 3000) or a {@link ToastOptions} object. */
+  show(msg: string, durationOrOptions?: number | ToastOptions): void;
   /** Green success toast, the explicit name for `show()` (same type, same 3000ms default, same behaviour). */
-  success(msg: string, duration?: number): void;
+  success(msg: string, durationOrOptions?: number | ToastOptions): void;
   /** Neutral (blue) toast for a result that is neither a success nor a failure, e.g. "No changes to save.". */
-  info(msg: string, duration?: number): void;
-  error(msg: string, duration?: number): void;
-  /** Removes the current toast now (close button / Escape). Safe when nothing is showing. */
+  info(msg: string, durationOrOptions?: number | ToastOptions): void;
+  error(msg: string, durationOrOptions?: number | ToastOptions): void;
+  /** A toast whose type comes from `options.type` (default `success`); the same as the named methods otherwise. */
+  notify(msg: string, options?: ToastOptions): void;
+  /** Removes the current toast now (close button / Escape); the next waiting one, if any, follows. Safe when nothing is showing. */
   dismiss(): void;
+  /** Uses the button `id` of the toast on screen: calls its `onAction`, emits `action$`, and closes the toast unless the button has `keepOpen`. No-op for an unknown or disabled button. */
+  runAction(id: string): void;
   /** Holds the countdown while the pointer or keyboard focus is on the toast (WCAG 2.2.1). No-op when nothing is counting down. */
   pause(): void;
   /** Continues after `pause()`; the toast gets at least 1000ms more so it can be read. No-op when not paused. */
@@ -2421,8 +2493,14 @@ export declare class ToastService implements OnDestroy {
   /** The root injector is destroyed (app teardown, TestBed reset): no timer may outlive it. */
   ngOnDestroy(): void;
   private _clearTimer;
+  private _clearTicker;
+  private _clearAdvance;
+  /** Starts the expiry timer (and the countdown ticker for a toast with a countdown). `fresh` = a new toast, not a resume after a pause. */
   private _start;
-  private _display;
+  /** The toast on screen is over (expired, dismissed or its button used): clear it and bring in the next waiting one after a short gap. */
+  private _finish;
+  private _enter;
+  private _present;
   static ɵfac: i0.ɵɵFactoryDeclaration<ToastService, never>;
   static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
@@ -2448,6 +2526,28 @@ export declare class ToastComponent {
    */
   readonly persistentLiveRegion: import("@angular/core").InputSignal<boolean | null>;
   protected readonly persistent: import("@angular/core").Signal<boolean>;
+  /**
+   * Outlet-wide defaults for the optional parts of a toast (a message's own options win). `null` (default) leaves the app / service setting alone
+   * (`provideForgerouteToast`, itself off); a value is applied while this is the live outlet.
+   *
+   * - `queue`: a toast that arrives while another is showing waits for it instead of replacing it.
+   * - `countdown`: show "Dismissing in Ns" and a shrinking bar on every toast.
+   * - `maxQueued`: how many may wait (default 20).
+   */
+  readonly queue: import("@angular/core").InputSignal<boolean | null>;
+  readonly countdown: import("@angular/core").InputSignal<boolean | null>;
+  readonly maxQueued: import("@angular/core").InputSignal<number | null>;
+  /** Wording of the countdown line; `{n}` is the seconds left. */
+  readonly countdownLabel: import("@angular/core").InputSignal<string>;
+  /** Wording of the chip that says how many toasts are waiting; `{n}` is the count. */
+  readonly queueLabel: import("@angular/core").InputSignal<string>;
+  /** A toast button was used (also after its own `onAction`). */
+  readonly action: import("@angular/core").OutputEmitterRef<ToastActionEvent>;
+  protected readonly isRich: import("@angular/core").Signal<boolean>;
+  protected readonly countdownPct: import("@angular/core").Signal<number>;
+  protected readonly countdownText: import("@angular/core").Signal<string>;
+  protected readonly queueText: import("@angular/core").Signal<string>;
+  protected onAction(id: string): void;
   /**
    * Message that was already on screen when this instance took over from a destroyed host. While it is
    * unchanged the toast renders without the entry animation and without live-region roles, so the
@@ -2478,7 +2578,34 @@ export declare class ToastComponent {
       "required": false;
       "isSignal": true;
     };
-  }, {}, never, never, true, never>;
+    "queue": {
+      "alias": "queue";
+      "required": false;
+      "isSignal": true;
+    };
+    "countdown": {
+      "alias": "countdown";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxQueued": {
+      "alias": "maxQueued";
+      "required": false;
+      "isSignal": true;
+    };
+    "countdownLabel": {
+      "alias": "countdownLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "queueLabel": {
+      "alias": "queueLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "action": "action";
+  }, never, never, true, never>;
 }
 export type ProgressBarVariant = 'blue' | 'green' | 'amber' | 'red' | 'slate';
 /**
@@ -7344,6 +7471,7 @@ export declare class NotesComponent {
  *   providers: [provideForgerouteToast()]
  *   providers: [provideForgerouteToast({ dismissible: true })]   // every toast also gets a close button (default: none)
  *   providers: [provideForgerouteToast({ persistentLiveRegion: true })]   // always-present live regions: reliable announcements in VoiceOver / Safari
+ *   providers: [provideForgerouteToast({ queue: true, countdown: true, maxQueued: 10 })]   // toasts wait for each other and show a countdown (defaults; a message's own options win)
  *
  * It is created first, so it is the registry's host and any other `<ui-toast>` (a table's own, a shell's) stays silent: each
  * message renders and is announced once. Nothing happens on the server. The outlet is destroyed with the app.
@@ -7351,6 +7479,9 @@ export declare class NotesComponent {
 export declare function provideForgerouteToast(options?: {
   dismissible?: boolean;
   persistentLiveRegion?: boolean;
+  queue?: boolean;
+  countdown?: boolean;
+  maxQueued?: number;
 }): EnvironmentProviders;
 /** Payload of `(reorder)`. Apply it with `reorderItems(items, order)` or take the ready-made `items`. */
 export interface ListReorderEvent<T = unknown> {