@jsdev_ninja/core 0.13.27 → 0.13.29

package/dist/lib/entities/Discount/__tests__/simple.test.js

@@ -0,0 +1,186 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { DiscountEngine } from "../engine";
+import { DiscountStrategyFactory } from "../factory";
+import { BundleDiscountStrategy } from "../strategies/BundleStrategy";
+describe("Simple Discount System Tests", () => {
+    beforeEach(() => {
+        DiscountStrategyFactory.clearStrategies();
+        DiscountStrategyFactory.registerStrategy("bundle", new BundleDiscountStrategy());
+    });
+    it("should calculate basic bundle discount correctly", () => {
+        const cart = [
+            {
+                amount: 2,
+                product: {
+                    id: "product1",
+                    price: 10,
+                },
+            },
+            {
+                amount: 1,
+                product: {
+                    id: "product2",
+                    price: 15,
+                },
+            },
+        ];
+        const discounts = [
+            {
+                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 = DiscountEngine.calculateDiscounts(cart, discounts);
+        expect(result.totalDiscount).toBe(10);
+        expect(result.appliedDiscounts).toHaveLength(1);
+    });
+    it("should not apply inactive discount", () => {
+        const cart = [
+            {
+                amount: 3,
+                product: {
+                    id: "product1",
+                    price: 10,
+                },
+            },
+        ];
+        const discounts = [
+            {
+                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"],
+                    requiredQuantity: 3,
+                    bundlePrice: 25,
+                },
+                conditions: {
+                    stackable: false,
+                },
+            },
+        ];
+        const result = DiscountEngine.calculateDiscounts(cart, discounts);
+        expect(result.totalDiscount).toBe(0);
+        expect(result.appliedDiscounts).toHaveLength(0);
+    });
+    it("should not apply discount when not enough items", () => {
+        const cart = [
+            {
+                amount: 2, // Only 2 items, need 3
+                product: {
+                    id: "product1",
+                    price: 10,
+                },
+            },
+        ];
+        const discounts = [
+            {
+                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 = DiscountEngine.calculateDiscounts(cart, discounts);
+        expect(result.totalDiscount).toBe(0);
+        expect(result.appliedDiscounts).toHaveLength(0);
+    });
+    it("should handle Buy 2 Get 1 Free scenario", () => {
+        const cart = [
+            {
+                amount: 3, // Buy 3 items
+                product: {
+                    id: "product1",
+                    price: 10, // $10 each
+                },
+            },
+        ];
+        const bogoDiscount = {
+            type: "Discount",
+            storeId: "store1",
+            companyId: "company1",
+            id: "bogo",
+            name: [{ lang: "he", value: "Buy 2 Get 1 Free" }],
+            active: true,
+            startDate: Date.now() - 1000,
+            endDate: Date.now() + 1000,
+            variant: {
+                variantType: "bundle",
+                productsId: ["product1"],
+                requiredQuantity: 3, // Buy 2 + get 1 free = 3 items
+                bundlePrice: 20, // Price of 2 items (10 × 2)
+            },
+            conditions: {
+                stackable: false,
+            },
+        };
+        const result = DiscountEngine.calculateDiscounts(cart, [bogoDiscount]);
+        // Original: 3 × $10 = $30
+        // Bundle: 3 items for $20
+        // Discount: $10
+        expect(result.totalDiscount).toBe(10);
+        expect(result.appliedDiscounts).toHaveLength(1);
+    });
+    it("should handle empty cart", () => {
+        const cart = [];
+        const discounts = [
+            {
+                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 = DiscountEngine.calculateDiscounts(cart, discounts);
+        expect(result.totalDiscount).toBe(0);
+        expect(result.appliedDiscounts).toHaveLength(0);
+        expect(result.items).toHaveLength(0);
+    });
+});

package/dist/lib/entities/Discount/__tests__/utils.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=utils.test.d.ts.map

package/dist/lib/entities/Discount/__tests__/utils.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.test.d.ts","sourceRoot":"","sources":["../../../../../lib/entities/Discount/__tests__/utils.test.ts"],"names":[],"mappings":""}

package/dist/lib/entities/Discount/__tests__/utils.test.js

@@ -0,0 +1,55 @@
+import { describe, it, expect } from "vitest";
+import { formatCurrency, formatCurrencyString, ensureNonNegative, calculatePercentageDiscount } from "../utils";
+describe("Discount Utils", () => {
+    describe("formatCurrency", () => {
+        it("should format numbers to 2 decimal places", () => {
+            expect(formatCurrency(10)).toBe(10.00);
+            expect(formatCurrency(10.123)).toBe(10.12);
+            expect(formatCurrency(10.125)).toBe(10.13); // Rounds up
+            expect(formatCurrency(10.124)).toBe(10.12); // Rounds down
+            expect(formatCurrency(0)).toBe(0.00);
+        });
+        it("should return a number type", () => {
+            const result = formatCurrency(10.123);
+            expect(typeof result).toBe("number");
+        });
+    });
+    describe("formatCurrencyString", () => {
+        it("should format numbers to 2 decimal places as string", () => {
+            expect(formatCurrencyString(10)).toBe("10.00");
+            expect(formatCurrencyString(10.123)).toBe("10.12");
+            expect(formatCurrencyString(10.125)).toBe("10.13");
+            expect(formatCurrencyString(0)).toBe("0.00");
+        });
+        it("should return a string type", () => {
+            const result = formatCurrencyString(10.123);
+            expect(typeof result).toBe("string");
+        });
+    });
+    describe("ensureNonNegative", () => {
+        it("should return 0 for negative values", () => {
+            expect(ensureNonNegative(-5)).toBe(0.00);
+            expect(ensureNonNegative(-0.01)).toBe(0.00);
+        });
+        it("should return formatted value for positive values", () => {
+            expect(ensureNonNegative(10.123)).toBe(10.12);
+            expect(ensureNonNegative(0)).toBe(0.00);
+        });
+    });
+    describe("calculatePercentageDiscount", () => {
+        it("should calculate percentage discount correctly", () => {
+            expect(calculatePercentageDiscount(100, 80)).toBe(20.00); // 20% discount
+            expect(calculatePercentageDiscount(50, 25)).toBe(50.00); // 50% discount
+            expect(calculatePercentageDiscount(100, 100)).toBe(0.00); // No discount
+        });
+        it("should handle edge cases", () => {
+            expect(calculatePercentageDiscount(0, 0)).toBe(0.00);
+            expect(calculatePercentageDiscount(100, 0)).toBe(100.00); // 100% discount
+        });
+        it("should return formatted number", () => {
+            const result = calculatePercentageDiscount(100, 90.5);
+            expect(typeof result).toBe("number");
+            expect(result).toBe(9.50); // 9.5% discount
+        });
+    });
+});

package/dist/lib/entities/Discount/engine.d.ts

@@ -0,0 +1,29 @@
+import { TDiscount, AppliedDiscount } from "./types";
+export declare class DiscountEngine {
+    static calculateDiscounts(cart: Array<{
+        amount: number;
+        product: {
+            id: string;
+            price: number;
+        };
+    }>, discounts: TDiscount[], user?: Record<string, unknown>): {
+        items: Array<{
+            amount: number;
+            product: {
+                id: string;
+                price: number;
+            };
+            originalPrice: number;
+            finalPrice: number;
+            finalDiscount: number;
+            appliedDiscounts: string[];
+        }>;
+        totalDiscount: number;
+        appliedDiscounts: AppliedDiscount[];
+    };
+    private static filterActiveDiscounts;
+    private static calculateFinalPrices;
+    static isDiscountActive(discount: TDiscount): boolean;
+    static getActiveDiscounts(discounts: TDiscount[]): TDiscount[];
+}
+//# sourceMappingURL=engine.d.ts.map

package/dist/lib/entities/Discount/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../../../lib/entities/Discount/engine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,eAAe,EAAmB,MAAM,SAAS,CAAC;AAYtE,qBAAa,cAAc;IAC1B,MAAM,CAAC,kBAAkB,CACxB,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,EACF,SAAS,EAAE,SAAS,EAAE,EACtB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B;QACF,KAAK,EAAE,KAAK,CAAC;YACZ,MAAM,EAAE,MAAM,CAAC;YACf,OAAO,EAAE;gBACR,EAAE,EAAE,MAAM,CAAC;gBACX,KAAK,EAAE,MAAM,CAAC;aACd,CAAC;YACF,aAAa,EAAE,MAAM,CAAC;YACtB,UAAU,EAAE,MAAM,CAAC;YACnB,aAAa,EAAE,MAAM,CAAC;YACtB,gBAAgB,EAAE,MAAM,EAAE,CAAC;SAC3B,CAAC,CAAC;QACH,aAAa,EAAE,MAAM,CAAC;QACtB,gBAAgB,EAAE,eAAe,EAAE,CAAC;KACpC;IAuDD,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAOpC,OAAO,CAAC,MAAM,CAAC,oBAAoB;IA8BnC,MAAM,CAAC,gBAAgB,CAAC,QAAQ,EAAE,SAAS,GAAG,OAAO;IAKrD,MAAM,CAAC,kBAAkB,CAAC,SAAS,EAAE,SAAS,EAAE,GAAG,SAAS,EAAE;CAG9D"}

package/dist/lib/entities/Discount/engine.js

@@ -0,0 +1,85 @@
+import { DiscountStrategyFactory } from "./factory";
+// discount engine - calculate discounts and return final prices
+// should register all discount types
+// should receive all store discounts
+// should check active discount that should be applied on cart
+// should find best discount per product
+// should apply discount to if stackable or best one
+// any applyd discount should mark products that effected and price before and after and average price per product in cart
+// should return items list with all calculations and final prices and discounts
+export class DiscountEngine {
+    static calculateDiscounts(cart, discounts, user) {
+        const context = {
+            cart,
+            user,
+            appliedDiscounts: [],
+        };
+        // Filter active discounts
+        const activeDiscounts = this.filterActiveDiscounts(discounts);
+        // Apply discounts
+        const appliedDiscounts = [];
+        for (const discount of activeDiscounts) {
+            const strategy = DiscountStrategyFactory.getStrategy(discount);
+            if (!strategy)
+                continue;
+            // Check if discount can be applied
+            if (!strategy.canApply(discount, context))
+                continue;
+            // Check if discount is stackable
+            // todo
+            if (!discount.conditions?.stackable && appliedDiscounts.length > 0)
+                continue;
+            // Calculate discount
+            const result = strategy.calculate(discount, context);
+            if (!result.applicable)
+                continue;
+            // Apply discount
+            appliedDiscounts.push({
+                discountId: discount.id,
+                discountName: discount.name[0]?.value || "Discount",
+                discountAmount: Number(result.discountAmount.toFixed(2)),
+                affectedItems: result.affectedItems,
+            });
+            // Update context for next iteration
+            context.appliedDiscounts = appliedDiscounts;
+        }
+        // Calculate final prices
+        const items = this.calculateFinalPrices(cart, appliedDiscounts);
+        const totalDiscount = appliedDiscounts.reduce((sum, discount) => sum + discount.discountAmount, 0);
+        return {
+            items,
+            totalDiscount: Number(totalDiscount.toFixed(2)),
+            appliedDiscounts,
+        };
+    }
+    static filterActiveDiscounts(discounts) {
+        const now = Date.now();
+        return discounts.filter((discount) => discount.active && discount.startDate <= now && discount.endDate >= now);
+    }
+    static calculateFinalPrices(cart, appliedDiscounts) {
+        return cart.map((item) => {
+            const itemDiscounts = appliedDiscounts.filter((discount) => discount.affectedItems.some((affected) => affected.productId === item.product.id));
+            const totalItemDiscount = itemDiscounts.reduce((sum, discount) => {
+                const affectedItem = discount.affectedItems.find((affected) => affected.productId === item.product.id);
+                return sum + (affectedItem?.discountAmount || 0);
+            }, 0);
+            const discountPerUnit = totalItemDiscount / item.amount;
+            const finalPrice = item.product.price - discountPerUnit;
+            return {
+                amount: item.amount,
+                product: item.product,
+                originalPrice: Number(item.product.price.toFixed(2)),
+                finalPrice: Number(Math.max(0, finalPrice).toFixed(2)),
+                finalDiscount: Number(totalItemDiscount.toFixed(2)),
+                appliedDiscounts: itemDiscounts.map((d) => d.discountId),
+            };
+        });
+    }
+    static isDiscountActive(discount) {
+        const now = Date.now();
+        return discount.active && discount.startDate <= now && discount.endDate >= now;
+    }
+    static getActiveDiscounts(discounts) {
+        return this.filterActiveDiscounts(discounts);
+    }
+}

package/dist/lib/entities/Discount/factory.d.ts

@@ -0,0 +1,10 @@
+import { TDiscount } from "./types";
+import { DiscountStrategy } from "./strategy";
+export declare class DiscountStrategyFactory {
+    private static strategies;
+    static getStrategy(discount: TDiscount): DiscountStrategy | null;
+    static registerStrategy(type: string, strategy: DiscountStrategy): void;
+    static getRegisteredTypes(): string[];
+    static clearStrategies(): void;
+}
+//# sourceMappingURL=factory.d.ts.map

package/dist/lib/entities/Discount/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../../lib/entities/Discount/factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAG9C,qBAAa,uBAAuB;IAClC,OAAO,CAAC,MAAM,CAAC,UAAU,CAEtB;IAEH,MAAM,CAAC,WAAW,CAAC,QAAQ,EAAE,SAAS,GAAG,gBAAgB,GAAG,IAAI;IAIhE,MAAM,CAAC,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,gBAAgB,GAAG,IAAI;IAIvE,MAAM,CAAC,kBAAkB,IAAI,MAAM,EAAE;IAIrC,MAAM,CAAC,eAAe,IAAI,IAAI;CAG/B"}

package/dist/lib/entities/Discount/factory.js

@@ -0,0 +1,18 @@
+import { BundleDiscountStrategy } from "./strategies/BundleStrategy";
+export class DiscountStrategyFactory {
+    static getStrategy(discount) {
+        return this.strategies.get(discount.variant.variantType) || null;
+    }
+    static registerStrategy(type, strategy) {
+        this.strategies.set(type, strategy);
+    }
+    static getRegisteredTypes() {
+        return Array.from(this.strategies.keys());
+    }
+    static clearStrategies() {
+        this.strategies.clear();
+    }
+}
+DiscountStrategyFactory.strategies = new Map([
+    ["bundle", new BundleDiscountStrategy()],
+]);

package/dist/lib/entities/Discount/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./types";
+export * from "./strategy";
+export * from "./factory";
+export * from "./engine";
+export * from "./strategies/BundleStrategy";
+export * from "./utils";
+export { DiscountSchema } from "./types";
+export type { TDiscount } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/entities/Discount/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../lib/entities/Discount/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,6BAA6B,CAAC;AAC5C,cAAc,SAAS,CAAC;AAGxB,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AACzC,YAAY,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC"}

package/{lib/entities/Discount/index.ts → dist/lib/entities/Discount/index.js}

@@ -4,7 +4,5 @@ export * from "./factory";
 export * from "./engine";
 export * from "./strategies/BundleStrategy";
 export * from "./utils";
-
 // Re-export the main discount schema for backward compatibility
 export { DiscountSchema } from "./types";
-export type { TDiscount } from "./types";

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

@@ -0,0 +1,12 @@
+import { DiscountStrategy } from "../strategy";
+import { TDiscount, DiscountResult, DiscountContext } from "../types";
+export declare class BundleDiscountStrategy implements DiscountStrategy {
+    canApply(discount: TDiscount, context: DiscountContext): boolean;
+    calculate(discount: TDiscount, context: DiscountContext): DiscountResult;
+    private isDiscountActive;
+    private getTotalQuantity;
+    private calculateOriginalPrice;
+    private calculateDiscountedPrice;
+    private distributeDiscount;
+}
+//# sourceMappingURL=BundleStrategy.d.ts.map

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

@@ -0,0 +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;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/lib/entities/Discount/strategies/BundleStrategy.js

@@ -0,0 +1,78 @@
+export class BundleDiscountStrategy {
+    canApply(discount, context) {
+        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, context) {
+        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,
+        };
+    }
+    isDiscountActive(discount) {
+        const now = Date.now();
+        return discount.active && discount.startDate <= now && discount.endDate >= now;
+    }
+    getTotalQuantity(cart, productIds) {
+        return cart
+            .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);
+    }
+    calculateDiscountedPrice(originalPrice, bundlePrice, bundleCount, requiredQuantity, totalQuantity) {
+        // 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;
+    }
+    distributeDiscount(items, totalDiscount, originalPrice) {
+        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/dist/lib/entities/Discount/strategies/__tests__/BundleStrategy.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=BundleStrategy.test.d.ts.map

package/dist/lib/entities/Discount/strategies/__tests__/BundleStrategy.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BundleStrategy.test.d.ts","sourceRoot":"","sources":["../../../../../../lib/entities/Discount/strategies/__tests__/BundleStrategy.test.ts"],"names":[],"mappings":""}