@vtex/faststore 0.0.8 → 0.0.11

package/dist/matter/access-code-sign-in/access-code-sign-in.d.ts

@@ -1,111 +1,295 @@
+import { ContentValue, MessageLocaleProp } from "../../core/dist/define-content-type.js";
 import { ComponentDefinition } from "../../core/dist/define-component.js";
 import "../../core/dist/index.js";
 import { ComponentActions } from "../../sdk/actions/types.js";
 import { ComponentPropsWithRef } from "react";
 //#region src/matter/access-code-sign-in/access-code-sign-in.d.ts
-/** Colocated fragment slice forwarded by the reactive runtime — `null` until both fields resolve. */
-export type AccessCodeSignInSlice = {
-  clientProfile: {
-    email: string | null;
-  } | null;
-  sessionAuthProviders: {
-    accessKeyAuthentication: boolean;
-  } | null;
-};
 export type AccessCodeSignInStep = 'request' | 'validate';
 export type AccessCodeSignInContextValue = Readonly<{
-  /** The shopper's locally-typed draft email — never written to the cart; only ever an argument to
-   * requestAccessCode/validateAccessCode. Pre-fills from `clientProfile.email` when known, but a
-   * shopper edit is never persisted anywhere by this family. */
-  email: string;
-  /** Updates the draft email; marks it as shopper-touched so pre-fill no longer overwrites it. */
-  setEmail: (email: string) => void;
   step: AccessCodeSignInStep;
   /** Opaque token round-tripped from requestAccessCode into validateAccessCode. */
   authenticationToken: string | null;
-  /** Called by AccessCodeRequestControl on a successful requestAccessCode. */
-  startValidation: (authenticationToken: string) => void;
+  /** The address `requestAccessCode` was dispatched with. `validateAccessCode` must use this, not the
+   * live `sign-in` draft: the server rejects a validate whose email differs from the request. */
+  requestedEmail: string | null;
+  /** Called by AccessCodeRequestControl and AccessCodeResendControl on a successful requestAccessCode.
+   * Writes the token and the address it was issued for in one transition, so neither can be set without
+   * the other, and arms the resend pace. */
+  startValidation: (authenticationToken: string, requestedEmail: string) => void;
+  /** Whole seconds until another code may be sent. `0` means permitted. */
+  resendAvailableInSeconds: number;
+  /** Discards the step, the token, the pinned address and the pace together, returning to `request`. */
+  resetToRequest: () => void;
 }>;
-export type AccessCodeSignInRootProps = ComponentPropsWithRef<'div'> & {
-  $data?: AccessCodeSignInSlice | null;
-};
-export type AccessCodeEmailControlProps = ComponentPropsWithRef<'div'> & {
+export type AccessCodeSignInRootProps = ComponentPropsWithRef<'div'>;
+export type AccessCodeRequestControlProps = ComponentPropsWithRef<'div'> & MessageLocaleProp & {
   label?: string;
-  placeholder?: string;
-  invalidEmailMessage?: string;
+  pendingLabel?: string;
+  onRequested?: (authenticationToken: string) => void;
+  /** The inline message for each refusal of the send. */
+  $content?: ContentValue<typeof AccessCodeRequestControlContent>;
+  $actions?: ComponentActions;
 };
-export type AccessCodeRequestControlProps = ComponentPropsWithRef<'div'> & {
+export type AccessCodeSentNoticeProps = ComponentPropsWithRef<'output'> & MessageLocaleProp & {
+  /** The confirmation sentence; its `email` argument is the address the code was sent to. */
+  $content?: ContentValue<typeof AccessCodeSentNoticeContent>;
+};
+export type AccessCodeResendControlProps = ComponentPropsWithRef<'div'> & MessageLocaleProp & {
   label?: string;
   pendingLabel?: string;
-  sendLimitMessage?: string;
-  blockedMessage?: string;
-  networkErrorMessage?: string;
-  onRequested?: (authenticationToken: string) => void;
+  onResent?: (authenticationToken: string) => void;
+  /** The button label while the pace has not elapsed (its `seconds` argument is the whole seconds left),
+   * and the inline message for each refusal of the send. */
+  $content?: ContentValue<typeof AccessCodeResendContent>;
   $actions?: ComponentActions;
 };
-export type AccessCodeValidateControlProps = ComponentPropsWithRef<'div'> & {
+export type AccessCodeCorrectEmailControlProps = ComponentPropsWithRef<'div'> & {
+  label?: string;
+  onCorrected?: () => void;
+};
+export type AccessCodeValidateControlProps = ComponentPropsWithRef<'div'> & MessageLocaleProp & {
   label?: string;
   placeholder?: string;
   submitLabel?: string;
   codeLength?: number;
-  invalidCodeMessage?: string;
-  blockedMessage?: string;
-  missingAuthContextMessage?: string;
-  networkErrorMessage?: string;
   onValidated?: () => void;
+  /** The inline message for each refusal of the code. */
+  $content?: ContentValue<typeof AccessCodeValidateControlContent>;
   $actions?: ComponentActions;
 };
-export declare const AccessCodeSignInRootDefinition: ComponentDefinition<AccessCodeSignInRootProps>;
-export declare const AccessCodeEmailControlDefinition: ComponentDefinition<AccessCodeEmailControlProps>;
+export declare const AccessCodeRequestControlContent: {
+  readonly id: "access-code-request-control";
+  readonly title: "Access Code Request Control";
+  readonly description: "The inline messages shown when sending the access code fails.";
+  readonly schema: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly properties: {
+      readonly sendLimitMessage: {
+        readonly type: "string";
+        readonly title: "Send-limit message";
+        readonly description: "Shown when too many codes were requested for the address.";
+        readonly format: "icu-message";
+        readonly messageSource: "Too many codes requested. Try again later.";
+      };
+      readonly blockedMessage: {
+        readonly type: "string";
+        readonly title: "Blocked message";
+        readonly description: "Shown when the account is blocked. Names no duration: the account service returns none.";
+        readonly format: "icu-message";
+        readonly messageSource: "This account is blocked. Contact support.";
+      };
+      readonly networkErrorMessage: {
+        readonly type: "string";
+        readonly title: "Generic error message";
+        readonly description: "Shown for a network failure and for any refusal the shopper cannot act on.";
+        readonly format: "icu-message";
+        readonly messageSource: "Something went wrong. Please try again.";
+      };
+    };
+  };
+};
+export declare const AccessCodeValidateControlContent: {
+  readonly id: "access-code-validate-control";
+  readonly title: "Access Code Validate Control";
+  readonly description: "The inline messages shown when the access code is refused.";
+  readonly schema: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly properties: {
+      readonly invalidCodeMessage: {
+        readonly type: "string";
+        readonly title: "Invalid code message";
+        readonly description: "Shown when the code is wrong or expired.";
+        readonly format: "icu-message";
+        readonly messageSource: "That code is incorrect or expired.";
+      };
+      readonly blockedMessage: {
+        readonly type: "string";
+        readonly title: "Blocked message";
+        readonly description: "Shown when the account is blocked. Names no duration: the account service returns none.";
+        readonly format: "icu-message";
+        readonly messageSource: "This account is blocked. Contact support.";
+      };
+      readonly missingAuthContextMessage: {
+        readonly type: "string";
+        readonly title: "Missing sign-in context message";
+        readonly description: "Shown when the request lost the context the code was issued for. Should not occur on a correct flow.";
+        readonly format: "icu-message";
+        readonly messageSource: "Something went wrong. Please try again.";
+      };
+      readonly networkErrorMessage: {
+        readonly type: "string";
+        readonly title: "Generic error message";
+        readonly description: "Shown for a network failure and for any refusal the shopper cannot act on.";
+        readonly format: "icu-message";
+        readonly messageSource: "Something went wrong. Please try again.";
+      };
+    };
+  };
+};
+export declare const AccessCodeSignInRootDefinition: ComponentDefinition<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>>;
 export declare const AccessCodeRequestControlDefinition: ComponentDefinition<AccessCodeRequestControlProps>;
 export declare const AccessCodeValidateControlDefinition: ComponentDefinition<AccessCodeValidateControlProps>;
+export declare const AccessCodeSentNoticeContent: {
+  readonly id: "access-code-sent-notice";
+  readonly title: "Access Code Sent Notice";
+  readonly description: "Confirmation that names the address the access code was sent to.";
+  readonly schema: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly properties: {
+      readonly template: {
+        readonly type: "string";
+        readonly title: "Template";
+        readonly format: "icu-message";
+        readonly messageSource: "We sent an access code to {email}.";
+        readonly messageArguments: {
+          readonly type: "object";
+          readonly properties: {
+            readonly email: {
+              readonly type: "string";
+            };
+          };
+        };
+        readonly messageExample: {
+          readonly email: "shopper@example.com";
+        };
+      };
+    };
+  };
+};
+export declare const AccessCodeSentNoticeDefinition: ComponentDefinition<AccessCodeSentNoticeProps>;
+export declare const AccessCodeResendContent: {
+  readonly id: "access-code-resend";
+  readonly title: "Access Code Resend";
+  readonly description: "Label of the resend button while the resend pace has not elapsed, and the inline messages shown when resending fails.";
+  readonly schema: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly properties: {
+      readonly sendLimitMessage: {
+        readonly type: "string";
+        readonly title: "Send-limit message";
+        readonly description: "Shown when too many codes were requested for the address.";
+        readonly format: "icu-message";
+        readonly messageSource: "Too many codes requested. Try again later.";
+      };
+      readonly blockedMessage: {
+        readonly type: "string";
+        readonly title: "Blocked message";
+        readonly description: "Shown when the account is blocked. Names no duration: the account service returns none.";
+        readonly format: "icu-message";
+        readonly messageSource: "This account is blocked. Contact support.";
+      };
+      readonly networkErrorMessage: {
+        readonly type: "string";
+        readonly title: "Generic error message";
+        readonly description: "Shown for a network failure and for any refusal the shopper cannot act on.";
+        readonly format: "icu-message";
+        readonly messageSource: "Something went wrong. Please try again.";
+      };
+      readonly countdownTemplate: {
+        readonly type: "string";
+        readonly title: "Countdown template";
+        readonly format: "icu-message";
+        readonly messageSource: "Resend code in {seconds}s";
+        readonly messageArguments: {
+          readonly type: "object";
+          readonly properties: {
+            readonly seconds: {
+              readonly type: "integer";
+            };
+          };
+        };
+        readonly messageExample: {
+          readonly seconds: 42;
+        };
+      };
+    };
+  };
+};
+export declare const AccessCodeResendControlDefinition: ComponentDefinition<AccessCodeResendControlProps>;
+export declare const AccessCodeCorrectEmailControlDefinition: ComponentDefinition<AccessCodeCorrectEmailControlProps>;
 /**
- * Data-owning root of the access-code sign-in flow. Self-gates on two signals:
- * `useSession().state !== 'loggedIn'` (available from anonymous through identified; hides once
- * signed in) and `sessionAuthProviders.accessKeyAuthentication === true`. An unresolved fragment
- * read (`$data` still `null`) is treated as "provider not enabled" — the flow stays hidden rather
- * than flashing. Owns the `step`/`authenticationToken` stepper plus a locally-typed draft `email`
- * as local state, broadcasting all of it through context to its children. The draft email pre-fills
- * from `clientProfile.email` once (for an already-identified shopper) but a shopper edit is never
- * persisted anywhere by this family — it is purely the requestAccessCode/validateAccessCode
- * argument; the server sets clientProfileData.email as a side effect of a successful validate.
- * Reacts automatically once `useSession()` flips to `loggedIn` — no manual unmount call anywhere in
- * this family.
- */
-export declare function AccessCodeSignInRoot({ $data: $dataProp, className, children, ...props }: AccessCodeSignInRootProps): import("react/jsx-runtime").JSX.Element | null;
-/**
- * The draft email input for the access-code flow. Renders only at the request step. Bound to the
- * Root's local `email`/`setEmail` — never a fragment, never a mutation of its own; typing here
- * never touches the cart. Format validation is `EmailField`'s own blur-triggered check (never
- * per-keystroke); `invalidEmailMessage` is only its fallback text, mirroring how
- * `EmailIdentificationControl` defers to the same particle for the same reason.
+ * Root of the access-code method of the sign-in surface. It declares no fragment and reads no data of
+ * its own: the gate is the three `sign-in` context reads (`resolved`, `accessCodeEnabled` and
+ * `method === 'accessCode'`) plus the session read (`state !== 'loggedIn'`), so a store enabling both
+ * methods shows the code step only while the access code is the method showing. It returns `null`
+ * rather than unmounting, so its `useState` — the stepper, the token and the pinned address — survives
+ * a method switch and a gate close.
+ *
+ * Owns the `step`/`authenticationToken` stepper, the address the token was issued for and the resend
+ * deadline, broadcasting them through context. The shared email draft is `SignInRoot`'s, never this
+ * family's; the validate dispatch reads the pinned `requestedEmail` instead, because the server rejects a
+ * `validateAccessCode` whose email differs from the `requestAccessCode` that issued the token. The
+ * deadline lives here, not on the resend control, because this Root returns `null` on a method switch and
+ * unmounts every child with it. Everything clears together — `resetToRequest()` — on any change of
+ * `useSession().state` other than the session resolving, so a stale token, address and countdown never greet
+ * the next shopper. This Root never unmounts, so that reaction is the only thing that clears it: no manual call
+ * anywhere in this family.
  */
-export declare function AccessCodeEmailControl({ label, placeholder, invalidEmailMessage, className, ...props }: AccessCodeEmailControlProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function AccessCodeSignInRoot({ className, children, ...props }: AccessCodeSignInRootProps): import("react/jsx-runtime").JSX.Element | null;
 /**
- * Renders only while the Root's stepper is at `step === 'request'`. Reads the draft email from
- * context and dispatches `$actions.session.requestAccessCode({ email })` once it is a valid,
+ * Renders only while the Root's stepper is at `step === 'request'`. Reads the shared draft email from
+ * `useSignIn()` and dispatches `$actions.session.requestAccessCode({ email })` once it is a valid,
  * non-empty address (no account-existence pre-check beyond that format gate). On a result with a
- * non-null token and no `userErrors`, advances the Root's stepper. Every `userErrors` entry renders
- * inline via a host-supplied, per-code message; the step never changes on error, so the shopper can
+ * non-null token and no `userErrors`, advances the Root's stepper and hands it the exact address that
+ * was dispatched, so the validate step is bound to it. Every `userErrors` entry renders
+ * inline, worded by the `$content` field for its code; the step never changes on error, so the shopper can
  * retry or abandon the method and continue as a guest.
+ *
+ * A result that arrives after the session changed under it is dropped rather than written: the Root
+ * cleared the stepper for that change, and writing the result would bind the next shopper to the
+ * address and the live token of the one who pressed send.
  */
-export declare function AccessCodeRequestControl({ label, pendingLabel, sendLimitMessage, blockedMessage, networkErrorMessage, onRequested, $actions: $actionsProp, className, ...props }: AccessCodeRequestControlProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function AccessCodeRequestControl({ label, pendingLabel, onRequested, $content, $locale, $actions: $actionsProp, className, ...props }: AccessCodeRequestControlProps): import("react/jsx-runtime").JSX.Element | null;
 /**
  * Renders only while the Root's stepper is at `step === 'validate'`. Composes `AccessCodeField` for
  * the code value and a submit control, disabled below `codeLength` (a UX courtesy, never a
- * validity claim). Dispatches `$actions.session.validateAccessCode` with the email and
- * `authenticationToken` read from context. On a non-empty `userErrors` result, sets the field's
- * `invalid`/`errorMessage` from a host-supplied per-code message and retains the code/token so the
- * shopper can retry without re-requesting. On success it calls the optional `onValidated` and renders
+ * validity claim). Dispatches `$actions.session.validateAccessCode` with the pinned `requestedEmail`
+ * and `authenticationToken` read from context — never the live `sign-in` draft. On a non-empty
+ * `userErrors` result, sets the field's `invalid`/`errorMessage` from the `$content` field for its code
+ * and retains the code/token so the shopper can retry without re-requesting. On success it calls the optional `onValidated` and renders
  * no local "success" UI — `useSession()` flipping to `loggedIn` is what makes the whole Root
  * disappear.
  */
-export declare function AccessCodeValidateControl({ label, placeholder, submitLabel, codeLength, invalidCodeMessage, blockedMessage, missingAuthContextMessage, networkErrorMessage, onValidated, $actions: $actionsProp, className, ...props }: AccessCodeValidateControlProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function AccessCodeValidateControl({ label, placeholder, submitLabel, codeLength, onValidated, $content, $locale, $actions: $actionsProp, className, ...props }: AccessCodeValidateControlProps): import("react/jsx-runtime").JSX.Element | null;
+/**
+ * Renders only at the validate step. Names the address the code was dispatched to — the Root's pinned
+ * `requestedEmail`, never the live `sign-in` draft, which a shopper edit or a profile re-seed can move
+ * after the request. The `template` message's `email` argument is the address. The wrapper is an
+ * `output`, whose implicit `status` role announces the confirmation once, when it appears.
+ */
+export declare function AccessCodeSentNotice({ $content, $locale, className, ...props }: AccessCodeSentNoticeProps): import("react/jsx-runtime").JSX.Element | null;
+/**
+ * Renders only at the validate step. Dispatches `$actions.session.requestAccessCode` with the Root's
+ * pinned `requestedEmail` — never the live draft, so a second code goes to the address the shopper was
+ * told about — and replaces the token with the one it returns through the same `startValidation` that
+ * the request control uses, which re-pins the same address and re-arms the pace. Inert until the pace
+ * has elapsed, with the whole seconds left in its own label. A failure renders inline and leaves the
+ * step, the token and the pace untouched: no code was sent, so none is paced.
+ *
+ * A result that arrives after the request it answered has been discarded (the shopper went back, the
+ * session changed, the Root closed) is dropped rather than written, so a token is never re-paired with
+ * the address that was left.
+ */
+export declare function AccessCodeResendControl({ label, pendingLabel, onResent, $content, $locale, $actions: $actionsProp, className, ...props }: AccessCodeResendControlProps): import("react/jsx-runtime").JSX.Element | null;
+/**
+ * Renders only at the validate step. Calls the Root's `resetToRequest()`, which discards the step, the
+ * token, the pinned address and the resend pace in one transition. The shopper lands on the request step
+ * with the shared draft still in the field to edit; the next request pins whatever address they send and
+ * the token the server issues for it, and the earlier token is unreachable. Never held by the pace: the
+ * pace counts codes sent, and a shopper who mistyped is not made to wait for the address they meant.
+ */
+export declare function AccessCodeCorrectEmailControl({ label, onCorrected, className, ...props }: AccessCodeCorrectEmailControlProps): import("react/jsx-runtime").JSX.Element | null;
 export declare const AccessCodeSignIn: {
   Root: typeof AccessCodeSignInRoot;
-  Email: typeof AccessCodeEmailControl;
   Request: typeof AccessCodeRequestControl;
+  SentNotice: typeof AccessCodeSentNotice;
   Validate: typeof AccessCodeValidateControl;
+  Resend: typeof AccessCodeResendControl;
+  CorrectEmail: typeof AccessCodeCorrectEmailControl;
 };
 //#endregion
 //# sourceMappingURL=access-code-sign-in.d.ts.map