@darkpos/pricing 1.0.46 → 1.0.48

package/__TEST__/item.test.js

@@ -282,4 +282,258 @@ describe('Item actions', () => {
       _xincluded: 0,
     });
   });
+
+  test('CU-86duwyvrr: Calculate item with modifier.extractCalculatedvalue=true percentageDiscount16', () => {
+    const percentageDiscount16 = {
+      compute: {
+        amount: 16,
+        type: 'percentage',
+        action: 'subtract',
+      },
+      properties: {
+        extractCalculatedValue: true,
+      },
+      name: 'percentageDiscount16',
+      type: 'discount',
+    };
+
+    const orderItem = {
+      price: 116,
+      quantity: 1,
+      modifiers: [percentageDiscount16],
+    };
+    const newItem = pricingService.item.calculate(orderItem);
+
+    expect(newItem).toHaveProperty('total', 116);
+    expect(newItem).toHaveProperty('price', 116);
+    expect(newItem.modifiers[0]).toHaveProperty('_computed', {
+      amount: -22.095238095238095,
+      description: 'percentageDiscount16 (-$22.10)',
+    });
+
+    expect(newItem).toHaveProperty('subTotals', {
+      discount: -22.095238095238095,
+      _included: 0,
+      _xincluded: -22.095238095238095,
+      _direct: 0,
+      _xdirect: -22.095238095238095,
+      _simple: 138.0952380952381,
+      _actual: 138.0952380952381,
+    });
+  });
+
+  test('CU-86duwyvrr: Calculate item with modifier.extractCalculatedvalue=true percentageFee16', () => {
+    const percentageFee16 = {
+      compute: {
+        amount: 16,
+        type: 'percentage',
+        action: 'add',
+      },
+      properties: {
+        extractCalculatedValue: true,
+      },
+      name: 'percentageFee16',
+      type: 'tax',
+    };
+
+    const orderItem = { price: 116, quantity: 1, modifiers: [percentageFee16] };
+    const newItem = pricingService.item.calculate(orderItem);
+
+    expect(newItem).toHaveProperty('total', 116);
+    expect(newItem).toHaveProperty('price', 116);
+    expect(newItem.modifiers[0]).toHaveProperty('_computed', {
+      amount: 16,
+      description: 'percentageFee16 ($16.00)',
+    });
+
+    expect(newItem).toHaveProperty('subTotals', {
+      tax: 16,
+      _included: 0,
+      _xincluded: 16,
+      _direct: 0,
+      _xdirect: 16,
+      _simple: 100,
+      _actual: 100,
+    });
+  });
+
+  test('CU-86duwyvrr: Calculate item with modifier.extractCalculatedvalue=true fixedDiscount16', () => {
+    const fixedDiscount16 = {
+      compute: {
+        amount: 16,
+        type: 'fixed',
+        action: 'subtract',
+      },
+      properties: {
+        extractCalculatedValue: true,
+      },
+      name: 'fixedDiscount16',
+      type: 'discount',
+    };
+
+    const orderItem = {
+      price: 116,
+      quantity: 1,
+      modifiers: [fixedDiscount16],
+    };
+    const newItem = pricingService.item.calculate(orderItem);
+
+    expect(newItem).toHaveProperty('total', 116);
+    expect(newItem).toHaveProperty('price', 116);
+    expect(newItem.modifiers[0]).toHaveProperty('_computed', {
+      amount: -16,
+      description: 'fixedDiscount16 (-$16.00)',
+    });
+
+    expect(newItem).toHaveProperty('subTotals', {
+      discount: -16,
+      _included: 0,
+      _xincluded: -16,
+      _direct: 0,
+      _xdirect: -16,
+      _simple: 132,
+      _actual: 132,
+    });
+  });
+
+  test('CU-86duwyvrr: Calculate item with modifier.extractCalculatedvalue=true fixedFee16', () => {
+    const fixedFee16 = {
+      compute: {
+        amount: 16,
+        type: 'fixed',
+        action: 'add',
+      },
+      properties: {
+        extractCalculatedValue: true,
+      },
+      name: 'fixedFee16',
+      type: 'tax',
+    };
+
+    const orderItem = {
+      price: 116,
+      quantity: 1,
+      modifiers: [fixedFee16],
+    };
+    const newItem = pricingService.item.calculate(orderItem);
+
+    expect(newItem).toHaveProperty('total', 116);
+    expect(newItem).toHaveProperty('price', 116);
+    expect(newItem.modifiers[0]).toHaveProperty('_computed', {
+      amount: 16,
+      description: 'fixedFee16 ($16.00)',
+    });
+
+    expect(newItem).toHaveProperty('subTotals', {
+      tax: 16,
+      _included: 0,
+      _xincluded: 16,
+      _direct: 0,
+      _xdirect: 16,
+      _simple: 100,
+      _actual: 100,
+    });
+  });
+
+  test('CU-86duwyvrr: Calculate item with modifier.extractCalculatedvalue=true fixedFee16 and other fixed fee of 10%', () => {
+    const fixedFee16 = {
+      compute: {
+        amount: 16,
+        type: 'fixed',
+        action: 'add',
+      },
+      properties: {
+        extractCalculatedValue: true,
+      },
+      name: 'fixedFee16',
+      type: 'tax',
+    };
+
+    const fixedFee10 = {
+      compute: {
+        amount: 10,
+        type: 'fixed',
+        action: 'add',
+      },
+      name: 'fixedFee10',
+      type: 'tax',
+    };
+
+    const orderItem = {
+      price: 116,
+      quantity: 1,
+      modifiers: [fixedFee16, fixedFee10],
+    };
+    const newItem = pricingService.item.calculate(orderItem);
+
+    expect(newItem).toHaveProperty('total', 126);
+    expect(newItem).toHaveProperty('price', 116);
+    expect(newItem.modifiers[0]).toHaveProperty('_computed', {
+      amount: 16,
+      description: 'fixedFee16 ($16.00)',
+    });
+
+    expect(newItem).toHaveProperty('subTotals', {
+      tax: 26,
+      _included: 0,
+      _xincluded: 26,
+      _direct: 0,
+      _xdirect: 26,
+      _simple: 100,
+      _actual: 100,
+    });
+  });
+
+  test('CU-86duwyvrr: Calculate item with modifier.extractCalculatedvalue=true fixedFee16 and other percentage fee of 10%', () => {
+    const fixedFee16 = {
+      compute: {
+        amount: 16,
+        type: 'fixed',
+        action: 'add',
+      },
+      properties: {
+        extractCalculatedValue: true,
+      },
+      name: 'fixedFee16',
+      type: 'tax',
+    };
+
+    const percentageFee10 = {
+      compute: {
+        amount: 10,
+        type: 'percentage',
+        action: 'add',
+      },
+      name: 'percentageFee10',
+      type: 'tax',
+    };
+
+    const orderItem = {
+      price: 116,
+      quantity: 1,
+      modifiers: [fixedFee16, percentageFee10],
+    };
+    const newItem = pricingService.item.calculate(orderItem);
+
+    expect(newItem).toHaveProperty('total', 126);
+    expect(newItem).toHaveProperty('price', 116);
+    expect(newItem.modifiers[0]).toHaveProperty('_computed', {
+      amount: 16,
+      description: 'fixedFee16 ($16.00)',
+    });
+    expect(newItem.modifiers[1]).toHaveProperty('_computed', {
+      amount: 10,
+      description: 'percentageFee10 ($10.00)',
+    });
+
+    expect(newItem).toHaveProperty('subTotals', {
+      tax: 26,
+      _included: 0,
+      _xincluded: 26,
+      _direct: 0,
+      _xdirect: 26,
+      _simple: 100,
+      _actual: 100,
+    });
+  });
 });

package/__TEST__/order/addItem.test.js

@@ -26,7 +26,11 @@ describe('addItem function', () => {
     };
 
     // Call the function
-    const [updatedOrder, itemIndex, addedItem] = addItem({
+    const {
+      updatedOrder,
+      itemIndex,
+      item: addedItem,
+    } = addItem({
       order,
       item,
       itemIndex: -1, // No existing item in order
@@ -67,7 +71,11 @@ describe('addItem function', () => {
     };
 
     // Call the function
-    const [updatedOrder, itemIndex, addedItem] = addItem({
+    const {
+      updatedOrder,
+      itemIndex,
+      item: addedItem,
+    } = addItem({
       order,
       item,
       itemIndex: -1, // Assuming no explicit index
@@ -99,7 +107,7 @@ describe('addItem function', () => {
     };
 
     // Call the function with an overridden quantity
-    const [updatedOrder, , addedItem] = addItem({
+    const { updatedOrder, item: addedItem } = addItem({
       order,
       item,
       itemIndex: -1, // Assuming no explicit index
@@ -179,7 +187,7 @@ describe('addItem function', () => {
     };
 
     // Call the function
-    const [updatedOrder] = addItem({
+    const { updatedOrder } = addItem({
       order,
       item,
       itemIndex: -1, // Assuming no explicit index

package/__TEST__/order/order.test.js

@@ -1,14 +1,6 @@
 const usePricing = require('../../index');
 const mockStores = require('../mocks/stores');
 
-const orderNotPaid = require('../mocks/unpaid/order-not-paid.json');
-const orderModifiersNotPaid = require('../mocks/unpaid/order-modifiers.json');
-const inputItemsNotPaidOrder = require('../mocks/unpaid/input-items.json');
-
-const orderPartiallyPaid = require('../mocks/partially-paid/order-partially-paid.json');
-const orderModifiersPartiallyPaid = require('../mocks/partially-paid/order-modifiers.json');
-const inputItemsPartiallyPaidOrder = require('../mocks/partially-paid/input-items.json');
-
 const orderCredit = require('../mocks/order-credit.json');
 const { Types } = require('../../lib/constants/Modifier/Compute');
 
@@ -2574,4 +2566,58 @@ describe('Order actions', () => {
     expect(subOrders.length).toBe(0);
     expect(newParentOrder.orders).toBe(undefined);
   });
+
+  test('Get calculated Order, multiple items and indirect modifiers #2 toNeareastMultiple', () => {
+    const pricingService2 = usePricing({
+      store: { _settings: { localization: { nearestMultiple: '0.5' } } },
+    });
+
+    const item1 = {
+      _id: 1,
+      price: 15.99,
+      quantity: 1,
+    };
+    const item2 = {
+      _id: 2,
+      price: 4.65,
+      quantity: 1,
+    };
+    const modifier1 = {
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'percentage',
+      },
+      name: 'modifier1',
+      type: 'discount',
+    };
+
+    const order = { items: [item1, item2], modifiers: [modifier1] };
+    const newOrder = pricingService2.order.calculate(order);
+    expect(newOrder).toHaveProperty('total', 19);
+    expect(newOrder).toHaveProperty('subTotal', 20.64);
+    expect(newOrder).toHaveProperty('subTotals', {
+      discount: -2.064,
+    });
+    expect(newOrder.items[0]).toHaveProperty('total', 14.81);
+    expect(newOrder.items[0]).toHaveProperty('subTotals', {
+      discount: -1.599,
+      _included: 0,
+      _xincluded: -1.599,
+      _direct: 0,
+      _xdirect: -1.599,
+      _simple: 15.99,
+      _actual: 15.99,
+    });
+    expect(newOrder.items[1]).toHaveProperty('total', 4.19);
+    expect(newOrder.items[1]).toHaveProperty('subTotals', {
+      discount: -0.465,
+      _included: 0,
+      _xincluded: -0.465,
+      _direct: 0,
+      _xdirect: -0.465,
+      _simple: 4.65,
+      _actual: 4.65,
+    });
+  });
 });

package/lib/item/calculate.js

@@ -26,7 +26,7 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
       _actual: 0,
     };
 
-    const price = parseFloat(item.price);
+    const price = parseFloat(actions.getPriceWithoutModifiers({ item }));
     const quantity = parseInt(item.quantity, 10);
     subTotals._simple = math.mul(price, quantity);
 

package/lib/item/getItemsBalance.js

@@ -4,6 +4,5 @@ module.exports = ({ utils, actions }) =>
       (acc, item) => utils.math.add(acc, actions.getBalance({ item })),
       0
     );
-    console.log({ result });
     return result;
   };

package/lib/item/getPriceWithoutModifiers.js

@@ -0,0 +1,28 @@
+module.exports = ({ modifierActions }) =>
+  /* eslint-disable no-restricted-syntax */
+  function getPriceWithoutModifiers({ item }) {
+    if (
+      !item ||
+      !Array.isArray(item.modifiers) ||
+      typeof item.price !== 'number'
+    )
+      return item.price;
+
+    const calculatedModifiers = item.modifiers.filter(modifier =>
+      modifierActions.isExtractCalculatedValue({ modifier })
+    );
+
+    if (calculatedModifiers.length === 0) return item.price;
+
+    const sortedModifiers = modifierActions.sort([...calculatedModifiers]);
+    let computedPrice = item.price;
+
+    for (const modifier of sortedModifiers) {
+      computedPrice = modifierActions.getPriceWithoutModifier({
+        itemPrice: computedPrice,
+        modifier,
+      });
+    }
+
+    return computedPrice;
+  };

package/lib/item/getTotalNeareastDifference.js

@@ -0,0 +1,16 @@
+module.exports = ({ utils, settings }) =>
+  function getTotalNeareastDifference({ items }) {
+    const { total } = items.reduce(
+      (acc, item) => ({
+        total: utils.math.add(acc.total, item.total),
+      }),
+      { total: 0 }
+    );
+
+    const totalToNeareast = utils.math.toNearestMultiple(
+      total,
+      settings.localization.nearestMultiple
+    );
+
+    return utils.math.sub(totalToNeareast, total);
+  };

package/lib/item/getTotalsDifference.js

@@ -0,0 +1,14 @@
+module.exports = ({ utils }) =>
+  function getTotalsDifference({ items }) {
+    const { total, subTotalsTotal } = items.reduce(
+      (acc, item) => ({
+        total: utils.math.add(acc.total, item.total),
+        subTotalsTotal: utils.math.add(
+          acc.subTotalsTotal,
+          utils.math.add(item.subTotals._actual, item.subTotals._xincluded)
+        ),
+      }),
+      { total: 0, subTotalsTotal: 0 }
+    );
+    return utils.math.sub(subTotalsTotal, total);
+  };

package/lib/item/index.js

@@ -41,6 +41,9 @@ const hasPaymentModifierWithPaymentId = require('./hasPaymentModifierWithPayment
 const getBalance = require('./getBalance');
 const getPipeModifiers = require('./getPipeModifiers');
 const getInvalidRequiredModifiers = require('./getInvalidRequiredModifiers');
+const getPriceWithoutModifiers = require('./getPriceWithoutModifiers');
+const getTotalsDifference = require('./getTotalsDifference');
+const getTotalNeareastDifference = require('./getTotalNeareastDifference');
 
 const itemActions = (deps = {}) => {
   const actions = {};
@@ -95,6 +98,9 @@ const itemActions = (deps = {}) => {
     getBalance: getBalance(innerDeps),
     getPipeModifiers: getPipeModifiers(innerDeps),
     getInvalidRequiredModifiers: getInvalidRequiredModifiers(innerDeps),
+    getPriceWithoutModifiers: getPriceWithoutModifiers(innerDeps),
+    getTotalsDifference: getTotalsDifference(innerDeps),
+    getTotalNeareastDifference: getTotalNeareastDifference(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/item/isFullyPaid.js

@@ -2,5 +2,5 @@ module.exports = () =>
   function isFullyPaid({ item }) {
     if (!item) return false;
 
-    return item.status.paid.value;
+    return item.status && item.status.paid.value;
   };

package/lib/modifier/getPriceWithoutModifier.js

@@ -0,0 +1,38 @@
+module.exports = ({ constants, utils }) => {
+  const { Modifier } = constants;
+  const { math } = utils;
+
+  return function getPriceWithoutModifier({ itemPrice, modifier }) {
+    if (
+      !modifier ||
+      !modifier.compute ||
+      !modifier.compute.type ||
+      typeof itemPrice !== 'number'
+    )
+      return itemPrice;
+
+    if (modifier.compute.action === Modifier.Compute.Actions.ADD) {
+      if (modifier.compute.type === Modifier.Compute.Types.PERCENTAGE)
+        return math.div(
+          itemPrice,
+          math.add(1, math.div(modifier.compute.amount, 100))
+        );
+
+      if (modifier.compute.type === Modifier.Compute.Types.FIXED)
+        return math.sub(itemPrice, modifier.compute.amount);
+    }
+
+    if (modifier.compute.action === Modifier.Compute.Actions.SUBTRACT) {
+      if (modifier.compute.type === Modifier.Compute.Types.PERCENTAGE)
+        return math.div(
+          itemPrice,
+          math.sub(1, math.div(modifier.compute.amount, 100))
+        );
+
+      if (modifier.compute.type === Modifier.Compute.Types.FIXED)
+        return math.add(itemPrice, modifier.compute.amount);
+    }
+
+    return itemPrice;
+  };
+};

package/lib/modifier/index.js

@@ -146,6 +146,8 @@ const calculatePaymentDiscountModifier = require('./calculatePaymentDiscountModi
 const calculatePaymentFeeModifier = require('./calculatePaymentFeeModifier');
 const isCalculatedPaymentModifier = require('./isCalculatedPaymentModifier');
 const isChild = require('./isChild');
+const isExtractCalculatedValue = require('./isExtractCalculatedValue');
+const getPriceWithoutModifier = require('./getPriceWithoutModifier');
 
 const modifierActions = (deps = {}) => {
   const actions = {};
@@ -305,6 +307,8 @@ const modifierActions = (deps = {}) => {
     calculatePaymentFeeModifier: calculatePaymentFeeModifier(innerDeps),
     isCalculatedPaymentModifier: isCalculatedPaymentModifier(innerDeps),
     isChild: isChild(innerDeps),
+    isExtractCalculatedValue: isExtractCalculatedValue(innerDeps),
+    getPriceWithoutModifier: getPriceWithoutModifier(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/modifier/isExtractCalculatedValue.js

@@ -0,0 +1,5 @@
+module.exports = () =>
+  function isExtractCalculatedValue({ modifier }) {
+    if (!modifier || !modifier.properties) return false;
+    return modifier.properties.extractCalculatedValue;
+  };

package/lib/order/addItem.js

@@ -187,6 +187,7 @@ module.exports = ({ actions, itemActions, modifierActions, settings, _ }) => {
       !_.isEmpty(orderItem.modifiers)
     )
       requiredModifiers = getUnselectedModifiers(orderItem, requiredModifiers);
+
     if (!_.isEmpty(requiredModifiers)) {
       modifiersToAdd.push(
         ...requiredModifiers.filter(
@@ -213,17 +214,23 @@ module.exports = ({ actions, itemActions, modifierActions, settings, _ }) => {
     let [nextOrder, nextItemIndex] = params;
     const [, , nextItem] = params;
 
+    const overrideModifiers = modifiersToAdd.filter(modToAdd =>
+      modifierActions.isOverride(modToAdd)
+    );
+
     if (modifiersToAdd.length) {
-      nextOrder = modifiersToAdd.reduce(
-        (acc, modifier) =>
-          actions.addItemModifier({
-            itemIndex: nextItemIndex,
-            order: acc,
-            modifier,
-            cache,
-          }),
-        nextOrder
-      );
+      nextOrder = modifiersToAdd
+        .filter(modToAdd => !modifierActions.isOverride(modToAdd))
+        .reduce(
+          (acc, modifier) =>
+            actions.addItemModifier({
+              itemIndex: nextItemIndex,
+              order: acc,
+              modifier,
+              cache,
+            }),
+          nextOrder
+        );
     }
 
     const { reArrangedOrder, newIndex } = reArrangeNewItem({
@@ -243,6 +250,11 @@ module.exports = ({ actions, itemActions, modifierActions, settings, _ }) => {
       nextOrder.items.splice(idxToRemove, 1);
     }
 
-    return [nextOrder, nextItemIndex, nextItem];
+    return {
+      updatedOrder: nextOrder,
+      itemIndex: nextItemIndex,
+      item: nextItem,
+      overrideModifiers,
+    };
   };
 };

package/lib/order/addItemModifier.js

@@ -244,7 +244,7 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
 
     if (modifierActions.hasRelatedItems(modifier)) {
       order = modifier.properties.group.items.reduce((acc, each) => {
-        const [nextOrder] = actions.addItem({
+        const { updatedOrder: nextOrder } = actions.addItem({
           item: {
             ...each,
             itemId: each._id,

package/lib/order/calculate.js

@@ -2,7 +2,14 @@
 /**
  * return calculated Order
  */
-module.exports = ({ _, actions, itemActions, modifierActions, utils }) =>
+module.exports = ({
+  _,
+  actions,
+  itemActions,
+  modifierActions,
+  utils,
+  storeActions,
+}) =>
   function calculateorder(inputOrder, opts = {}) {
     if (!inputOrder) return inputOrder;
     const order = _.cloneDeep(inputOrder);
@@ -97,24 +104,28 @@ module.exports = ({ _, actions, itemActions, modifierActions, utils }) =>
 
     const calculatedItemWIM = itemActions.calculate(itemsWIM, options);
 
-    if (calculatedItemWIM.length > 1) {
-      const { total, subTotalsTotal } = calculatedItemWIM.reduce(
-        (acc, item) => ({
-          total: utils.math.add(acc.total, item.total),
-          subTotalsTotal: utils.math.add(
-            acc.subTotalsTotal,
-            utils.math.add(item.subTotals._actual, item.subTotals._xincluded)
-          ),
-        }),
-        { total: 0, subTotalsTotal: 0 }
-      );
-      const difference = utils.math.sub(subTotalsTotal, total);
-
-      if (difference > 0) {
+    const addToItemTotal = difference => {
+      if (difference > 0 && calculatedItemWIM.length) {
         calculatedItemWIM[0].total = utils.math.toDecimalPlaces(
           utils.math.add(calculatedItemWIM[0].total, difference)
         );
       }
+    };
+
+    if (calculatedItemWIM.length > 1) {
+      const difference = itemActions.getTotalsDifference({
+        items: calculatedItemWIM,
+      });
+
+      addToItemTotal(difference);
+    }
+
+    if (storeActions.isNeareastMultiple() && calculatedItemWIM.length > 0) {
+      const difference = itemActions.getTotalNeareastDifference({
+        items: calculatedItemWIM,
+      });
+
+      if (difference > 0) addToItemTotal(difference);
     }
 
     return {

package/lib/order/updateItemQuantity.js

@@ -14,7 +14,7 @@ module.exports = ({ actions, settings, _ }) => {
       const updatedQuantity = reset
         ? quantity
         : parseInt(`${item.quantity}${quantity}`, 10);
-      return actions.updateItem({
+      const { updatedOrder } = actions.updateItem({
         order,
         itemIndex,
         item: {
@@ -22,6 +22,7 @@ module.exports = ({ actions, settings, _ }) => {
           quantity: updatedQuantity,
         },
       });
+      return updatedOrder;
     }
     if (isBefore) {
       return actions.addItem({

package/lib/store/index.js

@@ -1,6 +1,7 @@
 //
 const pickEndDate = require('./pickEndDate');
 const getRecommendedEndDate = require('./getRecommendedEndDate');
+const isNeareastMultiple = require('./isNeareastMultiple');
 
 const storeActions = (deps = {}) => {
   const actions = {};
@@ -13,6 +14,7 @@ const storeActions = (deps = {}) => {
   const freezedActions = Object.freeze({
     pickEndDate: pickEndDate(innerDeps),
     getRecommendedEndDate: getRecommendedEndDate(innerDeps),
+    isNeareastMultiple: isNeareastMultiple(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/store/isNeareastMultiple.js

@@ -0,0 +1,6 @@
+module.exports = ({ settings }) =>
+  function isNeareastMultiple() {
+    return (
+      settings && settings.localization && settings.localization.nearestMultiple
+    );
+  };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.46",
+  "version": "1.0.48",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -16,13 +16,14 @@
     "test:order": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/order/order.test.js",
     "test:validateConditions": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/order/validateConditionsCalculate.test.js",
     "test:hasModifier": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/modifier/hasModifier.test.js",
+    "test:item": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/item.test.js",
     "lint": "eslint --quiet lib/"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@darkpos/utils": "1.0.10",
+    "@darkpos/utils": "^1.0.11",
     "lodash": "^4.17.21",
     "moment-timezone": "^0.5.34"
   },
@@ -39,5 +40,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "e048578555dc3d2147bbc4e5b4e0d55809261dcc"
+  "gitHead": "4706909fded1e1083441ae48c8dc154cd569a48b"
 }