@forgeroute/ui 0.4.39 → 0.4.41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgeroute/ui",
-  "version": "0.4.39",
+  "version": "0.4.41",
   "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<"" | "email" | "text">;
+  readonly channel: import("@angular/core").InputSignal<"" | "text" | "email">;
   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<"email" | "text">;
+  readonly channel: import("@angular/core").InputSignal<"text" | "email">;
   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<"idle" | "loading" | "ready" | "error">;
+  readonly envelopeStatus: import("@angular/core").WritableSignal<"error" | "loading" | "ready" | "idle">;
   private envelopeSub;
   private readonly roleSubs;
   /** The sender opened the collapsed "Signing options" line. */
@@ -1813,7 +1813,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<"email" | "text">;
+  readonly channel: import("@angular/core").WritableSignal<"text" | "email">;
   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

@@ -1,5 +1,6 @@
 import * as i0 from "@angular/core";
-import { InjectionToken, Provider } from "@angular/core";
+import { DestroyRef, InjectionToken, Provider, WritableSignal } from "@angular/core";
+import { Observable } from "rxjs";
 /**
  * The small part of Stripe.js the library calls, written as plain structural types so the library has NO compile-time or run-time
  * dependency on `@stripe/stripe-js` outside of the lazy loader (`stripe-loader.ts`). The real `Stripe` object satisfies these; so does a hand-written fake.
@@ -1141,4 +1142,247 @@ export declare class MicrodepositVerifyComponent {
     "verifyFailed": "verifyFailed";
   }, never, never, true, never>;
 }
-export type { HandleReturnOptions, MicrodepositStartedBy, MicrodepositStepsContext, MicrodepositType, MicrodepositVerifyData, MicrodepositVerifyEvent, ProvideStripePaymentOptions, StripeA11yMessages, StripeAppearance, StripeBillingDetails, StripeConfirmResult, StripeConfirmedEvent, StripeConnection, StripeCreateIntentFn, StripeDeferredIntent, StripeElementChange, StripeElementsLike, StripeErrorDisplay, StripeErrorLike, StripeErrorMessageOptions, StripeFailure, StripeFailureStage, StripeIntentKind, StripeIntentLike, StripeLike, StripeLikeWithBankSetup, StripeLoadOptions, StripeLoaderFn, StripeMicrodepositNextAction, StripeMicrodepositResult, StripeOutcome, StripePaymentDefaults, StripePaymentElementLike, StripeReadyEvent, StripeReturnParams, StripeReturnResult, StripeVerification };
+/** What the account-status call answers (the shape of cremo's `GET /organizations/connect/status`). `isComplete` = Stripe accepts charges and payouts. */
+interface StripeConnectStatus {
+  isComplete: boolean;
+  detailsSubmitted?: boolean;
+  /** The address of Stripe's onboarding page for an unfinished account. */
+  onboardingUrl?: string;
+}
+/** What the create-account call answers (cremo's `POST /organizations/connect/create`): the new (or resumed) account and the address of Stripe's onboarding page. */
+interface StripeConnectAccount {
+  accountId: string;
+  onboardingUrl: string;
+}
+/**
+ * What happened after the user pressed a button or the page asked for the state. The flow never shows toasts itself (each app has its own): the host words
+ * each outcome, and decides what follows a finished account (for example switching payment collection on).
+ *
+ *  - `complete`: Stripe accepts the account. `source: 'check'` = after "Check Status"; `'resume'` = "Complete Setup" found it already complete; `'return'` =
+ *    the state was read again when the user came back to this tab (`refreshOnReturn`).
+ *  - `verifying`: the details were submitted and Stripe is reviewing them.
+ *  - `incomplete`: "Check Status" found an unfinished onboarding (`onboardingUrl` present).
+ *  - `link-unavailable`: the answer had no https Stripe address; nothing was opened.
+ *  - `failed`: a call failed (`action` says which); `error` is what it threw.
+ */
+type StripeConnectOutcome = {
+  kind: 'complete';
+  source: 'check' | 'resume' | 'return';
+} | {
+  kind: 'verifying';
+  source: 'check' | 'resume' | 'return';
+} | {
+  kind: 'incomplete';
+} | {
+  kind: 'link-unavailable';
+} | {
+  kind: 'failed';
+  action: 'start' | 'check' | 'resume';
+  error: unknown;
+};
+/** The state the flow reads and writes: signals owned by the host (or by the card's two-way models). */
+interface StripeConnectState {
+  accountId: WritableSignal<string | null>;
+  complete: WritableSignal<boolean>;
+  detailsSubmitted: WritableSignal<boolean>;
+  loading: WritableSignal<boolean>;
+}
+interface StripeConnectFlowOptions {
+  /** Read at call time, so a host can swap the call. Null = no call yet (`start()` does nothing). */
+  createAccount: () => (() => Observable<StripeConnectAccount>) | null;
+  getStatus: () => (() => Observable<StripeConnectStatus>) | null;
+  state: StripeConnectState;
+  /** Where outcomes go. */
+  emit: (outcome: StripeConnectOutcome) => void;
+  /** The buttons and methods do nothing while this says true (a read-only user). */
+  disabled?: () => boolean;
+  /** How THIS tab is sent to Stripe when the browser refused the new tab (default `window.location.href = url`). */
+  navigate?: (url: string) => void;
+  destroyRef: DestroyRef;
+}
+/** Only an https address on stripe.com or a real subdomain (never `evilstripe.com` / `connect.stripe.com.evil.com`, `http:`, `javascript:`). */
+export declare function isStripeUrl(url: string | undefined): url is string;
+/**
+ * The Stripe Connect flow of cremo Settings > Payment & Billing, as a plain class: create the account, "Check Status", "Complete Setup", and the "back from Stripe" read.
+ * `ui-stripe-connect` runs it behind its card; a host that has to start the flow from code before any view exists (Settings: the first change-detection pass with
+ * `?connect=return`) creates its own instance over the same state signals. Stripe's page always opens in a NEW tab opened inside the click (a tab opened after the
+ * request is blocked by popup blockers); only an https Stripe address is opened; a failed call closes the empty tab.
+ */
+export declare class StripeConnectFlow {
+  private readonly o;
+  /** A Stripe tab was opened: the card reads the state again when the user comes back (`refreshOnReturn`). */
+  tabOpened: boolean;
+  constructor(o: StripeConnectFlowOptions);
+  private get blocked();
+  /** Creates (or resumes) the account and opens Stripe's onboarding page in a new tab. */
+  start(): void;
+  /** "Check Status": reads the state; a finished or submitted account updates the card, an unfinished one is reported. */
+  check(): void;
+  /** "Complete Setup": reads the state and opens the onboarding address of an unfinished account in a new tab (a finished or submitted one just updates the card). */
+  resume(): void;
+  /** The state read when the user came back to this tab: silent unless something finished or was submitted. */
+  readStatusOnReturn(): void;
+  private openStripe;
+  /** The empty tab, opened inside the click and cut from this page (`opener`); null when the browser refused. */
+  openBlankTab(): Window | null;
+  /** The browser refused the new tab: Stripe opens in this one. */
+  private navigateCurrentTab;
+  private closeTab;
+}
+/**
+ * The default wording of an outcome (the texts cremo Settings has always used), for apps that just want a toast: `{ variant, message }`, or null when
+ * nothing should be said. `completeText` replaces the sentence of a finished account when the host has more to say about what follows.
+ */
+export declare function stripeConnectNotice(outcome: StripeConnectOutcome): {
+  variant: 'success' | 'info' | 'error';
+  message: string;
+} | null;
+/**
+ * "Stripe Connect Account": the card where a business connects the Stripe account it collects payments into (cremo Settings > Payment & Billing, built here
+ * once so every app and the setup wizard show and run the SAME flow). The host owns the data (its two calls and the three state values); the component owns
+ * the screen and the flow:
+ *
+ *  - no account yet (`accountId` empty): nothing is shown (the host has its own entry point and calls `start()`), or with `showWhenNoAccount` a card with
+ *    "Set Up Payment Account";;
+ *  - account, not complete, nothing submitted: warning "Account setup incomplete" with "Complete Setup" (asks the status for the onboarding address and opens it);
+ *  - details submitted, not complete: info "Stripe is verifying your account" with "Check Status";
+ *  - complete: success "Account setup complete" with the account id and "View Stripe Dashboard".
+ *
+ * Stripe's onboarding page always opens in a NEW tab: the empty tab is opened inside the click (a tab opened after the request is blocked by popup
+ * blockers) and receives the address when it arrives; with the tab refused the address opens in the current tab. Only an https Stripe address is ever opened,
+ * never one an answer made up (`javascript:`, `data:`). A failed call closes the empty tab.
+ *
+ *   <ui-stripe-connect [(accountId)]="accountId" [(complete)]="complete" [(detailsSubmitted)]="submitted"
+ *     [createAccount]="createAccount" [getStatus]="getStatus" [showWhenNoAccount]="true" (outcome)="onOutcome($event)" />
+ *
+ * where `createAccount = () => http.post<StripeConnectAccount>('/connect/create', {})` and `getStatus = () => http.get<StripeConnectStatus>('/connect/status')`.
+ */
+export declare class StripeConnectComponent {
+  private readonly destroyRef;
+  /** The call that creates the organization's Stripe account (or resumes it) and answers its id and the onboarding address. Needed for `start()`. */
+  readonly createAccount: import("@angular/core").InputSignal<(() => Observable<StripeConnectAccount>) | null>;
+  /** The call that reads the account's state. Needed for `check()`, `resume()` and `refreshOnReturn`. */
+  readonly getStatus: import("@angular/core").InputSignal<(() => Observable<StripeConnectStatus>) | null>;
+  /** The Stripe account's id (null / empty = no account yet). Two-way: the component sets it when `start()` created the account. */
+  readonly accountId: import("@angular/core").ModelSignal<string | null>;
+  /** Stripe accepts the account (charges and payouts on). Two-way: set by `check()` / `resume()`. */
+  readonly complete: import("@angular/core").ModelSignal<boolean>;
+  /** The details were submitted and Stripe is reviewing them. Two-way: set by `check()` / `resume()`. */
+  readonly detailsSubmitted: import("@angular/core").ModelSignal<boolean>;
+  readonly title: import("@angular/core").InputSignal<string>;
+  /** Shows the card (with "Set Up Payment Account") while there is no account yet. Default false: hosts with their own entry point show nothing and call `start()`. */
+  readonly showWhenNoAccount: import("@angular/core").InputSignal<boolean>;
+  readonly startTitle: import("@angular/core").InputSignal<string>;
+  readonly startText: import("@angular/core").InputSignal<string>;
+  readonly startLabel: import("@angular/core").InputSignal<string>;
+  /** The buttons cannot be pressed (a read-only user). */
+  readonly disabled: import("@angular/core").InputSignal<boolean>;
+  /** After a Stripe tab was opened, the state is read again when this tab becomes visible again (the user came back): `(outcome)` then reports `complete` / `verifying` with source `return`. */
+  readonly refreshOnReturn: import("@angular/core").InputSignal<boolean>;
+  /** The page "View Stripe Dashboard" opens. */
+  readonly dashboardUrl: import("@angular/core").InputSignal<string>;
+  /** What happened (see {@link StripeConnectOutcome}); the host words it. */
+  readonly outcome: import("@angular/core").OutputEmitterRef<StripeConnectOutcome>;
+  /** A request is running: the buttons show "Loading..." / "Checking..." and cannot be pressed again. Two-way, so a host that shows the state elsewhere can read it. */
+  readonly loading: import("@angular/core").ModelSignal<boolean>;
+  /** How the current tab is sent to Stripe when the browser refused the new tab (default: `window.location.href = url`); a host can route it through its own method. */
+  readonly navigateTab: import("@angular/core").InputSignal<((url: string) => void) | null>;
+  protected readonly visible: import("@angular/core").Signal<boolean>;
+  private readonly flow;
+  constructor();
+  /** Creates (or resumes) the account and opens Stripe's onboarding page in a new tab. */
+  start(): void;
+  /** "Check Status": reads the state; a finished or submitted account updates the card, an unfinished one is reported. */
+  check(): void;
+  /** "Complete Setup": reads the state and opens the onboarding address of an unfinished account in a new tab. */
+  resume(): void;
+  /** Opens the Stripe dashboard in a new tab. */
+  openDashboard(): void;
+  /** The browser refused the new tab: Stripe opens in this one (through the host's `navigateTab` when it gave one). */
+  protected navigateCurrentTab(url: string): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StripeConnectComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StripeConnectComponent, "ui-stripe-connect", never, {
+    "createAccount": {
+      "alias": "createAccount";
+      "required": false;
+      "isSignal": true;
+    };
+    "getStatus": {
+      "alias": "getStatus";
+      "required": false;
+      "isSignal": true;
+    };
+    "accountId": {
+      "alias": "accountId";
+      "required": false;
+      "isSignal": true;
+    };
+    "complete": {
+      "alias": "complete";
+      "required": false;
+      "isSignal": true;
+    };
+    "detailsSubmitted": {
+      "alias": "detailsSubmitted";
+      "required": false;
+      "isSignal": true;
+    };
+    "title": {
+      "alias": "title";
+      "required": false;
+      "isSignal": true;
+    };
+    "showWhenNoAccount": {
+      "alias": "showWhenNoAccount";
+      "required": false;
+      "isSignal": true;
+    };
+    "startTitle": {
+      "alias": "startTitle";
+      "required": false;
+      "isSignal": true;
+    };
+    "startText": {
+      "alias": "startText";
+      "required": false;
+      "isSignal": true;
+    };
+    "startLabel": {
+      "alias": "startLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "refreshOnReturn": {
+      "alias": "refreshOnReturn";
+      "required": false;
+      "isSignal": true;
+    };
+    "dashboardUrl": {
+      "alias": "dashboardUrl";
+      "required": false;
+      "isSignal": true;
+    };
+    "loading": {
+      "alias": "loading";
+      "required": false;
+      "isSignal": true;
+    };
+    "navigateTab": {
+      "alias": "navigateTab";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "accountId": "accountIdChange";
+    "complete": "completeChange";
+    "detailsSubmitted": "detailsSubmittedChange";
+    "outcome": "outcome";
+    "loading": "loadingChange";
+  }, never, never, true, never>;
+}
+export type { HandleReturnOptions, MicrodepositStartedBy, MicrodepositStepsContext, MicrodepositType, MicrodepositVerifyData, MicrodepositVerifyEvent, ProvideStripePaymentOptions, StripeA11yMessages, StripeAppearance, StripeBillingDetails, StripeConfirmResult, StripeConfirmedEvent, StripeConnectAccount, StripeConnectFlowOptions, StripeConnectOutcome, StripeConnectState, StripeConnectStatus, StripeConnection, StripeCreateIntentFn, StripeDeferredIntent, StripeElementChange, StripeElementsLike, StripeErrorDisplay, StripeErrorLike, StripeErrorMessageOptions, StripeFailure, StripeFailureStage, StripeIntentKind, StripeIntentLike, StripeLike, StripeLikeWithBankSetup, StripeLoadOptions, StripeLoaderFn, StripeMicrodepositNextAction, StripeMicrodepositResult, StripeOutcome, StripePaymentDefaults, StripePaymentElementLike, StripeReadyEvent, StripeReturnParams, StripeReturnResult, StripeVerification };