@salla.sa/twilight-components 3.0.23 → 3.0.25

package/dist/collection/components/salla-next-order-coupon/salla-next-order-coupon.js

@@ -43,6 +43,13 @@ export class SallaNextOrderCoupon {
         this.expiresTpl = Salla.lang.get('pages.thank_you.next_order_coupon_expires') || '';
     }
     async loadCoupons() {
+        // Store emits this marker only in edit-theme mode. An iframe alone is not
+        // sufficient: customer receipts embedded elsewhere must still use real coupons.
+        if (document.getElementById('theme-editor-script')) {
+            this.coupons = [{ code: 'PREVIEW15', type: 'P', amount: 15 }];
+            this.isLoading = false;
+            return;
+        }
         try {
             const response = await salla.api.request('coupons', { params: { type: 'thankyou' } });
             const raw = response?.data;

package/dist/collection/components/salla-order-shipments/salla-order-shipments.js

@@ -37,11 +37,7 @@ export class SallaOrderShipments {
         return this.fetchShipments();
     }
     readInitialShipments(value) {
-        // Shipment grouping and tracking stay behind the feature flag; without it only the items render.
-        if (!this.enabled) {
-            this.shipments = [];
-            return;
-        }
+        // Fulfillment visibility follows order data, not the store’s split-shipment capability.
         try {
             const parsed = typeof value === 'string' ? JSON.parse(value) : value;
             this.shipments = Array.isArray(parsed) ? parsed : [];
@@ -68,8 +64,6 @@ export class SallaOrderShipments {
     async fetchShipments() {
         // supersede whatever is in flight first — the guards below can bail out before run() would
         this.request.abort();
-        if (!this.enabled)
-            return;
         const orderId = this.orderId || salla.config.get('page.id');
         if (!orderId)
             return;
@@ -102,9 +96,6 @@ export class SallaOrderShipments {
     label(key, fallback) {
         return salla.lang.getWithDefault(key, fallback);
     }
-    get enabled() {
-        return salla.config.get('store.features', []).includes('thankyou-page-multi-shipments');
-    }
     get isSplit() {
         return this.shipments.length > 1;
     }

package/dist/collection/shared/cart-free-gifts.js

@@ -29,6 +29,9 @@
  * `twilight/packages/twilight/src/api/cart.js:831-846`.
  */
 const EMPTY_GIFT_ITEMS = Object.freeze([]);
+const EMPTY_PRODUCT_LINES = Object.freeze([]);
+/** Every line from the last parsed response — published in the SAME pass as `itemsCache`. */
+let linesCache = null;
 /**
  * The gift LINES from the last parsed response. `null` is the single "nothing has loaded
  * yet" flag shared with `countCache`, which keeps the two from ever disagreeing about
@@ -130,6 +133,7 @@ function syncCartIdentity() {
     if (cacheIdentity !== undefined && cacheIdentity !== current) {
         generation++;
         itemsCache = null;
+        linesCache = null;
         countCache = null;
         isAuthoritative = false;
         pendingRequest = null;
@@ -254,6 +258,24 @@ function buildGiftItems(items) {
     }
     return gifts;
 }
+/** Every line of the cart, in cart order — see `CartProductLine`. */
+function buildProductLines(items) {
+    const lines = [];
+    for (const item of items) {
+        if (item?.id === undefined || item?.id === null)
+            continue;
+        const quantity = toNumber(item.quantity);
+        lines.push({
+            id: String(item.id),
+            productId: toNullableNumber(item.product_id),
+            quantity,
+            // Only a line the server flagged as granted by a cart offer has free units.
+            freeQuantity: item.added_by_offer ? Math.max(0, resolveFreeQuantity(item, quantity)) : 0,
+            offerId: item.added_by_offer ? toNullableNumber(item.offer_id) : null,
+        });
+    }
+    return lines;
+}
 function fetchAndCache() {
     if (pendingRequest)
         return pendingRequest;
@@ -268,6 +290,7 @@ function fetchAndCache() {
         // Both projections come out of the SAME response, in one pass.
         return {
             gifts: buildGiftItems(items),
+            lines: buildProductLines(items),
             count: extractCartCount(res, found),
             // The response was reached and parsed — these values are the cart, so the cache
             // they land in may be short-circuited on. See `isAuthoritative`.
@@ -287,6 +310,7 @@ function fetchAndCache() {
         // connection can never claim the cart is empty.
         .catch((error) => ({
         gifts: itemsCache ?? [],
+        lines: linesCache ?? [],
         count: isCartNotCreated(error) ? 0 : countCache,
         /**
          * NOT authoritative, `CartNotCreated` included.
@@ -303,13 +327,14 @@ function fetchAndCache() {
          */
         ok: false,
     }))
-        .then(({ gifts, count, ok }) => {
+        .then(({ gifts, lines, count, ok }) => {
         // Only publish if nothing invalidated us while we were in flight.
         // Otherwise this is pre-mutation data racing a newer, authoritative
         // request — publishing it would make the lookups short-circuit on stale
         // data until the NEXT mutation happens to come along.
         if (startedAtGeneration === generation) {
             itemsCache = gifts;
+            linesCache = lines;
             countCache = count;
             isAuthoritative = ok;
         }
@@ -338,6 +363,20 @@ export function getCartFreeGiftItems() {
     }
     return fetchAndCache().then(() => itemsCache ?? EMPTY_GIFT_ITEMS);
 }
+/**
+ * Every line of the cart (paid and free), in cart order — for the CP-2171 free product picker.
+ *
+ * Shares the cache, the in-flight promise and the generation guard with
+ * `getCartFreeGiftItems()` and `getCartItemCount()`: no request of its own, and never a
+ * different cart state from theirs.
+ */
+export function getCartProductLines() {
+    syncCartIdentity();
+    if (isAuthoritative && itemsCache) {
+        return Promise.resolve(linesCache ?? EMPTY_PRODUCT_LINES);
+    }
+    return fetchAndCache().then(() => linesCache ?? EMPTY_PRODUCT_LINES);
+}
 /**
  * Whether the cached cart picture came from a response that was actually reached and
  * parsed, rather than from the fallback a rejected lookup publishes.
@@ -410,6 +449,7 @@ export function refreshCartFreeGifts() {
         return pendingRefresh;
     generation++;
     itemsCache = null;
+    linesCache = null;
     countCache = null;
     isAuthoritative = false;
     // This invalidation already covers whatever id the cart has now.
@@ -439,6 +479,7 @@ export function refreshCartFreeGifts() {
 /** @internal exported for tests only — resets module-level state between specs. */
 export function __resetCartFreeGiftsForTests() {
     itemsCache = null;
+    linesCache = null;
     countCache = null;
     isAuthoritative = false;
     pendingRequest = null;

package/dist/collection/shared/coupons-request.js

@@ -0,0 +1,47 @@
+/*!
+ * Crafted with ❤ by Salla
+ */
+/**
+ * One shared GET /coupons per page view (CHKM-594).
+ *
+ * Every `salla-cart-coupons` instance (a re-created drawer, a second mount) used to hit the
+ * endpoint on its own. They now share one in-flight/settled promise, keyed by everything the
+ * response varies on, so a currency / language / scope change automatically misses the cache.
+ */
+const requests = new Map();
+// Same source the request layer uses to send the scope (lib/request.js): config first, then storage.
+const requestKey = () => {
+    const scope = salla.config.get('store.scope', salla.storage.get('scope'));
+    return [
+        ...['store.id', 'user.currency_code', 'user.language_code'].map(key => String(salla.config.get(key, ''))),
+        String(scope?.id ?? ''),
+    ].join('|');
+};
+/** Drop every cached request, so the next load refetches. */
+export const resetCouponsRequest = () => {
+    requests.clear();
+};
+// A coupon added or removed changes what the endpoint returns (and what is still applicable).
+// off-then-on keeps the subscription single however often (or after whatever reset) this runs.
+const invalidateOnCouponChange = () => {
+    ['cart::coupon.added', 'cart::coupon.deleted'].forEach(eventName => {
+        salla.event.off(eventName, resetCouponsRequest);
+        salla.event.on(eventName, resetCouponsRequest);
+    });
+};
+export const getCouponsRequest = () => {
+    invalidateOnCouponChange();
+    const key = requestKey();
+    let request = requests.get(key);
+    if (!request) {
+        request = salla.api.request('coupons');
+        requests.set(key, request);
+        const failed = request;
+        // A failed request must never stick: let the next caller retry.
+        failed.catch(() => {
+            if (requests.get(key) === failed)
+                requests.delete(key);
+        });
+    }
+    return request;
+};

package/dist/collection/shared/offer-stages.js

@@ -180,8 +180,13 @@ export function sortByThreshold(items, getThreshold, getIdentity) {
  * @param rawTierValues each stage's OWN `current_value`, aligned the same way. A tier
  *        without a readable one is measured by `currentValue`, so omitting it — an older
  *        backend — changes nothing. See `OfferStageProgress.values`.
+ * @param rawCanAddFree each stage's `can_add_free` (CP-2171), aligned the same way. Read
+ *        only in case (3), where no tier carries `is_applied`: a free product tier that
+ *        carries one is reached when the ENGINE says so, not when its `current_value` —
+ *        which counts the gift lines at full price — passes `min_spend`. Omit it and case
+ *        (3) is the threshold behaviour, unchanged.
  */
-export function computeOfferStageProgress(currentValue, rawThresholds, rawStartValue = 0, rawApplied = [], rawTierValues = []) {
+export function computeOfferStageProgress(currentValue, rawThresholds, rawStartValue = 0, rawApplied = [], rawTierValues = [], rawCanAddFree = []) {
     // Unparseable thresholds are dropped, not zeroed — see `isUsableThreshold`.
     //
     // The flag travels WITH its threshold through both the drop and the sort. Sorting two
@@ -194,6 +199,7 @@ export function computeOfferStageProgress(currentValue, rawThresholds, rawStartV
         threshold: parseNumeric(threshold),
         applied: readAppliedFlag(rawApplied?.[index]),
         tierValue: parseNumeric(rawTierValues?.[index]),
+        canAddFree: typeof rawCanAddFree?.[index] === 'boolean' ? rawCanAddFree[index] : undefined,
     }))
         .filter((entry) => entry.threshold !== null)
         .sort((a, b) => a.threshold - b.threshold || a.index - b.index);
@@ -281,12 +287,25 @@ export function computeOfferStageProgress(currentValue, rawThresholds, rawStartV
             appliedIndex = index;
         }
     }
-    // Case (3) closes the prefix at `lastReachedIndex` rather than comparing tier by tier.
+    // Case (3) closes the prefix at the last reached tier rather than comparing tier by tier.
     // With one value for every tier the two are the same statement; with per-tier values
     // it is what keeps `met` a prefix, on the same single-winner reasoning as case (1).
+    //
+    // CP-2171 — a tier that carries `can_add_free` is reached on the engine's answer, not on
+    // its value: a guest with 40 paid and three listed gifts in the cart has a value past
+    // `min_spend`, yet every gift is charged. Only `met` reads it; the bar (`lastReachedIndex`,
+    // `fills`, `isComplete`) stays the threshold projection, and the guidance line, finding
+    // nothing left to spend, says the conditions are not met.
+    let lastMetIndex = NO_STAGE_REACHED;
+    for (let index = 0; index < thresholds.length; index++) {
+        const canAddFree = entries[index].canAddFree;
+        if (canAddFree === undefined ? values[index] >= thresholds[index] : canAddFree) {
+            lastMetIndex = index;
+        }
+    }
     const met = hasEngineVerdict
         ? thresholds.map((_, index) => index <= appliedIndex)
-        : thresholds.map((_, index) => index <= lastReachedIndex);
+        : thresholds.map((_, index) => index <= lastMetIndex);
     const metCount = met.filter(Boolean).length;
     const nextUnmetIndex = met.findIndex(isMet => !isMet); // -1 === NO_STAGE_REACHED
     const allMet = nextUnmetIndex === NO_STAGE_REACHED;