ng-miam 9.1.28 → 9.1.30

package/bundles/ng-miam.umd.js

@@ -1838,6 +1838,178 @@
       analyticsEnabled: true // Only used in DEV mode
   };
 
+  var WINDOW_SINGLETON_KEY = '__mealzRecipeCardShowTracker__';
+  /**
+   * Tracks recipe.show events and prevents duplicates for 5 minutes per recipe.
+   * 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.cleanupInterval = null;
+          this.MAX_RECIPES = 1000;
+          this.CLEANUP_INTERVAL = 5 * 60 * 1000;
+          this.SHOW_COOLDOWN_MS = 5 * 60 * 1000;
+          this.handlePageUnload = function () {
+              _this.destroy();
+          };
+          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);
+          if (lastShowTime && (now - lastShowTime) < this.SHOW_COOLDOWN_MS) {
+              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 () {
+          window.removeEventListener('beforeunload', this.handlePageUnload);
+          if (this.cleanupInterval) {
+              clearInterval(this.cleanupInterval);
+              this.cleanupInterval = null;
+          }
+          this.trackedRecipes.clear();
+          RecipeCardShowTracker.instance = null;
+          if (typeof window !== 'undefined') {
+              delete window[WINDOW_SINGLETON_KEY];
+          }
+      };
+      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() {
@@ -3651,7 +3823,7 @@
       EventJourney["EMPTY"] = "";
   })(EventJourney || (EventJourney = {}));
 
-  var VERSION = "9.1.28"; // TODO: replace by ##VERSION## and update it in the CI/CD
+  var VERSION = "9.1.30"; // TODO: replace by ##VERSION## and update it in the CI/CD
 
   var ContextRegistryService = /** @class */ (function () {
       function ContextRegistryService() {
@@ -8130,7 +8302,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; })),
@@ -8249,7 +8422,7 @@
                       if (plannerOrCategoryId === void 0) { plannerOrCategoryId = null; }
                       if (categoryId === void 0) { categoryId = null; }
                       var resolvedCategoryId = typeof plannerOrCategoryId === 'string' ? plannerOrCategoryId : categoryId;
-                      return _this.recipesService.openRecipeDetails(recipeId, guests, initialTabIndex, path, resolvedCategoryId);
+                      return _this.recipesService.openRecipeDetails(recipeId, guests, initialTabIndex, '', resolvedCategoryId);
                   },
                   setDefaultIngredientPicture: function (url) { return _this.defaultIngredientPicture = url; },
                   setDefaultRecipePicture: function (url) { return _this.defaultRecipePicture = url; },