@darkpos/pricing 1.0.145 → 1.0.146

package/__TEST__/order/addItem.test.js

@@ -201,6 +201,75 @@ describe('addItem function', () => {
     expect(updatedOrder.items[0].modifiers).toHaveLength(2); // Added item should have modifiers
   });
 
+  test('should return original order when item serial is duplicated', () => {
+    const { addItem } = pricingService.order;
+
+    const order = {
+      items: [
+        {
+          _id: 'existing-item',
+          itemId: '111',
+          quantity: 1,
+          price: 100,
+          serial: 'ABC-123',
+          modifiers: [],
+        },
+      ],
+    };
+
+    const item = {
+      _id: 'new-item',
+      itemId: '222',
+      quantity: 1,
+      price: 50,
+      serial: ' abc-123 ',
+      modifiers: [],
+    };
+
+    const result = addItem({
+      order,
+      item,
+      itemIndex: -1,
+      overridenQuantity: -1,
+    });
+
+    expect(result).toBe(order);
+  });
+
+  test('should return original order when autoBarcode serial is duplicated', () => {
+    const { addItem } = pricingService.order;
+
+    const order = {
+      items: [
+        {
+          _id: 'existing-item',
+          itemId: '111',
+          quantity: 1,
+          price: 100,
+          serial: 'ABC-123',
+          modifiers: [],
+        },
+      ],
+    };
+
+    const item = {
+      _id: 'new-item',
+      itemId: '222',
+      quantity: 1,
+      price: 50,
+      modifiers: [],
+    };
+
+    const result = addItem({
+      order,
+      item,
+      itemIndex: 1,
+      autoBarcode: 'ABC-123',
+    });
+
+    expect(result).toBe(order);
+  });
+
   test('Add Related Item', () => {
     const { addItem } = pricingService.order;
 

package/__TEST__/order/pickEndDate.test.js

@@ -1,7 +1,7 @@
 const moment = require('moment-timezone');
 const usePricing = require('../../lib/index');
 
-const getDefaultSettings = schedules => ({
+const getDefaultSettings = (schedules, readyDateCapacityDays = []) => ({
   store: {
     _settings: {
       schedule: {
@@ -24,6 +24,9 @@ const getDefaultSettings = schedules => ({
             cutHour: null,
           },
         ],
+        readyDateCapacity: {
+          days: readyDateCapacityDays,
+        },
       },
     },
   },
@@ -115,7 +118,7 @@ describe('pickEndDate function', () => {
       recommended: 'nothing_recommended',
     };
 
-    const now = moment().tz('America/New_York');
+    const now = moment('2024-08-25T15:00:00Z').tz('America/New_York');
 
     jest.spyOn(moment, 'now').mockImplementation(() => now.valueOf());
     const pricingServiceTest = usePricing(getDefaultSettings([schedule]));
@@ -299,4 +302,207 @@ describe('pickEndDate function', () => {
 
     expect(result).toBe('2025-05-15T22:00:00Z');
   });
+
+  test('pickEndDate - skips day when maxOrders capacity is reached', () => {
+    const schedule = {
+      addDays: 0,
+      readyHour: { hour: 17, minute: 0 },
+      skipDays: [],
+      cutHour: { hour: 16, minute: 0 },
+      cutDay: 1,
+    };
+
+    const pricingService = usePricing(
+      getDefaultSettings([schedule], [{ day: 2, maxOrders: 1 }])
+    );
+
+    const now = moment('2025-05-13T15:00:00Z').tz('America/New_York');
+    jest.spyOn(moment, 'now').mockImplementation(() => now.valueOf());
+
+    const result = pricingService.store.pickEndDate(
+      undefined,
+      undefined,
+      undefined,
+      [
+        {
+          date: '2025-05-13',
+          totalOrders: 1,
+          totalItems: 0,
+        },
+      ]
+    );
+
+    expect(result).toBe('2025-05-14T21:00:00Z');
+  });
+
+  test('pickEndDate - skips day when maxItems capacity is reached', () => {
+    const schedule = {
+      addDays: 0,
+      readyHour: { hour: 17, minute: 0 },
+      skipDays: [],
+      cutHour: { hour: 16, minute: 0 },
+      cutDay: 1,
+    };
+
+    const pricingService = usePricing(
+      getDefaultSettings([schedule], [{ day: 2, maxItems: 1 }])
+    );
+
+    const now = moment('2025-05-13T15:00:00Z').tz('America/New_York');
+    jest.spyOn(moment, 'now').mockImplementation(() => now.valueOf());
+
+    const result = pricingService.store.pickEndDate(
+      undefined,
+      undefined,
+      undefined,
+      [
+        {
+          date: '2025-05-13',
+          totalOrders: 0,
+          totalItems: 1,
+        },
+      ]
+    );
+
+    expect(result).toBe('2025-05-14T21:00:00Z');
+  });
+
+  test('pickEndDate - moves to next available day when capacity is full', () => {
+    const schedule = {
+      addDays: 2,
+      readyHour: { hour: 17, minute: 0 },
+      skipDays: [],
+      cutHour: { hour: 16, minute: 0 },
+      cutDay: 1,
+      dayOfWeek: [1, 2, 3, 4, 5],
+    };
+
+    const pricingService = usePricing(
+      getDefaultSettings([schedule], [{ day: 6, maxOrders: 1 }])
+    );
+
+    const now = moment('2026-02-26T15:00:00Z').tz('America/New_York');
+    jest.spyOn(moment, 'now').mockImplementation(() => now.valueOf());
+
+    const result = pricingService.store.pickEndDate(
+      undefined,
+      undefined,
+      undefined,
+      [
+        {
+          date: '2026-02-28',
+          totalOrders: 1,
+          totalItems: 0,
+        },
+      ]
+    );
+
+    expect(result).toBe('2026-03-01T22:00:00Z');
+  });
+
+  test('pickEndDate - skips closed day after capacity overflow', () => {
+    const schedule = {
+      addDays: 2,
+      readyHour: { hour: 17, minute: 0 },
+      skipDays: null,
+      cutHour: { hour: 10, minute: 0 },
+      cutDay: 1,
+    };
+
+    const pricingService = usePricing({
+      store: {
+        _settings: {
+          schedule: {
+            closed: [{ date: '2026-03-01' }],
+          },
+          order: {
+            schedules: [schedule],
+            readyDateCapacity: {
+              days: [
+                { day: 6, maxOrders: 2, maxItems: 10 },
+                { day: 1, maxOrders: 10, maxItems: 10 },
+              ],
+            },
+          },
+        },
+      },
+    });
+
+    const now = moment('2026-02-25T16:04:51Z').tz('America/New_York');
+    jest.spyOn(moment, 'now').mockImplementation(() => now.valueOf());
+
+    const result = pricingService.store.pickEndDate(
+      undefined,
+      undefined,
+      undefined,
+      [
+        { date: '2026-02-26', totalOrders: 4, totalItems: 5 },
+        { date: '2026-02-27', totalOrders: 1, totalItems: 1 },
+        { date: '2026-02-28', totalOrders: 2, totalItems: 2 },
+      ]
+    );
+
+    expect(result).toBe('2026-03-02T22:00:00Z');
+  });
+
+  test('pickEndDate - skips multiple consecutive capacity-full days', () => {
+    const schedule = {
+      addDays: 0,
+      readyHour: { hour: 17, minute: 0 },
+      skipDays: [],
+      cutHour: { hour: 16, minute: 0 },
+      cutDay: 1,
+    };
+
+    const pricingService = usePricing(
+      getDefaultSettings(
+        [schedule],
+        [
+          { day: 2, maxOrders: 1 },
+          { day: 3, maxOrders: 1 },
+        ]
+      )
+    );
+
+    const now = moment('2025-05-13T15:00:00Z').tz('America/New_York');
+    jest.spyOn(moment, 'now').mockImplementation(() => now.valueOf());
+
+    const result = pricingService.store.pickEndDate(
+      undefined,
+      undefined,
+      undefined,
+      [
+        { date: '2025-05-13', totalOrders: 1, totalItems: 0 },
+        { date: '2025-05-14', totalOrders: 1, totalItems: 0 },
+      ]
+    );
+
+    expect(result).toBe('2025-05-15T21:00:00Z');
+  });
+
+  test('pickEndDate - returns base date when no capacity counts are provided', () => {
+    const schedule = {
+      addDays: 0,
+      readyHour: { hour: 17, minute: 0 },
+      skipDays: [],
+      cutHour: { hour: 16, minute: 0 },
+      cutDay: 1,
+    };
+
+    const pricingService = usePricing(
+      getDefaultSettings([schedule], [{ day: 2, maxOrders: 1 }])
+    );
+
+    const now = moment('2025-05-13T15:00:00Z').tz('America/New_York');
+    jest.spyOn(moment, 'now').mockImplementation(() => now.valueOf());
+
+    const result = pricingService.store.pickEndDate(
+      undefined,
+      undefined,
+      undefined,
+      []
+    );
+
+    expect(result).toBe('2025-05-13T21:00:00Z');
+  });
 });

package/lib/constants/Store.js

@@ -0,0 +1,3 @@
+module.exports = {
+  MAX_ADD_DAYS: 365,
+};

package/lib/constants/index.js

@@ -1,7 +1,9 @@
 const Status = require('./Status');
 const Modifier = require('./Modifier');
+const Store = require('./Store');
 
 module.exports = {
   Status,
   Modifier,
+  Store,
 };

package/lib/order/addItem.js

@@ -227,6 +227,8 @@ module.exports = ({ actions, itemActions, modifierActions, settings, _ }) => {
       originalItem: item,
     });
 
+    if (actions.hasSerial({ order, item: orderItem })) return orderProp;
+
     const params = addOrderItem({
       order,
       item: orderItem,

package/lib/store/getClosedDays.js

@@ -0,0 +1,7 @@
+module.exports = ({ _, settings }) =>
+  function getClosedDays() {
+    const schedule = _.get(settings, 'schedule', {});
+    const { closed = [] } = schedule;
+    if (!Array.isArray(closed)) return [];
+    return closed;
+  };

package/lib/store/getReadyDateCapacityDays.js

@@ -0,0 +1,4 @@
+module.exports = ({ _, settings }) =>
+  function getReadyDateCapacityDays() {
+    return _.get(settings, 'order.readyDateCapacity.days', []);
+  };

package/lib/store/getReadyDateCountsByDate.js

@@ -0,0 +1,33 @@
+module.exports = ({ _, moment }) =>
+  function getReadyDateCountsByDate(counts = []) {
+    const countsByDate = new Map();
+
+    if (!Array.isArray(counts) || !counts.length) return countsByDate;
+
+    counts.forEach(dayCount => {
+      const rawDate = _.get(dayCount, 'date');
+      if (!rawDate) return;
+
+      const utcDateKey = moment.utc(rawDate).format('YYYY-MM-DD');
+      if (!utcDateKey || utcDateKey === 'Invalid date') return;
+
+      const currentValue = countsByDate.get(utcDateKey) || {
+        totalOrders: 0,
+        totalItems: 0,
+      };
+
+      const nextOrders = Number(_.get(dayCount, 'totalOrders'));
+      const nextItems = Number(_.get(dayCount, 'totalItems'));
+
+      countsByDate.set(utcDateKey, {
+        totalOrders:
+          currentValue.totalOrders +
+          (Number.isFinite(nextOrders) && nextOrders > 0 ? nextOrders : 0),
+        totalItems:
+          currentValue.totalItems +
+          (Number.isFinite(nextItems) && nextItems > 0 ? nextItems : 0),
+      });
+    });
+
+    return countsByDate;
+  };

package/lib/store/getSchedule.js

@@ -0,0 +1,61 @@
+module.exports = ({ _, moment, settings, actions }) =>
+  function getSchedule(schedules, isoWeekday, fromDate) {
+    const timezone = actions.getStoreTimezone();
+    let todayTZ = moment().tz(timezone);
+
+    if (fromDate) {
+      todayTZ = moment(fromDate).tz(timezone);
+    }
+
+    const day = isoWeekday || todayTZ.isoWeekday(); // monday 1 - sunday 7
+
+    let activeSchedules = _.get(settings, 'order.schedules', []).filter(
+      item => !item.departments || !item.departments.length
+    );
+
+    if (schedules && schedules.length) {
+      activeSchedules = schedules;
+    }
+
+    if (!activeSchedules.length) {
+      return {
+        todayTZ,
+        skipDays: [],
+        cutDay: 0,
+      };
+    }
+
+    const schedule = activeSchedules.find(item => {
+      const { dayOfWeek } = item || {};
+      if (!dayOfWeek || !dayOfWeek.length) return true;
+      return dayOfWeek.includes(day);
+    });
+
+    if (schedule) {
+      return {
+        ...schedule,
+        todayTZ,
+      };
+    }
+
+    for (let offset = 1; offset <= 7; offset += 1) {
+      const nextIsoWeekday = ((day - 1 + offset) % 7) + 1;
+      const nextSchedule = activeSchedules.find(item => {
+        const { dayOfWeek } = item || {};
+        return Array.isArray(dayOfWeek) && dayOfWeek.includes(nextIsoWeekday);
+      });
+
+      if (nextSchedule) {
+        return {
+          ...nextSchedule,
+          todayTZ: todayTZ.clone().add(offset, 'days'),
+        };
+      }
+    }
+
+    return {
+      todayTZ,
+      skipDays: [],
+      cutDay: 0,
+    };
+  };

package/lib/store/getStoreTimezone.js

@@ -0,0 +1,7 @@
+module.exports = ({ _, settings }) =>
+  function getStoreTimezone() {
+    return (
+      _.get(settings, 'localization.timezone', 'America/New_York') ||
+      'America/New_York'
+    );
+  };

package/lib/store/hasReadyDateCapacitySettings.js

@@ -0,0 +1,8 @@
+module.exports = ({ _, actions }) =>
+  function hasReadyDateCapacitySettings(days = []) {
+    return days.some(
+      day =>
+        actions.normalizeLimit(_.get(day, 'maxOrders')) > 0 ||
+        actions.normalizeLimit(_.get(day, 'maxItems')) > 0
+    );
+  };

package/lib/store/index.js

@@ -1,6 +1,14 @@
 //
 const getScheduleByCustomer = require('./getScheduleByCustomer');
 const isNeareastMultiple = require('./isNeareastMultiple');
+const getClosedDays = require('./getClosedDays');
+const getReadyDateCapacityDays = require('./getReadyDateCapacityDays');
+const getReadyDateCountsByDate = require('./getReadyDateCountsByDate');
+const getSchedule = require('./getSchedule');
+const getStoreTimezone = require('./getStoreTimezone');
+const hasReadyDateCapacitySettings = require('./hasReadyDateCapacitySettings');
+const normalizeLimit = require('./normalizeLimit');
+const pickBaseEndDate = require('./pickBaseEndDate');
 const pickEndDate = require('./pickEndDate');
 const pickEndDateByCustomer = require('./pickEndDateByCustomer');
 
@@ -13,8 +21,16 @@ const storeActions = (deps = {}) => {
   };
 
   const freezedActions = Object.freeze({
+    getClosedDays: getClosedDays(innerDeps),
+    getReadyDateCapacityDays: getReadyDateCapacityDays(innerDeps),
+    getReadyDateCountsByDate: getReadyDateCountsByDate(innerDeps),
     getScheduleByCustomer: getScheduleByCustomer(innerDeps),
+    getSchedule: getSchedule(innerDeps),
+    getStoreTimezone: getStoreTimezone(innerDeps),
+    hasReadyDateCapacitySettings: hasReadyDateCapacitySettings(innerDeps),
     isNeareastMultiple: isNeareastMultiple(innerDeps),
+    normalizeLimit: normalizeLimit(innerDeps),
+    pickBaseEndDate: pickBaseEndDate(innerDeps),
     pickEndDate: pickEndDate(innerDeps),
     pickEndDateByCustomer: pickEndDateByCustomer(innerDeps),
   });

package/lib/store/normalizeLimit.js

@@ -0,0 +1,5 @@
+module.exports = () =>
+  function normalizeLimit(value) {
+    const parsedValue = Math.trunc(Number(value) || 0);
+    return parsedValue > 0 ? parsedValue : 0;
+  };

package/lib/store/pickBaseEndDate.js

@@ -0,0 +1,71 @@
+const { MAX_ADD_DAYS } = require('../constants/Store');
+
+module.exports = ({ moment, actions }) =>
+  function pickBaseEndDate(schedules, isoWeekday, fromDate) {
+    const {
+      addDays: addDaysParam,
+      readyHour,
+      cutHour,
+      cutDay,
+      skipDays,
+      todayTZ,
+    } = actions.getSchedule(schedules, isoWeekday, fromDate);
+
+    let endDateTZ = todayTZ.clone();
+    const closedDays = actions.getClosedDays();
+    const todayHours = todayTZ.get('hours');
+    const todayMinutes = todayTZ.get('minutes');
+
+    let addDays = 0;
+
+    if (
+      !fromDate &&
+      typeof addDaysParam === 'number' &&
+      addDaysParam <= MAX_ADD_DAYS
+    ) {
+      addDays = addDaysParam;
+    }
+
+    if (
+      (cutHour && todayHours > cutHour.hour) ||
+      (cutHour && todayHours >= cutHour.hour && todayMinutes > cutHour.minute)
+    ) {
+      endDateTZ = endDateTZ.add(cutDay, 'days');
+    }
+
+    if (readyHour && readyHour.hour !== undefined)
+      endDateTZ.set('hour', readyHour.hour);
+    if (readyHour && readyHour.minute !== undefined)
+      endDateTZ.set('minute', readyHour.minute);
+
+    endDateTZ.set('second', 0);
+
+    const isSkipDay = endDateIsoWeekDay => {
+      if (skipDays && skipDays.length >= 7) return false;
+
+      return skipDays && skipDays.includes(endDateIsoWeekDay);
+    };
+
+    const isClosedDay = endDate =>
+      closedDays.some(
+        closedDate => endDate.format('YYYY-MM-DD') === closedDate.date
+      );
+
+    let addedDays = 0;
+
+    while (
+      addedDays < addDays ||
+      isSkipDay(endDateTZ.isoWeekday()) ||
+      isClosedDay(endDateTZ)
+    ) {
+      if (
+        endDateTZ.isSame(todayTZ, 'day') ||
+        (!isSkipDay(endDateTZ.isoWeekday()) && !isClosedDay(endDateTZ))
+      ) {
+        addedDays += 1;
+      }
+      endDateTZ.add(1, 'days');
+    }
+
+    return moment.utc(endDateTZ).format();
+  };

package/lib/store/pickEndDate.js

@@ -1,108 +1,82 @@
-module.exports = ({ settings, _, moment }) => {
-  const timezone =
-    _.get(settings, 'localization.timezone', 'America/New_York') ||
-    'America/New_York';
-
-  const getSchedule = (schedules, isoWeekday) => {
-    const todayTZ = moment().tz(timezone);
-    const day = isoWeekday || todayTZ.isoWeekday(); // monday 1 - sunday 7
-    const _schedules =
-      schedules && schedules.length
-        ? schedules
-        : _.get(settings, 'order.schedules', []).filter(
-            item => !item.departments || !item.departments.length
-          );
-
-    if (!_schedules.length) {
-      return {
-        todayTZ,
-        skipDays: [],
-        cutDay: 0,
-      };
-    }
+const { MAX_ADD_DAYS } = require('../constants/Store');
+
+module.exports = ({ _, moment, actions }) =>
+  function pickEndDate(
+    schedules,
+    isoWeekday,
+    fromDate,
+    readyDateCapacityCounts = []
+  ) {
+    const timezone = actions.getStoreTimezone();
+
+    let candidateDate = actions.pickBaseEndDate(
+      schedules,
+      isoWeekday,
+      fromDate
+    );
+
+    const readyDateCapacityDays = actions.getReadyDateCapacityDays();
+    if (!actions.hasReadyDateCapacitySettings(readyDateCapacityDays))
+      return candidateDate;
+
+    const countsByDate = actions.getReadyDateCountsByDate(
+      readyDateCapacityCounts
+    );
+    if (!countsByDate.size) return candidateDate;
+
+    const inspectedDays = new Set();
+
+    for (let index = 0; index < MAX_ADD_DAYS; index += 1) {
+      const candidateMomentTZ = moment(candidateDate).tz(timezone);
+      const candidateLocalDateKey = candidateMomentTZ.format('YYYY-MM-DD');
+
+      if (inspectedDays.has(candidateLocalDateKey)) break;
+      inspectedDays.add(candidateLocalDateKey);
+
+      const capacitySettingsForDay = readyDateCapacityDays.find(
+        day => Number(_.get(day, 'day')) === candidateMomentTZ.isoWeekday()
+      );
 
-    const schedule = _schedules.find(item => {
-      const { dayOfWeek } = item || {};
-      if (!dayOfWeek || !dayOfWeek.length) return true;
-      return dayOfWeek.includes(day);
-    });
+      if (!capacitySettingsForDay) return candidateDate;
 
-    return {
-      ...schedule,
-      todayTZ,
-    };
-  };
+      const maxOrders = actions.normalizeLimit(
+        _.get(capacitySettingsForDay, 'maxOrders')
+      );
+      const maxItems = actions.normalizeLimit(
+        _.get(capacitySettingsForDay, 'maxItems')
+      );
 
-  const getClosedDays = () => {
-    const schedule = _.get(settings, 'schedule', {});
-    const { closed = [] } = schedule;
-    if (!Array.isArray(closed)) return [];
-    return closed;
-  };
+      if (maxOrders <= 0 && maxItems <= 0) return candidateDate;
 
-  const MAX_ADD_DAYS = 365;
-
-  return function pickEndDate(schedules, isoWeekday) {
-    const {
-      addDays: addDaysParam,
-      readyHour,
-      cutHour,
-      cutDay,
-      skipDays,
-      todayTZ,
-    } = getSchedule(schedules, isoWeekday);
-
-    let endDateTZ = todayTZ.clone();
-    const closedDays = getClosedDays();
-    const todayHours = todayTZ.get('hours');
-    const todayMinutes = todayTZ.get('minutes');
-
-    const addDays =
-      typeof addDaysParam !== 'number' || addDaysParam > MAX_ADD_DAYS
-        ? 0
-        : addDaysParam;
-
-    if (
-      (cutHour && todayHours > cutHour.hour) ||
-      (cutHour && todayHours >= cutHour.hour && todayMinutes > cutHour.minute)
-    ) {
-      endDateTZ = endDateTZ.add(cutDay, 'days');
-    }
+      const candidateUTCDateKey = moment
+        .utc(candidateDate)
+        .format('YYYY-MM-DD');
+      const dayCount = countsByDate.get(candidateUTCDateKey) || {
+        totalOrders: 0,
+        totalItems: 0,
+      };
 
-    if (readyHour && readyHour.hour !== undefined)
-      endDateTZ.set('hour', readyHour.hour);
-    if (readyHour && readyHour.minute !== undefined)
-      endDateTZ.set('minute', readyHour.minute);
+      const isUnavailable =
+        (maxOrders > 0 && dayCount.totalOrders >= maxOrders) ||
+        (maxItems > 0 && dayCount.totalItems >= maxItems);
 
-    endDateTZ.set('second', 0);
+      if (!isUnavailable) return candidateDate;
 
-    const isSkipDay = endDateIsoWeekDay => {
-      if (skipDays && skipDays.length >= 7) return false;
+      const nextDateSeed = candidateMomentTZ
+        .clone()
+        .add(1, 'day')
+        .startOf('day')
+        .toISOString();
 
-      return skipDays && skipDays.includes(endDateIsoWeekDay);
-    };
+      const { readyHour, cutHour, cutDay, skipDays } =
+        actions.getSchedule(schedules, undefined, candidateDate) || {};
 
-    const isClosedDay = endDate =>
-      closedDays.some(
-        closedDate => endDate.format('YYYY-MM-DD') === closedDate.date
+      candidateDate = actions.pickBaseEndDate(
+        [{ readyHour, cutHour, cutDay, skipDays }],
+        undefined,
+        nextDateSeed
       );
-
-    let addedDays = 0;
-
-    while (
-      addedDays < addDays ||
-      isSkipDay(endDateTZ.isoWeekday()) ||
-      isClosedDay(endDateTZ)
-    ) {
-      if (
-        endDateTZ.isSame(todayTZ, 'day') ||
-        (!isSkipDay(endDateTZ.isoWeekday()) && !isClosedDay(endDateTZ))
-      ) {
-        addedDays += 1;
-      }
-      endDateTZ.add(1, 'days');
     }
 
-    return moment.utc(endDateTZ).format();
+    return candidateDate;
   };
-};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.145",
+  "version": "1.0.146",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -54,5 +54,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "eb6adf31020d7ca3b57f6e6b1bfa20c4e0289ca0"
+  "gitHead": "50cda463bcaad6e5aa03bded3329269a9ac99398"
 }