@darkpos/pricing 1.0.91 → 1.0.93

package/__TEST__/order/order.test.js

@@ -1960,7 +1960,7 @@ describe('Order actions', () => {
     expect(newOrder).toHaveProperty('total', 710.36);
     expect(newOrder).toHaveProperty('subTotal', 775.6);
     expect(newOrder).toHaveProperty('subTotals', {
-      percentage: -116.34,
+      percentage: -116.344,
       tax: 51.09265,
     });
     expect(newOrder.items[0]).toHaveProperty('total', 65.85);
@@ -1971,7 +1971,7 @@ describe('Order actions', () => {
     expect(newOrder.items[5]).toHaveProperty('total', 109.91);
     expect(newOrder.items[0].modifiers[0]._computed).toHaveProperty(
       'amount',
-      -10.785
+      -10.789
     );
     expect(newOrder.items[0].modifiers[1]._computed).toHaveProperty(
       'amount',
@@ -2065,17 +2065,17 @@ describe('Order actions', () => {
 
     const newOrder = pricingService.order.calculate(order);
 
-    expect(newOrder).toHaveProperty('total', 137.93);
+    expect(newOrder).toHaveProperty('total', 137.92);
     expect(newOrder).toHaveProperty('subTotal', 128);
     expect(newOrder).toHaveProperty('subTotals', {
-      tax: 9.92,
+      tax: 9.916,
     });
-    expect(newOrder.items[0]).toHaveProperty('total', 40.95);
+    expect(newOrder.items[0]).toHaveProperty('total', 40.94);
     expect(newOrder.items[1]).toHaveProperty('total', 45.26);
     expect(newOrder.items[2]).toHaveProperty('total', 51.72);
     expect(newOrder.items[0].modifiers[0]._computed).toHaveProperty(
       'amount',
-      2.945
+      2.941
     );
 
     expect(newOrder.items[1].modifiers[0]._computed).toHaveProperty(
@@ -3965,4 +3965,58 @@ describe('Order actions', () => {
     expect(newOrder.items[0].total).toBe(25);
     expect(newOrder.items[0].status).toMatchObject({});
   });
+
+  test('Calculate order with 7% tax, expect correct decimals and rounding', () => {
+    const taxModifier = {
+      compute: {
+        amount: 7,
+        type: 'percentage',
+        action: 'add',
+      },
+      name: 'tax 7%',
+      type: 'tax',
+    };
+
+    const orderItem1 = {
+      price: 4.5,
+      quantity: 1,
+      modifiers: [taxModifier],
+    };
+    const orderItem2 = {
+      price: 4.25,
+      quantity: 1,
+      modifiers: [taxModifier],
+    };
+    const orderItem3 = {
+      price: 6.95,
+      quantity: 1,
+      modifiers: [taxModifier],
+    };
+    const order = { items: [orderItem1, orderItem2, orderItem3] };
+    const newOrder = pricingService.order.calculate(order);
+
+    expect(newOrder).toHaveProperty('total', 16.8);
+    expect(newOrder).toHaveProperty('subTotal', 15.7);
+    expect(newOrder).toHaveProperty('subTotals', {
+      tax: 1.095,
+    });
+
+    expect(newOrder.items[0].modifiers[0]._computed.amount).toEqual(0.311);
+    expect(newOrder.items[0].modifiers[0]._computed.description).toEqual(
+      'tax 7% ($0.31)'
+    );
+    expect(newOrder.items[0].total).toEqual(4.81);
+
+    expect(newOrder.items[1].modifiers[0]._computed.amount).toEqual(0.2975);
+    expect(newOrder.items[1].modifiers[0]._computed.description).toEqual(
+      'tax 7% ($0.30)'
+    );
+    expect(newOrder.items[1].total).toEqual(4.55);
+
+    expect(newOrder.items[2].modifiers[0]._computed.amount).toEqual(0.4865);
+    expect(newOrder.items[2].modifiers[0]._computed.description).toEqual(
+      'tax 7% ($0.49)'
+    );
+    expect(newOrder.items[2].total).toEqual(7.44);
+  });
 });

package/__TEST__/order/pickEndDate.test.js

@@ -1,7 +1,7 @@
 const moment = require('moment-timezone');
 const usePricing = require('../../lib/index');
 
-const pricingService = usePricing({
+const getDefaultSettings = schedules => ({
   store: {
     _settings: {
       schedule: {
@@ -11,6 +11,20 @@ const pricingService = usePricing({
           },
         ],
       },
+      order: {
+        schedules: schedules || [
+          {
+            _id: '682373ef8256034ae1f2c195',
+            dayOfWeek: [2],
+            recommended: 'auto_recommended',
+            addDays: 1,
+            cutDay: 1,
+            skipDays: undefined,
+            readyHour: null,
+            cutHour: null,
+          },
+        ],
+      },
     },
   },
 });
@@ -24,64 +38,68 @@ describe('pickEndDate function', () => {
       readyHour: { hour: 17, minute: 0 },
       cutDay: 2,
     };
+    const pricingServiceTest = usePricing(getDefaultSettings([schedule]));
 
     const now = moment('2024-08-25T15:00:00Z').tz('America/New_York');
     jest.spyOn(moment, 'now').mockImplementation(() => now.valueOf());
 
-    const result = pricingService.store.pickEndDate(schedule);
+    const result = pricingServiceTest.store.pickEndDate();
 
-    expect(result).toBe('2024-08-26T21:00:00Z'); // 2024-08-27 17:00:00 EDT
+    expect(result).toBe('2024-08-26T21:00:00Z');
   });
 
   test('Order falls on a closed day', () => {
     const schedule = {
       addDays: 1,
       readyHour: { hour: 14, minute: 0 },
-      skipDays: [7], // Skip Sunday
+      skipDays: [7],
       cutHour: { hour: 16, minute: 0 },
       cutDay: 2,
     };
 
-    const now = moment('2024-08-27T15:00:00Z').tz('America/New_York'); // Tuesday
+    const now = moment('2024-08-27T15:00:00Z').tz('America/New_York');
 
     jest.spyOn(moment, 'now').mockImplementation(() => now.valueOf());
-    const result = pricingService.store.pickEndDate(schedule);
+    const pricingServiceTest = usePricing(getDefaultSettings([schedule]));
+    const result = pricingServiceTest.store.pickEndDate();
 
-    expect(result).toBe('2024-08-28T18:00:00Z'); // 2024-08-28 14:00:00 EDT
+    expect(result).toBe('2024-08-28T18:00:00Z');
   });
 
   test('Get endDate if today is friday and Saturday and Sunday are skip days', () => {
     const schedule = {
       addDays: 1,
       readyHour: { hour: 17, minute: 0 },
-      skipDays: [6, 7], // Skip Saturday and Sunday
+      skipDays: [6, 7],
       cutHour: { hour: 16, minute: 0 },
       cutDay: 5,
     };
 
-    const now = moment('2024-08-23T15:00:00Z').tz('America/New_York'); // Friday
+    const now = moment('2024-08-23T15:00:00Z').tz('America/New_York');
 
     jest.spyOn(moment, 'now').mockImplementation(() => now.valueOf());
-    const result = pricingService.store.pickEndDate(schedule);
+    const pricingServiceTest = usePricing(getDefaultSettings([schedule]));
+    const result = pricingServiceTest.store.pickEndDate();
 
-    expect(result).toBe('2024-08-26T21:00:00Z'); // 2024-08-26 17:00:00 EDT
+    expect(result).toBe('2024-08-26T21:00:00Z');
   });
 
   test('Order time before cut-off hour', () => {
     const schedule = {
-      addDays: 0, // Same day
+      addDays: 0,
       readyHour: { hour: 17, minute: 0 },
       skipDays: [],
-      cutHour: { hour: 16, minute: 0 }, // Cut-off at 4 PM
+      cutHour: { hour: 16, minute: 0 },
       cutDay: 5,
     };
 
-    const now = moment('2024-08-25T15:00:00Z').tz('America/New_York'); // Friday, before cut-off
+    const now = moment('2024-08-25T15:00:00Z').tz('America/New_York');
 
     jest.spyOn(moment, 'now').mockImplementation(() => now.valueOf());
-    const result = pricingService.store.pickEndDate(schedule);
+    const pricingServiceTest = usePricing(getDefaultSettings([schedule]));
+    const result = pricingServiceTest.store.pickEndDate();
 
-    expect(result).toBe('2024-08-25T21:00:00Z'); // 2024-08-25 17:00:00 EDT
+    expect(result).toBe('2024-08-25T21:00:00Z');
   });
 
   test('Order time after cut-off hour', () => {
@@ -97,12 +115,13 @@ describe('pickEndDate function', () => {
       recommended: 'nothing_recommended',
     };
 
-    const now = moment().tz('America/New_York'); // Friday, after cut-off
+    const now = moment().tz('America/New_York');
 
     jest.spyOn(moment, 'now').mockImplementation(() => now.valueOf());
-    const result = pricingService.store.pickEndDate(schedule);
+    const pricingServiceTest = usePricing(getDefaultSettings([schedule]));
+    const result = pricingServiceTest.store.pickEndDate();
 
-    expect(result).toBe('2024-08-31T21:00:00Z'); // 2024-08-31 17:00:00 EDT
+    expect(result).toBe('2024-08-31T21:00:00Z');
   });
 
   test('Get EndDate, there are skip dates in between', () => {
@@ -117,9 +136,10 @@ describe('pickEndDate function', () => {
     const now = moment('2024-08-25T15:00:00Z').tz('America/New_York');
     jest.spyOn(moment, 'now').mockImplementation(() => now.valueOf());
 
-    const result = pricingService.store.pickEndDate(schedule);
+    const pricingServiceTest = usePricing(getDefaultSettings([schedule]));
+    const result = pricingServiceTest.store.pickEndDate();
 
-    expect(result).toBe('2024-08-26T21:00:00Z'); // 2024-08-26 17:00:00 EDT
+    expect(result).toBe('2024-08-26T21:00:00Z');
   });
 
   test('Get EndDate, Now date is an skip day', () => {
@@ -134,10 +154,12 @@ describe('pickEndDate function', () => {
     const now = moment('2024-09-01T15:00:00Z').tz('America/New_York');
     jest.spyOn(moment, 'now').mockImplementation(() => now.valueOf());
 
-    const result = pricingService.store.pickEndDate(schedule);
+    const pricingServiceTest = usePricing(getDefaultSettings([schedule]));
+    const result = pricingServiceTest.store.pickEndDate();
 
-    expect(result).toBe('2024-09-05T00:00:00Z'); // 2024-09-04 20:00:00 EDT
+    expect(result).toBe('2024-09-05T00:00:00Z');
   });
+
   test('Get EndDate, undefined skipdays', () => {
     const schedule = {
       addDays: 1,
@@ -149,8 +171,72 @@ describe('pickEndDate function', () => {
     const now = moment('2025-05-13T15:00:00Z').tz('America/New_York');
     jest.spyOn(moment, 'now').mockImplementation(() => now.valueOf());
 
-    const result = pricingService.store.pickEndDate(schedule);
+    const pricingServiceTest = usePricing(getDefaultSettings([schedule]));
+    const result = pricingServiceTest.store.pickEndDate();
+
+    expect(result).toBe('2025-05-15T00:00:00Z');
+  });
+
+  test('pickEndDate, skipDays undefined', () => {
+    const pricingServiceSkipDays = usePricing(getDefaultSettings());
+    const now = moment('2025-05-13T15:00:00Z').tz('America/New_York');
+    jest.spyOn(moment, 'now').mockImplementation(() => now.valueOf());
+
+    const result = pricingServiceSkipDays.store.pickEndDate();
+    expect(result).toBe('2025-05-14T15:00:00Z');
+  });
+
+  test('pickEndDate - getRecommendedEndDate, skipDays with dayOfWeek undefined', () => {
+    const pricingServiceSkipDays2 = usePricing({
+      store: {
+        _settings: {
+          order: {
+            endDate: {
+              readySchedule: [
+                {
+                  _id: '682373ef8256034ae1f2c195',
+                  dayOfWeek: null,
+                  recommended: 'auto_recommended',
+                  addDays: 1,
+                  cutDay: 1,
+                  skipDays: [1],
+                  readyHour: null,
+                  cutHour: null,
+                },
+              ],
+            },
+          },
+        },
+      },
+    });
+    const now = moment('2025-05-13T15:00:00Z').tz('America/New_York');
+    jest.spyOn(moment, 'now').mockImplementation(() => now.valueOf());
+
+    const result = pricingServiceSkipDays2.store.pickEndDate();
+
+    expect(result).toBe('2025-05-13T15:00:00Z');
+  });
+
+  test('pickEndDate - getRecommendedEndDate, skipDays with one day', () => {
+    const pricingServiceSkipDays3 = usePricing(
+      getDefaultSettings([
+        {
+          _id: '682373ef8256034ae1f2c195',
+          dayOfWeek: [2],
+          recommended: 'auto_recommended',
+          addDays: 1,
+          cutDay: 1,
+          skipDays: [1],
+          readyHour: null,
+          cutHour: null,
+        },
+      ])
+    );
+    const now = moment('2025-05-13T15:00:00Z').tz('America/New_York');
+    jest.spyOn(moment, 'now').mockImplementation(() => now.valueOf());
+
+    const result = pricingServiceSkipDays3.store.pickEndDate();
 
-    expect(result).toBe('2025-05-15T00:00:00Z'); // 2024-09-04 20:00:00 EDT
+    expect(result).toBe('2025-05-14T15:00:00Z');
   });
 });

package/lib/item/calculate.js

@@ -9,6 +9,7 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
       typeof opts.amountToPay === 'number' ? opts.amountToPay : 0;
     const paymentMethod = opts.paymentMethod || null;
     const paymentType = opts.paymentType || null;
+    const isPrepay = opts.isPrepay || false;
     const startRequestDate = opts.startRequestDate || null;
     const endRequestDate = opts.endRequestDate || null;
     const lockPaymentModifiers = !!opts.lockPaymentModifiers;
@@ -70,6 +71,7 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
             paymentModifier: modifier,
             paymentMethod,
             paymentType,
+            isPrepay,
           })
       )
       .filter(paymentModifier => {
@@ -116,6 +118,8 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
       let prvPrice = 0;
       let prvSort;
 
+      let accumulatedAmount = 0;
+
       for (const modifier of sortedModifiers) {
         const included = modifierActions.isIncluded(modifier);
         const direct = modifierActions.isDirect(modifier);
@@ -132,7 +136,10 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
         if (modifierActions.isPaymentModifier(modifier)) {
           _modifier = modifierActions.calculatePaymentModifier({
             paymentModifier: modifier,
-            amountToPay,
+            amountToPay:
+              accumulatedAmount < 0 && amountToPay > 0
+                ? math.add(amountToPay, math.abs(accumulatedAmount))
+                : amountToPay,
             itemBalance:
               typeof item.totalPaid === 'number' && item.totalPaid > 0
                 ? actions.getItemsBalance({ items: [item] })
@@ -140,6 +147,7 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
             paymentMethod,
             paymentType,
             paymentId,
+            isPrepay,
           });
         }
 
@@ -168,6 +176,7 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
           computedAmount = _computed.amount;
 
         prvPrice = math.add(prvPrice, math.div(_computed.amount, quantity));
+        accumulatedAmount = math.add(accumulatedAmount, _computed.amount);
         prvSort = sort;
 
         ({ subTotals, total } = actions.getTotals({

package/lib/item/getTotalsDifference.js

@@ -10,5 +10,11 @@ module.exports = ({ utils }) =>
       }),
       { total: 0, subTotalsTotal: 0 }
     );
-    return utils.math.sub(subTotalsTotal, total);
+    const difference = utils.math.sub(subTotalsTotal, total);
+
+    if (difference < -0.005) return -0.004;
+    if (difference === -0.005) return 0.005;
+    if (difference > 0.005) return 0.004;
+    if (difference === 0.005) return -0.005;
+    return 0;
   };

package/lib/item/hasPaymentMethodType.js

@@ -1,5 +1,10 @@
 module.exports = ({ modifierActions }) =>
-  function hasPaymentMethodType({ item, paymentMethod, paymentType }) {
+  function hasPaymentMethodType({
+    item,
+    paymentMethod,
+    paymentType,
+    isPrepay,
+  }) {
     if (
       !item ||
       !Array.isArray(item.modifiers) ||
@@ -12,6 +17,7 @@ module.exports = ({ modifierActions }) =>
         paymentModifier: modifier,
         paymentMethod,
         paymentType,
+        isPrepay,
       })
     );
   };

package/lib/modifier/areConditionsMet.js

@@ -92,6 +92,9 @@ module.exports = ({ actions, utils }) => {
               return false;
             case 'paymentTypes':
               return false;
+            case 'payment': {
+              return false;
+            }
             default:
               return false;
           }

package/lib/modifier/calculatePaymentModifier.js

@@ -8,12 +8,14 @@ module.exports = ({ actions, utils }) => {
     paymentMethod,
     paymentType,
     paymentId,
+    isPrepay,
   }) {
     if (
       !actions.hasPaymentMethodType({
         paymentModifier: paymentModifierParam,
         paymentMethod,
         paymentType,
+        isPrepay,
       })
     )
       return undefined;

package/lib/modifier/hasPaymentMethodType.js

@@ -3,12 +3,27 @@ module.exports = ({ actions }) =>
     paymentModifier,
     paymentMethod,
     paymentType,
+    isPrepay,
   }) {
-    return (
-      actions.isPaymentModifier(paymentModifier) &&
-      paymentModifier.conditions.rules.some(
-        rule =>
-          rule.value.includes(paymentMethod) || rule.value.includes(paymentType)
+    if (!actions.isPaymentModifier(paymentModifier)) return false;
+
+    if (actions.isPrepayModifier(paymentModifier) && !isPrepay) return false;
+
+    if (
+      actions.isPaymentTypeModifier(paymentModifier) &&
+      !paymentModifier.conditions.rules.some(rule =>
+        rule.value.includes(paymentType)
       )
-    );
+    )
+      return false;
+
+    if (
+      actions.isPaymentMethodModifier(paymentModifier) &&
+      !paymentModifier.conditions.rules.some(rule =>
+        rule.value.includes(paymentMethod)
+      )
+    )
+      return false;
+
+    return true;
   };

package/lib/modifier/index.js

@@ -163,6 +163,7 @@ const isOrderUseValid = require('./isOrderUseValid');
 const getMaxItemQuantity = require('./getMaxItemQuantity');
 const createDescription = require('./createDescription');
 const patchModifier = require('./patchModifier');
+const isPrepayModifier = require('./isPrepayModifier');
 
 const modifierActions = (deps = {}) => {
   const actions = {};
@@ -339,6 +340,7 @@ const modifierActions = (deps = {}) => {
     getCreditModifiersTotalEntities: getCreditModifiersTotalEntities(innerDeps),
     createDescription: createDescription(innerDeps),
     patchModifier: patchModifier(innerDeps),
+    isPrepayModifier: isPrepayModifier(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/modifier/isPaymentModifier.js

@@ -2,6 +2,7 @@ module.exports = ({ actions }) =>
   function isPaymentModifier(modifier) {
     return (
       actions.isPaymentTypeModifier(modifier) ||
-      actions.isPaymentMethodModifier(modifier)
+      actions.isPaymentMethodModifier(modifier) ||
+      actions.isPrepayModifier(modifier)
     );
   };

package/lib/modifier/isPercentage.js

@@ -1,6 +1,6 @@
 module.exports = ({ constants }) => {
   const { Modifier } = constants;
-  return function isFixed(modifier) {
+  return function isPercentage(modifier) {
     return !!(
       modifier &&
       modifier.compute &&

package/lib/modifier/isPrepayModifier.js

@@ -0,0 +1,11 @@
+module.exports = () =>
+  function isPrepayModifier(modifier) {
+    return !!(
+      modifier &&
+      modifier.conditions &&
+      Array.isArray(modifier.conditions.rules) &&
+      modifier.conditions.rules.some(
+        condition => condition.key === 'payment' && condition.value === 'prepay'
+      )
+    );
+  };

package/lib/modifier/sort.js

@@ -2,7 +2,6 @@
 module.exports = ({ actions }) => {
   function compareValues(key, order = 'asc') {
     return function innerSort(a, b) {
-      // property doesn't exist on either object
       const aVal = actions.getProperty(a, key);
       const bVal = actions.getProperty(b, key);
 
@@ -13,38 +12,27 @@ module.exports = ({ actions }) => {
       const bIsCalculatedPaymentModifier =
         actions.isCalculatedPaymentModifier(b);
 
-      if (aIsCalculatedPaymentModifier && bIsPaymentModifier && aVal === null) {
-        return -1;
-      }
-      if (bIsCalculatedPaymentModifier && aIsPaymentModifier && bVal === null) {
-        return -1;
-      }
+      const aIsPercentageNoSort = actions.isPercentage(a) && aVal == null;
+      const bIsPercentageNoSort = actions.isPercentage(b) && bVal == null;
 
-      if (
-        (aIsPaymentModifier || aIsCalculatedPaymentModifier) &&
-        aVal === null
-      ) {
+      if (bIsPaymentModifier && aIsPercentageNoSort && !bIsPercentageNoSort)
         return 1;
-      }
-
-      if (
-        (bIsPaymentModifier || bIsCalculatedPaymentModifier) &&
-        bVal === null
-      ) {
-        return 1;
-      }
-
-      if (aVal == null && bVal === null) {
-        return 0;
-      }
+      if (aIsPaymentModifier && !aIsPercentageNoSort && bIsPercentageNoSort)
+        return -1;
 
-      if (aVal == null) {
+      if (aIsCalculatedPaymentModifier && bIsPaymentModifier && aVal === null)
+        return -1;
+      if (bIsCalculatedPaymentModifier && aIsPaymentModifier && bVal === null)
         return -1;
-      }
 
-      if (bVal === null) {
+      if ((aIsPaymentModifier || aIsCalculatedPaymentModifier) && aVal === null)
+        return 1;
+      if ((bIsPaymentModifier || bIsCalculatedPaymentModifier) && bVal === null)
         return 1;
-      }
+
+      if (aVal == null && bVal === null) return 0;
+      if (aVal == null) return -1;
+      if (bVal === null) return 1;
 
       const varA = typeof aVal === 'string' ? aVal.toUpperCase() : aVal;
       const varB = typeof bVal === 'string' ? bVal.toUpperCase() : bVal;
@@ -52,6 +40,7 @@ module.exports = ({ actions }) => {
       let comparison = 0;
       if (varA > varB) comparison = 1;
       else if (varA < varB) comparison = -1;
+
       return order === 'desc' ? comparison * -1 : comparison;
     };
   }

package/lib/order/calculate.js

@@ -114,16 +114,11 @@ module.exports = ({
         );
       }
     };
-
     if (calculatedItems.length > 0) {
-      let difference = itemActions.getTotalsDifference({
+      const difference = itemActions.getTotalsDifference({
         items: calculatedItems,
       });
 
-      if (difference < 0) {
-        difference = difference < -0.005 ? 0 : utils.math.abs(difference);
-      }
-
       const itemIndex = calculatedItems.findIndex(
         item =>
           !itemActions.isFullyPaid(item) &&
@@ -134,7 +129,7 @@ module.exports = ({
           )
       );
 
-      if (itemIndex >= 0 && difference >= 0.005) {
+      if (itemIndex >= 0 && difference !== 0) {
         calculatedItems[itemIndex] = itemActions.patchItem({
           item: calculatedItems[itemIndex],
           difference,

package/lib/order/getTotals.js

@@ -1,29 +1,28 @@
 module.exports = ({ utils }) => {
   const { math } = utils;
+
   return function getTotals(orders) {
-    if (!Array.isArray(orders)) return { total: 0, subTotals: {} };
-    return orders
-      .filter(each => !!each.parentId || !each.isParent)
-      .reduce(
-        (acc, order) => {
-          const subTotals = {};
-          const { subTotals: orderSubTotals } = order;
-          if (orderSubTotals) {
-            const keys = Object.keys(orderSubTotals);
-            // eslint-disable-next-line no-restricted-syntax
-            for (const key of keys)
-              subTotals[key] = math.add(
-                acc.subTotals[key] || 0,
-                orderSubTotals[key]
-              );
+    if (!Array.isArray(orders)) {
+      return { total: 0, subTotal: 0, subTotals: {} };
+    }
+
+    return orders.reduce(
+      (acc, order) => {
+        const { subTotals: orderSubTotals, subTotal = 0, total = 0 } = order;
+
+        if (orderSubTotals) {
+          // eslint-disable-next-line no-restricted-syntax
+          for (const [key, value] of Object.entries(orderSubTotals)) {
+            acc.subTotals[key] = math.add(acc.subTotals[key] || 0, value);
           }
+        }
+
+        acc.total = math.add(acc.total, total);
+        acc.subTotal = math.add(acc.subTotal, subTotal);
 
-          return {
-            total: math.add(acc.total, order.total),
-            subTotals,
-          };
-        },
-        { total: 0, subTotals: {} }
-      );
+        return acc;
+      },
+      { total: 0, subTotal: 0, subTotals: {} }
+    );
   };
 };