vlite3 1.4.3 → 1.4.5

package/components/Cart/CartVariant4.vue.js

@@ -0,0 +1,145 @@
+import { defineComponent as q, computed as c, openBlock as a, createElementBlock as i, normalizeClass as r, createElementVNode as m, createVNode as v, toDisplayString as b, createCommentVNode as u, unref as z, createBlock as y, Fragment as B, renderList as N, withCtx as k, createTextVNode as C } from "vue";
+import D from "../Icon.vue.js";
+import E from "../Price/Price.vue.js";
+import w from "../Button.vue.js";
+import L from "./CartLineItem.vue.js";
+import j from "./CartSummary.vue.js";
+import I from "./CartCouponInput.vue.js";
+import R from "./CartEmptyState.vue.js";
+const T = { class: "flex items-center gap-2 min-w-0" }, A = {
+  key: 0,
+  class: "inline-flex items-center justify-center px-1.5 h-5 rounded-full bg-primary/10 text-primary text-[10px] font-bold tabular-nums"
+}, F = {
+  key: 0,
+  class: "text-xs text-muted-foreground"
+}, U = { class: "font-semibold text-foreground" }, G = { class: "flex-1 min-h-0 overflow-y-auto" }, H = {
+  key: 1,
+  class: "space-y-1.5 pt-0.5"
+}, Y = /* @__PURE__ */ q({
+  __name: "CartVariant4",
+  props: {
+    data: {},
+    actions: {},
+    features: {},
+    labels: {},
+    compact: { type: Boolean, default: !1 },
+    variant: { default: "Variant4" },
+    containerClass: {}
+  },
+  emits: ["update:quantity", "remove", "clear", "apply-coupon", "remove-coupon", "coupon-change", "continue", "continue-shopping"],
+  setup(e, { emit: $ }) {
+    const p = e, l = $, s = c(() => p.data), g = c(() => p.labels || {}), o = c(() => p.actions || {}), f = c(() => p.features || {}), d = c(() => s.value.empty || !s.value.items || s.value.items.length === 0), S = c(
+      () => s.value.totals.itemCount ?? s.value.items?.reduce((h, t) => h + (t.quantity || 0), 0) ?? 0
+    );
+    return (h, t) => (a(), i("div", {
+      class: r(["v-cart v-cart-v4 flex flex-col bg-background text-foreground border border-border rounded-lg overflow-hidden w-full h-full", [e.containerClass, e.compact ? "max-w-xs" : "max-w-sm"]])
+    }, [
+      m("div", {
+        class: r(["flex items-center justify-between gap-2 border-b border-border shrink-0", e.compact ? "px-3 py-2" : "px-4 py-2.5"])
+      }, [
+        m("div", T, [
+          v(D, {
+            icon: "lucide:shopping-bag",
+            class: r(e.compact ? "w-4 h-4" : "w-4.5 h-4.5")
+          }, null, 8, ["class"]),
+          m("p", {
+            class: r(["font-bold text-foreground truncate", (e.compact, "text-sm")])
+          }, b(s.value.title || g.value.cart || "Cart"), 3),
+          d.value ? u("", !0) : (a(), i("span", A, b(S.value), 1))
+        ]),
+        !d.value && !e.compact ? (a(), i("p", F, [
+          m("span", U, [
+            v(z(E), {
+              value: e.data.totals.grandTotal,
+              class: "text-foreground font-semibold"
+            }, null, 8, ["value"])
+          ])
+        ])) : u("", !0)
+      ], 2),
+      m("div", G, [
+        d.value ? (a(), y(R, {
+          key: 0,
+          labels: e.labels,
+          compact: !0,
+          onContinueShopping: t[0] || (t[0] = (n) => l("continue-shopping"))
+        }, null, 8, ["labels"])) : (a(), i("ul", {
+          key: 1,
+          class: r(["divide-y divide-border", e.compact ? "px-3" : "px-4"])
+        }, [
+          (a(!0), i(B, null, N(e.data.items, (n) => (a(), i("li", {
+            key: n.id
+          }, [
+            v(L, {
+              item: n,
+              features: e.features,
+              labels: e.labels,
+              compact: e.compact,
+              readonly: e.data.readonly,
+              layout: "mini",
+              "onUpdate:quantity": t[1] || (t[1] = (x, V) => l("update:quantity", x, V)),
+              onRemove: t[2] || (t[2] = (x) => l("remove", x))
+            }, null, 8, ["item", "features", "labels", "compact", "readonly"])
+          ]))), 128))
+        ], 2))
+      ]),
+      d.value ? u("", !0) : (a(), i("div", {
+        key: 0,
+        class: r(["border-t border-border bg-muted/30 shrink-0", e.compact ? "p-3 space-y-2" : "p-4 space-y-3"])
+      }, [
+        v(j, {
+          totals: e.data.totals,
+          features: e.features,
+          labels: e.labels,
+          compact: e.compact,
+          coupon: e.data.coupon,
+          variant: "Variant4"
+        }, null, 8, ["totals", "features", "labels", "compact", "coupon"]),
+        e.features.coupon ? (a(), y(I, {
+          key: 0,
+          coupon: e.data.coupon,
+          labels: e.labels,
+          compact: e.compact,
+          readonly: e.data.readonly,
+          onApply: t[3] || (t[3] = (n) => l("apply-coupon", n)),
+          onRemove: t[4] || (t[4] = (n) => l("remove-coupon")),
+          onChange: t[5] || (t[5] = (n) => l("coupon-change", n))
+        }, null, 8, ["coupon", "labels", "compact", "readonly"])) : u("", !0),
+        o.value.showContinue && f.value.continue || o.value.showContinueShopping && f.value.continueShopping ? (a(), i("div", H, [
+          o.value.showContinue && f.value.continue ? (a(), y(w, {
+            key: 0,
+            variant: "primary",
+            size: e.compact ? "sm" : "md",
+            block: !0,
+            icon: o.value.continueIcon || "lucide:arrow-right",
+            disabled: o.value.continueDisabled || d.value,
+            class: "w-full",
+            onClick: t[6] || (t[6] = (n) => l("continue"))
+          }, {
+            default: k(() => [
+              C(b(o.value.continueLabel || g.value.continue || "Checkout"), 1)
+            ]),
+            _: 1
+          }, 8, ["size", "icon", "disabled"])) : u("", !0),
+          o.value.showContinueShopping && f.value.continueShopping ? (a(), y(w, {
+            key: 1,
+            variant: "ghost",
+            size: "sm",
+            block: !0,
+            icon: o.value.continueShoppingIcon || "lucide:arrow-left",
+            disabled: o.value.continueShoppingDisabled,
+            class: "w-full",
+            onClick: t[7] || (t[7] = (n) => l("continue-shopping"))
+          }, {
+            default: k(() => [
+              C(b(o.value.continueShoppingLabel || g.value.continueShopping || "Continue shopping"), 1)
+            ]),
+            _: 1
+          }, 8, ["icon", "disabled"])) : u("", !0)
+        ])) : u("", !0)
+      ], 2))
+    ], 2));
+  }
+});
+export {
+  Y as default
+};

package/components/Cart/CartVariant4.vue2.js

@@ -0,0 +1,4 @@
+import f from "./CartVariant4.vue.js";
+export {
+  f as default
+};

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

@@ -0,0 +1,46 @@
+import { ComputedRef, Ref } from 'vue';
+import { CartCoupon, CartData, CartItem, CartTotals } from '../types';
+export type CartItemId = CartItem['id'];
+export interface UseCartOptions extends Partial<Omit<CartData, 'items' | 'coupon' | 'totals'>> {
+    /** Initial line items */
+    items?: CartItem[];
+    /** Initial applied coupon */
+    coupon?: CartCoupon | null;
+    /** Server-provided totals. When omitted, useCart calculates totals locally. */
+    totals?: CartTotals;
+}
+export interface UseCartReturn {
+    /** Reactive line items */
+    items: Ref<CartItem[]>;
+    /** Reactive applied coupon */
+    coupon: Ref<CartCoupon | null>;
+    /** Totals produced by the same calculator used by the Cart component */
+    totals: ComputedRef<CartTotals>;
+    /** Ready-to-pass CartData object for `<Cart :data="cart.data" />` */
+    data: ComputedRef<CartData>;
+    /** Total quantity across all line items */
+    itemCount: ComputedRef<number>;
+    /** Whether the cart currently has no line items */
+    isEmpty: ComputedRef<boolean>;
+    /** Add a line item, merging quantity with an existing item that has the same id. */
+    addToCart: (item: CartItem, quantity?: number) => void;
+    /** Remove a line item entirely, or subtract a quantity when provided. */
+    removeFromCart: (itemId: CartItemId, quantity?: number) => void;
+    /** Set a line item's quantity. Quantities <= 0 remove the item. */
+    updateQuantity: (itemId: CartItemId, quantity: number) => void;
+    /** Increase a line item's quantity. */
+    incrementQuantity: (itemId: CartItemId, amount?: number) => void;
+    /** Decrease a line item's quantity, removing it at zero. */
+    decrementQuantity: (itemId: CartItemId, amount?: number) => void;
+    /** Replace all cart items. */
+    setItems: (nextItems: CartItem[]) => void;
+    /** Clear all line items. */
+    clearCart: () => void;
+    /** Set or clear the applied coupon. */
+    setCoupon: (nextCoupon: CartCoupon | null) => void;
+    /** Get the current quantity for a line item id. */
+    getQuantity: (itemId: CartItemId) => number;
+    /** Get a shallow-copied snapshot of the current cart items. */
+    getCartItems: () => CartItem[];
+}
+export declare function useCart(options?: UseCartOptions): UseCartReturn;

package/components/Cart/composables/useCart.js

@@ -0,0 +1,110 @@
+import { ref as Q, computed as v } from "vue";
+import { calculateCartTotals as w } from "./useCartCalculation.js";
+function s(u, o) {
+  if (!Number.isFinite(u)) return 0;
+  const d = Math.max(0, Math.floor(u));
+  return typeof o == "number" && Number.isFinite(o) ? Math.min(d, Math.max(0, Math.floor(o))) : d;
+}
+function f(u, o = u.quantity) {
+  return {
+    ...u,
+    quantity: s(o, u.maxQuantity)
+  };
+}
+function D(u = {}) {
+  const {
+    items: o = [],
+    coupon: d = null,
+    totals: h,
+    ...m
+  } = u, n = Q(o.map((t) => f(t))), p = Q(d), l = Q(h), g = v(() => w({
+    items: n.value,
+    tax: m.tax,
+    shipping: m.shipping,
+    coupon: p.value,
+    currency: m.currency
+  }).totals), C = v(() => l.value ?? g.value), M = v(() => n.value.reduce((t, e) => t + s(e.quantity), 0)), q = v(() => n.value.length === 0), T = v(() => ({
+    ...m,
+    items: n.value,
+    coupon: p.value ?? void 0,
+    totals: C.value
+  }));
+  function y(t) {
+    return s(n.value.find((e) => e.id === t)?.quantity ?? 0);
+  }
+  function b(t) {
+    n.value = t.map((e) => f(e)), l.value = void 0;
+  }
+  function F(t, e = t.quantity || 1) {
+    const a = s(e, t.maxQuantity);
+    if (a <= 0) return;
+    const r = n.value.findIndex((i) => i.id === t.id);
+    if (r === -1)
+      n.value = [...n.value, f(t, a)];
+    else {
+      const i = n.value[r], c = t.maxQuantity ?? i.maxQuantity, k = f(
+        {
+          ...i,
+          ...t,
+          maxQuantity: c
+        },
+        s(i.quantity + a, c)
+      );
+      n.value = [...n.value.slice(0, r), k, ...n.value.slice(r + 1)];
+    }
+    l.value = void 0;
+  }
+  function x(t, e) {
+    const a = n.value.findIndex((c) => c.id === t);
+    if (a === -1) return;
+    const r = n.value[a], i = s(e, r.maxQuantity);
+    i <= 0 ? n.value = n.value.filter((c) => c.id !== t) : n.value = [
+      ...n.value.slice(0, a),
+      f(r, i),
+      ...n.value.slice(a + 1)
+    ], l.value = void 0;
+  }
+  function z(t, e) {
+    if (e === void 0) {
+      n.value = n.value.filter((a) => a.id !== t), l.value = void 0;
+      return;
+    }
+    x(t, y(t) - e);
+  }
+  function N(t, e = 1) {
+    x(t, y(t) + e);
+  }
+  function O(t, e = 1) {
+    x(t, y(t) - e);
+  }
+  function E() {
+    n.value = [], l.value = void 0;
+  }
+  function I(t) {
+    p.value = t, l.value = void 0;
+  }
+  function j() {
+    return n.value.map((t) => ({ ...t }));
+  }
+  return {
+    items: n,
+    coupon: p,
+    totals: C,
+    data: T,
+    itemCount: M,
+    isEmpty: q,
+    addToCart: F,
+    removeFromCart: z,
+    updateQuantity: x,
+    incrementQuantity: N,
+    decrementQuantity: O,
+    setItems: b,
+    clearCart: E,
+    setCoupon: I,
+    getQuantity: y,
+    getCartItems: j
+  };
+}
+export {
+  D as useCart
+};

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/composables/useCartCalculation.js

@@ -0,0 +1,145 @@
+const n = (o, e = 0) => {
+  const r = Number(o);
+  return Number.isFinite(r) ? r : e;
+}, u = (o, e = 2) => {
+  const r = Math.pow(10, e);
+  return Math.round((o + Number.EPSILON) * r) / r;
+};
+function h(o, e = !1) {
+  return o.reduce((r, t) => {
+    const a = n(t.price), i = Math.max(0, Math.floor(n(t.quantity))), c = a * i;
+    return e && t.taxable === !1 ? r : r + c;
+  }, 0);
+}
+function M(o) {
+  return o.reduce((e, r) => {
+    const t = n(r.originalPrice), a = n(r.price), i = Math.max(0, Math.floor(n(r.quantity)));
+    return t > a ? e + (t - a) * i : e;
+  }, 0);
+}
+function S(o) {
+  return o.reduce((e, r) => e + Math.max(0, Math.floor(n(r.quantity))), 0);
+}
+function y(o, e, r) {
+  if (!o) return 0;
+  const t = o.definition;
+  if (!t)
+    return Math.max(0, n(o.discountAmount));
+  if (t.currency && r && t.currency !== r) return 0;
+  if (t.expiresAt) {
+    const i = t.expiresAt instanceof Date ? t.expiresAt : new Date(t.expiresAt);
+    if (!Number.isNaN(i.getTime()) && i.getTime() < Date.now()) return 0;
+  }
+  if (t.minSubtotal !== void 0 && e < n(t.minSubtotal)) return 0;
+  let a = 0;
+  if (t.type === "percentage")
+    a = e * n(t.value) / 100;
+  else if (t.type === "fixed")
+    a = n(t.value);
+  else
+    return 0;
+  return t.maxDiscount !== void 0 && a > n(t.maxDiscount) && (a = n(t.maxDiscount)), a > e && (a = e), Math.max(0, a);
+}
+function k(o, e, r = 2) {
+  if (!e || e.mode === "exempt")
+    return { total: 0, breakdown: [] };
+  if (e.mode === "flat") {
+    const t = Math.max(0, n(e.amount));
+    return {
+      total: u(t, r),
+      breakdown: [{ label: e.label || "Tax", amount: u(t, r) }]
+    };
+  }
+  if (e.mode === "rate" || e.mode === "inclusive") {
+    const t = n(e.rate);
+    if (t <= 0) return { total: 0, breakdown: [] };
+    const a = u(o * t / 100, r), i = e.label || (e.mode === "inclusive" ? `VAT (${t}%)` : `Tax (${t}%)`);
+    return { total: a, breakdown: [{ label: i, amount: a, rate: t }] };
+  }
+  return { total: 0, breakdown: [] };
+}
+function g(o, e, r) {
+  if (!e || e.mode === "free" || e.mode === "pickup")
+    return {
+      cost: 0,
+      isFree: !0,
+      label: e?.label || (e?.mode === "pickup" ? "In-store pickup" : "Free shipping"),
+      freeShippingProgress: null
+    };
+  let t = 0, a = !1, i = e.label || "Shipping", c = 0, s = 0;
+  switch (e.mode) {
+    case "flat": {
+      t = Math.max(0, n(e.cost)), i = e.label || "Shipping";
+      break;
+    }
+    case "freeOver": {
+      c = n(e.freeOver), o >= c && c > 0 ? (t = 0, a = !0, i = e.label || `Free (orders over ${c})`) : (t = Math.max(0, n(e.cost)), i = e.label || "Shipping", s = c > 0 ? Math.max(0, c - o) : 0);
+      break;
+    }
+    case "tiered": {
+      const l = (e.tiers || []).slice().sort((m, d) => m.minSubtotal - d.minSubtotal);
+      let f;
+      for (const m of l)
+        if (o >= n(m.minSubtotal)) f = m;
+        else break;
+      !f && l.length && (f = l[0]), f && (t = Math.max(0, n(f.cost)), f.cost === 0 && (a = !0), i = f.label || e.label || "Shipping");
+      break;
+    }
+    case "function": {
+      if (typeof e.calculate == "function") {
+        const l = e.calculate(o, r);
+        t = Math.max(0, n(l?.cost)), l?.isFree && (a = !0), l?.label && (i = l.label);
+      }
+      break;
+    }
+  }
+  return {
+    cost: u(t, 2),
+    isFree: a,
+    label: i,
+    freeShippingProgress: e.mode === "freeOver" && c > 0 && !a ? { remaining: u(s, 2), threshold: c } : null
+  };
+}
+function T(o) {
+  const { items: e, tax: r, shipping: t, coupon: a, currency: i } = o, c = o.roundToCents ?? 2, s = u(h(e, !1), c);
+  u(h(e, !0), c);
+  const l = u(M(e), c), f = S(e), m = u(y(a, s, i), c), d = u(Math.max(0, s - m), c);
+  let x = d;
+  r?.applyTo === "subtotal" && (x = s), r?.applyTo === "original" && (x = s);
+  const b = k(x, r, c), p = g(
+    r?.applyTo === "original" ? s : d,
+    t,
+    e
+  ), v = u(
+    Math.max(0, d + b.total + p.cost),
+    c
+  );
+  return {
+    totals: {
+      subtotal: s,
+      discount: m > 0 ? m : void 0,
+      estimatedTax: b.total > 0 ? b.total : void 0,
+      taxRate: r?.mode === "rate" || r?.mode === "inclusive" ? r.rate : void 0,
+      shipping: p.cost,
+      grandTotal: v,
+      itemCount: f,
+      totalSavings: l > 0 ? l : void 0,
+      currency: i || r?.currency || t?.currency
+    },
+    taxBreakdown: b.breakdown,
+    freeShippingProgress: p.freeShippingProgress
+  };
+}
+function w(o) {
+  return T(o());
+}
+export {
+  T as calculateCartTotals,
+  y as computeCouponDiscount,
+  g as computeShipping,
+  k as computeTax,
+  S as sumItemCount,
+  h as sumLineTotals,
+  M as sumSavings,
+  w as useCartCalculation
+};

package/components/Cart/index.d.ts

@@ -0,0 +1,9 @@
+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 { useCart } from './composables/useCart';
+export type { CartItemId, UseCartOptions, UseCartReturn } from './composables/useCart';
+export * from './composables/useCartCalculation';
+export * from './types';