@nivo/calendar/dist/nivo-calendar.umd.js

(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('recompose/setDisplayName'), require('react'), require('@nivo/core'), require('@nivo/legends'), require('prop-types'), require('d3-time-format'), require('recompose/pure'), require('recompose/withPropsOnChange'), require('recompose/defaultProps'), require('recompose/compose'), require('d3-scale'), require('lodash.memoize'), require('lodash.isdate'), require('lodash.range'), require('d3-time'), require('@nivo/tooltip')) :
    typeof define === 'function' && define.amd ? define(['exports', 'recompose/setDisplayName', 'react', '@nivo/core', '@nivo/legends', 'prop-types', 'd3-time-format', 'recompose/pure', 'recompose/withPropsOnChange', 'recompose/defaultProps', 'recompose/compose', 'd3-scale', 'lodash.memoize', 'lodash.isdate', 'lodash.range', 'd3-time', '@nivo/tooltip'], factory) :
    (global = global || self, factory(global.nivo = global.nivo || {}, global.RecomposeSetDisplayName, global.React, global.nivo, global.nivo, global.PropTypes, global.d3, global.RecomposePure, global.RecomposeWithPropsOnChange, global.RecomposeDefaultProps, global.RecomposeCompose, global.d3, global.lodash.memoize, global.lodash.isdate, global.lodash.range, global.d3, global.nivo));
}(this, function (exports, _setDisplayName, React, core, legends, PropTypes, d3TimeFormat, _pure, _withPropsOnChange, _defaultProps, _compose, d3Scale, memoize, isDate, range, d3Time, tooltip) { 'use strict';

    _setDisplayName = _setDisplayName && _setDisplayName.hasOwnProperty('default') ? _setDisplayName['default'] : _setDisplayName;
    var React__default = 'default' in React ? React['default'] : React;
    PropTypes = PropTypes && PropTypes.hasOwnProperty('default') ? PropTypes['default'] : PropTypes;
    _pure = _pure && _pure.hasOwnProperty('default') ? _pure['default'] : _pure;
    _withPropsOnChange = _withPropsOnChange && _withPropsOnChange.hasOwnProperty('default') ? _withPropsOnChange['default'] : _withPropsOnChange;
    _defaultProps = _defaultProps && _defaultProps.hasOwnProperty('default') ? _defaultProps['default'] : _defaultProps;
    _compose = _compose && _compose.hasOwnProperty('default') ? _compose['default'] : _compose;
    memoize = memoize && memoize.hasOwnProperty('default') ? memoize['default'] : memoize;
    isDate = isDate && isDate.hasOwnProperty('default') ? isDate['default'] : isDate;
    range = range && range.hasOwnProperty('default') ? range['default'] : range;

    function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
    function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
    var monthLabelFormat = d3TimeFormat.timeFormat('%b');
    var commonPropTypes = {
      from: PropTypes.oneOfType([PropTypes.string, PropTypes.instanceOf(Date)]).isRequired,
      to: PropTypes.oneOfType([PropTypes.string, PropTypes.instanceOf(Date)]).isRequired,
      data: PropTypes.arrayOf(PropTypes.shape({
        day: PropTypes.string.isRequired,
        value: PropTypes.number.isRequired
      })).isRequired,
      align: PropTypes.oneOf(core.boxAlignments).isRequired,
      originX: PropTypes.number.isRequired,
      originY: PropTypes.number.isRequired,
      calendarWidth: PropTypes.number.isRequired,
      calendarHeight: PropTypes.number.isRequired,
      minValue: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number]).isRequired,
      maxValue: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number]).isRequired,
      colors: PropTypes.arrayOf(PropTypes.string).isRequired,
      colorScale: PropTypes.func.isRequired,
      direction: PropTypes.oneOf(['horizontal', 'vertical']),
      emptyColor: PropTypes.string.isRequired,
      yearLegend: PropTypes.func.isRequired,
      yearSpacing: PropTypes.number.isRequired,
      yearLegendPosition: PropTypes.oneOf(['before', 'after']).isRequired,
      yearLegendOffset: PropTypes.number.isRequired,
      monthBorderWidth: PropTypes.number.isRequired,
      monthBorderColor: PropTypes.string.isRequired,
      monthLegend: PropTypes.func.isRequired,
      monthLegendPosition: PropTypes.oneOf(['before', 'after']).isRequired,
      monthLegendOffset: PropTypes.number.isRequired,
      daySpacing: PropTypes.number.isRequired,
      dayBorderWidth: PropTypes.number.isRequired,
      dayBorderColor: PropTypes.string.isRequired,
      isInteractive: PropTypes.bool,
      onClick: PropTypes.func.isRequired,
      tooltipFormat: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
      tooltip: PropTypes.func,
      legends: PropTypes.arrayOf(PropTypes.shape(_objectSpread({}, legends.LegendPropShape, {
        itemCount: PropTypes.number.isRequired
      }))).isRequired
    };
    var CalendarPropTypes = commonPropTypes;
    var CalendarCanvasPropTypes = _objectSpread({}, commonPropTypes, {
      pixelRatio: PropTypes.number.isRequired
    });
    var commonDefaultProps = {
      colors: ['#61cdbb', '#97e3d5', '#e8c1a0', '#f47560'],
      align: 'center',
      direction: 'horizontal',
      emptyColor: '#fff',
      minValue: 0,
      maxValue: 'auto',
      yearSpacing: 30,
      yearLegend: function yearLegend(year) {
        return year;
      },
      yearLegendPosition: 'before',
      yearLegendOffset: 10,
      monthBorderWidth: 2,
      monthBorderColor: '#000',
      monthLegend: function monthLegend(year, month, date) {
        return monthLabelFormat(date);
      },
      monthLegendPosition: 'before',
      monthLegendOffset: 10,
      weekdayLegend: function weekdayLegend(d) {
        return d;
      },
      daySpacing: 0,
      dayBorderWidth: 1,
      dayBorderColor: '#000',
      isInteractive: true,
      onClick: core.noop,
      legends: []
    };
    var CalendarDefaultProps = commonDefaultProps;
    var CalendarCanvasDefaultProps = _objectSpread({}, commonDefaultProps, {
      pixelRatio: global.window && global.window.devicePixelRatio ? global.window.devicePixelRatio : 1
    });

    function _objectSpread$1(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty$1(target, key, source[key]); }); } return target; }
    function _defineProperty$1(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
    function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
    function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
    function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
    function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
    function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
    function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
    function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
    function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
    var computeDomain = function computeDomain(data, minSpec, maxSpec) {
      var allValues = data.map(function (d) {
        return d.value;
      });
      var minValue = minSpec === 'auto' ? Math.min.apply(Math, _toConsumableArray(allValues)) : minSpec;
      var maxValue = maxSpec === 'auto' ? Math.max.apply(Math, _toConsumableArray(allValues)) : maxSpec;
      return [minValue, maxValue];
    };
    var computeCellSize = function computeCellSize(_ref) {
      var width = _ref.width,
          height = _ref.height,
          direction = _ref.direction,
          yearRange = _ref.yearRange,
          yearSpacing = _ref.yearSpacing,
          daySpacing = _ref.daySpacing,
          maxWeeks = _ref.maxWeeks;
      var hCellSize;
      var vCellSize;
      if (direction === 'horizontal') {
        hCellSize = (width - daySpacing * maxWeeks) / maxWeeks;
        vCellSize = (height - (yearRange.length - 1) * yearSpacing - yearRange.length * (8 * daySpacing)) / (yearRange.length * 7);
      } else {
        hCellSize = (width - (yearRange.length - 1) * yearSpacing - yearRange.length * (8 * daySpacing)) / (yearRange.length * 7);
        vCellSize = (height - daySpacing * maxWeeks) / maxWeeks;
      }
      return Math.min(hCellSize, vCellSize);
    };
    var monthPathAndBBox = function monthPathAndBBox(_ref2) {
      var date = _ref2.date,
          cellSize = _ref2.cellSize,
          yearIndex = _ref2.yearIndex,
          yearSpacing = _ref2.yearSpacing,
          daySpacing = _ref2.daySpacing,
          direction = _ref2.direction,
          originX = _ref2.originX,
          originY = _ref2.originY;
      var t1 = new Date(date.getFullYear(), date.getMonth() + 1, 0);
      var firstWeek = d3Time.timeWeek.count(d3Time.timeYear(date), date);
      var lastWeek = d3Time.timeWeek.count(d3Time.timeYear(t1), t1);
      var firstDay = date.getDay();
      var lastDay = t1.getDay();
      var xO = originX;
      var yO = originY;
      var yearOffset = yearIndex * (7 * (cellSize + daySpacing) + yearSpacing);
      if (direction === 'horizontal') {
        yO += yearOffset;
      } else {
        xO += yearOffset;
      }
      var path;
      var bbox = {
        x: xO,
        y: yO,
        width: 0,
        height: 0
      };
      if (direction === 'horizontal') {
        path = ["M".concat(xO + (firstWeek + 1) * (cellSize + daySpacing), ",").concat(yO + firstDay * (cellSize + daySpacing)), "H".concat(xO + firstWeek * (cellSize + daySpacing), "V").concat(yO + 7 * (cellSize + daySpacing)), "H".concat(xO + lastWeek * (cellSize + daySpacing), "V").concat(yO + (lastDay + 1) * (cellSize + daySpacing)), "H".concat(xO + (lastWeek + 1) * (cellSize + daySpacing), "V").concat(yO), "H".concat(xO + (firstWeek + 1) * (cellSize + daySpacing), "Z")].join('');
        bbox.x = xO + firstWeek * (cellSize + daySpacing);
        bbox.width = xO + (lastWeek + 1) * (cellSize + daySpacing) - bbox.x;
        bbox.height = 7 * (cellSize + daySpacing);
      } else {
        path = ["M".concat(xO + firstDay * (cellSize + daySpacing), ",").concat(yO + (firstWeek + 1) * (cellSize + daySpacing)), "H".concat(xO, "V").concat(yO + (lastWeek + 1) * (cellSize + daySpacing)), "H".concat(xO + (lastDay + 1) * (cellSize + daySpacing), "V").concat(yO + lastWeek * (cellSize + daySpacing)), "H".concat(xO + 7 * (cellSize + daySpacing), "V").concat(yO + firstWeek * (cellSize + daySpacing)), "H".concat(xO + firstDay * (cellSize + daySpacing), "Z")].join('');
        bbox.y = yO + firstWeek * (cellSize + daySpacing);
        bbox.width = 7 * (cellSize + daySpacing);
        bbox.height = yO + (lastWeek + 1) * (cellSize + daySpacing) - bbox.y;
      }
      return {
        path: path,
        bbox: bbox
      };
    };
    var memoMonthPathAndBBox = memoize(monthPathAndBBox, function (_ref3) {
      var date = _ref3.date,
          cellSize = _ref3.cellSize,
          yearIndex = _ref3.yearIndex,
          yearSpacing = _ref3.yearSpacing,
          daySpacing = _ref3.daySpacing,
          direction = _ref3.direction,
          originX = _ref3.originX,
          originY = _ref3.originY;
      return "".concat(date.toString(), ".").concat(cellSize, ".").concat(yearIndex, ".").concat(yearSpacing, ".").concat(daySpacing, ".").concat(direction, ".").concat(originX, ".").concat(originY);
    });
    var cellPositionHorizontal = function cellPositionHorizontal(cellSize, yearSpacing, daySpacing) {
      return function (originX, originY, d, yearIndex) {
        var weekOfYear = d3Time.timeWeek.count(d3Time.timeYear(d), d);
        return {
          x: originX + weekOfYear * (cellSize + daySpacing) + daySpacing / 2,
          y: originY + d.getDay() * (cellSize + daySpacing) + daySpacing / 2 + yearIndex * (yearSpacing + 7 * (cellSize + daySpacing))
        };
      };
    };
    var cellPositionVertical = function cellPositionVertical(cellSize, yearSpacing, daySpacing) {
      return function (originX, originY, d, yearIndex) {
        var weekOfYear = d3Time.timeWeek.count(d3Time.timeYear(d), d);
        return {
          x: originX + d.getDay() * (cellSize + daySpacing) + daySpacing / 2 + yearIndex * (yearSpacing + 7 * (cellSize + daySpacing)),
          y: originY + weekOfYear * (cellSize + daySpacing) + daySpacing / 2
        };
      };
    };
    var dayFormat = d3TimeFormat.timeFormat('%Y-%m-%d');
    var computeLayout = function computeLayout(_ref4) {
      var width = _ref4.width,
          height = _ref4.height,
          from = _ref4.from,
          to = _ref4.to,
          direction = _ref4.direction,
          yearSpacing = _ref4.yearSpacing,
          daySpacing = _ref4.daySpacing,
          align = _ref4.align;
      var fromDate = isDate(from) ? from : new Date(from);
      var toDate = isDate(to) ? to : new Date(to);
      var yearRange = range(fromDate.getFullYear(), toDate.getFullYear() + 1);
      var maxWeeks = Math.max.apply(Math, _toConsumableArray(yearRange.map(function (year) {
        return d3Time.timeWeeks(new Date(year, 0, 1), new Date(year + 1, 0, 1)).length;
      }))) + 1;
      var cellSize = computeCellSize({
        width: width,
        height: height,
        direction: direction,
        yearRange: yearRange,
        yearSpacing: yearSpacing,
        daySpacing: daySpacing,
        maxWeeks: maxWeeks
      });
      var monthsSize = cellSize * maxWeeks + daySpacing * maxWeeks;
      var yearsSize = (cellSize + daySpacing) * 7 * yearRange.length + yearSpacing * (yearRange.length - 1);
      var calendarWidth = direction === 'horizontal' ? monthsSize : yearsSize;
      var calendarHeight = direction === 'horizontal' ? yearsSize : monthsSize;
      var _alignBox = core.alignBox({
        x: 0,
        y: 0,
        width: calendarWidth,
        height: calendarHeight
      }, {
        x: 0,
        y: 0,
        width: width,
        height: height
      }, align),
          _alignBox2 = _slicedToArray(_alignBox, 2),
          originX = _alignBox2[0],
          originY = _alignBox2[1];
      var cellPosition;
      if (direction === 'horizontal') {
        cellPosition = cellPositionHorizontal(cellSize, yearSpacing, daySpacing);
      } else {
        cellPosition = cellPositionVertical(cellSize, yearSpacing, daySpacing);
      }
      var years = [];
      var months = [];
      var days = [];
      yearRange.forEach(function (year, i) {
        var yearStart = new Date(year, 0, 1);
        var yearEnd = new Date(year + 1, 0, 1);
        days = days.concat(d3Time.timeDays(yearStart, yearEnd).map(function (dayDate) {
          return _objectSpread$1({
            date: dayDate,
            day: dayFormat(dayDate),
            size: cellSize
          }, cellPosition(originX, originY, dayDate, i));
        }));
        var yearMonths = d3Time.timeMonths(yearStart, yearEnd).map(function (monthDate) {
          return _objectSpread$1({
            date: monthDate,
            year: monthDate.getFullYear(),
            month: monthDate.getMonth()
          }, memoMonthPathAndBBox({
            originX: originX,
            originY: originY,
            date: monthDate,
            direction: direction,
            yearIndex: i,
            yearSpacing: yearSpacing,
            daySpacing: daySpacing,
            cellSize: cellSize
          }));
        });
        months = months.concat(yearMonths);
        years.push({
          year: year,
          bbox: {
            x: yearMonths[0].bbox.x,
            y: yearMonths[0].bbox.y,
            width: yearMonths[11].bbox.x - yearMonths[0].bbox.x + yearMonths[11].bbox.width,
            height: yearMonths[11].bbox.y - yearMonths[0].bbox.y + yearMonths[11].bbox.height
          }
        });
      });
      return {
        years: years,
        months: months,
        days: days,
        cellSize: cellSize,
        calendarWidth: calendarWidth,
        calendarHeight: calendarHeight,
        originX: originX,
        originY: originY
      };
    };
    var bindDaysData = function bindDaysData(_ref5) {
      var days = _ref5.days,
          data = _ref5.data,
          colorScale = _ref5.colorScale,
          emptyColor = _ref5.emptyColor;
      return days.map(function (day) {
        day.color = emptyColor;
        data.forEach(function (dayData) {
          if (dayData.day === day.day) {
            day.value = dayData.value;
            day.color = colorScale(dayData.value);
            day.data = dayData;
          }
        });
        return day;
      });
    };
    var computeYearLegendPositions = function computeYearLegendPositions(_ref6) {
      var years = _ref6.years,
          direction = _ref6.direction,
          position = _ref6.position,
          offset = _ref6.offset;
      return years.map(function (year) {
        var x = 0;
        var y = 0;
        var rotation = 0;
        if (direction === 'horizontal' && position === 'before') {
          x = year.bbox.x - offset;
          y = year.bbox.y + year.bbox.height / 2;
          rotation = -90;
        } else if (direction === 'horizontal' && position === 'after') {
          x = year.bbox.x + year.bbox.width + offset;
          y = year.bbox.y + year.bbox.height / 2;
          rotation = -90;
        } else if (direction === 'vertical' && position === 'before') {
          x = year.bbox.x + year.bbox.width / 2;
          y = year.bbox.y - offset;
        } else {
          x = year.bbox.x + year.bbox.width / 2;
          y = year.bbox.y + year.bbox.height + offset;
        }
        return _objectSpread$1({}, year, {
          x: x,
          y: y,
          rotation: rotation
        });
      });
    };
    var computeMonthLegendPositions = function computeMonthLegendPositions(_ref7) {
      var months = _ref7.months,
          direction = _ref7.direction,
          position = _ref7.position,
          offset = _ref7.offset;
      return months.map(function (month) {
        var x = 0;
        var y = 0;
        var rotation = 0;
        if (direction === 'horizontal' && position === 'before') {
          x = month.bbox.x + month.bbox.width / 2;
          y = month.bbox.y - offset;
        } else if (direction === 'horizontal' && position === 'after') {
          x = month.bbox.x + month.bbox.width / 2;
          y = month.bbox.y + month.bbox.height + offset;
        } else if (direction === 'vertical' && position === 'before') {
          x = month.bbox.x - offset;
          y = month.bbox.y + month.bbox.height / 2;
          rotation = -90;
        } else {
          x = month.bbox.x + month.bbox.width + offset;
          y = month.bbox.y + month.bbox.height / 2;
          rotation = -90;
        }
        return _objectSpread$1({}, month, {
          x: x,
          y: y,
          rotation: rotation
        });
      });
    };

    var commonEnhancers = [core.withTheme(), core.withDimensions(), _withPropsOnChange(['data', 'minValue', 'maxValue', 'colors'], function (_ref) {
      var data = _ref.data,
          minValue = _ref.minValue,
          maxValue = _ref.maxValue,
          colors = _ref.colors;
      var domain = computeDomain(data, minValue, maxValue);
      var colorScale = d3Scale.scaleQuantize().domain(domain).range(colors);
      return {
        colorScale: colorScale
      };
    }), _withPropsOnChange(['width', 'height', 'from', 'to', 'direction', 'yearSpacing', 'daySpacing', 'align'], function (_ref2) {
      var width = _ref2.width,
          height = _ref2.height,
          from = _ref2.from,
          to = _ref2.to,
          direction = _ref2.direction,
          yearSpacing = _ref2.yearSpacing,
          daySpacing = _ref2.daySpacing,
          align = _ref2.align;
      return computeLayout({
        width: width,
        height: height,
        from: from,
        to: to,
        direction: direction,
        yearSpacing: yearSpacing,
        daySpacing: daySpacing,
        align: align
      });
    }), _withPropsOnChange(['years', 'direction', 'yearLegendPosition', 'yearLegendOffset'], function (_ref3) {
      var years = _ref3.years,
          direction = _ref3.direction,
          yearLegendPosition = _ref3.yearLegendPosition,
          yearLegendOffset = _ref3.yearLegendOffset;
      return {
        yearLegends: computeYearLegendPositions({
          years: years,
          direction: direction,
          position: yearLegendPosition,
          offset: yearLegendOffset
        })
      };
    }), _withPropsOnChange(['months', 'direction', 'monthLegendPosition', 'monthLegendOffset'], function (_ref4) {
      var months = _ref4.months,
          direction = _ref4.direction,
          monthLegendPosition = _ref4.monthLegendPosition,
          monthLegendOffset = _ref4.monthLegendOffset;
      return {
        monthLegends: computeMonthLegendPositions({
          months: months,
          direction: direction,
          position: monthLegendPosition,
          offset: monthLegendOffset
        })
      };
    }), _withPropsOnChange(['days', 'data', 'colorScale', 'emptyColor'], function (_ref5) {
      var days = _ref5.days,
          data = _ref5.data,
          colorScale = _ref5.colorScale,
          emptyColor = _ref5.emptyColor;
      return {
        days: bindDaysData({
          days: days,
          data: data,
          colorScale: colorScale,
          emptyColor: emptyColor
        })
      };
    })];
    var enhance = (function (Component) {
      switch (Component.displayName) {
        case 'Calendar':
          return _compose.apply(void 0, [_defaultProps(CalendarDefaultProps)].concat(commonEnhancers, [_pure]))(Component);
        case 'CalendarCanvas':
          return _compose.apply(void 0, [_defaultProps(CalendarCanvasDefaultProps)].concat(commonEnhancers, [_pure]))(Component);
      }
      return Component;
    });

    var CalendarYearLegends = React.memo(function (_ref) {
      var years = _ref.years,
          legend = _ref.legend,
          theme = _ref.theme;
      return React__default.createElement(React__default.Fragment, null, years.map(function (year) {
        return React__default.createElement("text", {
          key: year.year,
          transform: "translate(".concat(year.x, ",").concat(year.y, ") rotate(").concat(year.rotation, ")"),
          textAnchor: "middle",
          style: theme.labels.text
        }, legend(year.year));
      }));
    });
    CalendarYearLegends.propTypes = {
      years: PropTypes.array.isRequired,
      legend: PropTypes.func.isRequired,
      theme: PropTypes.object.isRequired
    };
    CalendarYearLegends.displayName = 'CalendarYearLegends';

    var CalendarMonthPath = function CalendarMonthPath(_ref) {
      var path = _ref.path,
          borderWidth = _ref.borderWidth,
          borderColor = _ref.borderColor;
      return React__default.createElement("path", {
        d: path,
        style: {
          fill: 'none',
          strokeWidth: borderWidth,
          stroke: borderColor,
          pointerEvents: 'none'
        }
      });
    };
    CalendarMonthPath.propTypes = {
      path: PropTypes.string.isRequired,
      borderWidth: PropTypes.number.isRequired,
      borderColor: PropTypes.string.isRequired
    };
    var CalendarMonthPath$1 = _pure(CalendarMonthPath);

    var CalendarMonthLegends = React.memo(function (_ref) {
      var months = _ref.months,
          legend = _ref.legend,
          theme = _ref.theme;
      return React__default.createElement(React__default.Fragment, null, months.map(function (month) {
        return React__default.createElement("text", {
          key: "".concat(month.date.toString(), ".legend"),
          transform: "translate(".concat(month.x, ",").concat(month.y, ") rotate(").concat(month.rotation, ")"),
          textAnchor: "middle",
          style: theme.labels.text
        }, legend(month.year, month.month, month.date));
      }));
    });
    CalendarMonthLegends.propTypes = {
      months: PropTypes.array.isRequired,
      legend: PropTypes.func.isRequired,
      theme: PropTypes.object.isRequired
    };
    CalendarMonthLegends.displayName = 'CalendarMonthLegends';

    function _objectSpread$2(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty$2(target, key, source[key]); }); } return target; }
    function _defineProperty$2(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
    var CalendarDay = React.memo(function (_ref) {
      var x = _ref.x,
          y = _ref.y,
          size = _ref.size,
          spacing = _ref.spacing,
          color = _ref.color,
          borderWidth = _ref.borderWidth,
          borderColor = _ref.borderColor,
          onClick = _ref.onClick,
          showTooltip = _ref.showTooltip,
          hideTooltip = _ref.hideTooltip;
      return React__default.createElement(React__default.Fragment, null, React__default.createElement("rect", {
        x: x,
        y: y,
        width: size,
        height: size,
        style: {
          fill: color,
          strokeWidth: borderWidth,
          stroke: borderColor
        }
      }), React__default.createElement("rect", {
        fill: "rgba(0, 0, 0, 0)",
        x: x - spacing / 2,
        y: y - spacing / 2,
        width: size + spacing,
        height: size + spacing,
        onClick: onClick,
        onMouseEnter: showTooltip,
        onMouseMove: showTooltip,
        onMouseLeave: hideTooltip
      }));
    });
    CalendarDay.propTypes = {
      onClick: PropTypes.func.isRequired,
      data: PropTypes.object.isRequired,
      x: PropTypes.number.isRequired,
      y: PropTypes.number.isRequired,
      size: PropTypes.number.isRequired,
      spacing: PropTypes.number.isRequired,
      color: PropTypes.string.isRequired,
      borderWidth: PropTypes.number.isRequired,
      borderColor: PropTypes.string.isRequired,
      tooltipFormat: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
      tooltip: PropTypes.func,
      showTooltip: PropTypes.func.isRequired,
      hideTooltip: PropTypes.func.isRequired,
      theme: PropTypes.shape({
        tooltip: PropTypes.shape({}).isRequired
      }).isRequired
    };
    CalendarDay.displayName = 'CalendarDay';
    var enhance$1 = _compose(_withPropsOnChange(['data', 'onClick'], function (_ref2) {
      var data = _ref2.data,
          _onClick = _ref2.onClick;
      return {
        onClick: function onClick(event) {
          return _onClick(data, event);
        }
      };
    }), _withPropsOnChange(['data', 'color', 'showTooltip', 'tooltipFormat', 'tooltip', 'theme'], function (_ref3) {
      var data = _ref3.data,
          color = _ref3.color,
          _showTooltip = _ref3.showTooltip,
          tooltipFormat = _ref3.tooltipFormat,
          tooltip$1 = _ref3.tooltip,
          theme = _ref3.theme;
      if (data.value === undefined) return {
        showTooltip: core.noop
      };
      return {
        showTooltip: function showTooltip(event) {
          return _showTooltip(React__default.createElement(tooltip.BasicTooltip, {
            id: "".concat(data.day),
            value: data.value,
            enableChip: true,
            color: color,
            theme: theme,
            format: tooltipFormat,
            renderContent: typeof tooltip$1 === 'function' ? tooltip$1.bind(null, _objectSpread$2({
              color: color
            }, data)) : null
          }), event);
        }
      };
    }), _pure);
    var CalendarDay$1 = enhance$1(CalendarDay);

    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); }
    var Calendar = function Calendar(_ref) {
      var colorScale = _ref.colorScale,
          margin = _ref.margin,
          width = _ref.width,
          height = _ref.height,
          outerWidth = _ref.outerWidth,
          outerHeight = _ref.outerHeight,
          yearLegends = _ref.yearLegends,
          yearLegend = _ref.yearLegend,
          monthLegends = _ref.monthLegends,
          monthLegend = _ref.monthLegend,
          monthBorderWidth = _ref.monthBorderWidth,
          monthBorderColor = _ref.monthBorderColor,
          daySpacing = _ref.daySpacing,
          dayBorderWidth = _ref.dayBorderWidth,
          dayBorderColor = _ref.dayBorderColor,
          theme = _ref.theme,
          isInteractive = _ref.isInteractive,
          tooltipFormat = _ref.tooltipFormat,
          tooltip = _ref.tooltip,
          onClick = _ref.onClick,
          legends$1 = _ref.legends,
          months = _ref.months,
          days = _ref.days;
      return React__default.createElement(core.Container, {
        isInteractive: isInteractive,
        theme: theme,
        animate: false
      }, function (_ref2) {
        var showTooltip = _ref2.showTooltip,
            hideTooltip = _ref2.hideTooltip;
        return React__default.createElement(core.SvgWrapper, {
          width: outerWidth,
          height: outerHeight,
          margin: margin,
          theme: theme
        }, days.map(function (d) {
          return React__default.createElement(CalendarDay$1, {
            key: d.date.toString(),
            data: d,
            x: d.x,
            y: d.y,
            size: d.size,
            spacing: daySpacing,
            color: d.color,
            borderWidth: dayBorderWidth,
            borderColor: dayBorderColor,
            showTooltip: showTooltip,
            hideTooltip: hideTooltip,
            tooltipFormat: tooltipFormat,
            tooltip: tooltip,
            theme: theme,
            onClick: onClick
          });
        }), months.map(function (m) {
          return React__default.createElement(CalendarMonthPath$1, {
            key: m.date.toString(),
            path: m.path,
            borderWidth: monthBorderWidth,
            borderColor: monthBorderColor
          });
        }), React__default.createElement(CalendarMonthLegends, {
          months: monthLegends,
          legend: monthLegend,
          theme: theme
        }), React__default.createElement(CalendarYearLegends, {
          years: yearLegends,
          legend: yearLegend,
          theme: theme
        }), legends$1.map(function (legend, i) {
          var legendData = colorScale.ticks(legend.itemCount).map(function (value) {
            return {
              id: value,
              label: value,
              color: colorScale(value)
            };
          });
          return React__default.createElement(legends.BoxLegendSvg, _extends({
            key: i
          }, legend, {
            containerWidth: width,
            containerHeight: height,
            data: legendData,
            theme: theme
          }));
        }));
      });
    };
    Calendar.displayName = 'Calendar';
    Calendar.propTypes = CalendarPropTypes;
    var Calendar$1 = _setDisplayName('Calendar')(enhance(Calendar));

    function _extends$1() { _extends$1 = 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$1.apply(this, arguments); }
    var ResponsiveCalendar = function ResponsiveCalendar(props) {
      return React__default.createElement(core.ResponsiveWrapper, null, function (_ref) {
        var width = _ref.width,
            height = _ref.height;
        return React__default.createElement(Calendar$1, _extends$1({
          width: width,
          height: height
        }, props));
      });
    };

    function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
    function _objectSpread$3(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty$3(target, key, source[key]); }); } return target; }
    function _slicedToArray$1(arr, i) { return _arrayWithHoles$1(arr) || _iterableToArrayLimit$1(arr, i) || _nonIterableRest$1(); }
    function _nonIterableRest$1() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
    function _iterableToArrayLimit$1(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
    function _arrayWithHoles$1(arr) { if (Array.isArray(arr)) return arr; }
    function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
    function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
    function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
    function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
    function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
    function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
    function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
    function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
    function _defineProperty$3(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
    var findDayUnderCursor = function findDayUnderCursor(days, size, spacing, margin, x, y) {
      return days.find(function (day) {
        return day.value !== undefined && core.isCursorInRect(day.x + margin.left - spacing / 2, day.y + margin.top - spacing / 2, size + spacing, size + spacing, x, y);
      });
    };
    var CalendarCanvas =
    function (_Component) {
      _inherits(CalendarCanvas, _Component);
      function CalendarCanvas() {
        var _getPrototypeOf2;
        var _this;
        _classCallCheck(this, CalendarCanvas);
        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
        }
        _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(CalendarCanvas)).call.apply(_getPrototypeOf2, [this].concat(args)));
        _defineProperty$3(_assertThisInitialized(_this), "handleMouseHover", function (showTooltip, hideTooltip) {
          return function (event) {
            var _this$props = _this.props,
                isInteractive = _this$props.isInteractive,
                margin = _this$props.margin,
                theme = _this$props.theme,
                days = _this$props.days,
                daySpacing = _this$props.daySpacing,
                tooltipFormat = _this$props.tooltipFormat,
                tooltip$1 = _this$props.tooltip;
            if (!isInteractive || !days || days.length === 0) return;
            var _getRelativeCursor = core.getRelativeCursor(_this.surface, event),
                _getRelativeCursor2 = _slicedToArray$1(_getRelativeCursor, 2),
                x = _getRelativeCursor2[0],
                y = _getRelativeCursor2[1];
            var currentDay = findDayUnderCursor(days, days[0].size, daySpacing, margin, x, y);
            if (currentDay !== undefined) {
              showTooltip(React__default.createElement(tooltip.BasicTooltip, {
                id: "".concat(currentDay.day),
                value: currentDay.value,
                enableChip: true,
                color: currentDay.color,
                theme: theme,
                format: tooltipFormat,
                renderContent: typeof tooltip$1 === 'function' ? tooltip$1.bind(null, currentDay) : null
              }), event);
            } else {
              hideTooltip();
            }
          };
        });
        _defineProperty$3(_assertThisInitialized(_this), "handleMouseLeave", function (hideTooltip) {
          return function () {
            if (_this.props.isInteractive !== true) return;
            hideTooltip();
          };
        });
        _defineProperty$3(_assertThisInitialized(_this), "handleClick", function (event) {
          var _this$props2 = _this.props,
              isInteractive = _this$props2.isInteractive,
              margin = _this$props2.margin,
              onClick = _this$props2.onClick,
              days = _this$props2.days,
              daySpacing = _this$props2.daySpacing;
          if (!isInteractive || !days || days.length === 0) return;
          var _getRelativeCursor3 = core.getRelativeCursor(_this.surface, event),
              _getRelativeCursor4 = _slicedToArray$1(_getRelativeCursor3, 2),
              x = _getRelativeCursor4[0],
              y = _getRelativeCursor4[1];
          var currentDay = findDayUnderCursor(days, days[0].size, daySpacing, margin, x, y);
          if (currentDay !== undefined) onClick(currentDay, event);
        });
        return _this;
      }
      _createClass(CalendarCanvas, [{
        key: "componentDidMount",
        value: function componentDidMount() {
          this.ctx = this.surface.getContext('2d');
          this.draw(this.props);
        }
      }, {
        key: "shouldComponentUpdate",
        value: function shouldComponentUpdate(props) {
          if (this.props.outerWidth !== props.outerWidth || this.props.outerHeight !== props.outerHeight || this.props.isInteractive !== props.isInteractive || this.props.theme !== props.theme) {
            return true;
          } else {
            this.draw(props);
            return false;
          }
        }
      }, {
        key: "componentDidUpdate",
        value: function componentDidUpdate() {
          this.ctx = this.surface.getContext('2d');
          this.draw(this.props);
        }
      }, {
        key: "draw",
        value: function draw(props) {
          var _this2 = this;
          var pixelRatio = props.pixelRatio,
              margin = props.margin,
              width = props.width,
              height = props.height,
              outerWidth = props.outerWidth,
              outerHeight = props.outerHeight,
              colorScale = props.colorScale,
              yearLegends = props.yearLegends,
              yearLegend = props.yearLegend,
              monthLegends = props.monthLegends,
              monthLegend = props.monthLegend,
              days = props.days,
              dayBorderWidth = props.dayBorderWidth,
              dayBorderColor = props.dayBorderColor,
              legends$1 = props.legends,
              theme = props.theme;
          this.surface.width = outerWidth * pixelRatio;
          this.surface.height = outerHeight * pixelRatio;
          this.ctx.scale(pixelRatio, pixelRatio);
          this.ctx.fillStyle = theme.background;
          this.ctx.fillRect(0, 0, outerWidth, outerHeight);
          this.ctx.translate(margin.left, margin.top);
          days.forEach(function (day) {
            _this2.ctx.fillStyle = day.color;
            if (dayBorderWidth > 0) {
              _this2.ctx.strokeStyle = dayBorderColor;
              _this2.ctx.lineWidth = dayBorderWidth;
            }
            _this2.ctx.beginPath();
            _this2.ctx.rect(day.x, day.y, day.size, day.size);
            _this2.ctx.fill();
            if (dayBorderWidth > 0) {
              _this2.ctx.stroke();
            }
          });
          this.ctx.textAlign = 'center';
          this.ctx.textBaseline = 'middle';
          this.ctx.fillStyle = theme.labels.text.fill;
          this.ctx.font = "".concat(theme.labels.text.fontSize, "px ").concat(theme.labels.text.fontFamily);
          monthLegends.forEach(function (month) {
            _this2.ctx.save();
            _this2.ctx.translate(month.x, month.y);
            _this2.ctx.rotate(core.degreesToRadians(month.rotation));
            _this2.ctx.fillText(monthLegend(month.year, month.month, month.date), 0, 0);
            _this2.ctx.restore();
          });
          yearLegends.forEach(function (year) {
            _this2.ctx.save();
            _this2.ctx.translate(year.x, year.y);
            _this2.ctx.rotate(core.degreesToRadians(year.rotation));
            _this2.ctx.fillText(yearLegend(year.year), 0, 0);
            _this2.ctx.restore();
          });
          legends$1.forEach(function (legend) {
            var legendData = colorScale.ticks(legend.itemCount).map(function (value) {
              return {
                id: value,
                label: value,
                color: colorScale(value)
              };
            });
            legends.renderLegendToCanvas(_this2.ctx, _objectSpread$3({}, legend, {
              data: legendData,
              containerWidth: width,
              containerHeight: height,
              theme: theme
            }));
          });
        }
      }, {
        key: "render",
        value: function render() {
          var _this3 = this;
          var _this$props3 = this.props,
              outerWidth = _this$props3.outerWidth,
              outerHeight = _this$props3.outerHeight,
              pixelRatio = _this$props3.pixelRatio,
              isInteractive = _this$props3.isInteractive,
              theme = _this$props3.theme;
          return React__default.createElement(core.Container, {
            isInteractive: isInteractive,
            theme: theme,
            animate: false
          }, function (_ref) {
            var showTooltip = _ref.showTooltip,
                hideTooltip = _ref.hideTooltip;
            return React__default.createElement("canvas", {
              ref: function ref(surface) {
                _this3.surface = surface;
              },
              width: outerWidth * pixelRatio,
              height: outerHeight * pixelRatio,
              style: {
                width: outerWidth,
                height: outerHeight
              },
              onMouseEnter: _this3.handleMouseHover(showTooltip, hideTooltip),
              onMouseMove: _this3.handleMouseHover(showTooltip, hideTooltip),
              onMouseLeave: _this3.handleMouseLeave(hideTooltip),
              onClick: _this3.handleClick
            });
          });
        }
      }]);
      return CalendarCanvas;
    }(React.Component);
    _defineProperty$3(CalendarCanvas, "propTypes", CalendarCanvasPropTypes);
    CalendarCanvas.displayName = 'CalendarCanvas';
    var CalendarCanvas$1 = _setDisplayName(CalendarCanvas.displayName)(enhance(CalendarCanvas));

    function _extends$2() { _extends$2 = 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$2.apply(this, arguments); }
    var ResponsiveCalendarCanvas = function ResponsiveCalendarCanvas(props) {
      return React__default.createElement(core.ResponsiveWrapper, null, function (_ref) {
        var width = _ref.width,
            height = _ref.height;
        return React__default.createElement(CalendarCanvas$1, _extends$2({
          width: width,
          height: height
        }, props));
      });
    };

    exports.Calendar = Calendar$1;
    exports.CalendarCanvas = CalendarCanvas$1;
    exports.CalendarCanvasDefaultProps = CalendarCanvasDefaultProps;
    exports.CalendarCanvasPropTypes = CalendarCanvasPropTypes;
    exports.CalendarDefaultProps = CalendarDefaultProps;
    exports.CalendarPropTypes = CalendarPropTypes;
    exports.ResponsiveCalendar = ResponsiveCalendar;
    exports.ResponsiveCalendarCanvas = ResponsiveCalendarCanvas;

    Object.defineProperty(exports, '__esModule', { value: true });

}));