ng-miam 10.5.11 → 10.6.0

package/bundles/ng-miam.umd.js

@@ -1646,6 +1646,202 @@
         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.0"; // TODO: replace by ##VERSION## and update it in the CI/CD
 
     var ContextRegistryService = /** @class */ (function () {
         function ContextRegistryService() {
@@ -11184,7 +11380,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; })),