@fanfare-io/fanfare-sdk-solid 0.14.0 → 0.16.0

package/README.md

@@ -42,6 +42,7 @@ Solid applications can use `FanfareProvider`, `ExperienceWidget`, and `useExperi
 
 ## Documentation
 
+- [Core SDK page observation](https://www.npmjs.com/package/@fanfare-io/fanfare-sdk-core): use `useExperienceJourney` for Solid state and `useSdkEvent` for typed SDK events. For surrounding CSS/non-framework scripts, install core's `createDomBridge` on a stable mounted target and dispose it before destroying the journey or SDK; Solid has no `useFanfareDomBridge` hook.
 - [Web components guide](https://docs.fanfare.io/sdk/components/web-components)
 - [Theming](https://docs.fanfare.io/sdk/components/theming) · [Slots](https://docs.fanfare.io/sdk/components/slots)
 - [SDK overview](https://docs.fanfare.io/sdk/overview)

package/dist/components/auth/auth-form.d.ts

@@ -4,7 +4,7 @@ import { AuthInputMode } from './auth-input';
 export interface AuthFormProps {
     onSubmit?: (credential: string, type: AuthInputMode) => Promise<void>;
     onVerify?: (otp: string) => Promise<void>;
-    onSkip?: () => void;
+    onSkip?: () => void | Promise<void>;
     onSuccess?: () => void;
     /** Badge color/intent in the panel heading. */
     variant?: PanelHeadingVariant;
@@ -17,6 +17,7 @@ export interface AuthFormProps {
     submitLabel?: string;
     verifyLabel?: string;
     allowSkip?: boolean;
+    skipLabel?: string;
     showBranding?: boolean;
     /** Initial step when mounting. Useful for SSR-resume or storybook lanes that need the verify step. */
     defaultStep?: "credential" | "verify";

package/dist/components/compositions/granted-panel.d.ts

@@ -4,6 +4,12 @@ export interface GrantedPanelProps {
     fallbackMessage: JSX.Element;
     ctaLabel?: JSX.Element;
     expiresAt?: Date;
+    /**
+     * A fact the grant settles at — a winning bid, a clearing price — rendered under the countdown
+     * and beside the fallback message. Omitted when the amount is not known: a figure beside a
+     * payment countdown states what the consumer owes, so a synthesised one is worse than none.
+     */
+    detail?: JSX.Element;
     onCtaClick?: () => void;
     class?: string;
     className?: string;

package/dist/components/compositions/journey-gate.d.ts

@@ -5,11 +5,12 @@ export interface JourneyGateProps {
     stage: JourneyGateStage;
     onAuthSubmit?: (credential: string, type: AuthInputMode) => Promise<void>;
     onAuthVerify?: (otp: string) => Promise<void>;
-    onAuthSkip?: () => void;
+    onAuthSkip?: () => void | Promise<void>;
     onAuthSuccess?: () => void;
     onAccessCodeSubmit?: (code: string) => Promise<void>;
     onAccessCodeSkip?: () => void;
     allowAuthSkip?: boolean;
+    authSkipLabel?: string;
     allowAccessCodeSkip?: boolean;
     authTitle?: string;
     authDescription?: string;

package/dist/components/internal/appointment-module.d.ts

@@ -10,7 +10,7 @@ export interface AppointmentModuleProps {
     timezone?: string;
     defaultLocationId?: string;
     onBook: (slotId: string, locationId?: string) => Promise<void>;
-    onCancel: (reason?: string) => Promise<void>;
+    onCancel: () => Promise<void>;
     onReschedule: (newSlotId: string, newLocationId?: string) => Promise<void>;
     isBooking: boolean;
     isCancelling: boolean;

package/dist/components/internal/auction-ledger.d.ts

@@ -0,0 +1,51 @@
+import { Accessor, JSX } from 'solid-js';
+export type LedgerTone = "default" | "muted" | "live" | "danger" | "success";
+export interface LedgerRowProps {
+    /** Decorative leading glyph; the label carries the row's meaning for assistive technology. */
+    marker?: string;
+    label: JSX.Element;
+    value: JSX.Element;
+    tone?: LedgerTone;
+    /** Renders the value struck through — a bid that has been beaten, a price already passed. */
+    struck?: boolean;
+    class?: string;
+}
+export declare function LedgerRow(props: LedgerRowProps): JSX.Element;
+export declare namespace LedgerRow {
+    var displayName: string;
+}
+/** A row whose value has not arrived yet: the label stands, the figure is a placeholder. */
+export declare function LedgerSkeletonRow(props: {
+    label: JSX.Element;
+}): JSX.Element;
+export declare namespace LedgerSkeletonRow {
+    var displayName: string;
+}
+export declare function Ledger(props: {
+    children: JSX.Element;
+    class?: string;
+}): JSX.Element;
+export declare namespace Ledger {
+    var displayName: string;
+}
+/**
+ * Discrete unit pips for a Dutch remaining count, at the wide adaptation only.
+ *
+ * The pips are decorative; the grid states the count once in its own label so a screen reader
+ * hears "7 of 20 units remaining" rather than twenty unlabelled cells.
+ */
+export declare function UnitPips(props: {
+    remaining: number;
+    total: number;
+    label: string;
+}): JSX.Element;
+export declare namespace UnitPips {
+    var displayName: string;
+}
+/**
+ * Whether the panel's own rendered width has reached `threshold`.
+ *
+ * The adaptation is the panel's, not the viewport's: the widget is embedded at whatever width its
+ * host gives it, and a viewport query would split the columns on a page that never made room.
+ */
+export declare function useIsWide(threshold: number): [(element: HTMLDivElement) => void, Accessor<boolean>];

package/dist/components/internal/auction-module.d.ts

@@ -1,24 +1,31 @@
+import { AuctionBidInput, AuctionConsumerStatus } from '@fanfare-io/fanfare-sdk-core/auctions';
 import { AuctionDisplayState } from '@fanfare-io/fanfare-sdk-core/internals';
 import { ReadableAtom } from 'nanostores';
 import { OutcomeAction } from '../compositions/outcome-panel';
 import { OutcomeReason } from '../module';
 export interface AuctionModuleProps {
     display$?: ReadableAtom<AuctionDisplayState>;
-    fallbackState?: AuctionDisplayState;
     sequencePhase: "enterable" | "participating" | "settling" | "granted" | "ended";
-    canEnter: boolean;
-    canLeave: boolean;
-    onEnter: () => Promise<void>;
-    onLeave: () => Promise<void>;
-    onBid?: (amount: string) => Promise<void>;
-    isEntering: boolean;
-    isLeaving: boolean;
+    /** Place a bid. English sends `{ amount }`; Dutch clinches at the shown price and sends `{}`. */
+    onBid?: (input: AuctionBidInput) => Promise<void>;
+    /** This consumer's own bid, which the live display state does not carry. */
+    yourBid?: string;
+    /** This consumer's own standing, which the live display state carries only as a loose string. */
+    yourStatus?: AuctionConsumerStatus;
     countdownTo?: Date;
-    defaultBidAmount?: string;
+    /** Currency code for money display; the live display state's own code wins when present. */
     currencyCode?: string;
+    /** Locale for currency formatting */
     locale?: string;
     grant?: string;
     expiresAt?: number | Date;
+    /** The amount this win settles at, shown beside the payment countdown. */
+    wonAmount?: string;
+    /**
+     * Which mechanism settled. The granted frame has no display atom to read the pricing model
+     * from, and a Dutch consumer bought at a posted price rather than winning a contest.
+     */
+    auctionType?: "english" | "dutch";
     checkoutUrl?: string;
     onCheckoutClick?: () => void;
     outcomeReason?: OutcomeReason;

package/dist/components/internal/auction-pricing.d.ts

@@ -0,0 +1,68 @@
+import { AuctionDisplayState } from '@fanfare-io/fanfare-sdk-core/internals';
+/** The live price model, reached through the display state rather than a separate core export. */
+export type AuctionPricing = NonNullable<AuctionDisplayState["pricing"]>;
+export type EnglishPricing = Extract<AuctionPricing, {
+    model: "english";
+}>;
+export type DutchPricing = Extract<AuctionPricing, {
+    model: "dutch";
+}>;
+/** True when a string is a money value the panel may compute with. */
+export declare function isWireMoney(value: string | undefined): value is string;
+/**
+ * Reads a typed amount as a wire money string, or `null` when it is not one.
+ *
+ * A consumer types the separators their keyboard and locale give them — `245,00` across most of
+ * Europe, `1,234.50` or `1 234,50` with grouping — and a bid that is refused as below the minimum
+ * because of a comma is a bid the auction lost for no reason. Grouping is dropped and the decimal
+ * separator is read from position. Exponent notation is refused rather than expanded: `1e5` is not
+ * an amount anyone means to bid.
+ *
+ * `digits` is the currency's fraction digits, which decide what a lone comma before exactly three
+ * digits means: grouping in a two-digit currency, the decimal in a three-digit one, where reading
+ * it as grouping would multiply the bid a thousandfold.
+ */
+export declare function normalizeAmountInput(raw: string, digits?: number): string | null;
+/** Orders two wire money strings exactly at the eight-digit wire scale. */
+export declare function compareMoney(left: string, right: string, _digits: number): number;
+/**
+ * Moves `base` by `steps` whole increments, never below `floor`.
+ *
+ * The stepper and the quick-pick chips are the same operation at different step counts, so they
+ * cannot disagree about what one increment is worth.
+ */
+export declare function stepAmount(base: string, increment: string, steps: number, digits: number, floor?: string): string;
+/**
+ * True when `amount` is more than ten increments above the minimum next bid. The comparison stays
+ * in minor units so a threshold past the wire money width cannot fail validation.
+ */
+export declare function exceedsObligationThreshold(amount: string, minNextBid: string, increment: string): boolean;
+/** One rung of the Dutch descent, in the order it is rendered. */
+export interface DutchLadder {
+    /** The price the ladder started from, when it is not also the live price. */
+    start?: string;
+    /** Prices the ladder has already passed, newest last. */
+    passed: string[];
+    /** The price a clinch would pay right now. */
+    current: string;
+    /** The price the next drop lands on, when another drop is still coming. */
+    next?: string;
+    /** The price the ladder never falls below, when one is configured. */
+    floor?: string;
+}
+/**
+ * Derives the descent from the ladder configuration and the live price.
+ *
+ * No drop history crosses the wire, so the passed rungs are recomputed as `startPrice − k × drop`
+ * down to the live price. Returns `null` when the configuration needed to draw the ladder is
+ * absent: the rows that survive are the ones the server actually stated.
+ */
+export declare function buildDutchLadder(pricing: DutchPricing, digits: number): DutchLadder | null;
+/**
+ * Whether a Dutch clinch may be offered at all.
+ *
+ * Three independent gates, each of which alone makes the buy button a lie: Dutch never enters
+ * `participating` or `settling`, so the phase must still be `enterable`; a sold-out auction has no
+ * unit to sell; and `ended` closes the mechanism whatever the price says.
+ */
+export declare function canClinch(pricing: DutchPricing, sequencePhase: string): boolean;

package/dist/components/module/outcome-reason.d.ts

@@ -21,7 +21,6 @@
  *   completed / already_completed -> completed (a success terminal, not a loss)
  *   won                    ->  won
  *   cancelled              ->  cancelled
- *   no_show                ->  no_show
  *   left                   ->  left (voluntary exit: leave/withdraw)
  *   closed / unknown / other -> ended
  *
@@ -32,7 +31,7 @@
  * Static story lanes pass UI values directly (e.g. `"outbid"`); those
  * pass through unchanged.
  */
-export type OutcomeReason = "expired" | "not_selected" | "sold_out" | "outbid" | "floor_unsold" | "reserve_not_met" | "completed" | "won" | "cancelled" | "no_show" | "left" | "ended";
+export type OutcomeReason = "expired" | "not_selected" | "sold_out" | "outbid" | "floor_unsold" | "reserve_not_met" | "completed" | "won" | "cancelled" | "left" | "ended";
 export declare function normalizeOutcomeReason(reason: string | undefined): OutcomeReason;
 export declare function normalizeSequenceOutcomeReason(outcome: {
     type: string;