lazywait-calcs 1.0.4 → 1.0.6

package/lib/esm/Calcs.js

@@ -1,176 +1,170 @@
 import _ from 'lodash';
 import moment from 'moment';
-import { convertToDate, preventNaN, toFixedFloat } from './utils';
-function ItemTotal(order_item, branch_vat, order_taxes, order_discounts, order_items_count = 1) {
+import { convertToDate, preventNaN, toFixed, toFixedFloat } from './utils';
+export function ItemTotal(order_item, branch_vat, order_taxes, order_discounts, order_items_count = 1) {
     let total = 0;
     const vat = branch_vat ? 1 + branch_vat / 100 : 1;
-    if (order_item.price && order_item.quantity) {
-        let price = order_item.price;
-        (order_item?.addons || []).forEach((addon) => {
-            if (addon.price && addon.quantity) {
-                price += addon.price * addon.quantity;
+    if (order_item?.price && order_item?.quantity) {
+        let price = preventNaN(order_item.price);
+        (order_item.addons ?? []).forEach((addon) => {
+            if (addon?.price && addon?.quantity) {
+                price += preventNaN(addon.price) * preventNaN(addon.quantity);
             }
         });
         const discounts = calcItemDiscounts(order_item, order_discounts, order_items_count);
         price -= discounts;
-        let item_tax = _.sum(order_item.taxes?.map((tax) => {
+        let item_tax = _.sum((order_item.taxes ?? []).map((tax) => {
             return tax.isPercent ? ((tax.amount || 0) / 100) * price : tax.amount || 0;
         }));
         if (order_taxes) {
-            price += _.sum(order_taxes?.map((_tax) => {
-                return _tax.isPercent ? ((_tax.amount || 0) / 100) * price : (_tax.amount || 0) / order_items_count;
-            }) || [0]);
+            price += _.sum((order_taxes ?? []).map((_tax) => {
+                return _tax.isPercent ? preventNaN((_tax.amount ?? 0) / 100) * price : preventNaN(_tax.amount ?? 0) / order_items_count;
+            }) ?? [0]);
         }
         if (order_item.not_taxable) {
-            total = price * order_item.quantity;
+            total = price * preventNaN(order_item.quantity);
         }
         else {
-            total = (price + item_tax) * order_item.quantity * vat;
+            total = (price + item_tax) * preventNaN(order_item.quantity) * vat;
         }
     }
     return total;
 }
-function Subtotal(order_items) {
-    if (order_items && order_items.length) {
-        return _.sum(order_items.map(calcItem));
-    }
-    return 0;
+export function Subtotal(order_items) {
+    return _.sum((order_items ?? []).map(calcItem));
 }
-function calcItem(order_item) {
+export function calcItem(order_item) {
     let result = 0;
-    (order_item?.addons || []).forEach((addon) => {
-        if (addon.price && addon.quantity) {
-            result += addon.price * addon.quantity;
+    (order_item?.addons ?? []).forEach((addon) => {
+        if (addon?.price && addon?.quantity) {
+            result += preventNaN(addon.price) * preventNaN(addon.quantity);
         }
     });
-    if (order_item.price && order_item.quantity) {
-        return (result + order_item.price) * order_item.quantity;
+    if (order_item?.price && order_item?.quantity) {
+        return (result + preventNaN(order_item.price)) * preventNaN(order_item.quantity);
     }
     return result;
 }
-function Discounts(order_discounts, order_items, loyalty_amount, branch_vat) {
+export function Discounts(order_discounts, order_items, loyalty_amount, branch_vat) {
     let discounts = 0;
     const subtotal = Subtotal(order_items);
-    if (order_discounts) {
-        order_discounts.forEach((discount) => {
-            if (discount.amount) {
-                let is_percentage = discount.is_percentage || false;
-                let is_spendAtleast = discount.spends_at_least || false;
-                let amount = 0;
-                if (is_percentage)
-                    amount = (subtotal * discount.amount) / 100;
-                else if (is_spendAtleast && subtotal >= discount.spends_at_least_amount) {
-                    amount = discount.amount;
-                }
-                else if (is_spendAtleast && subtotal < discount.spends_at_least_amount) {
-                    null;
-                }
-                else {
-                    amount = discount.amount;
-                }
-                discounts += amount;
+    (order_discounts ?? []).forEach((discount) => {
+        if (discount?.amount) {
+            let is_percentage = !!discount?.is_percentage;
+            let is_spendAtleast = !!discount?.spends_at_least;
+            let amount = 0;
+            if (is_percentage)
+                amount = (subtotal * preventNaN(discount?.amount)) / 100;
+            else if (is_spendAtleast && subtotal >= (discount?.spends_at_least_amount ?? 0)) {
+                amount = preventNaN(discount?.amount);
             }
-        });
-    }
-    order_items?.forEach((order_item) => {
-        (order_item?.discounts || []).forEach((discount) => {
-            if (discount.is_percentage && discount.amount) {
+            else if (is_spendAtleast && subtotal < (discount?.spends_at_least_amount ?? 0)) {
+                null;
+            }
+            else {
+                amount = preventNaN(discount?.amount);
+            }
+            discounts += amount;
+        }
+    });
+    (order_items ?? []).forEach((order_item) => {
+        (order_item?.discounts ?? []).forEach((discount) => {
+            if (discount?.is_percentage && discount?.amount) {
                 const addons_arr = order_item?.addons?.map((a) => (a.price ?? 0) * a.quantity || 0);
                 const addons_total = _.sum(addons_arr);
-                discounts += (order_item.price + (addons_total || 0)) * order_item.quantity * (discount.amount / 100);
+                discounts += (preventNaN(order_item?.price) + (addons_total || 0)) * preventNaN(order_item.quantity) * (preventNaN(discount?.amount) / 100);
             }
-            else if (discount.amount) {
-                discounts += discount.amount * order_item.quantity;
+            else if (discount?.amount) {
+                discounts += preventNaN(discount?.amount) * preventNaN(order_item.quantity);
             }
         });
     });
     if (loyalty_amount) {
         if (branch_vat) {
-            const vat = 1 + branch_vat / 100;
-            discounts += loyalty_amount / vat;
+            const vat = 1 + preventNaN(branch_vat) / 100;
+            discounts += preventNaN(loyalty_amount) / vat;
         }
         else {
-            discounts += loyalty_amount;
+            discounts += preventNaN(loyalty_amount);
         }
     }
     return discounts;
 }
-function DiscountsWithVat(order_discounts, order_items, loyalty_amount, branch_vat) {
+export function DiscountsWithVat(order_discounts, order_items, loyalty_amount, branch_vat) {
     let discounts = 0;
     const subtotal = Subtotal(order_items);
-    if (order_discounts) {
-        order_discounts.forEach((discount) => {
-            if (discount.amount) {
-                let is_percentage = discount.is_percentage || false;
-                let is_spendAtleast = discount.spends_at_least || false;
-                let amount = 0;
-                if (is_percentage)
-                    amount = (subtotal * discount.amount) / 100;
-                else if (is_spendAtleast && subtotal >= discount.spends_at_least_amount) {
-                    amount = discount.amount;
-                }
-                else if (is_spendAtleast && subtotal < discount.spends_at_least_amount) {
-                    null;
-                }
-                else {
-                    amount = discount.amount;
-                }
-                discounts += amount;
+    (order_discounts ?? []).forEach((discount) => {
+        if (discount?.amount) {
+            let is_percentage = !!discount?.is_percentage;
+            let is_spendAtleast = !!discount?.spends_at_least;
+            let amount = 0;
+            if (is_percentage)
+                amount = (subtotal * preventNaN(discount?.amount)) / 100;
+            else if (is_spendAtleast && subtotal >= (discount?.spends_at_least_amount ?? 0)) {
+                amount = preventNaN(discount?.amount);
             }
-        });
-    }
-    (order_items || []).forEach((order_item) => {
-        (order_item?.discounts || []).forEach((discount) => {
-            if (!order_item.not_taxable) {
-                if (discount.is_percentage && discount.amount) {
-                    const addons_arr = order_item?.addons?.map((a) => (a.price || 0) * (a.quantity || 0));
+            else if (is_spendAtleast && subtotal < (discount?.spends_at_least_amount ?? 0)) {
+                null;
+            }
+            else {
+                amount = preventNaN(discount?.amount);
+            }
+            discounts += amount;
+        }
+    });
+    (order_items ?? []).forEach((order_item) => {
+        (order_item?.discounts ?? []).forEach((discount) => {
+            if (!order_item?.not_taxable) {
+                if (discount?.is_percentage && discount?.amount) {
+                    const addons_arr = order_item?.addons?.map((a) => preventNaN(a.price) * preventNaN(a.quantity));
                     const addons_total = _.sum(addons_arr);
-                    discounts += (order_item.price + (addons_total || 0)) * order_item.quantity * (discount.amount / 100);
+                    discounts +=
+                        (preventNaN(order_item?.price) + (addons_total || 0)) * preventNaN(order_item?.quantity) * (preventNaN(discount?.amount) / 100);
                 }
-                else if (discount.amount) {
-                    discounts += discount.amount * order_item.quantity;
+                else if (discount?.amount) {
+                    discounts += preventNaN(discount?.amount) * preventNaN(order_item?.quantity);
                 }
             }
         });
     });
     if (loyalty_amount) {
         if (branch_vat) {
-            const vat = 1 + branch_vat / 100;
-            discounts += loyalty_amount / vat;
+            const vat = 1 + preventNaN(branch_vat) / 100;
+            discounts += preventNaN(loyalty_amount) / vat;
         }
         else {
-            discounts += loyalty_amount;
+            discounts += preventNaN(loyalty_amount);
         }
     }
     return discounts;
 }
-function ItemVat(order_item, branch_vat) {
+export function ItemVat(order_item, branch_vat) {
     const vat = branch_vat ? branch_vat / 100 : 1;
     let addons = 0;
-    (order_item?.addons || []).forEach((addon) => {
-        if (addon.price && addon.quantity) {
-            addons += toFixedFloat(addon.price * addon.quantity);
+    (order_item?.addons ?? []).forEach((addon) => {
+        if (addon?.price && addon?.quantity) {
+            addons += toFixedFloat(preventNaN(addon?.price) * preventNaN(addon?.quantity));
         }
     });
     let discounts = 0;
-    (order_item?.discounts || []).forEach((discount) => {
-        if (discount.is_percentage && discount.amount) {
-            discounts += toFixedFloat((order_item.price + addons) * order_item.quantity * (discount.amount / 100));
+    (order_item?.discounts ?? []).forEach((discount) => {
+        if (discount?.is_percentage && discount?.amount) {
+            discounts += toFixedFloat((preventNaN(order_item?.price) + addons) * preventNaN(order_item?.quantity) * (preventNaN(discount?.amount) / 100));
         }
-        else if (discount.amount) {
-            discounts += toFixedFloat(discount.amount * order_item.quantity);
+        else if (discount?.amount) {
+            discounts += toFixedFloat(preventNaN(discount?.amount) * preventNaN(order_item?.quantity));
         }
     });
-    const price = order_item.price + addons - discounts;
-    return order_item.not_taxable ? 0 : toFixedFloat(price * vat);
+    const price = preventNaN(order_item?.price) + addons - discounts;
+    return order_item?.not_taxable ? 0 : toFixedFloat(price * vat);
 }
-function Vat(order, order_items, loyalty_amount, branch_vat) {
+export function Vat(order_items, order_discounts, order_taxes, order_deliveries, loyalty_amount, branch_vat) {
     if (branch_vat && order_items.some((o) => !o.not_taxable)) {
-        const discount = DiscountsWithVat(order?.order_discounts || [], order_items, order?.loyalty_amount || 0, branch_vat);
+        const discount = DiscountsWithVat(order_discounts ?? [], order_items, loyalty_amount ?? 0, branch_vat);
         // Other charges for taxable items
-        const other_charges = Number(OtherCharges(order_items.filter((i) => !i.not_taxable), order, loyalty_amount, branch_vat));
+        const other_charges = Number(OtherCharges(order_items.filter((i) => !i.not_taxable), order_discounts, order_taxes, loyalty_amount, branch_vat));
         // Order delivery
-        const deliveries = Deliveries(order?.order_deliveries || []);
+        const deliveries = Deliveries(order_deliveries || []);
         // subtotal of items with vat
         let sub_total = _.sum(order_items.filter((i) => !i.not_taxable).map(calcItem));
         // VAT amount
@@ -179,13 +173,13 @@ function Vat(order, order_items, loyalty_amount, branch_vat) {
     }
     return 0;
 }
-function TaxableAmount(order_items) {
+export function TaxableAmount(order_items) {
     return _.sum((order_items || []).filter((i) => !i.not_taxable).map(calcItem));
 }
-function NonTaxableAmount(order_items) {
+export function NonTaxableAmount(order_items) {
     return _.sum((order_items || []).filter((i) => i.not_taxable).map(calcItem));
 }
-function Deliveries(order_deliveries) {
+export function Deliveries(order_deliveries) {
     let sum = 0;
     if (order_deliveries) {
         (order_deliveries || []).forEach((d) => {
@@ -199,140 +193,130 @@ function Deliveries(order_deliveries) {
     }
     return sum;
 }
-function OtherCharges(order_items, order, loyalty_amount, branch_vat) {
+export function OtherCharges(order_items, order_discounts, order_taxes, loyalty_amount, branch_vat) {
     const sub = Subtotal(order_items);
-    const discounts = Number(Discounts(order?.order_deliveries || [], order_items, loyalty_amount, branch_vat));
-    let other_charges = 0;
-    if (order?.order_taxes) {
-        other_charges = order?.order_taxes
-            ? _.sum(order?.order_taxes.map((tax) => {
-                if (tax.amount) {
-                    let result = tax.isPercent ? (tax.amount / 100) * (sub - discounts) : tax.amount;
-                    return result;
-                }
-                return 0;
-            }))
-            : 0;
-    }
-    (order_items || []).forEach((order_item) => {
-        const addons_total = _.sum(order_item?.addons?.map((a) => (a.price || 0) * (a.quantity || 0)));
-        const price = (order_item.price + addons_total) * order_item.quantity;
+    const discounts = Number(Discounts(order_discounts, order_items, loyalty_amount, branch_vat));
+    let other_charges = order_taxes
+        ? _.sum(order_taxes.map((tax) => {
+            if (tax.amount) {
+                let result = tax.isPercent ? (tax.amount / 100) * (sub - discounts) : tax.amount;
+                return result;
+            }
+            return 0;
+        }))
+        : 0;
+    (order_items ?? []).forEach((order_item) => {
+        const addons_total = _.sum(order_item?.addons?.map((a) => preventNaN(a.price ?? 0) * preventNaN(a.quantity ?? 0)));
+        const price = (preventNaN(order_item?.price) + addons_total) * preventNaN(order_item?.quantity);
         let _discounts = 0;
-        (order_item?.discounts || []).forEach((discount) => {
-            if (discount.is_percentage && discount.amount) {
-                _discounts += price * (discount.amount / 100);
+        (order_item?.discounts ?? []).forEach((discount) => {
+            if (discount?.is_percentage && discount?.amount) {
+                _discounts += price * (preventNaN(discount?.amount) / 100);
             }
-            else if (discount.amount) {
-                _discounts += discount.amount * order_item.quantity;
+            else if (discount?.amount) {
+                _discounts += preventNaN(discount?.amount) * preventNaN(order_item?.quantity);
             }
         });
-        const order_items_count = _.sum(order_items.map((i) => i.quantity));
-        (order?.order_discounts || []).forEach((discount) => {
-            if (discount.is_percentage && discount.amount) {
-                _discounts += price * (discount.amount / 100);
+        const order_items_count = _.sum((order_items ?? []).map((i) => preventNaN(i?.quantity)));
+        (order_discounts ?? []).forEach((discount) => {
+            if (discount?.is_percentage && discount?.amount) {
+                _discounts += price * (preventNaN(discount?.amount) / 100);
             }
-            else if (discount.amount) {
-                _discounts += (discount.amount / order_items_count) * order_item.quantity;
+            else if (discount?.amount) {
+                _discounts += (preventNaN(discount?.amount) / order_items_count) * preventNaN(order_item?.quantity);
             }
         });
-        (order_item?.taxes || []).forEach((tax) => {
-            if (tax.isPercent && tax.amount) {
+        (order_item?.taxes ?? []).forEach((tax) => {
+            if (tax?.isPercent && tax?.amount) {
                 let temp = price - _discounts;
                 if (temp < 0) {
                     temp = 0;
                 }
-                other_charges += temp * (tax.amount / 100);
+                other_charges += temp * (preventNaN(tax?.amount) / 100);
             }
-            else if (tax.amount) {
-                other_charges += tax.amount * (order_item?.quantity || 0);
+            else if (tax?.amount) {
+                other_charges += preventNaN(tax?.amount) * preventNaN(order_item?.quantity ?? 0);
             }
         });
     });
     return other_charges;
 }
-function printedOrderTaxes(order, loyalty_amount, branch_vat) {
+export function printedOrderTaxes(order_items, order_discounts, order_taxes, loyalty_amount, branch_vat) {
     let taxes = [];
-    if (order) {
-        const sub = Subtotal(order.order_items);
-        const discounts = Number(Discounts(order?.order_discounts || [], order.order_items, loyalty_amount, branch_vat));
-        if (order && order.order_taxes) {
-            (order?.order_taxes || []).forEach((tax) => {
-                if (tax.amount) {
-                    taxes.push({
-                        tax_id: tax.tax_id || '',
-                        name_lan_p: tax.name_lan_p || '',
-                        name_lan_s: tax.name_lan_s || '',
-                        isPercent: tax.isPercent,
-                        amount: tax.amount,
-                        total: tax.isPercent ? (tax.amount / 100) * (sub - discounts) : tax.amount,
-                    });
-                }
+    const sub = Subtotal(order_items);
+    const discounts = Number(Discounts(order_discounts ?? [], order_items ?? [], loyalty_amount ?? 0, branch_vat ?? 0));
+    (order_taxes ?? []).forEach((tax) => {
+        if (tax?.amount) {
+            taxes.push({
+                tax_id: tax?.tax_id ?? '',
+                name_lan_p: tax?.name_lan_p ?? '',
+                name_lan_s: tax?.name_lan_s ?? '',
+                isPercent: !!tax?.isPercent,
+                amount: preventNaN(tax?.amount),
+                total: tax?.isPercent ? (preventNaN(tax?.amount) / 100) * (sub - discounts) : preventNaN(tax?.amount),
             });
         }
-        const order_items_count = _.sum(order.order_items.map((i) => i.quantity));
-        const item_taxes = order.order_items.reduce((list, order_item) => {
-            const addons_amount = calcItemAddons(order_item);
-            (order_item?.taxes || []).forEach((tax) => {
-                let _discounts = calcItemDiscounts(order_item, order.order_discounts, order_items_count);
-                if (tax.tax_id) {
-                    let charge = 0;
-                    if (tax.isPercent && tax.amount) {
-                        charge = ((tax.amount || 0) / 100) * (order_item.price + addons_amount - _discounts) * order_item.quantity;
-                    }
-                    else if (tax.amount) {
-                        charge = (tax.amount || 0) * order_item.quantity;
-                    }
-                    if (!list.some((t) => t.tax_id === tax.tax_id)) {
-                        list.push({
-                            tax_id: tax.tax_id,
-                            name_lan_p: tax.name_lan_p || '',
-                            name_lan_s: tax.name_lan_s,
-                            isPercent: tax.isPercent,
-                            amount: tax.amount || 0,
-                            total: charge,
-                        });
-                    }
-                    else {
-                        list = list.map((t) => (t.tax_id !== tax.tax_id ? t : { ...t, total: t.total + charge }));
-                    }
+    });
+    const order_items_count = _.sum((order_items ?? []).map((i) => preventNaN(i.quantity)));
+    const item_taxes = (order_items ?? []).reduce((list, order_item) => {
+        const addons_amount = calcItemAddons(order_item);
+        (order_item?.taxes ?? []).forEach((tax) => {
+            let _discounts = calcItemDiscounts(order_item, order_discounts, order_items_count);
+            if (tax?.tax_id) {
+                let charge = 0;
+                if (tax?.isPercent && tax?.amount) {
+                    charge =
+                        ((preventNaN(tax?.amount) ?? 0) / 100) * (preventNaN(order_item?.price) + addons_amount - _discounts) * preventNaN(order_item?.quantity);
                 }
-            });
-            return list;
-        }, []);
-        return _.concat(taxes, item_taxes);
-    }
-    return taxes;
+                else if (tax?.amount) {
+                    charge = preventNaN(tax?.amount) * preventNaN(order_item?.quantity);
+                }
+                if (!list.some((t) => t.tax_id === tax?.tax_id)) {
+                    list.push({
+                        tax_id: tax?.tax_id,
+                        name_lan_p: tax?.name_lan_p ?? '',
+                        name_lan_s: tax?.name_lan_s,
+                        isPercent: tax?.isPercent,
+                        amount: tax?.amount ?? 0,
+                        total: charge,
+                    });
+                }
+                else {
+                    list = list.map((t) => (t.tax_id !== tax.tax_id ? t : { ...t, total: preventNaN(t.total) + charge }));
+                }
+            }
+        });
+        return list;
+    }, []);
+    return _.concat(taxes, item_taxes);
 }
-function Total(order, order_items, loyalty_amount, branch_vat) {
+export function Total(order_items, order_discounts, order_taxes, order_deliveries, loyalty_amount, branch_vat) {
     const sub = Number(Subtotal(order_items));
-    const discounts = Number(Discounts(order?.order_discounts || [], order_items, loyalty_amount, branch_vat));
-    const other_charges = Number(OtherCharges(order_items, order, loyalty_amount, branch_vat));
-    const vat = Number(Vat(order, order_items, loyalty_amount, branch_vat));
-    const deliveries = Number(Deliveries(order?.order_deliveries || []));
+    const discounts = Number(Discounts(order_discounts ?? [], order_items ?? [], loyalty_amount ?? 0, branch_vat ?? 0));
+    const other_charges = Number(OtherCharges(order_items ?? [], order_discounts ?? [], order_taxes ?? [], loyalty_amount ?? 0, branch_vat ?? 0));
+    const vat = Number(Vat(order_items ?? [], order_discounts ?? [], order_taxes ?? [], order_deliveries ?? [], loyalty_amount ?? 0, branch_vat ?? 0));
+    const deliveries = Number(Deliveries(order_deliveries ?? []));
     const total = toFixedFloat(sub - discounts + other_charges + vat + deliveries);
-    if (total < 0)
-        return 0;
-    return total;
+    return total > 0 ? total : 0;
 }
-function calcPaymentBalanceDue(invoice, branch) {
-    let due = (invoice.total || 0) - (invoice.received_amount || 0);
-    if (branch && branch.payment_methods) {
-        branch.payment_methods.forEach((payment) => {
-            due -= payment.payment_amount || 0;
-        });
-    }
+export function calcPaymentBalanceDue(invoice, branch) {
+    let due = preventNaN(invoice?.total ?? 0) - preventNaN(invoice?.received_amount ?? 0);
+    (branch?.payment_methods ?? []).forEach((payment) => {
+        due -= preventNaN(payment?.payment_amount ?? 0);
+    });
     return due > 0 ? due : 0;
 }
-function calPaymentTotal(info) {
-    let groupByPaymnets = _.map(info.payments, (p) => ({
-        name_lan_p: p.name_lan_p,
-        name_lan_s: p.name_lan_s,
+export function calPaymentTotal(info) {
+    let groupByPaymnets = _.map(info?.payments ?? [], (p) => ({
+        name_lan_p: p.name_lan_p ?? '',
+        name_lan_s: p.name_lan_s ?? '',
         amount: p.payment_amount,
     }));
     groupByPaymnets = groupByPaymnets.reduce(function (result, acc) {
         if (acc.name_lan_p !== 'CASH_ADD' && acc.name_lan_p !== 'CASH_REMOVE') {
-            result[acc.name_lan_p] = result[acc.name_lan_p] || [];
-            var val = toFixedFloat(result[acc.name_lan_p].payment_amount) || 0;
+            if (!result[acc.name_lan_p])
+                result[acc.name_lan_p] = [];
+            let val = toFixedFloat(preventNaN(result[acc.name_lan_p].payment_amount));
             result[acc.name_lan_p] = {
                 name_lan_p: acc.name_lan_p,
                 name_lan_s: acc.name_lan_s,
@@ -343,55 +327,64 @@ function calPaymentTotal(info) {
     }, {});
     return groupByPaymnets;
 }
-function calcClosingCashBalance(closing, opening_start_cash) {
-    return (preventNaN(closing.closing_cash_sales || 0) +
-        preventNaN(opening_start_cash || 0) +
-        (preventNaN(closing.closing_cash_add || 0) - preventNaN(closing.closing_cash_remove || 0)));
+export function calcClosingCashBalance(closing, opening_start_cash) {
+    return (preventNaN(closing?.closing_cash_sales ?? 0) +
+        preventNaN(opening_start_cash ?? 0) +
+        (preventNaN(closing?.closing_cash_add ?? 0) - preventNaN(closing?.closing_cash_remove ?? 0)));
 }
-function calcItemDiscounts(item, order_discounts, order_items_count) {
+export function calcItemDiscounts(item, order_discounts, order_items_count) {
     let discounts = 0;
     let addons = 0;
-    (item?.addons || []).forEach((addon) => {
-        if (addon.price && addon.quantity) {
-            addons += addon.price * addon.quantity;
+    (item?.addons ?? []).forEach((addon) => {
+        if (addon?.price && addon?.quantity) {
+            addons += preventNaN(addon?.price) * preventNaN(addon?.quantity);
         }
     });
-    (item?.discounts || []).forEach((discount) => {
-        if (discount.is_percentage && discount.amount) {
-            discounts += (item.price + addons) * (discount.amount / 100);
+    (item?.discounts ?? []).forEach((discount) => {
+        if (discount?.is_percentage && discount?.amount) {
+            discounts += (preventNaN(item?.price) + addons) * (preventNaN(discount?.amount) / 100);
         }
-        else if (discount.amount) {
-            discounts += discount.amount;
+        else if (discount?.amount) {
+            discounts += preventNaN(discount?.amount);
         }
     });
-    (order_discounts || []).forEach((discount) => {
-        if (discount.is_percentage && discount.amount) {
-            discounts += (item.price + addons) * (discount.amount / 100);
+    (order_discounts ?? []).forEach((discount) => {
+        if (discount?.is_percentage && discount?.amount) {
+            discounts += (preventNaN(item?.price) + addons) * (preventNaN(discount?.amount) / 100);
         }
-        else if (discount.amount) {
-            discounts += discount.amount / order_items_count;
+        else if (discount?.amount) {
+            discounts += preventNaN(discount?.amount) / order_items_count;
         }
     });
     return discounts;
 }
-function calcItemAddons(item) {
+export function calcItemAddons(item) {
     let addons = 0;
-    (item?.addons || []).forEach((addon) => {
-        if (addon.price && addon.quantity) {
-            addons += addon.price * addon.quantity;
+    (item?.addons ?? []).forEach((addon) => {
+        if (addon?.price && addon?.quantity) {
+            addons += preventNaN(addon?.price) * preventNaN(addon?.quantity);
         }
     });
     return addons;
 }
-function getInvoicesDiffrence(openning, invoices) {
-    const now = moment();
-    const openningTime = moment(convertToDate(openning.cashier_opening_date));
-    const orders = invoices.map((invoice) => {
-        const invoiceDate = moment(convertToDate(invoice.order_date));
-        if (!invoiceDate.isBetween(openningTime, now)) {
-            return invoice;
-        }
+export function getInvoicesDiffrence(openning, invoices) {
+    const now = moment(new Date());
+    const openningTime = moment(convertToDate(openning?.cashier_opening_date));
+    const orders = (invoices ?? []).filter((invoice) => {
+        const invoiceDate = moment(convertToDate(invoice?.order_date));
+        return !invoiceDate.isBetween(openningTime, now);
     });
     return orders;
 }
-export { ItemTotal, Subtotal, calcItem, Discounts, DiscountsWithVat, ItemVat, Vat, TaxableAmount, NonTaxableAmount, Deliveries, OtherCharges, printedOrderTaxes, Total, calcPaymentBalanceDue, calPaymentTotal, calcClosingCashBalance, calcItemDiscounts, calcItemAddons, getInvoicesDiffrence, };
+export function WithVat(branch_vat, price) {
+    if (branch_vat && price) {
+        return parseFloat(toFixed(price * (1 + branch_vat / 100)));
+    }
+    return price ?? 0;
+}
+export function WithoutVat(branch_vat, price) {
+    if (branch_vat && price) {
+        return price / (1 + branch_vat / 100);
+    }
+    return price ?? 0;
+}

package/lib/esm/index.js

@@ -1,2 +1,3 @@
-import { ItemTotal, Subtotal, calcItem, Discounts, DiscountsWithVat, ItemVat, Vat, TaxableAmount, NonTaxableAmount, Deliveries, OtherCharges, printedOrderTaxes, Total, calcPaymentBalanceDue, calPaymentTotal, calcClosingCashBalance, calcItemDiscounts, calcItemAddons, getInvoicesDiffrence, } from './Calcs';
-export { ItemTotal, Subtotal, calcItem, Discounts, DiscountsWithVat, ItemVat, Vat, TaxableAmount, NonTaxableAmount, Deliveries, OtherCharges, printedOrderTaxes, Total, calcPaymentBalanceDue, calPaymentTotal, calcClosingCashBalance, calcItemDiscounts, calcItemAddons, getInvoicesDiffrence, };
+export * as Calcs from './Calcs';
+export * as Setters from './setters';
+export * as Types from './types';