webc-miam 10.5.10 → 10.5.11

package/interfaces/mealz-internal-interface.ts

@@ -1,8 +1,17 @@
 import { PlausibleProps } from 'mealz-shared-analytics';
-import { Observable } from 'rxjs';
-import { BasketEntry, Recipe, RecipeLike } from '../../_models';
+import { DocumentCollection } from 'miam-jsonapi';
+import { BehaviorSubject, Observable, ReplaySubject } from 'rxjs';
+import { Basket, BasketEntry, Ingredient, Item, Menu, MenuRecipe, PointOfSale, Recipe, RecipeLike, SponsorBlock, Supplier } from '../../_models';
 import { RecipePricing } from '../../_models/recipe-pricing';
+import { Tag } from '../../_models/tag';
+import { ProductCategory, ProductPrice, RecipeDisplay } from '../../_services';
+import { RecipeInBasketPreview } from '../../_services/basket-utils.service';
+import { Product } from '../../_services/new-recipe-details.service';
+import { BasicPreference } from '../../_services/preferences.service';
+import { ProductPlanner, ProductPlannerCategory } from '../../_services/recipe-details-products-planner.service';
+import { BasketEntryToReplace } from '../../_services/replace-item.service';
 import { EventJourney } from '../event-journey.enum';
+import { EventTrace } from '../event-trace';
 
 export interface MealzInternalInterface {
 
@@ -33,32 +42,83 @@ export interface MealzInternalInterface {
     /**
      * Emits the pricing information for recipes in the basket.
      */
-    recipeDataInBasket$: () => Observable<{ id: string; price: string, guests: number }[]>;
+    recipePricesInBasket$: () => Observable<{ id: string; price: string }[]>;
+
+    /**
+     * Gets the guests count for a recipe
+     * @param recipeId
+     */
+    guestsForRecipe: (recipeId: string) => number;
+
+    /**
+     * Removes a recipe from the basket.
+     */
+    removeRecipe: (recipeId: string, analyticsPath: string) => void;
+
+    /**
+     * Emits the preview of recipes in the basket.
+     */
+    buildPreview: () => Observable<RecipeInBasketPreview[]>;
+
+
+    /**
+     * Observable that emits the full state of the basket preview including open state and active tab
+     */
+    basketPreviewState$: Observable<{ isOpen: boolean; activeTabIndex?: number }>;
 
     /**
      * Emits the list of recipes in the basket.
      */
     waitForBasketEntries: () => Observable<BasketEntry[]>;
-  };
 
-  // ---------------------------------------------------------------------------------------------------
+    /**
+     * Emits the list of basket-entries in the basket each time it changes.
+     */
+    entries$: () => Observable<BasketEntry[]>;
 
-  catalog: {
+    /**
+     * Refresh the current basket state and emit updated basket
+     */
+    refreshCurrentBasket: () => Observable<Basket>;
 
     /**
-     * Opens preferences modal
+     * if false, don't show the product section in the basket preview
      */
-    openPreferences: () => void;
+
+    displayProductsInBasket: () => boolean;
 
     /**
-     * Emits an observable that notifies subscribers when the preferences have changed
+     * Emits the list of basket-entries to add to retailer cart
      */
-    preferencesModalChanged: () => Observable<void>;
+    updateRetailerBasketFromPlanner: () => void;
+  };
 
+  basketTransfer: {
     /**
-     * returns an observable with the number of preferences set
+     * Exposes the transfer-in-progress state
      */
-    preferencesCount: () => Observable<number>;
+    basketIsBeingTransferred: BehaviorSubject<boolean>;
+
+    /**
+     * Abort the transfer (reloads basket)
+     */
+    abortTransfer: () => Observable<void>;
+
+    /**
+     * Navigate to the transfer URL stored in session
+     */
+    navigateToTransferUrl: () => void;
+
+    /**
+     * transfer basket to supplier
+     */
+
+    transfer: () => void;
+  };
+
+  // ---------------------------------------------------------------------------------------------------
+
+  catalog: {
 
     loadMoreRecipes: (packageId: string, page: number, pageSize: number, guests: number) => Observable<Recipe[]>;
   };
@@ -66,7 +126,151 @@ export interface MealzInternalInterface {
   // ---------------------------------------------------------------------------------------------------
 
   config: {
-    logLevel: Observable<string>
+    logLevel: Observable<string>;
+  };
+
+  // ---------------------------------------------------------------------------------------------------
+
+  planner: {
+    /**
+     * Emits the item to replace from recipe details view
+     */
+    itemToReplace$: BehaviorSubject<{ ingredient: Ingredient; item: Item }>;
+
+
+    /**
+     * Emits the list of items with prices
+     */
+    itemsWithPricesList$: BehaviorSubject<ProductPlanner[]>;
+
+
+    /**
+     * Emits if items are getting fetched
+     */
+    fetchingItemLoading$: BehaviorSubject<boolean>;
+
+    /**
+     * Emits an observable with the total price of the menu in the planner
+     */
+    menuPrice$: BehaviorSubject<number>;
+
+    /**
+     * Emits an observable with the price of the recipe currently displayed in the planner
+     */
+    plannerRecipePrice$: BehaviorSubject<number>;
+
+    /**
+     * creates a menu
+     */
+    createMenu: () => Observable<any>;
+
+    /**
+     * Deletes a menu from its id
+     * @param menuId
+     */
+    deleteMenu: (menuId: string) => Observable<void>;
+
+    /**
+     * Updates a menu with its id
+     * @param menuId
+     * @param toUpdate
+     */
+    updateMenu: (menuId: string, toUpdate: Partial<Menu>) => Observable<any>;
+
+    /**
+     * Add a recipe to a menu with its id
+     * @param recipeId
+     * @param guests
+     * @param autocomplete
+     */
+    addRecipeToMenu: (recipeId: string, guests: number, hasPos?: boolean, toPickProducts?: ProductPlanner[]) => Observable<MenuRecipe>;
+
+    /**
+     * Removes a recipe from a menu with its id
+     * @param recipeId
+     */
+    removeRecipeFromMenu: (recipeId: string) => Observable<void>;
+
+    /**
+     * Fetches the title of the menu
+     */
+    fetchMenuTitle: () => Observable<string>;
+
+    /**
+     * Transfers the menu to the basket
+     * @param basketId
+     */
+    menuToBasket: (basketId: string) => Observable<Menu>;
+
+    /**
+     * Gets the menu recipe id for a recipe
+     * @param recipeId
+     */
+    getMenuRecipeId: (recipeId: string) => Observable<string | undefined>;
+
+    /**
+     * Checks if a recipe is in the menu
+     * @param recipeId
+     */
+    isRecipeInMenu$: (recipeId: string) => Observable<boolean>;
+
+    /**
+     * Rejects a recipe suggestion to prevent it to be suggested again
+     * @param recipeId
+     */
+    rejectRecipe: (recipeId: string) => Observable<any>;
+
+    /**
+     * Selects a product in the planner
+     * @param itemId
+     * @param ingredientsDefinitionId
+     */
+    selectProduct: (itemId: number, ingredientsDefinitionId: string) => void;
+
+    /**
+     * Unselects a product in the planner
+     * @param itemId
+     * @param ingredientsDefinitionId
+     */
+    unselectProduct: (itemId: number, ingredientsDefinitionId: string) => void;
+
+    /**
+     * Replaces a product in the planner from the replace item modal
+     * @param product
+     */
+    replaceProduct: (product: ProductPlanner) => void;
+
+    /**
+     * Opens replace item view
+     * @param product
+     */
+    openReplaceItemView: (product: ProductPlanner) => void;
+
+    /**
+     * Searches for an item from replace item modal
+     * @param searchString
+     * @param ingredient
+     * @param item
+     */
+    searchItem(searchString: string, ingredient: Ingredient, item: Item): Observable<void>;
+
+    /**
+     * Gets suggested recipes
+     */
+    getSuggestedRecipes: () => Observable<Recipe[]>;
+
+    /**
+     * Updates the guests count
+     * @param guests
+     * @param eventTrace
+     */
+    updateGuests: (guests: number, eventTrace: EventTrace) => void;
+
+    /**
+     * Gets the guests count for a recipe
+     * @param recipeId
+     */
+    getGuestsForRecipe: (recipeId: string) => Observable<number>;
   };
 
   // ---------------------------------------------------------------------------------------------------
@@ -78,12 +282,122 @@ export interface MealzInternalInterface {
     openDetails: (
       recipeId: string,
       guests: number,
-      initialTabIndex: number,
+      initialTabIndex?: number,
       analyticsPath?: string,
       plannerOrCategoryId?: boolean | string,
       categoryId?: string
     ) => void;
 
+    /**
+     * Loads and setups a recipe
+     */
+    loadAndSetupRecipe: (recipeId: string, guests?: number) => Observable<void>;
+
+    /**
+     * Method to open replace item view
+     */
+    replaceBasketEntry: (basketEntry: BasketEntry, ignoreSelected: boolean) => void;
+
+    /**
+     * Method to update guest number
+     */
+    updateGuests: (eventTrace: EventTrace, guests?: number) => void;
+
+    /**
+     * Method to add all ingredients from recipe to basket
+     */
+    addAllIngredientsToBasket: (eventTrace: EventTrace) => void;
+
+    /**
+     * Method to add a product to the basket
+     */
+    addToBasket: (product: Product, eventTrace: EventTrace) => void;
+
+    /**
+     * Method to remove an ingredient
+     */
+    ingredientRemoved: (ingredient: Ingredient, eventTrace: EventTrace) => void;
+
+    /**
+     * Method to update the quantity of a product
+     */
+    updateProductQuantity: (basketEntry: BasketEntry, newQuantity: number, eventTrace: EventTrace) => void;
+
+    /**
+     * Method to ignore a product
+     */
+    ignoreProduct: (product: Product) => void;
+
+    /**
+     * Method to check if a product is being added
+     */
+    productIsBeingAdded: (basketEntry: BasketEntry) => Observable<boolean>;
+
+    /**
+     * Emits the loading state of the `addAllIngredientsToBasket` method
+     */
+    allIngredientsToBasketLoading$: BehaviorSubject<boolean>;
+
+    /**
+     * Emits the loading state of the `addToBasket` method
+     */
+    ingredientToBasketLoading$: BehaviorSubject<boolean>;
+
+    /**
+     * Emits the loading state of the `ingredientRemoved` or `updateIngredientFromBasket` method
+     */
+    updateIngredientFromBasketLoading$: BehaviorSubject<boolean>;
+
+    /**
+     * Emits the loading state of products
+     */
+    productsLoading$: BehaviorSubject<boolean>;
+
+    /**
+     * Emits the currently displayed recipe
+     */
+    displayedRecipe$: BehaviorSubject<RecipeDisplay>;
+
+    /**
+     * Emits the tab index to select when opening recipe details (0 = products, 1 = preparation).
+     */
+    recipeDetailsTabIndex$: BehaviorSubject<number>;
+
+    /**
+     * Emits the products by category
+     */
+    productsByCategory$: BehaviorSubject<ProductCategory>;
+
+    /**
+     * Emits the products by category in planner view
+     */
+    productsPlannerByCategory$: BehaviorSubject<ProductPlannerCategory>;
+
+    /**
+     * Emits if recipeDetails should display the noPos view
+     */
+    noPosDisplay$: BehaviorSubject<boolean>;
+
+    /**
+     * Emits if recipeDetails should display the invalidPos view
+     */
+    invalidPosDisplay$: BehaviorSubject<boolean>;
+
+    /**
+     * Emits an observable containing the recipe's basket entries that have not yet been added to the basket.
+     */
+    remainingBasketEntries$: BehaviorSubject<BasketEntry[]>;
+
+    /**
+     * Emits an observable with the price of a recipe displayed, from what is already in the basket and what is remaining
+     */
+    recipePrice$: BehaviorSubject<{ remaining: number; inBasket: number }>;
+
+    /**
+     * Emits an observable with the date of the last order
+     */
+    orderHistoryDate$: BehaviorSubject<string>;
+
     /**
      * Updates or creates a recipe like entry.
      * If `recipeLikeId` is provided, it updates the existing like; otherwise, it creates a new one.
@@ -91,11 +405,6 @@ export interface MealzInternalInterface {
      */
     updateRecipeLike: (recipeLikeId: string, recipeId: string, isPast: boolean, path?: string, categoryId?: string) => void;
 
-    /**
-     * Gets the RecipeLike for the recipeId
-     */
-    getRecipeLike: (recipeId: string) => Observable<RecipeLike>;
-
     /**
      * Emits an observable that notifies subscribers when a recipe like has been updated.
      */
@@ -115,6 +424,142 @@ export interface MealzInternalInterface {
      * Fetches the pricing information for a specific recipe based on the provided parameters.
      */
     fetchPricing: (recipeId: string, posId: string, serves: number) => Observable<RecipePricing>;
+
+    /**
+     * Updates the state to indicate whether the recipe details is being accessed from planner.
+     */
+    setIsRecipeDetailsFromPlanner: (isSSR: boolean) => void;
+
+    /**
+     * Checks if a recipe is in the basket
+     * @param recipeId
+     */
+    isRecipeInBasket: (recipeId: string) => Observable<boolean>;
+
+    /**
+     * Gets the recipe like for a specific recipe
+     * @param recipeId
+     */
+    getRecipeLike: (recipeId: string) => Observable<RecipeLike>;
+  };
+
+  // ---------------------------------------------------------------------------------------------------
+
+  replaceItem: {
+    /**
+     * Emits the basket entry to replace from recipe details view
+     */
+    basketEntryToReplace$: BehaviorSubject<BasketEntryToReplace>;
+
+    /**
+     * Emits if the replace item modal should be displayed from basket preview
+     */
+    replaceProductFromPreviewOpen$: BehaviorSubject<BasketEntry>;
+
+    /**
+     * Emits if the replace item modal should be displayed from the product addition
+     */
+    additionModalOpen$: BehaviorSubject<boolean>;
+
+    /**
+     * Method to call when adding an item from the replace item modal
+     */
+    onSelectItem: (item: Item, searchString: string, onComplete?: (itemId?: string) => void, eventTrace?: EventTrace) => void;
+
+    /**
+     * Variable with the list of items with prices
+     */
+    itemsWithPricesList$: BehaviorSubject<{ item: Item; price: ProductPrice }[]>;
+
+    /**
+     * Emits if items are getting fetched
+     */
+    fetchingItemLoading$: BehaviorSubject<boolean>;
+
+    /**
+     * Emits the item that is being replaced
+     */
+    replaceItemLoading$: BehaviorSubject<Item>;
+
+    /**
+     * method to call to retrieve item from query
+     */
+    searchItem: (searchString: string) => Observable<void>;
+  };
+
+  // ---------------------------------------------------------------------------------------------------
+
+  router: {
+
+    /**
+     * Retrieve retailer cart url
+     */
+    getRetailerCartUrl: () => string;
+
+    /**
+     * Retrieve catalog url
+     */
+    getCatalogUrl: () => string;
+  };
+
+
+  // ---------------------------------------------------------------------------------------------------
+
+  products: {
+    /**
+     * Changes the quantity of a product or removes it from the basket if quantity is equal to 0
+     */
+    changeQuantity: (basketEntry: BasketEntry, quantity: number, path: string) => void;
+
+    /**
+     * Removes a product from the basket
+     */
+    removeProduct: (basketEntry: BasketEntry, path: string) => void;
+
+    /**
+     * Checks if a product is being updated
+     */
+    entryIsBeingUpdated: (entryId: string) => Observable<boolean>;
+  };
+
+  // ---------------------------------------------------------------------------------------------------
+
+  pos: {
+
+    /**
+     * Fetches the current point of sale
+     */
+    currentPos: () => Observable<PointOfSale>;
+
+    /**
+     * Checks if the point of sale has been initialized
+     */
+    posWasInitialized: () => Observable<boolean>;
+
+    /**
+     * Loads the point of sale data for the given pos id
+     */
+    loadPos: (posId: string) => Observable<PointOfSale>;
+
+    /**
+     * Retrieves the updated basket after a new POS has been selected
+     */
+    basketLoadedForNewPos: () => Observable<Basket>;
+  };
+
+  // ---------------------------------------------------------------------------------------------------
+
+  sponsor: {
+
+    /**
+     * Checks if a sponsor has storytelling content available
+     */
+    hasStorytelling: (sponsorId: string) => Observable<boolean>;
+
+    /**
+     * Retrieves all sponsor blocks associated with a given sponsor, sorted by position
+     */
+    getSponsorBlocks: (sponsorId: string) => Observable<SponsorBlock[]>;
   };
 
   // ---------------------------------------------------------------------------------------------------
@@ -125,6 +570,21 @@ export interface MealzInternalInterface {
      * Retrieves the token from the suppliers service
      */
     getToken: () => string;
+
+    /**
+     * Fetches the current supplier
+     */
+    currentSupplier: () => Observable<Supplier>;
+
+    /**
+     * Retrieves if the retailer is not a supplier
+     */
+    isNoSupplier: () => boolean;
+
+    /**
+     * Emits once the no-supplier mode has been resolved from `setupWithToken`.
+     */
+    noSupplier$: ReplaySubject<boolean>;
   };
 
   // ---------------------------------------------------------------------------------------------------
@@ -141,11 +601,184 @@ export interface MealzInternalInterface {
      */
     isAuthenticated: () => Observable<boolean>;
 
+    /**
+     * BehaviorSubject containing the user's geolocation coordinates
+     */
+    userCoordinates$: BehaviorSubject<GeolocationPosition>;
+
     /**
      * Updates the SDK's session ID to ensure consistency with SSR.
      */
     setSessionId: (sessionId: string) => void;
   };
 
+  // ---------------------------------------------------------------------------------------------------
+
+  storeLocator: {
+
+    /**
+     * Opens the store locator
+     */
+    open: () => void;
+
+    /**
+     * Opens the store locator / indicator warning modal
+     */
+    openWarning: () => void;
+
+    /**
+     * Closes the store locator
+     */
+    close: () => void;
+
+    /**
+     * Method to call to configure new pos and supplier
+     */
+    changePosAndSupplier: (e: CustomEvent, eventTrace: EventTrace) => void;
+
+    /**
+     * Notifies subscribers that a new store has been selected
+     */
+    newStoreSelected: () => void;
+  };
+
+  // ---------------------------------------------------------------------------------------------------
+
+  productAddition: {
+
+    /**
+     * Opens the product addition modal
+     */
+    open: () => void;
+
+    /**
+     * Closes the product addition modal
+     */
+    close: () => void;
+
+    /**
+     * Emits an observable that notifies subscribers when a product has been added.
+     */
+    productAdded$: Observable<string>;
+  };
+
+  productReplacement: {
+
+    /**
+     * Opens the product replacement modal
+     * @param product the product to replace
+     */
+    open: (product: BasketEntry) => void;
+  };
+
+  html: {
+
+    /**
+     * method that returns Like button HTML from SSR
+     */
+    like: (recipeId: string, path?: string, categoryId?: string) => Observable<string>;
+  };
+
   getStickyHeaderHeight: () => Observable<number>;
+
+  preferences: {
+
+    /**
+     * Returns the current number of preferences
+     */
+    preferencesCount: () => Observable<number>;
+
+    /**
+     * BehaviorSubject containing the current number of guests
+     */
+    guests$: BehaviorSubject<number>;
+
+    /**
+     * Resets the tags actions
+     */
+    resetTagsActions: () => void;
+
+    /**
+     * Checks if a tag should be checked based on its state
+     */
+    tagShouldBeChecked: (tag: Tag, isWithout: boolean) => boolean;
+
+    /**
+     * Resets all preferences to default values
+     */
+    resetPreferences: () => void;
+
+    /**
+     * Sends a cache request to the server
+     */
+    sendCacheRequest: (action: 'set' | 'remove', key: string, value?: any) => Observable<void>;
+
+    /**
+     * Current preferences stored in local storage
+     */
+    preferencesInStorage: () => { with: BasicPreference[]; without: BasicPreference[] };
+
+    /**
+     * Array of tags to be added
+     */
+    tagsToAdd: { tag: Tag; checked: boolean; without: boolean }[];
+
+    /**
+     * Adds a tag to preferences
+     */
+    addTag: (tag: { tag: Tag; checked: boolean; without: boolean }) => void;
+
+    /**
+     * Removes a tag from preferences
+     */
+    removeTag: (tag: { tag: Tag; checked: boolean; without: boolean }) => void;
+
+    /**
+     * Updates the preferences
+     */
+    updatePreferences: () => void;
+
+    /**
+     * Notifies that preferences have changed
+     */
+    preferencesChanged$: () => Observable<void>;
+
+    /**
+     * Emits an observable that notifies subscribers when the preferences have changed
+     */
+    preferencesChanged: () => void;
+
+    /**
+     * Adds preferences to remote filters
+     */
+    addPreferencesToRemoteFilters: (filters: object, includeGuests: boolean) => { include_tags?: string; exclude_tags?: string };
+
+    /**
+     * Adds a new tag from search to preferences
+     */
+    newTagFromSearch: (tag: Tag) => void;
+  };
+
+  tags: {
+    all: (params: { remotefilter: { tag_type: string; for_supplier: string } }) => Observable<DocumentCollection<Tag>>;
+    autocomplete: (query: string) => Observable<DocumentCollection<Tag>>;
+  };
+
+  /**
+   * Set up a callback which Mealz will call before adding a recipe to the user's cart
+   *
+   * @param needLogin if true, Mealz will ask for login
+   * @param needPos if true, Mealz will ask for a pos
+   * @returns Observable<boolean> true if the operation can continue, false otherwise
+   */
+  hook: {
+    hookCallback: (needLogin?: boolean, needPos?: boolean) => Observable<boolean>;
+  };
+
+  noSupplier: {
+    addRecipeToBasketFromIdAndOpenPreview: (recipeId: string) => Observable<void>;
+    displaySupplierSelector$: BehaviorSubject<boolean>;
+    openStoreLocatorForPricing: () => void;
+    cancelPricingPosSelection: () => void;
+  };
 }