@unchainedshop/plugins 4.6.1 → 4.6.2

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

@@ -0,0 +1,74 @@
+import { OrderPricingRowCategory, 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();
+            },
+        };
+    },
+};
+export default OrderDiscount;

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

@@ -0,0 +1,4 @@
+import { type IPlugin } from '@unchainedshop/core';
+export declare const OrderDiscountPlugin: IPlugin;
+export default OrderDiscountPlugin;
+export { OrderDiscount } from './adapter.ts';

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

@@ -0,0 +1,10 @@
+import {} from '@unchainedshop/core';
+import { OrderDiscount } from "./adapter.js";
+export const OrderDiscountPlugin = {
+    key: 'shop.unchained.pricing.order-discount',
+    label: 'Order Discount Pricing Plugin',
+    version: '1.0.0',
+    adapters: [OrderDiscount],
+};
+export default OrderDiscountPlugin;
+export { OrderDiscount } from "./adapter.js";

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

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

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

@@ -0,0 +1,43 @@
+import { 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();
+            },
+        };
+    },
+};
+export default OrderItems;

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

@@ -0,0 +1,4 @@
+import { type IPlugin } from '@unchainedshop/core';
+export declare const OrderItemsPlugin: IPlugin;
+export default OrderItemsPlugin;
+export { OrderItems } from './adapter.ts';

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

@@ -0,0 +1,10 @@
+import {} from '@unchainedshop/core';
+import { OrderItems } from "./adapter.js";
+export const OrderItemsPlugin = {
+    key: 'shop.unchained.pricing.order-items',
+    label: 'Order Items Pricing Plugin',
+    version: '1.0.0',
+    adapters: [OrderItems],
+};
+export default OrderItemsPlugin;
+export { OrderItems } from "./adapter.js";

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

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

package/lib/pricing/order-payment/adapter.js

@@ -0,0 +1,33 @@
+import { 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();
+            },
+        };
+    },
+};
+export default OrderPayment;

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

@@ -0,0 +1,4 @@
+import { type IPlugin } from '@unchainedshop/core';
+export declare const OrderPaymentPlugin: IPlugin;
+export default OrderPaymentPlugin;
+export { OrderPayment } from './adapter.ts';

package/lib/pricing/order-payment/index.js

@@ -0,0 +1,10 @@
+import {} from '@unchainedshop/core';
+import { OrderPayment } from "./adapter.js";
+export const OrderPaymentPlugin = {
+    key: 'shop.unchained.pricing.order-payment',
+    label: 'Order Payment Pricing Plugin',
+    version: '1.0.0',
+    adapters: [OrderPayment],
+};
+export default OrderPaymentPlugin;
+export { OrderPayment } from "./adapter.js";

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

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

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

@@ -0,0 +1,60 @@
+import { 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();
+            },
+        };
+    },
+};
+export default ProductPrice;

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

@@ -0,0 +1,4 @@
+import { type IPlugin } from '@unchainedshop/core';
+export declare const ProductPricePlugin: IPlugin;
+export default ProductPricePlugin;
+export { ProductPrice } from './adapter.ts';

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

@@ -0,0 +1,10 @@
+import {} from '@unchainedshop/core';
+import { ProductPrice } from "./adapter.js";
+export const ProductPricePlugin = {
+    key: 'shop.unchained.pricing.product-catalog',
+    label: 'Product Catalog Price Plugin',
+    version: '1.0.0',
+    adapters: [ProductPrice],
+};
+export default ProductPricePlugin;
+export { ProductPrice } from "./adapter.js";

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

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

package/lib/pricing/product-discount/adapter.js

@@ -0,0 +1,69 @@
+import { calculation as calcUtils } from '@unchainedshop/utils';
+import { 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();
+            },
+        };
+    },
+};
+export default ProductDiscount;

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

@@ -0,0 +1,4 @@
+import { type IPlugin } from '@unchainedshop/core';
+export declare const ProductDiscountPlugin: IPlugin;
+export default ProductDiscountPlugin;
+export { ProductDiscount } from './adapter.ts';

package/lib/pricing/product-discount/index.js

@@ -0,0 +1,10 @@
+import {} from '@unchainedshop/core';
+import { ProductDiscount } from "./adapter.js";
+export const ProductDiscountPlugin = {
+    key: 'shop.unchained.pricing.product-discount',
+    label: 'Product Discount Pricing Plugin',
+    version: '1.0.0',
+    adapters: [ProductDiscount],
+};
+export default ProductDiscountPlugin;
+export { ProductDiscount } from "./adapter.js";

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

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

package/lib/pricing/product-price-rateconversion/adapter.js

@@ -0,0 +1,53 @@
+import { ProductPricingAdapter } from '@unchainedshop/core';
+export const ProductPriceRateConversion = {
+    ...ProductPricingAdapter,
+    key: 'shop.unchained.pricing.rate-conversion',
+    version: '1.0.0',
+    label: 'Generic rate conversion plugin that converts between rates if entry in DB exists.',
+    orderIndex: 10,
+    isActivatedFor: () => {
+        return true;
+    },
+    actions: (params) => {
+        const pricingAdapter = ProductPricingAdapter.actions(params);
+        const { modules } = params.context;
+        return {
+            ...pricingAdapter,
+            calculate: async () => {
+                const { product, countryCode, quantity, currencyCode: targetCurrency } = params.context;
+                const { calculation = [] } = params.calculationSheet;
+                if (calculation?.length) {
+                    return pricingAdapter.calculate();
+                }
+                const productPrice = await modules.products.prices.price(product, {
+                    countryCode,
+                    quantity,
+                });
+                if (!productPrice) {
+                    return pricingAdapter.calculate();
+                }
+                const fromCurrencyObj = await modules.currencies.findCurrency({
+                    isoCode: productPrice.currencyCode,
+                });
+                const targetCurrencyObj = await modules.currencies.findCurrency({
+                    isoCode: targetCurrency,
+                });
+                if (!targetCurrencyObj?.isActive || !fromCurrencyObj?.isActive)
+                    return pricingAdapter.calculate();
+                const rateData = await modules.products.prices.rates.getRate(fromCurrencyObj, targetCurrencyObj);
+                if (rateData && rateData.rate > 0) {
+                    const convertedAmount = Math.round(productPrice.amount * rateData.rate);
+                    pricingAdapter.resultSheet().resetCalculation(params.calculationSheet);
+                    pricingAdapter.resultSheet().addItem({
+                        amount: convertedAmount * quantity,
+                        isTaxable: Boolean(productPrice?.isTaxable),
+                        isNetPrice: Boolean(productPrice?.isNetPrice),
+                        meta: { adapter: ProductPriceRateConversion.key, rate: rateData.rate },
+                    });
+                }
+                return pricingAdapter.calculate();
+            },
+        };
+    },
+};
+export default ProductPriceRateConversion;

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

@@ -0,0 +1,4 @@
+import { type IPlugin } from '@unchainedshop/core';
+export declare const ProductPriceRateConversionPlugin: IPlugin;
+export default ProductPriceRateConversionPlugin;
+export { ProductPriceRateConversion } from './adapter.ts';

package/lib/pricing/product-price-rateconversion/index.js

@@ -0,0 +1,10 @@
+import {} from '@unchainedshop/core';
+import { ProductPriceRateConversion } from "./adapter.js";
+export const ProductPriceRateConversionPlugin = {
+    key: 'shop.unchained.pricing.rate-conversion',
+    label: 'Product Price Rate Conversion Plugin',
+    version: '1.0.0',
+    adapters: [ProductPriceRateConversion],
+};
+export default ProductPriceRateConversionPlugin;
+export { ProductPriceRateConversion } from "./adapter.js";

package/lib/pricing/product-swiss-tax/adapter.d.ts

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

package/lib/pricing/product-swiss-tax/adapter.js

@@ -0,0 +1,76 @@
+import { ProductPricingAdapter, ProductPricingRowCategory, } from '@unchainedshop/core';
+import { resolveTaxCategoryFromDeliveryProvider, resolveTaxCategoryFromProduct, SwissTaxCategories, } from "../tax/ch.js";
+import isDeliveryAddressInCountry from "../utils/isDeliveryAddressInCountry.js";
+export const ProductSwissTax = {
+    ...ProductPricingAdapter,
+    key: 'shop.unchained.pricing.product-swiss-tax',
+    version: '1.0.0',
+    label: 'Apply Swiss Tax on Product',
+    orderIndex: 80,
+    isActivatedFor: () => {
+        return true;
+    },
+    actions: (params) => {
+        const pricingAdapter = ProductPricingAdapter.actions(params);
+        const { context } = params;
+        return {
+            ...pricingAdapter,
+            calculate: async () => {
+                const orderDelivery = context.order?.deliveryId
+                    ? await context.modules.orders.deliveries.findDelivery({
+                        orderDeliveryId: context.order?.deliveryId,
+                    })
+                    : null;
+                if (!isDeliveryAddressInCountry({
+                    ...context,
+                    orderDelivery,
+                }, ['CH', 'LI'])) {
+                    return pricingAdapter.calculate();
+                }
+                let taxCategory = resolveTaxCategoryFromProduct(context.product);
+                if (!taxCategory) {
+                    const provider = orderDelivery?.deliveryProviderId
+                        ? await context.modules.delivery.findProvider({
+                            deliveryProviderId: orderDelivery?.deliveryProviderId,
+                        })
+                        : null;
+                    if (provider)
+                        taxCategory = resolveTaxCategoryFromDeliveryProvider(provider);
+                }
+                if (!taxCategory)
+                    taxCategory = SwissTaxCategories.DEFAULT;
+                const taxRate = taxCategory.rate(context.order?.ordered);
+                ProductPricingAdapter.log(`ProductSwissTax -> Tax Multiplicator: ${taxRate}`);
+                params.calculationSheet.filterBy({ isTaxable: true }).forEach(({ isNetPrice, ...row }) => {
+                    if (!isNetPrice) {
+                        const taxAmount = row.amount - row.amount / (1 + taxRate);
+                        pricingAdapter.resultSheet().calculation.push({
+                            ...row,
+                            amount: -taxAmount,
+                            isTaxable: false,
+                            isNetPrice: false,
+                            meta: { adapter: ProductSwissTax.key },
+                        });
+                        pricingAdapter.resultSheet().addTax({
+                            amount: taxAmount,
+                            rate: taxRate,
+                            baseCategory: ProductPricingRowCategory.Item,
+                            meta: { adapter: ProductSwissTax.key },
+                        });
+                    }
+                    else {
+                        const taxAmount = row.amount * taxRate;
+                        pricingAdapter.resultSheet().addTax({
+                            amount: taxAmount,
+                            rate: taxRate,
+                            baseCategory: ProductPricingRowCategory.Item,
+                            meta: { adapter: ProductSwissTax.key },
+                        });
+                    }
+                });
+                return pricingAdapter.calculate();
+            },
+        };
+    },
+};
+export default ProductSwissTax;

package/lib/pricing/product-swiss-tax/index.d.ts

@@ -0,0 +1,4 @@
+import { type IPlugin } from '@unchainedshop/core';
+export declare const ProductSwissTaxPlugin: IPlugin;
+export default ProductSwissTaxPlugin;
+export { ProductSwissTax } from './adapter.ts';

package/lib/pricing/product-swiss-tax/index.js

@@ -0,0 +1,10 @@
+import {} from '@unchainedshop/core';
+import { ProductSwissTax } from "./adapter.js";
+export const ProductSwissTaxPlugin = {
+    key: 'shop.unchained.pricing.product-swiss-tax',
+    label: 'Product Swiss Tax Plugin',
+    version: '1.0.0',
+    adapters: [ProductSwissTax],
+};
+export default ProductSwissTaxPlugin;
+export { ProductSwissTax } from "./adapter.js";

package/lib/quotations/manual/adapter.d.ts

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

package/lib/quotations/manual/adapter.js

@@ -0,0 +1,19 @@
+import { QuotationAdapter } from '@unchainedshop/core';
+export const ManualOffering = {
+    ...QuotationAdapter,
+    key: 'shop.unchained.quotations.manual',
+    version: '1.0.0',
+    label: 'Manual Offerings',
+    orderIndex: 0,
+    isActivatedFor: () => true,
+    actions: (params) => {
+        return {
+            ...QuotationAdapter.actions(params),
+            quote: async () => {
+                return {
+                    expires: new Date(new Date().getTime() + 3600 * 1000),
+                };
+            },
+        };
+    },
+};

package/lib/quotations/manual/index.d.ts

@@ -0,0 +1,4 @@
+import { type IPlugin } from '@unchainedshop/core';
+export declare const ManualOfferingPlugin: IPlugin;
+export default ManualOfferingPlugin;
+export { ManualOffering } from './adapter.ts';

package/lib/quotations/manual/index.js

@@ -0,0 +1,10 @@
+import {} from '@unchainedshop/core';
+import { ManualOffering } from "./adapter.js";
+export const ManualOfferingPlugin = {
+    key: 'shop.unchained.quotations.manual',
+    label: 'Manual Offering Quotation Plugin',
+    version: '1.0.0',
+    adapters: [ManualOffering],
+};
+export default ManualOfferingPlugin;
+export { ManualOffering } from "./adapter.js";

package/lib/warehousing/erc-metadata/api.d.ts

@@ -0,0 +1,12 @@
+import type { UnchainedCore } from '@unchainedshop/core';
+export declare function ercMetadataHandler(request: Request, context: UnchainedCore & {
+    params: Record<string, string>;
+    locale?: Intl.Locale;
+    loaders?: {
+        productLoader: {
+            load: (params: {
+                productId: string;
+            }) => Promise<any>;
+        };
+    };
+}): Promise<Response>;