@jsdev_ninja/core 0.12.6 → 0.12.8

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

@@ -0,0 +1,265 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { BundleDiscountStrategy } from "../BundleStrategy";
+describe("BundleDiscountStrategy", () => {
+    let strategy;
+    let mockContext;
+    beforeEach(() => {
+        strategy = new BundleDiscountStrategy();
+        mockContext = {
+            cart: [
+                {
+                    amount: 2,
+                    product: {
+                        id: "product1",
+                        price: 10,
+                    },
+                },
+                {
+                    amount: 1,
+                    product: {
+                        id: "product2",
+                        price: 15,
+                    },
+                },
+            ],
+            user: undefined,
+            appliedDiscounts: [],
+        };
+    });
+    describe("canApply", () => {
+        it("should return true for valid bundle discount", () => {
+            const discount = {
+                type: "Discount",
+                storeId: "store1",
+                companyId: "company1",
+                id: "bundle1",
+                name: [{ lang: "he", value: "Buy 3 for $25" }],
+                active: true,
+                startDate: Date.now() - 1000,
+                endDate: Date.now() + 1000,
+                variant: {
+                    variantType: "bundle",
+                    productsId: ["product1", "product2"],
+                    requiredQuantity: 3,
+                    bundlePrice: 25,
+                },
+                conditions: {
+                    stackable: false,
+                },
+            };
+            expect(strategy.canApply(discount, mockContext)).toBe(true);
+        });
+        it("should return true for bundle variant type", () => {
+            const discount = {
+                ...mockDiscount,
+                variant: {
+                    variantType: "bundle",
+                    productsId: ["product1", "product2"],
+                    requiredQuantity: 3,
+                    bundlePrice: 25,
+                },
+            };
+            // This should work since it's a bundle type and we have 3 items total
+            expect(strategy.canApply(discount, mockContext)).toBe(true);
+        });
+        it("should return false when not enough items", () => {
+            const discount = {
+                type: "Discount",
+                storeId: "store1",
+                companyId: "company1",
+                id: "bundle1",
+                name: [{ lang: "he", value: "Buy 5 for $40" }],
+                active: true,
+                startDate: Date.now() - 1000,
+                endDate: Date.now() + 1000,
+                variant: {
+                    variantType: "bundle",
+                    productsId: ["product1", "product2"],
+                    requiredQuantity: 5, // Need 5, but cart only has 3
+                    bundlePrice: 40,
+                },
+                conditions: {
+                    stackable: false,
+                },
+            };
+            expect(strategy.canApply(discount, mockContext)).toBe(false);
+        });
+        it("should return false when discount is inactive", () => {
+            const discount = {
+                type: "Discount",
+                storeId: "store1",
+                companyId: "company1",
+                id: "bundle1",
+                name: [{ lang: "he", value: "Buy 3 for $25" }],
+                active: false, // Inactive
+                startDate: Date.now() - 1000,
+                endDate: Date.now() + 1000,
+                variant: {
+                    variantType: "bundle",
+                    productsId: ["product1", "product2"],
+                    requiredQuantity: 3,
+                    bundlePrice: 25,
+                },
+                conditions: {
+                    stackable: false,
+                },
+            };
+            expect(strategy.canApply(discount, mockContext)).toBe(false);
+        });
+        it("should return false when discount is expired", () => {
+            const discount = {
+                type: "Discount",
+                storeId: "store1",
+                companyId: "company1",
+                id: "bundle1",
+                name: [{ lang: "he", value: "Buy 3 for $25" }],
+                active: true,
+                startDate: Date.now() - 2000,
+                endDate: Date.now() - 1000, // Expired
+                variant: {
+                    variantType: "bundle",
+                    productsId: ["product1", "product2"],
+                    requiredQuantity: 3,
+                    bundlePrice: 25,
+                },
+                conditions: {
+                    stackable: false,
+                },
+            };
+            expect(strategy.canApply(discount, mockContext)).toBe(false);
+        });
+    });
+    describe("calculate", () => {
+        it("should calculate bundle discount correctly", () => {
+            const discount = {
+                type: "Discount",
+                storeId: "store1",
+                companyId: "company1",
+                id: "bundle1",
+                name: [{ lang: "he", value: "Buy 3 for $25" }],
+                active: true,
+                startDate: Date.now() - 1000,
+                endDate: Date.now() + 1000,
+                variant: {
+                    variantType: "bundle",
+                    productsId: ["product1", "product2"],
+                    requiredQuantity: 3,
+                    bundlePrice: 25,
+                },
+                conditions: {
+                    stackable: false,
+                },
+            };
+            const result = strategy.calculate(discount, mockContext);
+            expect(result.applicable).toBe(true);
+            expect(result.discountAmount).toBe(10); // (2×10 + 1×15) - 25 = 35 - 25 = 10
+            expect(result.affectedItems).toHaveLength(2);
+            // Check product1 discount
+            const product1Item = result.affectedItems.find(item => item.productId === "product1");
+            expect(product1Item).toBeDefined();
+            expect(product1Item.discountAmount).toBeCloseTo(5.71, 2); // Proportional to 20/35
+            // Check product2 discount
+            const product2Item = result.affectedItems.find(item => item.productId === "product2");
+            expect(product2Item).toBeDefined();
+            expect(product2Item.discountAmount).toBeCloseTo(4.29, 2); // Proportional to 15/35
+        });
+        it("should handle multiple bundles", () => {
+            const contextWithMoreItems = {
+                cart: [
+                    {
+                        amount: 6, // 6 items
+                        product: {
+                            id: "product1",
+                            price: 10,
+                        },
+                    },
+                ],
+                user: undefined,
+                appliedDiscounts: [],
+            };
+            const discount = {
+                type: "Discount",
+                storeId: "store1",
+                companyId: "company1",
+                id: "bundle1",
+                name: [{ lang: "he", value: "Buy 3 for $25" }],
+                active: true,
+                startDate: Date.now() - 1000,
+                endDate: Date.now() + 1000,
+                variant: {
+                    variantType: "bundle",
+                    productsId: ["product1"],
+                    requiredQuantity: 3,
+                    bundlePrice: 25,
+                },
+                conditions: {
+                    stackable: false,
+                },
+            };
+            const result = strategy.calculate(discount, contextWithMoreItems);
+            expect(result.applicable).toBe(true);
+            expect(result.discountAmount).toBe(10); // (6×10) - (2×25) = 60 - 50 = 10
+            expect(result.affectedItems).toHaveLength(1);
+            expect(result.affectedItems[0].discountAmount).toBe(10);
+        });
+        it("should return not applicable for invalid bundle", () => {
+            const discount = {
+                ...mockDiscount,
+                variant: {
+                    variantType: "bundle",
+                    productsId: ["product1"],
+                    requiredQuantity: 10, // Too many required
+                    bundlePrice: 25,
+                },
+            };
+            const result = strategy.calculate(discount, mockContext);
+            expect(result.applicable).toBe(false);
+            expect(result.discountAmount).toBe(0);
+            expect(result.affectedItems).toHaveLength(0);
+        });
+        it("should return not applicable when not enough items", () => {
+            const discount = {
+                type: "Discount",
+                storeId: "store1",
+                companyId: "company1",
+                id: "bundle1",
+                name: [{ lang: "he", value: "Buy 5 for $40" }],
+                active: true,
+                startDate: Date.now() - 1000,
+                endDate: Date.now() + 1000,
+                variant: {
+                    variantType: "bundle",
+                    productsId: ["product1", "product2"],
+                    requiredQuantity: 5,
+                    bundlePrice: 40,
+                },
+                conditions: {
+                    stackable: false,
+                },
+            };
+            const result = strategy.calculate(discount, mockContext);
+            expect(result.applicable).toBe(false);
+            expect(result.discountAmount).toBe(0);
+            expect(result.affectedItems).toHaveLength(0);
+        });
+    });
+});
+const mockDiscount = {
+    type: "Discount",
+    storeId: "store1",
+    companyId: "company1",
+    id: "bundle1",
+    name: [{ lang: "he", value: "Buy 3 for $25" }],
+    active: true,
+    startDate: Date.now() - 1000,
+    endDate: Date.now() + 1000,
+    variant: {
+        variantType: "bundle",
+        productsId: ["product1", "product2"],
+        requiredQuantity: 3,
+        bundlePrice: 25,
+    },
+    conditions: {
+        stackable: false,
+    },
+};

package/dist/entities/Discount/strategy.d.ts

@@ -0,0 +1,6 @@
+import { TDiscount, DiscountResult, DiscountContext } from "./types";
+export interface DiscountStrategy {
+    canApply(discount: TDiscount, context: DiscountContext): boolean;
+    calculate(discount: TDiscount, context: DiscountContext): DiscountResult;
+}
+//# sourceMappingURL=strategy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"strategy.d.ts","sourceRoot":"","sources":["../../../lib/entities/Discount/strategy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAErE,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC;IACjE,SAAS,CAAC,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,eAAe,GAAG,cAAc,CAAC;CAC1E"}

package/dist/entities/Discount/strategy.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,148 @@
+import { z } from "zod";
+export declare const DiscountConditionsSchema: z.ZodOptional<z.ZodObject<{
+    minSpend: z.ZodOptional<z.ZodNumber>;
+    stackable: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    stackable: boolean;
+    minSpend?: number | undefined;
+}, {
+    minSpend?: number | undefined;
+    stackable?: boolean | undefined;
+}>>;
+export declare const DiscountVariantSchema: z.ZodDiscriminatedUnion<"variantType", [z.ZodObject<{
+    variantType: z.ZodLiteral<"bundle">;
+    productsId: z.ZodArray<z.ZodString, "many">;
+    requiredQuantity: z.ZodNumber;
+    bundlePrice: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    variantType: "bundle";
+    productsId: string[];
+    requiredQuantity: number;
+    bundlePrice: number;
+}, {
+    variantType: "bundle";
+    productsId: string[];
+    requiredQuantity: number;
+    bundlePrice: number;
+}>]>;
+export declare const DiscountSchema: z.ZodObject<{
+    type: z.ZodLiteral<"Discount">;
+    storeId: z.ZodString;
+    companyId: z.ZodString;
+    id: z.ZodString;
+    name: z.ZodArray<z.ZodObject<{
+        lang: z.ZodEnum<["he"]>;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        lang: "he";
+    }, {
+        value: string;
+        lang: "he";
+    }>, "many">;
+    active: z.ZodBoolean;
+    startDate: z.ZodNumber;
+    endDate: z.ZodNumber;
+    variant: z.ZodDiscriminatedUnion<"variantType", [z.ZodObject<{
+        variantType: z.ZodLiteral<"bundle">;
+        productsId: z.ZodArray<z.ZodString, "many">;
+        requiredQuantity: z.ZodNumber;
+        bundlePrice: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        variantType: "bundle";
+        productsId: string[];
+        requiredQuantity: number;
+        bundlePrice: number;
+    }, {
+        variantType: "bundle";
+        productsId: string[];
+        requiredQuantity: number;
+        bundlePrice: number;
+    }>]>;
+    conditions: z.ZodOptional<z.ZodObject<{
+        minSpend: z.ZodOptional<z.ZodNumber>;
+        stackable: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        stackable: boolean;
+        minSpend?: number | undefined;
+    }, {
+        minSpend?: number | undefined;
+        stackable?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    type: "Discount";
+    id: string;
+    companyId: string;
+    storeId: string;
+    name: {
+        value: string;
+        lang: "he";
+    }[];
+    active: boolean;
+    startDate: number;
+    endDate: number;
+    variant: {
+        variantType: "bundle";
+        productsId: string[];
+        requiredQuantity: number;
+        bundlePrice: number;
+    };
+    conditions?: {
+        stackable: boolean;
+        minSpend?: number | undefined;
+    } | undefined;
+}, {
+    type: "Discount";
+    id: string;
+    companyId: string;
+    storeId: string;
+    name: {
+        value: string;
+        lang: "he";
+    }[];
+    active: boolean;
+    startDate: number;
+    endDate: number;
+    variant: {
+        variantType: "bundle";
+        productsId: string[];
+        requiredQuantity: number;
+        bundlePrice: number;
+    };
+    conditions?: {
+        minSpend?: number | undefined;
+        stackable?: boolean | undefined;
+    } | undefined;
+}>;
+export type TDiscount = z.infer<typeof DiscountSchema>;
+export type DiscountVariant = z.infer<typeof DiscountVariantSchema>;
+export type DiscountConditions = z.infer<typeof DiscountConditionsSchema>;
+export interface DiscountResult {
+    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"];
+}
+export interface DiscountContext {
+    cart: Array<{
+        amount: number;
+        product: {
+            id: string;
+            price: number;
+        };
+    }>;
+    user?: Record<string, unknown>;
+    appliedDiscounts: AppliedDiscount[];
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +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"}

package/dist/entities/Discount/types.js

@@ -0,0 +1,27 @@
+import { z } from "zod";
+// Simple discount conditions
+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)
+    }),
+]);
+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,
+});

package/dist/entities/Discount/utils.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Utility functions for discount calculations
+ */
+/**
+ * Formats a number to 2 decimal places and returns as a number
+ * @param value - The number to format
+ * @returns The formatted number with 2 decimal places
+ */
+export declare function formatCurrency(value: number): number;
+/**
+ * Formats a number to 2 decimal places and returns as a string
+ * @param value - The number to format
+ * @returns The formatted string with 2 decimal places
+ */
+export declare function formatCurrencyString(value: number): string;
+/**
+ * Ensures a monetary value is never negative
+ * @param value - The value to check
+ * @returns The value, or 0 if negative
+ */
+export declare function ensureNonNegative(value: number): number;
+/**
+ * Calculates the percentage discount
+ * @param originalPrice - The original price
+ * @param discountedPrice - The discounted price
+ * @returns The percentage discount (0-100)
+ */
+export declare function calculatePercentageDiscount(originalPrice: number, discountedPrice: number): number;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../lib/entities/Discount/utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,aAAa,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,GAAG,MAAM,CAIlG"}

package/dist/entities/Discount/utils.js

@@ -0,0 +1,39 @@
+/**
+ * Utility functions for discount calculations
+ */
+/**
+ * Formats a number to 2 decimal places and returns as a number
+ * @param value - The number to format
+ * @returns The formatted number with 2 decimal places
+ */
+export function formatCurrency(value) {
+    return Number(value.toFixed(2));
+}
+/**
+ * Formats a number to 2 decimal places and returns as a string
+ * @param value - The number to format
+ * @returns The formatted string with 2 decimal places
+ */
+export function formatCurrencyString(value) {
+    return value.toFixed(2);
+}
+/**
+ * Ensures a monetary value is never negative
+ * @param value - The value to check
+ * @returns The value, or 0 if negative
+ */
+export function ensureNonNegative(value) {
+    return Math.max(0, formatCurrency(value));
+}
+/**
+ * Calculates the percentage discount
+ * @param originalPrice - The original price
+ * @param discountedPrice - The discounted price
+ * @returns The percentage discount (0-100)
+ */
+export function calculatePercentageDiscount(originalPrice, discountedPrice) {
+    if (originalPrice <= 0)
+        return 0;
+    const discount = originalPrice - discountedPrice;
+    return formatCurrency((discount / originalPrice) * 100);
+}

package/dist/tsconfig.app.tsbuildinfo

@@ -1 +1 @@
-{"root":["../lib/index.tsx","../lib/entities/address.ts","../lib/entities/atoms.ts","../lib/entities/cart.ts","../lib/entities/category.ts","../lib/entities/company.ts","../lib/entities/discount.ts","../lib/entities/favoriteproduct.ts","../lib/entities/locale.ts","../lib/entities/order.ts","../lib/entities/product.ts","../lib/entities/profile.ts","../lib/entities/store.ts","../lib/entities/index.ts","../lib/firebase-api/app.ts","../lib/firebase-api/index.ts","../lib/utils/index.ts"],"version":"5.7.3"}
+{"root":["../lib/index.tsx","../lib/entities/address.ts","../lib/entities/atoms.ts","../lib/entities/cart.ts","../lib/entities/category.ts","../lib/entities/company.ts","../lib/entities/favoriteproduct.ts","../lib/entities/locale.ts","../lib/entities/order.ts","../lib/entities/product.ts","../lib/entities/profile.ts","../lib/entities/store.ts","../lib/entities/index.ts","../lib/entities/discount/engine.ts","../lib/entities/discount/factory.ts","../lib/entities/discount/index.ts","../lib/entities/discount/strategy.ts","../lib/entities/discount/types.ts","../lib/entities/discount/utils.ts","../lib/entities/discount/__tests__/engine.test.ts","../lib/entities/discount/__tests__/factory.test.ts","../lib/entities/discount/__tests__/integration.test.ts","../lib/entities/discount/__tests__/simple.test.ts","../lib/entities/discount/__tests__/utils.test.ts","../lib/entities/discount/strategies/bundlestrategy.ts","../lib/entities/discount/strategies/__tests__/bundlestrategy.test.ts","../lib/firebase-api/app.ts","../lib/firebase-api/index.ts","../lib/utils/index.ts"],"version":"5.7.3"}

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;AAiCjE,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmIA"}
+{"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"}

package/dist/utils/index.js

@@ -1,3 +1,4 @@
+import { DiscountEngine } from "../entities/Discount/engine";
 const CONFIG = {
     VAT: 18,
 };
@@ -21,75 +22,30 @@ function getPriceAfterDiscount(product) {
     }
     return product.price;
 }
-// mark product that used in discount
-// get final price for product and discount id
-// filter better discount
 // main
 export function getCartCost({ cart, discounts, store, }) {
     const { isVatIncludedInPrice } = store;
-    let result = cart.map((item) => {
+    // Convert cart items to the format expected by the discount engine
+    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];
         return {
             amount: item.amount,
             product: { ...item.product },
             originalPrice: item.product.price,
-            finalPrice: getPriceAfterDiscount(item.product),
-            finalDiscount: calculateDiscount(item.product),
+            finalPrice: engineItem ? engineItem.finalPrice : getPriceAfterDiscount(item.product),
+            finalDiscount: engineItem ? engineItem.finalDiscount : calculateDiscount(item.product),
         };
     });
-    const activeDiscounts = discounts.filter((discount) => {
-        if (discount.variant.variantType === "bundle") {
-            const productsTotal = cart?.reduce((total, item) => {
-                if (discount.variant.productsId.includes(item.product.id)) {
-                    total += item.amount;
-                    return total;
-                }
-                return total;
-            }, 0) ?? 0;
-            if (productsTotal >= discount.variant.requiredQuantity) {
-                // const times = Math.floor(productsTotal / discount.variant.requiredQuantity);
-                // console.log("yes", times, discount.variant.discountPrice);
-                return true;
-            }
-        }
-        return false;
-    });
-    console.log("activeDiscounts", activeDiscounts);
-    activeDiscounts.forEach((discount) => {
-        if (discount.variant.variantType === "bundle") {
-            // get all products in cart
-            const products = cart.filter((item) => discount.variant.productsId.includes(item.product.id));
-            const productsTotal = products?.reduce((total, item) => {
-                if (discount.variant.productsId.includes(item.product.id)) {
-                    total += item.amount;
-                    return total;
-                }
-                return total;
-            }, 0) ?? 0;
-            const times = Math.floor(productsTotal / discount.variant.requiredQuantity);
-            const price = getPriceAfterDiscount(products[0]?.product);
-            const _discount = calculateDiscount(products[0]?.product);
-            console.log("price", price, _discount);
-            const discountPrice = Number((discount.variant.discountPrice / discount.variant.requiredQuantity).toFixed(2)) * 1;
-            console.log("discountPrice", discountPrice);
-            const totalDiscount = (price * discount.variant.requiredQuantity - discount.variant.discountPrice) * times;
-            const originalPrice = productsTotal * price;
-            const discountPriceFinal = originalPrice - totalDiscount;
-            const averagePrice = Number((discountPriceFinal / productsTotal).toFixed(2));
-            result = result.map((item) => {
-                if (discount.variant.productsId.includes(item.product.id)) {
-                    return {
-                        ...item,
-                        finalPrice: averagePrice,
-                        originalPrice: item.product.price,
-                        discountPrice: price,
-                        finalDiscount: item.finalDiscount + (item.product.price - averagePrice),
-                    };
-                }
-                return item;
-            });
-            // find average price
-        }
-    });
     const cartDetails = result.reduce((acc, item) => {
         const { product, amount, finalPrice, finalDiscount } = item;
         let productVatValue = 0;