@jsdev_ninja/core 0.12.8 → 0.12.9

package/dist/entities/Discount/strategies/BundleStrategy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BundleStrategy.d.ts","sourceRoot":"","sources":["../../../../lib/entities/Discount/strategies/BundleStrategy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEtE,qBAAa,sBAAuB,YAAW,gBAAgB;IAC7D,QAAQ,CAAC,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO;IAchE,SAAS,CAAC,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,eAAe,GAAG,cAAc;IA2CxE,OAAO,CAAC,gBAAgB;IAOxB,OAAO,CAAC,gBAAgB;IAMxB,OAAO,CAAC,sBAAsB;IAK9B,OAAO,CAAC,wBAAwB;IAwBhC,OAAO,CAAC,kBAAkB;CAmB3B"}
+{"version":3,"file":"BundleStrategy.d.ts","sourceRoot":"","sources":["../../../../lib/entities/Discount/strategies/BundleStrategy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEtE,qBAAa,sBAAuB,YAAW,gBAAgB;IAC9D,QAAQ,CAAC,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO;IAchE,SAAS,CAAC,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,eAAe,GAAG,cAAc;IA0CxE,OAAO,CAAC,gBAAgB;IAKxB,OAAO,CAAC,gBAAgB;IAMxB,OAAO,CAAC,sBAAsB;IAI9B,OAAO,CAAC,wBAAwB;IAwBhC,OAAO,CAAC,kBAAkB;CAmB1B"}

package/dist/entities/Discount/strategies/BundleStrategy.js

@@ -16,7 +16,7 @@ export class BundleDiscountStrategy {
         }
         const { productsId, requiredQuantity, bundlePrice } = discount.variant;
         // Get applicable items (only the products in the bundle)
-        const applicableItems = context.cart.filter(item => productsId.includes(item.product.id));
+        const applicableItems = context.cart.filter((item) => productsId.includes(item.product.id));
         const totalQuantity = this.getTotalQuantity(context.cart, productsId);
         const bundleCount = Math.floor(totalQuantity / requiredQuantity);
         if (bundleCount === 0) {
@@ -38,17 +38,15 @@ export class BundleDiscountStrategy {
     }
     isDiscountActive(discount) {
         const now = Date.now();
-        return discount.active &&
-            discount.startDate <= now &&
-            discount.endDate >= now;
+        return discount.active && discount.startDate <= now && discount.endDate >= now;
     }
     getTotalQuantity(cart, productIds) {
         return cart
-            .filter(item => productIds.includes(item.product.id))
+            .filter((item) => productIds.includes(item.product.id))
             .reduce((sum, item) => sum + item.amount, 0);
     }
     calculateOriginalPrice(items) {
-        return items.reduce((sum, item) => sum + (item.product.price * item.amount), 0);
+        return items.reduce((sum, item) => sum + item.product.price * item.amount, 0);
     }
     calculateDiscountedPrice(originalPrice, bundlePrice, bundleCount, requiredQuantity, totalQuantity) {
         // For bundle discounts, we pay the bundle price for each complete bundle
@@ -66,13 +64,13 @@ export class BundleDiscountStrategy {
     }
     distributeDiscount(items, totalDiscount, originalPrice) {
         const discountRatio = totalDiscount / originalPrice;
-        return items.map(item => {
-            const itemDiscount = (item.product.price * item.amount) * discountRatio;
+        return items.map((item) => {
+            const itemDiscount = item.product.price * item.amount * discountRatio;
             return {
                 productId: item.product.id,
                 quantity: item.amount,
                 originalPrice: Number(item.product.price.toFixed(2)),
-                discountedPrice: Number((item.product.price - (itemDiscount / item.amount)).toFixed(2)),
+                discountedPrice: Number((item.product.price - itemDiscount / item.amount).toFixed(2)),
                 discountAmount: Number(itemDiscount.toFixed(2)),
             };
         });

package/dist/entities/Discount/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../lib/entities/Discount/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,wBAAwB;;;;;;;;;GAGxB,CAAC;AAGd,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;IAOhC,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWzB,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACvD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAG1E,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,OAAO,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,KAAK,CAAC;QACnB,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;QACjB,aAAa,EAAE,MAAM,CAAC;QACtB,eAAe,EAAE,MAAM,CAAC;QACxB,cAAc,EAAE,MAAM,CAAC;KACxB,CAAC,CAAC;CACJ;AAED,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,cAAc,CAAC,eAAe,CAAC,CAAC;CAChD;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,KAAK,CAAC;QACV,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE;YACP,EAAE,EAAE,MAAM,CAAC;YACX,KAAK,EAAE,MAAM,CAAC;SACf,CAAC;KACH,CAAC,CAAC;IACH,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,gBAAgB,EAAE,eAAe,EAAE,CAAC;CACrC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../lib/entities/Discount/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,wBAAwB;;;;;;;;;GAKzB,CAAC;AAGb,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;IAOhC,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWzB,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACvD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAG1E,MAAM,WAAW,cAAc;IAC9B,UAAU,EAAE,OAAO,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,KAAK,CAAC;QACpB,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;QACjB,aAAa,EAAE,MAAM,CAAC;QACtB,eAAe,EAAE,MAAM,CAAC;QACxB,cAAc,EAAE,MAAM,CAAC;KACvB,CAAC,CAAC;CACH;AAED,MAAM,WAAW,eAAe;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,cAAc,CAAC,eAAe,CAAC,CAAC;CAC/C;AAED,MAAM,WAAW,eAAe;IAC/B,IAAI,EAAE,KAAK,CAAC;QACX,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE;YACR,EAAE,EAAE,MAAM,CAAC;YACX,KAAK,EAAE,MAAM,CAAC;SACd,CAAC;KACF,CAAC,CAAC;IACH,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,gBAAgB,EAAE,eAAe,EAAE,CAAC;CACpC"}

package/dist/entities/Discount/types.js

@@ -1,14 +1,16 @@
 import { z } from "zod";
 // Simple discount conditions
-export const DiscountConditionsSchema = z.object({
+export const DiscountConditionsSchema = z
+    .object({
     minSpend: z.number().positive().optional(),
     stackable: z.boolean().default(false),
-}).optional();
+})
+    .optional();
 // Bundle discount - buy X items for Y price
 export const DiscountVariantSchema = z.discriminatedUnion("variantType", [
     z.object({
         variantType: z.literal("bundle"),
-        productsId: z.array(z.string()).min(1), // Which products are included
+        productsId: z.array(z.string().nonempty()).min(1), // Which products are included
         requiredQuantity: z.number().positive(), // How many items needed (e.g., 3)
         bundlePrice: z.number().positive(), // Total price for the bundle (e.g., $25)
     }),
@@ -18,7 +20,7 @@ export const DiscountSchema = z.object({
     storeId: z.string().min(1),
     companyId: z.string().min(1),
     id: z.string().min(1),
-    name: z.array(z.object({ lang: z.enum(["he"]), value: z.string() })),
+    name: z.array(z.object({ lang: z.enum(["he"]), value: z.string().nonempty() })),
     active: z.boolean(),
     startDate: z.number(),
     endDate: z.number(),

package/dist/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,SAAS,EAAY,MAAM,EAAE,MAAM,aAAa,CAAC;AA8BjE,wBAAgB,WAAW,CAAC,EAC3B,IAAI,EACJ,SAAS,EACT,KAAK,GACL,EAAE;IACF,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;IACrB,SAAS,EAAE,SAAS,EAAE,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;CACd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4EA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,SAAS,EAAY,MAAM,EAAE,MAAM,aAAa,CAAC;AA8BjE,wBAAgB,WAAW,CAAC,EAC3B,IAAI,EACJ,SAAS,EACT,KAAK,GACL,EAAE;IACF,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;IACrB,SAAS,EAAE,SAAS,EAAE,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;CACd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsFA"}

package/dist/utils/index.js

@@ -35,6 +35,7 @@ export function getCartCost({ cart, discounts, store, }) {
     }));
     // Apply discounts using the new discount engine
     const discountResult = DiscountEngine.calculateDiscounts(cartForEngine, discounts);
+    console.log("discountResult", discountResult);
     // Map the results back to the original format with additional product info
     const result = cart.map((item, index) => {
         const engineItem = discountResult.items[index];
@@ -64,10 +65,17 @@ export function getCartCost({ cart, discounts, store, }) {
             }
             acc.vat = Number((acc.vat + vat).toFixed(2));
         }
-        acc.cost += amount * finalPrice;
+        // Round finalPrice to prevent floating point errors from discount engine
+        const roundedFinalPrice = Number(finalPrice.toFixed(2));
+        acc.cost += amount * roundedFinalPrice;
         acc.discount += finalDiscount ? amount * finalDiscount : finalDiscount;
-        acc.finalCost += amount * finalPrice + (isVatIncludedInPrice ? 0 : productVatValue);
-        acc.productsCost += amount * finalPrice + (isVatIncludedInPrice ? 0 : productVatValue);
+        acc.finalCost += amount * roundedFinalPrice + (isVatIncludedInPrice ? 0 : productVatValue);
+        acc.productsCost += amount * roundedFinalPrice + (isVatIncludedInPrice ? 0 : productVatValue);
+        // Round all accumulated values to prevent floating point errors
+        acc.cost = Number(acc.cost.toFixed(2));
+        acc.discount = Number(acc.discount.toFixed(2));
+        acc.finalCost = Number(acc.finalCost.toFixed(2));
+        acc.productsCost = Number(acc.productsCost.toFixed(2));
         return acc;
     }, {
         discount: 0,

package/lib/entities/Discount/strategies/BundleStrategy.ts

@@ -2,122 +2,118 @@ import { DiscountStrategy } from "../strategy";
 import { TDiscount, DiscountResult, DiscountContext } from "../types";
 
 export class BundleDiscountStrategy implements DiscountStrategy {
-  canApply(discount: TDiscount, context: DiscountContext): boolean {
-    if (discount.variant.variantType !== "bundle") return false;
-    
-    // Check if discount is active
-    if (!this.isDiscountActive(discount)) return false;
-    
-    const { productsId, requiredQuantity } = discount.variant;
-    
-    // Check if cart has enough of the required products
-    const totalQuantity = this.getTotalQuantity(context.cart, productsId);
-    
-    return totalQuantity >= requiredQuantity;
-  }
-  
-  calculate(discount: TDiscount, context: DiscountContext): DiscountResult {
-    if (discount.variant.variantType !== "bundle") {
-      return { applicable: false, discountAmount: 0, affectedItems: [] };
-    }
-    
-    const { productsId, requiredQuantity, bundlePrice } = discount.variant;
-    
-    // Get applicable items (only the products in the bundle)
-    const applicableItems = context.cart.filter(item => 
-      productsId.includes(item.product.id));
-    
-    const totalQuantity = this.getTotalQuantity(context.cart, productsId);
-    const bundleCount = Math.floor(totalQuantity / requiredQuantity);
-    
-    if (bundleCount === 0) {
-      return { applicable: false, discountAmount: 0, affectedItems: [] };
-    }
-    
-    // Calculate original price for bundled items
-    const originalPrice = this.calculateOriginalPrice(applicableItems);
-    
-    // Calculate discounted price
-    const cartTotalQuantity = this.getTotalQuantity(context.cart, productsId);
-    const discountedPrice = this.calculateDiscountedPrice(
-      originalPrice, 
-      bundlePrice, 
-      bundleCount,
-      requiredQuantity,
-      cartTotalQuantity
-    );
-    
-    const totalDiscount = originalPrice - discountedPrice;
-    
-    // Distribute discount proportionally among items
-    const affectedItems = this.distributeDiscount(applicableItems, totalDiscount, originalPrice);
-    
-    return {
-      applicable: true,
-      discountAmount: Number(totalDiscount.toFixed(2)),
-      affectedItems,
-    };
-  }
-  
-  private isDiscountActive(discount: TDiscount): boolean {
-    const now = Date.now();
-    return discount.active && 
-           discount.startDate <= now && 
-           discount.endDate >= now;
-  }
-  
-  private getTotalQuantity(cart: DiscountContext["cart"], productIds: string[]): number {
-    return cart
-      .filter(item => productIds.includes(item.product.id))
-      .reduce((sum, item) => sum + item.amount, 0);
-  }
-  
-  private calculateOriginalPrice(items: DiscountContext["cart"]): number {
-    return items.reduce((sum, item) => 
-      sum + (item.product.price * item.amount), 0);
-  }
-  
-  private calculateDiscountedPrice(
-    originalPrice: number, 
-    bundlePrice: number, 
-    bundleCount: number,
-    requiredQuantity: number,
-    totalQuantity: number
-  ): number {
-    // For bundle discounts, we pay the bundle price for each complete bundle
-    // and full price for any remaining items
-    const bundledItemsPrice = bundlePrice * bundleCount;
-    
-    // For bundle discounts, we pay bundle price for complete bundles
-    // and full price for remaining items
-    // Since we're dealing with the total original price, we need to calculate
-    // how much of the original price represents the bundled items vs remaining items
-    const itemsInBundles = bundleCount * requiredQuantity;
-    const remainingItems = Math.max(0, totalQuantity - itemsInBundles);
-    
-    // Calculate the proportion of original price that represents remaining items
-    const remainingItemsPrice = (remainingItems / totalQuantity) * originalPrice;
-    
-    return bundledItemsPrice + remainingItemsPrice;
-  }
-  
-  private distributeDiscount(
-    items: DiscountContext["cart"], 
-    totalDiscount: number, 
-    originalPrice: number
-  ): DiscountResult["affectedItems"] {
-    const discountRatio = totalDiscount / originalPrice;
-    
-    return items.map(item => {
-      const itemDiscount = (item.product.price * item.amount) * discountRatio;
-      
-      return {
-        productId: item.product.id,
-        quantity: item.amount,
-        originalPrice: Number(item.product.price.toFixed(2)),
-        discountedPrice: Number((item.product.price - (itemDiscount / item.amount)).toFixed(2)),
-        discountAmount: Number(itemDiscount.toFixed(2)),
-      };
-    });
-  }
-} 
+	canApply(discount: TDiscount, context: DiscountContext): boolean {
+		if (discount.variant.variantType !== "bundle") return false;
+
+		// Check if discount is active
+		if (!this.isDiscountActive(discount)) return false;
+
+		const { productsId, requiredQuantity } = discount.variant;
+
+		// Check if cart has enough of the required products
+		const totalQuantity = this.getTotalQuantity(context.cart, productsId);
+
+		return totalQuantity >= requiredQuantity;
+	}
+
+	calculate(discount: TDiscount, context: DiscountContext): DiscountResult {
+		if (discount.variant.variantType !== "bundle") {
+			return { applicable: false, discountAmount: 0, affectedItems: [] };
+		}
+
+		const { productsId, requiredQuantity, bundlePrice } = discount.variant;
+
+		// Get applicable items (only the products in the bundle)
+		const applicableItems = context.cart.filter((item) => productsId.includes(item.product.id));
+
+		const totalQuantity = this.getTotalQuantity(context.cart, productsId);
+		const bundleCount = Math.floor(totalQuantity / requiredQuantity);
+
+		if (bundleCount === 0) {
+			return { applicable: false, discountAmount: 0, affectedItems: [] };
+		}
+
+		// Calculate original price for bundled items
+		const originalPrice = this.calculateOriginalPrice(applicableItems);
+
+		// Calculate discounted price
+		const cartTotalQuantity = this.getTotalQuantity(context.cart, productsId);
+		const discountedPrice = this.calculateDiscountedPrice(
+			originalPrice,
+			bundlePrice,
+			bundleCount,
+			requiredQuantity,
+			cartTotalQuantity
+		);
+
+		const totalDiscount = originalPrice - discountedPrice;
+
+		// Distribute discount proportionally among items
+		const affectedItems = this.distributeDiscount(applicableItems, totalDiscount, originalPrice);
+
+		return {
+			applicable: true,
+			discountAmount: Number(totalDiscount.toFixed(2)),
+			affectedItems,
+		};
+	}
+
+	private isDiscountActive(discount: TDiscount): boolean {
+		const now = Date.now();
+		return discount.active && discount.startDate <= now && discount.endDate >= now;
+	}
+
+	private getTotalQuantity(cart: DiscountContext["cart"], productIds: string[]): number {
+		return cart
+			.filter((item) => productIds.includes(item.product.id))
+			.reduce((sum, item) => sum + item.amount, 0);
+	}
+
+	private calculateOriginalPrice(items: DiscountContext["cart"]): number {
+		return items.reduce((sum, item) => sum + item.product.price * item.amount, 0);
+	}
+
+	private calculateDiscountedPrice(
+		originalPrice: number,
+		bundlePrice: number,
+		bundleCount: number,
+		requiredQuantity: number,
+		totalQuantity: number
+	): number {
+		// For bundle discounts, we pay the bundle price for each complete bundle
+		// and full price for any remaining items
+		const bundledItemsPrice = bundlePrice * bundleCount;
+
+		// For bundle discounts, we pay bundle price for complete bundles
+		// and full price for remaining items
+		// Since we're dealing with the total original price, we need to calculate
+		// how much of the original price represents the bundled items vs remaining items
+		const itemsInBundles = bundleCount * requiredQuantity;
+		const remainingItems = Math.max(0, totalQuantity - itemsInBundles);
+
+		// Calculate the proportion of original price that represents remaining items
+		const remainingItemsPrice = (remainingItems / totalQuantity) * originalPrice;
+
+		return bundledItemsPrice + remainingItemsPrice;
+	}
+
+	private distributeDiscount(
+		items: DiscountContext["cart"],
+		totalDiscount: number,
+		originalPrice: number
+	): DiscountResult["affectedItems"] {
+		const discountRatio = totalDiscount / originalPrice;
+
+		return items.map((item) => {
+			const itemDiscount = item.product.price * item.amount * discountRatio;
+
+			return {
+				productId: item.product.id,
+				quantity: item.amount,
+				originalPrice: Number(item.product.price.toFixed(2)),
+				discountedPrice: Number((item.product.price - itemDiscount / item.amount).toFixed(2)),
+				discountAmount: Number(itemDiscount.toFixed(2)),
+			};
+		});
+	}
+}

package/lib/entities/Discount/types.ts

@@ -1,32 +1,34 @@
 import { z } from "zod";
 
 // Simple discount conditions
-export const DiscountConditionsSchema = z.object({
-  minSpend: z.number().positive().optional(),
-  stackable: z.boolean().default(false),
-}).optional();
+export const DiscountConditionsSchema = z
+	.object({
+		minSpend: z.number().positive().optional(),
+		stackable: z.boolean().default(false),
+	})
+	.optional();
 
 // Bundle discount - buy X items for Y price
 export const DiscountVariantSchema = z.discriminatedUnion("variantType", [
-  z.object({
-    variantType: z.literal("bundle"),
-    productsId: z.array(z.string()).min(1), // Which products are included
-    requiredQuantity: z.number().positive(), // How many items needed (e.g., 3)
-    bundlePrice: z.number().positive(), // Total price for the bundle (e.g., $25)
-  }),
+	z.object({
+		variantType: z.literal("bundle"),
+		productsId: z.array(z.string().nonempty()).min(1), // Which products are included
+		requiredQuantity: z.number().positive(), // How many items needed (e.g., 3)
+		bundlePrice: z.number().positive(), // Total price for the bundle (e.g., $25)
+	}),
 ]);
 
 export const DiscountSchema = z.object({
-  type: z.literal("Discount"),
-  storeId: z.string().min(1),
-  companyId: z.string().min(1),
-  id: z.string().min(1),
-  name: z.array(z.object({ lang: z.enum(["he"]), value: z.string() })),
-  active: z.boolean(),
-  startDate: z.number(),
-  endDate: z.number(),
-  variant: DiscountVariantSchema,
-  conditions: DiscountConditionsSchema,
+	type: z.literal("Discount"),
+	storeId: z.string().min(1),
+	companyId: z.string().min(1),
+	id: z.string().min(1),
+	name: z.array(z.object({ lang: z.enum(["he"]), value: z.string().nonempty() })),
+	active: z.boolean(),
+	startDate: z.number(),
+	endDate: z.number(),
+	variant: DiscountVariantSchema,
+	conditions: DiscountConditionsSchema,
 });
 
 export type TDiscount = z.infer<typeof DiscountSchema>;
@@ -35,34 +37,32 @@ export type DiscountConditions = z.infer<typeof DiscountConditionsSchema>;
 
 // Simple result types
 export interface DiscountResult {
-  applicable: boolean;
-  discountAmount: number;
-  affectedItems: Array<{
-    productId: string;
-    quantity: number;
-    originalPrice: number;
-    discountedPrice: number;
-    discountAmount: number;
-  }>;
+	applicable: boolean;
+	discountAmount: number;
+	affectedItems: Array<{
+		productId: string;
+		quantity: number;
+		originalPrice: number;
+		discountedPrice: number;
+		discountAmount: number;
+	}>;
 }
 
 export interface AppliedDiscount {
-  discountId: string;
-  discountName: string;
-  discountAmount: number;
-  affectedItems: DiscountResult["affectedItems"];
+	discountId: string;
+	discountName: string;
+	discountAmount: number;
+	affectedItems: DiscountResult["affectedItems"];
 }
 
 export interface DiscountContext {
-  cart: Array<{
-    amount: number;
-    product: {
-      id: string;
-      price: number;
-    };
-  }>;
-  user?: Record<string, unknown>;
-  appliedDiscounts: AppliedDiscount[];
+	cart: Array<{
+		amount: number;
+		product: {
+			id: string;
+			price: number;
+		};
+	}>;
+	user?: Record<string, unknown>;
+	appliedDiscounts: AppliedDiscount[];
 }
-
- 

package/lib/utils/index.ts

@@ -38,19 +38,19 @@ export function getCartCost({
 	store: TStore;
 }) {
 	const { isVatIncludedInPrice } = store;
-	
+
 	// Convert cart items to the format expected by the discount engine
-	const cartForEngine = cart.map(item => ({
+	const cartForEngine = cart.map((item) => ({
 		amount: item.amount,
 		product: {
 			id: item.product.id,
 			price: item.product.price,
 		},
 	}));
-	
+
 	// Apply discounts using the new discount engine
 	const discountResult = DiscountEngine.calculateDiscounts(cartForEngine, discounts);
-	
+
 	// Map the results back to the original format with additional product info
 	const result = cart.map((item, index) => {
 		const engineItem = discountResult.items[index];
@@ -86,10 +86,20 @@ export function getCartCost({
 				acc.vat = Number((acc.vat + vat).toFixed(2));
 			}
 
-			acc.cost += amount * finalPrice;
+			// Round finalPrice to prevent floating point errors from discount engine
+			const roundedFinalPrice = Number(finalPrice.toFixed(2));
+
+			acc.cost += amount * roundedFinalPrice;
 			acc.discount += finalDiscount ? amount * finalDiscount : finalDiscount;
-			acc.finalCost += amount * finalPrice + (isVatIncludedInPrice ? 0 : productVatValue);
-			acc.productsCost += amount * finalPrice + (isVatIncludedInPrice ? 0 : productVatValue);
+			acc.finalCost += amount * roundedFinalPrice + (isVatIncludedInPrice ? 0 : productVatValue);
+			acc.productsCost +=
+				amount * roundedFinalPrice + (isVatIncludedInPrice ? 0 : productVatValue);
+
+			// Round all accumulated values to prevent floating point errors
+			acc.cost = Number(acc.cost.toFixed(2));
+			acc.discount = Number(acc.discount.toFixed(2));
+			acc.finalCost = Number(acc.finalCost.toFixed(2));
+			acc.productsCost = Number(acc.productsCost.toFixed(2));
 
 			return acc;
 		},

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@jsdev_ninja/core",
-	"version": "0.12.8",
+	"version": "0.12.9",
 	"main": "dist/core.cjs.js",
 	"module": "dist/core.es.js",
 	"types": "dist/index.d.ts",