ng-miam 10.5.11 → 10.6.1

package/bundles/ng-miam.umd.js

@@ -1640,12 +1640,208 @@
         env: 'prod',
         miamAPI: 'https://api.miam.tech',
         miamWeb: 'https://miam.tech',
-        mealzComponents: 'https://cdn.jsdelivr.net/npm/mealz-components@2.10/dist',
+        mealzComponents: 'https://cdn.jsdelivr.net/npm/mealz-components@2.11/dist',
         mealzSsrApi: 'https://ssr-api.mealz.ai',
         lang: 'fr',
         analyticsEnabled: true // Only used in DEV mode
     };
 
+    var WINDOW_SINGLETON_KEY = '__mealzRecipeCardShowTracker__';
+    /**
+     * Tracks recipe.show events and prevents duplicates (first show, or again after scroll).
+     * Shared across SDK and Lit recipe cards via {@link WINDOW_SINGLETON_KEY} on window.
+     */
+    var RecipeCardShowTracker = /** @class */ (function () {
+        function RecipeCardShowTracker() {
+            var _this = this;
+            this.trackedRecipes = new Map();
+            this.hasScrolled = false;
+            this.scrollListener = null;
+            this.cleanupInterval = null;
+            this.MAX_RECIPES = 1000;
+            this.CLEANUP_INTERVAL = 5 * 60 * 1000;
+            this.handlePageUnload = function () {
+                _this.destroy();
+            };
+            this.setupScrollListener();
+            this.startAutoCleanup();
+            this.setupPageUnloadListener();
+        }
+        RecipeCardShowTracker.getInstance = function () {
+            var w = typeof window !== 'undefined'
+                ? window
+                : undefined;
+            var fromWindow = w === null || w === void 0 ? void 0 : w[WINDOW_SINGLETON_KEY];
+            if (fromWindow) {
+                RecipeCardShowTracker.instance = fromWindow;
+                return fromWindow;
+            }
+            if (!RecipeCardShowTracker.instance) {
+                RecipeCardShowTracker.instance = new RecipeCardShowTracker();
+                if (w) {
+                    w[WINDOW_SINGLETON_KEY] = RecipeCardShowTracker.instance;
+                }
+            }
+            return RecipeCardShowTracker.instance;
+        };
+        RecipeCardShowTracker.prototype.trackRecipeShow = function (recipeId, analyticsPath, categoryId) {
+            var _a, _b;
+            var now = Date.now();
+            var lastShowTime = this.trackedRecipes.get(recipeId);
+            var isFirstShow = !lastShowTime;
+            var hasScrolledSinceLastShow = this.hasScrolled;
+            if (!isFirstShow && !hasScrolledSinceLastShow) {
+                return;
+            }
+            if (this.trackedRecipes.size >= this.MAX_RECIPES) {
+                this.cleanOldRecipes();
+            }
+            this.trackedRecipes.set(recipeId, now);
+            (_b = (_a = window.mealzInternal) === null || _a === void 0 ? void 0 : _a.analytics) === null || _b === void 0 ? void 0 : _b.sendEvent('recipe.show', analyticsPath, {
+                recipe_id: recipeId,
+                category_id: categoryId
+            });
+        };
+        RecipeCardShowTracker.prototype.cleanOldRecipes = function () {
+            var e_1, _c;
+            var now = Date.now();
+            var oneHourAgo = now - (60 * 60 * 1000);
+            try {
+                for (var _d = __values(this.trackedRecipes.entries()), _e = _d.next(); !_e.done; _e = _d.next()) {
+                    var _f = __read(_e.value, 2), recipeId = _f[0], timestamp = _f[1];
+                    if (timestamp < oneHourAgo) {
+                        this.trackedRecipes.delete(recipeId);
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_e && !_e.done && (_c = _d.return)) _c.call(_d);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        };
+        RecipeCardShowTracker.prototype.clearAllRecipes = function () {
+            this.trackedRecipes.clear();
+        };
+        RecipeCardShowTracker.prototype.destroy = function () {
+            if (this.scrollListener) {
+                document.removeEventListener('scroll', this.scrollListener, true);
+                this.scrollListener = null;
+            }
+            window.removeEventListener('beforeunload', this.handlePageUnload);
+            if (this.cleanupInterval) {
+                clearInterval(this.cleanupInterval);
+                this.cleanupInterval = null;
+            }
+            this.trackedRecipes.clear();
+            this.hasScrolled = false;
+            RecipeCardShowTracker.instance = null;
+            if (typeof window !== 'undefined') {
+                delete window[WINDOW_SINGLETON_KEY];
+            }
+        };
+        RecipeCardShowTracker.prototype.setupScrollListener = function () {
+            var _this = this;
+            var scrollTimeout;
+            this.scrollListener = function () {
+                _this.hasScrolled = true;
+                clearTimeout(scrollTimeout);
+                scrollTimeout = window.setTimeout(function () {
+                    _this.hasScrolled = false;
+                }, 2000);
+            };
+            document.addEventListener('scroll', this.scrollListener, {
+                passive: true,
+                capture: true,
+            });
+        };
+        RecipeCardShowTracker.prototype.startAutoCleanup = function () {
+            var _this = this;
+            this.cleanupInterval = window.setInterval(function () {
+                _this.cleanOldRecipes();
+            }, this.CLEANUP_INTERVAL);
+        };
+        RecipeCardShowTracker.prototype.setupPageUnloadListener = function () {
+            window.addEventListener('beforeunload', this.handlePageUnload);
+        };
+        return RecipeCardShowTracker;
+    }());
+    RecipeCardShowTracker.instance = null;
+
+    var ViewportListenerParams = /** @class */ (function () {
+        function ViewportListenerParams() {
+            this.condition = true;
+            this.threshold = 0;
+            this.debounce = 0;
+        }
+        return ViewportListenerParams;
+    }());
+    var ViewportListener = /** @class */ (function () {
+        function ViewportListener(element, callback, params) {
+            var _this = this;
+            if (params === void 0) { params = {}; }
+            this.element = element;
+            this.callback = callback;
+            this.params = params;
+            this.intersectionSubject = new rxjs.Subject();
+            this.subscriptions = [];
+            this.params = Object.assign(Object.assign({}, new ViewportListenerParams()), params);
+            var options = {
+                root: null,
+                rootMargin: '0px',
+                threshold: this.params.threshold
+            };
+            this.observer = new IntersectionObserver(function (entries) {
+                entries.forEach(function (entry) { return _this.intersectionSubject.next(entry); });
+            }, options);
+            this.connect();
+        }
+        ViewportListener.prototype.connect = function () {
+            var _this = this;
+            this.subscriptions.push(this.intersectionSubject
+                .pipe(operators.debounceTime(this.params.debounce))
+                .subscribe(function (entry) { return _this.handleIntersection(entry); }));
+            this.observer.observe(this.element);
+        };
+        ViewportListener.prototype.disconnect = function () {
+            if (this.observer) {
+                this.observer.disconnect();
+            }
+            this.intersectionSubject.complete();
+            this.subscriptions.forEach(function (sub) { return sub.unsubscribe(); });
+        };
+        ViewportListener.prototype.handleIntersection = function (entry) {
+            if (this.params.condition && entry.isIntersecting) {
+                this.callback();
+            }
+        };
+        return ViewportListener;
+    }());
+
+    var RECIPE_CARD_SHOW_ANALYTICS_PATH = '/recipes';
+    /** Same visibility rule as `mealz-recipe-card`: IntersectionObserver ratio ≥ this value. */
+    var RECIPE_CARD_SHOW_VISIBILITY_THRESHOLD = 0.8;
+    /** Same timing as `mealz-recipe-card`: debounce on intersection stream (ms). */
+    var RECIPE_CARD_SHOW_DEBOUNCE_MS = 1000;
+    /**
+     * Same `recipe.show` pipeline as `mealz-recipe-card`: viewport visibility + deduped tracking.
+     * Call `disconnect()` when the host node is removed (virtual lists, SPA navigation).
+     */
+    function attachRecipeCardShowTracking(options) {
+        var element = options.element, recipeId = options.recipeId, _a = options.analyticsPath, analyticsPath = _a === void 0 ? RECIPE_CARD_SHOW_ANALYTICS_PATH : _a, _b = options.categoryId, categoryId = _b === void 0 ? '' : _b;
+        var listener = new ViewportListener(element, function () {
+            RecipeCardShowTracker.getInstance().trackRecipeShow(recipeId, analyticsPath, categoryId);
+        }, {
+            threshold: RECIPE_CARD_SHOW_VISIBILITY_THRESHOLD,
+            debounce: RECIPE_CARD_SHOW_DEBOUNCE_MS
+        });
+        return {
+            disconnect: function () { return listener.disconnect(); }
+        };
+    }
+
     var Ingredient = /** @class */ (function (_super) {
         __extends(Ingredient, _super);
         function Ingredient() {
@@ -3452,7 +3648,7 @@
         EventJourney["EMPTY"] = "";
     })(EventJourney || (EventJourney = {}));
 
-    var VERSION = "10.5.11"; // TODO: replace by ##VERSION## and update it in the CI/CD
+    var VERSION = "10.6.1"; // TODO: replace by ##VERSION## and update it in the CI/CD
 
     var ContextRegistryService = /** @class */ (function () {
         function ContextRegistryService() {
@@ -5577,7 +5773,10 @@
         RecipesService.prototype.getSuggestedRecipes = function () {
             var _this = this;
             var pref = this.buildfilterUrlFromPreferences();
-            var url = pref ? MIAM_API_HOST$2 + "recipes/suggest?" + pref.slice(1) : MIAM_API_HOST$2 + "recipes/suggest";
+            var params = new URLSearchParams(pref ? pref.slice(1) : '');
+            params.append('include', 'sponsors');
+            params.append('fields[sponsors]', 'logo-url');
+            var url = MIAM_API_HOST$2 + "recipes/suggest?" + params.toString();
             return this.http.get(url, {
                 headers: {
                     'Cache-Control': 'no-cache, no-store, must-revalidate',
@@ -6012,6 +6211,7 @@
             _this.basketPreviewIsCalculating$ = new rxjs.BehaviorSubject(true);
             _this.basketInitCalled = false;
             _this.recipesAdded = new i0.EventEmitter();
+            _this.recipesAddFailed = new i0.EventEmitter();
             _this.confirming = new rxjs.BehaviorSubject(false);
             _this.currentlyAddingRecipes = [];
             _this.basketActionsQueue = new rxjs.BehaviorSubject([]);
@@ -6196,8 +6396,30 @@
             return this.basket$.pipe(operators.skipWhile(function (b) { return !b; }), operators.map(function (basket) { return basket.hasRecipe(recipeId); }));
         };
         BasketsService.prototype.guestsForRecipe = function (recipeId) {
+            return this.resolveGuestsForRecipe(recipeId);
+        };
+        BasketsService.prototype.resolveGuestsForRecipe = function (recipeId) {
+            var _a;
+            var guestsFromBasket = (_a = this.basket$.value) === null || _a === void 0 ? void 0 : _a.guestsForRecipe(recipeId);
+            if (Number.isFinite(guestsFromBasket)) {
+                return guestsFromBasket;
+            }
+            var pendingRecipeAction = __spread(this.actionsBeingProcessed.value, this.basketActionsQueue.value).find(function (action) { return (action.type === BasketActionType.ADD_RECIPE || action.type === BasketActionType.ADD_RECIPE_LIGHT) &&
+                action.params.recipeId === recipeId &&
+                Number.isFinite(action.params.guests); });
+            return pendingRecipeAction === null || pendingRecipeAction === void 0 ? void 0 : pendingRecipeAction.params.guests;
+        };
+        /**
+         * Waits until the given recipe is in the basket before resolving.
+         * Emits `true` when the recipe is confirmed in the basket, `false` when its addition failed,
+         * so callers can avoid firing dependent requests (e.g. add-ingredient) against a recipe that was never created.
+         */
+        BasketsService.prototype.waitUntilRecipeInBasket = function (recipeId) {
             var _a;
-            return (_a = this.basket$.value) === null || _a === void 0 ? void 0 : _a.guestsForRecipe(recipeId);
+            if (!recipeId || ((_a = this.basket$.value) === null || _a === void 0 ? void 0 : _a.hasRecipe(recipeId))) {
+                return rxjs.of(true);
+            }
+            return rxjs.merge(this.basket$.pipe(operators.skipWhile(function (basket) { return !(basket === null || basket === void 0 ? void 0 : basket.hasRecipe(recipeId)); }), operators.take(1), operators.map(function () { return true; })), this.recipesAdded.pipe(operators.skipWhile(function (recipeIds) { return !recipeIds.includes(recipeId); }), operators.take(1), operators.map(function () { return true; })), this.recipesAddFailed.pipe(operators.skipWhile(function (recipeIds) { return !recipeIds.includes(recipeId); }), operators.take(1), operators.map(function () { return false; }))).pipe(operators.take(1));
         };
         BasketsService.prototype.showRecipeAddedToaster = function () {
             var _this = this;
@@ -6578,8 +6800,11 @@
         /** *************************************************** PROCESS THE ACTIONS QUEUE *************************************************** **/
         BasketsService.prototype.emptyActionsQueue = function () {
             var _this = this;
-            if (this.basketActionsQueue.value.length > 0) {
+            if (this.basketActionsQueue.value.length > 0 && this.actionsBeingProcessed.value.length === 0) {
                 var actionsToProcess_1 = this.nextActionsBatch();
+                if (actionsToProcess_1.length === 0) {
+                    return;
+                }
                 this.actionsBeingProcessed.next(__spread(actionsToProcess_1));
                 if (actionsToProcess_1.length > 0) {
                     this.processActionsBatch(actionsToProcess_1).subscribe(function () {
@@ -6595,14 +6820,16 @@
          * @returns the next batch of actions to process
          */
         BasketsService.prototype.nextActionsBatch = function () {
+            var _this = this;
+            var pendingActions = this.basketActionsQueue.value.filter(function (action) { return !_this.actionsBeingProcessed.value.includes(action); });
             var batch = [];
-            var i = 0;
-            var currentAction = this.basketActionsQueue.value[i];
+            var index = 0;
+            var currentAction = pendingActions[index];
             var shouldForceStop = false;
-            while (this.basketActionsQueue.value[i] && this.basketActionsQueue.value[i].type === currentAction.type && !shouldForceStop) {
-                currentAction = this.basketActionsQueue.value[i];
+            while (pendingActions[index] && pendingActions[index].type === currentAction.type && !shouldForceStop) {
+                currentAction = pendingActions[index];
                 shouldForceStop = this.addActionToBatchOrStopProcessingBatch(batch, currentAction);
-                i++;
+                index++;
             }
             return batch;
         };
@@ -6727,6 +6954,10 @@
                 return _this.http.post(postUrl, body).pipe(operators.switchMap(function (b) { var _a; return ((_a = b.data) === null || _a === void 0 ? void 0 : _a.id) ? _this.fillBasket(b) : rxjs.of(null); }), operators.tap(function () {
                     _this.recipesAdded.emit(recipeIds.map(function (r) { return r.recipe_id; }));
                     _this.currentlyAddingRecipes = _this.currentlyAddingRecipes.filter(function (id) { return !(_this.basket$.value.recipeInfos.find(function (i) { return i.id === id; })); });
+                }), operators.catchError(function () {
+                    _this.currentlyAddingRecipes = _this.currentlyAddingRecipes.filter(function (recipeId) { return !recipeIds.some(function (candidate) { return candidate.recipe_id === recipeId; }); });
+                    _this.recipesAddFailed.emit(recipeIds.map(function (r) { return r.recipe_id; }));
+                    return rxjs.of(null);
                 }));
             }), operators.catchError(function () { return rxjs.of(null); }));
         };
@@ -6786,23 +7017,32 @@
          */
         BasketsService.prototype.addItemsForIngredients = function (ingredientsToAdd) {
             var _this = this;
-            return this.waitForBasket.pipe(operators.switchMap(function (basket) {
-                var requests = ingredientsToAdd.map(function (action) {
-                    var modifiedGuests = _this.guestsForRecipe(action.params.recipeId);
-                    var patchUrl = environment$1.miamAPI + "/api/v1/baskets/" + basket.id + "/basket-entries/" + action.params.basketEntry.id + "/add-ingredient" +
-                        ("?ingredient_id=" + action.params.ingredientId + "&selected_item_id=" + action.params.basketEntry.selectedItem.id) +
-                        ("&guests=" + modifiedGuests + "&forced_quantity=" + action.params.basketEntry.quantity);
-                    return _this.http.patch(patchUrl, {});
-                });
-                return rxjs.forkJoin(requests);
-            }), operators.tap(function () {
-                // Determine journey: item-replacement if previousItem exists (indicates replacement), otherwise meals-space-recipe-details
-                var journey = ingredientsToAdd.some(function (action) { return action.params.previousItem; })
-                    ? 'item-replacement'
-                    : 'meals-space-recipe-details';
-                _this.analyticsService.sendAddProductsEvents(ingredientsToAdd, journey);
-            }), operators.switchMap(function () { return _this.reloadBasket(); }), operators.switchMap(function () { return rxjs.of(null); }), // Just to keep the return type as Observable<void> to match with the other methods
-            operators.catchError(function () { return rxjs.of(null); }));
+            var _a;
+            var recipeId = (_a = ingredientsToAdd[0]) === null || _a === void 0 ? void 0 : _a.params.recipeId;
+            return this.waitUntilRecipeInBasket(recipeId).pipe(operators.switchMap(function (recipeIsInBasket) {
+                // The parent recipe add failed: skip add-ingredient to avoid a request against a recipe that was never created
+                // (which would leave the retailer basket updated while Mealz stays out of sync).
+                if (!recipeIsInBasket) {
+                    return rxjs.of(null);
+                }
+                return _this.waitForBasket.pipe(operators.switchMap(function (basket) {
+                    var requests = ingredientsToAdd.map(function (action) {
+                        var modifiedGuests = _this.resolveGuestsForRecipe(action.params.recipeId);
+                        var patchUrl = environment$1.miamAPI + "/api/v1/baskets/" + basket.id + "/basket-entries/" + action.params.basketEntry.id + "/add-ingredient" +
+                            ("?ingredient_id=" + action.params.ingredientId + "&selected_item_id=" + action.params.basketEntry.selectedItem.id) +
+                            ("&guests=" + modifiedGuests + "&forced_quantity=" + action.params.basketEntry.quantity);
+                        return _this.http.patch(patchUrl, {});
+                    });
+                    return rxjs.forkJoin(requests);
+                }), operators.tap(function () {
+                    // Determine journey: item-replacement if previousItem exists (indicates replacement), otherwise meals-space-recipe-details
+                    var journey = ingredientsToAdd.some(function (action) { return action.params.previousItem; })
+                        ? 'item-replacement'
+                        : 'meals-space-recipe-details';
+                    _this.analyticsService.sendAddProductsEvents(ingredientsToAdd, journey);
+                }), operators.switchMap(function () { return _this.reloadBasket(); }), operators.switchMap(function () { return rxjs.of(null); }) // Just to keep the return type as Observable<void> to match with the other methods
+                );
+            }), operators.catchError(function () { return rxjs.of(null); }));
         };
         /**
          * Add items to the basket HTTP request.
@@ -8420,17 +8660,27 @@
 
     var BasketUtilsService = /** @class */ (function () {
         function BasketUtilsService(basketsService, recipesService, priceService, basketSynchroService, analyticsService, loadLitDrawerService) {
+            var _this = this;
             this.basketsService = basketsService;
             this.recipesService = recipesService;
             this.priceService = priceService;
             this.basketSynchroService = basketSynchroService;
             this.analyticsService = analyticsService;
             this.loadLitDrawerService = loadLitDrawerService;
+            this.removeRecipeJobs$ = new rxjs.Subject();
             this.recipesWithEntries = [];
             this.basketPreviewState$ = new rxjs.BehaviorSubject({
                 isOpen: false,
                 activeTabIndex: 0 // Default to the first tab (recipes)
             });
+            this.removeRecipeJobs$.pipe(operators.concatMap(function (_a) {
+                var recipeId = _a.recipeId, analyticsPath = _a.analyticsPath, result$ = _a.result$;
+                return _this.removeRecipeInternal(recipeId, analyticsPath).pipe(operators.tap({
+                    next: function (value) { return result$.next(value); },
+                    error: function (error) { return result$.error(error); },
+                    complete: function () { return result$.complete(); }
+                }), operators.catchError(function () { return rxjs.EMPTY; }));
+            })).subscribe();
         }
         /**
          * Builds a preview of recipes in the basket, including their total price and total number of products per recipe.
@@ -8456,6 +8706,15 @@
             });
         };
         BasketUtilsService.prototype.removeRecipe = function (recipeId, analyticsPath) {
+            var _this = this;
+            return new rxjs.Observable(function (subscriber) {
+                var result$ = new rxjs.Subject();
+                var resultSubscription = result$.subscribe(subscriber);
+                _this.removeRecipeJobs$.next({ recipeId: recipeId, analyticsPath: analyticsPath, result$: result$ });
+                return function () { return resultSubscription.unsubscribe(); };
+            });
+        };
+        BasketUtilsService.prototype.removeRecipeInternal = function (recipeId, analyticsPath) {
             var _this = this;
             return this.fetchDataToRemoveRecipe(recipeId).pipe(operators.switchMap(function (_a) {
                 var recipe = _a.recipe, basketEntries = _a.basketEntries;
@@ -11184,7 +11443,8 @@
                         _this.analyticsService.init(domain);
                     },
                     eventSent$: this.analyticsService.eventEmitter,
-                    setAbTestKey: function (key) { return _this.analyticsService.setAbTestKey(key); }
+                    setAbTestKey: function (key) { return _this.analyticsService.setAbTestKey(key); },
+                    attachRecipeCardShowTracking: attachRecipeCardShowTracking
                 },
                 basket: {
                     basketIsReady$: this.basketsService.basketStats$.pipe(operators.skipWhile(function (stats) { return !stats; }), operators.take(1), operators.map(function () { return true; })),
@@ -13194,7 +13454,7 @@
         env: 'prod',
         miamAPI: 'https://api.miam.tech',
         miamWeb: 'https://miam.tech',
-        mealzComponents: 'https://cdn.jsdelivr.net/npm/mealz-components@2.10/dist',
+        mealzComponents: 'https://cdn.jsdelivr.net/npm/mealz-components@2.11/dist',
         mealzSsrApi: 'https://ssr-api.mealz.ai',
         lang: 'fr',
         analyticsEnabled: true // Only used in DEV mode