shopoflex-types 1.0.181 → 1.0.183

package/dist/index.d.ts

@@ -2,3 +2,4 @@ export * from './common';
 export * from './productCart';
 export * from './filters';
 export * from './accounting';
+export * from './samples';

package/dist/index.js

@@ -18,3 +18,4 @@ __exportStar(require("./common"), exports);
 __exportStar(require("./productCart"), exports);
 __exportStar(require("./filters"), exports);
 __exportStar(require("./accounting"), exports);
+__exportStar(require("./samples"), exports);

package/dist/samples.d.ts

@@ -0,0 +1,40 @@
+import { Address, Discount, IZone } from "./common";
+import { CartItem } from "./productCart";
+export interface SampleTaxConfig {
+    type: "fixed" | "perCountry";
+    fixed?: {
+        active: boolean;
+        show: boolean;
+        payer: "vendor" | "customer";
+        percentage: number;
+    };
+    perCountry?: Record<string, {
+        active: boolean;
+        show: boolean;
+        payer: "vendor" | "customer";
+        percentage: number;
+    }>;
+}
+export declare const calculateCartTotalsWithDiscounts: (items: CartItem[], deliveryFee: number, allDiscounts: Discount[], manualDiscount?: Discount, vendorTaxConfig?: SampleTaxConfig, customerAddress?: Address | any) => {
+    items: CartItem[];
+    subtotal: number;
+    totalQuantity: number;
+    delivery: number;
+    discount: number;
+    total: number;
+    taxInfo: {
+        taxAmount: number;
+        taxRate: number;
+        shouldShowTax: boolean;
+        customerPays: boolean;
+        vendorTaxAmount: number;
+    };
+    totalDiscount: number;
+};
+export declare const calculateDeliveryFeeForZones: (zones: IZone[], location: {
+    lat: number;
+    lng: number;
+}, mapkey: string) => Promise<{
+    fee: number;
+    isValid: boolean;
+}>;

package/dist/samples.js

@@ -0,0 +1,418 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateDeliveryFeeForZones = exports.calculateCartTotalsWithDiscounts = void 0;
+const calculateCartTotalsWithDiscounts = (items, deliveryFee, allDiscounts, manualDiscount, vendorTaxConfig, customerAddress) => {
+    // Calculate initial totals for each item
+    const itemsWithTotals = items.map((item) => {
+        const basePrice = item.selectedVariant?.priceModel?.price || 0;
+        const modifiersPrice = item.modifiersPrice || 0;
+        const unitPrice = basePrice + modifiersPrice;
+        const totalPrice = unitPrice * item.quantity;
+        return {
+            ...item,
+            basePrice,
+            modifiersPrice,
+            unitPrice,
+            totalPrice,
+        };
+    });
+    const subtotal = itemsWithTotals.reduce((sum, item) => sum + (item.totalPrice ?? 0), 0);
+    const totalQuantity = itemsWithTotals.reduce((sum, item) => sum + item.quantity, 0);
+    // Create base cart for discount calculations
+    const baseCart = {
+        items: itemsWithTotals,
+        subtotal,
+        totalQuantity,
+        delivery: deliveryFee,
+        discount: 0,
+        total: subtotal + deliveryFee,
+    };
+    // Apply discounts and get updated cart
+    const applyDiscounts = (cart, allDiscounts, manualDiscount) => {
+        if (!cart)
+            return { updatedCart: cart, totalDiscount: 0 };
+        const currentDate = new Date();
+        let cartLevelDiscountAmount = 0; // Only cart_total discounts
+        let deliveryDiscountAmount = 0; // Only free_delivery discounts
+        // Helper function to calculate discount amount (inlined)
+        const calculateAmount = (discount, subtotal, deliveryFee) => {
+            if (!discount)
+                return 0;
+            let applicableTotal = 0;
+            // Determine applicable total based on discount category
+            if (discount.discountCategory === "free_delivery") {
+                applicableTotal = deliveryFee;
+            }
+            else if (discount.discountCategory === "cart_total") {
+                applicableTotal = subtotal;
+            }
+            else if (discount.discountCategory === "category_discount") {
+                // Calculate total basePrice of items in applicable categories (excludes modifiers)
+                applicableTotal = cart.items.reduce((total, item) => {
+                    const itemCategoryIds = Array.isArray(item.categoriesIds)
+                        ? item.categoriesIds
+                        : [];
+                    const hasApplicableCategory = itemCategoryIds.some((catId) => discount.applicableCategories.some((discountCatId) => catId.toString() === discountCatId.toString()));
+                    const isExcluded = itemCategoryIds.some((catId) => discount.excludedCategories.some((excludedCatId) => catId.toString() === excludedCatId.toString()));
+                    if (hasApplicableCategory && !isExcluded) {
+                        return total + (item.basePrice || 0) * (item.quantity || 1);
+                    }
+                    return total;
+                }, 0);
+            }
+            else if (discount.discountCategory === "product_discount") {
+                // Calculate total basePrice of applicable products (excludes modifiers)
+                applicableTotal = cart.items.reduce((total, item) => {
+                    if (!item._id)
+                        return total;
+                    const isApplicable = discount.applicableProducts.some((prodId) => item._id.toString() === prodId.toString());
+                    const isExcluded = discount.excludedProducts.some((excludedProdId) => item._id.toString() === excludedProdId.toString());
+                    if (isApplicable && !isExcluded) {
+                        return total + (item.basePrice || 0) * (item.quantity || 1);
+                    }
+                    return total;
+                }, 0);
+            }
+            let discountAmount = 0;
+            // Calculate discount based on type
+            if (discount.type === "fixed") {
+                discountAmount = discount.value;
+            }
+            else if (discount.type === "percentage") {
+                discountAmount = (applicableTotal * discount.value) / 100;
+                // Apply maximum discount cap if specified
+                if (discount.maxDiscountAmount) {
+                    discountAmount = Math.min(discountAmount, discount.maxDiscountAmount);
+                }
+            }
+            // Ensure discount doesn't exceed applicable total
+            return Math.min(discountAmount, applicableTotal);
+        };
+        // Find automatic discounts that should be applied
+        const automaticDiscounts = allDiscounts.filter((discount) => {
+            return (discount.isAutomatic &&
+                discount.status === "active" &&
+                (!discount.startDate || new Date(discount.startDate) <= currentDate) &&
+                (!discount.endDate || new Date(discount.endDate) >= currentDate) &&
+                (!discount.usageLimit || discount.usageCount < discount.usageLimit) &&
+                cart.subtotal >= discount.minCartValue);
+        });
+        // Apply manual discount if provided
+        if (manualDiscount) {
+            const manualDiscountAmount = calculateAmount(manualDiscount, cart.subtotal, cart.delivery || 0);
+            if (manualDiscount.discountCategory === "free_delivery") {
+                deliveryDiscountAmount += manualDiscountAmount;
+            }
+            else if (manualDiscount.discountCategory === "cart_total") {
+                cartLevelDiscountAmount += manualDiscountAmount;
+            }
+            // Product and category discounts are handled at item level, not here
+        }
+        // Apply automatic discounts with fixed combination rules:
+        // 1. Different categories always combine
+        // 2. Same categories never combine (manual wins)
+        // 3. Manual discount always wins over automatic discounts of same category
+        for (const autoDiscount of automaticDiscounts) {
+            let canApply = false;
+            if (!manualDiscount) {
+                // No manual discount, apply automatic discount
+                canApply = true;
+            }
+            else if (autoDiscount.discountCategory !== manualDiscount.discountCategory) {
+                // Different categories always combine
+                canApply = true;
+            }
+            // Same category with manual discount = skip automatic (manual wins)
+            if (canApply) {
+                const autoDiscountAmount = calculateAmount(autoDiscount, cart.subtotal, cart.delivery || 0);
+                if (autoDiscount.discountCategory === "free_delivery") {
+                    deliveryDiscountAmount += autoDiscountAmount;
+                }
+                else if (autoDiscount.discountCategory === "cart_total") {
+                    cartLevelDiscountAmount += autoDiscountAmount;
+                }
+                // Product and category discounts are handled at item level, not here
+            }
+        }
+        // Ensure discounts don't exceed their respective totals
+        cartLevelDiscountAmount = Math.min(cartLevelDiscountAmount, cart.subtotal);
+        deliveryDiscountAmount = Math.min(deliveryDiscountAmount, cart.delivery || 0);
+        const finalDeliveryFee = Math.max(0, (cart.delivery || 0) - deliveryDiscountAmount);
+        // Apply discounts to individual cart items
+        const updatedItems = cart.items.map((item) => {
+            // Recalculate item prices based on current quantity
+            const basePrice = item.selectedVariant?.priceModel?.price || item.basePrice || 0;
+            const modifiersPrice = item.modifiersPrice || 0;
+            const unitPrice = basePrice + modifiersPrice;
+            let itemDiscountAmount = 0;
+            const itemBasePrice = basePrice * (item.quantity || 1);
+            // Check if item is affected by manual discount
+            if (manualDiscount &&
+                manualDiscount.discountCategory !== "free_delivery") {
+                if (isItemEligibleForDiscount(item, manualDiscount)) {
+                    itemDiscountAmount += calculateItemDiscountAmount(item, manualDiscount, cart);
+                }
+            }
+            // Check if item is affected by automatic discounts
+            for (const autoDiscount of automaticDiscounts) {
+                if (autoDiscount.discountCategory === "free_delivery")
+                    continue;
+                let canApply = false;
+                if (!manualDiscount) {
+                    canApply = true;
+                }
+                else if (autoDiscount.discountCategory !== manualDiscount.discountCategory) {
+                    canApply = true;
+                }
+                if (canApply && isItemEligibleForDiscount(item, autoDiscount)) {
+                    itemDiscountAmount += calculateItemDiscountAmount(item, autoDiscount, cart);
+                }
+            }
+            // Ensure item discount doesn't exceed item's base price
+            itemDiscountAmount = Math.min(itemDiscountAmount, itemBasePrice);
+            // Calculate new prices using recalculated values
+            const discountedBasePrice = Math.max(0, itemBasePrice - itemDiscountAmount);
+            const newTotalPrice = discountedBasePrice + modifiersPrice;
+            return {
+                ...item,
+                basePrice,
+                modifiersPrice,
+                unitPrice,
+                discountAmount: itemDiscountAmount,
+                discountedBasePrice: discountedBasePrice,
+                totalPrice: newTotalPrice,
+            };
+        });
+        // Helper function to check if item is eligible for discount
+        function isItemEligibleForDiscount(item, discount) {
+            if (discount.discountCategory === "cart_total") {
+                // Cart total discounts should NOT be applied to individual items
+                // They affect the cart totals only
+                return false;
+            }
+            else if (discount.discountCategory === "category_discount") {
+                const itemCategoryIds = Array.isArray(item.categoriesIds)
+                    ? item.categoriesIds
+                    : [];
+                const hasApplicableCategory = itemCategoryIds.some((catId) => discount.applicableCategories.some((discountCatId) => catId.toString() === discountCatId.toString()));
+                const isExcluded = itemCategoryIds.some((catId) => discount.excludedCategories.some((excludedCatId) => catId.toString() === excludedCatId.toString()));
+                return hasApplicableCategory && !isExcluded;
+            }
+            else if (discount.discountCategory === "product_discount") {
+                if (!item._id)
+                    return false;
+                const isApplicable = discount.applicableProducts.some((prodId) => item._id.toString() === prodId.toString());
+                const isExcluded = discount.excludedProducts.some((excludedProdId) => item._id.toString() === excludedProdId.toString());
+                return isApplicable && !isExcluded;
+            }
+            return false;
+        }
+        // Helper function to calculate discount amount for a specific item
+        function calculateItemDiscountAmount(item, discount, cart) {
+            const itemBasePrice = (item.basePrice || 0) * (item.quantity || 1);
+            if (discount.type === "fixed") {
+                // For fixed discounts, distribute proportionally across eligible items
+                const totalEligibleValue = cart.items.reduce((total, cartItem) => {
+                    if (isItemEligibleForDiscount(cartItem, discount)) {
+                        return (total + (cartItem.basePrice || 0) * (cartItem.quantity || 1));
+                    }
+                    return total;
+                }, 0);
+                if (totalEligibleValue > 0) {
+                    const itemProportion = itemBasePrice / totalEligibleValue;
+                    return discount.value * itemProportion;
+                }
+                return 0;
+            }
+            else if (discount.type === "percentage") {
+                let discountAmount = (itemBasePrice * discount.value) / 100;
+                // Apply maximum discount cap proportionally if specified
+                if (discount.maxDiscountAmount) {
+                    const totalEligibleValue = cart.items.reduce((total, cartItem) => {
+                        if (isItemEligibleForDiscount(cartItem, discount)) {
+                            return (total + (cartItem.basePrice || 0) * (cartItem.quantity || 1));
+                        }
+                        return total;
+                    }, 0);
+                    if (totalEligibleValue > 0) {
+                        const itemProportion = itemBasePrice / totalEligibleValue;
+                        const maxDiscountForItem = discount.maxDiscountAmount * itemProportion;
+                        discountAmount = Math.min(discountAmount, maxDiscountForItem);
+                    }
+                }
+                return discountAmount;
+            }
+            return 0;
+        }
+        // Recalculate subtotal based on updated items
+        const newSubtotal = updatedItems.reduce((total, item) => total + (item.totalPrice || 0), 0);
+        // Cap cart discount to not exceed the available subtotal
+        const cappedCartLevelDiscountAmount = Math.min(cartLevelDiscountAmount, newSubtotal);
+        const updatedCart = {
+            ...cart,
+            items: updatedItems,
+            subtotal: newSubtotal,
+            discount: cappedCartLevelDiscountAmount, // Only cart-level discounts show in discount field
+            delivery: finalDeliveryFee, // Already reduced by delivery discounts
+            total: Math.max(0, newSubtotal - cappedCartLevelDiscountAmount + finalDeliveryFee),
+        };
+        return {
+            updatedCart,
+            totalDiscount: cappedCartLevelDiscountAmount + deliveryDiscountAmount,
+        };
+    };
+    const { updatedCart, totalDiscount } = applyDiscounts(baseCart, allDiscounts, manualDiscount);
+    // Calculate vendor tax if configuration is provided
+    let taxInfo = {
+        taxAmount: 0,
+        taxRate: 0,
+        shouldShowTax: false,
+        customerPays: false,
+        vendorTaxAmount: 0,
+    };
+    const calculateTaxForOrder = (subtotal, vendorTaxConfig, customerCountry) => {
+        if (!vendorTaxConfig || !vendorTaxConfig.type) {
+            return {
+                taxAmount: 0,
+                taxRate: 0,
+                shouldShowTax: false,
+                customerPays: false,
+                vendorTaxAmount: 0,
+            };
+        }
+        let taxConfig = null;
+        // Handle fixed tax configuration
+        if (vendorTaxConfig.type === "fixed" && vendorTaxConfig.fixed) {
+            taxConfig = vendorTaxConfig.fixed;
+        }
+        // Handle per-country tax configuration
+        else if (vendorTaxConfig.type === "perCountry" &&
+            vendorTaxConfig.perCountry &&
+            customerCountry) {
+            // Find exact country match (case-insensitive)
+            const countryKey = Object.keys(vendorTaxConfig.perCountry).find((key) => key.toLowerCase() === customerCountry.toLowerCase());
+            if (countryKey) {
+                taxConfig = vendorTaxConfig.perCountry[countryKey];
+            }
+        }
+        if (!taxConfig || !taxConfig.active) {
+            return {
+                taxAmount: 0,
+                taxRate: 0,
+                shouldShowTax: false,
+                customerPays: false,
+                vendorTaxAmount: 0,
+            };
+        }
+        const taxRate = taxConfig.percentage / 100;
+        const calculatedTaxAmount = subtotal * taxRate;
+        const customerPays = taxConfig.payer === "customer";
+        const shouldShowTax = taxConfig.show;
+        return {
+            taxAmount: customerPays ? calculatedTaxAmount : 0, // Only add tax to total if customer pays
+            taxRate,
+            shouldShowTax,
+            customerPays,
+            vendorTaxAmount: !customerPays ? calculatedTaxAmount : 0, // Track vendor tax amount for display
+        };
+    };
+    if (vendorTaxConfig) {
+        const customerCountry = customerAddress?.country;
+        const calculatedTax = calculateTaxForOrder(updatedCart.subtotal, vendorTaxConfig, customerCountry);
+        taxInfo = {
+            ...calculatedTax,
+            vendorTaxAmount: calculatedTax.vendorTaxAmount || 0,
+        };
+    }
+    // Final total calculation with tax
+    const finalTotal = updatedCart.total + taxInfo.taxAmount;
+    return {
+        items: updatedCart.items,
+        subtotal: updatedCart.subtotal,
+        totalQuantity: updatedCart.totalQuantity,
+        delivery: updatedCart.delivery,
+        discount: updatedCart.discount,
+        total: finalTotal,
+        taxInfo,
+        totalDiscount,
+    };
+};
+exports.calculateCartTotalsWithDiscounts = calculateCartTotalsWithDiscounts;
+const calculateDeliveryFeeForZones = async (zones, location, mapkey) => {
+    let totalFee = 0;
+    let isValid = false;
+    const calculateDistance = (point1, point2) => {
+        if (!point1 ||
+            !point2 ||
+            typeof point1.lat !== "number" ||
+            typeof point1.lng !== "number" ||
+            typeof point2.lat !== "number" ||
+            typeof point2.lng !== "number") {
+            console.error("❌ [Distance] Invalid coordinates:", { point1, point2 });
+            return Infinity; // Invalid coordinates means infinite distance
+        }
+        const R = 6371;
+        const dLat = (point2.lat - point1.lat) * (Math.PI / 180);
+        const dLng = (point2.lng - point1.lng) * (Math.PI / 180);
+        const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+            Math.cos(point1.lat * (Math.PI / 180)) *
+                Math.cos(point2.lat * (Math.PI / 180)) *
+                Math.sin(dLng / 2) *
+                Math.sin(dLng / 2);
+        const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+        const distance = R * c;
+        return distance;
+    };
+    for (let i = 0; i < zones.length; i++) {
+        const zone = zones[i];
+        const distance = calculateDistance(zone.markerPosition, location);
+        let zoneValid = false;
+        const isInCountry = async (location, country, mapkey) => {
+            if (!mapkey) {
+                return false;
+            }
+            try {
+                const url = `https://maps.googleapis.com/maps/api/geocode/json?latlng=${location.lat},${location.lng}&key=${mapkey}`;
+                const response = await fetch(url);
+                const data = await response.json();
+                if (data.status === "OK" && data.results?.[0]) {
+                    const countryComponent = data.results[0].address_components.find((c) => c.types.includes("country"));
+                    // Check both long_name and short_name
+                    const longNameMatch = countryComponent?.long_name?.toLowerCase() ===
+                        country.toLowerCase();
+                    const shortNameMatch = countryComponent?.short_name?.toLowerCase() ===
+                        country.toLowerCase();
+                    return longNameMatch || shortNameMatch;
+                }
+                return false;
+            }
+            catch (error) {
+                console.error("❌ [Country Check] Error during country validation:", error);
+                return false;
+            }
+        };
+        if (zone.deliveryRange === "radius" && distance <= (zone.radius || 0)) {
+            zoneValid = true;
+        }
+        else if (zone.deliveryRange === "country") {
+            // For country-based zones, check both country AND radius as fallback
+            const countryValid = await isInCountry(location, zone.country || "lebanon", mapkey);
+            const radiusValid = zone.radius && distance <= zone.radius;
+            // Accept if either country check passes OR within radius (fallback)
+            zoneValid = countryValid || radiusValid;
+        }
+        if (zoneValid) {
+            isValid = true;
+            if (zone.deliveryType === "constant") {
+                const fee = parseFloat(zone.deliveryFee || "0");
+                totalFee += fee;
+            }
+            else if (zone.deliveryType === "distance") {
+                const fee = distance * parseFloat(zone.pricePerKm || "0");
+                totalFee += fee;
+            }
+        }
+    }
+    return { fee: totalFee, isValid };
+};
+exports.calculateDeliveryFeeForZones = calculateDeliveryFeeForZones;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shopoflex-types",
-  "version": "1.0.181",
+  "version": "1.0.183",
   "description": "Shared TypeScript types for Shopoflex applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",