@vtex/faststore 0.0.1

package/dist/matter/cart/cart.d.ts

@@ -0,0 +1,312 @@
+import { ContentValue } from "../../core/dist/define-content-type.js";
+import { ComponentDefinition } from "../../core/dist/define-component.js";
+import "../../core/dist/index.js";
+import "../../sdk/generated/graphql.js";
+import { CartEntity } from "../../sdk/cart/operations.js";
+import { ComponentActions } from "../../sdk/actions/types.js";
+import { NavigationLinkProps } from "../../particles/navigation-link/navigation-link.js";
+import { ComponentPropsWithRef, ReactNode } from "react";
+import { ErrorLike } from "@apollo/client";
+//#region src/matter/cart/cart.d.ts
+export declare const CartDisclaimerContent: {
+  readonly id: "cart-disclaimer";
+  readonly title: "Cart Disclaimer";
+  readonly description: "Conditions, limits, or legal wording shown in the cart before checkout.";
+  readonly schema: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["text"];
+    readonly properties: {
+      readonly text: {
+        readonly type: "string";
+        readonly minLength: 1;
+        readonly title: "Disclaimer text";
+      };
+    };
+  };
+};
+export declare const CartCheckoutLabelContent: {
+  readonly id: "cart-checkout-label";
+  readonly title: "Cart Checkout Label";
+  readonly description: "Editorial label for the checkout call to action.";
+  readonly schema: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["label"];
+    readonly properties: {
+      readonly label: {
+        readonly type: "string";
+        readonly minLength: 1;
+        readonly title: "Checkout label";
+      };
+    };
+  };
+};
+export type CartDataContextValue = Readonly<{
+  cart: CartEntity | null;
+  /**
+   * Cart query error surfaced by the reactive root. `cart` is non-null on the server (`Cart!`),
+   * so `cart: null` + `error` means the fetch failed — not an empty cart.
+   */
+  error: ErrorLike | null;
+}>;
+export type CartRootProps = ComponentPropsWithRef<'div'> & {
+  /**
+   * Cart entity slice forwarded by the reactive runtime (`ReactiveDataProvider`) — it is the value
+   * of the `cart` top-level field on `CartData on Query`, not the wrapping `{ cart: … }` shape.
+   * Receives `null` when the cart is not yet seeded (e.g. server returned no cart for the current
+   * session, or `orderFormIdVar` is still null).
+   */
+  $data?: CartEntity | null;
+};
+export type CartListProps = ComponentPropsWithRef<'div'> & {
+  /** Number of CartItemSkeleton rows to render while the cart is still loading (FR-7). */
+  skeletonCount?: number;
+};
+export type CartTotalProps = ComponentPropsWithRef<'span'> & {
+  label?: string;
+};
+export type CartCountProps = ComponentPropsWithRef<'span'> & {
+  template?: string;
+};
+export type CartErrorProps = ComponentPropsWithRef<'div'>;
+export type CartGoCheckoutProps = Omit<NavigationLinkProps, 'href' | '$content'> & {
+  href?: string;
+  /** Authored fallback for the button label; `children` still works for stores that label it there. */
+  label?: string;
+  /** Merchant-authored label, sliced from the page/layout content entry; wins over the label prop and
+   *  over children. Absent in a non-CMS store — the props are the fallback. */
+  $content?: ContentValue<typeof CartCheckoutLabelContent>;
+  /** Injected by the compiler from `actions: { cart: ['validate'] }`; the stock-validation write surface. */
+  $actions?: ComponentActions;
+};
+export type CartCouponFormProps = ComponentPropsWithRef<'form'> & {
+  placeholder?: string;
+  applyLabel?: string;
+  /** Injected by the compiler from `actions: { cart: ['applyCoupon'] }`; the cart write surface. */
+  $actions?: ComponentActions;
+};
+export type CartAppliedCouponsProps = ComponentPropsWithRef<'div'> & {
+  /** Injected by the compiler from `actions: { cart: ['removeCoupon'] }`; forwarded to the built-in chip's remove control. */
+  $actions?: ComponentActions;
+};
+export type CartCouponRemoveProps = ComponentPropsWithRef<'button'> & {
+  /**
+   * The coupon code this control removes. Normally supplied by the enclosing CartAppliedCoupons
+   * chip via context; pass it explicitly to override or to use the control standalone.
+   */
+  code?: string;
+  /** Injected by the compiler from `actions: { cart: ['removeCoupon'] }`; the cart write surface. */
+  $actions?: ComponentActions;
+};
+export type CartCouponErrorProps = ComponentPropsWithRef<'div'>;
+export type CartDisclaimerProps = ComponentPropsWithRef<'p'> & {
+  /**
+   * Authored fallback, rendered when no CMS entry supplies the notice. Ranks below `children`:
+   * `children ?? $content?.text ?? text`.
+   */
+  text?: string;
+  /** Injected by the compiler, sliced from the page's or layout's composite content entry. */
+  $content?: ContentValue<typeof CartDisclaimerContent>;
+};
+export type CartCheckoutGuardProps = ComponentPropsWithRef<'div'>;
+export type CartLoadingProps = ComponentPropsWithRef<'div'>;
+export type CartEmptyProps = ComponentPropsWithRef<'div'>;
+export type CartFilledProps = ComponentPropsWithRef<'div'>;
+export type CartEmptyMessageProps = ComponentPropsWithRef<'p'> & {
+  /** Authored fallback, rendered when no CMS entry supplies the message. */
+  text?: string;
+  /** Injected by the compiler, sliced from the page's or layout's composite content entry. */
+  $content?: ContentValue<typeof CartEmptyMessageContent>;
+};
+export type CartContinueShoppingProps = ComponentPropsWithRef<'button'> & {
+  /** Authored fallback, rendered when no CMS entry supplies the label. Children win over both. */
+  label?: string;
+  /** Injected by the compiler, sliced from the page's or layout's composite content entry. */
+  $content?: ContentValue<typeof CartContinueShoppingContent>;
+};
+export type CartUnavailableCountProps = ComponentPropsWithRef<'span'> & {
+  /** Output format; `{count}` is replaced by the integer count. */
+  template?: string;
+};
+export type CartRemoveUnavailableProps = ComponentPropsWithRef<'button'> & {
+  /** Injected by the compiler from `actions: { cart: ['removeItems'] }`; the cart write surface. */
+  $actions?: ComponentActions;
+};
+export type CartOpenOnAddProps = {
+  children?: ReactNode;
+  /** Injected by the compiler from `actions: { cart: ['validate'] }`; drives the validate-on-open call. */
+  $actions?: ComponentActions;
+};
+export type CartRedirectOnAddProps = {
+  href?: string;
+  children?: ReactNode;
+};
+export declare const CartDataContext: React.Context<CartDataContextValue>;
+/**
+ * Read the current cart entity and query error from the nearest `CartRoot`. Throws when called
+ * outside a `CartRoot` subtree.
+ *
+ * Cart *writes* no longer flow through this context — they are dispatched via the compiler-injected
+ * `$actions.cart.*` prop (the `cart` action namespace), which reads/writes the cache directly and
+ * needs no `CartRoot` ancestor (specs/actions.md, ADR-0010). This hook is reads only.
+ */
+export declare function useCart(): CartDataContextValue;
+export declare const CartRootDefinition: ComponentDefinition<CartRootProps>;
+export declare const CartListDefinition: ComponentDefinition<CartListProps>;
+export declare const CartTotalDefinition: ComponentDefinition<CartTotalProps>;
+export declare const CartCountDefinition: ComponentDefinition<CartCountProps>;
+export declare const CartErrorDefinition: ComponentDefinition<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>>;
+export declare const CartGoCheckoutDefinition: ComponentDefinition<CartGoCheckoutProps>;
+export declare const CartCouponFormDefinition: ComponentDefinition<CartCouponFormProps>;
+export declare const CartAppliedCouponsDefinition: ComponentDefinition<CartAppliedCouponsProps>;
+export declare const CartCouponRemoveDefinition: ComponentDefinition<CartCouponRemoveProps>;
+export declare const CartCouponErrorDefinition: ComponentDefinition<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>>;
+export declare function CartRoot({ $data: $dataProp, className, children, ...props }: CartRootProps): import("react/jsx-runtime").JSX.Element;
+export declare function CartList({ className, children, skeletonCount, ...props }: CartListProps): import("react/jsx-runtime").JSX.Element;
+export declare function CartTotal({ label, className, children, ...props }: CartTotalProps): import("react/jsx-runtime").JSX.Element;
+export declare function CartCount({ className, children, template, ...props }: CartCountProps): import("react/jsx-runtime").JSX.Element;
+export declare function CartError({ className, children, ...props }: CartErrorProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function CartGoCheckout({ href, label, className, children, onClick, $content, $actions, ...props }: CartGoCheckoutProps): import("react/jsx-runtime").JSX.Element;
+export declare function CartCouponForm({ placeholder, applyLabel, className, children, onSubmit, $actions, ...props }: CartCouponFormProps): import("react/jsx-runtime").JSX.Element;
+export declare function CartAppliedCoupons({ className, children, $actions, ...props }: CartAppliedCouponsProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function CartCouponRemove({ code, className, children, onClick, $actions, ...props }: CartCouponRemoveProps): import("react/jsx-runtime").JSX.Element;
+export declare function CartCouponError({ className, children, ...props }: CartCouponErrorProps): import("react/jsx-runtime").JSX.Element | null;
+export declare const CartCheckoutGuardDefinition: ComponentDefinition<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>>;
+export declare const CartLoadingDefinition: ComponentDefinition<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>>;
+export declare const CartEmptyDefinition: ComponentDefinition<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>>;
+export declare const CartFilledDefinition: ComponentDefinition<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>>;
+export declare const CartUnavailableCountDefinition: ComponentDefinition<CartUnavailableCountProps>;
+export declare const CartRemoveUnavailableDefinition: ComponentDefinition<CartRemoveUnavailableProps>;
+export declare function CartCheckoutGuard({ className, children, ...props }: CartCheckoutGuardProps): import("react/jsx-runtime").JSX.Element;
+export declare function CartUnavailableCount({ className, children, template, ...props }: CartUnavailableCountProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function CartRemoveUnavailable({ className, children, onClick, $actions, ...props }: CartRemoveUnavailableProps): import("react/jsx-runtime").JSX.Element | null;
+export declare const CartOpenOnAddDefinition: ComponentDefinition<CartOpenOnAddProps>;
+export declare const CartRedirectOnAddDefinition: ComponentDefinition<CartRedirectOnAddProps>;
+/**
+ * Makes the wrapped mini-cart `DrawerRoot` controlled by `miniCartOpenVar` and opens it on each
+ * add-success pulse. `miniCartOpenVar` is the single source of truth: the pulse-driven open, the
+ * header trigger (`onOpenChange(true)`), and manual close (`onOpenChange(false)`) all route through
+ * it, so the trigger and manual dismissal keep working under controlled mode. Context-free — it
+ * reads reactive vars and needs no `CartRoot` ancestor (ADR-0010). Expects a single `DrawerRoot`
+ * child; the wiring is encapsulated here, never exposed as authorable drawer props.
+ */
+export declare function CartOpenOnAdd({ children, $actions }: CartOpenOnAddProps): ReactNode;
+/**
+ * Navigates a no-mini-cart store to checkout after a successful add. Keys a `useEffect` on the
+ * add-success pulse, which `addItem` increments only on the clean branch after the `await`, so the
+ * redirect is post-resolve and success-gated. The initial `0` is ignored, so a fresh mount never
+ * navigates. Context-free — no `CartRoot` ancestor (ADR-0010). Renders its passthrough children (or
+ * nothing); it carries no drawer.
+ */
+export declare function CartRedirectOnAdd({ href, children }: CartRedirectOnAddProps): ReactNode;
+export declare function CartLoading({ className, children, ...props }: CartLoadingProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function CartEmpty({ className, children, ...props }: CartEmptyProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function CartFilled({ className, children, ...props }: CartFilledProps): import("react/jsx-runtime").JSX.Element | null;
+export declare const CartDisclaimerDefinition: ComponentDefinition<CartDisclaimerProps>;
+export declare function CartDisclaimer({ text, $content, className, children, ...props }: CartDisclaimerProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function CartItemSkeleton({ className, ...props }: ComponentPropsWithRef<'div'>): import("react/jsx-runtime").JSX.Element;
+export declare const CartAlertContent: {
+  readonly id: "cart-alert";
+  readonly title: "Cart Alert";
+  readonly description: "Merchant notice shown at the top of the mini-cart overlay.";
+  readonly schema: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly properties: {
+      readonly text: {
+        readonly type: "string";
+        readonly minLength: 1;
+        readonly title: "Message";
+      };
+      readonly icon: {
+        readonly type: "string";
+        readonly enum: readonly ["bell", "bell-ringing", "tag", "shopping-cart", "map-pin", "star"];
+        readonly title: "Icon";
+      };
+      readonly iconUrl: {
+        readonly type: "string";
+        readonly format: "uri";
+        readonly title: "Custom icon";
+        readonly widget: {
+          readonly 'ui:widget': "media-gallery";
+        };
+      };
+      readonly iconAlt: {
+        readonly type: "string";
+        readonly title: "Custom icon alt text";
+      };
+    };
+  };
+};
+/**
+ * The sprite names the CMS channel admits. Exported because a store whose merchants pick the icon
+ * has to list them under `icons.include` for the glyph to reach the route sprite — one import there
+ * instead of six retyped strings. Read off the model so the two cannot drift apart.
+ */
+export declare const CART_ALERT_ICON_NAMES: readonly ["bell", "bell-ringing", "tag", "shopping-cart", "map-pin", "star"];
+export type CartAlertRootProps = ComponentPropsWithRef<'div'> & {
+  /** Authored fallback message. No default: an invented one would ship copy no merchant wrote. */
+  text?: string;
+  /** Authored fallback sprite name. Unbounded — the compiler resolves it or fails the build. */
+  icon?: string;
+  /** Authored fallback uploaded glyph; wins over `icon` when both resolve. */
+  iconUrl?: string;
+  /** Alt text for the uploaded glyph; empty (decorative) when unset. */
+  iconAlt?: string;
+  /** Merchant-authored copy, sliced from the layout's composite entry; wins field by field. */
+  $content?: ContentValue<typeof CartAlertContent>;
+};
+/** The glyph renders as an `img` or an `svg` depending on the channel, so it takes only what both accept. */
+export type CartAlertIconProps = {
+  className?: string;
+};
+export type CartAlertTextProps = ComponentPropsWithRef<'span'>;
+export declare const CartAlertRootDefinition: ComponentDefinition<CartAlertRootProps>;
+export declare const CartAlertIconDefinition: ComponentDefinition<CartAlertIconProps>;
+export declare const CartAlertTextDefinition: ComponentDefinition<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>>;
+export declare function CartAlertRoot({ text, icon, iconUrl, iconAlt, className, children, $content, ...props }: CartAlertRootProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function CartAlertIcon({ className }: Readonly<CartAlertIconProps>): import("react/jsx-runtime").JSX.Element | null;
+export declare function CartAlertText({ className, children, ...props }: CartAlertTextProps): import("react/jsx-runtime").JSX.Element;
+export declare const CartEmptyMessageContent: {
+  readonly id: "cart-empty-message";
+  readonly title: "Cart Empty Message";
+  readonly description: "Message shown in the cart overlay when the cart has no items.";
+  readonly schema: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["text"];
+    readonly properties: {
+      readonly text: {
+        readonly type: "string";
+        readonly minLength: 1;
+        readonly title: "Empty cart message";
+        readonly default: "Your cart is empty";
+      };
+    };
+  };
+};
+export declare const CartContinueShoppingContent: {
+  readonly id: "cart-continue-shopping";
+  readonly title: "Cart Continue Shopping";
+  readonly description: "Label for the control that dismisses the cart overlay and returns the shopper to browsing.";
+  readonly schema: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["label"];
+    readonly properties: {
+      readonly label: {
+        readonly type: "string";
+        readonly minLength: 1;
+        readonly title: "Continue shopping label";
+        readonly default: "Continue shopping";
+      };
+    };
+  };
+};
+export declare const CartEmptyMessageDefinition: ComponentDefinition<CartEmptyMessageProps>;
+export declare const CartContinueShoppingDefinition: ComponentDefinition<CartContinueShoppingProps>;
+export declare function CartEmptyMessage({ text, $content, className, ...props }: CartEmptyMessageProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function CartContinueShopping({ label, $content, className, children, ...props }: CartContinueShoppingProps): import("react/jsx-runtime").JSX.Element | null;
+//#endregion
+//# sourceMappingURL=cart.d.ts.map