@unchainedshop/plugins 4.7.2 → 4.8.0

package/lib/pricing/free-payment.js

@@ -0,0 +1,27 @@
+import { PaymentPricingAdapter, PaymentPricingDirector, } from '@unchainedshop/core';
+export const PaymentFreePrice = {
+    ...PaymentPricingAdapter,
+    key: 'shop.unchained.pricing.payment-free',
+    label: 'Free Payment',
+    version: '1.0.0',
+    orderIndex: 0,
+    isActivatedFor: () => {
+        return true;
+    },
+    actions: (params) => {
+        const pricingAdapter = PaymentPricingAdapter.actions(params);
+        return {
+            ...pricingAdapter,
+            calculate: async () => {
+                pricingAdapter.resultSheet().addFee({
+                    amount: 0,
+                    isNetPrice: false,
+                    isTaxable: false,
+                    meta: { adapter: PaymentFreePrice.key },
+                });
+                return pricingAdapter.calculate();
+            },
+        };
+    },
+};
+PaymentPricingDirector.registerAdapter(PaymentFreePrice);

package/lib/pricing/order-delivery.d.ts

@@ -0,0 +1,2 @@
+import { type IOrderPricingAdapter } from '@unchainedshop/core';
+export declare const OrderDelivery: IOrderPricingAdapter;

package/lib/pricing/order-delivery.js

@@ -0,0 +1,33 @@
+import { OrderPricingDirector, OrderPricingAdapter, DeliveryPricingSheet, } from '@unchainedshop/core';
+export const OrderDelivery = {
+    ...OrderPricingAdapter,
+    key: 'shop.unchained.pricing.order-delivery',
+    version: '1.0.0',
+    label: 'Add Delivery Fees to Order',
+    orderIndex: 10,
+    isActivatedFor: () => {
+        return true;
+    },
+    actions: (params) => {
+        const pricingAdapter = OrderPricingAdapter.actions(params);
+        const { order, orderDelivery } = params.context;
+        return {
+            ...pricingAdapter,
+            calculate: async () => {
+                if (!orderDelivery)
+                    return null;
+                const pricing = DeliveryPricingSheet({
+                    calculation: orderDelivery.calculation,
+                    currencyCode: order.currencyCode,
+                });
+                const tax = pricing.taxSum();
+                const shipping = pricing.gross();
+                pricingAdapter
+                    .resultSheet()
+                    .addDelivery({ amount: shipping, taxAmount: tax, meta: { adapter: OrderDelivery.key } });
+                return pricingAdapter.calculate();
+            },
+        };
+    },
+};
+OrderPricingDirector.registerAdapter(OrderDelivery);

package/lib/pricing/order-discount.d.ts

@@ -0,0 +1,2 @@
+import { type IOrderPricingAdapter, type OrderDiscountConfiguration } from '@unchainedshop/core';
+export declare const OrderDiscount: IOrderPricingAdapter<OrderDiscountConfiguration>;

package/lib/pricing/order-discount.js

@@ -0,0 +1,74 @@
+import { OrderPricingRowCategory, OrderPricingDirector, OrderPricingAdapter, DeliveryPricingSheet, PaymentPricingSheet, ProductPricingSheet, resolveRatioAndTaxDivisorForPricingSheet, } from '@unchainedshop/core';
+import { calculation as calcUtils } from '@unchainedshop/utils';
+export const OrderDiscount = {
+    ...OrderPricingAdapter,
+    key: 'shop.unchained.pricing.order-discount',
+    version: '1.0.0',
+    label: 'Apply Discounts on Total Order Value',
+    orderIndex: 40,
+    isActivatedFor: () => {
+        return true;
+    },
+    actions: (params) => {
+        const pricingAdapter = OrderPricingAdapter.actions(params);
+        const { order, orderDelivery, orderPositions, orderPayment } = params.context;
+        return {
+            ...pricingAdapter,
+            calculate: async () => {
+                if (!order)
+                    return pricingAdapter.calculate();
+                const totalAmountOfItems = params.calculationSheet.total({
+                    category: OrderPricingRowCategory.Items,
+                    useNetPrice: false,
+                }).amount;
+                const totalAmountOfPaymentAndDelivery = params.calculationSheet.total({
+                    category: OrderPricingRowCategory.Payment,
+                    useNetPrice: false,
+                }).amount +
+                    params.calculationSheet.total({
+                        category: OrderPricingRowCategory.Delivery,
+                        useNetPrice: false,
+                    }).amount;
+                const itemShares = orderPositions.map((orderPosition) => resolveRatioAndTaxDivisorForPricingSheet(ProductPricingSheet({
+                    calculation: orderPosition.calculation,
+                    currencyCode: order.currencyCode,
+                    quantity: orderPosition.quantity,
+                }), totalAmountOfItems));
+                const deliveryShare = resolveRatioAndTaxDivisorForPricingSheet(DeliveryPricingSheet({
+                    calculation: orderDelivery?.calculation || [],
+                    currencyCode: order.currencyCode,
+                }), totalAmountOfPaymentAndDelivery);
+                const paymentShare = resolveRatioAndTaxDivisorForPricingSheet(PaymentPricingSheet({
+                    calculation: orderPayment?.calculation || [],
+                    currencyCode: order.currencyCode,
+                }), totalAmountOfPaymentAndDelivery);
+                let amountLeft = totalAmountOfPaymentAndDelivery + totalAmountOfItems;
+                params.discounts.forEach(({ configuration, discountId }) => {
+                    const leftInDiscountToSplit = calcUtils.calculateAmountToSplit({ ...configuration }, Math.min(totalAmountOfItems, amountLeft));
+                    const [itemsDiscountAmount, itemsTaxAmount] = calcUtils.applyDiscountToMultipleShares(itemShares, Math.max(0, Math.min(amountLeft, leftInDiscountToSplit)));
+                    amountLeft -= itemsDiscountAmount;
+                    const fixedRate = Number(configuration.fixedRate) > 0
+                        ? Math.max(0, configuration.fixedRate - itemsDiscountAmount)
+                        : undefined;
+                    const leftInFeesToSplit = calcUtils.calculateAmountToSplit({ ...configuration, fixedRate }, Math.min(totalAmountOfPaymentAndDelivery, amountLeft));
+                    const [deliveryAndPaymentDiscountAmount, deliveryAndPaymentTaxAmount] = calcUtils.applyDiscountToMultipleShares([deliveryShare, paymentShare], Math.max(0, Math.min(amountLeft, leftInFeesToSplit)));
+                    amountLeft -= deliveryAndPaymentDiscountAmount;
+                    const discountAmount = (itemsDiscountAmount + deliveryAndPaymentDiscountAmount) * -1;
+                    const taxAmount = (itemsTaxAmount + deliveryAndPaymentTaxAmount) * -1;
+                    if (discountAmount) {
+                        pricingAdapter.resultSheet().addDiscount({
+                            amount: discountAmount,
+                            taxAmount,
+                            discountId,
+                            meta: {
+                                adapter: OrderDiscount.key,
+                            },
+                        });
+                    }
+                });
+                return pricingAdapter.calculate();
+            },
+        };
+    },
+};
+OrderPricingDirector.registerAdapter(OrderDiscount);

package/lib/pricing/order-items-discount.d.ts

@@ -0,0 +1,2 @@
+import { type OrderDiscountConfiguration, type IOrderPricingAdapter } from '@unchainedshop/core';
+export declare const OrderItemsDiscount: IOrderPricingAdapter<OrderDiscountConfiguration>;

package/lib/pricing/order-items-discount.js

@@ -0,0 +1,50 @@
+import { ProductPricingSheet, OrderPricingDirector, OrderPricingAdapter, OrderPricingRowCategory, resolveRatioAndTaxDivisorForPricingSheet, } from '@unchainedshop/core';
+import { calculation as calcUtils } from '@unchainedshop/utils';
+export const OrderItemsDiscount = {
+    ...OrderPricingAdapter,
+    key: 'shop.unchained.pricing.order-items-discount',
+    version: '1.0.0',
+    label: 'Apply Discounts on Total Value Of Goods',
+    orderIndex: 30,
+    isActivatedFor: () => {
+        return true;
+    },
+    actions: (params) => {
+        const pricingAdapter = OrderPricingAdapter.actions(params);
+        const { order, orderPositions } = params.context;
+        return {
+            ...pricingAdapter,
+            calculate: async () => {
+                const totalAmountOfItems = params.calculationSheet.total({
+                    category: OrderPricingRowCategory.Items,
+                    useNetPrice: false,
+                }).amount;
+                const itemShares = orderPositions.map((orderPosition) => resolveRatioAndTaxDivisorForPricingSheet(ProductPricingSheet({
+                    calculation: orderPosition.calculation,
+                    currencyCode: order.currencyCode,
+                    quantity: orderPosition.quantity,
+                }), totalAmountOfItems));
+                let amountLeft = totalAmountOfItems;
+                params.discounts.forEach(({ configuration, discountId }) => {
+                    const leftInItemsToSplit = calcUtils.calculateAmountToSplit({ ...configuration }, totalAmountOfItems);
+                    const [itemsDiscountAmount, itemsTaxAmount] = calcUtils.applyDiscountToMultipleShares(itemShares, Math.max(0, Math.min(amountLeft, leftInItemsToSplit)));
+                    amountLeft -= itemsDiscountAmount;
+                    const discountAmount = itemsDiscountAmount * -1;
+                    const taxAmount = itemsTaxAmount * -1;
+                    if (discountAmount) {
+                        pricingAdapter.resultSheet().addDiscount({
+                            amount: discountAmount,
+                            taxAmount,
+                            discountId,
+                            meta: {
+                                adapter: OrderItemsDiscount.key,
+                            },
+                        });
+                    }
+                });
+                return pricingAdapter.calculate();
+            },
+        };
+    },
+};
+OrderPricingDirector.registerAdapter(OrderItemsDiscount);

package/lib/pricing/order-items.d.ts

@@ -0,0 +1,2 @@
+import { type IOrderPricingAdapter } from '@unchainedshop/core';
+export declare const OrderItems: IOrderPricingAdapter;

package/lib/pricing/order-items.js

@@ -0,0 +1,43 @@
+import { OrderPricingDirector, OrderPricingAdapter, ProductPricingSheet, } from '@unchainedshop/core';
+export const OrderItems = {
+    ...OrderPricingAdapter,
+    key: 'shop.unchained.pricing.order-items',
+    version: '1.0.0',
+    label: 'Add Total Value Of Goods to Order',
+    orderIndex: 0,
+    isActivatedFor: () => {
+        return true;
+    },
+    actions: (params) => {
+        const pricingAdapter = OrderPricingAdapter.actions(params);
+        const { order, orderPositions } = params.context;
+        return {
+            ...pricingAdapter,
+            calculate: async () => {
+                const totalAndTaxesOfAllItems = orderPositions.reduce((current, orderPosition) => {
+                    const pricing = ProductPricingSheet({
+                        calculation: orderPosition.calculation,
+                        currencyCode: order.currencyCode,
+                        quantity: orderPosition.quantity,
+                    });
+                    const tax = pricing.taxSum();
+                    const items = pricing.gross();
+                    return {
+                        taxes: current.taxes + tax,
+                        items: current.items + items,
+                    };
+                }, {
+                    taxes: 0,
+                    items: 0,
+                });
+                pricingAdapter.resultSheet().addItems({
+                    amount: totalAndTaxesOfAllItems.items,
+                    taxAmount: totalAndTaxesOfAllItems.taxes,
+                    meta: { adapter: OrderItems.key },
+                });
+                return pricingAdapter.calculate();
+            },
+        };
+    },
+};
+OrderPricingDirector.registerAdapter(OrderItems);

package/lib/pricing/order-payment.d.ts

@@ -0,0 +1,2 @@
+import { type IOrderPricingAdapter } from '@unchainedshop/core';
+export declare const OrderPayment: IOrderPricingAdapter;

package/lib/pricing/order-payment.js

@@ -0,0 +1,33 @@
+import { OrderPricingDirector, OrderPricingAdapter, PaymentPricingSheet, } from '@unchainedshop/core';
+export const OrderPayment = {
+    ...OrderPricingAdapter,
+    key: 'shop.unchained.pricing.order-payment',
+    version: '1.0.0',
+    label: 'Add Payment Fees to Order',
+    orderIndex: 10,
+    isActivatedFor: () => {
+        return true;
+    },
+    actions: (params) => {
+        const pricingAdapter = OrderPricingAdapter.actions(params);
+        const { order, orderPayment } = params.context;
+        return {
+            ...pricingAdapter,
+            calculate: async () => {
+                if (!orderPayment)
+                    return null;
+                const pricing = PaymentPricingSheet({
+                    calculation: orderPayment.calculation,
+                    currencyCode: order.currencyCode,
+                });
+                const tax = pricing.taxSum();
+                const paymentFees = pricing.gross();
+                pricingAdapter
+                    .resultSheet()
+                    .addPayment({ amount: paymentFees, taxAmount: tax, meta: { adapter: OrderPayment.key } });
+                return pricingAdapter.calculate();
+            },
+        };
+    },
+};
+OrderPricingDirector.registerAdapter(OrderPayment);

package/lib/pricing/order-round.d.ts

@@ -0,0 +1,10 @@
+import { type IOrderPricingAdapter } from '@unchainedshop/core';
+interface PriceRoundSettings {
+    defaultPrecision: number;
+    roundTo: (value: number, precision: number, currencyCode: string) => number;
+}
+export declare const OrderPriceRound: IOrderPricingAdapter & {
+    configure: (params: PriceRoundSettings) => void;
+    settings: PriceRoundSettings;
+};
+export {};

package/lib/pricing/order-round.js

@@ -0,0 +1,135 @@
+import { OrderPricingAdapter, OrderPricingDirector, OrderPricingRowCategory, } from '@unchainedshop/core';
+const calculateDifference = (amount, currencyCode) => {
+    const roundedAmount = OrderPriceRound.settings.roundTo(amount, OrderPriceRound.settings.defaultPrecision, currencyCode);
+    return roundedAmount - amount;
+};
+export const OrderPriceRound = {
+    ...OrderPricingAdapter,
+    key: 'shop.unchained.pricing.order-round',
+    version: '1.0.0',
+    label: 'Round order price to the next precision number',
+    orderIndex: 90,
+    isActivatedFor: () => {
+        return true;
+    },
+    settings: {
+        defaultPrecision: 5,
+        roundTo: (value, precision) => precision !== 0 ? Math.round(value / precision) * precision : value,
+    },
+    configure({ defaultPrecision, roundTo }) {
+        if (defaultPrecision)
+            this.settings.defaultPrecision = defaultPrecision;
+        if (roundTo)
+            this.settings.roundTo = roundTo;
+    },
+    actions: (params) => {
+        const pricingAdapter = OrderPricingAdapter.actions(params);
+        return {
+            ...pricingAdapter,
+            calculate: async () => {
+                const { currencyCode } = params.context;
+                if (!currencyCode)
+                    return pricingAdapter.calculate();
+                const { amount: deliveryAmount } = params.calculationSheet.total({
+                    category: OrderPricingRowCategory.Delivery,
+                    useNetPrice: true,
+                });
+                if (deliveryAmount) {
+                    const taxes = params.calculationSheet.taxSum({
+                        baseCategory: OrderPricingRowCategory.Delivery,
+                    });
+                    const deliveryTaxRate = taxes / deliveryAmount;
+                    const deliveryDifference = calculateDifference(deliveryAmount, currencyCode);
+                    pricingAdapter.resultSheet().addDelivery({
+                        amount: deliveryDifference,
+                        taxAmount: deliveryTaxRate * deliveryDifference,
+                        meta: {
+                            adapter: OrderPriceRound.key,
+                        },
+                    });
+                }
+                const { amount: discountAmount } = params.calculationSheet.total({
+                    category: OrderPricingRowCategory.Discounts,
+                    useNetPrice: true,
+                });
+                if (discountAmount) {
+                    const taxes = params.calculationSheet.taxSum({
+                        baseCategory: OrderPricingRowCategory.Discounts,
+                    });
+                    const discountTaxRate = taxes / discountAmount;
+                    const discountsDifference = calculateDifference(discountAmount, currencyCode);
+                    pricingAdapter.resultSheet().addDiscount({
+                        amount: discountsDifference,
+                        taxAmount: discountsDifference * discountTaxRate,
+                        meta: {
+                            adapter: OrderPriceRound.key,
+                        },
+                        discountId: null,
+                    });
+                }
+                const { amount: itemsAmount } = params.calculationSheet.total({
+                    category: OrderPricingRowCategory.Items,
+                    useNetPrice: true,
+                });
+                if (itemsAmount) {
+                    const taxes = params.calculationSheet.taxSum({
+                        baseCategory: OrderPricingRowCategory.Items,
+                    });
+                    const itemTaxRate = taxes / itemsAmount;
+                    const itemsDifference = calculateDifference(itemsAmount, currencyCode);
+                    pricingAdapter.resultSheet().addItems({
+                        amount: itemsDifference,
+                        taxAmount: itemsDifference * itemTaxRate,
+                        meta: {
+                            adapter: OrderPriceRound.key,
+                        },
+                    });
+                }
+                const { amount: paymentAmount } = params.calculationSheet.total({
+                    category: OrderPricingRowCategory.Payment,
+                    useNetPrice: true,
+                });
+                if (paymentAmount) {
+                    const taxes = params.calculationSheet.taxSum({
+                        baseCategory: OrderPricingRowCategory.Payment,
+                    });
+                    const paymentTaxRate = taxes / paymentAmount;
+                    const paymentsDifference = calculateDifference(paymentAmount, currencyCode);
+                    pricingAdapter.resultSheet().addPayment({
+                        amount: paymentsDifference,
+                        taxAmount: paymentsDifference * paymentTaxRate,
+                        meta: {
+                            adapter: OrderPriceRound.key,
+                        },
+                    });
+                }
+                const priorTaxesAmount = params.calculationSheet.taxSum({
+                    category: OrderPricingRowCategory.Taxes,
+                });
+                const additionalRoundedTaxes = pricingAdapter.resultSheet().taxSum({
+                    category: OrderPricingRowCategory.Taxes,
+                });
+                const taxesAmount = priorTaxesAmount + additionalRoundedTaxes;
+                if (taxesAmount) {
+                    const taxDifference = calculateDifference(taxesAmount, currencyCode);
+                    pricingAdapter.resultSheet().calculation.push({
+                        category: OrderPricingRowCategory.Taxes,
+                        amount: taxDifference,
+                        meta: {
+                            adapter: OrderPriceRound.key,
+                        },
+                    });
+                    pricingAdapter.resultSheet().calculation.push({
+                        category: null,
+                        amount: taxDifference,
+                        meta: {
+                            adapter: OrderPriceRound.key,
+                        },
+                    });
+                }
+                return pricingAdapter.calculate();
+            },
+        };
+    },
+};
+OrderPricingDirector.registerAdapter(OrderPriceRound);

package/lib/pricing/product-catalog-price-options.d.ts

@@ -0,0 +1,2 @@
+import { type IProductPricingAdapter } from '@unchainedshop/core';
+export declare const ProductPriceOptions: IProductPricingAdapter;

package/lib/pricing/product-catalog-price-options.js

@@ -0,0 +1,51 @@
+import { ProductPricingDirector, ProductPricingAdapter, } from '@unchainedshop/core';
+export const ProductPriceOptions = {
+    ...ProductPricingAdapter,
+    key: 'shop.unchained.pricing.product-price-options',
+    version: '1.0',
+    label: 'Add Gross Price of Options',
+    orderIndex: 1,
+    isActivatedFor: () => {
+        return true;
+    },
+    actions: (params) => {
+        const pricingAdapter = ProductPricingAdapter.actions(params);
+        const { countryCode, currencyCode, quantity, modules } = params.context;
+        return {
+            ...pricingAdapter,
+            async calculatePriceForProduct(product) {
+                const price = await modules.products.prices.price(product, {
+                    countryCode,
+                    currencyCode,
+                    quantity,
+                });
+                if (price) {
+                    const itemTotal = price.amount * quantity;
+                    pricingAdapter.resultSheet().addItem({
+                        amount: itemTotal,
+                        isTaxable: Boolean(price.isTaxable),
+                        isNetPrice: Boolean(price.isNetPrice),
+                        meta: { adapter: ProductPriceOptions.key },
+                    });
+                }
+            },
+            async calculate() {
+                const { configuration } = params.context;
+                const productIds = configuration?.flatMap(({ key, value }) => {
+                    if (key === 'option')
+                        return [value];
+                    return [];
+                });
+                if (!productIds?.length) {
+                    return pricingAdapter.calculate();
+                }
+                const options = await modules.products.findProducts({
+                    productIds,
+                });
+                await Promise.all(options.map(this.calculatePriceForProduct));
+                return pricingAdapter.calculate();
+            },
+        };
+    },
+};
+ProductPricingDirector.registerAdapter(ProductPriceOptions);

package/lib/pricing/product-catalog-price.d.ts

@@ -0,0 +1,2 @@
+import { type IProductPricingAdapter } from '@unchainedshop/core';
+export declare const ProductPrice: IProductPricingAdapter;

package/lib/pricing/product-catalog-price.js

@@ -0,0 +1,60 @@
+import { ProductPricingDirector, ProductPricingAdapter, } from '@unchainedshop/core';
+import { ProductType } from '@unchainedshop/core-products';
+export const ProductPrice = {
+    ...ProductPricingAdapter,
+    key: 'shop.unchained.pricing.product-price',
+    version: '1.0.0',
+    label: 'Add Gross Price to Product',
+    orderIndex: 0,
+    isActivatedFor: () => {
+        return true;
+    },
+    actions: (params) => {
+        const pricingAdapter = ProductPricingAdapter.actions(params);
+        return {
+            ...pricingAdapter,
+            calculate: async () => {
+                const { product, countryCode, currencyCode, quantity, modules } = params.context;
+                const price = await modules.products.prices.price(product, {
+                    countryCode,
+                    currencyCode,
+                    quantity,
+                });
+                if (price) {
+                    const itemTotal = price.amount * quantity;
+                    pricingAdapter.resultSheet().addItem({
+                        amount: itemTotal,
+                        isTaxable: Boolean(price.isTaxable),
+                        isNetPrice: Boolean(price.isNetPrice),
+                        meta: { adapter: ProductPrice.key },
+                    });
+                }
+                else if (product.type === ProductType.BUNDLE_PRODUCT) {
+                    for (const bundleItem of product.bundleItems || []) {
+                        const bundledProduct = await modules.products.findProduct({
+                            productId: bundleItem.productId,
+                        });
+                        if (bundledProduct) {
+                            const bundleItemPrice = await modules.products.prices.price(bundledProduct, {
+                                countryCode,
+                                currencyCode,
+                                quantity: bundleItem.quantity * quantity,
+                            });
+                            if (bundleItemPrice) {
+                                const bundleItemTotal = bundleItemPrice.amount * bundleItem.quantity * quantity;
+                                pricingAdapter.resultSheet().addItem({
+                                    amount: bundleItemTotal,
+                                    isTaxable: Boolean(bundleItemPrice.isTaxable),
+                                    isNetPrice: Boolean(bundleItemPrice.isNetPrice),
+                                    meta: { adapter: ProductPrice.key },
+                                });
+                            }
+                        }
+                    }
+                }
+                return pricingAdapter.calculate();
+            },
+        };
+    },
+};
+ProductPricingDirector.registerAdapter(ProductPrice);

package/lib/pricing/product-discount.d.ts

@@ -0,0 +1,2 @@
+import { type ProductDiscountConfiguration, type IProductPricingAdapter } from '@unchainedshop/core';
+export declare const ProductDiscount: IProductPricingAdapter<ProductDiscountConfiguration>;

package/lib/pricing/product-discount.js

@@ -0,0 +1,69 @@
+import { calculation as calcUtils } from '@unchainedshop/utils';
+import { ProductPricingDirector, ProductPricingAdapter, ProductPricingRowCategory, } from '@unchainedshop/core';
+export const ProductDiscount = {
+    ...ProductPricingAdapter,
+    key: 'shop.unchained.pricing.product-discount',
+    version: '1.0.0',
+    label: 'Apply Discounts on Product Price',
+    orderIndex: 30,
+    isActivatedFor: () => {
+        return true;
+    },
+    actions: (params) => {
+        const pricingAdapter = ProductPricingAdapter.actions(params);
+        const addDiscounts = (discount, total, resolvedConfiguration) => {
+            const { discountId } = discount;
+            const { isNetPrice = false, taxRate, ...meta } = resolvedConfiguration;
+            const amount = calcUtils.applyRate(resolvedConfiguration, total);
+            const isTaxable = taxRate === undefined || taxRate === null;
+            pricingAdapter.resultSheet().addDiscount({
+                amount: amount * -1,
+                discountId,
+                isNetPrice,
+                isTaxable,
+                meta: { adapter: ProductDiscount.key, ...meta },
+            });
+            if (!isTaxable && taxRate) {
+                const taxAmount = calcUtils.getTaxAmount(amount, taxRate, isNetPrice);
+                pricingAdapter.resultSheet().addTax({
+                    amount: taxAmount * -1,
+                    rate: taxRate,
+                    discountId,
+                    baseCategory: ProductPricingRowCategory.Discount,
+                    meta: { adapter: ProductDiscount.key, discountId, ...meta },
+                });
+                if (!isNetPrice) {
+                    pricingAdapter.resultSheet().addDiscount({
+                        amount: taxAmount,
+                        discountId,
+                        isNetPrice: false,
+                        isTaxable: false,
+                        meta: { adapter: ProductDiscount.key, discountId, ...meta },
+                    });
+                }
+            }
+        };
+        return {
+            ...pricingAdapter,
+            calculate: async () => {
+                params.discounts.forEach((discount) => {
+                    if (!discount)
+                        return;
+                    const { configuration } = discount;
+                    const resolvedConfiguration = configuration.customPriceConfigurationResolver
+                        ? configuration.customPriceConfigurationResolver(params.context.product, params.context.quantity, params.context.configuration)
+                        : configuration;
+                    if (!resolvedConfiguration)
+                        return;
+                    const total = params.calculationSheet.total({
+                        category: ProductPricingRowCategory.Item,
+                        useNetPrice: resolvedConfiguration.isNetPrice,
+                    });
+                    addDiscounts(discount, total.amount, resolvedConfiguration);
+                });
+                return pricingAdapter.calculate();
+            },
+        };
+    },
+};
+ProductPricingDirector.registerAdapter(ProductDiscount);

package/lib/pricing/product-price-rateconversion.d.ts

@@ -0,0 +1,2 @@
+import { type IProductPricingAdapter } from '@unchainedshop/core';
+export declare const ProductPriceRateConversion: IProductPricingAdapter;