mapwize-ui-react-native/lib/commonjs/formatter/openingHoursFormatter.js

Fully featured and ready to use UI to add Mapwize Indoor Maps and Navigation in your React Native app.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.buildCurrentOpeningStatus = exports.buildOpeningHours = void 0;

var _dayjs = _interopRequireDefault(require("dayjs"));

var _localizor = require("../localizor");

var _utc = _interopRequireDefault(require("dayjs/plugin/utc"));

var _timezone = _interopRequireDefault(require("dayjs/plugin/timezone"));

var _customParseFormat = _interopRequireDefault(require("dayjs/plugin/customParseFormat"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

_dayjs.default.extend(_utc.default);

_dayjs.default.extend(_timezone.default);

_dayjs.default.extend(_customParseFormat.default);

const buildOpeningHours = (openHours, language, uses24 = true) => {
  const format = uses24 ? 'HH:mm' : 'hh:mm';
  let formatted = [[], [], [], [], [], [], []];
  openHours.forEach(o => {
    if (o.open === '00:00' && o.close === '23:59') {
      formatted[o.day].push((0, _localizor.lang_open_all_day)(language));
    } else {
      formatted[o.day].push((0, _dayjs.default)(o.open, 'HH:mm').format(format) + ' - ' + (0, _dayjs.default)(o.close, 'HH:mm').format(format));
    }
  });

  for (let i = 0; i < formatted.length; i++) {
    if (formatted[i].length === 0) {
      formatted[i].push((0, _localizor.lang_closed)(language));
    }
  }

  formatted = formatted.map((v, i) => {
    return {
      day: dayOfWeekAsString(i, language),
      intervals: v
    };
  });
  formatted.push(formatted.shift());
  return formatted;
};

exports.buildOpeningHours = buildOpeningHours;

const buildCurrentOpeningStatus = (placeDetails, language, uses24 = true) => {
  return getCurrentOpeningState(placeDetails.openingHours, placeDetails.timezone, language, uses24);
};

exports.buildCurrentOpeningStatus = buildCurrentOpeningStatus;

const getFormattedHours = (minuts, uses24 = true) => {
  const date = new Date();
  date.setHours(Math.floor(minuts / 60));
  date.setMinutes(minuts % 60);
  date.setSeconds(0);
  date.setMilliseconds(0);
  const format = uses24 ? 'HH:mm' : 'hh:mm';
  const s = (0, _dayjs.default)(date).format(format);
  return s;
};

const dayOfWeekAsString = (dayIndex, language) => {
  return [(0, _localizor.lang_sunday)(language), (0, _localizor.lang_monday)(language), (0, _localizor.lang_tuesday)(language), (0, _localizor.lang_wednesday)(language), (0, _localizor.lang_thursday)(language), (0, _localizor.lang_friday)(language), (0, _localizor.lang_saturday)(language)][dayIndex] || '';
};

const getCurrentOpeningState = (input, timezoneCode, language, uses24) => {
  const localOffset = -new Date().getTimezoneOffset();
  const venueOffset = (0, _dayjs.default)().tz(timezoneCode).utcOffset();
  const diff = (venueOffset - localOffset) / 60;
  const date = new Date();
  const weekday = date.getDay();
  const currentMinuts = (new Date().getHours() + diff) * 60 + new Date().getMinutes();
  const intervals = sortInterval(buildIntervals(input), new Date().getDay(), currentMinuts);
  const currentInterval = getIntervalIfOpenFromIntervals(intervals, weekday, currentMinuts);

  if (currentInterval) {
    const closingInterval = getNextCloseIntervalFromIntervals(intervals, currentInterval);

    if (closingInterval) {
      if (closingInterval === currentInterval) {
        return (0, _localizor.lang_open_close_at)(language, getFormattedHours(closingInterval.close, uses24));
      }

      if (closingInterval.day - currentInterval.day === 1 || closingInterval.day - currentInterval.day === -6) {
        return (0, _localizor.lang_open_close_tomorrow)(language, getFormattedHours(closingInterval.close, uses24));
      } else {
        return (0, _localizor.lang_open_close)(language, dayOfWeekAsString(closingInterval.day, language), getFormattedHours(closingInterval.close, uses24));
      }
    } else {
      return (0, _localizor.lang_open_24_7)(language);
    }
  } else {
    const openingInterval = getNextOpeningIntervalFromIntervals(intervals, weekday, currentMinuts);

    if (openingInterval) {
      if (openingInterval.day === weekday) {
        return (0, _localizor.lang_close_open_at)(language, getFormattedHours(openingInterval.open, uses24));
      }

      if (openingInterval.day - weekday === 1 || openingInterval.day - weekday === -6) {
        return (0, _localizor.lang_close_open_tomorrow)(language, getFormattedHours(openingInterval.open, uses24));
      } else {
        return (0, _localizor.lang_close_open)(language, dayOfWeekAsString(openingInterval.day, language), getFormattedHours(openingInterval.open, uses24));
      }
    } else {
      return (0, _localizor.lang_close_24_7)(language);
    }
  }
};

const getNextOpeningIntervalFromIntervals = (intervals, day, minuts) => {
  // i.open > ? minuts
  let nextPossibleOpening = [];

  for (let i = 0; i < intervals.length; i++) {
    if (intervals[i].day === day && intervals[i].open > minuts && intervals[i].close > minuts) {
      return intervals[i];
    }

    if (intervals[i].day !== day) {
      nextPossibleOpening.push(intervals[i]);
    }
  }

  let counter = 0;

  while (counter < 7) {
    const nextDay = (day + counter) % 7;
    const interval = nextPossibleOpening.find(e => e.day === nextDay);

    if (interval) {
      return interval;
    }

    counter++;
  }

  return null;
};

const getNextCloseIntervalFromIntervals = (intervals, current) => {
  if (current.close !== 23 * 60 + 59) {
    return current;
  }

  const index = intervals.indexOf(current);

  for (let i = 0; i < intervals.length; i++) {
    const next = intervals[(i + index) % intervals.length];

    if (next.close !== 23 * 60 + 59) {
      return next;
    }
  }

  return null;
};

const getIntervalIfOpenFromIntervals = (intervals, day, minuts) => {
  for (let i = 0; i < intervals.length; i++) {
    if (day === intervals[i].day && minuts > intervals[i].open && minuts < intervals[i].close) {
      return intervals[i];
    }
  }

  return null;
};

const buildIntervals = input => {
  if (!input) {
    return [];
  }

  return input.map(o => {
    return convertStringOpeningHourToMinuts(o);
  });
};

const sortInterval = (input, day, minuts) => {
  const sorted = input.sort((a, b) => {
    if (a.day === b.day) {
      return a.open - b.open;
    }

    return a.day - b.day;
  });
  let index = -1;

  for (let i = 0; i < sorted.length; i++) {
    if (sorted[i].day > day) {
      index = i - 1;
      break;
    }
  }

  for (let i = 0; i < index; i++) {
    sorted.push(sorted.shift());
  }

  return sorted;
};

const isOpenToday = (input, minuts) => {
  input.forEach(i => {
    if (i.open <= minuts && i.close > minuts) {
      return true;
    }
  });
  return false;
};

const convertToOpeningByDay = input => {
  const output = {};
  convertStringOpeningHoursToMinuts(input).forEach(o => {
    if (!output[o.day]) {
      output[o.day] = [];
    }

    output[o.day].push({
      open: o.open,
      clise: o.close
    });
  });
  return output;
};

const convertStringOpeningHoursToMinuts = input => {
  return input.map(convertStringOpeningHourToMinuts);
};

const convertStringOpeningHourToMinuts = input => {
  return {
    day: input.day,
    open: convertStringToMinuts(input.open),
    close: convertStringToMinuts(input.close)
  };
};

const convertStringToMinuts = input => {
  const hours = parseInt(input.substr(0, 2), 10);
  const minuts = parseInt(input.substr(3, 2), 10);
  return hours * 60 + minuts;
};
//# sourceMappingURL=openingHoursFormatter.js.map