@vtex/faststore 0.0.8 → 0.0.11

package/dist/matter/cart-destination/cart-destination.js

@@ -0,0 +1,703 @@
+"use client";
+import { defineComponent } from "../../core/dist/define-component.js";
+import { defineContentType } from "../../core/dist/define-content-type.js";
+import "../../core/dist/index.js";
+import { useMessageFormatter } from "../../sdk/i18n/use-message-formatter.js";
+import { Field } from "../../particles/field/field.js";
+import { useActionsOverride } from "../../sdk/actions/actions-override-context.js";
+import { formatErrorCode } from "../../sdk/i18n/format-error-code.js";
+import { useDataOverride } from "../../sdk/data/data-override-context.js";
+import { loggableErrorName } from "../../utils/loggable-error-name.js";
+import { ReactiveRootContext } from "../../sdk/data/page-reactive-data-root.js";
+import { addressFields } from "../../sdk/address/address-fields.js";
+import { loadCountryRules } from "../../sdk/address/country-rules.js";
+import { validateAddress } from "../../sdk/address/validate-address.js";
+import { normalizePostalCode } from "../../sdk/address/postal-code.js";
+import { awaitCartWrites } from "../../sdk/cart/write-gate.js";
+import { Input } from "../../particles/input/input.js";
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/matter/cart-destination/cart-destination.tsx
+const fragment = `
+  fragment CartDestinationData on Query {
+    shipping {
+      __typename
+      id
+      address {
+        __typename
+        id
+        postalCode
+        country
+        city
+        state
+      }
+    }
+  }
+`;
+const CartDestinationValueContent = defineContentType({
+	id: "cart-destination-value",
+	title: "Cart Destination Value",
+	description: "Copy that precedes the destination in read mode.",
+	schema: {
+		type: "object",
+		additionalProperties: false,
+		properties: { prefix: {
+			type: "string",
+			title: "Prefix"
+		} }
+	}
+});
+const CartDestinationChangeContent = defineContentType({
+	id: "cart-destination-change",
+	title: "Cart Destination Change",
+	description: "Copy for the control that opens edit mode.",
+	schema: {
+		type: "object",
+		additionalProperties: false,
+		properties: { label: {
+			type: "string",
+			title: "Button label"
+		} }
+	}
+});
+const CartDestinationSubmitContent = defineContentType({
+	id: "cart-destination-submit",
+	title: "Cart Destination Submit",
+	description: "Copy for the control that writes the destination.",
+	schema: {
+		type: "object",
+		additionalProperties: false,
+		properties: {
+			label: {
+				type: "string",
+				title: "Button label"
+			},
+			pendingLabel: {
+				type: "string",
+				title: "Pending label"
+			}
+		}
+	}
+});
+const CartDestinationCancelContent = defineContentType({
+	id: "cart-destination-cancel",
+	title: "Cart Destination Cancel",
+	description: "Copy for the control that closes edit mode without writing.",
+	schema: {
+		type: "object",
+		additionalProperties: false,
+		properties: { label: {
+			type: "string",
+			title: "Button label"
+		} }
+	}
+});
+const CartDestinationErrorContent = defineContentType({
+	id: "cart-destination-error",
+	title: "Cart Destination Error",
+	description: "Messages shown when the destination write is refused, one per error code the shopper can act on.",
+	schema: {
+		type: "object",
+		additionalProperties: false,
+		properties: {
+			genericMessage: {
+				type: "string",
+				title: "Failure message",
+				description: "Shown for a network failure and for every refusal the shopper cannot act on.",
+				format: "icu-message",
+				messageSource: "Unable to update the delivery location. Please try again."
+			},
+			invalidPostalCodeMessage: {
+				type: "string",
+				title: "Invalid postal code message",
+				description: "Shown when the server rejects the postal code.",
+				format: "icu-message",
+				messageSource: "Enter a valid postal code."
+			}
+		}
+	}
+});
+const CART_DESTINATION_CONTEXT_UNSET = Symbol("CartDestinationContextUnset");
+const CartDestinationContextInternal = createContext(CART_DESTINATION_CONTEXT_UNSET);
+/**
+* Read the destination and the edit-mode state from the nearest `CartDestinationRoot`. Throws outside
+* one: a misplaced part is a composition bug the author should see at once.
+*/
+function useCartDestination() {
+	const ctx = useContext(CartDestinationContextInternal);
+	if (ctx === CART_DESTINATION_CONTEXT_UNSET) throw new Error("CartDestination components must be used inside a <CartDestinationRoot> subtree.");
+	return ctx;
+}
+/** Whether a `CartDestinationForm` encloses the subtree, so `CartDestinationSubmit` knows its form owner. */
+const CartDestinationFormContext = createContext(false);
+const DEFAULT_COUNTRY = "BRA";
+/** Whether the country's rules refuse the value. A country the library does not cover refuses nothing. */
+function isPostalCodeRefused(value, rules) {
+	if (!rules?.covered) return false;
+	return validateAddress({ postalCode: value.trim() }, rules).postalCode !== void 0;
+}
+/** The form the write sends and the comparison uses: the country's own, else the trimmed text. */
+function toStoredPostalCode(value, rules) {
+	return rules ? normalizePostalCode(value, rules) : value.trim();
+}
+function isDraftSubmittable(draft, current, rules) {
+	if (draft.trim() === "" || isPostalCodeRefused(draft, rules)) return false;
+	return toStoredPostalCode(draft, rules) !== toStoredPostalCode(current ?? "", rules);
+}
+const CartDestinationRootDefinition = defineComponent({
+	name: "CartDestinationRoot",
+	importPath: "@vtex/faststore/components",
+	component: CartDestinationRoot,
+	fragment,
+	fetchStrategy: "reactive",
+	providesContext: "cartDestination",
+	actions: { shipping: ["setAddress"] },
+	editor: {
+		label: "Cart Destination Root",
+		category: "content"
+	},
+	schema: { defaultCountry: {
+		type: "string",
+		default: "BRA",
+		label: "Default country (ISO alpha-3)"
+	} },
+	guideline: "Where the cart is delivered, with a postal-code-only form that writes the cart destination so the free-shipping bar follows. Compose CartDestinationRead (CartDestinationValue, CartDestinationUnset, CartDestinationChange) for read mode and CartDestinationForm (PostalCodeControl, Submit, Cancel, Error) for edit mode. Starts in read mode; the store cannot open edit mode from outside. See cart-destination.md."
+});
+const CartDestinationReadDefinition = defineComponent({
+	name: "CartDestinationRead",
+	importPath: "@vtex/faststore/components",
+	component: CartDestinationRead,
+	requiresContext: "cartDestination",
+	editor: {
+		label: "Cart Destination Read",
+		category: "layout"
+	},
+	schema: {},
+	guideline: "Wraps what read mode shows: the value, the invitation when no destination is set, and the change control. Renders nothing while edit mode is open. Must be inside CartDestinationRoot."
+});
+const CartDestinationValueDefinition = defineComponent({
+	name: "CartDestinationValue",
+	importPath: "@vtex/faststore/components",
+	component: CartDestinationValue,
+	content: CartDestinationValueContent,
+	requiresContext: "cartDestination",
+	editor: {
+		label: "Cart Destination Value",
+		category: "content"
+	},
+	schema: { prefix: {
+		type: "string",
+		label: "Prefix"
+	} },
+	guideline: "The cart destination as postal code, city and state, each in its own element. Renders nothing while loading or when no destination is set. Must be inside CartDestinationRoot."
+});
+const CartDestinationUnsetDefinition = defineComponent({
+	name: "CartDestinationUnset",
+	importPath: "@vtex/faststore/components",
+	component: CartDestinationUnset,
+	requiresContext: "cartDestination",
+	editor: {
+		label: "Cart Destination Unset",
+		category: "content"
+	},
+	schema: {},
+	guideline: "A button that opens edit mode when pressed, like CartDestinationChange, with aria-expanded tied to the mode. Renders only once the destination resolved and none is set. Its children are the store-authored invitation (for example an Icon and a Text reading \"Informe seu CEP\"). Never place a CartDestinationChange, a link or another button inside it: a button cannot hold another. The regular CartDestinationChange repeats it, so the store usually hides that one while this shows. Place it within CartDestinationRead. Must be inside CartDestinationRoot."
+});
+const CartDestinationChangeDefinition = defineComponent({
+	name: "CartDestinationChange",
+	importPath: "@vtex/faststore/components",
+	component: CartDestinationChange,
+	content: CartDestinationChangeContent,
+	requiresContext: "cartDestination",
+	editor: {
+		label: "Cart Destination Change",
+		category: "action"
+	},
+	schema: { label: {
+		type: "string",
+		label: "Button label"
+	} },
+	guideline: "Button that opens edit mode, styled as a link by the store. Place it inside CartDestinationRead. Must be inside CartDestinationRoot."
+});
+const CartDestinationFormDefinition = defineComponent({
+	name: "CartDestinationForm",
+	importPath: "@vtex/faststore/components",
+	component: CartDestinationForm,
+	requiresContext: "cartDestination",
+	editor: {
+		label: "Cart Destination Form",
+		category: "action"
+	},
+	schema: {},
+	guideline: "Edit mode: renders only while editing and routes Enter to the submit. Holds the postal code control, Submit, Cancel and Error, and any help text the store places. Must be inside CartDestinationRoot."
+});
+const CartDestinationPostalCodeControlDefinition = defineComponent({
+	name: "CartDestinationPostalCodeControl",
+	importPath: "@vtex/faststore/components",
+	component: CartDestinationPostalCodeControl,
+	requiresContext: "cartDestination",
+	editor: {
+		label: "Cart Destination Postal Code Control",
+		category: "content"
+	},
+	schema: {
+		label: {
+			type: "string",
+			label: "Label"
+		},
+		placeholder: {
+			type: "string",
+			label: "Placeholder"
+		},
+		invalidMessage: {
+			type: "string",
+			label: "Invalid-value message"
+		}
+	},
+	guideline: "The postal code input of edit mode, empty each time edit mode opens and focused once enabled. A plain text field whose limits and example come from the cart country's postal code rules; it stays disabled while they load, and a country the rules do not cover takes free text. Must be inside CartDestinationForm."
+});
+const CartDestinationSubmitDefinition = defineComponent({
+	name: "CartDestinationSubmit",
+	importPath: "@vtex/faststore/components",
+	component: CartDestinationSubmit,
+	content: CartDestinationSubmitContent,
+	requiresContext: "cartDestination",
+	editor: {
+		label: "Cart Destination Submit",
+		category: "action"
+	},
+	schema: {
+		label: {
+			type: "string",
+			label: "Button label"
+		},
+		pendingLabel: {
+			type: "string",
+			label: "Pending label"
+		}
+	},
+	guideline: "Writes the typed postal code. Disabled until the country's rules have loaded, the typed code is valid for the country (any text for a country the rules do not cover) and different from the current one, and while a write is pending (aria-busy). Must be inside CartDestinationForm."
+});
+const CartDestinationCancelDefinition = defineComponent({
+	name: "CartDestinationCancel",
+	importPath: "@vtex/faststore/components",
+	component: CartDestinationCancel,
+	content: CartDestinationCancelContent,
+	requiresContext: "cartDestination",
+	editor: {
+		label: "Cart Destination Cancel",
+		category: "action"
+	},
+	schema: { label: {
+		type: "string",
+		label: "Button label"
+	} },
+	guideline: "Closes edit mode, discards what was typed and writes nothing. Disabled while a write is pending. Must be inside CartDestinationForm."
+});
+const CartDestinationErrorDefinition = defineComponent({
+	name: "CartDestinationError",
+	importPath: "@vtex/faststore/components",
+	component: CartDestinationError,
+	content: CartDestinationErrorContent,
+	requiresContext: "cartDestination",
+	editor: {
+		label: "Cart Destination Error",
+		category: "content"
+	},
+	schema: {},
+	guideline: "Announces why the destination write failed, as an alert, and renders nothing otherwise. Words each error code from its $content: invalidPostalCodeMessage for a postal code the server rejects, genericMessage for a network failure and every refusal the shopper cannot act on. A postal code the platform refuses upstream also reaches the client as a network failure, so write genericMessage to cover it. An unknown code also shows genericMessage. Must be inside CartDestinationForm."
+});
+/**
+* Reads the cart destination reactively and publishes it, the edit-mode flag, the draft and the write
+* state as `cartDestination` context.
+*
+* The destination is never copied into state: the Value renders only what `$data` resolves, and a
+* successful write updates it solely by the mutation payload normalizing into the Apollo cache. A
+* rejected write therefore needs no rollback.
+*/
+function CartDestinationRoot({ defaultCountry = DEFAULT_COUNTRY, $data: $dataProp, $actions: $actionsProp, className, children, ...props }) {
+	const $data = useDataOverride($dataProp);
+	const $actions = useActionsOverride($actionsProp);
+	const address = $data?.address ?? null;
+	const { loading: rootLoading } = useContext(ReactiveRootContext);
+	const postalCode = address?.postalCode ?? null;
+	const loading = rootLoading && postalCode == null;
+	const country = address?.country ?? defaultCountry;
+	const [editing, setEditing] = useState(false);
+	const [draft, setDraft] = useState("");
+	const [pending, setPending] = useState(false);
+	const [errors, setErrors] = useState([]);
+	const [invalid, setInvalid] = useState(false);
+	const inFlightRef = useRef(false);
+	const rootRef = useRef(null);
+	const wasEditingRef = useRef(false);
+	/**
+	* Leaving edit mode moves focus back to the control that opens it, which only mounts once read mode
+	* renders again, hence an effect on the flag rather than a call at the event. With no destination that
+	* is the invitation; the change control is hidden then, so the invitation wins when both exist.
+	* Opening it focuses the field, which `CartDestinationPostalCodeControl` does once the rules have loaded and enabled it.
+	*/
+	useEffect(() => {
+		if (wasEditingRef.current === editing) return;
+		wasEditingRef.current = editing;
+		if (editing) return;
+		(rootRef.current?.querySelector("[data-fs-cart-destination-unset]") ?? rootRef.current?.querySelector("[data-fs-cart-destination-change]"))?.focus();
+	}, [editing]);
+	const [loaded, setLoaded] = useState(null);
+	useEffect(() => {
+		if (!editing) {
+			setLoaded((current) => current?.rules ? current : null);
+			return;
+		}
+		let active = true;
+		loadCountryRules(country).then((rules) => {
+			if (active) setLoaded({
+				country,
+				rules
+			});
+		}, (error) => {
+			if (!active) return;
+			console.warn("[CartDestinationRoot] country rules failed to load", {
+				country,
+				error: loggableErrorName(error)
+			});
+			setLoaded({
+				country,
+				rules: null
+			});
+		});
+		return () => {
+			active = false;
+		};
+	}, [editing, country]);
+	const rulesLoading = editing && loaded?.country !== country;
+	const rules = loaded?.country === country ? loaded.rules : null;
+	const canSubmit = !pending && !rulesLoading && isDraftSubmittable(draft, postalCode, rules);
+	const startEditing = useCallback(() => setEditing(true), []);
+	const cancel = useCallback(() => {
+		setEditing(false);
+		setDraft("");
+		setErrors([]);
+		setInvalid(false);
+	}, []);
+	/** Typing is the shopper's answer to a refusal, so the message and the invalid flag go with it. */
+	const updateDraft = useCallback((value) => {
+		setDraft(value);
+		setErrors((current) => current.length === 0 ? current : []);
+		setInvalid(false);
+	}, []);
+	const submit = useCallback(() => {
+		if (inFlightRef.current) return;
+		const setAddress = $actions?.shipping?.setAddress;
+		if (!setAddress) return;
+		if (!canSubmit) {
+			setInvalid(true);
+			return;
+		}
+		inFlightRef.current = true;
+		setPending(true);
+		setErrors([]);
+		setInvalid(false);
+		awaitCartWrites().then(() => setAddress({
+			postalCode: toStoredPostalCode(draft, rules),
+			country
+		})).then((writeErrors) => {
+			if (writeErrors.length > 0) {
+				setErrors(writeErrors);
+				return;
+			}
+			setEditing(false);
+			setDraft("");
+		}).finally(() => {
+			inFlightRef.current = false;
+			setPending(false);
+		});
+	}, [
+		$actions,
+		canSubmit,
+		draft,
+		country,
+		rules
+	]);
+	const value = useMemo(() => ({
+		postalCode,
+		city: address?.city ?? null,
+		state: address?.state ?? null,
+		country,
+		loading,
+		editing,
+		startEditing,
+		cancel,
+		draft,
+		setDraft: updateDraft,
+		rules,
+		rulesLoading,
+		canSubmit,
+		pending,
+		errors,
+		invalid,
+		submit
+	}), [
+		postalCode,
+		address?.city,
+		address?.state,
+		country,
+		loading,
+		editing,
+		startEditing,
+		cancel,
+		draft,
+		updateDraft,
+		rules,
+		rulesLoading,
+		canSubmit,
+		pending,
+		errors,
+		invalid,
+		submit
+	]);
+	return /* @__PURE__ */ jsx(CartDestinationContextInternal, {
+		value,
+		children: /* @__PURE__ */ jsx("div", {
+			...props,
+			ref: rootRef,
+			className,
+			"data-fs-cart-destination": "",
+			...pending ? { "data-fs-cart-destination-pending": "" } : {},
+			...editing ? { "data-fs-cart-destination-editing": "" } : {},
+			children
+		})
+	});
+}
+function CartDestinationRead({ className, children, ...props }) {
+	const { editing } = useCartDestination();
+	if (editing) return null;
+	return /* @__PURE__ */ jsx("div", {
+		...props,
+		className,
+		"data-fs-cart-destination-read": "",
+		children
+	});
+}
+function pickAuthored(content, prop) {
+	if (content?.trim()) return content;
+	if (prop?.trim()) return prop;
+	return null;
+}
+function CartDestinationValue({ prefix, $content, className, ...props }) {
+	const { postalCode, city, state, loading } = useCartDestination();
+	if (loading || postalCode == null) return null;
+	const resolvedPrefix = pickAuthored($content?.prefix, prefix);
+	return /* @__PURE__ */ jsxs("span", {
+		...props,
+		className,
+		"data-fs-cart-destination-value": "",
+		children: [
+			resolvedPrefix ? /* @__PURE__ */ jsx("span", {
+				"data-fs-cart-destination-value-prefix": "",
+				children: resolvedPrefix
+			}) : null,
+			resolvedPrefix ? " " : null,
+			/* @__PURE__ */ jsx("span", {
+				"data-fs-cart-destination-value-postal-code": "",
+				children: postalCode
+			}),
+			city || state ? " · " : null,
+			city ? /* @__PURE__ */ jsx("span", {
+				"data-fs-cart-destination-value-city": "",
+				children: city
+			}) : null,
+			city && state ? ", " : null,
+			state ? /* @__PURE__ */ jsx("span", {
+				"data-fs-cart-destination-value-state": "",
+				children: state
+			}) : null
+		]
+	});
+}
+function CartDestinationUnset({ className, children, onClick, ...props }) {
+	const { postalCode, loading, editing, startEditing } = useCartDestination();
+	if (loading || postalCode != null) return null;
+	return /* @__PURE__ */ jsx("button", {
+		...props,
+		type: "button",
+		onClick: (event) => {
+			onClick?.(event);
+			startEditing();
+		},
+		"aria-expanded": editing,
+		className,
+		"data-fs-cart-destination-unset": "",
+		children
+	});
+}
+function CartDestinationChange({ label, $content, className, children, ...props }) {
+	const { editing, startEditing } = useCartDestination();
+	const resolvedLabel = pickAuthored($content?.label, label);
+	return /* @__PURE__ */ jsx("button", {
+		...props,
+		type: "button",
+		onClick: startEditing,
+		"aria-expanded": editing,
+		className,
+		"data-fs-cart-destination-change": "",
+		children: children ?? resolvedLabel
+	});
+}
+function CartDestinationForm({ className, children, ...props }) {
+	const { editing, submit } = useCartDestination();
+	if (!editing) return null;
+	return /* @__PURE__ */ jsx(CartDestinationFormContext, {
+		value: true,
+		children: /* @__PURE__ */ jsx("form", {
+			...props,
+			className,
+			"data-fs-cart-destination-form": "",
+			onKeyDown: (event) => {
+				if (event.key !== "Enter" || !(event.target instanceof HTMLInputElement)) return;
+				event.preventDefault();
+				submit();
+			},
+			onSubmit: (event) => {
+				event.preventDefault();
+				submit();
+			},
+			children
+		})
+	});
+}
+function CartDestinationPostalCodeControl({ className, label, placeholder, invalidMessage }) {
+	const { draft, setDraft, errors, invalid, pending, rules, rulesLoading } = useCartDestination();
+	const rootRef = useRef(null);
+	const focusedOnOpenRef = useRef(false);
+	const [blurInvalid, setBlurInvalid] = useState(false);
+	const refused = errors.length > 0;
+	const descriptor = useMemo(() => rules ? addressFields(rules, {}).find(({ name }) => name === "postalCode") : void 0, [rules]);
+	/** The country's example postal code: address data, not a message. */
+	const example = descriptor?.placeholder?.values.example;
+	/** A disabled input cannot take focus, so opening edit mode focuses the field once the rules enable it. */
+	useEffect(() => {
+		if (rulesLoading || focusedOnOpenRef.current) return;
+		focusedOnOpenRef.current = true;
+		rootRef.current?.querySelector("[data-fs-postal-code-field-input]")?.focus();
+	}, [rulesLoading]);
+	/**
+	* Disabling the input while the write is in flight drops focus to the body, so a refusal otherwise
+	* lands with nothing focused. Waits for `pending` to clear: focusing a disabled input is a no-op.
+	*/
+	useEffect(() => {
+		if (!refused || pending) return;
+		rootRef.current?.querySelector("[data-fs-postal-code-field-input]")?.focus();
+	}, [refused, pending]);
+	function handleChange(event) {
+		setBlurInvalid(false);
+		setDraft(event.target.value);
+	}
+	const showInvalid = invalid || refused || blurInvalid;
+	return /* @__PURE__ */ jsxs(Field.Root, {
+		ref: rootRef,
+		className,
+		name: "postalCode",
+		invalid: showInvalid,
+		disabled: pending || rulesLoading,
+		"data-fs-postal-code-field": "",
+		"data-fs-cart-destination-postal-code-control": "",
+		children: [
+			label ? /* @__PURE__ */ jsx(Field.Label, {
+				"data-fs-postal-code-field-label": "",
+				children: label
+			}) : null,
+			/* @__PURE__ */ jsx(Input, {
+				"data-fs-postal-code-field-input": "",
+				type: "text",
+				name: "postalCode",
+				autoComplete: "postal-code",
+				value: draft,
+				maxLength: descriptor?.maxLength,
+				inputMode: descriptor?.inputMode,
+				placeholder: placeholder ?? example,
+				onChange: handleChange,
+				onBlur: () => setBlurInvalid(draft.trim() !== "" && isPostalCodeRefused(draft, rules))
+			}),
+			showInvalid && !refused && invalidMessage ? /* @__PURE__ */ jsx(Field.Error, {
+				match: true,
+				"data-fs-postal-code-field-error": "",
+				children: invalidMessage
+			}) : null
+		]
+	});
+}
+function CartDestinationSubmit({ label, pendingLabel, $content, className, children, ...props }) {
+	const { canSubmit, pending, submit } = useCartDestination();
+	const inForm = useContext(CartDestinationFormContext);
+	const resolvedLabel = pickAuthored($content?.label, label);
+	const resolvedPendingLabel = pickAuthored($content?.pendingLabel, pendingLabel);
+	return /* @__PURE__ */ jsx("button", {
+		...props,
+		type: inForm ? "submit" : "button",
+		onClick: inForm ? props.onClick : submit,
+		disabled: !canSubmit || props.disabled,
+		"aria-busy": pending || void 0,
+		className,
+		"data-fs-cart-destination-submit": "",
+		...pending ? { "data-fs-cart-destination-submit-pending": "" } : {},
+		children: children ?? (pending ? resolvedPendingLabel ?? resolvedLabel : resolvedLabel)
+	});
+}
+function CartDestinationCancel({ label, $content, className, children, ...props }) {
+	const { cancel, pending } = useCartDestination();
+	const resolvedLabel = pickAuthored($content?.label, label);
+	return /* @__PURE__ */ jsx("button", {
+		...props,
+		type: "button",
+		onClick: cancel,
+		disabled: pending || props.disabled,
+		className,
+		"data-fs-cart-destination-cancel": "",
+		children: children ?? resolvedLabel
+	});
+}
+/**
+* The message for each code `shippingAddressUpdate` can return, plus the client-minted transport failure.
+* This form writes only the postal code and the country, so every other refusal is one the shopper
+* cannot act on here.
+*/
+const CART_DESTINATION_ERROR_FIELDS = {
+	INVALID_POSTAL_CODE: "invalidPostalCodeMessage",
+	INVALID_ADDRESS: "genericMessage",
+	INVALID_COUNTRY_CODE: "genericMessage",
+	MISSING_RECIPIENT_NAME: "genericMessage",
+	INVALID_SAVED_ADDRESS_ID: "genericMessage",
+	MISSING_CART_CONTEXT: "genericMessage",
+	CART_NOT_FOUND: "genericMessage",
+	NETWORK_ERROR: "genericMessage"
+};
+function CartDestinationError({ $content, $locale, className, ...props }) {
+	const { errors } = useCartDestination();
+	const { format } = useMessageFormatter(CartDestinationErrorContent, $content);
+	const [firstError] = errors;
+	if (!firstError) return null;
+	return /* @__PURE__ */ jsx("div", {
+		...props,
+		role: "alert",
+		className,
+		"data-fs-cart-destination-error": "",
+		children: formatErrorCode(CartDestinationErrorContent, CART_DESTINATION_ERROR_FIELDS, firstError, format, "genericMessage")
+	});
+}
+const CartDestination = {
+	Root: CartDestinationRoot,
+	Read: CartDestinationRead,
+	Value: CartDestinationValue,
+	Unset: CartDestinationUnset,
+	Change: CartDestinationChange,
+	Form: CartDestinationForm,
+	PostalCodeControl: CartDestinationPostalCodeControl,
+	Submit: CartDestinationSubmit,
+	Cancel: CartDestinationCancel,
+	Error: CartDestinationError
+};
+//#endregion
+export { CART_DESTINATION_ERROR_FIELDS, CartDestination, CartDestinationCancel, CartDestinationCancelContent, CartDestinationCancelDefinition, CartDestinationChange, CartDestinationChangeContent, CartDestinationChangeDefinition, CartDestinationError, CartDestinationErrorContent, CartDestinationErrorDefinition, CartDestinationForm, CartDestinationFormDefinition, CartDestinationPostalCodeControl, CartDestinationPostalCodeControlDefinition, CartDestinationRead, CartDestinationReadDefinition, CartDestinationRoot, CartDestinationRootDefinition, CartDestinationSubmit, CartDestinationSubmitContent, CartDestinationSubmitDefinition, CartDestinationUnset, CartDestinationUnsetDefinition, CartDestinationValue, CartDestinationValueContent, CartDestinationValueDefinition, useCartDestination };
+
+//# sourceMappingURL=cart-destination.js.map