@12-apps/ui 6.77.2 → 6.78.0

package/dist/types/components/feedback/SequenceResolver/SequenceResolver.types.d.ts

@@ -0,0 +1,175 @@
+import type * as React from 'react';
+/**
+ * One entry of the queue a {@link SequenceResolverProps} walks through.
+ *
+ * Extend it with whatever the host's step needs (`item.payload`, an id, the
+ * row it came from): the component only reads `key` and `kindLabel`, and hands
+ * the WHOLE item back to `renderStep` and `onBack`.
+ */
+export interface SequenceItem {
+    /** Stable identity across re-renders and refetches — what the run tracks. */
+    key: string;
+    /** The kind word the header shows next to the position ("Purchase"). */
+    kindLabel: string;
+}
+/** Where the run stands, handed to the end screen, `onClose` and `labels.step`. */
+export interface SequenceSummary {
+    /** Steps answered with `resolve`. */
+    resolved: number;
+    /** Steps passed over with `skip`. */
+    skipped: number;
+    /** Every step of the run so far: answered + skipped + still ahead. */
+    total: number;
+    /**
+     * Problems the host reported as resolved TOGETHER with an answered step
+     * (`api.resolve(result, { alsoResolved })` — "apply to every sibling"),
+     * which never became steps. `resolved + alsoResolved` is what a close toast
+     * counts; the end screen's "N of M" counts steps.
+     */
+    alsoResolved: number;
+}
+/** What an answer can say besides its result. */
+export interface SequenceResolveOptions {
+    /** How many OTHER problems this answer resolved too (siblings that never became steps). */
+    alsoResolved?: number;
+}
+/** A button a step puts in the resolver's footer. */
+export interface SequenceAction {
+    label: string;
+    onClick: () => void;
+    /** Disabled on top of the resolver's own `busy`. */
+    disabled?: boolean;
+}
+/** What `renderStep` gets: the run's verbs and its state. */
+export interface SequenceStepApi<R> {
+    /**
+     * Answer this step and move to the next one. Pass the result itself, or the
+     * PROMISE of it (the host's server write): the step stays on screen and
+     * `busy` until it settles; a rejection keeps it and shows the rejection's
+     * message. The result is what `onBack` receives if the reader returns.
+     */
+    resolve: (result: R | PromiseLike<R>, options?: SequenceResolveOptions) => void;
+    /** Leave this step unanswered and move on. */
+    skip: () => void;
+    /** Return to the previous step (the header's back button does the same). */
+    back: () => void;
+    /** True while a `resolve` promise or an `onBack` is pending — disable the step's own answers. */
+    busy: boolean;
+    /**
+     * Spread on the step's TITLE — the item's name, first and large. It names
+     * the dialog (`aria-labelledby`) and takes focus on every advance.
+     */
+    titleProps: {
+        id: string;
+        tabIndex: -1;
+        ref: React.RefCallback<HTMLElement>;
+    };
+}
+/** What a step renders: its body and, at most, two footer actions plus one tertiary. */
+export interface SequenceStep {
+    /** The body: item name (spread `titleProps` on it), question, facts, inputs. */
+    content: React.ReactNode;
+    /** The step's verb ("Save limits"). Omit for a step answered from its body (a list of reasons). */
+    primary?: SequenceAction;
+    /**
+     * The secondary action. Omitted, it is SKIP with `labels.skip`; pass one to
+     * reword it ("Not bought yet") or to replace it (a split mode's "One reason
+     * only"); `false` removes it.
+     */
+    secondary?: SequenceAction | false;
+    /** One text button above the footer ("It was a stock count, not a loss"). */
+    tertiary?: SequenceAction;
+    /**
+     * How the footer lays its actions out on a pointer: `'end'` (default) —
+     * auto-width, right-aligned, over a hairline; `'split'` — two equal
+     * full-width columns, no hairline (a form step: limits, a purchase). On a
+     * phone the actions always share the row, with no hairline.
+     */
+    footer?: 'end' | 'split';
+}
+/** One kind on the intro screen. */
+export interface SequenceCategory {
+    label: string;
+    description?: string;
+    /** How many problems of this kind there are. A kind at zero should not be listed. */
+    count: number;
+    /** Resolve only this kind: set the queue to it and drop `intro`. */
+    onPick: () => void;
+}
+/** The screen before the run: the kinds with their counts, and "resolve them all". */
+export interface SequenceIntro {
+    title: string;
+    description?: string;
+    categories: SequenceCategory[];
+    startAllLabel: string;
+    /** Resolve every kind: set the queue to all of them and drop `intro`. */
+    onStartAll: () => void;
+}
+/** The end screen's words. */
+export interface SequenceDone {
+    title: string;
+    description?: string;
+    /** The one button there; it closes the resolver. */
+    confirmLabel: string;
+}
+/** The chrome's words. The package ships none: every one is the host's. */
+export interface SequenceResolverLabels {
+    /** The back button's visible word ("Back"); a chevron icon precedes it. */
+    back: string;
+    /** The back button's accessible name, when it says more ("Back to the previous problem"). Must contain `back`. */
+    backAccessible?: string;
+    /** The close button's accessible name. */
+    close: string;
+    /** The default secondary action: leave the step unanswered. */
+    skip: string;
+    /** The header label on a step: `"Problem 3 of 13 · Purchase"`. `position` is 1-based. */
+    step: (position: number, total: number, item: SequenceItem) => string;
+    /** The header label on the intro screen. */
+    introStep: string;
+    /** The header label on the end screen. */
+    doneStep: string;
+    /** The progress bar's accessible name. */
+    progress: string;
+    /** Shown when `onBack` / a `resolve` promise rejects with no message of its own. */
+    failed: string;
+}
+export interface SequenceResolverProps<I extends SequenceItem = SequenceItem, R = unknown> {
+    open: boolean;
+    /**
+     * The close button, Esc, and the end screen's button. Gets where the run
+     * stood, for the host's "N resolved · Undo" toast.
+     */
+    onClose: (summary: SequenceSummary) => void;
+    /**
+     * While given, the intro screen shows instead of the run. The host drops it
+     * (and sets `queue`) in the same update as a category's `onPick` / `onStartAll`.
+     */
+    intro?: SequenceIntro;
+    /**
+     * The problems to walk, in order. The host's live data: it may shrink while
+     * the run goes (an answer that resolves siblings too) or grow; the run keeps
+     * pointing at the next unresolved key and never runs past the end.
+     */
+    queue: readonly I[];
+    /** The body and actions of the current step. */
+    renderStep: (item: I, api: SequenceStepApi<R>) => SequenceStep;
+    /**
+     * Undo the previous answer before showing its step again — the host's server
+     * inverse. Called only when the step being returned to was RESOLVED (a skipped
+     * one has nothing to undo). A rejection keeps the current step and shows its message.
+     */
+    onBack?: (item: I, result: R) => Promise<void> | void;
+    /** Offer the back button at all (default `true`). It shows only once a previous step exists. */
+    canGoBack?: boolean;
+    /** The end screen's words, from the run's summary. */
+    done: SequenceDone | ((summary: SequenceSummary) => SequenceDone);
+    labels: SequenceResolverLabels;
+    /**
+     * Base test id (default `sequence-resolver`). Parts get `${id}-back`,
+     * `${id}-close`, `${id}-step-label`, `${id}-progress`, `${id}-category-${index}`,
+     * `${id}-start-all`, `${id}-primary`, `${id}-secondary`, `${id}-tertiary`,
+     * `${id}-error`, `${id}-done`, `${id}-done-confirm`.
+     */
+    dataTestId?: string;
+}
+//# sourceMappingURL=SequenceResolver.types.d.ts.map

package/dist/types/components/feedback/SequenceResolver/SequenceResolver.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SequenceResolver.types.d.ts","sourceRoot":"","sources":["../../../../../src/components/feedback/SequenceResolver/SequenceResolver.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAEpC;;;;;;GAMG;AACH,MAAM,WAAW,YAAY;IAC3B,6EAA6E;IAC7E,GAAG,EAAE,MAAM,CAAC;IACZ,wEAAwE;IACxE,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,mFAAmF;AACnF,MAAM,WAAW,eAAe;IAC9B,qCAAqC;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,qCAAqC;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,sEAAsE;IACtE,KAAK,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,iDAAiD;AACjD,MAAM,WAAW,sBAAsB;IACrC,2FAA2F;IAC3F,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,qDAAqD;AACrD,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,oDAAoD;IACpD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,6DAA6D;AAC7D,MAAM,WAAW,eAAe,CAAC,CAAC;IAChC;;;;;OAKG;IACH,OAAO,EAAE,CAAC,MAAM,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,sBAAsB,KAAK,IAAI,CAAC;IAChF,8CAA8C;IAC9C,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,4EAA4E;IAC5E,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,iGAAiG;IACjG,IAAI,EAAE,OAAO,CAAC;IACd;;;OAGG;IACH,UAAU,EAAE;QACV,EAAE,EAAE,MAAM,CAAC;QACX,QAAQ,EAAE,CAAC,CAAC,CAAC;QACb,GAAG,EAAE,KAAK,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;KACrC,CAAC;CACH;AAED,wFAAwF;AACxF,MAAM,WAAW,YAAY;IAC3B,gFAAgF;IAChF,OAAO,EAAE,KAAK,CAAC,SAAS,CAAC;IACzB,mGAAmG;IACnG,OAAO,CAAC,EAAE,cAAc,CAAC;IACzB;;;;OAIG;IACH,SAAS,CAAC,EAAE,cAAc,GAAG,KAAK,CAAC;IACnC,6EAA6E;IAC7E,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B;;;;;OAKG;IACH,MAAM,CAAC,EAAE,KAAK,GAAG,OAAO,CAAC;CAC1B;AAED,oCAAoC;AACpC,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,qFAAqF;IACrF,KAAK,EAAE,MAAM,CAAC;IACd,oEAAoE;IACpE,MAAM,EAAE,MAAM,IAAI,CAAC;CACpB;AAED,sFAAsF;AACtF,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,gBAAgB,EAAE,CAAC;IAC/B,aAAa,EAAE,MAAM,CAAC;IACtB,yEAAyE;IACzE,UAAU,EAAE,MAAM,IAAI,CAAC;CACxB;AAED,8BAA8B;AAC9B,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,oDAAoD;IACpD,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,2EAA2E;AAC3E,MAAM,WAAW,sBAAsB;IACrC,2EAA2E;IAC3E,IAAI,EAAE,MAAM,CAAC;IACb,kHAAkH;IAClH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,0CAA0C;IAC1C,KAAK,EAAE,MAAM,CAAC;IACd,+DAA+D;IAC/D,IAAI,EAAE,MAAM,CAAC;IACb,yFAAyF;IACzF,IAAI,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,KAAK,MAAM,CAAC;IACtE,4CAA4C;IAC5C,SAAS,EAAE,MAAM,CAAC;IAClB,0CAA0C;IAC1C,QAAQ,EAAE,MAAM,CAAC;IACjB,0CAA0C;IAC1C,QAAQ,EAAE,MAAM,CAAC;IACjB,oFAAoF;IACpF,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,qBAAqB,CAAC,CAAC,SAAS,YAAY,GAAG,YAAY,EAAE,CAAC,GAAG,OAAO;IACvF,IAAI,EAAE,OAAO,CAAC;IACd;;;OAGG;IACH,OAAO,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,IAAI,CAAC;IAC5C;;;OAGG;IACH,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB;;;;OAIG;IACH,KAAK,EAAE,SAAS,CAAC,EAAE,CAAC;IACpB,gDAAgD;IAChD,UAAU,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,GAAG,EAAE,eAAe,CAAC,CAAC,CAAC,KAAK,YAAY,CAAC;IAC/D;;;;OAIG;IACH,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACtD,gGAAgG;IAChG,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,sDAAsD;IACtD,IAAI,EAAE,YAAY,GAAG,CAAC,CAAC,OAAO,EAAE,eAAe,KAAK,YAAY,CAAC,CAAC;IAClE,MAAM,EAAE,sBAAsB,CAAC;IAC/B;;;;;OAKG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB"}

package/dist/types/components/feedback/SequenceResolver/index.d.ts

@@ -0,0 +1,3 @@
+export { SequenceResolver } from './SequenceResolver';
+export type { SequenceAction, SequenceCategory, SequenceDone, SequenceIntro, SequenceItem, SequenceResolverLabels, SequenceResolveOptions, SequenceResolverProps, SequenceStep, SequenceStepApi, SequenceSummary, } from './SequenceResolver.types';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/components/feedback/SequenceResolver/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/feedback/SequenceResolver/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,YAAY,EACV,cAAc,EACd,gBAAgB,EAChB,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,sBAAsB,EACtB,sBAAsB,EACtB,qBAAqB,EACrB,YAAY,EACZ,eAAe,EACf,eAAe,GAChB,MAAM,0BAA0B,CAAC"}

package/dist/types/components/feedback/SequenceResolver/sequence-model.d.ts

@@ -0,0 +1,85 @@
+import type { SequenceItem, SequenceSummary } from './SequenceResolver.types';
+/**
+ * THE RUN, as pure data: what was answered or passed over, and what is ahead.
+ *
+ * The queue is the host's live data, not a snapshot. An answer can resolve
+ * other entries with it (one limit saved for every sibling of a product), a
+ * refetch can drop the entry just answered, and a realtime push can add one —
+ * so the run is NOT an index into the queue. It keeps the visited steps in the
+ * order they were visited, and the steps still ahead in the order the queue
+ * gave them; `syncRun` reconciles the second list with each new queue.
+ */
+/** How a visited step was left. */
+export type Visit<I extends SequenceItem, R> = {
+    item: I;
+    outcome: 'resolved';
+    result: R;
+    alsoResolved?: number;
+} | {
+    item: I;
+    outcome: 'skipped';
+};
+export interface RunState<I extends SequenceItem, R> {
+    /** Every step left behind, oldest first. Back pops the last one. */
+    visits: Visit<I, R>[];
+    /** The steps still ahead; the first is on screen. Empty means the end screen. */
+    ahead: I[];
+    /**
+     * The step whose answer is being written, kept ahead even while the queue
+     * lacks it (the host's refetch may drop it before the write returns).
+     * Cleared when the run leaves it.
+     */
+    pinned?: string;
+    /**
+     * The steps Back returned to, kept ahead while the queue lacks them (the
+     * host's inverse ran, its refetch has not put the entry back yet). A SET:
+     * two Backs before one refetch hold both. A key leaves it when the queue
+     * confirms the entry or the run leaves the step.
+     */
+    held: readonly string[];
+}
+/** A fresh run over `queue` (a repeated key counts once). */
+export declare function startRun<I extends SequenceItem, R>(queue: readonly I[]): RunState<I, R>;
+/**
+ * The run against a new queue.
+ *
+ * - A step ahead that the queue no longer has is dropped — it was resolved
+ *   elsewhere (siblings answered together, another device) — unless it is
+ *   `pinned` or `held`.
+ * - A held key the queue has again is released: the host confirmed it.
+ * - A queue entry the run has not seen is appended, in queue order.
+ * - The entries kept are refreshed from the queue (same key, newer data).
+ * - Visited steps are history and never change.
+ */
+export declare function syncRun<I extends SequenceItem, R>(state: RunState<I, R>, queue: readonly I[]): RunState<I, R>;
+/** Keep `key` ahead whatever the queue says, until the run moves on (see {@link RunState.pinned}). */
+export declare function pinRun<I extends SequenceItem, R>(state: RunState<I, R>, key: string): RunState<I, R>;
+/** The step on screen, or `undefined` at the end. */
+export declare function currentOf<I extends SequenceItem, R>(state: RunState<I, R>): I | undefined;
+/**
+ * Answer `item` — the step that was on screen when the answer began (a pending
+ * write keeps it there, see {@link RunState.pinned}). An item no longer ahead
+ * was already answered (a double call): a no-op, as at the end.
+ */
+export declare function resolveRun<I extends SequenceItem, R>(state: RunState<I, R>, result: R, item?: I | undefined, alsoResolved?: number): RunState<I, R>;
+/**
+ * Pass over the step on screen. Given the `key` that was on screen when the
+ * skip began, a step that has moved on since (a double call) is left alone. At
+ * the end it is a no-op.
+ */
+export declare function skipRun<I extends SequenceItem, R>(state: RunState<I, R>, key?: string): RunState<I, R>;
+/** The step Back would return to, or `undefined` on the first one. */
+export declare function previousOf<I extends SequenceItem, R>(state: RunState<I, R>): Visit<I, R> | undefined;
+/**
+ * Return to the previous step: it is on screen again, ahead of the rest, and
+ * held until the queue confirms it. Given the `key` Back began from, a step
+ * already returned to (a double call) is left alone.
+ */
+export declare function backRun<I extends SequenceItem, R>(state: RunState<I, R>, key?: string): RunState<I, R>;
+/** Where the run stands. */
+export declare function summaryOf<I extends SequenceItem, R>(state: RunState<I, R>): SequenceSummary;
+/** 1-based position of the step on screen (`total + 1` never happens: at the end it is `total`). */
+export declare function positionOf<I extends SequenceItem, R>(state: RunState<I, R>): number;
+/** How far along, 0..100. An empty run is complete. */
+export declare function progressOf<I extends SequenceItem, R>(state: RunState<I, R>): number;
+//# sourceMappingURL=sequence-model.d.ts.map

package/dist/types/components/feedback/SequenceResolver/sequence-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequence-model.d.ts","sourceRoot":"","sources":["../../../../../src/components/feedback/SequenceResolver/sequence-model.ts"],"names":[],"mappings":"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"}

package/dist/types/components/feedback/SequenceResolver/useSequenceRun.d.ts

@@ -0,0 +1,24 @@
+import { type RunState } from './sequence-model';
+import type { SequenceItem, SequenceResolveOptions } from './SequenceResolver.types';
+interface RunInputs<I extends SequenceItem, R> {
+    /** The resolver is open. Opening it, intro or not, starts a fresh run. */
+    open: boolean;
+    /** True while the run is on screen: open, and past the intro. */
+    active: boolean;
+    queue: readonly I[];
+    onBack?: (item: I, result: R) => Promise<void> | void;
+    /** The message for a rejection that carries none. */
+    failed: string;
+}
+export interface SequenceRun<I extends SequenceItem, R> {
+    run: RunState<I, R>;
+    busy: boolean;
+    error: string | null;
+    resolve: (result: R | PromiseLike<R>, options?: SequenceResolveOptions) => void;
+    skip: () => void;
+    back: () => void;
+}
+/** The run's state and its verbs — the index/back/skip/done logic, once (FUT-3671). */
+export declare function useSequenceRun<I extends SequenceItem, R>(inputs: RunInputs<I, R>): SequenceRun<I, R>;
+export {};
+//# sourceMappingURL=useSequenceRun.d.ts.map

package/dist/types/components/feedback/SequenceResolver/useSequenceRun.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSequenceRun.d.ts","sourceRoot":"","sources":["../../../../../src/components/feedback/SequenceResolver/useSequenceRun.ts"],"names":[],"mappings":"AAEA,OAAO,EASL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,YAAY,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAErF,UAAU,SAAS,CAAC,CAAC,SAAS,YAAY,EAAE,CAAC;IAC3C,0EAA0E;IAC1E,IAAI,EAAE,OAAO,CAAC;IACd,iEAAiE;IACjE,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,SAAS,CAAC,EAAE,CAAC;IACpB,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACtD,qDAAqD;IACrD,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,WAAW,CAAC,CAAC,SAAS,YAAY,EAAE,CAAC;IACpD,GAAG,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACpB,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,OAAO,EAAE,CAAC,MAAM,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,sBAAsB,KAAK,IAAI,CAAC;IAChF,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,IAAI,EAAE,MAAM,IAAI,CAAC;CAClB;AA6HD,uFAAuF;AACvF,wBAAgB,cAAc,CAAC,CAAC,SAAS,YAAY,EAAE,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CA6CpG"}

package/dist/types/components/feedback/index.d.ts

@@ -2,6 +2,7 @@ export * from './ConfirmAction';
 export * from './Dialog';
 export * from './Modal';
 export * from './NotificationStatusNotice';
+export * from './SequenceResolver';
 export * from './Sonner';
 export * from './StackedModal';
 export * from './Toast';

package/dist/types/components/feedback/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/feedback/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,4BAA4B,CAAC;AAC3C,cAAc,UAAU,CAAC;AACzB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,SAAS,CAAC;AACxB,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/feedback/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,4BAA4B,CAAC;AAC3C,cAAc,oBAAoB,CAAC;AACnC,cAAc,UAAU,CAAC;AACzB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,SAAS,CAAC;AACxB,cAAc,mBAAmB,CAAC"}

package/dist/user-avatar.js

@@ -1,7 +1,7 @@
 import {
   UserAvatar,
   UserMenu
-} from "./chunk-TDWA2XFJ.js";
+} from "./chunk-OE3SQOZV.js";
 import "./chunk-UDQSIRAP.js";
 import "./chunk-KARMRTTM.js";
 import "./chunk-7XSCEHGA.js";
@@ -15,17 +15,17 @@ import "./chunk-FKUYRQSP.js";
 import "./chunk-PLB6WWXW.js";
 import "./chunk-HDBP55R3.js";
 import "./chunk-BA4RHQ3B.js";
-import "./chunk-YOXYSAUI.js";
-import "./chunk-PPEHBI5O.js";
+import "./chunk-5USHYSCO.js";
+import "./chunk-KXTNTDRD.js";
 import "./chunk-G2FUZALJ.js";
 import "./chunk-TAMIZE4Q.js";
 import "./chunk-AJBRO76D.js";
 import "./chunk-36VXZCJT.js";
 import "./chunk-TYJR4GOF.js";
-import "./chunk-RGVNXES5.js";
-import "./chunk-GDN2LUTZ.js";
+import "./chunk-QQHZBJMU.js";
 import "./chunk-7ZADLRLP.js";
 import "./chunk-3NGE6NE6.js";
+import "./chunk-GDN2LUTZ.js";
 import "./chunk-2FBGDSGC.js";
 import "./chunk-VBP46YP4.js";
 import "./chunk-44BD7SFH.js";

package/dist/utility/WorkflowStep.js

@@ -6,17 +6,17 @@ import "../chunk-VNVV6Y2X.js";
 import "../chunk-SV6IQ2YO.js";
 import "../chunk-XKSA4L2X.js";
 import "../chunk-B7ZHEOQQ.js";
-import "../chunk-BRHRK7BK.js";
+import "../chunk-ENRB6PIN.js";
 import "../chunk-25MSGLNU.js";
 import "../chunk-GAXHYRX6.js";
 import "../chunk-NP6SHLQ3.js";
 import "../chunk-TZ23DNKY.js";
 import "../chunk-7ZPUN7TV.js";
 import "../chunk-PT6TCWIW.js";
-import "../chunk-RGVNXES5.js";
-import "../chunk-GDN2LUTZ.js";
+import "../chunk-QQHZBJMU.js";
 import "../chunk-7ZADLRLP.js";
 import "../chunk-3NGE6NE6.js";
+import "../chunk-GDN2LUTZ.js";
 import "../chunk-2FBGDSGC.js";
 import "../chunk-VBP46YP4.js";
 import "../chunk-44BD7SFH.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@12-apps/ui",
-  "version": "6.77.2",
+  "version": "6.78.0",
   "license": "MIT",
   "packageManager": "pnpm@10.34.5",
   "type": "module",
@@ -320,6 +320,10 @@
       "types": "./dist/types/components/feedback/Sonner/index.d.ts",
       "default": "./dist/feedback/Sonner.js"
     },
+    "./feedback/SequenceResolver": {
+      "types": "./dist/types/components/feedback/SequenceResolver/index.d.ts",
+      "default": "./dist/feedback/SequenceResolver.js"
+    },
     "./feedback/StackedModal": {
       "types": "./dist/types/components/feedback/StackedModal/index.d.ts",
       "default": "./dist/feedback/StackedModal.js"

package/src/components/feedback/SequenceResolver/SequenceResolver.md

@@ -0,0 +1,136 @@
+# SequenceResolver
+
+Resolve a **queue of problems one at a time** in one dialog whose body is replaced step by
+step. The component owns the run — which step is on screen, what was answered or skipped,
+where Back returns to, when the end screen shows — and nothing about the domain: every
+step body, every word and every server call is the host's (FUT-3671).
+
+```
+┌──────────────────────────────────────────────┐
+│ ‹ Back   Problem 3 of 13 · Purchase       ×  │  header: back (once a previous step exists), label, close
+│ ▓▓▓▓▓▓▓░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ │  progress: steps left behind / total
+│ Red Bull 250ml                               │  ┐
+│ Register the purchase                        │  │ the host's step (renderStep)
+│ No stock. Last purchase: 24 u for $ 163.20   │  ┘
+│ It was a stock count                         │  tertiary (text button, optional)
+│ ──────────────────────────────────────────── │
+│                    [Not bought yet] [Save]   │  footer: secondary (skip by default) + primary
+└──────────────────────────────────────────────┘
+```
+
+**When to use it.** A list of things that each need a decision (a stock screen's "N problems
+to solve", a product's subproducts to restock), resolved in order, where Back must undo the
+previous answer. **Not** `StackedModal` — that stacks nested dialogs, and thirteen problems
+would be thirteen layers with a back button that closes a layer instead of undoing an
+answer. **Not** `Stepper` — that shows a known, short list of named steps; this queue is
+data-sized and shrinks while you go.
+
+## Surfaces
+
+- **≥ 600px (`sm`)**: a centred `Dialog` (`size="sm"`), capped by the viewport.
+- **Either way the body is the only scroll region**: the handle, header and progress stay
+  put while a long step scrolls under them, so it is never cut off and Back/close never
+  scroll away.
+- **< 600px**: the `Dialog` inset `bottom-sheet` variant, at most 95% of the dynamic
+  viewport, scrolling inside; a drag handle on top is decoration only (the sheet does not
+  drag). Every header and footer target is at least 44px tall there.
+
+## Props
+
+| Prop | Type | Description |
+|---|---|---|
+| `open` | `boolean` | Shows the resolver. Every opening — with an intro or without — starts a fresh run. |
+| `onClose` | `(summary) => void` | Close button, Esc and the end screen's button. Gets `{ resolved, skipped, total, alsoResolved }`; a close toast counts `resolved + alsoResolved` (and shows only when that is above 0). Clicking the veil does nothing (as approved). |
+| `intro` | `SequenceIntro?` | While given, the intro shows instead of the run: `title`, `description`, `categories` (`label`, `description`, `count`, `onPick`), `startAllLabel`, `onStartAll`. The host drops it and sets `queue` in the same update as a pick. |
+| `queue` | `readonly I[]` (`I extends { key; kindLabel }`) | The problems, in order. Live data: it may shrink (siblings answered together) or grow mid-run. |
+| `renderStep` | `(item, api) => SequenceStep` | The current step: `content`, `primary?`, `secondary?` (default: skip with `labels.skip`; `false` removes it), `tertiary?`, `footer?` (`'end'` default — right-aligned over a hairline; `'split'` — two equal columns, no hairline; on a phone the actions always share the row without a hairline). |
+| `onBack` | `(item, result) => Promise<void> \| void` | The host's server inverse, awaited before Back shows the previous step again. Called only when that step was RESOLVED. |
+| `canGoBack` | `boolean` (default `true`) | Offer Back at all. It shows only once a previous step exists — on steps and on the end screen, never on the intro. |
+| `done` | `SequenceDone \| (summary) => SequenceDone` | The end screen: `title`, `description?`, `confirmLabel`. |
+| `labels` | `SequenceResolverLabels` | Every chrome word: `back`, `backAccessible?`, `close`, `skip`, `step(position, total, item)`, `introStep`, `doneStep`, `progress`, `failed`. **Required — the package ships no copy.** |
+| `dataTestId` | `string` (default `sequence-resolver`) | Parts: `-back`, `-close`, `-step-label`, `-progress`, `-handle`, `-category-<n>`, `-start-all`, `-primary`, `-secondary`, `-tertiary`, `-footer`, `-error`, `-done`, `-done-confirm`. |
+
+### The step API
+
+| `api.` | |
+|---|---|
+| `resolve(result \| promise, { alsoResolved? })` | Answer and move on. `alsoResolved` counts OTHER problems this answer resolved too ("apply to every sibling") for the close summary; Back over the step takes them off again. Given the PROMISE of the host's write, the step stays on screen and `busy` until it settles (even if the host's refetch drops the entry first); a rejection keeps it and shows the rejection's message. |
+| `skip()` | Leave it unanswered and move on. |
+| `back()` | Same as the header's Back. |
+| `busy` | True while a `resolve` promise or an `onBack` is pending. The footer, tertiary and Back are disabled by the component; disable the step's own answers with it. |
+| `titleProps` | **Spread on the step's title** (the item's name). It names the dialog and takes focus on every advance. |
+
+## Behaviour
+
+- **Index.** The run is not an index into `queue`. Visited steps are kept in visit order,
+  the steps ahead in queue order. A new `queue` drops the steps ahead it no longer has
+  (resolved elsewhere — "apply to every sibling") and appends entries it has not seen; the
+  total follows. The run never goes past the end: with nothing ahead the end screen shows.
+- **An empty queue at the start shows the end screen.** Do not open the resolver (past the
+  intro) before the problems have loaded.
+- **Back** pops the last visited step. Over a resolved step it awaits `onBack(item, result)`
+  first; over a skipped one it returns at once. A rejected `onBack` keeps the current step
+  and shows the message (`labels.failed` when the rejection has none). Every step Back
+  returned to is held on screen while the host's refetch has not put it back yet — two Backs
+  before one refetch hold both — and is released once the queue has it again.
+- **`onBack` receives the item as it was when the step was answered** (with that answer's
+  result), not a fresher copy from a later queue.
+- **The close summary counts what has settled.** An answer whose write is still pending
+  when the reader closes is not in `resolved`.
+- **An error belongs to its step**: once the run moves to another step (an answer, a skip,
+  or a queue change), it is gone.
+- **Busy** blocks every verb: a second tap, or a skip during a pending write, is ignored.
+- **Focus** moves to the screen's title on open and on every advance or return; Tab is
+  trapped in the dialog; Esc closes (a popup inside a step that handles its own Esc keeps it).
+- **Labelling.** `role="dialog"`, `aria-modal`, `aria-labelledby` = the intro title, the
+  step title (`api.titleProps`) or the end title. The progress bar is named by
+  `labels.progress`.
+
+## Writing a step
+
+The pattern the owner approved — **the item's name first** (large), the question second, the
+facts third. Footer: the secondary is "Skip for now" (or a step-specific word), the primary
+is the step's verb; two actions at most, plus at most ONE tertiary, which sits as a text
+button above the footer.
+
+```tsx
+<SequenceResolver<Problem, Answer>
+  open={open}
+  onClose={(summary) => { setOpen(false); toastResolved(summary); }}
+  intro={showIntro ? intro : undefined}
+  queue={problems}
+  renderStep={(item, api) => stepFor(item, api)}
+  onBack={(item, answer) => api.undo(answer.undoId)}
+  done={(s) => ({
+    title: s.resolved === s.total ? copy.allSolved : copy.someSolved(s.resolved, s.total),
+    description: copy.doneHint,
+    confirmLabel: copy.finish,
+  })}
+  labels={copy.resolver}
+/>
+```
+
+### Four step kinds, as a stock screen plugs them in
+
+| Kind (`kindLabel`) | `content` | `primary` | `secondary` | `tertiary` / `footer` |
+|---|---|---|---|---|
+| **Limits** — no minimum/maximum | name; "How much stays on display?"; facts; min/max steppers (`NumberField`); "Apply to every subproduct of X (N)" checkbox | "Save limits" → `api.resolve(saveLimits(...))`; with the checkbox the host's refetch drops the siblings' steps, and `{ alsoResolved: N }` counts them | skip | `footer: 'split'` |
+| **Purchase** — out of stock | name; "Register purchase"; last purchase; quantity / total paid (`NumberField`), supplier (`CreatableSelect`), destination; "Also put N on display" | "Register and display N" → `api.resolve(registerPurchase(...))` | `{ label: 'Not bought yet', onClick: api.skip }` | `footer: 'split'` |
+| **Restock** — display below its rule | name; "How many to take?"; total / displayed / stored; the 0→max bar; − / + | "Take N" → `api.resolve(restock(...))` | skip | `footer: 'end'` |
+| **Unexplained loss** — a write-off with no reason | name; "Why did these N leave?"; quick reasons + "Other reason" (each answers with `api.resolve`, disabled while `api.busy`); "Different reasons? Split the N" | — (the reason buttons answer); while splitting: "Save N reasons" | skip; while splitting: `{ label: 'One reason only', ... }` | "It was a stock count, not a loss" |
+
+Each `resolve` returns what `onBack` needs to undo it (an undo id from the server), so Back
+is one call to the host's inverse.
+
+## Accessibility
+
+- Dialog role, labelled title, focus trap (MUI's, via `Dialog`), Esc to close.
+- Focus to the title on every screen change, so a screen reader announces the new problem.
+- 44px+ targets below 600px (`lg` buttons, a 44px close).
+- Errors are an assertive `Alert`; `aria-busy` marks the step while a write is pending.
+
+## Related
+
+- `Dialog` — the surface (default and inset `bottom-sheet` variants).
+- `Progress` — the bar.
+- `StackedModal`, `Stepper` — see "When to use it".

package/src/components/feedback/SequenceResolver/SequenceResolver.metrics.ts

@@ -0,0 +1,26 @@
+/**
+ * THE RESOLVER'S NUMBERS — the approved prototype's, in px. The web reads
+ * them through `rem`/`sxRem` so a density mode scales them (FUT-3671).
+ */
+export const SEQUENCE_METRICS = {
+  /** Below this width the dialog is the inset bottom sheet, and targets are 44px+. */
+  sheetBreakpoint: 'sm',
+  /** The sheet never grows past this share of the viewport; the paper scrolls inside it. */
+  sheetMaxHeightPercent: 95,
+  /** The smallest a control may be below the sheet breakpoint, and the end screen's button everywhere. */
+  touchTarget: 44,
+  /** The intro's "all in sequence" button, at least. */
+  startAllHeight: 48,
+  /** Header icon button: 40px on a pointer, 44px on a phone. */
+  closeSize: { pointer: 40, touch: 44 },
+  /** The drag handle — decoration only, the sheet does not drag. */
+  handle: { width: 40, height: 4 },
+  title: 22,
+  stepLabel: 13,
+  categoryDescription: 13,
+  categoryMinHeight: 56,
+  countBadge: 32,
+  listRadius: 12,
+  doneIcon: 44,
+  doneTitle: 20,
+} as const;