bk-nepali-datepicker-reactjs/dist/index.js

Nepali Datepicker (Bikram Sambat) as a ReactJS component

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

var React = require('react');
var React__default = _interopDefault(React);
var bkAd = require('bk-ad');
var nepaliNumber = require('nepali-number');

function _extends() {
  _extends = Object.assign || function (target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i];

      for (var key in source) {
        if (Object.prototype.hasOwnProperty.call(source, key)) {
          target[key] = source[key];
        }
      }
    }

    return target;
  };

  return _extends.apply(this, arguments);
}

function _objectWithoutPropertiesLoose(source, excluded) {
  if (source == null) return {};
  var target = {};
  var sourceKeys = Object.keys(source);
  var key, i;

  for (i = 0; i < sourceKeys.length; i++) {
    key = sourceKeys[i];
    if (excluded.indexOf(key) >= 0) continue;
    target[key] = source[key];
  }

  return target;
}

var ENGLISH = "en";
var NEPALI = "ne";
var BS = "BS";
var parsedDateInitialValue = {
  adDate: new Date(),
  bsDay: 0,
  bsMonth: 0,
  bsYear: 0,
  firstAdDayInBSMonth: new Date(),
  numberOfDaysInBSMonth: 0,
  weekDay: 0
};

var SET_CONFIG = "set_config";

var initialState = function initialState(minYear, maxYear) {
  return {
    currentLocale: NEPALI,
    minYear: minYear != null ? minYear : 2000,
    maxYear: maxYear != null ? maxYear : 2100
  };
};

var ConfigReducer = function ConfigReducer(state, action) {
  if (state === void 0) {
    state = initialState();
  }

  if (action.type === SET_CONFIG) {
    var _extends2;

    return _extends({}, state, (_extends2 = {}, _extends2[action.key] = action.value, _extends2));
  }

  return state;
};

var ConfigContext = React.createContext({
  dispatch: function dispatch() {
    return null;
  },
  state: initialState()
});

var ConfigProvider = function ConfigProvider(_ref) {
  var children = _ref.children,
      minYear = _ref.minYear,
      maxYear = _ref.maxYear;

  var _useReducer = React.useReducer(ConfigReducer, initialState(minYear, maxYear)),
      state = _useReducer[0],
      dispatch = _useReducer[1];

  var contextValue = {
    state: state,
    dispatch: dispatch
  };
  return React__default.createElement(ConfigContext.Provider, {
    value: contextValue
  }, children);
};

var useConfig = function useConfig() {
  var _useContext = React.useContext(ConfigContext),
      state = _useContext.state,
      dispatch = _useContext.dispatch;

  function setConfig(key, value) {
    dispatch({
      key: key,
      type: SET_CONFIG,
      value: value
    });
  }

  function getConfig(key) {
    return state[key];
  }

  return {
    setConfig: setConfig,
    getConfig: getConfig
  };
};

var CalenderConfig = {
  maxBSYear: 2100,
  minBSYear: 1970,
  outputSeparator: "-"
};

var months = {
  en: ["Baisakh", "Jestha", "Asar", "Shrawan", "Bhadra", "Ashoj", "Kartik", "Mangsir", "Poush", "Magh", "Falgun", "Chaitra"],
  ne: ["बैशाख", "जेठ", "असार", "सावन", "भदौ", "असोज", "कार्तिक", "मंसिर", "पौष", "माघ", "फागुन", "चैत"]
};
var weeks = {
  en: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
  ne: ["आईत", "सोम", "मंगल", "बुध", "बिही", "शुक्र", "शनि"]
};
var minBSYear = 1970;
var bsMonthMaxDays = [[30, 31], [31, 32], [31, 32], [31, 32], [31, 32], [30, 31], [29, 30], [29, 30], [29, 30], [29, 30], [29, 30], [30, 31]];
var bsMonthCalculatedData = [[0, 1, 1, 22, 1, 3, 1, 1, 1, 3, 1, 22, 1, 3, 1, 3, 1, 22, 1, 3, 1, 19, 1, 3, 1, 1, 3, 1, 2, 2, 1, 3, 1], [1, 2, 2, 2, 2, 2, 2, 1, 3, 1, 3, 1, 2, 2, 2, 3, 2, 2, 2, 1, 3, 1, 3, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 3, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 3, 1, 2, 2, 2, 2, 2, 1, 1, 1, 2, 2, 2, 2, 2, 1, 3, 1, 1, 2], [0, 1, 2, 1, 3, 1, 3, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 1, 3, 1, 3, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 3, 1, 3, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 3, 1, 3, 1, 1, 1, 1, 2, 2, 2, 2, 2, 1, 3, 1, 1, 2], [1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 2, 2, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 2, 2, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 2, 2, 1, 3, 1, 2, 2, 2, 1, 2], [59, 1, 26, 1, 28, 1, 2, 1, 12], [0, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 3, 1, 3, 1, 3, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 3, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 3, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 5, 1, 1, 2, 2, 1, 3, 1, 2, 1, 2], [0, 12, 1, 3, 1, 3, 1, 5, 1, 11, 1, 3, 1, 3, 1, 18, 1, 3, 1, 3, 1, 18, 1, 3, 1, 3, 1, 27, 1, 2], [1, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 3, 1, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 15, 2, 4], [0, 1, 2, 2, 2, 2, 1, 3, 1, 3, 1, 3, 1, 2, 2, 2, 3, 2, 2, 2, 1, 3, 1, 3, 1, 3, 1, 2, 2, 2, 2, 2, 2, 2, 1, 3, 1, 3, 1, 3, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 3, 1, 3, 1, 2, 2, 2, 15, 2, 4], [1, 1, 3, 1, 3, 1, 14, 1, 3, 1, 1, 1, 3, 1, 14, 1, 3, 1, 3, 1, 3, 1, 18, 1, 3, 1, 3, 1, 3, 1, 14, 1, 3, 15, 1, 2, 1, 1], [0, 1, 1, 3, 1, 3, 1, 10, 1, 3, 1, 3, 1, 1, 1, 3, 1, 3, 1, 10, 1, 3, 1, 3, 1, 3, 1, 3, 1, 14, 1, 3, 1, 3, 1, 3, 1, 3, 1, 10, 1, 20, 1, 1, 1], [1, 2, 2, 1, 3, 1, 3, 1, 3, 1, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 1, 3, 1, 3, 1, 3, 1, 2, 2, 2, 2, 2, 2, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 2, 2, 2, 2, 2, 2, 2, 1, 3, 1, 3, 1, 20, 3]];

var validateAdYear = function validateAdYear(year) {
  var minAdYear = CalenderConfig.minBSYear - 57;
  var maxAdYear = CalenderConfig.maxBSYear - 57;

  if (year < minAdYear || year > maxAdYear) {
    throw new RangeError("AD year should be in range of " + minAdYear + " to " + maxAdYear);
  }
};
var validateAdMonth = function validateAdMonth(month) {
  if (month < 1 || month > 12) {
    throw new RangeError("AD month should be in range of 1 to 12");
  }
};
var validateAdDay = function validateAdDay(day) {
  if (day < 1 || day > 31) {
    throw new RangeError("AD day should be in range of 1 to 31");
  }
};
var validateBsYear = function validateBsYear(year) {
  var midBsYear = CalenderConfig.minBSYear;
  var maxBsYear = CalenderConfig.maxBSYear;

  if (year < midBsYear || year > maxBsYear) {
    throw new RangeError("BS year should be in range of " + midBsYear + " to " + maxBsYear);
  }
};
var validateBsMonth = function validateBsMonth(month) {
  if (month < 1 || month > 12) {
    throw new RangeError("BS month should be in range of 1 to 12");
  }
};
var validateBsDay = function validateBsDay(day) {
  if (day < 1 || day > 32) {
    throw new RangeError("BS day should be in range of 1 to 32");
  }
};

var range = function range(start, end, step) {
  if (step === void 0) {
    step = 1;
  }

  var list = [];

  for (var i = start; i <= end; i = i + step) {
    list.push(i);
  }

  return list;
};
var zeroPad = function zeroPad(num) {
  return "" + (num > 9 ? num : "0" + num);
};
var executionDelegation = function executionDelegation(execution, delegatedExecution) {
  new Promise(function (resolve) {
    execution();
    resolve();
  }).then(function () {
    delegatedExecution();
  });
};
var splitDate = function splitDate(date, separator) {
  if (separator === void 0) {
    separator = "-";
  }

  var _date$split = date.split(separator),
      year = _date$split[0],
      month = _date$split[1],
      day = _date$split[2];

  return {
    day: parseInt(day, 10),
    month: parseInt(month, 10),
    year: parseInt(year, 10)
  };
};
var stitchDate = function stitchDate(date, separator) {
  if (separator === void 0) {
    separator = "-";
  }

  return "" + date.year + separator + zeroPad(date.month) + separator + zeroPad(date.day);
};
var validateDateObject = function validateDateObject(date, type) {
  if (type === void 0) {
    type = BS;
  }

  var year = date.year,
      month = date.month,
      day = date.day;

  if (type === BS) {
    validateBsYear(year);
    validateBsMonth(month);
    validateBsDay(day);
    return;
  }

  validateAdYear(year);
  validateAdMonth(month);
  validateAdDay(day);
};
var getNumberOfDaysInBSMonth = function getNumberOfDaysInBSMonth(yearMonth) {
  var year = yearMonth.year,
      month = yearMonth.month;
  validateBsYear(year);
  validateBsMonth(month);
  var yearCount = 0;
  var totalYears = year + 1 - minBSYear;
  var bsMonthData = bsMonthCalculatedData[month - 1];
  return bsMonthData.reduce(function (numberOfDays, monthData, index) {
    if (monthData === 0 || numberOfDays !== 0) {
      return numberOfDays;
    }

    var bsMonthUpperDaysIndex = index % 2;
    yearCount += monthData;

    if (totalYears > yearCount) {
      return numberOfDays;
    }

    if (year === 2081 && month === 2) {
      return bsMonthMaxDays[month - 1][bsMonthUpperDaysIndex + 1];
    }

    if (year === 2081 && month === 3) {
      return bsMonthMaxDays[month - 1][bsMonthUpperDaysIndex - 1];
    }

    if (year === 2081 && month === 11) {
      return bsMonthMaxDays[month - 1][bsMonthUpperDaysIndex] - 1;
    }

    if (year === 2081 && month === 12) {
      return bsMonthMaxDays[month - 1][bsMonthUpperDaysIndex] + 1;
    }

    if (year === 2082 && month === 1) {
      return bsMonthMaxDays[month - 1][bsMonthUpperDaysIndex] + 1;
    }

    if (year === 2082 && month === 2) {
      return bsMonthMaxDays[month - 1][bsMonthUpperDaysIndex] - 1;
    }

    if (year === 2082 && month === 3) {
      return bsMonthMaxDays[month - 1][bsMonthUpperDaysIndex] + 1;
    }

    if (year === 2082 && month === 4) {
      return bsMonthMaxDays[month - 1][bsMonthUpperDaysIndex] - 1;
    }

    if (year === 2082 && month === 6) {
      return bsMonthMaxDays[month - 1][bsMonthUpperDaysIndex] + 1;
    }

    if (year === 2082 && month === 8) {
      return bsMonthMaxDays[month - 1][bsMonthUpperDaysIndex] - 1;
    }

    if (year === 2082 && month === 9) {
      return bsMonthMaxDays[month - 1][bsMonthUpperDaysIndex] + 1;
    }

    if (year === 2082 && month === 10) {
      return bsMonthMaxDays[month - 1][bsMonthUpperDaysIndex] - 1;
    }

    if (year === 2085 && month === 5 || year === 2088 && month === 5) {
      return bsMonthMaxDays[month - 1][bsMonthUpperDaysIndex] - 2;
    }

    return bsMonthMaxDays[month - 1][bsMonthUpperDaysIndex];
  }, 0);
};
var parseBSDate = function parseBSDate(date, separator) {
  if (separator === void 0) {
    separator = "-";
  }

  var _splitDate = splitDate(date, separator),
      year = _splitDate.year,
      month = _splitDate.month,
      day = _splitDate.day;

  validateDateObject({
    year: year,
    month: month,
    day: day
  });
  var adDate = new Date(bkAd.BSToAD(date));
  var firstAdDateInBSMonth = new Date(bkAd.BSToAD(stitchDate({
    year: year,
    month: month,
    day: 1
  }, separator)));
  var numberOfDaysInMonth = getNumberOfDaysInBSMonth({
    year: year,
    month: month
  });
  return {
    adDate: adDate,
    bsDay: day,
    bsMonth: month,
    bsYear: year,
    firstAdDayInBSMonth: firstAdDateInBSMonth,
    numberOfDaysInBSMonth: numberOfDaysInMonth,
    weekDay: adDate.getDay()
  };
};
var childOf = function childOf(childNode, parentNode) {
  return parentNode.contains(childNode);
};

var IconBase = function IconBase(props) {
  var options = _objectWithoutPropertiesLoose(props, ["size", "viewBoxSize"]);

  return React__default.createElement("svg", Object.assign({
    xmlns: 'http://www.w3.org/2000/svg',
    xmlnsXlink: 'http://www.w3.org/1999/xlink',
    width: props.size,
    height: props.size
  }, options, {
    viewBox: "0 0 " + props.viewBoxSize + " " + props.viewBoxSize
  }), props.children);
};

IconBase.defaultProps = {
  color: "#6b6b6b",
  size: "16",
  viewBoxSize: "24"
};

var Next = function Next(props) {
  var rotationOrigin = parseInt(props.size || "24", 10) / 2;
  return React__default.createElement(IconBase, Object.assign({}, props), React__default.createElement("path", {
    transform: "rotate(180 " + rotationOrigin + " " + rotationOrigin + ")",
    fill: 'none',
    fillRule: 'evenodd',
    stroke: 'currentcolor',
    strokeLinecap: 'round',
    strokeLinejoin: 'round',
    strokeWidth: '2.4',
    d: 'M16.283 18.907L9.6 12l6.683-5.438'
  }));
};

var Previous = function Previous(props) {
  return React__default.createElement(IconBase, Object.assign({}, props), React__default.createElement("path", {
    fill: 'none',
    fillRule: 'evenodd',
    stroke: 'currentcolor',
    strokeLinecap: 'round',
    strokeLinejoin: 'round',
    strokeWidth: '2.4',
    d: 'M16.283 18.907L9.6 12l6.683-5.438'
  }));
};

var Today = function Today(props) {
  props = _extends({}, props, {
    viewBoxSize: "512",
    size: "15"
  });
  return React__default.createElement(IconBase, Object.assign({}, props), React__default.createElement("defs", null, React__default.createElement("path", {
    id: 'a',
    d: 'M468 160H44c-6.6 0-12-5.4-12-12v-36c0-26.5 21.5-48 48-48h48V12c0-6.6 5.4-12 12-12h40c6.6 0 12 5.4 12 12v52h128V12c0-6.6 5.4-12 12-12h40c6.6 0 12 5.4 12 12v52h48c26.5 0 48 21.5 48 48v36c0 6.6-5.4 12-12 12zM44 192h424c6.6 0 12 5.4 12 12v260c0 26.5-21.5 48-48 48H80c-26.5 0-48-21.5-48-48V204c0-6.6 5.4-12 12-12zm116 204c0-6.6-5.4-12-12-12h-40c-6.6 0-12 5.4-12 12v40c0 6.6 5.4 12 12 12h40c6.6 0 12-5.4 12-12v-40zm0-128c0-6.6-5.4-12-12-12h-40c-6.6 0-12 5.4-12 12v40c0 6.6 5.4 12 12 12h40c6.6 0 12-5.4 12-12v-40zm128 128c0-6.6-5.4-12-12-12h-40c-6.6 0-12 5.4-12 12v40c0 6.6 5.4 12 12 12h40c6.6 0 12-5.4 12-12v-40zm0-128c0-6.6-5.4-12-12-12h-40c-6.6 0-12 5.4-12 12v40c0 6.6 5.4 12 12 12h40c6.6 0 12-5.4 12-12v-40zm128 128c0-6.6-5.4-12-12-12h-40c-6.6 0-12 5.4-12 12v40c0 6.6 5.4 12 12 12h40c6.6 0 12-5.4 12-12v-40zm0-128c0-6.6-5.4-12-12-12h-40c-6.6 0-12 5.4-12 12v40c0 6.6 5.4 12 12 12h40c6.6 0 12-5.4 12-12v-40z'
  })), React__default.createElement("g", {
    fill: 'none',
    fillRule: 'evenodd'
  }, React__default.createElement("mask", {
    id: 'b',
    fill: '#fff'
  }, React__default.createElement("use", {
    xlinkHref: '#a'
  })), React__default.createElement("use", {
    fill: '#000',
    fillRule: 'nonzero',
    xlinkHref: '#a'
  }), React__default.createElement("g", {
    fill: 'currentcolor',
    mask: 'url(#b)'
  }, React__default.createElement("path", {
    d: 'M0 0h512v512H0z'
  }))));
};

var translations = {
  previous: {
    en: "Previous",
    ne: "अघिल्लो"
  },
  next: {
    en: "Next",
    ne: "अर्को"
  },
  today: {
    en: "Today",
    ne: "आज"
  }
};

var useTrans = function useTrans(currentLocale) {
  return {
    trans: function trans(key, locale) {
      if (!translations.hasOwnProperty(key)) {
        return key;
      }

      return translations[key][locale || currentLocale];
    },
    numberTrans: function numberTrans(num, locale) {
      return "" + (locale || currentLocale) === ENGLISH ? nepaliNumber.nepaliToEnglishNumber(num) : nepaliNumber.englishToNepaliNumber(num);
    }
  };
};

var DropDown = function DropDown(_ref) {
  var options = _ref.options,
      value = _ref.value,
      onSelect = _ref.onSelect;
  React.useLayoutEffect(function () {});
  return React__default.createElement("div", {
    className: 'drop-down'
  }, React__default.createElement("div", {
    className: 'option-wrapper'
  }, React__default.createElement("ul", null, options.map(function (option, index) {
    return React__default.createElement("li", {
      key: index,
      className: option.value === value ? "active" : "",
      onClick: function onClick() {
        onSelect(option);
      }
    }, option.label);
  }))));
};

var MonthPicker = function MonthPicker(_ref) {
  var date = _ref.date,
      onSelect = _ref.onSelect;

  var _useState = React.useState(false),
      showDropdown = _useState[0],
      setShowDropdown = _useState[1];

  var _useConfig = useConfig(),
      getConfig = _useConfig.getConfig;

  var currentLocale = React.useMemo(function () {
    return getConfig("currentLocale");
  }, [getConfig]);
  var currentMonth = React.useMemo(function () {
    var month = date.bsMonth;
    return {
      label: months[currentLocale][month - 1],
      value: month
    };
  }, [date, currentLocale]);
  var monthList = React.useMemo(function () {
    return months[currentLocale].map(function (month, index) {
      return {
        label: month,
        value: index + 1
      };
    });
  }, [currentLocale]);

  var handleDropdownView = function handleDropdownView(selected) {
    setShowDropdown(!showDropdown);
    onSelect(selected.value);
  };

  return React__default.createElement("div", {
    className: 'control month'
  }, React__default.createElement("span", {
    className: 'current-month',
    onClick: function onClick() {
      return setShowDropdown(!showDropdown);
    }
  }, currentMonth.label), showDropdown && React__default.createElement(DropDown, {
    options: monthList,
    value: currentMonth.value,
    onSelect: handleDropdownView
  }));
};

var YearPicker = function YearPicker(_ref) {
  var date = _ref.date,
      onSelect = _ref.onSelect;

  var _useState = React.useState(false),
      showDropdown = _useState[0],
      setShowDropdown = _useState[1];

  var _useConfig = useConfig(),
      getConfig = _useConfig.getConfig;

  var _useTrans = useTrans(getConfig("currentLocale")),
      numberTrans = _useTrans.numberTrans;

  var currentYear = React.useMemo(function () {
    var year = date.bsYear;
    return {
      label: numberTrans(year),
      value: year
    };
  }, [date]);
  var years = React.useMemo(function () {
    return range(getConfig("minYear"), getConfig("maxYear")).reverse().map(function (year) {
      return {
        label: numberTrans(year),
        value: year
      };
    });
  }, []);

  var handleDropdownView = function handleDropdownView(selected) {
    setShowDropdown(!showDropdown);
    onSelect(selected.value);
  };

  return React__default.createElement("div", {
    className: 'control year'
  }, React__default.createElement("span", {
    className: 'current-year',
    onClick: function onClick() {
      return setShowDropdown(!showDropdown);
    }
  }, currentYear.label), showDropdown && React__default.createElement(DropDown, {
    options: years,
    value: currentYear.value,
    onSelect: handleDropdownView
  }));
};

var CalenderController = function CalenderController(props) {
  var onNextMonth = props.onNextMonth,
      onPreviousMonth = props.onPreviousMonth,
      calenderDate = props.calenderDate,
      onToday = props.onToday,
      onYearSelect = props.onYearSelect,
      onMonthSelect = props.onMonthSelect;

  var _useConfig = useConfig(),
      getConfig = _useConfig.getConfig;

  var _useTrans = useTrans(getConfig("currentLocale")),
      trans = _useTrans.trans;

  return React__default.createElement("div", {
    className: 'calendar-controller'
  }, React__default.createElement("span", {
    className: 'control icon',
    title: trans("previous"),
    onClick: onPreviousMonth
  }, React__default.createElement(Previous, null)), React__default.createElement("div", {
    className: 'date-indicator'
  }, React__default.createElement(MonthPicker, {
    date: calenderDate,
    onSelect: onMonthSelect
  }), React__default.createElement(YearPicker, {
    date: calenderDate,
    onSelect: onYearSelect
  })), React__default.createElement("span", {
    className: 'control icon icon-today',
    title: trans("today"),
    onClick: onToday
  }, React__default.createElement(Today, {
    color: '#2096f5'
  })), React__default.createElement("span", {
    className: 'control icon',
    title: trans("next"),
    onClick: onNextMonth
  }, React__default.createElement(Next, null)));
};

var DayPickerBody = function DayPickerBody(_ref) {
  var selectedDate = _ref.selectedDate,
      date = _ref.calenderDate,
      onSelect = _ref.onSelect;
  var weeksInMonth = React.useMemo(function () {
    return Math.ceil((date.firstAdDayInBSMonth.getDay() + date.numberOfDaysInBSMonth) / 7) - 1;
  }, [date]);
  var previousMonth = React.useMemo(function () {
    return date.bsMonth - 1 !== 0 ? date.bsMonth - 1 : 12;
  }, [date]);
  var previousYear = React.useMemo(function () {
    return previousMonth === 12 ? date.bsYear - 1 : date.bsYear;
  }, [previousMonth, date]);
  var previousMonthDays = React.useMemo(function () {
    return previousYear >= minBSYear ? getNumberOfDaysInBSMonth({
      month: previousMonth,
      year: previousYear
    }) : 30;
  }, [previousYear]);

  var _useConfig = useConfig(),
      getConfig = _useConfig.getConfig;

  var _useTrans = useTrans(getConfig("currentLocale")),
      numberTrans = _useTrans.numberTrans;

  var getDayInfo = React.useCallback(function (weekNum, weekDayNum) {
    var day = weekNum * 7 + weekDayNum - date.firstAdDayInBSMonth.getDay();
    var month = date.bsMonth;
    var year = date.bsYear;
    var isCurrentMonth = true;

    if (day <= 0) {
      day = previousMonthDays + day;
      isCurrentMonth = false;
    } else if (day > date.numberOfDaysInBSMonth) {
      day = day - date.numberOfDaysInBSMonth;
      isCurrentMonth = false;
    }

    var today = splitDate(bkAd.ADToBS(new Date()));
    var isToday = isCurrentMonth ? today.day === day && today.month === date.bsMonth && today.year === date.bsYear : false;
    var isSelected = selectedDate && isCurrentMonth ? selectedDate.bsDay === day && selectedDate.bsMonth === date.bsMonth && selectedDate.bsYear === date.bsYear : false;
    return {
      day: day,
      month: month,
      year: year,
      isCurrentMonth: isCurrentMonth,
      isToday: isToday,
      isSelected: isSelected
    };
  }, [date, selectedDate, previousMonthDays]);
  var onDateSelectHandler = React.useCallback(function (dayInfo) {
    if (dayInfo.isCurrentMonth) {
      onSelect({
        year: dayInfo.year,
        month: dayInfo.month,
        day: dayInfo.day
      });
    }
  }, [onSelect]);
  return React__default.createElement("tbody", null, range(0, weeksInMonth).map(function (weekNum) {
    return React__default.createElement("tr", {
      key: weekNum
    }, range(1, 7).map(function (weekDayNum) {
      var dayInfo = getDayInfo(weekNum, weekDayNum);
      return React__default.createElement("td", {
        key: weekDayNum,
        className: "month-day " + (dayInfo.isCurrentMonth ? "current" : "disabled") + " " + (dayInfo.isToday ? "today" : "") + " " + (dayInfo.isSelected ? "selected" : ""),
        onClick: function onClick() {
          return onDateSelectHandler(dayInfo);
        }
      }, numberTrans(dayInfo.day));
    }));
  }));
};

var DayPickerHeader = function DayPickerHeader() {
  var _useConfig = useConfig(),
      getConfig = _useConfig.getConfig;

  var currentLocale = React.useMemo(function () {
    return getConfig("currentLocale");
  }, [getConfig]);
  return React__default.createElement("thead", null, React__default.createElement("tr", null, weeks[currentLocale].map(function (weekDay, index) {
    return React__default.createElement("td", {
      key: index
    }, weekDay);
  })));
};

var DayPicker = function DayPicker(_ref) {
  var selectedDate = _ref.selectedDate,
      calenderDate = _ref.calenderDate,
      onDaySelect = _ref.onDaySelect;
  return React__default.createElement("table", null, React__default.createElement(DayPickerHeader, null), React__default.createElement(DayPickerBody, {
    selectedDate: selectedDate,
    calenderDate: calenderDate,
    onSelect: onDaySelect
  }));
};

var Calender = function Calender(_ref) {
  var value = _ref.value,
      events = _ref.events;

  var _useState = React.useState(false),
      isInitialized = _useState[0],
      setIsInitialized = _useState[1];

  var _useState2 = React.useState(null),
      selectedDate = _useState2[0],
      setSelectedDate = _useState2[1];

  var _useState3 = React.useState(parsedDateInitialValue),
      calenderDate = _useState3[0],
      setCalenderDate = _useState3[1];

  var _useConfig = useConfig(),
      getConfig = _useConfig.getConfig;

  React.useEffect(function () {
    var parsedDateValue = value ? parseBSDate(value) : null;

    if (parsedDateValue) {
      setSelectedDate(parsedDateValue);
      setCalenderDate(parsedDateValue);
    } else {
      var today = parseBSDate(bkAd.ADToBS(new Date()));
      setCalenderDate(today);
      setSelectedDate(null);
    }

    setIsInitialized(true);
  }, [value]);
  React.useEffect(function () {
    if (isInitialized && selectedDate) {
      events.change(stitchDate({
        year: selectedDate.bsYear,
        month: selectedDate.bsMonth,
        day: selectedDate.bsDay
      }));
    }
  }, [selectedDate, isInitialized]);
  var onPreviousMonthHandler = React.useCallback(function () {
    executionDelegation(function () {
      setCalenderDate(function (date) {
        var year = date.bsYear;
        var month = date.bsMonth - 1;

        if (month < 1) {
          month = 12;
          year--;
        }

        if (year < getConfig("minYear") || year > getConfig("maxYear")) {
          return date;
        }

        return parseBSDate(stitchDate({
          day: date.bsDay,
          month: month,
          year: year
        }, "-"));
      });
    }, function () {
      if (events.previousMonthSelect) {
        events.previousMonthSelect({
          month: calenderDate.bsMonth,
          year: calenderDate.bsYear
        });
      }
    });
  }, []);
  var onNextMonthClickHandler = React.useCallback(function () {
    executionDelegation(function () {
      setCalenderDate(function (date) {
        var year = date.bsYear;
        var month = date.bsMonth + 1;

        if (month > 12) {
          month = 1;
          year++;
        }

        return parseBSDate(stitchDate({
          day: date.bsDay,
          month: month,
          year: year
        }, "-"));
      });
    }, function () {
      if (events.nextMonthSelect) {
        events.nextMonthSelect({
          year: calenderDate.bsYear,
          month: calenderDate.bsMonth
        });
      }
    });
  }, []);
  var onTodayClickHandler = React.useCallback(function () {
    var today = parseBSDate(bkAd.ADToBS(new Date()));
    executionDelegation(function () {
      setCalenderDate(today);
      setSelectedDate(today);
    }, function () {
      if (events.todaySelect) {
        events.todaySelect({
          year: today.bsYear,
          month: today.bsMonth,
          day: today.bsDay
        });
      }
    });
  }, []);
  var onYearSelectHandler = React.useCallback(function (year) {
    executionDelegation(function () {
      setCalenderDate(parseBSDate(stitchDate({
        year: year,
        month: calenderDate.bsMonth,
        day: calenderDate.bsDay
      })));
    }, function () {
      if (events.yearSelect) {
        events.yearSelect(year);
      }
    });
  }, [calenderDate]);
  var onMonthSelectHandler = React.useCallback(function (month) {
    executionDelegation(function () {
      setCalenderDate(parseBSDate(stitchDate({
        year: calenderDate.bsYear,
        month: month,
        day: calenderDate.bsDay
      })));
    }, function () {
      if (events.monthSelect) {
        events.monthSelect(month);
      }
    });
  }, [calenderDate]);
  var onDaySelectHandler = React.useCallback(function (date) {
    executionDelegation(function () {
      var newDate = parseBSDate(stitchDate(date));
      setCalenderDate(newDate);
      setSelectedDate(newDate);
    }, function () {
      if (events.daySelect) {
        events.daySelect(date);
      }
    });
  }, []);
  return React__default.createElement("div", {
    className: 'calender'
  }, React__default.createElement("div", {
    className: 'calendar-wrapper'
  }, isInitialized && React__default.createElement(React.Fragment, null, React__default.createElement(CalenderController, {
    onPreviousMonth: onPreviousMonthHandler,
    onNextMonth: onNextMonthClickHandler,
    calenderDate: calenderDate,
    onToday: onTodayClickHandler,
    onYearSelect: onYearSelectHandler,
    onMonthSelect: onMonthSelectHandler
  }), React__default.createElement(DayPicker, {
    selectedDate: selectedDate,
    calenderDate: calenderDate,
    onDaySelect: onDaySelectHandler
  }))));
};

var NepaliDatePicker = function NepaliDatePicker(props) {
  var className = props.className,
      inputClassName = props.inputClassName,
      value = props.value,
      onChange = props.onChange,
      onSelect = props.onSelect,
      options = props.options,
      todayIfEmpty = props.todayIfEmpty;
  var nepaliDatePickerWrapper = React.useRef(null);
  var nepaliDatePickerInput = React.useRef(null);

  var _useState = React.useState(""),
      date = _useState[0],
      setDate = _useState[1];

  var _useState2 = React.useState(false),
      showCalendar = _useState2[0],
      setShowCalendar = _useState2[1];

  var _useConfig = useConfig(),
      setConfig = _useConfig.setConfig,
      getConfig = _useConfig.getConfig;

  var _useTrans = useTrans(getConfig("currentLocale")),
      numberTrans = _useTrans.numberTrans;

  var toEnglish = React.useCallback(function (val) {
    return numberTrans(val, ENGLISH);
  }, []);
  var returnDateValue = React.useCallback(function (val) {
    return numberTrans(val, options.valueLocale);
  }, [options.valueLocale]);
  React.useEffect(function () {
    setConfig("currentLocale", options.calenderLocale);
  }, [options.calenderLocale]);
  React.useEffect(function () {
    setDate(toEnglish(value || (todayIfEmpty ? bkAd.ADToBS(new Date()) : "")));
  }, [value]);
  var handleClickOutside = React.useCallback(function (event) {
    if (nepaliDatePickerWrapper.current && childOf(event.target, nepaliDatePickerWrapper.current)) {
      return;
    }

    setShowCalendar(false);
  }, []);
  React.useLayoutEffect(function () {
    if (showCalendar) {
      document.addEventListener("mousedown", handleClickOutside);
    }

    return function () {
      document.removeEventListener("mousedown", handleClickOutside);
    };
  }, [showCalendar]);
  React.useLayoutEffect(function () {
    if (showCalendar && nepaliDatePickerWrapper.current) {
      var nepaliDatePicker = nepaliDatePickerWrapper.current.getBoundingClientRect();
      var screenHeight = window.innerHeight;
      var calender = nepaliDatePickerWrapper.current.querySelector(".calender");

      if (calender) {
        setTimeout(function () {
          var calenderHeight = calender.clientHeight;

          if (calenderHeight + nepaliDatePicker.bottom > screenHeight) {
            if (calenderHeight < nepaliDatePicker.top) {
              calender.style.bottom = nepaliDatePicker.height + "px";
            }
          }
        }, 0);
      }
    }
  }, [showCalendar]);
  var handleOnChange = React.useCallback(function (changedDate) {
    executionDelegation(function () {
      setDate(changedDate);
    }, function () {
      if (onChange) {
        onChange(returnDateValue(changedDate));
      }
    });
  }, [onChange]);
  var handleOnDaySelect = React.useCallback(function (selectedDate) {
    executionDelegation(function () {
      if (options.closeOnSelect) {
        setShowCalendar(false);
      }
    }, function () {
      if (onSelect) {
        onSelect(returnDateValue(stitchDate(selectedDate)));
      }
    });
  }, [onSelect]);
  var datepickerEvents = {
    change: handleOnChange,
    daySelect: handleOnDaySelect,
    todaySelect: handleOnDaySelect
  };
  return React__default.createElement("div", {
    ref: nepaliDatePickerWrapper,
    className: "nepali-date-picker " + className
  }, React__default.createElement("input", {
    type: 'text',
    ref: nepaliDatePickerInput,
    className: inputClassName,
    readOnly: true,
    value: numberTrans(date),
    onClick: function onClick() {
      return setShowCalendar(function (visible) {
        return !visible;
      });
    }
  }), showCalendar && React__default.createElement(Calender, {
    value: date && date,
    events: datepickerEvents
  }));
};

var NepaliDatePickerWrapper = function NepaliDatePickerWrapper(props) {
  var calenderOptions = React.useMemo(function () {
    return _extends({
      closeOnSelect: true,
      calenderLocale: NEPALI,
      valueLocale: ENGLISH
    }, props.options);
  }, [props.options]);
  return React__default.createElement(ConfigProvider, {
    maxYear: props.maxYear,
    minYear: props.minYear
  }, React__default.createElement(NepaliDatePicker, Object.assign({}, _extends({}, props, {
    options: calenderOptions
  }))));
};

NepaliDatePickerWrapper.defaultProps = {
  className: "",
  inputClassName: "",
  value: "",
  onChange: function onChange() {
    return null;
  },
  onSelect: function onSelect() {
    return null;
  },
  options: {},
  todayIfEmpty: false
};

exports.NepaliDatePicker = NepaliDatePickerWrapper;
//# sourceMappingURL=index.js.map