vlite3 1.4.3 → 1.4.4

package/components/AvatarUploader/AvatarUploader.vue.d.ts

@@ -13,12 +13,12 @@ export interface Props {
     className?: string;
 }
 declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
-    change: (value: FilePickerValue) => any;
     error: (error: string) => any;
+    change: (value: FilePickerValue) => any;
     "update:modelValue": (value: any) => any;
 }, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
-    onChange?: (value: FilePickerValue) => any;
     onError?: (error: string) => any;
+    onChange?: (value: FilePickerValue) => any;
     "onUpdate:modelValue"?: (value: any) => any;
 }>, {
     alt: string;

package/components/Cart/Cart.vue.d.ts

@@ -0,0 +1,27 @@
+import { CartProps, CartCoupon, CartTotals } from './types';
+declare const _default: import('vue').DefineComponent<CartProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    clear: () => any;
+    remove: (itemId: string | number) => any;
+    continue: () => any;
+    "update:quantity": (itemId: string | number, quantity: number) => any;
+    "continue-shopping": () => any;
+    "apply-coupon": (code: string) => any;
+    "remove-coupon": () => any;
+    "coupon-change": (code: string) => any;
+    "update:coupon": (coupon: CartCoupon) => any;
+    "update:totals": (totals: CartTotals) => any;
+}, string, import('vue').PublicProps, Readonly<CartProps> & Readonly<{
+    onClear?: () => any;
+    onRemove?: (itemId: string | number) => any;
+    onContinue?: () => any;
+    "onUpdate:quantity"?: (itemId: string | number, quantity: number) => any;
+    "onContinue-shopping"?: () => any;
+    "onApply-coupon"?: (code: string) => any;
+    "onRemove-coupon"?: () => any;
+    "onCoupon-change"?: (code: string) => any;
+    "onUpdate:coupon"?: (coupon: CartCoupon) => any;
+    "onUpdate:totals"?: (totals: CartTotals) => any;
+}>, {
+    variant: import('./types').CartVariant;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/components/Cart/CartCouponInput.vue.d.ts

@@ -0,0 +1,32 @@
+import { CartCoupon, CartLabels } from './types';
+/**
+ * Coupon field with all UX states modelled as a discriminated union.
+ *
+ * - idle     → empty input, no validation feedback
+ * - applying → request in flight (spinner, input + button disabled)
+ * - applied  → success state, shows remove action and discount summary
+ * - invalid  → code not recognised (red border + helper text)
+ * - expired  → coupon no longer valid (amber border + helper text)
+ * - error    → generic API error, uses `coupon.message` for helper text
+ *
+ * The parent owns validation logic; the component only renders.
+ */
+type __VLS_Props = {
+    coupon?: CartCoupon;
+    labels: CartLabels;
+    compact?: boolean;
+    readonly?: boolean;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    remove: () => any;
+    apply: (code: string) => any;
+    change: (code: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onRemove?: () => any;
+    onApply?: (code: string) => any;
+    onChange?: (code: string) => any;
+}>, {
+    compact: boolean;
+    readonly: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/components/Cart/CartEmptyState.vue.d.ts

@@ -0,0 +1,17 @@
+import { CartLabels } from './types';
+/**
+ * Empty-cart state, rendered when items.length === 0 (and features.emptyState).
+ * Same look across all variants; the parent controls size via `compact`.
+ */
+type __VLS_Props = {
+    labels: CartLabels;
+    compact?: boolean;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "continue-shopping": () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onContinue-shopping"?: () => any;
+}>, {
+    compact: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/components/Cart/CartLineItem.vue.d.ts

@@ -0,0 +1,29 @@
+import { CartItem, CartFeatures, CartLabels } from './types';
+/**
+ * Internal layout hints — passed by the variant parent to switch presentation.
+ * - 'drawer' : full image, name, sku, variant, qty stepper, price, remove
+ * - 'compact': no image, dense single-line per item (POS / register)
+ * - 'card'   : image + name + variant stacked, controls in a row below
+ * - 'mini'   : single line, name, qty, price; minimal controls
+ */
+type Layout = 'drawer' | 'compact' | 'card' | 'mini';
+type __VLS_Props = {
+    item: CartItem;
+    features: CartFeatures;
+    labels: CartLabels;
+    compact?: boolean;
+    readonly?: boolean;
+    layout?: Layout;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    remove: (itemId: string | number) => any;
+    "update:quantity": (itemId: string | number, quantity: number) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onRemove?: (itemId: string | number) => any;
+    "onUpdate:quantity"?: (itemId: string | number, quantity: number) => any;
+}>, {
+    compact: boolean;
+    readonly: boolean;
+    layout: Layout;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/components/Cart/CartSummary.vue.d.ts

@@ -0,0 +1,29 @@
+import { CartTotals, CartFeatures, CartLabels, CartVariant, CartCoupon } from './types';
+/**
+ * Subtotal / Discount / Estimated Tax / Shipping / Grand Total renderer.
+ * Used by Variant1, Variant2, Variant3. Variant4 inlines its own summary
+ * to preserve the mini-cart look.
+ *
+ * Driven entirely by `features` — every row is conditionally rendered, so
+ * the same component can produce a single-line POS total or a full
+ * e-commerce summary without branching at the call site.
+ *
+ * Accepts the applied `coupon` (optional) so it can render the discount
+ * row as "Discount · WELCOME10" + "−$25.00" / "−10%". Also renders the
+ * free-shipping progress hint ("Add $X more for free shipping") when the
+ * totals carry a `freeShippingProgress` payload.
+ */
+type __VLS_Props = {
+    totals: CartTotals;
+    features: CartFeatures;
+    labels: CartLabels;
+    compact?: boolean;
+    variant?: CartVariant;
+    /** Currently applied coupon (for the discount-row caption + pill) */
+    coupon?: CartCoupon;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    variant: CartVariant;
+    compact: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/components/Cart/CartVariant1.vue.d.ts

@@ -0,0 +1,42 @@
+import { CartData, CartActions, CartFeatures, CartLabels, CartVariant } from './types';
+/**
+ * Variant 1 — E-commerce Drawer / Slide-over Cart
+ *
+ * - Full-width drawer / panel layout
+ * - Header: title + item count + close
+ * - Scrollable line-items list
+ * - Sticky footer: coupon + summary + actions
+ * - Best for: site.com slide-over cart, mobile / tablet cart drawer
+ */
+type __VLS_Props = {
+    data: CartData;
+    actions: CartActions;
+    features: CartFeatures;
+    labels: CartLabels;
+    compact?: boolean;
+    variant?: CartVariant;
+    containerClass?: string | any[] | Record<string, boolean>;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    clear: () => any;
+    remove: (itemId: string | number) => any;
+    continue: () => any;
+    "update:quantity": (itemId: string | number, quantity: number) => any;
+    "continue-shopping": () => any;
+    "apply-coupon": (code: string) => any;
+    "remove-coupon": () => any;
+    "coupon-change": (code: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClear?: () => any;
+    onRemove?: (itemId: string | number) => any;
+    onContinue?: () => any;
+    "onUpdate:quantity"?: (itemId: string | number, quantity: number) => any;
+    "onContinue-shopping"?: () => any;
+    "onApply-coupon"?: (code: string) => any;
+    "onRemove-coupon"?: () => any;
+    "onCoupon-change"?: (code: string) => any;
+}>, {
+    variant: CartVariant;
+    compact: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/components/Cart/CartVariant2.vue.d.ts

@@ -0,0 +1,42 @@
+import { CartData, CartActions, CartFeatures, CartLabels, CartVariant } from './types';
+/**
+ * Variant 2 — POS / Register Cart
+ *
+ *   - Dense, register-friendly layout
+ *   - No thumbnails (faster scanning at the till)
+ *   - Receipt-style dashed dividers
+ *   - Inline coupon + summary, two compact side-by-side actions
+ *   - Best for: in-store POS, kitchen tickets, fast-checkout flows
+ */
+type __VLS_Props = {
+    data: CartData;
+    actions: CartActions;
+    features: CartFeatures;
+    labels: CartLabels;
+    compact?: boolean;
+    variant?: CartVariant;
+    containerClass?: string | any[] | Record<string, boolean>;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    clear: () => any;
+    remove: (itemId: string | number) => any;
+    continue: () => any;
+    "update:quantity": (itemId: string | number, quantity: number) => any;
+    "continue-shopping": () => any;
+    "apply-coupon": (code: string) => any;
+    "remove-coupon": () => any;
+    "coupon-change": (code: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClear?: () => any;
+    onRemove?: (itemId: string | number) => any;
+    onContinue?: () => any;
+    "onUpdate:quantity"?: (itemId: string | number, quantity: number) => any;
+    "onContinue-shopping"?: () => any;
+    "onApply-coupon"?: (code: string) => any;
+    "onRemove-coupon"?: () => any;
+    "onCoupon-change"?: (code: string) => any;
+}>, {
+    variant: CartVariant;
+    compact: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/components/Cart/CartVariant3.vue.d.ts

@@ -0,0 +1,41 @@
+import { CartData, CartActions, CartFeatures, CartLabels, CartVariant } from './types';
+/**
+ * Variant 3 — Full Page Cart
+ *
+ * - Header (title + item count + clear)
+ * - Two-column body on lg+: items list (left) + sticky summary card (right)
+ * - Stacks on mobile
+ * - Best for: /cart route, e-commerce site, mobile-first responsive checkout
+ */
+type __VLS_Props = {
+    data: CartData;
+    actions: CartActions;
+    features: CartFeatures;
+    labels: CartLabels;
+    compact?: boolean;
+    variant?: CartVariant;
+    containerClass?: string | any[] | Record<string, boolean>;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    clear: () => any;
+    remove: (itemId: string | number) => any;
+    continue: () => any;
+    "update:quantity": (itemId: string | number, quantity: number) => any;
+    "continue-shopping": () => any;
+    "apply-coupon": (code: string) => any;
+    "remove-coupon": () => any;
+    "coupon-change": (code: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClear?: () => any;
+    onRemove?: (itemId: string | number) => any;
+    onContinue?: () => any;
+    "onUpdate:quantity"?: (itemId: string | number, quantity: number) => any;
+    "onContinue-shopping"?: () => any;
+    "onApply-coupon"?: (code: string) => any;
+    "onRemove-coupon"?: () => any;
+    "onCoupon-change"?: (code: string) => any;
+}>, {
+    variant: CartVariant;
+    compact: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/components/Cart/CartVariant4.vue.d.ts

@@ -0,0 +1,41 @@
+import { CartData, CartActions, CartFeatures, CartLabels, CartVariant } from './types';
+/**
+ * Variant 4 — Mini Cart / Summary
+ *
+ *   - Compact, single-column "summary-first" layout
+ *   - Tiny line items (no images, no qty stepper — name + qty + price)
+ *   - Inline summary, single primary CTA
+ *   - Best for: navbar dropdown, header mini-cart, side panel pre-checkout
+ */
+type __VLS_Props = {
+    data: CartData;
+    actions: CartActions;
+    features: CartFeatures;
+    labels: CartLabels;
+    compact?: boolean;
+    variant?: CartVariant;
+    containerClass?: string | any[] | Record<string, boolean>;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    clear: () => any;
+    remove: (itemId: string | number) => any;
+    continue: () => any;
+    "update:quantity": (itemId: string | number, quantity: number) => any;
+    "continue-shopping": () => any;
+    "apply-coupon": (code: string) => any;
+    "remove-coupon": () => any;
+    "coupon-change": (code: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClear?: () => any;
+    onRemove?: (itemId: string | number) => any;
+    onContinue?: () => any;
+    "onUpdate:quantity"?: (itemId: string | number, quantity: number) => any;
+    "onContinue-shopping"?: () => any;
+    "onApply-coupon"?: (code: string) => any;
+    "onRemove-coupon"?: () => any;
+    "onCoupon-change"?: (code: string) => any;
+}>, {
+    variant: CartVariant;
+    compact: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/components/Cart/composables/useCartCalculation.d.ts

@@ -0,0 +1,91 @@
+import { CartItem, CartTotals, CartTaxConfig, CartShippingConfig, CartCoupon } from '../types';
+/** Sum of (price × quantity) for items that are taxable (or all, if item.taxable is undefined). */
+export declare function sumLineTotals(items: CartItem[], onlyTaxable?: boolean): number;
+/** Sum of (originalPrice × quantity) − (price × quantity) across all items. */
+export declare function sumSavings(items: CartItem[]): number;
+export declare function sumItemCount(items: CartItem[]): number;
+/**
+ * Compute the discount amount a coupon would apply to a given subtotal.
+ * Returns 0 if the coupon doesn't qualify (expired / min-spend not met / etc).
+ */
+export declare function computeCouponDiscount(coupon: CartCoupon | null | undefined, subtotal: number, currency?: string): number;
+export interface TaxBreakdownLine {
+    /** Human label, e.g. "Sales Tax" or "VAT (20%)" */
+    label: string;
+    /** Computed tax amount */
+    amount: number;
+    /** Rate used (in percent), when applicable */
+    rate?: number;
+}
+export interface TaxResult {
+    /** Total tax across all breakdown lines */
+    total: number;
+    /** Per-line breakdown (single line for `rate`/`flat`, no lines for `exempt`) */
+    breakdown: TaxBreakdownLine[];
+}
+/**
+ * Compute tax on a given taxable subtotal using a `CartTaxConfig`.
+ * - `mode: 'rate'`     → percent-based tax (e.g. 8.75% sales tax)
+ * - `mode: 'flat'`     → fixed tax amount regardless of cart value
+ * - `mode: 'exempt'`   → no tax
+ * - `mode: 'inclusive'`→ tax is already inside the price (display only)
+ */
+export declare function computeTax(taxableSubtotal: number, tax: CartTaxConfig | undefined, roundToCents?: number): TaxResult;
+export interface ShippingResult {
+    /** Final shipping cost the customer pays */
+    cost: number;
+    /** True when the cost is 0 because the user crossed a free-shipping threshold */
+    isFree: boolean;
+    /** Human-readable reason, e.g. "Free over $50" or "Standard" */
+    label: string;
+    /** For UI: "Add $X more for free shipping" — null when already free / no rule */
+    freeShippingProgress: {
+        /** Amount left to spend to unlock free shipping (0 when already unlocked) */
+        remaining: number;
+        /** The threshold itself */
+        threshold: number;
+    } | null;
+}
+/**
+ * Compute shipping cost using a `CartShippingConfig`.
+ * - `mode: 'flat'`          → fixed cost
+ * - `mode: 'free'`          → always free
+ * - `mode: 'freeOver'`      → free when subtotal ≥ cost-free threshold
+ * - `mode: 'tiered'`        → lookup table; first row whose `minSubtotal ≤ subtotal` wins
+ * - `mode: 'function'`      → caller-provided (subtotal, items) => cost
+ * - `mode: 'pickup'`        → no shipping (in-store pickup)
+ */
+export declare function computeShipping(subtotal: number, shipping: CartShippingConfig | undefined, items: CartItem[]): ShippingResult;
+export interface CalculateInput {
+    items: CartItem[];
+    tax?: CartTaxConfig;
+    shipping?: CartShippingConfig;
+    /** The applied coupon (with optional `definition` for internal math) */
+    coupon?: CartCoupon | null;
+    /** Override rounding precision (default 2) */
+    roundToCents?: number;
+    /** Currency code — propagated to the result */
+    currency?: string;
+}
+export interface CalculateOutput {
+    /** The full `CartTotals` object the cart renders */
+    totals: CartTotals;
+    /** Per-line tax breakdown (empty array for `exempt` / no tax) */
+    taxBreakdown: TaxBreakdownLine[];
+    /** Free-shipping progress hint for the UI ("Add $X more…") */
+    freeShippingProgress: ShippingResult['freeShippingProgress'];
+}
+/**
+ * The single entry point used by the Cart. Pure: same input → same output.
+ *
+ *   items = [{ price: 100, quantity: 2 }, { price: 50, quantity: 1, taxable: false }]
+ *   tax = { mode: 'rate', rate: 8.75 }
+ *   shipping = { mode: 'freeOver', cost: 9.99, freeOver: 50 }
+ *   coupon = { code: 'WELCOME10', state: 'applied', definition: { type: 'percentage', value: 10, minSubtotal: 100 } }
+ *
+ *   → { subtotal: 250, discount: 25, taxableSubtotal: 200, estimatedTax: 17.50,
+ *        shipping: 0, grandTotal: 242.50, itemCount: 3, ... }
+ */
+export declare function calculateCartTotals(input: CalculateInput): CalculateOutput;
+/** Convenience helper for the most common case: just items + configs. */
+export declare function useCartCalculation(input: () => CalculateInput): CalculateOutput;

package/components/Cart/index.d.ts

@@ -0,0 +1,7 @@
+export { default as Cart } from './Cart.vue';
+export { default as CartLineItem } from './CartLineItem.vue';
+export { default as CartSummary } from './CartSummary.vue';
+export { default as CartCouponInput } from './CartCouponInput.vue';
+export { default as CartEmptyState } from './CartEmptyState.vue';
+export * from './composables/useCartCalculation';
+export * from './types';

package/components/Cart/types.d.ts

@@ -0,0 +1,391 @@
+export type CartVariant = 'Variant1' | 'Variant2' | 'Variant3' | 'Variant4';
+/** How the cart should be sized within its parent */
+export type CartSize = 'sm' | 'md' | 'lg';
+/**
+ * Tax configuration. The cart applies this automatically when `data.totals`
+ * is not provided. Supports the most common real-world scenarios:
+ *
+ * - **`rate`**     — percent-based tax on the post-discount subtotal
+ *                    (e.g. 8.75% US sales tax, 19% German VAT)
+ * - **`flat`**     — fixed tax amount (e.g. "$5 service fee")
+ * - **`exempt`**   — no tax at all (digital goods, B2B resale, etc.)
+ * - **`inclusive`**— tax already baked into the displayed price (EU VAT)
+ */
+export interface CartTaxConfig {
+    mode: 'rate' | 'flat' | 'exempt' | 'inclusive';
+    /** Percent rate when `mode === 'rate' | 'inclusive'` (e.g. 8.75) */
+    rate?: number;
+    /** Fixed amount when `mode === 'flat'` */
+    amount?: number;
+    /** Override the default label (e.g. "GST" instead of "Tax (10%)") */
+    label?: string;
+    /** Currency this tax applies to (defaults to the cart currency) */
+    currency?: string;
+    /**
+     * What base to apply tax on. Default: 'afterDiscount' (most common).
+     * - `subtotal`        — full subtotal before any coupon
+     * - `afterDiscount`   — subtotal minus coupon discount
+     * - `original`        — alias for `subtotal`
+     */
+    applyTo?: 'subtotal' | 'afterDiscount' | 'original';
+}
+/**
+ * Shipping configuration. Plug-and-play with the most common e-commerce /
+ * POS patterns. Use `mode: 'function'` for fully custom logic.
+ */
+export interface CartShippingConfig {
+    mode: 'flat' | 'free' | 'freeOver' | 'tiered' | 'function' | 'pickup';
+    /** Default shipping cost (for `flat` / `freeOver`) */
+    cost?: number;
+    /** Free-shipping threshold (for `freeOver`) */
+    freeOver?: number;
+    /** Tiered shipping table (for `tiered`) */
+    tiers?: Array<{
+        /** Min subtotal for this tier to apply */
+        minSubtotal: number;
+        /** Shipping cost for this tier (0 = free) */
+        cost: number;
+        /** Optional label override for this tier */
+        label?: string;
+    }>;
+    /** Custom calculation (for `function`) */
+    calculate?: (subtotal: number, items: CartItem[]) => {
+        cost: number;
+        isFree?: boolean;
+        label?: string;
+    };
+    /** Default label for the shipping line */
+    label?: string;
+    /** Currency this shipping cost is in */
+    currency?: string;
+}
+/**
+ * A coupon's business rules. Pass an array of these as `data.coupons` and
+ * the cart will validate user-typed codes against this list internally —
+ * you don't need any custom code in your component to handle fixed/percent
+ * discounts, min-spend, expiry, or max-cap.
+ *
+ * If you need server-side validation (rate-limited, single-use, fraud),
+ * use `validateCoupon` on `CartProps` instead — the cart will await it
+ * and drive the `applying` / `applied` / `invalid` UX for you.
+ */
+export interface CartCouponDefinition {
+    /** Coupon code (case-insensitive match by default) */
+    code: string;
+    /** 'percentage' (% off subtotal) or 'fixed' (flat amount off) */
+    type: 'percentage' | 'fixed';
+    /** Discount value — percent (0-100) for 'percentage', currency for 'fixed' */
+    value: number;
+    /** Human-readable description, e.g. "10% off your first order" */
+    description?: string;
+    /** Min cart subtotal required to apply */
+    minSubtotal?: number;
+    /** Cap on the discount amount (mostly for `type: 'percentage'`) */
+    maxDiscount?: number;
+    /** ISO 8601 / Date — coupon expiry */
+    expiresAt?: string | Date;
+    /** ISO 4217 currency code (coupon only applies to matching currency) */
+    currency?: string;
+    /**
+     * For stacking: how many times this coupon can be applied (1 by default).
+     * Single-use coupons set this to 1.
+     */
+    usageLimit?: number;
+    /** Optional minimum item count required */
+    minItems?: number;
+}
+/**
+ * Drives the coupon input's visual state and helper message.
+ *
+ * - `idle`     → empty input, no validation feedback
+ * - `applying` → request in flight (shows spinner, disables input)
+ * - `applied`  → success state (green check, shows "Remove" action)
+ * - `invalid`  → code does not exist (red border + helper text)
+ * - `expired`  → coupon no longer valid (amber border + helper text)
+ * - `error`    → generic error (e.g. min spend not met) — message from API
+ */
+export type CartCouponState = 'idle' | 'applying' | 'applied' | 'invalid' | 'expired' | 'error';
+export interface CartTrustSignal {
+    /** Iconify name, e.g. "lucide:truck" */
+    icon: string;
+    /** Text to display */
+    text: string;
+}
+export interface CartItem {
+    /** Unique identifier for the line item */
+    id: string | number;
+    /** Product / service name (required) */
+    name: string;
+    /** Optional secondary description */
+    description?: string;
+    /** URL to the product thumbnail */
+    thumbnail?: string;
+    /** SKU / barcode string */
+    sku?: string;
+    /** Variant label (size, color, etc.) */
+    variant?: string;
+    /** Unit price */
+    price: number;
+    /** Quantity in cart */
+    quantity: number;
+    /** Optional strike-through original price (for sale items) */
+    originalPrice?: number;
+    /** Hard cap on the qty stepper (e.g. stock) */
+    maxQuantity?: number;
+    /** Mark out-of-stock items (renders disabled state) */
+    inStock?: boolean;
+    /** Whether this line should be taxed */
+    taxable?: boolean;
+    /** Free-form metadata — passed through to custom renderers via slots */
+    metadata?: Record<string, any>;
+}
+export interface CartCoupon {
+    /** The coupon code as typed by the user */
+    code: string;
+    /** Human-readable description, e.g. "10% off your order" */
+    description?: string;
+    /** Current state of the coupon in the UX (see CartCouponState) */
+    state?: CartCouponState;
+    /** Discount amount (positive number) applied to the cart */
+    discountAmount?: number;
+    /**
+     * Free-form message from the validation API.
+     * Shown in the helper-text area when state is 'invalid' | 'expired' | 'error'.
+     */
+    message?: string;
+    /** ISO 8601 / Date — used to render the "Expires in 2d" pill */
+    expiresAt?: string | Date;
+    /**
+     * The full coupon definition. When provided, the cart will recompute
+     * `discountAmount` automatically as items change. Without it, the
+     * cart trusts whatever `discountAmount` you pass in.
+     */
+    definition?: CartCouponDefinition;
+}
+export interface CartTotals {
+    /** Sum of all line items before any discount/tax/shipping */
+    subtotal: number;
+    /** Total discount applied to the order (positive number) */
+    discount?: number;
+    /** Estimated tax — labelled exactly as the user asked: "Estimated Tax" */
+    estimatedTax?: number;
+    /** Tax rate in percent (e.g. 8.625) — used to render "Tax (8.625%)" */
+    taxRate?: number;
+    /** Shipping cost */
+    shipping?: number;
+    /** Final amount to charge (after discount + tax + shipping) */
+    grandTotal: number;
+    /** Number of items — used to render the "Items (4)" line in the summary */
+    itemCount?: number;
+    /** Total saved vs. original prices — rendered as a savings pill */
+    totalSavings?: number;
+    /** ISO 4217 currency code (defaults to the global Price config) */
+    currency?: string;
+    /** Subtotal of taxable items only (used internally; safe to ignore) */
+    taxableSubtotal?: number;
+    /**
+     * Free-shipping progress hint. When the user is below the free-shipping
+     * threshold, the cart renders "Add $X more for free shipping".
+     */
+    freeShippingProgress?: {
+        /** Amount left to spend to unlock free shipping */
+        remaining: number;
+        /** The free-shipping threshold itself */
+        threshold: number;
+    } | null;
+    /** Per-line tax breakdown — drives the summary if you want multi-rate tax */
+    taxBreakdown?: Array<{
+        label: string;
+        amount: number;
+        rate?: number;
+    }>;
+}
+export interface CartActions {
+    /** Label for the primary action, e.g. "Continue to Checkout" */
+    continueLabel?: string;
+    /** Label for the secondary action, e.g. "Continue Shopping" */
+    continueShoppingLabel?: string;
+    /** Show / hide the primary action button */
+    showContinue?: boolean;
+    /** Show / hide the secondary action button */
+    showContinueShopping?: boolean;
+    /** Disable the primary action (e.g. when cart is empty) */
+    continueDisabled?: boolean;
+    /** Disable the secondary action */
+    continueShoppingDisabled?: boolean;
+    /** Optional icon for the primary action (Iconify name) */
+    continueIcon?: string;
+    /** Optional icon for the secondary action (Iconify name) */
+    continueShoppingIcon?: string;
+}
+/**
+ * Every optional block of the cart can be turned on or off independently.
+ * This is what makes the same component usable across e-commerce and POS.
+ *
+ * Defaults are documented per field — they are designed to satisfy the
+ * "out-of-the-box e-commerce cart" use case. POS scenarios explicitly
+ * disable thumbnails and description.
+ */
+export interface CartFeatures {
+    /** Allow +/- quantity stepper (disabled in readonly) */
+    editableQuantity?: boolean;
+    /** Allow removing individual items */
+    removable?: boolean;
+    /** Show the "Clear cart" action */
+    clearable?: boolean;
+    /** Show the coupon input */
+    coupon?: boolean;
+    /** Show the Subtotal row */
+    subtotal?: boolean;
+    /** Show the Discount row */
+    discount?: boolean;
+    /** Show the Estimated Tax row */
+    estimatedTax?: boolean;
+    /** Show the Shipping row */
+    shipping?: boolean;
+    /** Show the Total Savings row */
+    totalSavings?: boolean;
+    /** Show the primary "Continue" action */
+    continue?: boolean;
+    /** Show the secondary "Continue shopping" action */
+    continueShopping?: boolean;
+    /** Show item thumbnails (false in POS compact) */
+    thumbnails?: boolean;
+    /** Show the secondary description line under the name */
+    description?: boolean;
+    /** Show the SKU line under the name */
+    sku?: boolean;
+    /** Show the variant label (size, color) */
+    itemVariant?: boolean;
+    /** Render an Empty state when there are no items */
+    emptyState?: boolean;
+    /** Show trust signals (if provided in data) */
+    trustSignals?: boolean;
+}
+export interface CartData {
+    /** Cart title (e.g. "Your Cart", "Order #1287", "Basket") */
+    title?: string;
+    /** Optional subtitle / context line */
+    subtitle?: string;
+    /** Brand / store name */
+    brandName?: string;
+    /** Brand / store logo URL */
+    brandLogo?: string;
+    /** Line items in the cart */
+    items: CartItem[];
+    /**
+     * Totals breakdown. OPTIONAL — if you don't pass it, the cart computes
+     * it automatically from `items + tax + shipping + coupon`. If you do
+     * pass it (e.g. server-computed or pre-aggregated), the cart uses it
+     * verbatim and skips its own math.
+     */
+    totals?: CartTotals;
+    /** Currently applied coupon, if any */
+    coupon?: CartCoupon;
+    /**
+     * Tax configuration. Used by the built-in calculator when `totals`
+     * is not provided. Ignored when `totals` is provided.
+     */
+    tax?: CartTaxConfig;
+    /**
+     * Shipping configuration. Used by the built-in calculator when `totals`
+     * is not provided. Ignored when `totals` is provided.
+     */
+    shipping?: CartShippingConfig;
+    /**
+     * Catalog of valid coupons. When provided, the cart will validate
+     * user-typed codes against this list internally — no `apply-coupon`
+     * event handler needed. Use this for static coupon lists; for
+     * server-validated coupons, use the `validateCoupon` prop instead.
+     */
+    coupons?: CartCouponDefinition[];
+    /**
+     * Default currency for the cart. Used by the calculation engine when
+     * `totals` is not provided. Falls back to the global Price config.
+     */
+    currency?: string;
+    /** Mark the entire cart read-only (no qty edits, no remove, no coupon change) */
+    readonly?: boolean;
+    /** Reduce padding/typography (mirrors Invoice `compact` flag) */
+    compact?: boolean;
+    /** Manually toggle the empty state (overrides `items.length === 0`) */
+    empty?: boolean;
+    /** Optional trust signals (e.g. "Free shipping over $50", "30-day returns"). */
+    trustSignals?: CartTrustSignal[];
+    /** Custom CSS class for the root container */
+    containerClass?: string | any[] | Record<string, boolean>;
+}
+export interface CartLabels {
+    /** Replaces the default "Cart" / "Your Cart" heading */
+    cart?: string;
+    /** Replaces the default "Your cart is empty" heading in the empty state */
+    emptyTitle?: string;
+    /** Replaces the default empty-state description */
+    emptyDescription?: string;
+    /** Replaces the default "Start shopping" CTA in the empty state */
+    emptyAction?: string;
+    /** Replaces the default "Subtotal" label */
+    subtotal?: string;
+    /** Replaces the default "Discount" label */
+    discount?: string;
+    /** Replaces the default "Estimated Tax" label */
+    estimatedTax?: string;
+    /** Replaces the default "Shipping" label */
+    shipping?: string;
+    /** Replaces the default "Grand Total" label */
+    grandTotal?: string;
+    /** Replaces the default "Total Savings" label */
+    totalSavings?: string;
+    /** Replaces the default "Coupon" input label */
+    coupon?: string;
+    /** Replaces the default coupon input placeholder */
+    couponPlaceholder?: string;
+    /** Replaces the default "Apply" button text */
+    applyCoupon?: string;
+    /** Replaces the default "Remove coupon" aria-label on the applied-coupon × button */
+    removeCoupon?: string;
+    /** Replaces the default "Quantity" label */
+    quantity?: string;
+    /** Replaces the default "Remove" item button */
+    remove?: string;
+    /** Replaces the default "Continue to checkout" button */
+    continue?: string;
+    /** Replaces the default "Continue shopping" button */
+    continueShopping?: string;
+    /** Replaces the default "Clear cart" action */
+    clearCart?: string;
+    /** Replaces the default "Items" prefix in summary (e.g. "Items (3)") */
+    itemCount?: string;
+}
+export interface CartProps {
+    /** The complete cart data object (required) */
+    data: CartData;
+    /** Visual layout variant */
+    variant?: CartVariant;
+    /** Action button configuration */
+    actions?: CartActions;
+    /** Per-feature on/off toggles */
+    features?: CartFeatures;
+    /** Custom text label overrides */
+    labels?: CartLabels;
+    /** Custom CSS class for the root container */
+    containerClass?: string | any[] | Record<string, boolean>;
+    /**
+     * Async server-side coupon validator. Receives the code the user typed
+     * and the current subtotal; resolves with a `CartCouponDefinition`
+     * (or null to reject). When provided, this takes precedence over
+     * `data.coupons` for the apply flow.
+     *
+     * The cart automatically drives the `applying` / `applied` / `invalid`
+     * / `expired` / `error` UX around this call.
+     */
+    validateCoupon?: (code: string, context: {
+        subtotal: number;
+        currency?: string;
+        items: CartItem[];
+    }) => Promise<CartCouponDefinition | {
+        code: string;
+        message: string;
+        state?: 'invalid' | 'expired' | 'error';
+    } | null>;
+}

package/components/CategoryManager/CategoryManager.vue.d.ts

@@ -37,11 +37,11 @@ declare const __VLS_component: import('vue').DefineComponent<CategoryManagerProp
 }>, {
     size: "sm" | "md" | "lg";
     loading: boolean;
+    emptyTitle: string;
+    emptyDescription: string;
     readonly: boolean;
     modelValue: CategoryItem[];
     rawData: RawCategoryItem[];
-    emptyTitle: string;
-    emptyDescription: string;
     defaultExpanded: (string | number)[];
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;

package/components/Clipboard.vue.d.ts

@@ -27,11 +27,11 @@ declare function __VLS_template(): {
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: import('vue').DefineComponent<ClipboardProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
-    copy: (text: string) => any;
     error: (err: Error) => any;
+    copy: (text: string) => any;
 }, string, import('vue').PublicProps, Readonly<ClipboardProps> & Readonly<{
-    onCopy?: (text: string) => any;
     onError?: (err: Error) => any;
+    onCopy?: (text: string) => any;
 }>, {
     variant: ButtonVariant;
     size: ButtonSize;

package/components/FilePicker/FilePicker.vue.d.ts

@@ -41,12 +41,12 @@ declare function __VLS_template(): {
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
-    change: (value: FilePickerValue | FilePickerValue[]) => any;
     error: (error: string) => any;
+    change: (value: FilePickerValue | FilePickerValue[]) => any;
     "update:modelValue": (value: FilePickerValue | FilePickerValue[]) => any;
 }, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
-    onChange?: (value: FilePickerValue | FilePickerValue[]) => any;
     onError?: (error: string) => any;
+    onChange?: (value: FilePickerValue | FilePickerValue[]) => any;
     "onUpdate:modelValue"?: (value: FilePickerValue | FilePickerValue[]) => any;
 }>, {
     variant: "dropzone" | "input";

package/components/Form/FormField.vue.d.ts

@@ -31,8 +31,8 @@ declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, imp
     size: InputSize;
     rounded: InputRounded;
     loading: boolean;
-    readonly: boolean;
     error: string;
+    readonly: boolean;
     disabled: boolean;
     isUpdate: boolean;
     floatingActive: boolean;

package/components/OTPInput/OTPInput.vue.d.ts

@@ -37,8 +37,8 @@ declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, imp
     mask: boolean;
     variant: "solid" | "outline" | "ghost";
     size: "sm" | "md" | "lg";
-    placeholder: string;
     error: boolean;
+    placeholder: string;
     disabled: boolean;
     modelValue: string;
     autofocus: boolean;

package/components/Rating/Rating.vue.d.ts

@@ -23,6 +23,7 @@ declare const __VLS_component: import('vue').DefineComponent<RatingProps, {}, {}
     icon: string | string[];
     size: "sm" | "md" | "lg" | "xl";
     solid: boolean;
+    clearable: boolean;
     readonly: boolean;
     disabled: boolean;
     modelValue: number;
@@ -32,7 +33,6 @@ declare const __VLS_component: import('vue').DefineComponent<RatingProps, {}, {}
     activeIcon: string | string[];
     activeColor: string;
     inactiveColor: string;
-    clearable: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;

package/core/config.d.ts

@@ -113,6 +113,70 @@ export declare const configState: {
             };
             containerClass?: string | any[] | Record<string, boolean>;
         };
+        cart?: {
+            variant?: import('../components/Cart').CartVariant;
+            labels?: {
+                cart?: string;
+                emptyTitle?: string;
+                emptyDescription?: string;
+                emptyAction?: string;
+                subtotal?: string;
+                discount?: string;
+                estimatedTax?: string;
+                shipping?: string;
+                grandTotal?: string;
+                totalSavings?: string;
+                coupon?: string;
+                couponPlaceholder?: string;
+                applyCoupon?: string;
+                removeCoupon?: string;
+                quantity?: string;
+                remove?: string;
+                continue?: string;
+                continueShopping?: string;
+                clearCart?: string;
+                itemCount?: string;
+            };
+            containerClass?: string | any[] | Record<string, boolean>;
+            actions?: {
+                continueLabel?: string;
+                continueShoppingLabel?: string;
+                showContinue?: boolean;
+                showContinueShopping?: boolean;
+                continueDisabled?: boolean;
+                continueShoppingDisabled?: boolean;
+                continueIcon?: string;
+                continueShoppingIcon?: string;
+            };
+            features?: {
+                editableQuantity?: boolean;
+                removable?: boolean;
+                clearable?: boolean;
+                coupon?: boolean;
+                subtotal?: boolean;
+                discount?: boolean;
+                estimatedTax?: boolean;
+                shipping?: boolean;
+                totalSavings?: boolean;
+                continue?: boolean;
+                continueShopping?: boolean;
+                thumbnails?: boolean;
+                description?: boolean;
+                sku?: boolean;
+                itemVariant?: boolean;
+                emptyState?: boolean;
+                trustSignals?: boolean;
+            };
+            validateCoupon?: (code: string, context: {
+                subtotal: number;
+                currency?: string;
+                items: import('../components/Cart').CartItem[];
+            }) => Promise<import('../components/Cart').CartCouponDefinition | {
+                code: string;
+                message: string;
+                state?: "invalid" | "expired" | "error";
+            } | null>;
+        };
     };
 };
 /**
@@ -228,5 +292,69 @@ export declare function useVLiteConfig(): {
             };
             containerClass?: string | any[] | Record<string, boolean>;
         };
+        cart?: {
+            variant?: import('../components/Cart').CartVariant;
+            labels?: {
+                cart?: string;
+                emptyTitle?: string;
+                emptyDescription?: string;
+                emptyAction?: string;
+                subtotal?: string;
+                discount?: string;
+                estimatedTax?: string;
+                shipping?: string;
+                grandTotal?: string;
+                totalSavings?: string;
+                coupon?: string;
+                couponPlaceholder?: string;
+                applyCoupon?: string;
+                removeCoupon?: string;
+                quantity?: string;
+                remove?: string;
+                continue?: string;
+                continueShopping?: string;
+                clearCart?: string;
+                itemCount?: string;
+            };
+            containerClass?: string | any[] | Record<string, boolean>;
+            actions?: {
+                continueLabel?: string;
+                continueShoppingLabel?: string;
+                showContinue?: boolean;
+                showContinueShopping?: boolean;
+                continueDisabled?: boolean;
+                continueShoppingDisabled?: boolean;
+                continueIcon?: string;
+                continueShoppingIcon?: string;
+            };
+            features?: {
+                editableQuantity?: boolean;
+                removable?: boolean;
+                clearable?: boolean;
+                coupon?: boolean;
+                subtotal?: boolean;
+                discount?: boolean;
+                estimatedTax?: boolean;
+                shipping?: boolean;
+                totalSavings?: boolean;
+                continue?: boolean;
+                continueShopping?: boolean;
+                thumbnails?: boolean;
+                description?: boolean;
+                sku?: boolean;
+                itemVariant?: boolean;
+                emptyState?: boolean;
+                trustSignals?: boolean;
+            };
+            validateCoupon?: (code: string, context: {
+                subtotal: number;
+                currency?: string;
+                items: import('../components/Cart').CartItem[];
+            }) => Promise<import('../components/Cart').CartCouponDefinition | {
+                code: string;
+                message: string;
+                state?: "invalid" | "expired" | "error";
+            } | null>;
+        };
     };
 };

package/package.json

@@ -3,7 +3,7 @@
   "private": false,
   "description": "A Vue 3 UI component library built with Tailwind CSS.",
   "license": "MIT",
-  "version": "1.4.3",
+  "version": "1.4.4",
   "type": "module",
   "main": "index.js",
   "module": "index.js",

package/types/config.type.d.ts

@@ -5,6 +5,7 @@ import { AttachmentsListProps } from '../components/AttachmentsList/types';
 import { ListProps } from './list.type';
 import { InvoiceProps } from '../components/Invoice/types';
 import { FooterProps } from '../components/Footer/types';
+import { CartProps } from '../components/Cart/types';
 /**
  * Interface for the file upload handler function.
  * This allows users to replace the default upload logic with their own API.
@@ -104,5 +105,6 @@ export interface VLiteConfig {
         list?: Omit<ListProps, 'fields' | 'data'>;
         invoice?: Omit<InvoiceProps, 'data'>;
         footer?: Omit<FooterProps, 'data'>;
+        cart?: Omit<CartProps, 'data'>;
     };
 }