@delicity/client-cart 1.5.8 → 2.0.0

package/dist/esm/classes/Cart.js

@@ -0,0 +1,705 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { OrderModesEnum } from "../types/CartInterface";
+import { DateTime } from 'luxon';
+import { v4 as uuidv4 } from 'uuid';
+import { addDiscountCode, addonIntegrity, fetchMerchantMenu, getProductCount, getProductPrice, getProductPriceSum, getTotalModifiersUnitPrice, isItemAlreadyInCart, isItemAvailable, mandatoryModifierCheck, removeDiscountCode, synchronizeCart, transformMenuAddonInCartAddon, isBundleAvailable, validateBundleRequirements, validateBundlePartQuantities, getBundlePrice, isBundleAlreadyInCart } from "../service/CartService";
+import { getDeliveryDetails } from "../service/DeliveryService";
+import { formatPrice } from "../service/HelperService";
+// @ts-ignore
+import ScheduleManagement from "@delicity/backend-schedule-management";
+import { categoryAvailable } from "../service/CategoryAvailabilityService";
+export class Cart {
+    constructor(config, merchant, menu, OrderMode, when) {
+        this.acceptCondition = false;
+        this.errors = [];
+        this.listeners = {};
+        this.isPriceLoading = false;
+        this.isDeliveryLoading = false;
+        this.syncPromise = null;
+        this.voucherBalance = {
+            edenred: 0
+        };
+        this.merchant = merchant;
+        this.menu = JSON.parse(JSON.stringify(menu));
+        this.config = config;
+        this.remoteErrors = {};
+        if (this.merchant.schedule) {
+            this.merchantSchedule = new ScheduleManagement(this.merchant.schedule.slots, this.merchant.schedule.closes, this.merchant.schedule.options);
+        }
+        this.cart = {
+            uuid: uuidv4(),
+            createdAt: DateTime.now().toISO(),
+            merchantId: merchant.id,
+            preparationDurationBetween: null,
+            items: [],
+            totalItems: 0,
+            totalItemPrice: 0,
+            paymentMethods: [],
+            when: when,
+            comment: null,
+            type: OrderMode,
+            addons: menu.addons.map(a => transformMenuAddonInCartAddon(a))
+        };
+    }
+    on(event, callback) {
+        if (!this.listeners[event])
+            this.listeners[event] = [];
+        this.listeners[event].push(callback);
+    }
+    off(event, callback) {
+        const list = this.listeners[event];
+        if (!list)
+            return;
+        if (!callback) {
+            this.listeners[event] = [];
+            return;
+        }
+        this.listeners[event] = list.filter(cb => cb !== callback);
+    }
+    trigger(event, ...args) {
+        const list = this.listeners[event];
+        if (!list)
+            return;
+        for (const cb of list) {
+            try {
+                cb(...args);
+            }
+            catch (e) {
+                console.error(`[client-cart] listener for "${event}" threw:`, e);
+            }
+        }
+    }
+    setMenu(menu) {
+        this.menu = JSON.parse(JSON.stringify(menu));
+        this.cartIntegrity();
+        this.updateCartProductPrices();
+        this.trigger('update-cart');
+        return this;
+    }
+    reloadMenu() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const menu = yield fetchMerchantMenu(this.config, this.merchant.slug);
+            this.menu = JSON.parse(JSON.stringify(menu));
+            this.cartIntegrity(true);
+            this.updateCartProductPrices();
+            this.trigger('update-cart');
+            return this;
+        });
+    }
+    setCart(cart) {
+        if (!cart.paymentMethods)
+            cart.paymentMethods = [];
+        this.cart = cart;
+        this.cartIntegrity();
+        this.updateCartProductPrices();
+        if (cart.addons) {
+            cart.addons = addonIntegrity(cart.addons, this.menu.addons);
+            // Add missing addon if any
+            this.menu.addons.map(a => transformMenuAddonInCartAddon(a))
+                .filter(a => cart.addons && !cart.addons.map(e => e.name).includes(a.name))
+                .forEach(a => { var _a; return (_a = cart.addons) === null || _a === void 0 ? void 0 : _a.push(a); });
+        }
+        this.trigger('update-cart');
+        return this;
+    }
+    getPrices() {
+        return this.cart.prices || null;
+    }
+    getCartAddons() {
+        return this.cart.addons || [];
+    }
+    getAcceptCondition() {
+        return this.acceptCondition;
+    }
+    setAcceptCondition(acceptCondition) {
+        this.acceptCondition = acceptCondition;
+        return this;
+    }
+    getPreparationDurationBetween() {
+        return this.cart.preparationDurationBetween;
+    }
+    addonIncrement(identifier) {
+        if (!this.cart.addons)
+            return;
+        const addonIndex = this.cart.addons.findIndex(e => e.identifier === identifier);
+        if (addonIndex === -1)
+            return;
+        this.cart.addons[addonIndex].quantity++;
+        // if addon is checkbox, set quantity to 1
+        if (!this.cart.addons[addonIndex].quantitySelector)
+            this.cart.addons[addonIndex].quantity = 1;
+        this.cart.addons[addonIndex].totalPriceWt = this.cart.addons[addonIndex].quantity * this.cart.addons[addonIndex].unitPriceWt;
+    }
+    addonDecrement(identifier) {
+        if (!this.cart.addons)
+            return;
+        const addonIndex = this.cart.addons.findIndex(e => e.identifier === identifier);
+        if (addonIndex === -1)
+            return;
+        if (this.cart.addons[addonIndex].quantity === 0)
+            return;
+        this.cart.addons[addonIndex].quantity--;
+        // if addon is checkbox, reset quantity to 0
+        if (!this.cart.addons[addonIndex].quantitySelector)
+            this.cart.addons[addonIndex].quantity = 0;
+        this.cart.addons[addonIndex].totalPriceWt = this.cart.addons[addonIndex].quantity * this.cart.addons[addonIndex].unitPriceWt;
+    }
+    getIsDeliveryLoading() {
+        return this.isDeliveryLoading;
+    }
+    getIsPriceLoading() {
+        return this.isPriceLoading;
+    }
+    getRemoteErrors() {
+        return this.remoteErrors;
+    }
+    setAddress(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.cart.type !== OrderModesEnum.DELIVERY)
+                throw new Error('invalid_order_mode');
+            this.isDeliveryLoading = true;
+            const delivery = yield getDeliveryDetails(this.config, this.merchant.id, address.position);
+            this.cart.delivery = Object.assign({ address }, delivery);
+            this.isDeliveryLoading = false;
+            this.trigger('update-cart');
+            return this;
+        });
+    }
+    getDeliveryInfos() {
+        return this.cart.delivery;
+    }
+    setCartComment(comment) {
+        this.cart.comment = comment;
+        return this;
+    }
+    getCartComment() {
+        return this.cart.comment;
+    }
+    updateCartProductPrices() {
+        for (let index in this.cart.items) {
+            const cartItem = this.cart.items[index];
+            const menuItem = this.menu.items.find(m => m.id === cartItem.item.id);
+            if (!menuItem) {
+                this.cart.items.splice(parseInt(index), 1);
+                continue;
+            }
+            cartItem.item = menuItem;
+            if (cartItem.type === 'BUNDLE') {
+                // Handle bundle items
+                const bundleItems = cartItem.bundleItems || [];
+                const quantity = cartItem.quantity;
+                const unitPrice = getBundlePrice(menuItem, bundleItems, this.cart.type);
+                cartItem.unitPrice = unitPrice;
+                cartItem.totalPrice = unitPrice * quantity;
+            }
+            else {
+                // Handle regular products
+                const modifierGroups = cartItem.modifierGroups;
+                const quantity = cartItem.quantity;
+                cartItem.unitPrice = getProductPrice(menuItem, this.cart.type) + getTotalModifiersUnitPrice(modifierGroups || []);
+                cartItem.totalPrice = (getProductPrice(menuItem, this.cart.type) + getTotalModifiersUnitPrice(modifierGroups || [])) * quantity;
+            }
+        }
+        this.cart.totalItems = getProductCount(this.cart);
+        this.cart.totalItemPrice = getProductPriceSum(this.cart);
+        if (this.cart.paymentMethods && this.cart.paymentMethods.length > 0) {
+            this.updatePaymentMethodAmount();
+        }
+        this.validateCartIfError();
+    }
+    setOrderMode(mode) {
+        this.cart.type = mode;
+        if (!this.canBePayOnsite() && this.getPaymentMethods().some(e => e.type === 'cash')) {
+            this.cart.paymentMethods = [];
+        }
+        this.updateCartProductPrices();
+        this.trigger('update-cart');
+        return this;
+    }
+    setWhen(when) {
+        this.cart.when = when;
+        this.trigger('update-cart');
+        this.cartIntegrity(true);
+        this.validateCartIfError();
+        return this;
+    }
+    setAddressComment(comment) {
+        var _a;
+        if ((_a = this.cart.delivery) === null || _a === void 0 ? void 0 : _a.address) {
+            this.cart.delivery.address.additional_informations = comment;
+        }
+        return this;
+    }
+    getMerchantId() {
+        return this.merchant.id;
+    }
+    getMerchant() {
+        return this.merchant;
+    }
+    getMerchantMenu() {
+        return this.menu;
+    }
+    getCartUUID() {
+        return this.cart.uuid;
+    }
+    getOrderMode() {
+        return this.cart.type;
+    }
+    getWhen() {
+        return this.cart.when;
+    }
+    getPaymentMethods() {
+        return this.cart.paymentMethods || [];
+    }
+    setPaymentMethods(paymentMethods) {
+        this.cart.paymentMethods = paymentMethods;
+        return this;
+    }
+    getPaymentMethodTotalAmount() {
+        return this.cart.paymentMethods.reduce((a, value) => a + value.amount, 0);
+    }
+    isVoucherEligible() {
+        return this.merchant.features.edenredIntegrationEnabled;
+    }
+    isOrderFree() {
+        return this.getTotalPrice() === 0;
+    }
+    isVoucherPayingEverything() {
+        return this.cart.paymentMethods.some(p => p.type === 'meal-voucher' && p.amount === this.getTotalPrice());
+    }
+    enablePaymentMethodVoucher(type, availableVoucherAmount) {
+        if (!this.isVoucherEligible())
+            throw new Error("voucher_not_available_in_this_merchant");
+        // Set current voucher balance
+        this.setVoucherBalance(type, availableVoucherAmount);
+        // Keep Only Existing payment method
+        this.cart.paymentMethods = this.cart.paymentMethods.filter(p => p.type !== 'meal-voucher');
+        // Get Amount to pay with voucher (Only product price)
+        const totalToPayVoucher = Math.min(this.voucherBalance[type], this.getTotalItemPrice());
+        // Set Meal Voucher
+        this.cart.paymentMethods.push({
+            type: "meal-voucher",
+            voucher: { type },
+            amount: totalToPayVoucher
+        });
+        // Update current card amount if defined
+        const leftToPayWithCard = this.getTotalPrice() - totalToPayVoucher;
+        if (leftToPayWithCard > 0 && this.cart.paymentMethods.some(p => p.type !== 'meal-voucher')) {
+            const cardIndex = this.cart.paymentMethods.findIndex(p => p.type !== 'meal-voucher');
+            this.cart.paymentMethods[cardIndex].amount = leftToPayWithCard;
+        }
+        this.updatePaymentMethodAmount();
+        return this;
+    }
+    disablePaymentMethodVoucher() {
+        // Keep Only Existing payment method
+        this.cart.paymentMethods = this.cart.paymentMethods.filter(p => p.type !== 'meal-voucher');
+        this.updatePaymentMethodAmount();
+        return this;
+    }
+    paymentMethodCard(type, token, brand, last4, expiration) {
+        // Keep only meal-voucher
+        this.cart.paymentMethods = this.cart.paymentMethods.filter(p => p.type === 'meal-voucher');
+        // Get left to pay with Card
+        let leftToPay = Math.max(this.getTotalPrice() - this.getPaymentMethodTotalAmount(), 0);
+        // Add Card
+        this.cart.paymentMethods.push({
+            type: 'card',
+            amount: leftToPay,
+            card: { type, token, brand, last4, expiration }
+        });
+        this.updatePaymentMethodAmount();
+        return this;
+    }
+    paymentMethodWallet(type) {
+        // Keep only meal-voucher
+        this.cart.paymentMethods = this.cart.paymentMethods.filter(p => p.type === 'meal-voucher');
+        // Get left to pay with Card
+        let leftToPay = Math.max(this.getTotalPrice() - this.getPaymentMethodTotalAmount(), 0);
+        // Add Wallet
+        this.cart.paymentMethods.push({
+            type: "wallet",
+            wallet: { type },
+            amount: leftToPay,
+        });
+        return this;
+    }
+    // Set All order is paid onsite
+    paymentMethodOnsite() {
+        this.cart.paymentMethods = [];
+        this.cart.paymentMethods.push({
+            type: 'cash',
+            amount: this.getTotalPrice(),
+        });
+        return this;
+    }
+    paymentMethodDeliveryCash() {
+        this.cart.paymentMethods = [];
+        this.cart.paymentMethods.push({
+            type: 'delivery_cash',
+            amount: this.getTotalPrice(),
+        });
+        return this;
+    }
+    updatePaymentMethodAmount() {
+        var _a, _b, _c;
+        if (!this.isOrderFree()) {
+            this.cart.paymentMethods = this.cart.paymentMethods.filter(p => p.type !== 'free');
+        }
+        if (((_a = this.cart.paymentMethods) === null || _a === void 0 ? void 0 : _a.length) === 1) {
+            if (this.cart.paymentMethods[0].type !== 'meal-voucher') {
+                this.cart.paymentMethods[0].amount = this.getTotalPrice(); // Card Pay all
+            }
+            else if (this.cart.paymentMethods[0].voucher) {
+                // Voucher Can pay only product
+                this.cart.paymentMethods[0].amount = Math.min(this.voucherBalance[this.cart.paymentMethods[0].voucher.type], this.getTotalItemPrice());
+            }
+        }
+        else if (((_b = this.cart.paymentMethods) === null || _b === void 0 ? void 0 : _b.length) === 2 && ((_c = this.cart.paymentMethods) === null || _c === void 0 ? void 0 : _c.some(p => p.type === 'meal-voucher'))) {
+            const voucherIndex = this.cart.paymentMethods.findIndex(p => p.type === 'meal-voucher' && p.voucher);
+            const cardIndex = this.cart.paymentMethods.findIndex(p => p.type !== 'meal-voucher');
+            // Voucher Can pay only product
+            const voucherType = this.cart.paymentMethods[voucherIndex];
+            if (voucherType.voucher) {
+                this.cart.paymentMethods[voucherIndex].amount = Math.min(this.voucherBalance[voucherType.voucher.type], this.getTotalItemPrice());
+            }
+            // Card pay the rest : Delivery / Delicity Fees...
+            this.cart.paymentMethods[cardIndex].amount = this.getTotalPrice() - this.cart.paymentMethods[voucherIndex].amount;
+        }
+        else {
+            // If multiple payment methods, split amount
+            // Not dev yet...
+        }
+        return this;
+    }
+    addToCart(item, modifierGroups, quantity, comment, replace) {
+        // Check if item have mandatory modifiers
+        if (!mandatoryModifierCheck(item, modifierGroups, this.menu)) {
+            throw new Error('mandatory_field_missing');
+        }
+        // Check if item is available
+        if (!isItemAvailable(item, this.menu)) {
+            throw new Error('item_not_available');
+        }
+        const index = isItemAlreadyInCart(item, modifierGroups, this.cart, comment);
+        if (index !== -1 && !replace) {
+            this.cart.items[index].quantity += quantity;
+            this.cart.items[index].totalPrice = (getProductPrice(item, this.cart.type) + getTotalModifiersUnitPrice(modifierGroups)) * this.cart.items[index].quantity;
+        }
+        else {
+            const cartItem = {
+                uuid: uuidv4(),
+                item,
+                modifierGroups,
+                quantity,
+                comment: comment || null,
+                unitPrice: getProductPrice(item, this.cart.type) + getTotalModifiersUnitPrice(modifierGroups),
+                totalPrice: (getProductPrice(item, this.cart.type) + getTotalModifiersUnitPrice(modifierGroups)) * quantity,
+                type: 'PRODUCT'
+            };
+            if (replace) {
+                const index = this.cart.items.findIndex(i => i.uuid === replace.uuid);
+                this.cart.items.splice(index, 1, cartItem);
+            }
+            else {
+                this.cart.items.push(cartItem);
+            }
+        }
+        this.cart.totalItems = getProductCount(this.cart);
+        this.cart.totalItemPrice = getProductPriceSum(this.cart);
+        if (this.cart.paymentMethods && this.cart.paymentMethods.length > 0) {
+            this.updatePaymentMethodAmount();
+        }
+        this.validateCartIfError();
+        this.cartIntegrity(true);
+        this.trigger('update-cart');
+        return this;
+    }
+    addBundleToCart(bundle, bundleItems, quantity, comment, replace) {
+        // Check if bundle is available
+        if (!isBundleAvailable(bundle, this.menu)) {
+            throw new Error('bundle_not_available');
+        }
+        // Validate bundle requirements (required parts)
+        validateBundleRequirements(bundle, bundleItems, this.menu);
+        // Validate bundle part quantity constraints
+        validateBundlePartQuantities(bundleItems);
+        // Check if identical bundle already exists in cart
+        const index = isBundleAlreadyInCart(bundle, bundleItems, this.cart, comment);
+        if (index !== -1 && !replace) {
+            // Merge with existing bundle
+            this.cart.items[index].quantity += quantity;
+            const unitPrice = getBundlePrice(bundle, bundleItems, this.cart.type);
+            this.cart.items[index].totalPrice = unitPrice * this.cart.items[index].quantity;
+        }
+        else {
+            // Create new bundle cart item
+            const unitPrice = getBundlePrice(bundle, bundleItems, this.cart.type);
+            const cartItem = {
+                uuid: uuidv4(),
+                item: bundle,
+                modifierGroups: [],
+                bundleItems: bundleItems,
+                quantity,
+                comment: comment || null,
+                unitPrice,
+                totalPrice: unitPrice * quantity,
+                type: 'BUNDLE'
+            };
+            if (replace) {
+                // Replace existing item
+                const replaceIndex = this.cart.items.findIndex(i => i.uuid === replace.uuid);
+                this.cart.items.splice(replaceIndex, 1, cartItem);
+            }
+            else {
+                // Add new bundle to cart
+                this.cart.items.push(cartItem);
+            }
+        }
+        // Update cart totals
+        this.cart.totalItems = getProductCount(this.cart);
+        this.cart.totalItemPrice = getProductPriceSum(this.cart);
+        // Update payment methods if needed
+        if (this.cart.paymentMethods && this.cart.paymentMethods.length > 0) {
+            this.updatePaymentMethodAmount();
+        }
+        // Validate and trigger update
+        this.validateCartIfError();
+        this.cartIntegrity(true);
+        this.trigger('update-cart');
+        return this;
+    }
+    removeFromCart(cartItem) {
+        this.cart.items = this.cart.items.filter((item) => item.uuid !== cartItem.uuid);
+        this.cart.totalItems = getProductCount(this.cart);
+        this.cart.totalItemPrice = getProductPriceSum(this.cart);
+        if (this.cart.paymentMethods) {
+            this.updatePaymentMethodAmount();
+        }
+        this.cartIntegrity(true);
+        this.trigger('update-cart');
+        return this;
+    }
+    updateCart(cartItem, modifierGroup, quantity, comment) {
+        return this.addToCart(cartItem.item, modifierGroup, quantity, comment, cartItem);
+    }
+    getCart() {
+        return this.cart;
+    }
+    getItems() {
+        return this.cart.items;
+    }
+    getTotalItems() {
+        return this.cart.totalItems;
+    }
+    getTotalItemPrice() {
+        var _a, _b;
+        return this.cart.totalItemPrice - Math.abs(((_b = (_a = this.cart.discounts) === null || _a === void 0 ? void 0 : _a.filter(a => a.affect === 'products')) === null || _b === void 0 ? void 0 : _b.reduce((a, d) => a + d.value, 0))
+            || 0);
+    }
+    getTotalItemPriceRaw() {
+        return this.cart.totalItemPrice;
+    }
+    getTotalPrice() {
+        var _a;
+        return ((_a = this.cart.prices) === null || _a === void 0 ? void 0 : _a.total) || this.getTotalItemPrice();
+    }
+    canBePayOnsite() {
+        return [OrderModesEnum.PICKUP, OrderModesEnum.ON_SITE_COUNTER].includes(this.cart.type) && this.merchant.features.onsitePayment;
+    }
+    canBePayWithCashOnDelivery() {
+        return [OrderModesEnum.DELIVERY].includes(this.cart.type) && this.merchant.features.deliveryCashPayment;
+    }
+    synchronize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.cart.type === OrderModesEnum.DELIVERY && !this.cart.delivery) {
+                throw new Error('no_delivery_address');
+            }
+            // Dedupe concurrent calls: return the in-flight promise to prevent server-side races
+            // when the user double-clicks "Commander" or another flow re-triggers a sync mid-flight.
+            if (this.syncPromise)
+                return this.syncPromise;
+            this.syncPromise = (() => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                this.isPriceLoading = true;
+                try {
+                    const request = yield synchronizeCart(this.config, this.cart);
+                    if (this.cart.delivery && request.delivery) {
+                        this.cart.delivery = Object.assign({ address: (_a = this.cart.delivery) === null || _a === void 0 ? void 0 : _a.address }, request.delivery);
+                    }
+                    this.cart.preparationDurationBetween = request.preparationDurationBetween;
+                    this.cart.discounts = request.discounts;
+                    this.cart.prices = request.prices;
+                    this.cart.addons = request.addons;
+                    this.cart.paymentMethods = request.paymentMethods;
+                    this.remoteErrors = request.errors;
+                    if (this.cart.paymentMethods && this.cart.paymentMethods.length > 0) {
+                        this.updatePaymentMethodAmount();
+                    }
+                    return this;
+                }
+                finally {
+                    this.isPriceLoading = false;
+                    this.syncPromise = null;
+                }
+            }))();
+            return this.syncPromise;
+        });
+    }
+    setCartDiscounts(discounts) {
+        this.cart.discounts = discounts;
+        this.cartIntegrity();
+        if (this.cart.paymentMethods && this.cart.paymentMethods.length > 0) {
+            this.updatePaymentMethodAmount();
+        }
+        this.trigger('update-cart');
+        return this;
+    }
+    setAddons(addons) {
+        this.cart.addons = addons;
+        if (this.cart.paymentMethods && this.cart.paymentMethods.length > 0) {
+            this.updatePaymentMethodAmount();
+        }
+        this.trigger('update-cart');
+        return this;
+    }
+    validateMerchantSchedule() {
+        this.errors = this.errors.filter(e => e.field !== 'schedule');
+        if (this.merchantSchedule) {
+            const when = this.getWhen() !== null ? DateTime.fromISO(this.getWhen()) : DateTime.now();
+            if (!this.merchantSchedule.isOpenAt(when))
+                this.errors.push({ field: 'schedule', code: 'merchant_currently_close', vars: {} });
+        }
+        return this;
+    }
+    validateCart() {
+        var _a;
+        this.errors = [];
+        if (!this.isOrderFree()) {
+            if (this.getPaymentMethods().reduce((a, b) => a + b.amount, 0) !== this.getTotalPrice() || !this.cart.paymentMethods || ((_a = this.cart.paymentMethods) === null || _a === void 0 ? void 0 : _a.length) === 0)
+                this.errors.push({ field: 'payment_method', code: 'missing_payment_methods', vars: {} });
+            if (this.cart.type === OrderModesEnum.DELIVERY && this.merchant.settings.minDeliveryOrderPrice > this.cart.totalItemPrice)
+                this.errors.push({ field: 'prices', code: 'minium_delivery_product_price', vars: { min: formatPrice(this.merchant.settings.minDeliveryOrderPrice) } });
+        }
+        if (this.cart.type === OrderModesEnum.DELIVERY && !this.cart.delivery)
+            this.errors.push({ field: 'address', code: 'no_address_defined', vars: {} });
+        if (this.cart.type === OrderModesEnum.DELIVERY && this.cart.delivery && !this.cart.delivery.available)
+            this.errors.push({ field: 'address', code: 'address_not_available', vars: {} });
+        if (!this.acceptCondition)
+            this.errors.push({ field: 'conditions', code: 'condition_not_accepted', vars: {} });
+        this.validateMerchantSchedule();
+        return this;
+    }
+    validateCartIfError() {
+        if (this.errors.length > 0)
+            this.validateCart();
+        return this;
+    }
+    resetErrors() {
+        this.errors = [];
+        return this;
+    }
+    getErrors() {
+        return this.errors;
+    }
+    pushError(field, code, vars) {
+        this.errors.push({ field, code, vars });
+        return this;
+    }
+    setErrors(errors) {
+        this.errors = errors;
+        return this;
+    }
+    setVoucherBalance(type, amount) {
+        this.voucherBalance[type] = amount;
+    }
+    addDiscountCoupon(code) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield addDiscountCode(this.config, this.cart, code);
+            this.trigger('update-cart');
+            return this;
+        });
+    }
+    getDiscounts() {
+        var _a;
+        return (_a = this.cart.discounts) !== null && _a !== void 0 ? _a : [];
+    }
+    getCoupons() {
+        var _a, _b;
+        return (_b = (_a = this.cart.discounts) === null || _a === void 0 ? void 0 : _a.filter(d => d.type === 'coupon')) !== null && _b !== void 0 ? _b : [];
+    }
+    removeDiscount(discount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield removeDiscountCode(this.config, this.cart, discount);
+            this.trigger('update-cart');
+            return this;
+        });
+    }
+    cartIntegrity(event = false) {
+        var _a;
+        // Check if cart products are still available in menu
+        if (this.cart.items.length > 0) {
+            const merchantSchedule = new ScheduleManagement(this.merchant.schedule.slots, this.merchant.schedule.closes, this.merchant.schedule.options);
+            const toRemove = [];
+            for (let i = 0; i < this.cart.items.length; i++) {
+                const cartItem = this.cart.items[i];
+                // Skip validation for bundles - they have their own integrity logic
+                if (cartItem.type === 'BUNDLE') {
+                    if (cartItem.item.unavailable)
+                        toRemove.push({ item: cartItem, reason: 'unavailable' });
+                    continue;
+                }
+                const menuItem = this.menu.items.find(m => m.id === cartItem.item.id);
+                const category = this.menu.categories.find(c => { var _a; return (_a = c.itemIds) === null || _a === void 0 ? void 0 : _a.includes(cartItem.item.uid); });
+                if (!menuItem) {
+                    toRemove.push({ item: cartItem, reason: 'missing' });
+                    continue;
+                }
+                if (menuItem.archived) {
+                    toRemove.push({ item: cartItem, reason: 'archived' });
+                    continue;
+                }
+                if (menuItem.unavailable) {
+                    toRemove.push({ item: cartItem, reason: 'unavailable' });
+                    continue;
+                }
+                if (category === null || category === void 0 ? void 0 : category.availability) {
+                    const atDate = this.cart.when ? DateTime.fromISO(this.cart.when) : DateTime.now();
+                    // ItemAvailability/CategoryAvailability share semantics but use different slot interfaces — bridge via cast.
+                    const categoryAvailability = categoryAvailable(category.availability, atDate, merchantSchedule);
+                    if (!categoryAvailability.isAvailable) {
+                        toRemove.push({ item: cartItem, reason: 'not-available-at-date' });
+                        continue;
+                    }
+                }
+                cartItem.item = menuItem;
+            }
+            if (toRemove.length > 0) {
+                const removedUuids = new Set(toRemove.map(r => r.item.uuid));
+                this.cart.items = this.cart.items.filter(item => !removedUuids.has(item.uuid));
+                if (event) {
+                    for (const r of toRemove) {
+                        this.trigger('product-removed', { item: r.item, reason: r.reason });
+                    }
+                }
+            }
+            // Update cart
+            this.cart.totalItems = getProductCount(this.cart);
+            this.cart.totalItemPrice = getProductPriceSum(this.cart);
+            if (this.cart.paymentMethods && this.cart.paymentMethods.length > 0) {
+                this.updatePaymentMethodAmount();
+            }
+            if (this.cart.addons && ((_a = this.cart.addons) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            }
+        }
+    }
+}
+//# sourceMappingURL=Cart.js.map