react-calendar
Advanced tools
Comparing version 4.0.0 to 4.1.0
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
var __extends = (this && this.__extends) || (function () { | ||
var extendStatics = function (d, b) { | ||
extendStatics = Object.setPrototypeOf || | ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || | ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; | ||
return extendStatics(d, b); | ||
}; | ||
return function (d, b) { | ||
if (typeof b !== "function" && b !== null) | ||
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); | ||
extendStatics(d, b); | ||
function __() { this.constructor = d; } | ||
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); | ||
}; | ||
})(); | ||
var __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { | ||
if (k2 === undefined) k2 = k; | ||
var desc = Object.getOwnPropertyDescriptor(m, k); | ||
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { | ||
desc = { enumerable: true, get: function() { return m[k]; } }; | ||
} | ||
Object.defineProperty(o, k2, desc); | ||
}) : (function(o, m, k, k2) { | ||
if (k2 === undefined) k2 = k; | ||
o[k2] = m[k]; | ||
})); | ||
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { | ||
Object.defineProperty(o, "default", { enumerable: true, value: v }); | ||
}) : function(o, v) { | ||
o["default"] = v; | ||
}); | ||
exports["default"] = void 0; | ||
var _react = _interopRequireWildcard(require("react")); | ||
var _propTypes = _interopRequireDefault(require("prop-types")); | ||
var _clsx = _interopRequireDefault(require("clsx")); | ||
var _Navigation = _interopRequireDefault(require("./Calendar/Navigation")); | ||
var _CenturyView = _interopRequireDefault(require("./CenturyView")); | ||
var _DecadeView = _interopRequireDefault(require("./DecadeView")); | ||
var _YearView = _interopRequireDefault(require("./YearView")); | ||
var _MonthView = _interopRequireDefault(require("./MonthView")); | ||
var _dates = require("./shared/dates"); | ||
var _propTypes2 = require("./shared/propTypes"); | ||
var _utils = require("./shared/utils"); | ||
var _excluded = ["activeStartDate", "defaultActiveStartDate", "defaultValue", "defaultView", "maxDetail", "minDetail", "value", "view"]; | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } | ||
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } | ||
function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } | ||
function _extends() { _extends = Object.assign ? Object.assign.bind() : 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 _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); } | ||
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); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } | ||
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 } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); } | ||
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } | ||
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } | ||
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); } | ||
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } | ||
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } | ||
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } | ||
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } | ||
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(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; } | ||
function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } | ||
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; } | ||
function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); } | ||
function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } | ||
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } | ||
function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); } | ||
function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); } | ||
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } | ||
var __importStar = (this && this.__importStar) || function (mod) { | ||
if (mod && mod.__esModule) return mod; | ||
var result = {}; | ||
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); | ||
__setModuleDefault(result, mod); | ||
return result; | ||
}; | ||
var __rest = (this && this.__rest) || function (s, e) { | ||
var t = {}; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) | ||
t[p] = s[p]; | ||
if (s != null && typeof Object.getOwnPropertySymbols === "function") | ||
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { | ||
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) | ||
t[p[i]] = s[p[i]]; | ||
} | ||
return t; | ||
}; | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
var react_1 = __importStar(require("react")); | ||
var prop_types_1 = __importDefault(require("prop-types")); | ||
var clsx_1 = __importDefault(require("clsx")); | ||
var Navigation_1 = __importDefault(require("./Calendar/Navigation")); | ||
var CenturyView_1 = __importDefault(require("./CenturyView")); | ||
var DecadeView_1 = __importDefault(require("./DecadeView")); | ||
var YearView_1 = __importDefault(require("./YearView")); | ||
var MonthView_1 = __importDefault(require("./MonthView")); | ||
var dates_1 = require("./shared/dates"); | ||
var propTypes_1 = require("./shared/propTypes"); | ||
var utils_1 = require("./shared/utils"); | ||
var defaultMinDate = new Date(); | ||
@@ -51,10 +83,9 @@ defaultMinDate.setFullYear(1, 0, 1); | ||
var allViews = ['century', 'decade', 'year', 'month']; | ||
var allValueTypes = [].concat(_toConsumableArray(allViews.slice(1)), ['day']); | ||
var allValueTypes = ['decade', 'year', 'month', 'day']; | ||
function toDate(value) { | ||
if (value instanceof Date) { | ||
return value; | ||
} | ||
return new Date(value); | ||
if (value instanceof Date) { | ||
return value; | ||
} | ||
return new Date(value); | ||
} | ||
/** | ||
@@ -64,5 +95,4 @@ * Returns views array with disallowed values cut off. | ||
function getLimitedViews(minDetail, maxDetail) { | ||
return allViews.slice(allViews.indexOf(minDetail), allViews.indexOf(maxDetail) + 1); | ||
return allViews.slice(allViews.indexOf(minDetail), allViews.indexOf(maxDetail) + 1); | ||
} | ||
/** | ||
@@ -72,6 +102,5 @@ * Determines whether a given view is allowed with currently applied settings. | ||
function isViewAllowed(view, minDetail, maxDetail) { | ||
var views = getLimitedViews(minDetail, maxDetail); | ||
return views.indexOf(view) !== -1; | ||
var views = getLimitedViews(minDetail, maxDetail); | ||
return views.indexOf(view) !== -1; | ||
} | ||
/** | ||
@@ -82,617 +111,518 @@ * Gets either provided view if allowed by minDetail and maxDetail, or gets | ||
function getView(view, minDetail, maxDetail) { | ||
if (isViewAllowed(view, minDetail, maxDetail)) { | ||
return view; | ||
} | ||
return maxDetail; | ||
if (!view) { | ||
return maxDetail; | ||
} | ||
if (isViewAllowed(view, minDetail, maxDetail)) { | ||
return view; | ||
} | ||
return maxDetail; | ||
} | ||
/** | ||
* Returns value type that can be returned with currently applied settings. | ||
*/ | ||
function getValueType(maxDetail) { | ||
return allValueTypes[allViews.indexOf(maxDetail)]; | ||
function getValueType(view) { | ||
var index = allViews.indexOf(view); | ||
return allValueTypes[index]; | ||
} | ||
function getValue(value, index) { | ||
if (!value) { | ||
return null; | ||
} | ||
var rawValue = Array.isArray(value) && value.length === 2 ? value[index] : value; | ||
if (!rawValue) { | ||
return null; | ||
} | ||
var valueDate = toDate(rawValue); | ||
if (isNaN(valueDate.getTime())) { | ||
throw new Error("Invalid date: ".concat(value)); | ||
} | ||
return valueDate; | ||
var rawValue = Array.isArray(value) ? value[index] : value; | ||
if (!rawValue) { | ||
return null; | ||
} | ||
var valueDate = toDate(rawValue); | ||
if (isNaN(valueDate.getTime())) { | ||
throw new Error("Invalid date: ".concat(value)); | ||
} | ||
return valueDate; | ||
} | ||
function getDetailValue(_ref, index) { | ||
var value = _ref.value, | ||
minDate = _ref.minDate, | ||
maxDate = _ref.maxDate, | ||
maxDetail = _ref.maxDetail; | ||
var valuePiece = getValue(value, index); | ||
if (!valuePiece) { | ||
return null; | ||
} | ||
var valueType = getValueType(maxDetail); | ||
var detailValueFrom = [_dates.getBegin, _dates.getEnd][index](valueType, valuePiece); | ||
return (0, _utils.between)(detailValueFrom, minDate, maxDate); | ||
function getDetailValue(_a, index) { | ||
var value = _a.value, minDate = _a.minDate, maxDate = _a.maxDate, maxDetail = _a.maxDetail; | ||
var valuePiece = getValue(value, index); | ||
if (!valuePiece) { | ||
return null; | ||
} | ||
var valueType = getValueType(maxDetail); | ||
var detailValueFrom = (function () { | ||
switch (index) { | ||
case 0: | ||
return (0, dates_1.getBegin)(valueType, valuePiece); | ||
case 1: | ||
return (0, dates_1.getEnd)(valueType, valuePiece); | ||
default: | ||
throw new Error("Invalid index value: ".concat(index)); | ||
} | ||
})(); | ||
return (0, utils_1.between)(detailValueFrom, minDate, maxDate); | ||
} | ||
var getDetailValueFrom = function getDetailValueFrom(args) { | ||
return getDetailValue(args, 0); | ||
var getDetailValueFrom = function (args) { return getDetailValue(args, 0); }; | ||
var getDetailValueTo = function (args) { return getDetailValue(args, 1); }; | ||
var getDetailValueArray = function (args) { | ||
var value = args.value; | ||
if (Array.isArray(value)) { | ||
return value; | ||
} | ||
return [getDetailValueFrom, getDetailValueTo].map(function (fn) { return fn(args); }); | ||
}; | ||
var getDetailValueTo = function getDetailValueTo(args) { | ||
return getDetailValue(args, 1); | ||
}; | ||
var getDetailValueArray = function getDetailValueArray(args) { | ||
var value = args.value; | ||
if (Array.isArray(value)) { | ||
return value; | ||
} | ||
return [getDetailValueFrom, getDetailValueTo].map(function (fn) { | ||
return fn(args); | ||
}); | ||
}; | ||
function getActiveStartDate(props) { | ||
var maxDate = props.maxDate, | ||
maxDetail = props.maxDetail, | ||
minDate = props.minDate, | ||
minDetail = props.minDetail, | ||
value = props.value, | ||
view = props.view; | ||
var rangeType = getView(view, minDetail, maxDetail); | ||
var valueFrom = getDetailValueFrom({ | ||
value: value, | ||
minDate: minDate, | ||
maxDate: maxDate, | ||
maxDetail: maxDetail | ||
}) || new Date(); | ||
return (0, _dates.getBegin)(rangeType, valueFrom); | ||
var maxDate = props.maxDate, maxDetail = props.maxDetail, minDate = props.minDate, minDetail = props.minDetail, value = props.value, view = props.view; | ||
var rangeType = getView(view, minDetail, maxDetail); | ||
var valueFrom = getDetailValueFrom({ | ||
value: value, | ||
minDate: minDate, | ||
maxDate: maxDate, | ||
maxDetail: maxDetail, | ||
}) || new Date(); | ||
return (0, dates_1.getBegin)(rangeType, valueFrom); | ||
} | ||
function getInitialActiveStartDate(props) { | ||
var activeStartDate = props.activeStartDate, | ||
defaultActiveStartDate = props.defaultActiveStartDate, | ||
defaultValue = props.defaultValue, | ||
defaultView = props.defaultView, | ||
maxDetail = props.maxDetail, | ||
minDetail = props.minDetail, | ||
value = props.value, | ||
view = props.view, | ||
otherProps = _objectWithoutProperties(props, _excluded); | ||
var rangeType = getView(view, minDetail, maxDetail); | ||
var valueFrom = activeStartDate || defaultActiveStartDate; | ||
if (valueFrom) { | ||
return (0, _dates.getBegin)(rangeType, valueFrom); | ||
} | ||
return getActiveStartDate(_objectSpread({ | ||
maxDetail: maxDetail, | ||
minDetail: minDetail, | ||
value: value || defaultValue, | ||
view: view || defaultView | ||
}, otherProps)); | ||
var activeStartDate = props.activeStartDate, defaultActiveStartDate = props.defaultActiveStartDate, defaultValue = props.defaultValue, defaultView = props.defaultView, maxDetail = props.maxDetail, minDetail = props.minDetail, value = props.value, view = props.view, otherProps = __rest(props, ["activeStartDate", "defaultActiveStartDate", "defaultValue", "defaultView", "maxDetail", "minDetail", "value", "view"]); | ||
var rangeType = getView(view, minDetail, maxDetail); | ||
var valueFrom = activeStartDate || defaultActiveStartDate; | ||
if (valueFrom) { | ||
return (0, dates_1.getBegin)(rangeType, valueFrom); | ||
} | ||
return getActiveStartDate(__assign({ maxDetail: maxDetail, minDetail: minDetail, value: value || defaultValue, view: view || defaultView }, otherProps)); | ||
} | ||
var getIsSingleValue = function getIsSingleValue(value) { | ||
return value && [].concat(value).length === 1; | ||
}; | ||
var Calendar = /*#__PURE__*/function (_Component) { | ||
_inherits(Calendar, _Component); | ||
var _super = _createSuper(Calendar); | ||
function Calendar() { | ||
var _this; | ||
_classCallCheck(this, Calendar); | ||
for (var _len = arguments.length, _args = new Array(_len), _key = 0; _key < _len; _key++) { | ||
_args[_key] = arguments[_key]; | ||
} | ||
_this = _super.call.apply(_super, [this].concat(_args)); | ||
_defineProperty(_assertThisInitialized(_this), "state", { | ||
activeStartDate: _this.props.defaultActiveStartDate, | ||
value: _this.props.defaultValue, | ||
view: _this.props.defaultView | ||
}); | ||
_defineProperty(_assertThisInitialized(_this), "setStateAndCallCallbacks", function (nextState, event, callback) { | ||
var _assertThisInitialize = _assertThisInitialized(_this), | ||
previousActiveStartDate = _assertThisInitialize.activeStartDate, | ||
previousView = _assertThisInitialize.view; | ||
var _this$props = _this.props, | ||
allowPartialRange = _this$props.allowPartialRange, | ||
onActiveStartDateChange = _this$props.onActiveStartDateChange, | ||
onChange = _this$props.onChange, | ||
onViewChange = _this$props.onViewChange, | ||
selectRange = _this$props.selectRange; | ||
var prevArgs = { | ||
activeStartDate: previousActiveStartDate, | ||
view: previousView | ||
}; | ||
_this.setState(nextState, function () { | ||
var args = { | ||
action: nextState.action, | ||
activeStartDate: nextState.activeStartDate || _this.activeStartDate, | ||
value: nextState.value || _this.value, | ||
view: nextState.view || _this.view | ||
function getIsSingleValue(value) { | ||
return value && (!Array.isArray(value) || value.length === 1); | ||
} | ||
var isActiveStartDate = prop_types_1.default.instanceOf(Date); | ||
var isLooseValue = prop_types_1.default.oneOfType([prop_types_1.default.string, propTypes_1.isValue]); | ||
var Calendar = /** @class */ (function (_super) { | ||
__extends(Calendar, _super); | ||
function Calendar() { | ||
var _this = _super !== null && _super.apply(this, arguments) || this; | ||
_this.state = { | ||
activeStartDate: _this.props.defaultActiveStartDate, | ||
hover: null, | ||
value: typeof _this.props.defaultValue === 'string' | ||
? toDate(_this.props.defaultValue) | ||
: _this.props.defaultValue, | ||
view: _this.props.defaultView, | ||
}; | ||
function shouldUpdate(key) { | ||
return ( | ||
// Key must exist, and… | ||
key in nextState && ( | ||
// …key changed from undefined to defined or the other way around, or… | ||
_typeof(nextState[key]) !== _typeof(prevArgs[key]) || ( | ||
// …value changed. | ||
nextState[key] instanceof Date ? nextState[key].getTime() !== prevArgs[key].getTime() : nextState[key] !== prevArgs[key])) | ||
); | ||
} | ||
if (shouldUpdate('activeStartDate')) { | ||
if (onActiveStartDateChange) onActiveStartDateChange(args); | ||
} | ||
if (shouldUpdate('view')) { | ||
if (onViewChange) onViewChange(args); | ||
} | ||
if (shouldUpdate('value')) { | ||
if (onChange) { | ||
_this.setStateAndCallCallbacks = function (nextState, event, callback) { | ||
var _a = _this, previousActiveStartDate = _a.activeStartDate, previousView = _a.view; | ||
var _b = _this.props, allowPartialRange = _b.allowPartialRange, onActiveStartDateChange = _b.onActiveStartDateChange, onChange = _b.onChange, onViewChange = _b.onViewChange, selectRange = _b.selectRange; | ||
var prevArgs = { | ||
action: undefined, | ||
activeStartDate: previousActiveStartDate, | ||
value: undefined, | ||
view: previousView, | ||
}; | ||
_this.setState(nextState, function () { | ||
var args = { | ||
action: nextState.action, | ||
activeStartDate: nextState.activeStartDate || _this.activeStartDate, | ||
value: ('value' in nextState && nextState.value) || _this.value, | ||
view: ('view' in nextState && nextState.view) || _this.view, | ||
}; | ||
function shouldUpdate(key) { | ||
// Key must exist, and… | ||
if (!(key in nextState)) { | ||
return false; | ||
} | ||
var nextValue = nextState[key]; | ||
var prevValue = prevArgs[key]; | ||
// …key changed from defined to undefined or the other way around, or… | ||
if (typeof nextValue !== typeof prevValue) { | ||
return true; | ||
} | ||
// …value changed. | ||
if (nextValue instanceof Date && prevValue instanceof Date) { | ||
return nextValue.getTime() !== prevValue.getTime(); | ||
} | ||
else { | ||
return nextValue !== prevValue; | ||
} | ||
} | ||
if (shouldUpdate('activeStartDate')) { | ||
if (onActiveStartDateChange) | ||
onActiveStartDateChange(args); | ||
} | ||
if (shouldUpdate('view')) { | ||
if (onViewChange) | ||
onViewChange(args); | ||
} | ||
if (shouldUpdate('value')) { | ||
if (onChange) { | ||
if (!event) { | ||
throw new Error('event is required'); | ||
} | ||
if (selectRange) { | ||
var isSingleValue = getIsSingleValue(nextState.value); | ||
if (!isSingleValue) { | ||
onChange(nextState.value || null, event); | ||
} | ||
else if (allowPartialRange) { | ||
if (Array.isArray(nextState.value)) { | ||
throw new Error('value must not be an array'); | ||
} | ||
onChange([nextState.value || null], event); | ||
} | ||
} | ||
else { | ||
onChange(nextState.value || null, event); | ||
} | ||
} | ||
} | ||
if (callback) | ||
callback(args); | ||
}); | ||
}; | ||
/** | ||
* Called when the user uses navigation buttons. | ||
*/ | ||
_this.setActiveStartDate = function (nextActiveStartDate, action) { | ||
_this.setStateAndCallCallbacks({ | ||
action: action, | ||
activeStartDate: nextActiveStartDate, | ||
}); | ||
}; | ||
_this.drillDown = function (nextActiveStartDate, event) { | ||
if (!_this.drillDownAvailable) { | ||
return; | ||
} | ||
_this.onClickTile(nextActiveStartDate, event); | ||
var _a = _this, view = _a.view, views = _a.views; | ||
var onDrillDown = _this.props.onDrillDown; | ||
var nextView = views[views.indexOf(view) + 1]; | ||
if (!nextView) { | ||
throw new Error('Attempted to drill down from the lowest view.'); | ||
} | ||
_this.setStateAndCallCallbacks({ | ||
action: 'drillDown', | ||
activeStartDate: nextActiveStartDate, | ||
view: nextView, | ||
}, undefined, onDrillDown); | ||
}; | ||
_this.drillUp = function () { | ||
if (!_this.drillUpAvailable) { | ||
return; | ||
} | ||
var _a = _this, activeStartDate = _a.activeStartDate, view = _a.view, views = _a.views; | ||
var onDrillUp = _this.props.onDrillUp; | ||
var nextView = views[views.indexOf(view) - 1]; | ||
if (!nextView) { | ||
throw new Error('Attempted to drill up from the highest view.'); | ||
} | ||
var nextActiveStartDate = (0, dates_1.getBegin)(nextView, activeStartDate); | ||
_this.setStateAndCallCallbacks({ | ||
action: 'drillUp', | ||
activeStartDate: nextActiveStartDate, | ||
view: nextView, | ||
}, undefined, onDrillUp); | ||
}; | ||
_this.onChange = function (value, event) { | ||
var previousValue = _this.value; | ||
var _a = _this.props, goToRangeStartOnSelect = _a.goToRangeStartOnSelect, selectRange = _a.selectRange; | ||
_this.onClickTile(value, event); | ||
var isFirstValueInRange = selectRange && !getIsSingleValue(previousValue); | ||
var nextValue; | ||
if (selectRange) { | ||
var isSingleValue = getIsSingleValue(nextState.value); | ||
if (!isSingleValue) { | ||
onChange(nextState.value, event); | ||
} else if (allowPartialRange) { | ||
onChange([nextState.value], event); | ||
} | ||
} else { | ||
onChange(nextState.value, event); | ||
// Range selection turned on | ||
var valueType = _this.valueType; | ||
if (isFirstValueInRange) { | ||
// Value has 0 or 2 elements - either way we're starting a new array | ||
// First value | ||
nextValue = (0, dates_1.getBegin)(valueType, value); | ||
} | ||
else { | ||
if (!previousValue) { | ||
throw new Error('previousValue is required'); | ||
} | ||
if (Array.isArray(previousValue)) { | ||
throw new Error('previousValue must not be an array'); | ||
} | ||
// Second value | ||
nextValue = (0, dates_1.getValueRange)(valueType, previousValue, value); | ||
} | ||
} | ||
} | ||
} | ||
if (callback) callback(args); | ||
}); | ||
else { | ||
// Range selection turned off | ||
nextValue = _this.getProcessedValue(value); | ||
} | ||
var nextActiveStartDate = | ||
// Range selection turned off | ||
!selectRange || | ||
// Range selection turned on, first value | ||
isFirstValueInRange || | ||
// Range selection turned on, second value, goToRangeStartOnSelect toggled on | ||
goToRangeStartOnSelect | ||
? getActiveStartDate(__assign(__assign({}, _this.props), { value: nextValue })) | ||
: null; | ||
event.persist(); | ||
_this.setStateAndCallCallbacks({ | ||
action: 'onChange', | ||
activeStartDate: nextActiveStartDate, | ||
value: nextValue, | ||
}, event); | ||
}; | ||
_this.onClickTile = function (value, event) { | ||
var view = _this.view; | ||
var _a = _this.props, onClickDay = _a.onClickDay, onClickDecade = _a.onClickDecade, onClickMonth = _a.onClickMonth, onClickYear = _a.onClickYear; | ||
var callback = (function () { | ||
switch (view) { | ||
case 'century': | ||
return onClickDecade; | ||
case 'decade': | ||
return onClickYear; | ||
case 'year': | ||
return onClickMonth; | ||
case 'month': | ||
return onClickDay; | ||
default: | ||
throw new Error("Invalid view: ".concat(view, ".")); | ||
} | ||
})(); | ||
if (callback) | ||
callback(value, event); | ||
}; | ||
_this.onMouseOver = function (value) { | ||
_this.setState(function (prevState) { | ||
if (prevState.hover && prevState.hover.getTime() === value.getTime()) { | ||
return null; | ||
} | ||
return { hover: value }; | ||
}); | ||
}; | ||
_this.onMouseLeave = function () { | ||
_this.setState({ hover: null }); | ||
}; | ||
return _this; | ||
} | ||
Object.defineProperty(Calendar.prototype, "activeStartDate", { | ||
get: function () { | ||
var activeStartDateProps = this.props.activeStartDate; | ||
var activeStartDateState = this.state.activeStartDate; | ||
return activeStartDateProps || activeStartDateState || getInitialActiveStartDate(this.props); | ||
}, | ||
enumerable: false, | ||
configurable: true | ||
}); | ||
_defineProperty(_assertThisInitialized(_this), "setActiveStartDate", function (nextActiveStartDate, action) { | ||
_this.setStateAndCallCallbacks({ | ||
action: action, | ||
activeStartDate: nextActiveStartDate | ||
}); | ||
Object.defineProperty(Calendar.prototype, "value", { | ||
get: function () { | ||
var _a = this.props, selectRange = _a.selectRange, valueProps = _a.value; | ||
var valueState = this.state.value; | ||
var rawValue = (function () { | ||
// In the middle of range selection, use value from state | ||
if (selectRange && getIsSingleValue(valueState)) { | ||
return valueState; | ||
} | ||
return valueProps !== undefined ? valueProps : valueState; | ||
})(); | ||
if (!rawValue) { | ||
return null; | ||
} | ||
return typeof rawValue === 'string' ? toDate(rawValue) : rawValue; | ||
}, | ||
enumerable: false, | ||
configurable: true | ||
}); | ||
_defineProperty(_assertThisInitialized(_this), "drillDown", function (nextActiveStartDate, event) { | ||
if (!_this.drillDownAvailable) { | ||
return; | ||
} | ||
_this.onClickTile(nextActiveStartDate, event); | ||
var _assertThisInitialize2 = _assertThisInitialized(_this), | ||
view = _assertThisInitialize2.view, | ||
views = _assertThisInitialize2.views; | ||
var onDrillDown = _this.props.onDrillDown; | ||
var nextView = views[views.indexOf(view) + 1]; | ||
_this.setStateAndCallCallbacks({ | ||
action: 'drillDown', | ||
activeStartDate: nextActiveStartDate, | ||
view: nextView | ||
}, undefined, onDrillDown); | ||
Object.defineProperty(Calendar.prototype, "valueType", { | ||
get: function () { | ||
var maxDetail = this.props.maxDetail; | ||
return getValueType(maxDetail); | ||
}, | ||
enumerable: false, | ||
configurable: true | ||
}); | ||
_defineProperty(_assertThisInitialized(_this), "drillUp", function () { | ||
if (!_this.drillUpAvailable) { | ||
return; | ||
} | ||
var _assertThisInitialize3 = _assertThisInitialized(_this), | ||
activeStartDate = _assertThisInitialize3.activeStartDate, | ||
view = _assertThisInitialize3.view, | ||
views = _assertThisInitialize3.views; | ||
var onDrillUp = _this.props.onDrillUp; | ||
var nextView = views[views.indexOf(view) - 1]; | ||
var nextActiveStartDate = (0, _dates.getBegin)(nextView, activeStartDate); | ||
_this.setStateAndCallCallbacks({ | ||
action: 'drillUp', | ||
activeStartDate: nextActiveStartDate, | ||
view: nextView | ||
}, undefined, onDrillUp); | ||
Object.defineProperty(Calendar.prototype, "view", { | ||
get: function () { | ||
var _a = this.props, minDetail = _a.minDetail, maxDetail = _a.maxDetail, viewProps = _a.view; | ||
var viewState = this.state.view; | ||
return getView(viewProps || viewState, minDetail, maxDetail); | ||
}, | ||
enumerable: false, | ||
configurable: true | ||
}); | ||
_defineProperty(_assertThisInitialized(_this), "onChange", function (value, event) { | ||
var _assertThisInitialize4 = _assertThisInitialized(_this), | ||
previousValue = _assertThisInitialize4.value; | ||
var _this$props2 = _this.props, | ||
goToRangeStartOnSelect = _this$props2.goToRangeStartOnSelect, | ||
selectRange = _this$props2.selectRange; | ||
_this.onClickTile(value, event); | ||
var isFirstValueInRange = selectRange && !getIsSingleValue(previousValue); | ||
var nextValue; | ||
if (selectRange) { | ||
// Range selection turned on | ||
var _assertThisInitialize5 = _assertThisInitialized(_this), | ||
valueType = _assertThisInitialize5.valueType; | ||
if (isFirstValueInRange) { | ||
// Value has 0 or 2 elements - either way we're starting a new array | ||
// First value | ||
nextValue = (0, _dates.getBegin)(valueType, value); | ||
} else { | ||
// Second value | ||
nextValue = (0, _dates.getValueRange)(valueType, previousValue, value); | ||
} | ||
} else { | ||
// Range selection turned off | ||
nextValue = _this.getProcessedValue(value); | ||
} | ||
var nextActiveStartDate = | ||
// Range selection turned off | ||
!selectRange || | ||
// Range selection turned on, first value | ||
isFirstValueInRange || | ||
// Range selection turned on, second value, goToRangeStartOnSelect toggled on | ||
goToRangeStartOnSelect ? getActiveStartDate(_objectSpread(_objectSpread({}, _this.props), {}, { | ||
value: nextValue | ||
})) : null; | ||
event.persist(); | ||
_this.setStateAndCallCallbacks({ | ||
action: 'onChange', | ||
activeStartDate: nextActiveStartDate, | ||
value: nextValue | ||
}, event); | ||
Object.defineProperty(Calendar.prototype, "views", { | ||
get: function () { | ||
var _a = this.props, minDetail = _a.minDetail, maxDetail = _a.maxDetail; | ||
return getLimitedViews(minDetail, maxDetail); | ||
}, | ||
enumerable: false, | ||
configurable: true | ||
}); | ||
_defineProperty(_assertThisInitialized(_this), "onClickTile", function (value, event) { | ||
var _assertThisInitialize6 = _assertThisInitialized(_this), | ||
view = _assertThisInitialize6.view; | ||
var _this$props3 = _this.props, | ||
onClickDay = _this$props3.onClickDay, | ||
onClickDecade = _this$props3.onClickDecade, | ||
onClickMonth = _this$props3.onClickMonth, | ||
onClickYear = _this$props3.onClickYear; | ||
var callback = function () { | ||
switch (view) { | ||
case 'century': | ||
return onClickDecade; | ||
case 'decade': | ||
return onClickYear; | ||
case 'year': | ||
return onClickMonth; | ||
case 'month': | ||
return onClickDay; | ||
default: | ||
throw new Error("Invalid view: ".concat(view, ".")); | ||
} | ||
}(); | ||
if (callback) callback(value, event); | ||
Object.defineProperty(Calendar.prototype, "hover", { | ||
get: function () { | ||
var selectRange = this.props.selectRange; | ||
var hover = this.state.hover; | ||
return selectRange ? hover : null; | ||
}, | ||
enumerable: false, | ||
configurable: true | ||
}); | ||
_defineProperty(_assertThisInitialized(_this), "onMouseOver", function (value) { | ||
_this.setState(function (prevState) { | ||
if (prevState.hover && prevState.hover.getTime() === value.getTime()) { | ||
return null; | ||
} | ||
return { | ||
hover: value | ||
}; | ||
}); | ||
Object.defineProperty(Calendar.prototype, "drillDownAvailable", { | ||
get: function () { | ||
var _a = this, view = _a.view, views = _a.views; | ||
return views.indexOf(view) < views.length - 1; | ||
}, | ||
enumerable: false, | ||
configurable: true | ||
}); | ||
_defineProperty(_assertThisInitialized(_this), "onMouseLeave", function () { | ||
_this.setState({ | ||
hover: null | ||
}); | ||
Object.defineProperty(Calendar.prototype, "drillUpAvailable", { | ||
get: function () { | ||
var _a = this, view = _a.view, views = _a.views; | ||
return views.indexOf(view) > 0; | ||
}, | ||
enumerable: false, | ||
configurable: true | ||
}); | ||
return _this; | ||
} | ||
_createClass(Calendar, [{ | ||
key: "activeStartDate", | ||
get: function get() { | ||
var activeStartDateProps = this.props.activeStartDate; | ||
var activeStartDateState = this.state.activeStartDate; | ||
return activeStartDateProps || activeStartDateState || getInitialActiveStartDate(this.props); | ||
} | ||
}, { | ||
key: "value", | ||
get: function get() { | ||
var _this$props4 = this.props, | ||
selectRange = _this$props4.selectRange, | ||
valueProps = _this$props4.value; | ||
var valueState = this.state.value; | ||
// In the middle of range selection, use value from state | ||
if (selectRange && getIsSingleValue(valueState)) { | ||
return valueState; | ||
} | ||
return valueProps !== undefined ? valueProps : valueState; | ||
} | ||
}, { | ||
key: "valueType", | ||
get: function get() { | ||
var maxDetail = this.props.maxDetail; | ||
return getValueType(maxDetail); | ||
} | ||
}, { | ||
key: "view", | ||
get: function get() { | ||
var _this$props5 = this.props, | ||
minDetail = _this$props5.minDetail, | ||
maxDetail = _this$props5.maxDetail, | ||
viewProps = _this$props5.view; | ||
var viewState = this.state.view; | ||
return getView(viewProps || viewState, minDetail, maxDetail); | ||
} | ||
}, { | ||
key: "views", | ||
get: function get() { | ||
var _this$props6 = this.props, | ||
minDetail = _this$props6.minDetail, | ||
maxDetail = _this$props6.maxDetail; | ||
return getLimitedViews(minDetail, maxDetail); | ||
} | ||
}, { | ||
key: "hover", | ||
get: function get() { | ||
var selectRange = this.props.selectRange; | ||
var hover = this.state.hover; | ||
return selectRange ? hover : null; | ||
} | ||
}, { | ||
key: "drillDownAvailable", | ||
get: function get() { | ||
var view = this.view, | ||
views = this.views; | ||
return views.indexOf(view) < views.length - 1; | ||
} | ||
}, { | ||
key: "drillUpAvailable", | ||
get: function get() { | ||
var view = this.view, | ||
views = this.views; | ||
return views.indexOf(view) > 0; | ||
} | ||
/** | ||
* Gets current value in a desired format. | ||
*/ | ||
}, { | ||
key: "getProcessedValue", | ||
value: function getProcessedValue(value) { | ||
var _this$props7 = this.props, | ||
minDate = _this$props7.minDate, | ||
maxDate = _this$props7.maxDate, | ||
maxDetail = _this$props7.maxDetail, | ||
returnValue = _this$props7.returnValue; | ||
var processFunction = function () { | ||
switch (returnValue) { | ||
case 'start': | ||
return getDetailValueFrom; | ||
case 'end': | ||
return getDetailValueTo; | ||
case 'range': | ||
return getDetailValueArray; | ||
default: | ||
throw new Error('Invalid returnValue.'); | ||
Calendar.prototype.getProcessedValue = function (value) { | ||
var _a = this.props, minDate = _a.minDate, maxDate = _a.maxDate, maxDetail = _a.maxDetail, returnValue = _a.returnValue; | ||
var processFunction = (function () { | ||
switch (returnValue) { | ||
case 'start': | ||
return getDetailValueFrom; | ||
case 'end': | ||
return getDetailValueTo; | ||
case 'range': | ||
return getDetailValueArray; | ||
default: | ||
throw new Error('Invalid returnValue.'); | ||
} | ||
})(); | ||
return processFunction({ | ||
value: value, | ||
minDate: minDate, | ||
maxDate: maxDate, | ||
maxDetail: maxDetail, | ||
}); | ||
}; | ||
Calendar.prototype.renderContent = function (next) { | ||
var _a = this, currentActiveStartDate = _a.activeStartDate, onMouseOver = _a.onMouseOver, valueType = _a.valueType, value = _a.value, view = _a.view; | ||
var _b = this.props, calendarType = _b.calendarType, locale = _b.locale, maxDate = _b.maxDate, minDate = _b.minDate, selectRange = _b.selectRange, tileClassName = _b.tileClassName, tileContent = _b.tileContent, tileDisabled = _b.tileDisabled; | ||
var hover = this.hover; | ||
var activeStartDate = next | ||
? (0, dates_1.getBeginNext)(view, currentActiveStartDate) | ||
: (0, dates_1.getBegin)(view, currentActiveStartDate); | ||
var onClick = this.drillDownAvailable ? this.drillDown : this.onChange; | ||
var commonProps = { | ||
activeStartDate: activeStartDate, | ||
hover: hover, | ||
locale: locale, | ||
maxDate: maxDate, | ||
minDate: minDate, | ||
onClick: onClick, | ||
onMouseOver: selectRange ? onMouseOver : null, | ||
tileClassName: tileClassName, | ||
tileContent: tileContent, | ||
tileDisabled: tileDisabled, | ||
value: value, | ||
valueType: valueType, | ||
}; | ||
switch (view) { | ||
case 'century': { | ||
var formatYear = this.props.formatYear; | ||
return react_1.default.createElement(CenturyView_1.default, __assign({ formatYear: formatYear }, commonProps)); | ||
} | ||
case 'decade': { | ||
var formatYear = this.props.formatYear; | ||
return react_1.default.createElement(DecadeView_1.default, __assign({ formatYear: formatYear }, commonProps)); | ||
} | ||
case 'year': { | ||
var _c = this.props, formatMonth = _c.formatMonth, formatMonthYear = _c.formatMonthYear; | ||
return (react_1.default.createElement(YearView_1.default, __assign({ formatMonth: formatMonth, formatMonthYear: formatMonthYear }, commonProps))); | ||
} | ||
case 'month': { | ||
var _d = this.props, formatDay = _d.formatDay, formatLongDate = _d.formatLongDate, formatShortWeekday = _d.formatShortWeekday, formatWeekday = _d.formatWeekday, onClickWeekNumber = _d.onClickWeekNumber, showDoubleView = _d.showDoubleView, showFixedNumberOfWeeks = _d.showFixedNumberOfWeeks, showNeighboringMonth = _d.showNeighboringMonth, showWeekNumbers = _d.showWeekNumbers; | ||
var onMouseLeave = this.onMouseLeave; | ||
return (react_1.default.createElement(MonthView_1.default, __assign({ calendarType: calendarType, formatDay: formatDay, formatLongDate: formatLongDate, formatShortWeekday: formatShortWeekday, formatWeekday: formatWeekday, onClickWeekNumber: onClickWeekNumber, onMouseLeave: selectRange ? onMouseLeave : null, showFixedNumberOfWeeks: typeof showFixedNumberOfWeeks !== 'undefined' | ||
? showFixedNumberOfWeeks | ||
: showDoubleView, showNeighboringMonth: showNeighboringMonth, showWeekNumbers: showWeekNumbers }, commonProps))); | ||
} | ||
default: | ||
throw new Error("Invalid view: ".concat(view, ".")); | ||
} | ||
}(); | ||
return processFunction({ | ||
value: value, | ||
minDate: minDate, | ||
maxDate: maxDate, | ||
maxDetail: maxDetail | ||
}); | ||
} | ||
}, { | ||
key: "renderContent", | ||
value: function renderContent(next) { | ||
var currentActiveStartDate = this.activeStartDate, | ||
onMouseOver = this.onMouseOver, | ||
valueType = this.valueType, | ||
value = this.value, | ||
view = this.view; | ||
var _this$props8 = this.props, | ||
calendarType = _this$props8.calendarType, | ||
locale = _this$props8.locale, | ||
maxDate = _this$props8.maxDate, | ||
minDate = _this$props8.minDate, | ||
selectRange = _this$props8.selectRange, | ||
tileClassName = _this$props8.tileClassName, | ||
tileContent = _this$props8.tileContent, | ||
tileDisabled = _this$props8.tileDisabled; | ||
var hover = this.hover; | ||
var activeStartDate = next ? (0, _dates.getBeginNext)(view, currentActiveStartDate) : (0, _dates.getBegin)(view, currentActiveStartDate); | ||
var onClick = this.drillDownAvailable ? this.drillDown : this.onChange; | ||
var commonProps = { | ||
activeStartDate: activeStartDate, | ||
hover: hover, | ||
locale: locale, | ||
maxDate: maxDate, | ||
minDate: minDate, | ||
onClick: onClick, | ||
onMouseOver: selectRange ? onMouseOver : null, | ||
tileClassName: tileClassName, | ||
tileContent: tileContent, | ||
tileDisabled: tileDisabled, | ||
value: value, | ||
valueType: valueType | ||
}; | ||
switch (view) { | ||
case 'century': | ||
{ | ||
var formatYear = this.props.formatYear; | ||
return /*#__PURE__*/_react["default"].createElement(_CenturyView["default"], _extends({ | ||
formatYear: formatYear | ||
}, commonProps)); | ||
} | ||
case 'decade': | ||
{ | ||
var _formatYear = this.props.formatYear; | ||
return /*#__PURE__*/_react["default"].createElement(_DecadeView["default"], _extends({ | ||
formatYear: _formatYear | ||
}, commonProps)); | ||
} | ||
case 'year': | ||
{ | ||
var _this$props9 = this.props, | ||
formatMonth = _this$props9.formatMonth, | ||
formatMonthYear = _this$props9.formatMonthYear; | ||
return /*#__PURE__*/_react["default"].createElement(_YearView["default"], _extends({ | ||
formatMonth: formatMonth, | ||
formatMonthYear: formatMonthYear | ||
}, commonProps)); | ||
} | ||
case 'month': | ||
{ | ||
var _this$props10 = this.props, | ||
formatDay = _this$props10.formatDay, | ||
formatLongDate = _this$props10.formatLongDate, | ||
formatShortWeekday = _this$props10.formatShortWeekday, | ||
formatWeekday = _this$props10.formatWeekday, | ||
onClickWeekNumber = _this$props10.onClickWeekNumber, | ||
showDoubleView = _this$props10.showDoubleView, | ||
showFixedNumberOfWeeks = _this$props10.showFixedNumberOfWeeks, | ||
showNeighboringMonth = _this$props10.showNeighboringMonth, | ||
showWeekNumbers = _this$props10.showWeekNumbers; | ||
var onMouseLeave = this.onMouseLeave; | ||
return /*#__PURE__*/_react["default"].createElement(_MonthView["default"], _extends({ | ||
calendarType: calendarType, | ||
formatDay: formatDay, | ||
formatLongDate: formatLongDate, | ||
formatShortWeekday: formatShortWeekday, | ||
formatWeekday: formatWeekday, | ||
onClickWeekNumber: onClickWeekNumber, | ||
onMouseLeave: selectRange ? onMouseLeave : null, | ||
showFixedNumberOfWeeks: typeof showFixedNumberOfWeeks !== 'undefined' ? showFixedNumberOfWeeks : showDoubleView, | ||
showNeighboringMonth: showNeighboringMonth, | ||
showWeekNumbers: showWeekNumbers | ||
}, commonProps)); | ||
} | ||
default: | ||
throw new Error("Invalid view: ".concat(view, ".")); | ||
} | ||
} | ||
}, { | ||
key: "renderNavigation", | ||
value: function renderNavigation() { | ||
var showNavigation = this.props.showNavigation; | ||
if (!showNavigation) { | ||
return null; | ||
} | ||
var activeStartDate = this.activeStartDate, | ||
view = this.view, | ||
views = this.views; | ||
var _this$props11 = this.props, | ||
formatMonthYear = _this$props11.formatMonthYear, | ||
formatYear = _this$props11.formatYear, | ||
locale = _this$props11.locale, | ||
maxDate = _this$props11.maxDate, | ||
minDate = _this$props11.minDate, | ||
navigationAriaLabel = _this$props11.navigationAriaLabel, | ||
navigationAriaLive = _this$props11.navigationAriaLive, | ||
navigationLabel = _this$props11.navigationLabel, | ||
next2AriaLabel = _this$props11.next2AriaLabel, | ||
next2Label = _this$props11.next2Label, | ||
nextAriaLabel = _this$props11.nextAriaLabel, | ||
nextLabel = _this$props11.nextLabel, | ||
prev2AriaLabel = _this$props11.prev2AriaLabel, | ||
prev2Label = _this$props11.prev2Label, | ||
prevAriaLabel = _this$props11.prevAriaLabel, | ||
prevLabel = _this$props11.prevLabel, | ||
showDoubleView = _this$props11.showDoubleView; | ||
return /*#__PURE__*/_react["default"].createElement(_Navigation["default"], { | ||
activeStartDate: activeStartDate, | ||
drillUp: this.drillUp, | ||
formatMonthYear: formatMonthYear, | ||
formatYear: formatYear, | ||
locale: locale, | ||
maxDate: maxDate, | ||
minDate: minDate, | ||
navigationAriaLabel: navigationAriaLabel, | ||
navigationAriaLive: navigationAriaLive, | ||
navigationLabel: navigationLabel, | ||
next2AriaLabel: next2AriaLabel, | ||
next2Label: next2Label, | ||
nextAriaLabel: nextAriaLabel, | ||
nextLabel: nextLabel, | ||
prev2AriaLabel: prev2AriaLabel, | ||
prev2Label: prev2Label, | ||
prevAriaLabel: prevAriaLabel, | ||
prevLabel: prevLabel, | ||
setActiveStartDate: this.setActiveStartDate, | ||
showDoubleView: showDoubleView, | ||
view: view, | ||
views: views | ||
}); | ||
} | ||
}, { | ||
key: "render", | ||
value: function render() { | ||
var _this$props12 = this.props, | ||
className = _this$props12.className, | ||
inputRef = _this$props12.inputRef, | ||
selectRange = _this$props12.selectRange, | ||
showDoubleView = _this$props12.showDoubleView; | ||
var onMouseLeave = this.onMouseLeave, | ||
value = this.value; | ||
var valueArray = [].concat(value); | ||
return /*#__PURE__*/_react["default"].createElement("div", { | ||
className: (0, _clsx["default"])(baseClassName, selectRange && valueArray.length === 1 && "".concat(baseClassName, "--selectRange"), showDoubleView && "".concat(baseClassName, "--doubleView"), className), | ||
ref: inputRef | ||
}, this.renderNavigation(), /*#__PURE__*/_react["default"].createElement("div", { | ||
className: "".concat(baseClassName, "__viewContainer"), | ||
onBlur: selectRange ? onMouseLeave : null, | ||
onMouseLeave: selectRange ? onMouseLeave : null | ||
}, this.renderContent(), showDoubleView && this.renderContent(true))); | ||
} | ||
}]); | ||
return Calendar; | ||
}(_react.Component); | ||
exports["default"] = Calendar; | ||
Calendar.defaultProps = { | ||
goToRangeStartOnSelect: true, | ||
maxDate: defaultMaxDate, | ||
maxDetail: 'month', | ||
minDate: defaultMinDate, | ||
minDetail: 'century', | ||
returnValue: 'start', | ||
showNavigation: true, | ||
showNeighboringMonth: true | ||
}; | ||
var isActiveStartDate = _propTypes["default"].instanceOf(Date); | ||
var isLooseValue = _propTypes["default"].oneOfType([_propTypes["default"].string, _propTypes2.isValue]); | ||
Calendar.propTypes = { | ||
activeStartDate: isActiveStartDate, | ||
allowPartialRange: _propTypes["default"].bool, | ||
calendarType: _propTypes2.isCalendarType, | ||
className: _propTypes2.isClassName, | ||
defaultActiveStartDate: isActiveStartDate, | ||
defaultValue: isLooseValue, | ||
defaultView: _propTypes2.isView, | ||
formatDay: _propTypes["default"].func, | ||
formatLongDate: _propTypes["default"].func, | ||
formatMonth: _propTypes["default"].func, | ||
formatMonthYear: _propTypes["default"].func, | ||
formatShortWeekday: _propTypes["default"].func, | ||
formatWeekday: _propTypes["default"].func, | ||
formatYear: _propTypes["default"].func, | ||
goToRangeStartOnSelect: _propTypes["default"].bool, | ||
inputRef: _propTypes2.isRef, | ||
locale: _propTypes["default"].string, | ||
maxDate: _propTypes2.isMaxDate, | ||
maxDetail: _propTypes["default"].oneOf(allViews), | ||
minDate: _propTypes2.isMinDate, | ||
minDetail: _propTypes["default"].oneOf(allViews), | ||
navigationAriaLabel: _propTypes["default"].string, | ||
navigationAriaLive: _propTypes["default"].oneOf(['off', 'polite', 'assertive']), | ||
navigationLabel: _propTypes["default"].func, | ||
next2AriaLabel: _propTypes["default"].string, | ||
next2Label: _propTypes["default"].node, | ||
nextAriaLabel: _propTypes["default"].string, | ||
nextLabel: _propTypes["default"].node, | ||
onActiveStartDateChange: _propTypes["default"].func, | ||
onChange: _propTypes["default"].func, | ||
onClickDay: _propTypes["default"].func, | ||
onClickDecade: _propTypes["default"].func, | ||
onClickMonth: _propTypes["default"].func, | ||
onClickWeekNumber: _propTypes["default"].func, | ||
onClickYear: _propTypes["default"].func, | ||
onDrillDown: _propTypes["default"].func, | ||
onDrillUp: _propTypes["default"].func, | ||
onViewChange: _propTypes["default"].func, | ||
prev2AriaLabel: _propTypes["default"].string, | ||
prev2Label: _propTypes["default"].node, | ||
prevAriaLabel: _propTypes["default"].string, | ||
prevLabel: _propTypes["default"].node, | ||
returnValue: _propTypes["default"].oneOf(['start', 'end', 'range']), | ||
selectRange: _propTypes["default"].bool, | ||
showDoubleView: _propTypes["default"].bool, | ||
showFixedNumberOfWeeks: _propTypes["default"].bool, | ||
showNavigation: _propTypes["default"].bool, | ||
showNeighboringMonth: _propTypes["default"].bool, | ||
showWeekNumbers: _propTypes["default"].bool, | ||
tileClassName: _propTypes["default"].oneOfType([_propTypes["default"].func, _propTypes2.isClassName]), | ||
tileContent: _propTypes["default"].oneOfType([_propTypes["default"].func, _propTypes["default"].node]), | ||
tileDisabled: _propTypes["default"].func, | ||
value: isLooseValue, | ||
view: _propTypes2.isView | ||
}; | ||
}; | ||
Calendar.prototype.renderNavigation = function () { | ||
var showNavigation = this.props.showNavigation; | ||
if (!showNavigation) { | ||
return null; | ||
} | ||
var _a = this, activeStartDate = _a.activeStartDate, view = _a.view, views = _a.views; | ||
var _b = this.props, formatMonthYear = _b.formatMonthYear, formatYear = _b.formatYear, locale = _b.locale, maxDate = _b.maxDate, minDate = _b.minDate, navigationAriaLabel = _b.navigationAriaLabel, navigationAriaLive = _b.navigationAriaLive, navigationLabel = _b.navigationLabel, next2AriaLabel = _b.next2AriaLabel, next2Label = _b.next2Label, nextAriaLabel = _b.nextAriaLabel, nextLabel = _b.nextLabel, prev2AriaLabel = _b.prev2AriaLabel, prev2Label = _b.prev2Label, prevAriaLabel = _b.prevAriaLabel, prevLabel = _b.prevLabel, showDoubleView = _b.showDoubleView; | ||
return (react_1.default.createElement(Navigation_1.default, { activeStartDate: activeStartDate, drillUp: this.drillUp, formatMonthYear: formatMonthYear, formatYear: formatYear, locale: locale, maxDate: maxDate, minDate: minDate, navigationAriaLabel: navigationAriaLabel, navigationAriaLive: navigationAriaLive, navigationLabel: navigationLabel, next2AriaLabel: next2AriaLabel, next2Label: next2Label, nextAriaLabel: nextAriaLabel, nextLabel: nextLabel, prev2AriaLabel: prev2AriaLabel, prev2Label: prev2Label, prevAriaLabel: prevAriaLabel, prevLabel: prevLabel, setActiveStartDate: this.setActiveStartDate, showDoubleView: showDoubleView, view: view, views: views })); | ||
}; | ||
Calendar.prototype.render = function () { | ||
var _a = this.props, className = _a.className, inputRef = _a.inputRef, selectRange = _a.selectRange, showDoubleView = _a.showDoubleView; | ||
var _b = this, onMouseLeave = _b.onMouseLeave, value = _b.value; | ||
var valueArray = Array.isArray(value) ? value : [value]; | ||
return (react_1.default.createElement("div", { className: (0, clsx_1.default)(baseClassName, selectRange && valueArray.length === 1 && "".concat(baseClassName, "--selectRange"), showDoubleView && "".concat(baseClassName, "--doubleView"), className), ref: inputRef }, | ||
this.renderNavigation(), | ||
react_1.default.createElement("div", { className: "".concat(baseClassName, "__viewContainer"), onBlur: selectRange ? onMouseLeave : undefined, onMouseLeave: selectRange ? onMouseLeave : undefined }, | ||
this.renderContent(), | ||
showDoubleView ? this.renderContent(true) : null))); | ||
}; | ||
Calendar.defaultProps = { | ||
goToRangeStartOnSelect: true, | ||
maxDate: defaultMaxDate, | ||
maxDetail: 'month', | ||
minDate: defaultMinDate, | ||
minDetail: 'century', | ||
returnValue: 'start', | ||
showNavigation: true, | ||
showNeighboringMonth: true, | ||
}; | ||
Calendar.propTypes = { | ||
activeStartDate: isActiveStartDate, | ||
allowPartialRange: prop_types_1.default.bool, | ||
calendarType: propTypes_1.isCalendarType, | ||
className: propTypes_1.isClassName, | ||
defaultActiveStartDate: isActiveStartDate, | ||
defaultValue: isLooseValue, | ||
defaultView: propTypes_1.isView, | ||
formatDay: prop_types_1.default.func, | ||
formatLongDate: prop_types_1.default.func, | ||
formatMonth: prop_types_1.default.func, | ||
formatMonthYear: prop_types_1.default.func, | ||
formatShortWeekday: prop_types_1.default.func, | ||
formatWeekday: prop_types_1.default.func, | ||
formatYear: prop_types_1.default.func, | ||
goToRangeStartOnSelect: prop_types_1.default.bool, | ||
inputRef: propTypes_1.isRef, | ||
locale: prop_types_1.default.string, | ||
maxDate: propTypes_1.isMaxDate, | ||
maxDetail: prop_types_1.default.oneOf(allViews), | ||
minDate: propTypes_1.isMinDate, | ||
minDetail: prop_types_1.default.oneOf(allViews), | ||
navigationAriaLabel: prop_types_1.default.string, | ||
navigationAriaLive: prop_types_1.default.oneOf(['off', 'polite', 'assertive']), | ||
navigationLabel: prop_types_1.default.func, | ||
next2AriaLabel: prop_types_1.default.string, | ||
next2Label: prop_types_1.default.node, | ||
nextAriaLabel: prop_types_1.default.string, | ||
nextLabel: prop_types_1.default.node, | ||
onActiveStartDateChange: prop_types_1.default.func, | ||
onChange: prop_types_1.default.func, | ||
onClickDay: prop_types_1.default.func, | ||
onClickDecade: prop_types_1.default.func, | ||
onClickMonth: prop_types_1.default.func, | ||
onClickWeekNumber: prop_types_1.default.func, | ||
onClickYear: prop_types_1.default.func, | ||
onDrillDown: prop_types_1.default.func, | ||
onDrillUp: prop_types_1.default.func, | ||
onViewChange: prop_types_1.default.func, | ||
prev2AriaLabel: prop_types_1.default.string, | ||
prev2Label: prop_types_1.default.node, | ||
prevAriaLabel: prop_types_1.default.string, | ||
prevLabel: prop_types_1.default.node, | ||
returnValue: prop_types_1.default.oneOf(['start', 'end', 'range']), | ||
selectRange: prop_types_1.default.bool, | ||
showDoubleView: prop_types_1.default.bool, | ||
showFixedNumberOfWeeks: prop_types_1.default.bool, | ||
showNavigation: prop_types_1.default.bool, | ||
showNeighboringMonth: prop_types_1.default.bool, | ||
showWeekNumbers: prop_types_1.default.bool, | ||
tileClassName: prop_types_1.default.oneOfType([prop_types_1.default.func, propTypes_1.isClassName]), | ||
tileContent: prop_types_1.default.oneOfType([prop_types_1.default.func, prop_types_1.default.node]), | ||
tileDisabled: prop_types_1.default.func, | ||
value: isLooseValue, | ||
view: propTypes_1.isView, | ||
}; | ||
return Calendar; | ||
}(react_1.Component)); | ||
exports.default = Calendar; |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
exports["default"] = Navigation; | ||
var _react = _interopRequireDefault(require("react")); | ||
var _propTypes = _interopRequireDefault(require("prop-types")); | ||
var _getUserLocale = require("get-user-locale"); | ||
var _dates = require("../shared/dates"); | ||
var _dateFormatter = require("../shared/dateFormatter"); | ||
var _propTypes2 = require("../shared/propTypes"); | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
var react_1 = __importDefault(require("react")); | ||
var prop_types_1 = __importDefault(require("prop-types")); | ||
var get_user_locale_1 = require("get-user-locale"); | ||
var dates_1 = require("../shared/dates"); | ||
var dateFormatter_1 = require("../shared/dateFormatter"); | ||
var propTypes_1 = require("../shared/propTypes"); | ||
var className = 'react-calendar__navigation'; | ||
function Navigation(_ref) { | ||
var activeStartDate = _ref.activeStartDate, | ||
drillUp = _ref.drillUp, | ||
_ref$formatMonthYear = _ref.formatMonthYear, | ||
formatMonthYear = _ref$formatMonthYear === void 0 ? _dateFormatter.formatMonthYear : _ref$formatMonthYear, | ||
_ref$formatYear = _ref.formatYear, | ||
formatYear = _ref$formatYear === void 0 ? _dateFormatter.formatYear : _ref$formatYear, | ||
locale = _ref.locale, | ||
maxDate = _ref.maxDate, | ||
minDate = _ref.minDate, | ||
_ref$navigationAriaLa = _ref.navigationAriaLabel, | ||
navigationAriaLabel = _ref$navigationAriaLa === void 0 ? '' : _ref$navigationAriaLa, | ||
navigationAriaLive = _ref.navigationAriaLive, | ||
navigationLabel = _ref.navigationLabel, | ||
_ref$next2AriaLabel = _ref.next2AriaLabel, | ||
next2AriaLabel = _ref$next2AriaLabel === void 0 ? '' : _ref$next2AriaLabel, | ||
_ref$next2Label = _ref.next2Label, | ||
next2Label = _ref$next2Label === void 0 ? '»' : _ref$next2Label, | ||
_ref$nextAriaLabel = _ref.nextAriaLabel, | ||
nextAriaLabel = _ref$nextAriaLabel === void 0 ? '' : _ref$nextAriaLabel, | ||
_ref$nextLabel = _ref.nextLabel, | ||
nextLabel = _ref$nextLabel === void 0 ? '›' : _ref$nextLabel, | ||
_ref$prev2AriaLabel = _ref.prev2AriaLabel, | ||
prev2AriaLabel = _ref$prev2AriaLabel === void 0 ? '' : _ref$prev2AriaLabel, | ||
_ref$prev2Label = _ref.prev2Label, | ||
prev2Label = _ref$prev2Label === void 0 ? '«' : _ref$prev2Label, | ||
_ref$prevAriaLabel = _ref.prevAriaLabel, | ||
prevAriaLabel = _ref$prevAriaLabel === void 0 ? '' : _ref$prevAriaLabel, | ||
_ref$prevLabel = _ref.prevLabel, | ||
prevLabel = _ref$prevLabel === void 0 ? '‹' : _ref$prevLabel, | ||
setActiveStartDate = _ref.setActiveStartDate, | ||
showDoubleView = _ref.showDoubleView, | ||
view = _ref.view, | ||
views = _ref.views; | ||
var drillUpAvailable = views.indexOf(view) > 0; | ||
var shouldShowPrevNext2Buttons = view !== 'century'; | ||
var previousActiveStartDate = (0, _dates.getBeginPrevious)(view, activeStartDate); | ||
var previousActiveStartDate2 = shouldShowPrevNext2Buttons && (0, _dates.getBeginPrevious2)(view, activeStartDate); | ||
var nextActiveStartDate = (0, _dates.getBeginNext)(view, activeStartDate); | ||
var nextActiveStartDate2 = shouldShowPrevNext2Buttons && (0, _dates.getBeginNext2)(view, activeStartDate); | ||
var prevButtonDisabled = function () { | ||
if (previousActiveStartDate.getFullYear() < 0) { | ||
return true; | ||
function Navigation(_a) { | ||
var activeStartDate = _a.activeStartDate, drillUp = _a.drillUp, _b = _a.formatMonthYear, formatMonthYear = _b === void 0 ? dateFormatter_1.formatMonthYear : _b, _c = _a.formatYear, formatYear = _c === void 0 ? dateFormatter_1.formatYear : _c, locale = _a.locale, maxDate = _a.maxDate, minDate = _a.minDate, _d = _a.navigationAriaLabel, navigationAriaLabel = _d === void 0 ? '' : _d, navigationAriaLive = _a.navigationAriaLive, navigationLabel = _a.navigationLabel, _e = _a.next2AriaLabel, next2AriaLabel = _e === void 0 ? '' : _e, _f = _a.next2Label, next2Label = _f === void 0 ? '»' : _f, _g = _a.nextAriaLabel, nextAriaLabel = _g === void 0 ? '' : _g, _h = _a.nextLabel, nextLabel = _h === void 0 ? '›' : _h, _j = _a.prev2AriaLabel, prev2AriaLabel = _j === void 0 ? '' : _j, _k = _a.prev2Label, prev2Label = _k === void 0 ? '«' : _k, _l = _a.prevAriaLabel, prevAriaLabel = _l === void 0 ? '' : _l, _m = _a.prevLabel, prevLabel = _m === void 0 ? '‹' : _m, setActiveStartDate = _a.setActiveStartDate, showDoubleView = _a.showDoubleView, view = _a.view, views = _a.views; | ||
var drillUpAvailable = views.indexOf(view) > 0; | ||
var shouldShowPrevNext2Buttons = view !== 'century'; | ||
var previousActiveStartDate = (0, dates_1.getBeginPrevious)(view, activeStartDate); | ||
var previousActiveStartDate2 = shouldShowPrevNext2Buttons | ||
? (0, dates_1.getBeginPrevious2)(view, activeStartDate) | ||
: undefined; | ||
var nextActiveStartDate = (0, dates_1.getBeginNext)(view, activeStartDate); | ||
var nextActiveStartDate2 = shouldShowPrevNext2Buttons | ||
? (0, dates_1.getBeginNext2)(view, activeStartDate) | ||
: undefined; | ||
var prevButtonDisabled = (function () { | ||
if (previousActiveStartDate.getFullYear() < 0) { | ||
return true; | ||
} | ||
var previousActiveEndDate = (0, dates_1.getEndPrevious)(view, activeStartDate); | ||
return minDate && minDate >= previousActiveEndDate; | ||
})(); | ||
var prev2ButtonDisabled = shouldShowPrevNext2Buttons && | ||
(function () { | ||
if (previousActiveStartDate2.getFullYear() < 0) { | ||
return true; | ||
} | ||
var previousActiveEndDate = (0, dates_1.getEndPrevious2)(view, activeStartDate); | ||
return minDate && minDate >= previousActiveEndDate; | ||
})(); | ||
var nextButtonDisabled = maxDate && maxDate < nextActiveStartDate; | ||
var next2ButtonDisabled = shouldShowPrevNext2Buttons && maxDate && maxDate < nextActiveStartDate2; | ||
function onClickPrevious() { | ||
setActiveStartDate(previousActiveStartDate, 'prev'); | ||
} | ||
var previousActiveEndDate = (0, _dates.getEndPrevious)(view, activeStartDate); | ||
return minDate && minDate >= previousActiveEndDate; | ||
}(); | ||
var prev2ButtonDisabled = shouldShowPrevNext2Buttons && function () { | ||
if (previousActiveStartDate2.getFullYear() < 0) { | ||
return true; | ||
function onClickPrevious2() { | ||
setActiveStartDate(previousActiveStartDate2, 'prev2'); | ||
} | ||
var previousActiveEndDate = (0, _dates.getEndPrevious2)(view, activeStartDate); | ||
return minDate && minDate >= previousActiveEndDate; | ||
}(); | ||
var nextButtonDisabled = maxDate && maxDate < nextActiveStartDate; | ||
var next2ButtonDisabled = shouldShowPrevNext2Buttons && maxDate && maxDate < nextActiveStartDate2; | ||
function onClickPrevious() { | ||
setActiveStartDate(previousActiveStartDate, 'prev'); | ||
} | ||
function onClickPrevious2() { | ||
setActiveStartDate(previousActiveStartDate2, 'prev2'); | ||
} | ||
function onClickNext() { | ||
setActiveStartDate(nextActiveStartDate, 'next'); | ||
} | ||
function onClickNext2() { | ||
setActiveStartDate(nextActiveStartDate2, 'next2'); | ||
} | ||
function renderLabel(date) { | ||
var label = function () { | ||
switch (view) { | ||
case 'century': | ||
return (0, _dates.getCenturyLabel)(locale, formatYear, date); | ||
case 'decade': | ||
return (0, _dates.getDecadeLabel)(locale, formatYear, date); | ||
case 'year': | ||
return formatYear(locale, date); | ||
case 'month': | ||
return formatMonthYear(locale, date); | ||
default: | ||
throw new Error("Invalid view: ".concat(view, ".")); | ||
} | ||
}(); | ||
return navigationLabel ? navigationLabel({ | ||
date: date, | ||
label: label, | ||
locale: locale || (0, _getUserLocale.getUserLocale)(), | ||
view: view | ||
}) : label; | ||
} | ||
function renderButton() { | ||
var labelClassName = "".concat(className, "__label"); | ||
return /*#__PURE__*/_react["default"].createElement("button", { | ||
"aria-label": navigationAriaLabel, | ||
"aria-live": navigationAriaLive, | ||
className: labelClassName, | ||
disabled: !drillUpAvailable, | ||
onClick: drillUp, | ||
style: { | ||
flexGrow: 1 | ||
}, | ||
type: "button" | ||
}, /*#__PURE__*/_react["default"].createElement("span", { | ||
className: "".concat(labelClassName, "__labelText ").concat(labelClassName, "__labelText--from") | ||
}, renderLabel(activeStartDate)), showDoubleView && /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, null, /*#__PURE__*/_react["default"].createElement("span", { | ||
className: "".concat(labelClassName, "__divider") | ||
}, " \u2013 "), /*#__PURE__*/_react["default"].createElement("span", { | ||
className: "".concat(labelClassName, "__labelText ").concat(labelClassName, "__labelText--to") | ||
}, renderLabel(nextActiveStartDate)))); | ||
} | ||
return /*#__PURE__*/_react["default"].createElement("div", { | ||
className: className | ||
}, prev2Label !== null && shouldShowPrevNext2Buttons && /*#__PURE__*/_react["default"].createElement("button", { | ||
"aria-label": prev2AriaLabel, | ||
className: "".concat(className, "__arrow ").concat(className, "__prev2-button"), | ||
disabled: prev2ButtonDisabled, | ||
onClick: onClickPrevious2, | ||
type: "button" | ||
}, prev2Label), prevLabel !== null && /*#__PURE__*/_react["default"].createElement("button", { | ||
"aria-label": prevAriaLabel, | ||
className: "".concat(className, "__arrow ").concat(className, "__prev-button"), | ||
disabled: prevButtonDisabled, | ||
onClick: onClickPrevious, | ||
type: "button" | ||
}, prevLabel), renderButton(), nextLabel !== null && /*#__PURE__*/_react["default"].createElement("button", { | ||
"aria-label": nextAriaLabel, | ||
className: "".concat(className, "__arrow ").concat(className, "__next-button"), | ||
disabled: nextButtonDisabled, | ||
onClick: onClickNext, | ||
type: "button" | ||
}, nextLabel), next2Label !== null && shouldShowPrevNext2Buttons && /*#__PURE__*/_react["default"].createElement("button", { | ||
"aria-label": next2AriaLabel, | ||
className: "".concat(className, "__arrow ").concat(className, "__next2-button"), | ||
disabled: next2ButtonDisabled, | ||
onClick: onClickNext2, | ||
type: "button" | ||
}, next2Label)); | ||
function onClickNext() { | ||
setActiveStartDate(nextActiveStartDate, 'next'); | ||
} | ||
function onClickNext2() { | ||
setActiveStartDate(nextActiveStartDate2, 'next2'); | ||
} | ||
function renderLabel(date) { | ||
var label = (function () { | ||
switch (view) { | ||
case 'century': | ||
return (0, dates_1.getCenturyLabel)(locale, formatYear, date); | ||
case 'decade': | ||
return (0, dates_1.getDecadeLabel)(locale, formatYear, date); | ||
case 'year': | ||
return formatYear(locale, date); | ||
case 'month': | ||
return formatMonthYear(locale, date); | ||
default: | ||
throw new Error("Invalid view: ".concat(view, ".")); | ||
} | ||
})(); | ||
return navigationLabel | ||
? navigationLabel({ | ||
date: date, | ||
label: label, | ||
locale: locale || (0, get_user_locale_1.getUserLocale)() || undefined, | ||
view: view, | ||
}) | ||
: label; | ||
} | ||
function renderButton() { | ||
var labelClassName = "".concat(className, "__label"); | ||
return (react_1.default.createElement("button", { "aria-label": navigationAriaLabel, "aria-live": navigationAriaLive, className: labelClassName, disabled: !drillUpAvailable, onClick: drillUp, style: { flexGrow: 1 }, type: "button" }, | ||
react_1.default.createElement("span", { className: "".concat(labelClassName, "__labelText ").concat(labelClassName, "__labelText--from") }, renderLabel(activeStartDate)), | ||
showDoubleView ? (react_1.default.createElement(react_1.default.Fragment, null, | ||
react_1.default.createElement("span", { className: "".concat(labelClassName, "__divider") }, " \u2013 "), | ||
react_1.default.createElement("span", { className: "".concat(labelClassName, "__labelText ").concat(labelClassName, "__labelText--to") }, renderLabel(nextActiveStartDate)))) : null)); | ||
} | ||
return (react_1.default.createElement("div", { className: className }, | ||
prev2Label !== null && shouldShowPrevNext2Buttons ? (react_1.default.createElement("button", { "aria-label": prev2AriaLabel, className: "".concat(className, "__arrow ").concat(className, "__prev2-button"), disabled: prev2ButtonDisabled, onClick: onClickPrevious2, type: "button" }, prev2Label)) : null, | ||
prevLabel !== null && (react_1.default.createElement("button", { "aria-label": prevAriaLabel, className: "".concat(className, "__arrow ").concat(className, "__prev-button"), disabled: prevButtonDisabled, onClick: onClickPrevious, type: "button" }, prevLabel)), | ||
renderButton(), | ||
nextLabel !== null && (react_1.default.createElement("button", { "aria-label": nextAriaLabel, className: "".concat(className, "__arrow ").concat(className, "__next-button"), disabled: nextButtonDisabled, onClick: onClickNext, type: "button" }, nextLabel)), | ||
next2Label !== null && shouldShowPrevNext2Buttons ? (react_1.default.createElement("button", { "aria-label": next2AriaLabel, className: "".concat(className, "__arrow ").concat(className, "__next2-button"), disabled: next2ButtonDisabled, onClick: onClickNext2, type: "button" }, next2Label)) : null)); | ||
} | ||
exports.default = Navigation; | ||
Navigation.propTypes = { | ||
activeStartDate: _propTypes["default"].instanceOf(Date).isRequired, | ||
drillUp: _propTypes["default"].func.isRequired, | ||
formatMonthYear: _propTypes["default"].func, | ||
formatYear: _propTypes["default"].func, | ||
locale: _propTypes["default"].string, | ||
maxDate: _propTypes["default"].instanceOf(Date), | ||
minDate: _propTypes["default"].instanceOf(Date), | ||
navigationAriaLabel: _propTypes["default"].string, | ||
navigationAriaLive: _propTypes["default"].string, | ||
navigationLabel: _propTypes["default"].func, | ||
next2AriaLabel: _propTypes["default"].string, | ||
next2Label: _propTypes["default"].node, | ||
nextAriaLabel: _propTypes["default"].string, | ||
nextLabel: _propTypes["default"].node, | ||
prev2AriaLabel: _propTypes["default"].string, | ||
prev2Label: _propTypes["default"].node, | ||
prevAriaLabel: _propTypes["default"].string, | ||
prevLabel: _propTypes["default"].node, | ||
setActiveStartDate: _propTypes["default"].func.isRequired, | ||
showDoubleView: _propTypes["default"].bool, | ||
view: _propTypes2.isView.isRequired, | ||
views: _propTypes2.isViews.isRequired | ||
}; | ||
activeStartDate: prop_types_1.default.instanceOf(Date).isRequired, | ||
drillUp: prop_types_1.default.func.isRequired, | ||
formatMonthYear: prop_types_1.default.func, | ||
formatYear: prop_types_1.default.func, | ||
locale: prop_types_1.default.string, | ||
maxDate: prop_types_1.default.instanceOf(Date), | ||
minDate: prop_types_1.default.instanceOf(Date), | ||
navigationAriaLabel: prop_types_1.default.string, | ||
navigationAriaLive: prop_types_1.default.string, | ||
navigationLabel: prop_types_1.default.func, | ||
next2AriaLabel: prop_types_1.default.string, | ||
next2Label: prop_types_1.default.node, | ||
nextAriaLabel: prop_types_1.default.string, | ||
nextLabel: prop_types_1.default.node, | ||
prev2AriaLabel: prop_types_1.default.string, | ||
prev2Label: prop_types_1.default.node, | ||
prevAriaLabel: prop_types_1.default.string, | ||
prevLabel: prop_types_1.default.node, | ||
setActiveStartDate: prop_types_1.default.func.isRequired, | ||
showDoubleView: prop_types_1.default.bool, | ||
view: propTypes_1.isView.isRequired, | ||
views: propTypes_1.isViews.isRequired, | ||
}; |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
exports["default"] = CenturyView; | ||
var _react = _interopRequireDefault(require("react")); | ||
var _Decades = _interopRequireDefault(require("./CenturyView/Decades")); | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } | ||
var __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
var react_1 = __importDefault(require("react")); | ||
var Decades_1 = __importDefault(require("./CenturyView/Decades")); | ||
function CenturyView(props) { | ||
function renderDecades() { | ||
return /*#__PURE__*/_react["default"].createElement(_Decades["default"], props); | ||
} | ||
return /*#__PURE__*/_react["default"].createElement("div", { | ||
className: "react-calendar__century-view" | ||
}, renderDecades()); | ||
} | ||
function renderDecades() { | ||
return react_1.default.createElement(Decades_1.default, __assign({}, props)); | ||
} | ||
return react_1.default.createElement("div", { className: "react-calendar__century-view" }, renderDecades()); | ||
} | ||
exports.default = CenturyView; |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
exports["default"] = Decade; | ||
var _react = _interopRequireDefault(require("react")); | ||
var _propTypes = _interopRequireDefault(require("prop-types")); | ||
var _dateUtils = require("@wojtekmaj/date-utils"); | ||
var _Tile = _interopRequireDefault(require("../Tile")); | ||
var _dates = require("../shared/dates"); | ||
var _dateFormatter = require("../shared/dateFormatter"); | ||
var _propTypes2 = require("../shared/propTypes"); | ||
var _excluded = ["classes", "formatYear"]; | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } | ||
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } | ||
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(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; } | ||
function _extends() { _extends = Object.assign ? Object.assign.bind() : 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 _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } | ||
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 __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
var __rest = (this && this.__rest) || function (s, e) { | ||
var t = {}; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) | ||
t[p] = s[p]; | ||
if (s != null && typeof Object.getOwnPropertySymbols === "function") | ||
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { | ||
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) | ||
t[p[i]] = s[p[i]]; | ||
} | ||
return t; | ||
}; | ||
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) { | ||
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) { | ||
if (ar || !(i in from)) { | ||
if (!ar) ar = Array.prototype.slice.call(from, 0, i); | ||
ar[i] = from[i]; | ||
} | ||
} | ||
return to.concat(ar || Array.prototype.slice.call(from)); | ||
}; | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
var react_1 = __importDefault(require("react")); | ||
var prop_types_1 = __importDefault(require("prop-types")); | ||
var date_utils_1 = require("@wojtekmaj/date-utils"); | ||
var Tile_1 = __importDefault(require("../Tile")); | ||
var dates_1 = require("../shared/dates"); | ||
var dateFormatter_1 = require("../shared/dateFormatter"); | ||
var propTypes_1 = require("../shared/propTypes"); | ||
var className = 'react-calendar__century-view__decades__decade'; | ||
function Decade(_ref) { | ||
var classes = _ref.classes, | ||
_ref$formatYear = _ref.formatYear, | ||
formatYear = _ref$formatYear === void 0 ? _dateFormatter.formatYear : _ref$formatYear, | ||
otherProps = _objectWithoutProperties(_ref, _excluded); | ||
var date = otherProps.date, | ||
locale = otherProps.locale; | ||
return /*#__PURE__*/_react["default"].createElement(_Tile["default"], _extends({}, otherProps, { | ||
classes: [].concat(classes, className), | ||
maxDateTransform: _dateUtils.getDecadeEnd, | ||
minDateTransform: _dateUtils.getDecadeStart, | ||
view: "century" | ||
}), (0, _dates.getDecadeLabel)(locale, formatYear, date)); | ||
function Decade(_a) { | ||
var _b = _a.classes, classes = _b === void 0 ? [] : _b, _c = _a.formatYear, formatYear = _c === void 0 ? dateFormatter_1.formatYear : _c, otherProps = __rest(_a, ["classes", "formatYear"]); | ||
var date = otherProps.date, locale = otherProps.locale; | ||
return (react_1.default.createElement(Tile_1.default, __assign({}, otherProps, { classes: __spreadArray(__spreadArray([], classes, true), [className], false), maxDateTransform: date_utils_1.getDecadeEnd, minDateTransform: date_utils_1.getDecadeStart, view: "century" }), (0, dates_1.getDecadeLabel)(locale, formatYear, date))); | ||
} | ||
Decade.propTypes = _objectSpread(_objectSpread({}, _propTypes2.tileProps), {}, { | ||
formatYear: _propTypes["default"].func | ||
}); | ||
exports.default = Decade; | ||
Decade.propTypes = __assign(__assign({}, propTypes_1.tileProps), { formatYear: prop_types_1.default.func }); |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
exports["default"] = Decades; | ||
var _react = _interopRequireDefault(require("react")); | ||
var _dateUtils = require("@wojtekmaj/date-utils"); | ||
var _TileGroup = _interopRequireDefault(require("../TileGroup")); | ||
var _Decade = _interopRequireDefault(require("./Decade")); | ||
var _dates = require("../shared/dates"); | ||
var _propTypes = require("../shared/propTypes"); | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } | ||
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } | ||
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(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; } | ||
function _extends() { _extends = Object.assign ? Object.assign.bind() : 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 __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
var react_1 = __importDefault(require("react")); | ||
var date_utils_1 = require("@wojtekmaj/date-utils"); | ||
var TileGroup_1 = __importDefault(require("../TileGroup")); | ||
var Decade_1 = __importDefault(require("./Decade")); | ||
var dates_1 = require("../shared/dates"); | ||
var propTypes_1 = require("../shared/propTypes"); | ||
function Decades(props) { | ||
var activeStartDate = props.activeStartDate; | ||
var start = (0, _dates.getBeginOfCenturyYear)(activeStartDate); | ||
var end = start + 99; | ||
return /*#__PURE__*/_react["default"].createElement(_TileGroup["default"], _extends({}, props, { | ||
className: "react-calendar__century-view__decades", | ||
dateTransform: _dateUtils.getDecadeStart, | ||
dateType: "decade", | ||
end: end, | ||
start: start, | ||
step: 10, | ||
tile: _Decade["default"] | ||
})); | ||
var activeStartDate = props.activeStartDate; | ||
var start = (0, dates_1.getBeginOfCenturyYear)(activeStartDate); | ||
var end = start + 99; | ||
return (react_1.default.createElement(TileGroup_1.default, __assign({}, props, { className: "react-calendar__century-view__decades", dateTransform: date_utils_1.getDecadeStart, dateType: "decade", end: end, start: start, step: 10, tile: Decade_1.default }))); | ||
} | ||
Decades.propTypes = _objectSpread({}, _propTypes.tileGroupProps); | ||
exports.default = Decades; | ||
Decades.propTypes = __assign({}, propTypes_1.tileGroupProps); |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
exports["default"] = DecadeView; | ||
var _react = _interopRequireDefault(require("react")); | ||
var _Years = _interopRequireDefault(require("./DecadeView/Years")); | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } | ||
var __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
var react_1 = __importDefault(require("react")); | ||
var Years_1 = __importDefault(require("./DecadeView/Years")); | ||
function DecadeView(props) { | ||
function renderYears() { | ||
return /*#__PURE__*/_react["default"].createElement(_Years["default"], props); | ||
} | ||
return /*#__PURE__*/_react["default"].createElement("div", { | ||
className: "react-calendar__decade-view" | ||
}, renderYears()); | ||
} | ||
function renderYears() { | ||
return react_1.default.createElement(Years_1.default, __assign({}, props)); | ||
} | ||
return react_1.default.createElement("div", { className: "react-calendar__decade-view" }, renderYears()); | ||
} | ||
exports.default = DecadeView; |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
exports["default"] = Year; | ||
var _react = _interopRequireDefault(require("react")); | ||
var _propTypes = _interopRequireDefault(require("prop-types")); | ||
var _dateUtils = require("@wojtekmaj/date-utils"); | ||
var _Tile = _interopRequireDefault(require("../Tile")); | ||
var _dateFormatter = require("../shared/dateFormatter"); | ||
var _propTypes2 = require("../shared/propTypes"); | ||
var _excluded = ["classes", "formatYear"]; | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } | ||
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } | ||
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(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; } | ||
function _extends() { _extends = Object.assign ? Object.assign.bind() : 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 _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } | ||
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 __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
var __rest = (this && this.__rest) || function (s, e) { | ||
var t = {}; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) | ||
t[p] = s[p]; | ||
if (s != null && typeof Object.getOwnPropertySymbols === "function") | ||
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { | ||
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) | ||
t[p[i]] = s[p[i]]; | ||
} | ||
return t; | ||
}; | ||
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) { | ||
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) { | ||
if (ar || !(i in from)) { | ||
if (!ar) ar = Array.prototype.slice.call(from, 0, i); | ||
ar[i] = from[i]; | ||
} | ||
} | ||
return to.concat(ar || Array.prototype.slice.call(from)); | ||
}; | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
var react_1 = __importDefault(require("react")); | ||
var prop_types_1 = __importDefault(require("prop-types")); | ||
var date_utils_1 = require("@wojtekmaj/date-utils"); | ||
var Tile_1 = __importDefault(require("../Tile")); | ||
var dateFormatter_1 = require("../shared/dateFormatter"); | ||
var propTypes_1 = require("../shared/propTypes"); | ||
var className = 'react-calendar__decade-view__years__year'; | ||
function Year(_ref) { | ||
var classes = _ref.classes, | ||
_ref$formatYear = _ref.formatYear, | ||
formatYear = _ref$formatYear === void 0 ? _dateFormatter.formatYear : _ref$formatYear, | ||
otherProps = _objectWithoutProperties(_ref, _excluded); | ||
var date = otherProps.date, | ||
locale = otherProps.locale; | ||
return /*#__PURE__*/_react["default"].createElement(_Tile["default"], _extends({}, otherProps, { | ||
classes: [].concat(classes, className), | ||
maxDateTransform: _dateUtils.getYearEnd, | ||
minDateTransform: _dateUtils.getYearStart, | ||
view: "decade" | ||
}), formatYear(locale, date)); | ||
function Year(_a) { | ||
var _b = _a.classes, classes = _b === void 0 ? [] : _b, _c = _a.formatYear, formatYear = _c === void 0 ? dateFormatter_1.formatYear : _c, otherProps = __rest(_a, ["classes", "formatYear"]); | ||
var date = otherProps.date, locale = otherProps.locale; | ||
return (react_1.default.createElement(Tile_1.default, __assign({}, otherProps, { classes: __spreadArray(__spreadArray([], classes, true), [className], false), maxDateTransform: date_utils_1.getYearEnd, minDateTransform: date_utils_1.getYearStart, view: "decade" }), formatYear(locale, date))); | ||
} | ||
Year.propTypes = _objectSpread(_objectSpread({}, _propTypes2.tileProps), {}, { | ||
formatYear: _propTypes["default"].func | ||
}); | ||
exports.default = Year; | ||
Year.propTypes = __assign(__assign({}, propTypes_1.tileProps), { formatYear: prop_types_1.default.func }); |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
exports["default"] = Years; | ||
var _react = _interopRequireDefault(require("react")); | ||
var _TileGroup = _interopRequireDefault(require("../TileGroup")); | ||
var _Year = _interopRequireDefault(require("./Year")); | ||
var _dates = require("../shared/dates"); | ||
var _propTypes = require("../shared/propTypes"); | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } | ||
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } | ||
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(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; } | ||
function _extends() { _extends = Object.assign ? Object.assign.bind() : 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 __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
var react_1 = __importDefault(require("react")); | ||
var TileGroup_1 = __importDefault(require("../TileGroup")); | ||
var Year_1 = __importDefault(require("./Year")); | ||
var dates_1 = require("../shared/dates"); | ||
var propTypes_1 = require("../shared/propTypes"); | ||
function Years(props) { | ||
var activeStartDate = props.activeStartDate; | ||
var start = (0, _dates.getBeginOfDecadeYear)(activeStartDate); | ||
var end = start + 9; | ||
return /*#__PURE__*/_react["default"].createElement(_TileGroup["default"], _extends({}, props, { | ||
className: "react-calendar__decade-view__years", | ||
dateTransform: function dateTransform(year) { | ||
var date = new Date(); | ||
date.setFullYear(year, 0, 1); | ||
date.setHours(0, 0, 0, 0); | ||
return date; | ||
}, | ||
dateType: "year", | ||
end: end, | ||
start: start, | ||
tile: _Year["default"] | ||
})); | ||
var activeStartDate = props.activeStartDate; | ||
var start = (0, dates_1.getBeginOfDecadeYear)(activeStartDate); | ||
var end = start + 9; | ||
return (react_1.default.createElement(TileGroup_1.default, __assign({}, props, { className: "react-calendar__decade-view__years", dateTransform: function (year) { | ||
var date = new Date(); | ||
date.setFullYear(year, 0, 1); | ||
date.setHours(0, 0, 0, 0); | ||
return date; | ||
}, dateType: "year", end: end, start: start, tile: Year_1.default }))); | ||
} | ||
Years.propTypes = _objectSpread({}, _propTypes.tileGroupProps); | ||
exports.default = Years; | ||
Years.propTypes = __assign({}, propTypes_1.tileGroupProps); |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
exports["default"] = Flex; | ||
var _react = _interopRequireDefault(require("react")); | ||
var _propTypes = _interopRequireDefault(require("prop-types")); | ||
var _excluded = ["children", "className", "direction", "count", "offset", "style", "wrap"]; | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } | ||
function _extends() { _extends = Object.assign ? Object.assign.bind() : 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 ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } | ||
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(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; } | ||
function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } | ||
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 __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
var __rest = (this && this.__rest) || function (s, e) { | ||
var t = {}; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) | ||
t[p] = s[p]; | ||
if (s != null && typeof Object.getOwnPropertySymbols === "function") | ||
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { | ||
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) | ||
t[p[i]] = s[p[i]]; | ||
} | ||
return t; | ||
}; | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
var react_1 = __importDefault(require("react")); | ||
var prop_types_1 = __importDefault(require("prop-types")); | ||
function toPercent(num) { | ||
return "".concat(num, "%"); | ||
return "".concat(num, "%"); | ||
} | ||
function Flex(_ref) { | ||
var children = _ref.children, | ||
className = _ref.className, | ||
direction = _ref.direction, | ||
count = _ref.count, | ||
offset = _ref.offset, | ||
style = _ref.style, | ||
wrap = _ref.wrap, | ||
otherProps = _objectWithoutProperties(_ref, _excluded); | ||
return /*#__PURE__*/_react["default"].createElement("div", _extends({ | ||
className: className, | ||
style: _objectSpread({ | ||
display: 'flex', | ||
flexDirection: direction, | ||
flexWrap: wrap ? 'wrap' : 'no-wrap' | ||
}, style) | ||
}, otherProps), _react["default"].Children.map(children, function (child, index) { | ||
return /*#__PURE__*/_react["default"].cloneElement(child, _objectSpread(_objectSpread({}, child.props), {}, { | ||
style: { | ||
flexBasis: toPercent(100 / count), | ||
flexShrink: 0, | ||
flexGrow: 0, | ||
overflow: 'hidden', | ||
marginLeft: offset && index === 0 ? toPercent(100 * offset / count) : null | ||
} | ||
})); | ||
})); | ||
function Flex(_a) { | ||
var children = _a.children, className = _a.className, count = _a.count, direction = _a.direction, offset = _a.offset, style = _a.style, wrap = _a.wrap, otherProps = __rest(_a, ["children", "className", "count", "direction", "offset", "style", "wrap"]); | ||
return (react_1.default.createElement("div", __assign({ className: className, style: __assign({ display: 'flex', flexDirection: direction, flexWrap: wrap ? 'wrap' : 'nowrap' }, style) }, otherProps), react_1.default.Children.map(children, function (child, index) { | ||
return react_1.default.cloneElement(child, __assign(__assign({}, child.props), { style: { | ||
flexBasis: toPercent(100 / count), | ||
flexShrink: 0, | ||
flexGrow: 0, | ||
overflow: 'hidden', | ||
marginLeft: offset && index === 0 ? toPercent((100 * offset) / count) : null, | ||
} })); | ||
}))); | ||
} | ||
exports.default = Flex; | ||
Flex.propTypes = { | ||
children: _propTypes["default"].node, | ||
className: _propTypes["default"].string, | ||
count: _propTypes["default"].number.isRequired, | ||
direction: _propTypes["default"].string, | ||
offset: _propTypes["default"].number, | ||
style: _propTypes["default"].objectOf(_propTypes["default"].oneOfType([_propTypes["default"].string, _propTypes["default"].number])), | ||
wrap: _propTypes["default"].bool | ||
}; | ||
children: prop_types_1.default.node, | ||
className: prop_types_1.default.string, | ||
count: prop_types_1.default.number.isRequired, | ||
direction: prop_types_1.default.string, | ||
offset: prop_types_1.default.number, | ||
style: prop_types_1.default.objectOf(prop_types_1.default.oneOfType([prop_types_1.default.string, prop_types_1.default.number])), | ||
wrap: prop_types_1.default.bool, | ||
}; |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
Object.defineProperty(exports, "Calendar", { | ||
enumerable: true, | ||
get: function get() { | ||
return _Calendar["default"]; | ||
} | ||
}); | ||
Object.defineProperty(exports, "CenturyView", { | ||
enumerable: true, | ||
get: function get() { | ||
return _CenturyView["default"]; | ||
} | ||
}); | ||
Object.defineProperty(exports, "DecadeView", { | ||
enumerable: true, | ||
get: function get() { | ||
return _DecadeView["default"]; | ||
} | ||
}); | ||
Object.defineProperty(exports, "MonthView", { | ||
enumerable: true, | ||
get: function get() { | ||
return _MonthView["default"]; | ||
} | ||
}); | ||
Object.defineProperty(exports, "Navigation", { | ||
enumerable: true, | ||
get: function get() { | ||
return _Navigation["default"]; | ||
} | ||
}); | ||
Object.defineProperty(exports, "YearView", { | ||
enumerable: true, | ||
get: function get() { | ||
return _YearView["default"]; | ||
} | ||
}); | ||
exports["default"] = void 0; | ||
var _Calendar = _interopRequireDefault(require("./Calendar")); | ||
var _Navigation = _interopRequireDefault(require("./Calendar/Navigation")); | ||
var _CenturyView = _interopRequireDefault(require("./CenturyView")); | ||
var _DecadeView = _interopRequireDefault(require("./DecadeView")); | ||
var _YearView = _interopRequireDefault(require("./YearView")); | ||
var _MonthView = _interopRequireDefault(require("./MonthView")); | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } | ||
var _default = _Calendar["default"]; | ||
exports["default"] = _default; | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
exports.MonthView = exports.YearView = exports.DecadeView = exports.CenturyView = exports.Navigation = exports.Calendar = void 0; | ||
var Calendar_1 = __importDefault(require("./Calendar")); | ||
exports.Calendar = Calendar_1.default; | ||
var Navigation_1 = __importDefault(require("./Calendar/Navigation")); | ||
exports.Navigation = Navigation_1.default; | ||
var CenturyView_1 = __importDefault(require("./CenturyView")); | ||
exports.CenturyView = CenturyView_1.default; | ||
var DecadeView_1 = __importDefault(require("./DecadeView")); | ||
exports.DecadeView = DecadeView_1.default; | ||
var YearView_1 = __importDefault(require("./YearView")); | ||
exports.YearView = YearView_1.default; | ||
var MonthView_1 = __importDefault(require("./MonthView")); | ||
exports.MonthView = MonthView_1.default; | ||
exports.default = Calendar_1.default; |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
exports["default"] = MonthView; | ||
var _react = _interopRequireDefault(require("react")); | ||
var _propTypes = _interopRequireDefault(require("prop-types")); | ||
var _clsx = _interopRequireDefault(require("clsx")); | ||
var _Days = _interopRequireDefault(require("./MonthView/Days")); | ||
var _Weekdays = _interopRequireDefault(require("./MonthView/Weekdays")); | ||
var _WeekNumbers = _interopRequireDefault(require("./MonthView/WeekNumbers")); | ||
var _const = require("./shared/const"); | ||
var _propTypes2 = require("./shared/propTypes"); | ||
var _excluded = ["calendarType", "formatShortWeekday", "formatWeekday", "onClickWeekNumber", "showWeekNumbers"]; | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } | ||
function _extends() { _extends = Object.assign ? Object.assign.bind() : 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 _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } | ||
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 __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
var __rest = (this && this.__rest) || function (s, e) { | ||
var t = {}; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) | ||
t[p] = s[p]; | ||
if (s != null && typeof Object.getOwnPropertySymbols === "function") | ||
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { | ||
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) | ||
t[p[i]] = s[p[i]]; | ||
} | ||
return t; | ||
}; | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
var react_1 = __importDefault(require("react")); | ||
var prop_types_1 = __importDefault(require("prop-types")); | ||
var clsx_1 = __importDefault(require("clsx")); | ||
var Days_1 = __importDefault(require("./MonthView/Days")); | ||
var Weekdays_1 = __importDefault(require("./MonthView/Weekdays")); | ||
var WeekNumbers_1 = __importDefault(require("./MonthView/WeekNumbers")); | ||
var const_1 = require("./shared/const"); | ||
var propTypes_1 = require("./shared/propTypes"); | ||
function getCalendarTypeFromLocale(locale) { | ||
return Object.keys(_const.CALENDAR_TYPE_LOCALES).find(function (calendarType) { | ||
return _const.CALENDAR_TYPE_LOCALES[calendarType].includes(locale); | ||
}) || _const.CALENDAR_TYPES.ISO_8601; | ||
for (var _i = 0, _a = Object.entries(const_1.CALENDAR_TYPE_LOCALES); _i < _a.length; _i++) { | ||
var _b = _a[_i], calendarType = _b[0], locales = _b[1]; | ||
if (locales.includes(locale)) { | ||
return calendarType; | ||
} | ||
} | ||
return const_1.CALENDAR_TYPES.ISO_8601; | ||
} | ||
function MonthView(props) { | ||
var activeStartDate = props.activeStartDate, | ||
locale = props.locale, | ||
onMouseLeave = props.onMouseLeave, | ||
showFixedNumberOfWeeks = props.showFixedNumberOfWeeks; | ||
var _props$calendarType = props.calendarType, | ||
calendarType = _props$calendarType === void 0 ? getCalendarTypeFromLocale(locale) : _props$calendarType, | ||
formatShortWeekday = props.formatShortWeekday, | ||
formatWeekday = props.formatWeekday, | ||
onClickWeekNumber = props.onClickWeekNumber, | ||
showWeekNumbers = props.showWeekNumbers, | ||
childProps = _objectWithoutProperties(props, _excluded); | ||
function renderWeekdays() { | ||
return /*#__PURE__*/_react["default"].createElement(_Weekdays["default"], { | ||
calendarType: calendarType, | ||
formatShortWeekday: formatShortWeekday, | ||
formatWeekday: formatWeekday, | ||
locale: locale, | ||
onMouseLeave: onMouseLeave | ||
}); | ||
} | ||
function renderWeekNumbers() { | ||
if (!showWeekNumbers) { | ||
return null; | ||
var activeStartDate = props.activeStartDate, locale = props.locale, onMouseLeave = props.onMouseLeave, showFixedNumberOfWeeks = props.showFixedNumberOfWeeks; | ||
var _a = props.calendarType, calendarType = _a === void 0 ? getCalendarTypeFromLocale(locale) : _a, formatShortWeekday = props.formatShortWeekday, formatWeekday = props.formatWeekday, onClickWeekNumber = props.onClickWeekNumber, showWeekNumbers = props.showWeekNumbers, childProps = __rest(props, ["calendarType", "formatShortWeekday", "formatWeekday", "onClickWeekNumber", "showWeekNumbers"]); | ||
function renderWeekdays() { | ||
return (react_1.default.createElement(Weekdays_1.default, { calendarType: calendarType, formatShortWeekday: formatShortWeekday, formatWeekday: formatWeekday, locale: locale, onMouseLeave: onMouseLeave })); | ||
} | ||
return /*#__PURE__*/_react["default"].createElement(_WeekNumbers["default"], { | ||
activeStartDate: activeStartDate, | ||
calendarType: calendarType, | ||
onClickWeekNumber: onClickWeekNumber, | ||
onMouseLeave: onMouseLeave, | ||
showFixedNumberOfWeeks: showFixedNumberOfWeeks | ||
}); | ||
} | ||
function renderDays() { | ||
return /*#__PURE__*/_react["default"].createElement(_Days["default"], _extends({ | ||
calendarType: calendarType | ||
}, childProps)); | ||
} | ||
var className = 'react-calendar__month-view'; | ||
return /*#__PURE__*/_react["default"].createElement("div", { | ||
className: (0, _clsx["default"])(className, showWeekNumbers ? "".concat(className, "--weekNumbers") : '') | ||
}, /*#__PURE__*/_react["default"].createElement("div", { | ||
style: { | ||
display: 'flex', | ||
alignItems: 'flex-end' | ||
function renderWeekNumbers() { | ||
if (!showWeekNumbers) { | ||
return null; | ||
} | ||
return (react_1.default.createElement(WeekNumbers_1.default, { activeStartDate: activeStartDate, calendarType: calendarType, onClickWeekNumber: onClickWeekNumber, onMouseLeave: onMouseLeave, showFixedNumberOfWeeks: showFixedNumberOfWeeks })); | ||
} | ||
}, renderWeekNumbers(), /*#__PURE__*/_react["default"].createElement("div", { | ||
style: { | ||
flexGrow: 1, | ||
width: '100%' | ||
function renderDays() { | ||
return react_1.default.createElement(Days_1.default, __assign({ calendarType: calendarType }, childProps)); | ||
} | ||
}, renderWeekdays(), renderDays()))); | ||
var className = 'react-calendar__month-view'; | ||
return (react_1.default.createElement("div", { className: (0, clsx_1.default)(className, showWeekNumbers ? "".concat(className, "--weekNumbers") : '') }, | ||
react_1.default.createElement("div", { style: { | ||
display: 'flex', | ||
alignItems: 'flex-end', | ||
} }, | ||
renderWeekNumbers(), | ||
react_1.default.createElement("div", { style: { | ||
flexGrow: 1, | ||
width: '100%', | ||
} }, | ||
renderWeekdays(), | ||
renderDays())))); | ||
} | ||
MonthView.propTypes = { | ||
activeStartDate: _propTypes["default"].instanceOf(Date).isRequired, | ||
calendarType: _propTypes2.isCalendarType, | ||
formatShortWeekday: _propTypes["default"].func, | ||
formatWeekday: _propTypes["default"].func, | ||
locale: _propTypes["default"].string, | ||
onClickWeekNumber: _propTypes["default"].func, | ||
onMouseLeave: _propTypes["default"].func, | ||
showFixedNumberOfWeeks: _propTypes["default"].bool, | ||
showWeekNumbers: _propTypes["default"].bool | ||
}; | ||
exports.default = MonthView; | ||
MonthView.propTypes = __assign(__assign({}, propTypes_1.tileGroupProps), { calendarType: propTypes_1.isCalendarType, formatDay: prop_types_1.default.func, formatLongDate: prop_types_1.default.func, formatShortWeekday: prop_types_1.default.func, formatWeekday: prop_types_1.default.func, onClickWeekNumber: prop_types_1.default.func, onMouseLeave: prop_types_1.default.func, showFixedNumberOfWeeks: prop_types_1.default.bool, showNeighboringMonth: prop_types_1.default.bool, showWeekNumbers: prop_types_1.default.bool }); |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
exports["default"] = Day; | ||
var _react = _interopRequireDefault(require("react")); | ||
var _propTypes = _interopRequireDefault(require("prop-types")); | ||
var _dateUtils = require("@wojtekmaj/date-utils"); | ||
var _Tile = _interopRequireDefault(require("../Tile")); | ||
var _dates = require("../shared/dates"); | ||
var _dateFormatter = require("../shared/dateFormatter"); | ||
var _propTypes2 = require("../shared/propTypes"); | ||
var _excluded = ["formatDay", "formatLongDate", "calendarType", "classes", "currentMonthIndex"]; | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } | ||
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } | ||
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(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; } | ||
function _extends() { _extends = Object.assign ? Object.assign.bind() : 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 _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } | ||
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 __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
var __rest = (this && this.__rest) || function (s, e) { | ||
var t = {}; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) | ||
t[p] = s[p]; | ||
if (s != null && typeof Object.getOwnPropertySymbols === "function") | ||
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { | ||
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) | ||
t[p[i]] = s[p[i]]; | ||
} | ||
return t; | ||
}; | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
var react_1 = __importDefault(require("react")); | ||
var prop_types_1 = __importDefault(require("prop-types")); | ||
var date_utils_1 = require("@wojtekmaj/date-utils"); | ||
var Tile_1 = __importDefault(require("../Tile")); | ||
var dates_1 = require("../shared/dates"); | ||
var dateFormatter_1 = require("../shared/dateFormatter"); | ||
var propTypes_1 = require("../shared/propTypes"); | ||
var className = 'react-calendar__month-view__days__day'; | ||
function Day(_ref) { | ||
var _ref$formatDay = _ref.formatDay, | ||
formatDay = _ref$formatDay === void 0 ? _dateFormatter.formatDay : _ref$formatDay, | ||
_ref$formatLongDate = _ref.formatLongDate, | ||
formatLongDate = _ref$formatLongDate === void 0 ? _dateFormatter.formatLongDate : _ref$formatLongDate, | ||
calendarType = _ref.calendarType, | ||
classes = _ref.classes, | ||
currentMonthIndex = _ref.currentMonthIndex, | ||
otherProps = _objectWithoutProperties(_ref, _excluded); | ||
var date = otherProps.date, | ||
locale = otherProps.locale; | ||
return /*#__PURE__*/_react["default"].createElement(_Tile["default"], _extends({}, otherProps, { | ||
classes: [].concat(classes, className, (0, _dates.isWeekend)(date, calendarType) ? "".concat(className, "--weekend") : null, date.getMonth() !== currentMonthIndex ? "".concat(className, "--neighboringMonth") : null), | ||
formatAbbr: formatLongDate, | ||
maxDateTransform: _dateUtils.getDayEnd, | ||
minDateTransform: _dateUtils.getDayStart, | ||
view: "month" | ||
}), formatDay(locale, date)); | ||
function Day(_a) { | ||
var calendarType = _a.calendarType, _b = _a.classes, classes = _b === void 0 ? [] : _b, currentMonthIndex = _a.currentMonthIndex, _c = _a.formatDay, formatDay = _c === void 0 ? dateFormatter_1.formatDay : _c, _d = _a.formatLongDate, formatLongDate = _d === void 0 ? dateFormatter_1.formatLongDate : _d, otherProps = __rest(_a, ["calendarType", "classes", "currentMonthIndex", "formatDay", "formatLongDate"]); | ||
var date = otherProps.date, locale = otherProps.locale; | ||
var classesProps = []; | ||
if (classes) { | ||
classesProps.push.apply(classesProps, classes); | ||
} | ||
if (className) { | ||
classesProps.push(className); | ||
} | ||
if ((0, dates_1.isWeekend)(date, calendarType)) { | ||
classesProps.push("".concat(className, "--weekend")); | ||
} | ||
if (date.getMonth() !== currentMonthIndex) { | ||
classesProps.push("".concat(className, "--neighboringMonth")); | ||
} | ||
return (react_1.default.createElement(Tile_1.default, __assign({}, otherProps, { classes: classesProps, formatAbbr: formatLongDate, maxDateTransform: date_utils_1.getDayEnd, minDateTransform: date_utils_1.getDayStart, view: "month" }), formatDay(locale, date))); | ||
} | ||
Day.propTypes = _objectSpread(_objectSpread({}, _propTypes2.tileProps), {}, { | ||
currentMonthIndex: _propTypes["default"].number.isRequired, | ||
formatDay: _propTypes["default"].func, | ||
formatLongDate: _propTypes["default"].func | ||
}); | ||
exports.default = Day; | ||
Day.propTypes = __assign(__assign({}, propTypes_1.tileProps), { currentMonthIndex: prop_types_1.default.number.isRequired, formatDay: prop_types_1.default.func, formatLongDate: prop_types_1.default.func }); |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
exports["default"] = Days; | ||
var _react = _interopRequireDefault(require("react")); | ||
var _propTypes = _interopRequireDefault(require("prop-types")); | ||
var _dateUtils = require("@wojtekmaj/date-utils"); | ||
var _TileGroup = _interopRequireDefault(require("../TileGroup")); | ||
var _Day = _interopRequireDefault(require("./Day")); | ||
var _dates = require("../shared/dates"); | ||
var _propTypes2 = require("../shared/propTypes"); | ||
var _excluded = ["showFixedNumberOfWeeks", "showNeighboringMonth"]; | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } | ||
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } | ||
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(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; } | ||
function _extends() { _extends = Object.assign ? Object.assign.bind() : 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 _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } | ||
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 __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
var __rest = (this && this.__rest) || function (s, e) { | ||
var t = {}; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) | ||
t[p] = s[p]; | ||
if (s != null && typeof Object.getOwnPropertySymbols === "function") | ||
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { | ||
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) | ||
t[p[i]] = s[p[i]]; | ||
} | ||
return t; | ||
}; | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
var react_1 = __importDefault(require("react")); | ||
var prop_types_1 = __importDefault(require("prop-types")); | ||
var date_utils_1 = require("@wojtekmaj/date-utils"); | ||
var TileGroup_1 = __importDefault(require("../TileGroup")); | ||
var Day_1 = __importDefault(require("./Day")); | ||
var dates_1 = require("../shared/dates"); | ||
var propTypes_1 = require("../shared/propTypes"); | ||
function Days(props) { | ||
var activeStartDate = props.activeStartDate, | ||
calendarType = props.calendarType; | ||
var showFixedNumberOfWeeks = props.showFixedNumberOfWeeks, | ||
showNeighboringMonth = props.showNeighboringMonth, | ||
otherProps = _objectWithoutProperties(props, _excluded); | ||
var year = (0, _dateUtils.getYear)(activeStartDate); | ||
var monthIndex = (0, _dateUtils.getMonth)(activeStartDate); | ||
var hasFixedNumberOfWeeks = showFixedNumberOfWeeks || showNeighboringMonth; | ||
var dayOfWeek = (0, _dates.getDayOfWeek)(activeStartDate, calendarType); | ||
var offset = hasFixedNumberOfWeeks ? 0 : dayOfWeek; | ||
/** | ||
* Defines on which day of the month the grid shall start. If we simply show current | ||
* month, we obviously start on day one, but if showNeighboringMonth is set to | ||
* true, we need to find the beginning of the week the first day of the month is in. | ||
*/ | ||
var start = (hasFixedNumberOfWeeks ? -dayOfWeek : 0) + 1; | ||
/** | ||
* Defines on which day of the month the grid shall end. If we simply show current | ||
* month, we need to stop on the last day of the month, but if showNeighboringMonth | ||
* is set to true, we need to find the end of the week the last day of the month is in. | ||
*/ | ||
var end = function () { | ||
if (showFixedNumberOfWeeks) { | ||
// Always show 6 weeks | ||
return start + 6 * 7 - 1; | ||
} | ||
var daysInMonth = (0, _dateUtils.getDaysInMonth)(activeStartDate); | ||
if (showNeighboringMonth) { | ||
var activeEndDate = new Date(); | ||
activeEndDate.setFullYear(year, monthIndex, daysInMonth); | ||
activeEndDate.setHours(0, 0, 0, 0); | ||
var daysUntilEndOfTheWeek = 7 - (0, _dates.getDayOfWeek)(activeEndDate, calendarType) - 1; | ||
return daysInMonth + daysUntilEndOfTheWeek; | ||
} | ||
return daysInMonth; | ||
}(); | ||
return /*#__PURE__*/_react["default"].createElement(_TileGroup["default"], _extends({}, otherProps, { | ||
className: "react-calendar__month-view__days", | ||
count: 7, | ||
currentMonthIndex: monthIndex, | ||
dateTransform: function dateTransform(day) { | ||
var date = new Date(); | ||
date.setFullYear(year, monthIndex, day); | ||
date.setHours(0, 0, 0, 0); | ||
return date; | ||
}, | ||
dateType: "day", | ||
end: end, | ||
offset: offset, | ||
start: start, | ||
tile: _Day["default"] | ||
})); | ||
var activeStartDate = props.activeStartDate, calendarType = props.calendarType; | ||
var showFixedNumberOfWeeks = props.showFixedNumberOfWeeks, showNeighboringMonth = props.showNeighboringMonth, otherProps = __rest(props, ["showFixedNumberOfWeeks", "showNeighboringMonth"]); | ||
var year = (0, date_utils_1.getYear)(activeStartDate); | ||
var monthIndex = (0, date_utils_1.getMonth)(activeStartDate); | ||
var hasFixedNumberOfWeeks = showFixedNumberOfWeeks || showNeighboringMonth; | ||
var dayOfWeek = (0, dates_1.getDayOfWeek)(activeStartDate, calendarType); | ||
var offset = hasFixedNumberOfWeeks ? 0 : dayOfWeek; | ||
/** | ||
* Defines on which day of the month the grid shall start. If we simply show current | ||
* month, we obviously start on day one, but if showNeighboringMonth is set to | ||
* true, we need to find the beginning of the week the first day of the month is in. | ||
*/ | ||
var start = (hasFixedNumberOfWeeks ? -dayOfWeek : 0) + 1; | ||
/** | ||
* Defines on which day of the month the grid shall end. If we simply show current | ||
* month, we need to stop on the last day of the month, but if showNeighboringMonth | ||
* is set to true, we need to find the end of the week the last day of the month is in. | ||
*/ | ||
var end = (function () { | ||
if (showFixedNumberOfWeeks) { | ||
// Always show 6 weeks | ||
return start + 6 * 7 - 1; | ||
} | ||
var daysInMonth = (0, date_utils_1.getDaysInMonth)(activeStartDate); | ||
if (showNeighboringMonth) { | ||
var activeEndDate = new Date(); | ||
activeEndDate.setFullYear(year, monthIndex, daysInMonth); | ||
activeEndDate.setHours(0, 0, 0, 0); | ||
var daysUntilEndOfTheWeek = 7 - (0, dates_1.getDayOfWeek)(activeEndDate, calendarType) - 1; | ||
return daysInMonth + daysUntilEndOfTheWeek; | ||
} | ||
return daysInMonth; | ||
})(); | ||
return (react_1.default.createElement(TileGroup_1.default, __assign({}, otherProps, { className: "react-calendar__month-view__days", count: 7, currentMonthIndex: monthIndex, dateTransform: function (day) { | ||
var date = new Date(); | ||
date.setFullYear(year, monthIndex, day); | ||
date.setHours(0, 0, 0, 0); | ||
return date; | ||
}, dateType: "day", end: end, offset: offset, start: start, tile: Day_1.default }))); | ||
} | ||
Days.propTypes = _objectSpread({ | ||
calendarType: _propTypes2.isCalendarType.isRequired, | ||
showFixedNumberOfWeeks: _propTypes["default"].bool, | ||
showNeighboringMonth: _propTypes["default"].bool | ||
}, _propTypes2.tileGroupProps); | ||
exports.default = Days; | ||
Days.propTypes = __assign({ calendarType: propTypes_1.isCalendarType, showFixedNumberOfWeeks: prop_types_1.default.bool, showNeighboringMonth: prop_types_1.default.bool }, propTypes_1.tileGroupProps); |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
exports["default"] = Weekdays; | ||
var _react = _interopRequireDefault(require("react")); | ||
var _propTypes = _interopRequireDefault(require("prop-types")); | ||
var _clsx = _interopRequireDefault(require("clsx")); | ||
var _dateUtils = require("@wojtekmaj/date-utils"); | ||
var _Flex = _interopRequireDefault(require("../Flex")); | ||
var _dates = require("../shared/dates"); | ||
var _dateFormatter = require("../shared/dateFormatter"); | ||
var _propTypes2 = require("../shared/propTypes"); | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
var react_1 = __importDefault(require("react")); | ||
var prop_types_1 = __importDefault(require("prop-types")); | ||
var clsx_1 = __importDefault(require("clsx")); | ||
var date_utils_1 = require("@wojtekmaj/date-utils"); | ||
var Flex_1 = __importDefault(require("../Flex")); | ||
var dates_1 = require("../shared/dates"); | ||
var dateFormatter_1 = require("../shared/dateFormatter"); | ||
var propTypes_1 = require("../shared/propTypes"); | ||
var className = 'react-calendar__month-view__weekdays'; | ||
var weekdayClassName = "".concat(className, "__weekday"); | ||
function Weekdays(props) { | ||
var calendarType = props.calendarType, | ||
_props$formatShortWee = props.formatShortWeekday, | ||
formatShortWeekday = _props$formatShortWee === void 0 ? _dateFormatter.formatShortWeekday : _props$formatShortWee, | ||
_props$formatWeekday = props.formatWeekday, | ||
formatWeekday = _props$formatWeekday === void 0 ? _dateFormatter.formatWeekday : _props$formatWeekday, | ||
locale = props.locale, | ||
onMouseLeave = props.onMouseLeave; | ||
var anyDate = new Date(); | ||
var beginOfMonth = (0, _dateUtils.getMonthStart)(anyDate); | ||
var year = (0, _dateUtils.getYear)(beginOfMonth); | ||
var monthIndex = (0, _dateUtils.getMonth)(beginOfMonth); | ||
var weekdays = []; | ||
for (var weekday = 1; weekday <= 7; weekday += 1) { | ||
var weekdayDate = new Date(year, monthIndex, weekday - (0, _dates.getDayOfWeek)(beginOfMonth, calendarType)); | ||
var abbr = formatWeekday(locale, weekdayDate); | ||
weekdays.push( /*#__PURE__*/_react["default"].createElement("div", { | ||
key: weekday, | ||
className: (0, _clsx["default"])(weekdayClassName, (0, _dates.isWeekend)(weekdayDate, calendarType) && "".concat(weekdayClassName, "--weekend")) | ||
}, /*#__PURE__*/_react["default"].createElement("abbr", { | ||
"aria-label": abbr, | ||
title: abbr | ||
}, formatShortWeekday(locale, weekdayDate).replace('.', '')))); | ||
} | ||
return /*#__PURE__*/_react["default"].createElement(_Flex["default"], { | ||
className: className, | ||
count: 7, | ||
onFocus: onMouseLeave, | ||
onMouseOver: onMouseLeave | ||
}, weekdays); | ||
var calendarType = props.calendarType, _a = props.formatShortWeekday, formatShortWeekday = _a === void 0 ? dateFormatter_1.formatShortWeekday : _a, _b = props.formatWeekday, formatWeekday = _b === void 0 ? dateFormatter_1.formatWeekday : _b, locale = props.locale, onMouseLeave = props.onMouseLeave; | ||
var anyDate = new Date(); | ||
var beginOfMonth = (0, date_utils_1.getMonthStart)(anyDate); | ||
var year = (0, date_utils_1.getYear)(beginOfMonth); | ||
var monthIndex = (0, date_utils_1.getMonth)(beginOfMonth); | ||
var weekdays = []; | ||
for (var weekday = 1; weekday <= 7; weekday += 1) { | ||
var weekdayDate = new Date(year, monthIndex, weekday - (0, dates_1.getDayOfWeek)(beginOfMonth, calendarType)); | ||
var abbr = formatWeekday(locale, weekdayDate); | ||
weekdays.push(react_1.default.createElement("div", { key: weekday, className: (0, clsx_1.default)(weekdayClassName, (0, dates_1.isCurrentDayOfWeek)(weekdayDate) && "".concat(weekdayClassName, "--current"), (0, dates_1.isWeekend)(weekdayDate, calendarType) && "".concat(weekdayClassName, "--weekend")) }, | ||
react_1.default.createElement("abbr", { "aria-label": abbr, title: abbr }, formatShortWeekday(locale, weekdayDate).replace('.', '')))); | ||
} | ||
return (react_1.default.createElement(Flex_1.default, { className: className, count: 7, onFocus: onMouseLeave, onMouseOver: onMouseLeave }, weekdays)); | ||
} | ||
exports.default = Weekdays; | ||
Weekdays.propTypes = { | ||
calendarType: _propTypes2.isCalendarType.isRequired, | ||
formatShortWeekday: _propTypes["default"].func, | ||
formatWeekday: _propTypes["default"].func, | ||
locale: _propTypes["default"].string, | ||
onMouseLeave: _propTypes["default"].func | ||
}; | ||
calendarType: propTypes_1.isCalendarType, | ||
formatShortWeekday: prop_types_1.default.func, | ||
formatWeekday: prop_types_1.default.func, | ||
locale: prop_types_1.default.string, | ||
onMouseLeave: prop_types_1.default.func, | ||
}; |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
exports["default"] = WeekNumber; | ||
var _react = _interopRequireDefault(require("react")); | ||
var _propTypes = _interopRequireDefault(require("prop-types")); | ||
var _excluded = ["date", "onClickWeekNumber", "weekNumber"]; | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } | ||
function _extends() { _extends = Object.assign ? Object.assign.bind() : 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 ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } | ||
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(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; } | ||
function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } | ||
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 __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
var __rest = (this && this.__rest) || function (s, e) { | ||
var t = {}; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) | ||
t[p] = s[p]; | ||
if (s != null && typeof Object.getOwnPropertySymbols === "function") | ||
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { | ||
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) | ||
t[p[i]] = s[p[i]]; | ||
} | ||
return t; | ||
}; | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
var react_1 = __importDefault(require("react")); | ||
var prop_types_1 = __importDefault(require("prop-types")); | ||
var className = 'react-calendar__tile'; | ||
function WeekNumber(_ref) { | ||
var date = _ref.date, | ||
onClickWeekNumber = _ref.onClickWeekNumber, | ||
weekNumber = _ref.weekNumber, | ||
otherProps = _objectWithoutProperties(_ref, _excluded); | ||
var props = _objectSpread({ | ||
className: className | ||
}, otherProps); | ||
var children = /*#__PURE__*/_react["default"].createElement("span", null, weekNumber); | ||
return onClickWeekNumber ? /*#__PURE__*/_react["default"].createElement("button", _extends({}, props, { | ||
onClick: function onClick(event) { | ||
return onClickWeekNumber(weekNumber, date, event); | ||
}, | ||
type: "button" | ||
}), children) : /*#__PURE__*/_react["default"].createElement("div", props, children); | ||
function WeekNumber(props) { | ||
var onClickWeekNumber = props.onClickWeekNumber, weekNumber = props.weekNumber; | ||
var children = react_1.default.createElement("span", null, weekNumber); | ||
if (onClickWeekNumber) { | ||
var date_1 = props.date, onClickWeekNumber_1 = props.onClickWeekNumber, weekNumber_1 = props.weekNumber, otherProps = __rest(props, ["date", "onClickWeekNumber", "weekNumber"]); | ||
return (react_1.default.createElement("button", __assign({}, otherProps, { className: className, onClick: function (event) { return onClickWeekNumber_1(weekNumber_1, date_1, event); }, type: "button" }), children)); | ||
} | ||
else { | ||
var date = props.date, onClickWeekNumber_2 = props.onClickWeekNumber, weekNumber_2 = props.weekNumber, otherProps = __rest(props, ["date", "onClickWeekNumber", "weekNumber"]); | ||
return (react_1.default.createElement("div", __assign({}, otherProps, { className: className }), children)); | ||
} | ||
} | ||
exports.default = WeekNumber; | ||
WeekNumber.propTypes = { | ||
date: _propTypes["default"].instanceOf(Date).isRequired, | ||
onClickWeekNumber: _propTypes["default"].func, | ||
weekNumber: _propTypes["default"].node.isRequired | ||
}; | ||
date: prop_types_1.default.instanceOf(Date).isRequired, | ||
onClickWeekNumber: prop_types_1.default.func, | ||
weekNumber: prop_types_1.default.node.isRequired, | ||
}; |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
exports["default"] = WeekNumbers; | ||
var _react = _interopRequireDefault(require("react")); | ||
var _propTypes = _interopRequireDefault(require("prop-types")); | ||
var _dateUtils = require("@wojtekmaj/date-utils"); | ||
var _WeekNumber = _interopRequireDefault(require("./WeekNumber")); | ||
var _Flex = _interopRequireDefault(require("../Flex")); | ||
var _dates = require("../shared/dates"); | ||
var _propTypes2 = require("../shared/propTypes"); | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
var react_1 = __importDefault(require("react")); | ||
var prop_types_1 = __importDefault(require("prop-types")); | ||
var date_utils_1 = require("@wojtekmaj/date-utils"); | ||
var WeekNumber_1 = __importDefault(require("./WeekNumber")); | ||
var Flex_1 = __importDefault(require("../Flex")); | ||
var dates_1 = require("../shared/dates"); | ||
var propTypes_1 = require("../shared/propTypes"); | ||
function WeekNumbers(props) { | ||
var activeStartDate = props.activeStartDate, | ||
calendarType = props.calendarType, | ||
onClickWeekNumber = props.onClickWeekNumber, | ||
onMouseLeave = props.onMouseLeave, | ||
showFixedNumberOfWeeks = props.showFixedNumberOfWeeks; | ||
var numberOfWeeks = function () { | ||
if (showFixedNumberOfWeeks) { | ||
return 6; | ||
} | ||
var numberOfDays = (0, _dateUtils.getDaysInMonth)(activeStartDate); | ||
var startWeekday = (0, _dates.getDayOfWeek)(activeStartDate, calendarType); | ||
var days = numberOfDays - (7 - startWeekday); | ||
return 1 + Math.ceil(days / 7); | ||
}(); | ||
var dates = function () { | ||
var year = (0, _dateUtils.getYear)(activeStartDate); | ||
var monthIndex = (0, _dateUtils.getMonth)(activeStartDate); | ||
var day = (0, _dateUtils.getDate)(activeStartDate); | ||
var result = []; | ||
for (var index = 0; index < numberOfWeeks; index += 1) { | ||
result.push((0, _dates.getBeginOfWeek)(new Date(year, monthIndex, day + index * 7), calendarType)); | ||
} | ||
return result; | ||
}(); | ||
var weekNumbers = dates.map(function (date) { | ||
return (0, _dates.getWeekNumber)(date, calendarType); | ||
}); | ||
return /*#__PURE__*/_react["default"].createElement(_Flex["default"], { | ||
className: "react-calendar__month-view__weekNumbers", | ||
count: numberOfWeeks, | ||
direction: "column", | ||
onFocus: onMouseLeave, | ||
onMouseOver: onMouseLeave, | ||
style: { | ||
flexBasis: 'calc(100% * (1 / 8)', | ||
flexShrink: 0 | ||
} | ||
}, weekNumbers.map(function (weekNumber, weekIndex) { | ||
return /*#__PURE__*/_react["default"].createElement(_WeekNumber["default"], { | ||
key: weekNumber, | ||
date: dates[weekIndex], | ||
onClickWeekNumber: onClickWeekNumber, | ||
weekNumber: weekNumber | ||
}); | ||
})); | ||
var activeStartDate = props.activeStartDate, calendarType = props.calendarType, onClickWeekNumber = props.onClickWeekNumber, onMouseLeave = props.onMouseLeave, showFixedNumberOfWeeks = props.showFixedNumberOfWeeks; | ||
var numberOfWeeks = (function () { | ||
if (showFixedNumberOfWeeks) { | ||
return 6; | ||
} | ||
var numberOfDays = (0, date_utils_1.getDaysInMonth)(activeStartDate); | ||
var startWeekday = (0, dates_1.getDayOfWeek)(activeStartDate, calendarType); | ||
var days = numberOfDays - (7 - startWeekday); | ||
return 1 + Math.ceil(days / 7); | ||
})(); | ||
var dates = (function () { | ||
var year = (0, date_utils_1.getYear)(activeStartDate); | ||
var monthIndex = (0, date_utils_1.getMonth)(activeStartDate); | ||
var day = (0, date_utils_1.getDate)(activeStartDate); | ||
var result = []; | ||
for (var index = 0; index < numberOfWeeks; index += 1) { | ||
result.push((0, dates_1.getBeginOfWeek)(new Date(year, monthIndex, day + index * 7), calendarType)); | ||
} | ||
return result; | ||
})(); | ||
var weekNumbers = dates.map(function (date) { return (0, dates_1.getWeekNumber)(date, calendarType); }); | ||
return (react_1.default.createElement(Flex_1.default, { className: "react-calendar__month-view__weekNumbers", count: numberOfWeeks, direction: "column", onFocus: onMouseLeave, onMouseOver: onMouseLeave, style: { flexBasis: 'calc(100% * (1 / 8)', flexShrink: 0 } }, weekNumbers.map(function (weekNumber, weekIndex) { | ||
var date = dates[weekIndex]; | ||
if (!date) { | ||
throw new Error('date is not defined'); | ||
} | ||
return (react_1.default.createElement(WeekNumber_1.default, { key: weekNumber, date: date, onClickWeekNumber: onClickWeekNumber, weekNumber: weekNumber })); | ||
}))); | ||
} | ||
exports.default = WeekNumbers; | ||
WeekNumbers.propTypes = { | ||
activeStartDate: _propTypes["default"].instanceOf(Date).isRequired, | ||
calendarType: _propTypes2.isCalendarType.isRequired, | ||
onClickWeekNumber: _propTypes["default"].func, | ||
onMouseLeave: _propTypes["default"].func, | ||
showFixedNumberOfWeeks: _propTypes["default"].bool | ||
}; | ||
activeStartDate: prop_types_1.default.instanceOf(Date).isRequired, | ||
calendarType: propTypes_1.isCalendarType, | ||
onClickWeekNumber: prop_types_1.default.func, | ||
onMouseLeave: prop_types_1.default.func, | ||
showFixedNumberOfWeeks: prop_types_1.default.bool, | ||
}; |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
var _a; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
exports.WEEKDAYS = exports.CALENDAR_TYPE_LOCALES = exports.CALENDAR_TYPES = void 0; | ||
var _CALENDAR_TYPE_LOCALE; | ||
function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); } | ||
function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } | ||
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } | ||
function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); } | ||
function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); } | ||
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } | ||
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 CALENDAR_TYPES = { | ||
ARABIC: 'Arabic', | ||
HEBREW: 'Hebrew', | ||
ISO_8601: 'ISO 8601', | ||
US: 'US' | ||
exports.CALENDAR_TYPES = { | ||
ARABIC: 'Arabic', | ||
HEBREW: 'Hebrew', | ||
ISO_8601: 'ISO 8601', | ||
US: 'US', | ||
}; | ||
exports.CALENDAR_TYPES = CALENDAR_TYPES; | ||
var CALENDAR_TYPE_LOCALES = (_CALENDAR_TYPE_LOCALE = {}, _defineProperty(_CALENDAR_TYPE_LOCALE, CALENDAR_TYPES.US, ['en-CA', 'en-US', 'es-AR', 'es-BO', 'es-CL', 'es-CO', 'es-CR', 'es-DO', 'es-EC', 'es-GT', 'es-HN', 'es-MX', 'es-NI', 'es-PA', 'es-PE', 'es-PR', 'es-SV', 'es-VE', 'pt-BR']), _defineProperty(_CALENDAR_TYPE_LOCALE, CALENDAR_TYPES.ARABIC, [ | ||
// ar-LB, ar-MA intentionally missing | ||
'ar', 'ar-AE', 'ar-BH', 'ar-DZ', 'ar-EG', 'ar-IQ', 'ar-JO', 'ar-KW', 'ar-LY', 'ar-OM', 'ar-QA', 'ar-SA', 'ar-SD', 'ar-SY', 'ar-YE', 'dv', 'dv-MV', 'ps', 'ps-AR']), _defineProperty(_CALENDAR_TYPE_LOCALE, CALENDAR_TYPES.HEBREW, ['he', 'he-IL']), _CALENDAR_TYPE_LOCALE); | ||
exports.CALENDAR_TYPE_LOCALES = CALENDAR_TYPE_LOCALES; | ||
var WEEKDAYS = _toConsumableArray(Array(7)).map(function (el, index) { | ||
return index; | ||
}); | ||
exports.WEEKDAYS = WEEKDAYS; | ||
exports.CALENDAR_TYPE_LOCALES = (_a = {}, | ||
_a[exports.CALENDAR_TYPES.US] = [ | ||
'en-CA', | ||
'en-US', | ||
'es-AR', | ||
'es-BO', | ||
'es-CL', | ||
'es-CO', | ||
'es-CR', | ||
'es-DO', | ||
'es-EC', | ||
'es-GT', | ||
'es-HN', | ||
'es-MX', | ||
'es-NI', | ||
'es-PA', | ||
'es-PE', | ||
'es-PR', | ||
'es-SV', | ||
'es-VE', | ||
'pt-BR', | ||
], | ||
_a[exports.CALENDAR_TYPES.ARABIC] = [ | ||
// ar-LB, ar-MA intentionally missing | ||
'ar', | ||
'ar-AE', | ||
'ar-BH', | ||
'ar-DZ', | ||
'ar-EG', | ||
'ar-IQ', | ||
'ar-JO', | ||
'ar-KW', | ||
'ar-LY', | ||
'ar-OM', | ||
'ar-QA', | ||
'ar-SA', | ||
'ar-SD', | ||
'ar-SY', | ||
'ar-YE', | ||
'dv', | ||
'dv-MV', | ||
'ps', | ||
'ps-AR', | ||
], | ||
_a[exports.CALENDAR_TYPES.HEBREW] = ['he', 'he-IL'], | ||
_a); | ||
exports.WEEKDAYS = [0, 1, 2, 3, 4, 5, 6]; |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
exports.formatYear = exports.formatWeekday = exports.formatShortWeekday = exports.formatMonthYear = exports.formatMonth = exports.formatLongDate = exports.formatDay = exports.formatDate = void 0; | ||
var _getUserLocale = _interopRequireDefault(require("get-user-locale")); | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } | ||
var get_user_locale_1 = __importDefault(require("get-user-locale")); | ||
var formatterCache = new Map(); | ||
function getFormatter(options) { | ||
return function (locale, date) { | ||
var localeWithDefault = locale || (0, _getUserLocale["default"])(); | ||
if (!formatterCache.has(localeWithDefault)) { | ||
formatterCache.set(localeWithDefault, new Map()); | ||
} | ||
var formatterCacheLocale = formatterCache.get(localeWithDefault); | ||
if (!formatterCacheLocale.has(options)) { | ||
formatterCacheLocale.set(options, new Intl.DateTimeFormat(localeWithDefault, options).format); | ||
} | ||
return formatterCacheLocale.get(options)(date); | ||
}; | ||
return function formatter(locale, date) { | ||
var localeWithDefault = locale || (0, get_user_locale_1.default)(); | ||
if (!formatterCache.has(localeWithDefault)) { | ||
formatterCache.set(localeWithDefault, new Map()); | ||
} | ||
var formatterCacheLocale = formatterCache.get(localeWithDefault); | ||
if (!formatterCacheLocale.has(options)) { | ||
formatterCacheLocale.set(options, new Intl.DateTimeFormat(localeWithDefault || undefined, options).format); | ||
} | ||
return formatterCacheLocale.get(options)(date); | ||
}; | ||
} | ||
/** | ||
@@ -34,54 +32,34 @@ * Changes the hour in a Date to ensure right date formatting even if DST is messed up. | ||
function toSafeHour(date) { | ||
var safeDate = new Date(date); | ||
return new Date(safeDate.setHours(12)); | ||
var safeDate = new Date(date); | ||
return new Date(safeDate.setHours(12)); | ||
} | ||
function getSafeFormatter(options) { | ||
return function (locale, date) { | ||
return getFormatter(options)(locale, toSafeHour(date)); | ||
}; | ||
return function (locale, date) { return getFormatter(options)(locale, toSafeHour(date)); }; | ||
} | ||
var formatDateOptions = { | ||
day: 'numeric', | ||
month: 'numeric', | ||
year: 'numeric' | ||
day: 'numeric', | ||
month: 'numeric', | ||
year: 'numeric', | ||
}; | ||
var formatDayOptions = { | ||
day: 'numeric' | ||
}; | ||
var formatDayOptions = { day: 'numeric' }; | ||
var formatLongDateOptions = { | ||
day: 'numeric', | ||
month: 'long', | ||
year: 'numeric' | ||
day: 'numeric', | ||
month: 'long', | ||
year: 'numeric', | ||
}; | ||
var formatMonthOptions = { | ||
month: 'long' | ||
}; | ||
var formatMonthOptions = { month: 'long' }; | ||
var formatMonthYearOptions = { | ||
month: 'long', | ||
year: 'numeric' | ||
month: 'long', | ||
year: 'numeric', | ||
}; | ||
var formatShortWeekdayOptions = { | ||
weekday: 'short' | ||
}; | ||
var formatWeekdayOptions = { | ||
weekday: 'long' | ||
}; | ||
var formatYearOptions = { | ||
year: 'numeric' | ||
}; | ||
var formatDate = getSafeFormatter(formatDateOptions); | ||
exports.formatDate = formatDate; | ||
var formatDay = getSafeFormatter(formatDayOptions); | ||
exports.formatDay = formatDay; | ||
var formatLongDate = getSafeFormatter(formatLongDateOptions); | ||
exports.formatLongDate = formatLongDate; | ||
var formatMonth = getSafeFormatter(formatMonthOptions); | ||
exports.formatMonth = formatMonth; | ||
var formatMonthYear = getSafeFormatter(formatMonthYearOptions); | ||
exports.formatMonthYear = formatMonthYear; | ||
var formatShortWeekday = getSafeFormatter(formatShortWeekdayOptions); | ||
exports.formatShortWeekday = formatShortWeekday; | ||
var formatWeekday = getSafeFormatter(formatWeekdayOptions); | ||
exports.formatWeekday = formatWeekday; | ||
var formatYear = getSafeFormatter(formatYearOptions); | ||
exports.formatYear = formatYear; | ||
var formatShortWeekdayOptions = { weekday: 'short' }; | ||
var formatWeekdayOptions = { weekday: 'long' }; | ||
var formatYearOptions = { year: 'numeric' }; | ||
exports.formatDate = getSafeFormatter(formatDateOptions); | ||
exports.formatDay = getSafeFormatter(formatDayOptions); | ||
exports.formatLongDate = getSafeFormatter(formatLongDateOptions); | ||
exports.formatMonth = getSafeFormatter(formatMonthOptions); | ||
exports.formatMonthYear = getSafeFormatter(formatMonthYearOptions); | ||
exports.formatShortWeekday = getSafeFormatter(formatShortWeekdayOptions); | ||
exports.formatWeekday = getSafeFormatter(formatWeekdayOptions); | ||
exports.formatYear = getSafeFormatter(formatYearOptions); |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
exports.getBegin = getBegin; | ||
exports.getBeginNext = getBeginNext; | ||
exports.getBeginNext2 = void 0; | ||
exports.getBeginOfCenturyYear = getBeginOfCenturyYear; | ||
exports.getBeginOfDecadeYear = getBeginOfDecadeYear; | ||
exports.getBeginOfWeek = getBeginOfWeek; | ||
exports.getBeginPrevious = getBeginPrevious; | ||
exports.getBeginPrevious2 = void 0; | ||
exports.getCenturyLabel = getCenturyLabel; | ||
exports.getDayOfWeek = getDayOfWeek; | ||
exports.getDecadeLabel = getDecadeLabel; | ||
exports.getEnd = getEnd; | ||
exports.getEndPrevious = getEndPrevious; | ||
exports.getEndPrevious2 = void 0; | ||
exports.getRange = getRange; | ||
exports.getValueRange = getValueRange; | ||
exports.getWeekNumber = getWeekNumber; | ||
exports.isWeekend = isWeekend; | ||
var _dateUtils = require("@wojtekmaj/date-utils"); | ||
var _const = require("./const"); | ||
var _dateFormatter = require("./dateFormatter"); | ||
var SUNDAY = _const.WEEKDAYS[0]; | ||
var FRIDAY = _const.WEEKDAYS[5]; | ||
var SATURDAY = _const.WEEKDAYS[6]; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
exports.isWeekend = exports.isCurrentDayOfWeek = exports.getDecadeLabel = exports.getCenturyLabel = exports.getValueRange = exports.getRange = exports.getEndPrevious2 = exports.getEndPrevious = exports.getEnd = exports.getBeginNext2 = exports.getBeginPrevious2 = exports.getBeginNext = exports.getBeginPrevious = exports.getBegin = exports.getWeekNumber = exports.getBeginOfWeek = exports.getBeginOfDecadeYear = exports.getBeginOfCenturyYear = exports.getDayOfWeek = void 0; | ||
var date_utils_1 = require("@wojtekmaj/date-utils"); | ||
var const_1 = require("./const"); | ||
var dateFormatter_1 = require("./dateFormatter"); | ||
var SUNDAY = const_1.WEEKDAYS[0]; | ||
var FRIDAY = const_1.WEEKDAYS[5]; | ||
var SATURDAY = const_1.WEEKDAYS[6]; | ||
/* Simple getters - getting a property of a given point in time */ | ||
function getDayOfWeek(date) { | ||
var calendarType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _const.CALENDAR_TYPES.ISO_8601; | ||
var weekday = date.getDay(); | ||
switch (calendarType) { | ||
case _const.CALENDAR_TYPES.ISO_8601: | ||
// Shifts days of the week so that Monday is 0, Sunday is 6 | ||
return (weekday + 6) % 7; | ||
case _const.CALENDAR_TYPES.ARABIC: | ||
return (weekday + 1) % 7; | ||
case _const.CALENDAR_TYPES.HEBREW: | ||
case _const.CALENDAR_TYPES.US: | ||
return weekday; | ||
default: | ||
throw new Error('Unsupported calendar type.'); | ||
} | ||
function getDayOfWeek(date, calendarType) { | ||
if (calendarType === void 0) { calendarType = const_1.CALENDAR_TYPES.ISO_8601; } | ||
var weekday = date.getDay(); | ||
switch (calendarType) { | ||
case const_1.CALENDAR_TYPES.ISO_8601: | ||
// Shifts days of the week so that Monday is 0, Sunday is 6 | ||
return (weekday + 6) % 7; | ||
case const_1.CALENDAR_TYPES.ARABIC: | ||
return (weekday + 1) % 7; | ||
case const_1.CALENDAR_TYPES.HEBREW: | ||
case const_1.CALENDAR_TYPES.US: | ||
return weekday; | ||
default: | ||
throw new Error('Unsupported calendar type.'); | ||
} | ||
} | ||
exports.getDayOfWeek = getDayOfWeek; | ||
/** | ||
* Century | ||
*/ | ||
function getBeginOfCenturyYear(date) { | ||
var beginOfCentury = (0, _dateUtils.getCenturyStart)(date); | ||
return (0, _dateUtils.getYear)(beginOfCentury); | ||
var beginOfCentury = (0, date_utils_1.getCenturyStart)(date); | ||
return (0, date_utils_1.getYear)(beginOfCentury); | ||
} | ||
exports.getBeginOfCenturyYear = getBeginOfCenturyYear; | ||
/** | ||
@@ -63,10 +40,9 @@ * Decade | ||
function getBeginOfDecadeYear(date) { | ||
var beginOfDecade = (0, _dateUtils.getDecadeStart)(date); | ||
return (0, _dateUtils.getYear)(beginOfDecade); | ||
var beginOfDecade = (0, date_utils_1.getDecadeStart)(date); | ||
return (0, date_utils_1.getYear)(beginOfDecade); | ||
} | ||
exports.getBeginOfDecadeYear = getBeginOfDecadeYear; | ||
/** | ||
* Week | ||
*/ | ||
/** | ||
@@ -76,12 +52,12 @@ * Returns the beginning of a given week. | ||
* @param {Date} date Date. | ||
* @param {string} calendarType Calendar type. Can be ISO 8601 or US. | ||
* @param {string} [calendarType="ISO 8601"] Calendar type. | ||
*/ | ||
function getBeginOfWeek(date) { | ||
var calendarType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _const.CALENDAR_TYPES.ISO_8601; | ||
var year = (0, _dateUtils.getYear)(date); | ||
var monthIndex = (0, _dateUtils.getMonth)(date); | ||
var day = date.getDate() - getDayOfWeek(date, calendarType); | ||
return new Date(year, monthIndex, day); | ||
function getBeginOfWeek(date, calendarType) { | ||
if (calendarType === void 0) { calendarType = const_1.CALENDAR_TYPES.ISO_8601; } | ||
var year = (0, date_utils_1.getYear)(date); | ||
var monthIndex = (0, date_utils_1.getMonth)(date); | ||
var day = date.getDate() - getDayOfWeek(date, calendarType); | ||
return new Date(year, monthIndex, day); | ||
} | ||
exports.getBeginOfWeek = getBeginOfWeek; | ||
/** | ||
@@ -93,25 +69,23 @@ * Gets week number according to ISO 8601 or US standard. | ||
* @param {Date} date Date. | ||
* @param {string} calendarType Calendar type. Can be ISO 8601 or US. | ||
* @param {string} [calendarType="ISO 8601"] Calendar type. | ||
*/ | ||
function getWeekNumber(date) { | ||
var calendarType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _const.CALENDAR_TYPES.ISO_8601; | ||
var calendarTypeForWeekNumber = calendarType === _const.CALENDAR_TYPES.US ? _const.CALENDAR_TYPES.US : _const.CALENDAR_TYPES.ISO_8601; | ||
var beginOfWeek = getBeginOfWeek(date, calendarType); | ||
var year = (0, _dateUtils.getYear)(date) + 1; | ||
var dayInWeekOne; | ||
var beginOfFirstWeek; | ||
// Look for the first week one that does not come after a given date | ||
do { | ||
dayInWeekOne = new Date(year, 0, calendarTypeForWeekNumber === _const.CALENDAR_TYPES.ISO_8601 ? 4 : 1); | ||
beginOfFirstWeek = getBeginOfWeek(dayInWeekOne, calendarType); | ||
year -= 1; | ||
} while (date < beginOfFirstWeek); | ||
return Math.round((beginOfWeek - beginOfFirstWeek) / (8.64e7 * 7)) + 1; | ||
function getWeekNumber(date, calendarType) { | ||
if (calendarType === void 0) { calendarType = const_1.CALENDAR_TYPES.ISO_8601; } | ||
var calendarTypeForWeekNumber = calendarType === const_1.CALENDAR_TYPES.US ? const_1.CALENDAR_TYPES.US : const_1.CALENDAR_TYPES.ISO_8601; | ||
var beginOfWeek = getBeginOfWeek(date, calendarType); | ||
var year = (0, date_utils_1.getYear)(date) + 1; | ||
var dayInWeekOne; | ||
var beginOfFirstWeek; | ||
// Look for the first week one that does not come after a given date | ||
do { | ||
dayInWeekOne = new Date(year, 0, calendarTypeForWeekNumber === const_1.CALENDAR_TYPES.ISO_8601 ? 4 : 1); | ||
beginOfFirstWeek = getBeginOfWeek(dayInWeekOne, calendarType); | ||
year -= 1; | ||
} while (date < beginOfFirstWeek); | ||
return Math.round((beginOfWeek.getTime() - beginOfFirstWeek.getTime()) / (8.64e7 * 7)) + 1; | ||
} | ||
exports.getWeekNumber = getWeekNumber; | ||
/** | ||
* Others | ||
*/ | ||
/** | ||
@@ -124,71 +98,74 @@ * Returns the beginning of a given range. | ||
function getBegin(rangeType, date) { | ||
switch (rangeType) { | ||
case 'century': | ||
return (0, _dateUtils.getCenturyStart)(date); | ||
case 'decade': | ||
return (0, _dateUtils.getDecadeStart)(date); | ||
case 'year': | ||
return (0, _dateUtils.getYearStart)(date); | ||
case 'month': | ||
return (0, _dateUtils.getMonthStart)(date); | ||
case 'day': | ||
return (0, _dateUtils.getDayStart)(date); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
switch (rangeType) { | ||
case 'century': | ||
return (0, date_utils_1.getCenturyStart)(date); | ||
case 'decade': | ||
return (0, date_utils_1.getDecadeStart)(date); | ||
case 'year': | ||
return (0, date_utils_1.getYearStart)(date); | ||
case 'month': | ||
return (0, date_utils_1.getMonthStart)(date); | ||
case 'day': | ||
return (0, date_utils_1.getDayStart)(date); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
} | ||
exports.getBegin = getBegin; | ||
function getBeginPrevious(rangeType, date) { | ||
switch (rangeType) { | ||
case 'century': | ||
return (0, _dateUtils.getPreviousCenturyStart)(date); | ||
case 'decade': | ||
return (0, _dateUtils.getPreviousDecadeStart)(date); | ||
case 'year': | ||
return (0, _dateUtils.getPreviousYearStart)(date); | ||
case 'month': | ||
return (0, _dateUtils.getPreviousMonthStart)(date); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
switch (rangeType) { | ||
case 'century': | ||
return (0, date_utils_1.getPreviousCenturyStart)(date); | ||
case 'decade': | ||
return (0, date_utils_1.getPreviousDecadeStart)(date); | ||
case 'year': | ||
return (0, date_utils_1.getPreviousYearStart)(date); | ||
case 'month': | ||
return (0, date_utils_1.getPreviousMonthStart)(date); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
} | ||
exports.getBeginPrevious = getBeginPrevious; | ||
function getBeginNext(rangeType, date) { | ||
switch (rangeType) { | ||
case 'century': | ||
return (0, _dateUtils.getNextCenturyStart)(date); | ||
case 'decade': | ||
return (0, _dateUtils.getNextDecadeStart)(date); | ||
case 'year': | ||
return (0, _dateUtils.getNextYearStart)(date); | ||
case 'month': | ||
return (0, _dateUtils.getNextMonthStart)(date); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
switch (rangeType) { | ||
case 'century': | ||
return (0, date_utils_1.getNextCenturyStart)(date); | ||
case 'decade': | ||
return (0, date_utils_1.getNextDecadeStart)(date); | ||
case 'year': | ||
return (0, date_utils_1.getNextYearStart)(date); | ||
case 'month': | ||
return (0, date_utils_1.getNextMonthStart)(date); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
} | ||
var getBeginPrevious2 = function getBeginPrevious2(rangeType, date) { | ||
switch (rangeType) { | ||
case 'decade': | ||
return (0, _dateUtils.getPreviousDecadeStart)(date, -100); | ||
case 'year': | ||
return (0, _dateUtils.getPreviousYearStart)(date, -10); | ||
case 'month': | ||
return (0, _dateUtils.getPreviousMonthStart)(date, -12); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
}; | ||
exports.getBeginNext = getBeginNext; | ||
function getBeginPrevious2(rangeType, date) { | ||
switch (rangeType) { | ||
case 'decade': | ||
return (0, date_utils_1.getPreviousDecadeStart)(date, -100); | ||
case 'year': | ||
return (0, date_utils_1.getPreviousYearStart)(date, -10); | ||
case 'month': | ||
return (0, date_utils_1.getPreviousMonthStart)(date, -12); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
} | ||
exports.getBeginPrevious2 = getBeginPrevious2; | ||
var getBeginNext2 = function getBeginNext2(rangeType, date) { | ||
switch (rangeType) { | ||
case 'decade': | ||
return (0, _dateUtils.getNextDecadeStart)(date, 100); | ||
case 'year': | ||
return (0, _dateUtils.getNextYearStart)(date, 10); | ||
case 'month': | ||
return (0, _dateUtils.getNextMonthStart)(date, 12); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
}; | ||
function getBeginNext2(rangeType, date) { | ||
switch (rangeType) { | ||
case 'decade': | ||
return (0, date_utils_1.getNextDecadeStart)(date, 100); | ||
case 'year': | ||
return (0, date_utils_1.getNextYearStart)(date, 10); | ||
case 'month': | ||
return (0, date_utils_1.getNextMonthStart)(date, 12); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
} | ||
exports.getBeginNext2 = getBeginNext2; | ||
/** | ||
@@ -200,46 +177,47 @@ * Returns the end of a given range. | ||
*/ | ||
exports.getBeginNext2 = getBeginNext2; | ||
function getEnd(rangeType, date) { | ||
switch (rangeType) { | ||
case 'century': | ||
return (0, _dateUtils.getCenturyEnd)(date); | ||
case 'decade': | ||
return (0, _dateUtils.getDecadeEnd)(date); | ||
case 'year': | ||
return (0, _dateUtils.getYearEnd)(date); | ||
case 'month': | ||
return (0, _dateUtils.getMonthEnd)(date); | ||
case 'day': | ||
return (0, _dateUtils.getDayEnd)(date); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
switch (rangeType) { | ||
case 'century': | ||
return (0, date_utils_1.getCenturyEnd)(date); | ||
case 'decade': | ||
return (0, date_utils_1.getDecadeEnd)(date); | ||
case 'year': | ||
return (0, date_utils_1.getYearEnd)(date); | ||
case 'month': | ||
return (0, date_utils_1.getMonthEnd)(date); | ||
case 'day': | ||
return (0, date_utils_1.getDayEnd)(date); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
} | ||
exports.getEnd = getEnd; | ||
function getEndPrevious(rangeType, date) { | ||
switch (rangeType) { | ||
case 'century': | ||
return (0, _dateUtils.getPreviousCenturyEnd)(date); | ||
case 'decade': | ||
return (0, _dateUtils.getPreviousDecadeEnd)(date); | ||
case 'year': | ||
return (0, _dateUtils.getPreviousYearEnd)(date); | ||
case 'month': | ||
return (0, _dateUtils.getPreviousMonthEnd)(date); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
switch (rangeType) { | ||
case 'century': | ||
return (0, date_utils_1.getPreviousCenturyEnd)(date); | ||
case 'decade': | ||
return (0, date_utils_1.getPreviousDecadeEnd)(date); | ||
case 'year': | ||
return (0, date_utils_1.getPreviousYearEnd)(date); | ||
case 'month': | ||
return (0, date_utils_1.getPreviousMonthEnd)(date); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
} | ||
var getEndPrevious2 = function getEndPrevious2(rangeType, date) { | ||
switch (rangeType) { | ||
case 'decade': | ||
return (0, _dateUtils.getPreviousDecadeEnd)(date, -100); | ||
case 'year': | ||
return (0, _dateUtils.getPreviousYearEnd)(date, -10); | ||
case 'month': | ||
return (0, _dateUtils.getPreviousMonthEnd)(date, -12); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
}; | ||
exports.getEndPrevious = getEndPrevious; | ||
function getEndPrevious2(rangeType, date) { | ||
switch (rangeType) { | ||
case 'decade': | ||
return (0, date_utils_1.getPreviousDecadeEnd)(date, -100); | ||
case 'year': | ||
return (0, date_utils_1.getPreviousYearEnd)(date, -10); | ||
case 'month': | ||
return (0, date_utils_1.getPreviousMonthEnd)(date, -12); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
} | ||
exports.getEndPrevious2 = getEndPrevious2; | ||
/** | ||
@@ -251,20 +229,19 @@ * Returns an array with the beginning and the end of a given range. | ||
*/ | ||
exports.getEndPrevious2 = getEndPrevious2; | ||
function getRange(rangeType, date) { | ||
switch (rangeType) { | ||
case 'century': | ||
return (0, _dateUtils.getCenturyRange)(date); | ||
case 'decade': | ||
return (0, _dateUtils.getDecadeRange)(date); | ||
case 'year': | ||
return (0, _dateUtils.getYearRange)(date); | ||
case 'month': | ||
return (0, _dateUtils.getMonthRange)(date); | ||
case 'day': | ||
return (0, _dateUtils.getDayRange)(date); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
switch (rangeType) { | ||
case 'century': | ||
return (0, date_utils_1.getCenturyRange)(date); | ||
case 'decade': | ||
return (0, date_utils_1.getDecadeRange)(date); | ||
case 'year': | ||
return (0, date_utils_1.getYearRange)(date); | ||
case 'month': | ||
return (0, date_utils_1.getMonthRange)(date); | ||
case 'day': | ||
return (0, date_utils_1.getDayRange)(date); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
} | ||
exports.getRange = getRange; | ||
/** | ||
@@ -278,25 +255,28 @@ * Creates a range out of two values, ensuring they are in order and covering entire period ranges. | ||
function getValueRange(rangeType, date1, date2) { | ||
var rawNextValue = [date1, date2].sort(function (a, b) { | ||
return a - b; | ||
}); | ||
return [getBegin(rangeType, rawNextValue[0]), getEnd(rangeType, rawNextValue[1])]; | ||
var rawNextValue = [date1, date2].sort(function (a, b) { return a.getTime() - b.getTime(); }); | ||
return [getBegin(rangeType, rawNextValue[0]), getEnd(rangeType, rawNextValue[1])]; | ||
} | ||
function toYearLabel(locale) { | ||
var formatYear = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _dateFormatter.formatYear; | ||
var dates = arguments.length > 2 ? arguments[2] : undefined; | ||
return dates.map(function (date) { | ||
return formatYear(locale, date); | ||
}).join(' – '); | ||
exports.getValueRange = getValueRange; | ||
function toYearLabel(locale, formatYear, dates) { | ||
if (formatYear === void 0) { formatYear = dateFormatter_1.formatYear; } | ||
return dates.map(function (date) { return formatYear(locale, date); }).join(' – '); | ||
} | ||
/** | ||
* @callback FormatYear | ||
* @param {string} locale Locale. | ||
* @param {Date} date Date. | ||
* @returns {string} Formatted year. | ||
*/ | ||
/** | ||
* Returns a string labelling a century of a given date. | ||
* For example, for 2017 it will return 2001-2100. | ||
* | ||
* @param {Date|String|Number} date Date or a year as a string or as a number. | ||
* @param {string} locale Locale. | ||
* @param {FormatYear} formatYear Function to format a year. | ||
* @param {Date|string|number} date Date or a year as a string or as a number. | ||
*/ | ||
function getCenturyLabel(locale, formatYear, date) { | ||
return toYearLabel(locale, formatYear, (0, _dateUtils.getCenturyRange)(date)); | ||
return toYearLabel(locale, formatYear, (0, date_utils_1.getCenturyRange)(date)); | ||
} | ||
exports.getCenturyLabel = getCenturyLabel; | ||
/** | ||
@@ -306,26 +286,39 @@ * Returns a string labelling a century of a given date. | ||
* | ||
* @param {Date|String|Number} date Date or a year as a string or as a number. | ||
* @param {string} locale Locale. | ||
* @param {FormatYear} formatYear Function to format a year. | ||
* @param {Date|string|number} date Date or a year as a string or as a number. | ||
*/ | ||
function getDecadeLabel(locale, formatYear, date) { | ||
return toYearLabel(locale, formatYear, (0, _dateUtils.getDecadeRange)(date)); | ||
return toYearLabel(locale, formatYear, (0, date_utils_1.getDecadeRange)(date)); | ||
} | ||
exports.getDecadeLabel = getDecadeLabel; | ||
/** | ||
* Returns a boolean determining whether a given date is on Saturday or Sunday. | ||
* Returns a boolean determining whether a given date is the current day of the week. | ||
* | ||
* @param {Date} date Date. | ||
*/ | ||
function isWeekend(date) { | ||
var calendarType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _const.CALENDAR_TYPES.ISO_8601; | ||
var weekday = date.getDay(); | ||
switch (calendarType) { | ||
case _const.CALENDAR_TYPES.ARABIC: | ||
case _const.CALENDAR_TYPES.HEBREW: | ||
return weekday === FRIDAY || weekday === SATURDAY; | ||
case _const.CALENDAR_TYPES.ISO_8601: | ||
case _const.CALENDAR_TYPES.US: | ||
return weekday === SATURDAY || weekday === SUNDAY; | ||
default: | ||
throw new Error('Unsupported calendar type.'); | ||
} | ||
} | ||
function isCurrentDayOfWeek(date) { | ||
return date.getDay() === new Date().getDay(); | ||
} | ||
exports.isCurrentDayOfWeek = isCurrentDayOfWeek; | ||
/** | ||
* Returns a boolean determining whether a given date is a weekend day. | ||
* | ||
* @param {Date} date Date. | ||
* @param {string} [calendarType="ISO 8601"] Calendar type. | ||
*/ | ||
function isWeekend(date, calendarType) { | ||
if (calendarType === void 0) { calendarType = const_1.CALENDAR_TYPES.ISO_8601; } | ||
var weekday = date.getDay(); | ||
switch (calendarType) { | ||
case const_1.CALENDAR_TYPES.ARABIC: | ||
case const_1.CALENDAR_TYPES.HEBREW: | ||
return weekday === FRIDAY || weekday === SATURDAY; | ||
case const_1.CALENDAR_TYPES.ISO_8601: | ||
case const_1.CALENDAR_TYPES.US: | ||
return weekday === SATURDAY || weekday === SUNDAY; | ||
default: | ||
throw new Error('Unsupported calendar type.'); | ||
} | ||
} | ||
exports.isWeekend = isWeekend; |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
exports.tileProps = exports.tileGroupProps = exports.isViews = exports.isView = exports.isValue = exports.isRef = exports.isMinDate = exports.isMaxDate = exports.isClassName = exports.isCalendarType = void 0; | ||
var _propTypes = _interopRequireDefault(require("prop-types")); | ||
var _const = require("./const"); | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } | ||
function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); } | ||
var calendarTypes = Object.values(_const.CALENDAR_TYPES); | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
exports.tileProps = exports.tileGroupProps = exports.isView = exports.isViews = exports.isValue = exports.isRef = exports.isMaxDate = exports.isMinDate = exports.isClassName = exports.isCalendarType = void 0; | ||
var prop_types_1 = __importDefault(require("prop-types")); | ||
var const_1 = require("./const"); | ||
var calendarTypes = Object.values(const_1.CALENDAR_TYPES); | ||
var allViews = ['century', 'decade', 'year', 'month']; | ||
var isCalendarType = _propTypes["default"].oneOf(calendarTypes); | ||
exports.isCalendarType = isCalendarType; | ||
var isClassName = _propTypes["default"].oneOfType([_propTypes["default"].string, _propTypes["default"].arrayOf(_propTypes["default"].string)]); | ||
exports.isClassName = isClassName; | ||
var isMinDate = function isMinDate(props, propName, componentName) { | ||
var minDate = props[propName]; | ||
if (!minDate) { | ||
exports.isCalendarType = prop_types_1.default.oneOf(calendarTypes); | ||
exports.isClassName = prop_types_1.default.oneOfType([ | ||
prop_types_1.default.string, | ||
prop_types_1.default.arrayOf(prop_types_1.default.string), | ||
]); | ||
function isMinDate(props, propName, componentName) { | ||
var _a = props, _b = propName, minDate = _a[_b]; | ||
if (!minDate) { | ||
return null; | ||
} | ||
if (!(minDate instanceof Date)) { | ||
return new Error("Invalid prop `".concat(propName, "` of type `").concat(typeof minDate, "` supplied to `").concat(componentName, "`, expected instance of `Date`.")); | ||
} | ||
var maxDate = props.maxDate; | ||
if (maxDate && minDate > maxDate) { | ||
return new Error("Invalid prop `".concat(propName, "` of type `").concat(typeof minDate, "` supplied to `").concat(componentName, "`, minDate cannot be larger than maxDate.")); | ||
} | ||
return null; | ||
} | ||
if (!(minDate instanceof Date)) { | ||
return new Error("Invalid prop `".concat(propName, "` of type `").concat(_typeof(minDate), "` supplied to `").concat(componentName, "`, expected instance of `Date`.")); | ||
} | ||
var maxDate = props.maxDate; | ||
if (maxDate && minDate > maxDate) { | ||
return new Error("Invalid prop `".concat(propName, "` of type `").concat(_typeof(minDate), "` supplied to `").concat(componentName, "`, minDate cannot be larger than maxDate.")); | ||
} | ||
return null; | ||
}; | ||
} | ||
exports.isMinDate = isMinDate; | ||
var isMaxDate = function isMaxDate(props, propName, componentName) { | ||
var maxDate = props[propName]; | ||
if (!maxDate) { | ||
function isMaxDate(props, propName, componentName) { | ||
var _a = props, _b = propName, maxDate = _a[_b]; | ||
if (!maxDate) { | ||
return null; | ||
} | ||
if (!(maxDate instanceof Date)) { | ||
return new Error("Invalid prop `".concat(propName, "` of type `").concat(typeof maxDate, "` supplied to `").concat(componentName, "`, expected instance of `Date`.")); | ||
} | ||
var minDate = props.minDate; | ||
if (minDate && maxDate < minDate) { | ||
return new Error("Invalid prop `".concat(propName, "` of type `").concat(typeof maxDate, "` supplied to `").concat(componentName, "`, maxDate cannot be smaller than minDate.")); | ||
} | ||
return null; | ||
} | ||
if (!(maxDate instanceof Date)) { | ||
return new Error("Invalid prop `".concat(propName, "` of type `").concat(_typeof(maxDate), "` supplied to `").concat(componentName, "`, expected instance of `Date`.")); | ||
} | ||
var minDate = props.minDate; | ||
if (minDate && maxDate < minDate) { | ||
return new Error("Invalid prop `".concat(propName, "` of type `").concat(_typeof(maxDate), "` supplied to `").concat(componentName, "`, maxDate cannot be smaller than minDate.")); | ||
} | ||
return null; | ||
}; | ||
} | ||
exports.isMaxDate = isMaxDate; | ||
var isRef = _propTypes["default"].oneOfType([_propTypes["default"].func, _propTypes["default"].shape({ | ||
current: _propTypes["default"].any | ||
})]); | ||
exports.isRef = isRef; | ||
var isValue = _propTypes["default"].oneOfType([_propTypes["default"].instanceOf(Date), _propTypes["default"].arrayOf(_propTypes["default"].instanceOf(Date))]); | ||
exports.isValue = isValue; | ||
var isViews = _propTypes["default"].arrayOf(_propTypes["default"].oneOf(allViews)); | ||
exports.isViews = isViews; | ||
var isView = function isView(props, propName, componentName) { | ||
var view = props[propName]; | ||
var views = props.views; | ||
var allowedViews = views || allViews; | ||
if (view !== undefined && allowedViews.indexOf(view) === -1) { | ||
return new Error("Invalid prop `".concat(propName, "` of value `").concat(view, "` supplied to `").concat(componentName, "`, expected one of [").concat(allowedViews.map(function (a) { | ||
return "\"".concat(a, "\""); | ||
}).join(', '), "].")); | ||
} | ||
// Everything is fine | ||
return null; | ||
}; | ||
exports.isRef = prop_types_1.default.oneOfType([ | ||
prop_types_1.default.func, | ||
prop_types_1.default.shape({ | ||
current: prop_types_1.default.any, | ||
}), | ||
]); | ||
exports.isValue = prop_types_1.default.oneOfType([ | ||
prop_types_1.default.instanceOf(Date), | ||
prop_types_1.default.arrayOf(prop_types_1.default.instanceOf(Date)), | ||
]); | ||
exports.isViews = prop_types_1.default.arrayOf(prop_types_1.default.oneOf(allViews)); | ||
function isView(props, propName, componentName) { | ||
var _a = props, _b = propName, view = _a[_b]; | ||
var views = props.views; | ||
var allowedViews = views || allViews; | ||
if (view !== undefined && (typeof view !== 'string' || allowedViews.indexOf(view) === -1)) { | ||
return new Error("Invalid prop `".concat(propName, "` of value `").concat(view, "` supplied to `").concat(componentName, "`, expected one of [").concat(allowedViews | ||
.map(function (a) { return "\"".concat(a, "\""); }) | ||
.join(', '), "].")); | ||
} | ||
// Everything is fine | ||
return null; | ||
} | ||
exports.isView = isView; | ||
isView.isRequired = function (props, propName, componentName) { | ||
var view = props[propName]; | ||
if (!view) { | ||
return new Error("The prop `".concat(propName, "` is marked as required in `").concat(componentName, "`, but its value is `").concat(view, "`.")); | ||
} | ||
return isView(props, propName, componentName); | ||
var _a = props, _b = propName, view = _a[_b]; | ||
if (!view) { | ||
return new Error("The prop `".concat(propName, "` is marked as required in `").concat(componentName, "`, but its value is `").concat(view, "`.")); | ||
} | ||
return isView(props, propName, componentName); | ||
}; | ||
var tileGroupProps = { | ||
activeStartDate: _propTypes["default"].instanceOf(Date).isRequired, | ||
hover: _propTypes["default"].instanceOf(Date), | ||
locale: _propTypes["default"].string, | ||
maxDate: isMaxDate, | ||
minDate: isMinDate, | ||
onClick: _propTypes["default"].func, | ||
onMouseOver: _propTypes["default"].func, | ||
tileClassName: _propTypes["default"].oneOfType([_propTypes["default"].func, isClassName]), | ||
tileContent: _propTypes["default"].oneOfType([_propTypes["default"].func, _propTypes["default"].node]), | ||
value: isValue, | ||
valueType: _propTypes["default"].string | ||
exports.tileGroupProps = { | ||
activeStartDate: prop_types_1.default.instanceOf(Date).isRequired, | ||
hover: prop_types_1.default.instanceOf(Date), | ||
locale: prop_types_1.default.string, | ||
maxDate: isMaxDate, | ||
minDate: isMinDate, | ||
onClick: prop_types_1.default.func, | ||
onMouseOver: prop_types_1.default.func, | ||
tileClassName: prop_types_1.default.oneOfType([prop_types_1.default.func, exports.isClassName]), | ||
tileContent: prop_types_1.default.oneOfType([prop_types_1.default.func, prop_types_1.default.node]), | ||
value: exports.isValue, | ||
valueType: prop_types_1.default.string, | ||
}; | ||
exports.tileGroupProps = tileGroupProps; | ||
var tileProps = { | ||
activeStartDate: _propTypes["default"].instanceOf(Date).isRequired, | ||
classes: _propTypes["default"].arrayOf(_propTypes["default"].string).isRequired, | ||
date: _propTypes["default"].instanceOf(Date).isRequired, | ||
locale: _propTypes["default"].string, | ||
maxDate: isMaxDate, | ||
minDate: isMinDate, | ||
onClick: _propTypes["default"].func, | ||
onMouseOver: _propTypes["default"].func, | ||
style: _propTypes["default"].objectOf(_propTypes["default"].oneOfType([_propTypes["default"].string, _propTypes["default"].number])), | ||
tileClassName: _propTypes["default"].oneOfType([_propTypes["default"].func, isClassName]), | ||
tileContent: _propTypes["default"].oneOfType([_propTypes["default"].func, _propTypes["default"].node]), | ||
tileDisabled: _propTypes["default"].func | ||
exports.tileProps = { | ||
activeStartDate: prop_types_1.default.instanceOf(Date).isRequired, | ||
classes: prop_types_1.default.arrayOf(prop_types_1.default.string).isRequired, | ||
date: prop_types_1.default.instanceOf(Date).isRequired, | ||
locale: prop_types_1.default.string, | ||
maxDate: isMaxDate, | ||
minDate: isMinDate, | ||
onClick: prop_types_1.default.func, | ||
onMouseOver: prop_types_1.default.func, | ||
style: prop_types_1.default.objectOf(prop_types_1.default.oneOfType([prop_types_1.default.string, prop_types_1.default.number])), | ||
tileClassName: prop_types_1.default.oneOfType([prop_types_1.default.func, exports.isClassName]), | ||
tileContent: prop_types_1.default.oneOfType([prop_types_1.default.func, prop_types_1.default.node]), | ||
tileDisabled: prop_types_1.default.func, | ||
}; | ||
exports.tileProps = tileProps; |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
exports.between = between; | ||
exports.doRangesOverlap = doRangesOverlap; | ||
exports.getTileClasses = getTileClasses; | ||
exports.isRangeWithinRange = isRangeWithinRange; | ||
exports.isValueWithinRange = isValueWithinRange; | ||
var _dates = require("./dates"); | ||
function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); } | ||
function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } | ||
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } | ||
function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); } | ||
function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); } | ||
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
exports.getTileClasses = exports.doRangesOverlap = exports.isRangeWithinRange = exports.isValueWithinRange = exports.between = void 0; | ||
var dates_1 = require("./dates"); | ||
/** | ||
* Returns a value no smaller than min and no larger than max. | ||
* | ||
* @param {*} value Value to return. | ||
* @param {*} min Minimum return value. | ||
* @param {*} max Maximum return value. | ||
* @param {Date} value Value to return. | ||
* @param {Date} min Minimum return value. | ||
* @param {Date} max Maximum return value. | ||
*/ | ||
function between(value, min, max) { | ||
if (min && min > value) { | ||
return min; | ||
} | ||
if (max && max < value) { | ||
return max; | ||
} | ||
return value; | ||
if (min && min > value) { | ||
return min; | ||
} | ||
if (max && max < value) { | ||
return max; | ||
} | ||
return value; | ||
} | ||
exports.between = between; | ||
function isValueWithinRange(value, range) { | ||
return range[0] <= value && range[1] >= value; | ||
return range[0] <= value && range[1] >= value; | ||
} | ||
exports.isValueWithinRange = isValueWithinRange; | ||
function isRangeWithinRange(greaterRange, smallerRange) { | ||
return greaterRange[0] <= smallerRange[0] && greaterRange[1] >= smallerRange[1]; | ||
return greaterRange[0] <= smallerRange[0] && greaterRange[1] >= smallerRange[1]; | ||
} | ||
exports.isRangeWithinRange = isRangeWithinRange; | ||
function doRangesOverlap(range1, range2) { | ||
return isValueWithinRange(range1[0], range2) || isValueWithinRange(range1[1], range2); | ||
return isValueWithinRange(range1[0], range2) || isValueWithinRange(range1[1], range2); | ||
} | ||
exports.doRangesOverlap = doRangesOverlap; | ||
function getRangeClassNames(valueRange, dateRange, baseClassName) { | ||
var isRange = doRangesOverlap(dateRange, valueRange); | ||
var classes = []; | ||
if (isRange) { | ||
classes.push(baseClassName); | ||
var isRangeStart = isValueWithinRange(valueRange[0], dateRange); | ||
var isRangeEnd = isValueWithinRange(valueRange[1], dateRange); | ||
if (isRangeStart) { | ||
classes.push("".concat(baseClassName, "Start")); | ||
var isRange = doRangesOverlap(dateRange, valueRange); | ||
var classes = []; | ||
if (isRange) { | ||
classes.push(baseClassName); | ||
var isRangeStart = isValueWithinRange(valueRange[0], dateRange); | ||
var isRangeEnd = isValueWithinRange(valueRange[1], dateRange); | ||
if (isRangeStart) { | ||
classes.push("".concat(baseClassName, "Start")); | ||
} | ||
if (isRangeEnd) { | ||
classes.push("".concat(baseClassName, "End")); | ||
} | ||
if (isRangeStart && isRangeEnd) { | ||
classes.push("".concat(baseClassName, "BothEnds")); | ||
} | ||
} | ||
if (isRangeEnd) { | ||
classes.push("".concat(baseClassName, "End")); | ||
return classes; | ||
} | ||
function getTileClasses(args) { | ||
if (!args) { | ||
throw new Error('args is required'); | ||
} | ||
if (isRangeStart && isRangeEnd) { | ||
classes.push("".concat(baseClassName, "BothEnds")); | ||
var value = args.value, date = args.date, hover = args.hover; | ||
var className = 'react-calendar__tile'; | ||
var classes = [className]; | ||
if (!date) { | ||
return classes; | ||
} | ||
} | ||
return classes; | ||
var now = new Date(); | ||
var dateRange = (function () { | ||
if (Array.isArray(date)) { | ||
return date; | ||
} | ||
var dateType = args.dateType; | ||
if (!dateType) { | ||
throw new Error('dateType is required when date is not an array of two dates'); | ||
} | ||
return (0, dates_1.getRange)(dateType, date); | ||
})(); | ||
if (isValueWithinRange(now, dateRange)) { | ||
classes.push("".concat(className, "--now")); | ||
} | ||
if (!value) { | ||
return classes; | ||
} | ||
var valueRange = (function () { | ||
if (Array.isArray(value)) { | ||
return value; | ||
} | ||
var valueType = args.valueType; | ||
if (!valueType) { | ||
throw new Error('valueType is required when value is not an array of two dates'); | ||
} | ||
return (0, dates_1.getRange)(valueType, value); | ||
})(); | ||
if (isRangeWithinRange(valueRange, dateRange)) { | ||
classes.push("".concat(className, "--active")); | ||
} | ||
else if (doRangesOverlap(valueRange, dateRange)) { | ||
classes.push("".concat(className, "--hasActive")); | ||
} | ||
var valueRangeClassNames = getRangeClassNames(valueRange, dateRange, "".concat(className, "--range")); | ||
classes.push.apply(classes, valueRangeClassNames); | ||
var valueArray = Array.isArray(value) ? value : [value]; | ||
if (hover && valueArray.length === 1) { | ||
var hoverRange = hover > valueRange[0] ? [valueRange[0], hover] : [hover, valueRange[0]]; | ||
var hoverRangeClassNames = getRangeClassNames(hoverRange, dateRange, "".concat(className, "--hover")); | ||
classes.push.apply(classes, hoverRangeClassNames); | ||
} | ||
return classes; | ||
} | ||
function getTileClasses() { | ||
var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}, | ||
value = _ref.value, | ||
valueType = _ref.valueType, | ||
date = _ref.date, | ||
dateType = _ref.dateType, | ||
hover = _ref.hover; | ||
var className = 'react-calendar__tile'; | ||
var classes = [className]; | ||
if (!date) { | ||
return classes; | ||
} | ||
if (!Array.isArray(date) && !dateType) { | ||
throw new Error('getTileClasses(): Unable to get tile activity classes because one or more required arguments were not passed.'); | ||
} | ||
var now = new Date(); | ||
var dateRange = Array.isArray(date) ? date : (0, _dates.getRange)(dateType, date); | ||
if (isValueWithinRange(now, dateRange)) { | ||
classes.push("".concat(className, "--now")); | ||
} | ||
if (!value) { | ||
return classes; | ||
} | ||
if (!Array.isArray(value) && !valueType) { | ||
throw new Error('getTileClasses(): Unable to get tile activity classes because one or more required arguments were not passed.'); | ||
} | ||
var valueRange = Array.isArray(value) ? value : (0, _dates.getRange)(valueType, value); | ||
if (isRangeWithinRange(valueRange, dateRange)) { | ||
classes.push("".concat(className, "--active")); | ||
} else if (doRangesOverlap(valueRange, dateRange)) { | ||
classes.push("".concat(className, "--hasActive")); | ||
} | ||
var valueRangeClassNames = getRangeClassNames(valueRange, dateRange, "".concat(className, "--range")); | ||
classes.push.apply(classes, _toConsumableArray(valueRangeClassNames)); | ||
var valueArray = [].concat(value); | ||
if (hover && valueArray.length === 1) { | ||
var hoverRange = hover > valueRange[0] ? [valueRange[0], hover] : [hover, valueRange[0]]; | ||
var hoverRangeClassNames = getRangeClassNames(hoverRange, dateRange, "".concat(className, "--hover")); | ||
classes.push.apply(classes, _toConsumableArray(hoverRangeClassNames)); | ||
} | ||
return classes; | ||
} | ||
exports.getTileClasses = getTileClasses; |
"use strict"; | ||
function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); } | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
var __extends = (this && this.__extends) || (function () { | ||
var extendStatics = function (d, b) { | ||
extendStatics = Object.setPrototypeOf || | ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || | ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; | ||
return extendStatics(d, b); | ||
}; | ||
return function (d, b) { | ||
if (typeof b !== "function" && b !== null) | ||
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); | ||
extendStatics(d, b); | ||
function __() { this.constructor = d; } | ||
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); | ||
}; | ||
})(); | ||
var __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { | ||
if (k2 === undefined) k2 = k; | ||
var desc = Object.getOwnPropertyDescriptor(m, k); | ||
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { | ||
desc = { enumerable: true, get: function() { return m[k]; } }; | ||
} | ||
Object.defineProperty(o, k2, desc); | ||
}) : (function(o, m, k, k2) { | ||
if (k2 === undefined) k2 = k; | ||
o[k2] = m[k]; | ||
})); | ||
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { | ||
Object.defineProperty(o, "default", { enumerable: true, value: v }); | ||
}) : function(o, v) { | ||
o["default"] = v; | ||
}); | ||
exports["default"] = void 0; | ||
var _react = _interopRequireWildcard(require("react")); | ||
var _propTypes = _interopRequireDefault(require("prop-types")); | ||
var _clsx = _interopRequireDefault(require("clsx")); | ||
var _propTypes2 = require("./shared/propTypes"); | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } | ||
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } | ||
function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } | ||
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } | ||
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; } | ||
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); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } | ||
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 } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); } | ||
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } | ||
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } | ||
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); } | ||
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } | ||
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } | ||
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } | ||
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 __importStar = (this && this.__importStar) || function (mod) { | ||
if (mod && mod.__esModule) return mod; | ||
var result = {}; | ||
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); | ||
__setModuleDefault(result, mod); | ||
return result; | ||
}; | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
var react_1 = __importStar(require("react")); | ||
var prop_types_1 = __importDefault(require("prop-types")); | ||
var clsx_1 = __importDefault(require("clsx")); | ||
var propTypes_1 = require("./shared/propTypes"); | ||
function datesAreDifferent(date1, date2) { | ||
return date1 && !date2 || !date1 && date2 || date1 && date2 && date1.getTime() !== date2.getTime(); | ||
return ((date1 && !date2) || | ||
(!date1 && date2) || | ||
(date1 && date2 && date1.getTime() !== date2.getTime())); | ||
} | ||
function getValue(nextProps, prop) { | ||
var activeStartDate = nextProps.activeStartDate, | ||
date = nextProps.date, | ||
view = nextProps.view; | ||
return typeof prop === 'function' ? prop({ | ||
activeStartDate: activeStartDate, | ||
date: date, | ||
view: view | ||
}) : prop; | ||
} | ||
var Tile = /*#__PURE__*/function (_Component) { | ||
_inherits(Tile, _Component); | ||
var _super = _createSuper(Tile); | ||
function Tile() { | ||
var _this; | ||
_classCallCheck(this, Tile); | ||
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { | ||
args[_key] = arguments[_key]; | ||
var Tile = /** @class */ (function (_super) { | ||
__extends(Tile, _super); | ||
function Tile() { | ||
var _this = _super !== null && _super.apply(this, arguments) || this; | ||
_this.state = {}; | ||
return _this; | ||
} | ||
_this = _super.call.apply(_super, [this].concat(args)); | ||
_defineProperty(_assertThisInitialized(_this), "state", {}); | ||
return _this; | ||
} | ||
_createClass(Tile, [{ | ||
key: "render", | ||
value: function render() { | ||
var _this$props = this.props, | ||
activeStartDate = _this$props.activeStartDate, | ||
children = _this$props.children, | ||
classes = _this$props.classes, | ||
date = _this$props.date, | ||
formatAbbr = _this$props.formatAbbr, | ||
locale = _this$props.locale, | ||
maxDate = _this$props.maxDate, | ||
maxDateTransform = _this$props.maxDateTransform, | ||
minDate = _this$props.minDate, | ||
minDateTransform = _this$props.minDateTransform, | ||
onClick = _this$props.onClick, | ||
onMouseOver = _this$props.onMouseOver, | ||
style = _this$props.style, | ||
tileDisabled = _this$props.tileDisabled, | ||
view = _this$props.view; | ||
var _this$state = this.state, | ||
tileClassName = _this$state.tileClassName, | ||
tileContent = _this$state.tileContent; | ||
return /*#__PURE__*/_react["default"].createElement("button", { | ||
className: (0, _clsx["default"])(classes, tileClassName), | ||
disabled: minDate && minDateTransform(minDate) > date || maxDate && maxDateTransform(maxDate) < date || tileDisabled && tileDisabled({ | ||
activeStartDate: activeStartDate, | ||
date: date, | ||
view: view | ||
}), | ||
onClick: onClick && function (event) { | ||
return onClick(date, event); | ||
}, | ||
onFocus: onMouseOver && function () { | ||
return onMouseOver(date); | ||
}, | ||
onMouseOver: onMouseOver && function () { | ||
return onMouseOver(date); | ||
}, | ||
style: style, | ||
type: "button" | ||
}, formatAbbr ? /*#__PURE__*/_react["default"].createElement("abbr", { | ||
"aria-label": formatAbbr(locale, date) | ||
}, children) : children, tileContent); | ||
} | ||
}], [{ | ||
key: "getDerivedStateFromProps", | ||
value: function getDerivedStateFromProps(nextProps, prevState) { | ||
var activeStartDate = nextProps.activeStartDate, | ||
tileClassName = nextProps.tileClassName, | ||
tileContent = nextProps.tileContent; | ||
var nextState = {}; | ||
if (tileClassName !== prevState.tileClassNameProps || datesAreDifferent(activeStartDate, prevState.activeStartDateProps)) { | ||
nextState.tileClassName = getValue(nextProps, tileClassName); | ||
nextState.tileClassNameProps = tileClassName; | ||
} | ||
if (tileContent !== prevState.tileContentProps || datesAreDifferent(activeStartDate, prevState.activeStartDateProps)) { | ||
nextState.tileContent = getValue(nextProps, tileContent); | ||
nextState.tileContentProps = tileContent; | ||
} | ||
nextState.activeStartDateProps = activeStartDate; | ||
return nextState; | ||
} | ||
}]); | ||
return Tile; | ||
}(_react.Component); | ||
exports["default"] = Tile; | ||
Tile.propTypes = _objectSpread(_objectSpread({}, _propTypes2.tileProps), {}, { | ||
children: _propTypes["default"].node.isRequired, | ||
formatAbbr: _propTypes["default"].func, | ||
maxDateTransform: _propTypes["default"].func.isRequired, | ||
minDateTransform: _propTypes["default"].func.isRequired | ||
}); | ||
Tile.getDerivedStateFromProps = function (nextProps, prevState) { | ||
var activeStartDate = nextProps.activeStartDate, date = nextProps.date, tileClassName = nextProps.tileClassName, tileContent = nextProps.tileContent, view = nextProps.view; | ||
var nextState = {}; | ||
var args = { activeStartDate: activeStartDate, date: date, view: view }; | ||
if (tileClassName !== prevState.tileClassNameProps || | ||
datesAreDifferent(activeStartDate, prevState.activeStartDateProps)) { | ||
nextState.tileClassName = | ||
typeof tileClassName === 'function' ? tileClassName(args) : tileClassName; | ||
nextState.tileClassNameProps = tileClassName; | ||
} | ||
if (tileContent !== prevState.tileContentProps || | ||
datesAreDifferent(activeStartDate, prevState.activeStartDateProps)) { | ||
nextState.tileContent = typeof tileContent === 'function' ? tileContent(args) : tileContent; | ||
nextState.tileContentProps = tileContent; | ||
} | ||
nextState.activeStartDateProps = activeStartDate; | ||
return nextState; | ||
}; | ||
Tile.prototype.render = function () { | ||
var _a = this.props, activeStartDate = _a.activeStartDate, children = _a.children, classes = _a.classes, date = _a.date, formatAbbr = _a.formatAbbr, locale = _a.locale, maxDate = _a.maxDate, maxDateTransform = _a.maxDateTransform, minDate = _a.minDate, minDateTransform = _a.minDateTransform, onClick = _a.onClick, onMouseOver = _a.onMouseOver, style = _a.style, tileDisabled = _a.tileDisabled, view = _a.view; | ||
var _b = this.state, tileClassName = _b.tileClassName, tileContent = _b.tileContent; | ||
return (react_1.default.createElement("button", { className: (0, clsx_1.default)(classes, tileClassName), disabled: (minDate && minDateTransform(minDate) > date) || | ||
(maxDate && maxDateTransform(maxDate) < date) || | ||
(tileDisabled && tileDisabled({ activeStartDate: activeStartDate, date: date, view: view })), onClick: onClick ? function (event) { return onClick(date, event); } : undefined, onFocus: onMouseOver ? function () { return onMouseOver(date); } : undefined, onMouseOver: onMouseOver ? function () { return onMouseOver(date); } : undefined, style: style, type: "button" }, | ||
formatAbbr ? react_1.default.createElement("abbr", { "aria-label": formatAbbr(locale, date) }, children) : children, | ||
tileContent)); | ||
}; | ||
Tile.propTypes = __assign(__assign({}, propTypes_1.tileProps), { children: prop_types_1.default.node.isRequired, formatAbbr: prop_types_1.default.func, maxDateTransform: prop_types_1.default.func.isRequired, minDateTransform: prop_types_1.default.func.isRequired }); | ||
return Tile; | ||
}(react_1.Component)); | ||
exports.default = Tile; |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
exports["default"] = TileGroup; | ||
var _react = _interopRequireDefault(require("react")); | ||
var _propTypes = _interopRequireDefault(require("prop-types")); | ||
var _Flex = _interopRequireDefault(require("./Flex")); | ||
var _utils = require("./shared/utils"); | ||
var _propTypes2 = require("./shared/propTypes"); | ||
var _excluded = ["className", "count", "dateTransform", "dateType", "end", "hover", "offset", "start", "step", "tile", "value", "valueType"]; | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } | ||
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } | ||
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(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; } | ||
function _extends() { _extends = Object.assign ? Object.assign.bind() : 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 _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } | ||
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; } | ||
function TileGroup(_ref) { | ||
var className = _ref.className, | ||
_ref$count = _ref.count, | ||
count = _ref$count === void 0 ? 3 : _ref$count, | ||
dateTransform = _ref.dateTransform, | ||
dateType = _ref.dateType, | ||
end = _ref.end, | ||
hover = _ref.hover, | ||
offset = _ref.offset, | ||
start = _ref.start, | ||
_ref$step = _ref.step, | ||
step = _ref$step === void 0 ? 1 : _ref$step, | ||
Tile = _ref.tile, | ||
value = _ref.value, | ||
valueType = _ref.valueType, | ||
tileProps = _objectWithoutProperties(_ref, _excluded); | ||
var tiles = []; | ||
for (var point = start; point <= end; point += step) { | ||
var date = dateTransform(point); | ||
tiles.push( /*#__PURE__*/_react["default"].createElement(Tile, _extends({ | ||
key: date.getTime(), | ||
classes: (0, _utils.getTileClasses)({ | ||
value: value, | ||
valueType: valueType, | ||
date: date, | ||
dateType: dateType, | ||
hover: hover | ||
}), | ||
date: date, | ||
point: point | ||
}, tileProps))); | ||
} | ||
return /*#__PURE__*/_react["default"].createElement(_Flex["default"], { | ||
className: className, | ||
count: count, | ||
offset: offset, | ||
wrap: true | ||
}, tiles); | ||
var __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
var __rest = (this && this.__rest) || function (s, e) { | ||
var t = {}; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) | ||
t[p] = s[p]; | ||
if (s != null && typeof Object.getOwnPropertySymbols === "function") | ||
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { | ||
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) | ||
t[p[i]] = s[p[i]]; | ||
} | ||
return t; | ||
}; | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
var react_1 = __importDefault(require("react")); | ||
var prop_types_1 = __importDefault(require("prop-types")); | ||
var Flex_1 = __importDefault(require("./Flex")); | ||
var utils_1 = require("./shared/utils"); | ||
var propTypes_1 = require("./shared/propTypes"); | ||
function TileGroup(_a) { | ||
var className = _a.className, _b = _a.count, count = _b === void 0 ? 3 : _b, dateTransform = _a.dateTransform, dateType = _a.dateType, end = _a.end, hover = _a.hover, offset = _a.offset, start = _a.start, _c = _a.step, step = _c === void 0 ? 1 : _c, Tile = _a.tile, value = _a.value, valueType = _a.valueType, tileProps = __rest(_a, ["className", "count", "dateTransform", "dateType", "end", "hover", "offset", "start", "step", "tile", "value", "valueType"]); | ||
var tiles = []; | ||
for (var point = start; point <= end; point += step) { | ||
var date = dateTransform(point); | ||
tiles.push(react_1.default.createElement(Tile, __assign({ key: date.getTime(), classes: (0, utils_1.getTileClasses)({ | ||
value: value, | ||
valueType: valueType, | ||
date: date, | ||
dateType: dateType, | ||
hover: hover, | ||
}), date: date, point: point }, tileProps))); | ||
} | ||
return (react_1.default.createElement(Flex_1.default, { className: className, count: count, offset: offset, wrap: true }, tiles)); | ||
} | ||
TileGroup.propTypes = _objectSpread(_objectSpread({}, _propTypes2.tileGroupProps), {}, { | ||
activeStartDate: _propTypes["default"].instanceOf(Date), | ||
count: _propTypes["default"].number, | ||
dateTransform: _propTypes["default"].func.isRequired, | ||
dateType: _propTypes["default"].string, | ||
offset: _propTypes["default"].number, | ||
step: _propTypes["default"].number, | ||
tile: _propTypes["default"].func.isRequired | ||
}); | ||
exports.default = TileGroup; | ||
TileGroup.propTypes = __assign(__assign({}, propTypes_1.tileGroupProps), { className: prop_types_1.default.string, count: prop_types_1.default.number, dateTransform: prop_types_1.default.func.isRequired, dateType: prop_types_1.default.string, end: prop_types_1.default.number.isRequired, offset: prop_types_1.default.number, step: prop_types_1.default.number, start: prop_types_1.default.number.isRequired, tile: prop_types_1.default.func.isRequired }); |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
exports["default"] = YearView; | ||
var _react = _interopRequireDefault(require("react")); | ||
var _Months = _interopRequireDefault(require("./YearView/Months")); | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } | ||
var __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
var react_1 = __importDefault(require("react")); | ||
var Months_1 = __importDefault(require("./YearView/Months")); | ||
function YearView(props) { | ||
function renderMonths() { | ||
return /*#__PURE__*/_react["default"].createElement(_Months["default"], props); | ||
} | ||
return /*#__PURE__*/_react["default"].createElement("div", { | ||
className: "react-calendar__year-view" | ||
}, renderMonths()); | ||
} | ||
function renderMonths() { | ||
return react_1.default.createElement(Months_1.default, __assign({}, props)); | ||
} | ||
return react_1.default.createElement("div", { className: "react-calendar__year-view" }, renderMonths()); | ||
} | ||
exports.default = YearView; |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
exports["default"] = Month; | ||
var _react = _interopRequireDefault(require("react")); | ||
var _propTypes = _interopRequireDefault(require("prop-types")); | ||
var _dateUtils = require("@wojtekmaj/date-utils"); | ||
var _Tile = _interopRequireDefault(require("../Tile")); | ||
var _dateFormatter = require("../shared/dateFormatter"); | ||
var _propTypes2 = require("../shared/propTypes"); | ||
var _excluded = ["classes", "formatMonth", "formatMonthYear"]; | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } | ||
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } | ||
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(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; } | ||
function _extends() { _extends = Object.assign ? Object.assign.bind() : 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 _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } | ||
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 __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
var __rest = (this && this.__rest) || function (s, e) { | ||
var t = {}; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) | ||
t[p] = s[p]; | ||
if (s != null && typeof Object.getOwnPropertySymbols === "function") | ||
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { | ||
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) | ||
t[p[i]] = s[p[i]]; | ||
} | ||
return t; | ||
}; | ||
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) { | ||
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) { | ||
if (ar || !(i in from)) { | ||
if (!ar) ar = Array.prototype.slice.call(from, 0, i); | ||
ar[i] = from[i]; | ||
} | ||
} | ||
return to.concat(ar || Array.prototype.slice.call(from)); | ||
}; | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
var react_1 = __importDefault(require("react")); | ||
var prop_types_1 = __importDefault(require("prop-types")); | ||
var date_utils_1 = require("@wojtekmaj/date-utils"); | ||
var Tile_1 = __importDefault(require("../Tile")); | ||
var dateFormatter_1 = require("../shared/dateFormatter"); | ||
var propTypes_1 = require("../shared/propTypes"); | ||
var className = 'react-calendar__year-view__months__month'; | ||
function Month(_ref) { | ||
var classes = _ref.classes, | ||
_ref$formatMonth = _ref.formatMonth, | ||
formatMonth = _ref$formatMonth === void 0 ? _dateFormatter.formatMonth : _ref$formatMonth, | ||
_ref$formatMonthYear = _ref.formatMonthYear, | ||
formatMonthYear = _ref$formatMonthYear === void 0 ? _dateFormatter.formatMonthYear : _ref$formatMonthYear, | ||
otherProps = _objectWithoutProperties(_ref, _excluded); | ||
var date = otherProps.date, | ||
locale = otherProps.locale; | ||
return /*#__PURE__*/_react["default"].createElement(_Tile["default"], _extends({}, otherProps, { | ||
classes: [].concat(classes, className), | ||
formatAbbr: formatMonthYear, | ||
maxDateTransform: _dateUtils.getMonthEnd, | ||
minDateTransform: _dateUtils.getMonthStart, | ||
view: "year" | ||
}), formatMonth(locale, date)); | ||
function Month(_a) { | ||
var _b = _a.classes, classes = _b === void 0 ? [] : _b, _c = _a.formatMonth, formatMonth = _c === void 0 ? dateFormatter_1.formatMonth : _c, _d = _a.formatMonthYear, formatMonthYear = _d === void 0 ? dateFormatter_1.formatMonthYear : _d, otherProps = __rest(_a, ["classes", "formatMonth", "formatMonthYear"]); | ||
var date = otherProps.date, locale = otherProps.locale; | ||
return (react_1.default.createElement(Tile_1.default, __assign({}, otherProps, { classes: __spreadArray(__spreadArray([], classes, true), [className], false), formatAbbr: formatMonthYear, maxDateTransform: date_utils_1.getMonthEnd, minDateTransform: date_utils_1.getMonthStart, view: "year" }), formatMonth(locale, date))); | ||
} | ||
Month.propTypes = _objectSpread(_objectSpread({}, _propTypes2.tileProps), {}, { | ||
formatMonth: _propTypes["default"].func, | ||
formatMonthYear: _propTypes["default"].func | ||
}); | ||
exports.default = Month; | ||
Month.propTypes = __assign(__assign({}, propTypes_1.tileProps), { formatMonth: prop_types_1.default.func, formatMonthYear: prop_types_1.default.func }); |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
exports["default"] = Months; | ||
var _react = _interopRequireDefault(require("react")); | ||
var _propTypes = _interopRequireDefault(require("prop-types")); | ||
var _dateUtils = require("@wojtekmaj/date-utils"); | ||
var _TileGroup = _interopRequireDefault(require("../TileGroup")); | ||
var _Month = _interopRequireDefault(require("./Month")); | ||
var _propTypes2 = require("../shared/propTypes"); | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } | ||
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } | ||
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(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; } | ||
function _extends() { _extends = Object.assign ? Object.assign.bind() : 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 __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
var react_1 = __importDefault(require("react")); | ||
var prop_types_1 = __importDefault(require("prop-types")); | ||
var date_utils_1 = require("@wojtekmaj/date-utils"); | ||
var TileGroup_1 = __importDefault(require("../TileGroup")); | ||
var Month_1 = __importDefault(require("./Month")); | ||
var propTypes_1 = require("../shared/propTypes"); | ||
function Months(props) { | ||
var activeStartDate = props.activeStartDate; | ||
var start = 0; | ||
var end = 11; | ||
var year = (0, _dateUtils.getYear)(activeStartDate); | ||
return /*#__PURE__*/_react["default"].createElement(_TileGroup["default"], _extends({}, props, { | ||
className: "react-calendar__year-view__months", | ||
dateTransform: function dateTransform(monthIndex) { | ||
var date = new Date(); | ||
date.setFullYear(year, monthIndex, 1); | ||
date.setHours(0, 0, 0, 0); | ||
return date; | ||
}, | ||
dateType: "month", | ||
end: end, | ||
start: start, | ||
tile: _Month["default"] | ||
})); | ||
var activeStartDate = props.activeStartDate; | ||
var start = 0; | ||
var end = 11; | ||
var year = (0, date_utils_1.getYear)(activeStartDate); | ||
return (react_1.default.createElement(TileGroup_1.default, __assign({}, props, { className: "react-calendar__year-view__months", dateTransform: function (monthIndex) { | ||
var date = new Date(); | ||
date.setFullYear(year, monthIndex, 1); | ||
date.setHours(0, 0, 0, 0); | ||
return date; | ||
}, dateType: "month", end: end, start: start, tile: Month_1.default }))); | ||
} | ||
Months.propTypes = _objectSpread(_objectSpread({}, _propTypes2.tileGroupProps), {}, { | ||
locale: _propTypes["default"].string | ||
}); | ||
exports.default = Months; | ||
Months.propTypes = __assign(__assign({}, propTypes_1.tileGroupProps), { locale: prop_types_1.default.string }); |
@@ -1,25 +0,38 @@ | ||
var _excluded = ["activeStartDate", "defaultActiveStartDate", "defaultValue", "defaultView", "maxDetail", "minDetail", "value", "view"]; | ||
function _extends() { _extends = Object.assign ? Object.assign.bind() : 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 _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); } | ||
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); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } | ||
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 } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); } | ||
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } | ||
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } | ||
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); } | ||
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } | ||
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } | ||
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } | ||
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } | ||
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(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; } | ||
function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } | ||
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; } | ||
function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); } | ||
function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } | ||
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } | ||
function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); } | ||
function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); } | ||
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } | ||
var __extends = (this && this.__extends) || (function () { | ||
var extendStatics = function (d, b) { | ||
extendStatics = Object.setPrototypeOf || | ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || | ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; | ||
return extendStatics(d, b); | ||
}; | ||
return function (d, b) { | ||
if (typeof b !== "function" && b !== null) | ||
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); | ||
extendStatics(d, b); | ||
function __() { this.constructor = d; } | ||
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); | ||
}; | ||
})(); | ||
var __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
var __rest = (this && this.__rest) || function (s, e) { | ||
var t = {}; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) | ||
t[p] = s[p]; | ||
if (s != null && typeof Object.getOwnPropertySymbols === "function") | ||
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { | ||
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) | ||
t[p[i]] = s[p[i]]; | ||
} | ||
return t; | ||
}; | ||
import React, { Component } from 'react'; | ||
@@ -34,3 +47,3 @@ import PropTypes from 'prop-types'; | ||
import { getBegin, getBeginNext, getEnd, getValueRange } from './shared/dates'; | ||
import { isCalendarType, isClassName, isMaxDate, isMinDate, isRef, isValue, isView } from './shared/propTypes'; | ||
import { isCalendarType, isClassName, isMaxDate, isMinDate, isRef, isValue, isView, } from './shared/propTypes'; | ||
import { between } from './shared/utils'; | ||
@@ -43,10 +56,9 @@ var defaultMinDate = new Date(); | ||
var allViews = ['century', 'decade', 'year', 'month']; | ||
var allValueTypes = [].concat(_toConsumableArray(allViews.slice(1)), ['day']); | ||
var allValueTypes = ['decade', 'year', 'month', 'day']; | ||
function toDate(value) { | ||
if (value instanceof Date) { | ||
return value; | ||
} | ||
return new Date(value); | ||
if (value instanceof Date) { | ||
return value; | ||
} | ||
return new Date(value); | ||
} | ||
/** | ||
@@ -56,5 +68,4 @@ * Returns views array with disallowed values cut off. | ||
function getLimitedViews(minDetail, maxDetail) { | ||
return allViews.slice(allViews.indexOf(minDetail), allViews.indexOf(maxDetail) + 1); | ||
return allViews.slice(allViews.indexOf(minDetail), allViews.indexOf(maxDetail) + 1); | ||
} | ||
/** | ||
@@ -64,6 +75,5 @@ * Determines whether a given view is allowed with currently applied settings. | ||
function isViewAllowed(view, minDetail, maxDetail) { | ||
var views = getLimitedViews(minDetail, maxDetail); | ||
return views.indexOf(view) !== -1; | ||
var views = getLimitedViews(minDetail, maxDetail); | ||
return views.indexOf(view) !== -1; | ||
} | ||
/** | ||
@@ -74,617 +84,518 @@ * Gets either provided view if allowed by minDetail and maxDetail, or gets | ||
function getView(view, minDetail, maxDetail) { | ||
if (isViewAllowed(view, minDetail, maxDetail)) { | ||
return view; | ||
} | ||
return maxDetail; | ||
if (!view) { | ||
return maxDetail; | ||
} | ||
if (isViewAllowed(view, minDetail, maxDetail)) { | ||
return view; | ||
} | ||
return maxDetail; | ||
} | ||
/** | ||
* Returns value type that can be returned with currently applied settings. | ||
*/ | ||
function getValueType(maxDetail) { | ||
return allValueTypes[allViews.indexOf(maxDetail)]; | ||
function getValueType(view) { | ||
var index = allViews.indexOf(view); | ||
return allValueTypes[index]; | ||
} | ||
function getValue(value, index) { | ||
if (!value) { | ||
return null; | ||
} | ||
var rawValue = Array.isArray(value) && value.length === 2 ? value[index] : value; | ||
if (!rawValue) { | ||
return null; | ||
} | ||
var valueDate = toDate(rawValue); | ||
if (isNaN(valueDate.getTime())) { | ||
throw new Error("Invalid date: ".concat(value)); | ||
} | ||
return valueDate; | ||
var rawValue = Array.isArray(value) ? value[index] : value; | ||
if (!rawValue) { | ||
return null; | ||
} | ||
var valueDate = toDate(rawValue); | ||
if (isNaN(valueDate.getTime())) { | ||
throw new Error("Invalid date: ".concat(value)); | ||
} | ||
return valueDate; | ||
} | ||
function getDetailValue(_ref, index) { | ||
var value = _ref.value, | ||
minDate = _ref.minDate, | ||
maxDate = _ref.maxDate, | ||
maxDetail = _ref.maxDetail; | ||
var valuePiece = getValue(value, index); | ||
if (!valuePiece) { | ||
return null; | ||
} | ||
var valueType = getValueType(maxDetail); | ||
var detailValueFrom = [getBegin, getEnd][index](valueType, valuePiece); | ||
return between(detailValueFrom, minDate, maxDate); | ||
function getDetailValue(_a, index) { | ||
var value = _a.value, minDate = _a.minDate, maxDate = _a.maxDate, maxDetail = _a.maxDetail; | ||
var valuePiece = getValue(value, index); | ||
if (!valuePiece) { | ||
return null; | ||
} | ||
var valueType = getValueType(maxDetail); | ||
var detailValueFrom = (function () { | ||
switch (index) { | ||
case 0: | ||
return getBegin(valueType, valuePiece); | ||
case 1: | ||
return getEnd(valueType, valuePiece); | ||
default: | ||
throw new Error("Invalid index value: ".concat(index)); | ||
} | ||
})(); | ||
return between(detailValueFrom, minDate, maxDate); | ||
} | ||
var getDetailValueFrom = function getDetailValueFrom(args) { | ||
return getDetailValue(args, 0); | ||
var getDetailValueFrom = function (args) { return getDetailValue(args, 0); }; | ||
var getDetailValueTo = function (args) { return getDetailValue(args, 1); }; | ||
var getDetailValueArray = function (args) { | ||
var value = args.value; | ||
if (Array.isArray(value)) { | ||
return value; | ||
} | ||
return [getDetailValueFrom, getDetailValueTo].map(function (fn) { return fn(args); }); | ||
}; | ||
var getDetailValueTo = function getDetailValueTo(args) { | ||
return getDetailValue(args, 1); | ||
}; | ||
var getDetailValueArray = function getDetailValueArray(args) { | ||
var value = args.value; | ||
if (Array.isArray(value)) { | ||
return value; | ||
} | ||
return [getDetailValueFrom, getDetailValueTo].map(function (fn) { | ||
return fn(args); | ||
}); | ||
}; | ||
function getActiveStartDate(props) { | ||
var maxDate = props.maxDate, | ||
maxDetail = props.maxDetail, | ||
minDate = props.minDate, | ||
minDetail = props.minDetail, | ||
value = props.value, | ||
view = props.view; | ||
var rangeType = getView(view, minDetail, maxDetail); | ||
var valueFrom = getDetailValueFrom({ | ||
value: value, | ||
minDate: minDate, | ||
maxDate: maxDate, | ||
maxDetail: maxDetail | ||
}) || new Date(); | ||
return getBegin(rangeType, valueFrom); | ||
var maxDate = props.maxDate, maxDetail = props.maxDetail, minDate = props.minDate, minDetail = props.minDetail, value = props.value, view = props.view; | ||
var rangeType = getView(view, minDetail, maxDetail); | ||
var valueFrom = getDetailValueFrom({ | ||
value: value, | ||
minDate: minDate, | ||
maxDate: maxDate, | ||
maxDetail: maxDetail, | ||
}) || new Date(); | ||
return getBegin(rangeType, valueFrom); | ||
} | ||
function getInitialActiveStartDate(props) { | ||
var activeStartDate = props.activeStartDate, | ||
defaultActiveStartDate = props.defaultActiveStartDate, | ||
defaultValue = props.defaultValue, | ||
defaultView = props.defaultView, | ||
maxDetail = props.maxDetail, | ||
minDetail = props.minDetail, | ||
value = props.value, | ||
view = props.view, | ||
otherProps = _objectWithoutProperties(props, _excluded); | ||
var rangeType = getView(view, minDetail, maxDetail); | ||
var valueFrom = activeStartDate || defaultActiveStartDate; | ||
if (valueFrom) { | ||
return getBegin(rangeType, valueFrom); | ||
} | ||
return getActiveStartDate(_objectSpread({ | ||
maxDetail: maxDetail, | ||
minDetail: minDetail, | ||
value: value || defaultValue, | ||
view: view || defaultView | ||
}, otherProps)); | ||
var activeStartDate = props.activeStartDate, defaultActiveStartDate = props.defaultActiveStartDate, defaultValue = props.defaultValue, defaultView = props.defaultView, maxDetail = props.maxDetail, minDetail = props.minDetail, value = props.value, view = props.view, otherProps = __rest(props, ["activeStartDate", "defaultActiveStartDate", "defaultValue", "defaultView", "maxDetail", "minDetail", "value", "view"]); | ||
var rangeType = getView(view, minDetail, maxDetail); | ||
var valueFrom = activeStartDate || defaultActiveStartDate; | ||
if (valueFrom) { | ||
return getBegin(rangeType, valueFrom); | ||
} | ||
return getActiveStartDate(__assign({ maxDetail: maxDetail, minDetail: minDetail, value: value || defaultValue, view: view || defaultView }, otherProps)); | ||
} | ||
var getIsSingleValue = function getIsSingleValue(value) { | ||
return value && [].concat(value).length === 1; | ||
}; | ||
var Calendar = /*#__PURE__*/function (_Component) { | ||
_inherits(Calendar, _Component); | ||
var _super = _createSuper(Calendar); | ||
function Calendar() { | ||
var _this; | ||
_classCallCheck(this, Calendar); | ||
for (var _len = arguments.length, _args = new Array(_len), _key = 0; _key < _len; _key++) { | ||
_args[_key] = arguments[_key]; | ||
} | ||
_this = _super.call.apply(_super, [this].concat(_args)); | ||
_defineProperty(_assertThisInitialized(_this), "state", { | ||
activeStartDate: _this.props.defaultActiveStartDate, | ||
value: _this.props.defaultValue, | ||
view: _this.props.defaultView | ||
}); | ||
_defineProperty(_assertThisInitialized(_this), "setStateAndCallCallbacks", function (nextState, event, callback) { | ||
var _assertThisInitialize = _assertThisInitialized(_this), | ||
previousActiveStartDate = _assertThisInitialize.activeStartDate, | ||
previousView = _assertThisInitialize.view; | ||
var _this$props = _this.props, | ||
allowPartialRange = _this$props.allowPartialRange, | ||
onActiveStartDateChange = _this$props.onActiveStartDateChange, | ||
onChange = _this$props.onChange, | ||
onViewChange = _this$props.onViewChange, | ||
selectRange = _this$props.selectRange; | ||
var prevArgs = { | ||
activeStartDate: previousActiveStartDate, | ||
view: previousView | ||
}; | ||
_this.setState(nextState, function () { | ||
var args = { | ||
action: nextState.action, | ||
activeStartDate: nextState.activeStartDate || _this.activeStartDate, | ||
value: nextState.value || _this.value, | ||
view: nextState.view || _this.view | ||
function getIsSingleValue(value) { | ||
return value && (!Array.isArray(value) || value.length === 1); | ||
} | ||
var isActiveStartDate = PropTypes.instanceOf(Date); | ||
var isLooseValue = PropTypes.oneOfType([PropTypes.string, isValue]); | ||
var Calendar = /** @class */ (function (_super) { | ||
__extends(Calendar, _super); | ||
function Calendar() { | ||
var _this = _super !== null && _super.apply(this, arguments) || this; | ||
_this.state = { | ||
activeStartDate: _this.props.defaultActiveStartDate, | ||
hover: null, | ||
value: typeof _this.props.defaultValue === 'string' | ||
? toDate(_this.props.defaultValue) | ||
: _this.props.defaultValue, | ||
view: _this.props.defaultView, | ||
}; | ||
function shouldUpdate(key) { | ||
return ( | ||
// Key must exist, and… | ||
key in nextState && ( | ||
// …key changed from undefined to defined or the other way around, or… | ||
_typeof(nextState[key]) !== _typeof(prevArgs[key]) || ( | ||
// …value changed. | ||
nextState[key] instanceof Date ? nextState[key].getTime() !== prevArgs[key].getTime() : nextState[key] !== prevArgs[key])) | ||
); | ||
} | ||
if (shouldUpdate('activeStartDate')) { | ||
if (onActiveStartDateChange) onActiveStartDateChange(args); | ||
} | ||
if (shouldUpdate('view')) { | ||
if (onViewChange) onViewChange(args); | ||
} | ||
if (shouldUpdate('value')) { | ||
if (onChange) { | ||
_this.setStateAndCallCallbacks = function (nextState, event, callback) { | ||
var _a = _this, previousActiveStartDate = _a.activeStartDate, previousView = _a.view; | ||
var _b = _this.props, allowPartialRange = _b.allowPartialRange, onActiveStartDateChange = _b.onActiveStartDateChange, onChange = _b.onChange, onViewChange = _b.onViewChange, selectRange = _b.selectRange; | ||
var prevArgs = { | ||
action: undefined, | ||
activeStartDate: previousActiveStartDate, | ||
value: undefined, | ||
view: previousView, | ||
}; | ||
_this.setState(nextState, function () { | ||
var args = { | ||
action: nextState.action, | ||
activeStartDate: nextState.activeStartDate || _this.activeStartDate, | ||
value: ('value' in nextState && nextState.value) || _this.value, | ||
view: ('view' in nextState && nextState.view) || _this.view, | ||
}; | ||
function shouldUpdate(key) { | ||
// Key must exist, and… | ||
if (!(key in nextState)) { | ||
return false; | ||
} | ||
var nextValue = nextState[key]; | ||
var prevValue = prevArgs[key]; | ||
// …key changed from defined to undefined or the other way around, or… | ||
if (typeof nextValue !== typeof prevValue) { | ||
return true; | ||
} | ||
// …value changed. | ||
if (nextValue instanceof Date && prevValue instanceof Date) { | ||
return nextValue.getTime() !== prevValue.getTime(); | ||
} | ||
else { | ||
return nextValue !== prevValue; | ||
} | ||
} | ||
if (shouldUpdate('activeStartDate')) { | ||
if (onActiveStartDateChange) | ||
onActiveStartDateChange(args); | ||
} | ||
if (shouldUpdate('view')) { | ||
if (onViewChange) | ||
onViewChange(args); | ||
} | ||
if (shouldUpdate('value')) { | ||
if (onChange) { | ||
if (!event) { | ||
throw new Error('event is required'); | ||
} | ||
if (selectRange) { | ||
var isSingleValue = getIsSingleValue(nextState.value); | ||
if (!isSingleValue) { | ||
onChange(nextState.value || null, event); | ||
} | ||
else if (allowPartialRange) { | ||
if (Array.isArray(nextState.value)) { | ||
throw new Error('value must not be an array'); | ||
} | ||
onChange([nextState.value || null], event); | ||
} | ||
} | ||
else { | ||
onChange(nextState.value || null, event); | ||
} | ||
} | ||
} | ||
if (callback) | ||
callback(args); | ||
}); | ||
}; | ||
/** | ||
* Called when the user uses navigation buttons. | ||
*/ | ||
_this.setActiveStartDate = function (nextActiveStartDate, action) { | ||
_this.setStateAndCallCallbacks({ | ||
action: action, | ||
activeStartDate: nextActiveStartDate, | ||
}); | ||
}; | ||
_this.drillDown = function (nextActiveStartDate, event) { | ||
if (!_this.drillDownAvailable) { | ||
return; | ||
} | ||
_this.onClickTile(nextActiveStartDate, event); | ||
var _a = _this, view = _a.view, views = _a.views; | ||
var onDrillDown = _this.props.onDrillDown; | ||
var nextView = views[views.indexOf(view) + 1]; | ||
if (!nextView) { | ||
throw new Error('Attempted to drill down from the lowest view.'); | ||
} | ||
_this.setStateAndCallCallbacks({ | ||
action: 'drillDown', | ||
activeStartDate: nextActiveStartDate, | ||
view: nextView, | ||
}, undefined, onDrillDown); | ||
}; | ||
_this.drillUp = function () { | ||
if (!_this.drillUpAvailable) { | ||
return; | ||
} | ||
var _a = _this, activeStartDate = _a.activeStartDate, view = _a.view, views = _a.views; | ||
var onDrillUp = _this.props.onDrillUp; | ||
var nextView = views[views.indexOf(view) - 1]; | ||
if (!nextView) { | ||
throw new Error('Attempted to drill up from the highest view.'); | ||
} | ||
var nextActiveStartDate = getBegin(nextView, activeStartDate); | ||
_this.setStateAndCallCallbacks({ | ||
action: 'drillUp', | ||
activeStartDate: nextActiveStartDate, | ||
view: nextView, | ||
}, undefined, onDrillUp); | ||
}; | ||
_this.onChange = function (value, event) { | ||
var previousValue = _this.value; | ||
var _a = _this.props, goToRangeStartOnSelect = _a.goToRangeStartOnSelect, selectRange = _a.selectRange; | ||
_this.onClickTile(value, event); | ||
var isFirstValueInRange = selectRange && !getIsSingleValue(previousValue); | ||
var nextValue; | ||
if (selectRange) { | ||
var isSingleValue = getIsSingleValue(nextState.value); | ||
if (!isSingleValue) { | ||
onChange(nextState.value, event); | ||
} else if (allowPartialRange) { | ||
onChange([nextState.value], event); | ||
} | ||
} else { | ||
onChange(nextState.value, event); | ||
// Range selection turned on | ||
var valueType = _this.valueType; | ||
if (isFirstValueInRange) { | ||
// Value has 0 or 2 elements - either way we're starting a new array | ||
// First value | ||
nextValue = getBegin(valueType, value); | ||
} | ||
else { | ||
if (!previousValue) { | ||
throw new Error('previousValue is required'); | ||
} | ||
if (Array.isArray(previousValue)) { | ||
throw new Error('previousValue must not be an array'); | ||
} | ||
// Second value | ||
nextValue = getValueRange(valueType, previousValue, value); | ||
} | ||
} | ||
} | ||
} | ||
if (callback) callback(args); | ||
}); | ||
else { | ||
// Range selection turned off | ||
nextValue = _this.getProcessedValue(value); | ||
} | ||
var nextActiveStartDate = | ||
// Range selection turned off | ||
!selectRange || | ||
// Range selection turned on, first value | ||
isFirstValueInRange || | ||
// Range selection turned on, second value, goToRangeStartOnSelect toggled on | ||
goToRangeStartOnSelect | ||
? getActiveStartDate(__assign(__assign({}, _this.props), { value: nextValue })) | ||
: null; | ||
event.persist(); | ||
_this.setStateAndCallCallbacks({ | ||
action: 'onChange', | ||
activeStartDate: nextActiveStartDate, | ||
value: nextValue, | ||
}, event); | ||
}; | ||
_this.onClickTile = function (value, event) { | ||
var view = _this.view; | ||
var _a = _this.props, onClickDay = _a.onClickDay, onClickDecade = _a.onClickDecade, onClickMonth = _a.onClickMonth, onClickYear = _a.onClickYear; | ||
var callback = (function () { | ||
switch (view) { | ||
case 'century': | ||
return onClickDecade; | ||
case 'decade': | ||
return onClickYear; | ||
case 'year': | ||
return onClickMonth; | ||
case 'month': | ||
return onClickDay; | ||
default: | ||
throw new Error("Invalid view: ".concat(view, ".")); | ||
} | ||
})(); | ||
if (callback) | ||
callback(value, event); | ||
}; | ||
_this.onMouseOver = function (value) { | ||
_this.setState(function (prevState) { | ||
if (prevState.hover && prevState.hover.getTime() === value.getTime()) { | ||
return null; | ||
} | ||
return { hover: value }; | ||
}); | ||
}; | ||
_this.onMouseLeave = function () { | ||
_this.setState({ hover: null }); | ||
}; | ||
return _this; | ||
} | ||
Object.defineProperty(Calendar.prototype, "activeStartDate", { | ||
get: function () { | ||
var activeStartDateProps = this.props.activeStartDate; | ||
var activeStartDateState = this.state.activeStartDate; | ||
return activeStartDateProps || activeStartDateState || getInitialActiveStartDate(this.props); | ||
}, | ||
enumerable: false, | ||
configurable: true | ||
}); | ||
_defineProperty(_assertThisInitialized(_this), "setActiveStartDate", function (nextActiveStartDate, action) { | ||
_this.setStateAndCallCallbacks({ | ||
action: action, | ||
activeStartDate: nextActiveStartDate | ||
}); | ||
Object.defineProperty(Calendar.prototype, "value", { | ||
get: function () { | ||
var _a = this.props, selectRange = _a.selectRange, valueProps = _a.value; | ||
var valueState = this.state.value; | ||
var rawValue = (function () { | ||
// In the middle of range selection, use value from state | ||
if (selectRange && getIsSingleValue(valueState)) { | ||
return valueState; | ||
} | ||
return valueProps !== undefined ? valueProps : valueState; | ||
})(); | ||
if (!rawValue) { | ||
return null; | ||
} | ||
return typeof rawValue === 'string' ? toDate(rawValue) : rawValue; | ||
}, | ||
enumerable: false, | ||
configurable: true | ||
}); | ||
_defineProperty(_assertThisInitialized(_this), "drillDown", function (nextActiveStartDate, event) { | ||
if (!_this.drillDownAvailable) { | ||
return; | ||
} | ||
_this.onClickTile(nextActiveStartDate, event); | ||
var _assertThisInitialize2 = _assertThisInitialized(_this), | ||
view = _assertThisInitialize2.view, | ||
views = _assertThisInitialize2.views; | ||
var onDrillDown = _this.props.onDrillDown; | ||
var nextView = views[views.indexOf(view) + 1]; | ||
_this.setStateAndCallCallbacks({ | ||
action: 'drillDown', | ||
activeStartDate: nextActiveStartDate, | ||
view: nextView | ||
}, undefined, onDrillDown); | ||
Object.defineProperty(Calendar.prototype, "valueType", { | ||
get: function () { | ||
var maxDetail = this.props.maxDetail; | ||
return getValueType(maxDetail); | ||
}, | ||
enumerable: false, | ||
configurable: true | ||
}); | ||
_defineProperty(_assertThisInitialized(_this), "drillUp", function () { | ||
if (!_this.drillUpAvailable) { | ||
return; | ||
} | ||
var _assertThisInitialize3 = _assertThisInitialized(_this), | ||
activeStartDate = _assertThisInitialize3.activeStartDate, | ||
view = _assertThisInitialize3.view, | ||
views = _assertThisInitialize3.views; | ||
var onDrillUp = _this.props.onDrillUp; | ||
var nextView = views[views.indexOf(view) - 1]; | ||
var nextActiveStartDate = getBegin(nextView, activeStartDate); | ||
_this.setStateAndCallCallbacks({ | ||
action: 'drillUp', | ||
activeStartDate: nextActiveStartDate, | ||
view: nextView | ||
}, undefined, onDrillUp); | ||
Object.defineProperty(Calendar.prototype, "view", { | ||
get: function () { | ||
var _a = this.props, minDetail = _a.minDetail, maxDetail = _a.maxDetail, viewProps = _a.view; | ||
var viewState = this.state.view; | ||
return getView(viewProps || viewState, minDetail, maxDetail); | ||
}, | ||
enumerable: false, | ||
configurable: true | ||
}); | ||
_defineProperty(_assertThisInitialized(_this), "onChange", function (value, event) { | ||
var _assertThisInitialize4 = _assertThisInitialized(_this), | ||
previousValue = _assertThisInitialize4.value; | ||
var _this$props2 = _this.props, | ||
goToRangeStartOnSelect = _this$props2.goToRangeStartOnSelect, | ||
selectRange = _this$props2.selectRange; | ||
_this.onClickTile(value, event); | ||
var isFirstValueInRange = selectRange && !getIsSingleValue(previousValue); | ||
var nextValue; | ||
if (selectRange) { | ||
// Range selection turned on | ||
var _assertThisInitialize5 = _assertThisInitialized(_this), | ||
valueType = _assertThisInitialize5.valueType; | ||
if (isFirstValueInRange) { | ||
// Value has 0 or 2 elements - either way we're starting a new array | ||
// First value | ||
nextValue = getBegin(valueType, value); | ||
} else { | ||
// Second value | ||
nextValue = getValueRange(valueType, previousValue, value); | ||
} | ||
} else { | ||
// Range selection turned off | ||
nextValue = _this.getProcessedValue(value); | ||
} | ||
var nextActiveStartDate = | ||
// Range selection turned off | ||
!selectRange || | ||
// Range selection turned on, first value | ||
isFirstValueInRange || | ||
// Range selection turned on, second value, goToRangeStartOnSelect toggled on | ||
goToRangeStartOnSelect ? getActiveStartDate(_objectSpread(_objectSpread({}, _this.props), {}, { | ||
value: nextValue | ||
})) : null; | ||
event.persist(); | ||
_this.setStateAndCallCallbacks({ | ||
action: 'onChange', | ||
activeStartDate: nextActiveStartDate, | ||
value: nextValue | ||
}, event); | ||
Object.defineProperty(Calendar.prototype, "views", { | ||
get: function () { | ||
var _a = this.props, minDetail = _a.minDetail, maxDetail = _a.maxDetail; | ||
return getLimitedViews(minDetail, maxDetail); | ||
}, | ||
enumerable: false, | ||
configurable: true | ||
}); | ||
_defineProperty(_assertThisInitialized(_this), "onClickTile", function (value, event) { | ||
var _assertThisInitialize6 = _assertThisInitialized(_this), | ||
view = _assertThisInitialize6.view; | ||
var _this$props3 = _this.props, | ||
onClickDay = _this$props3.onClickDay, | ||
onClickDecade = _this$props3.onClickDecade, | ||
onClickMonth = _this$props3.onClickMonth, | ||
onClickYear = _this$props3.onClickYear; | ||
var callback = function () { | ||
switch (view) { | ||
case 'century': | ||
return onClickDecade; | ||
case 'decade': | ||
return onClickYear; | ||
case 'year': | ||
return onClickMonth; | ||
case 'month': | ||
return onClickDay; | ||
default: | ||
throw new Error("Invalid view: ".concat(view, ".")); | ||
} | ||
}(); | ||
if (callback) callback(value, event); | ||
Object.defineProperty(Calendar.prototype, "hover", { | ||
get: function () { | ||
var selectRange = this.props.selectRange; | ||
var hover = this.state.hover; | ||
return selectRange ? hover : null; | ||
}, | ||
enumerable: false, | ||
configurable: true | ||
}); | ||
_defineProperty(_assertThisInitialized(_this), "onMouseOver", function (value) { | ||
_this.setState(function (prevState) { | ||
if (prevState.hover && prevState.hover.getTime() === value.getTime()) { | ||
return null; | ||
} | ||
return { | ||
hover: value | ||
}; | ||
}); | ||
Object.defineProperty(Calendar.prototype, "drillDownAvailable", { | ||
get: function () { | ||
var _a = this, view = _a.view, views = _a.views; | ||
return views.indexOf(view) < views.length - 1; | ||
}, | ||
enumerable: false, | ||
configurable: true | ||
}); | ||
_defineProperty(_assertThisInitialized(_this), "onMouseLeave", function () { | ||
_this.setState({ | ||
hover: null | ||
}); | ||
Object.defineProperty(Calendar.prototype, "drillUpAvailable", { | ||
get: function () { | ||
var _a = this, view = _a.view, views = _a.views; | ||
return views.indexOf(view) > 0; | ||
}, | ||
enumerable: false, | ||
configurable: true | ||
}); | ||
return _this; | ||
} | ||
_createClass(Calendar, [{ | ||
key: "activeStartDate", | ||
get: function get() { | ||
var activeStartDateProps = this.props.activeStartDate; | ||
var activeStartDateState = this.state.activeStartDate; | ||
return activeStartDateProps || activeStartDateState || getInitialActiveStartDate(this.props); | ||
} | ||
}, { | ||
key: "value", | ||
get: function get() { | ||
var _this$props4 = this.props, | ||
selectRange = _this$props4.selectRange, | ||
valueProps = _this$props4.value; | ||
var valueState = this.state.value; | ||
// In the middle of range selection, use value from state | ||
if (selectRange && getIsSingleValue(valueState)) { | ||
return valueState; | ||
} | ||
return valueProps !== undefined ? valueProps : valueState; | ||
} | ||
}, { | ||
key: "valueType", | ||
get: function get() { | ||
var maxDetail = this.props.maxDetail; | ||
return getValueType(maxDetail); | ||
} | ||
}, { | ||
key: "view", | ||
get: function get() { | ||
var _this$props5 = this.props, | ||
minDetail = _this$props5.minDetail, | ||
maxDetail = _this$props5.maxDetail, | ||
viewProps = _this$props5.view; | ||
var viewState = this.state.view; | ||
return getView(viewProps || viewState, minDetail, maxDetail); | ||
} | ||
}, { | ||
key: "views", | ||
get: function get() { | ||
var _this$props6 = this.props, | ||
minDetail = _this$props6.minDetail, | ||
maxDetail = _this$props6.maxDetail; | ||
return getLimitedViews(minDetail, maxDetail); | ||
} | ||
}, { | ||
key: "hover", | ||
get: function get() { | ||
var selectRange = this.props.selectRange; | ||
var hover = this.state.hover; | ||
return selectRange ? hover : null; | ||
} | ||
}, { | ||
key: "drillDownAvailable", | ||
get: function get() { | ||
var view = this.view, | ||
views = this.views; | ||
return views.indexOf(view) < views.length - 1; | ||
} | ||
}, { | ||
key: "drillUpAvailable", | ||
get: function get() { | ||
var view = this.view, | ||
views = this.views; | ||
return views.indexOf(view) > 0; | ||
} | ||
/** | ||
* Gets current value in a desired format. | ||
*/ | ||
}, { | ||
key: "getProcessedValue", | ||
value: function getProcessedValue(value) { | ||
var _this$props7 = this.props, | ||
minDate = _this$props7.minDate, | ||
maxDate = _this$props7.maxDate, | ||
maxDetail = _this$props7.maxDetail, | ||
returnValue = _this$props7.returnValue; | ||
var processFunction = function () { | ||
switch (returnValue) { | ||
case 'start': | ||
return getDetailValueFrom; | ||
case 'end': | ||
return getDetailValueTo; | ||
case 'range': | ||
return getDetailValueArray; | ||
default: | ||
throw new Error('Invalid returnValue.'); | ||
Calendar.prototype.getProcessedValue = function (value) { | ||
var _a = this.props, minDate = _a.minDate, maxDate = _a.maxDate, maxDetail = _a.maxDetail, returnValue = _a.returnValue; | ||
var processFunction = (function () { | ||
switch (returnValue) { | ||
case 'start': | ||
return getDetailValueFrom; | ||
case 'end': | ||
return getDetailValueTo; | ||
case 'range': | ||
return getDetailValueArray; | ||
default: | ||
throw new Error('Invalid returnValue.'); | ||
} | ||
})(); | ||
return processFunction({ | ||
value: value, | ||
minDate: minDate, | ||
maxDate: maxDate, | ||
maxDetail: maxDetail, | ||
}); | ||
}; | ||
Calendar.prototype.renderContent = function (next) { | ||
var _a = this, currentActiveStartDate = _a.activeStartDate, onMouseOver = _a.onMouseOver, valueType = _a.valueType, value = _a.value, view = _a.view; | ||
var _b = this.props, calendarType = _b.calendarType, locale = _b.locale, maxDate = _b.maxDate, minDate = _b.minDate, selectRange = _b.selectRange, tileClassName = _b.tileClassName, tileContent = _b.tileContent, tileDisabled = _b.tileDisabled; | ||
var hover = this.hover; | ||
var activeStartDate = next | ||
? getBeginNext(view, currentActiveStartDate) | ||
: getBegin(view, currentActiveStartDate); | ||
var onClick = this.drillDownAvailable ? this.drillDown : this.onChange; | ||
var commonProps = { | ||
activeStartDate: activeStartDate, | ||
hover: hover, | ||
locale: locale, | ||
maxDate: maxDate, | ||
minDate: minDate, | ||
onClick: onClick, | ||
onMouseOver: selectRange ? onMouseOver : null, | ||
tileClassName: tileClassName, | ||
tileContent: tileContent, | ||
tileDisabled: tileDisabled, | ||
value: value, | ||
valueType: valueType, | ||
}; | ||
switch (view) { | ||
case 'century': { | ||
var formatYear = this.props.formatYear; | ||
return React.createElement(CenturyView, __assign({ formatYear: formatYear }, commonProps)); | ||
} | ||
case 'decade': { | ||
var formatYear = this.props.formatYear; | ||
return React.createElement(DecadeView, __assign({ formatYear: formatYear }, commonProps)); | ||
} | ||
case 'year': { | ||
var _c = this.props, formatMonth = _c.formatMonth, formatMonthYear = _c.formatMonthYear; | ||
return (React.createElement(YearView, __assign({ formatMonth: formatMonth, formatMonthYear: formatMonthYear }, commonProps))); | ||
} | ||
case 'month': { | ||
var _d = this.props, formatDay = _d.formatDay, formatLongDate = _d.formatLongDate, formatShortWeekday = _d.formatShortWeekday, formatWeekday = _d.formatWeekday, onClickWeekNumber = _d.onClickWeekNumber, showDoubleView = _d.showDoubleView, showFixedNumberOfWeeks = _d.showFixedNumberOfWeeks, showNeighboringMonth = _d.showNeighboringMonth, showWeekNumbers = _d.showWeekNumbers; | ||
var onMouseLeave = this.onMouseLeave; | ||
return (React.createElement(MonthView, __assign({ calendarType: calendarType, formatDay: formatDay, formatLongDate: formatLongDate, formatShortWeekday: formatShortWeekday, formatWeekday: formatWeekday, onClickWeekNumber: onClickWeekNumber, onMouseLeave: selectRange ? onMouseLeave : null, showFixedNumberOfWeeks: typeof showFixedNumberOfWeeks !== 'undefined' | ||
? showFixedNumberOfWeeks | ||
: showDoubleView, showNeighboringMonth: showNeighboringMonth, showWeekNumbers: showWeekNumbers }, commonProps))); | ||
} | ||
default: | ||
throw new Error("Invalid view: ".concat(view, ".")); | ||
} | ||
}(); | ||
return processFunction({ | ||
value: value, | ||
minDate: minDate, | ||
maxDate: maxDate, | ||
maxDetail: maxDetail | ||
}); | ||
} | ||
}, { | ||
key: "renderContent", | ||
value: function renderContent(next) { | ||
var currentActiveStartDate = this.activeStartDate, | ||
onMouseOver = this.onMouseOver, | ||
valueType = this.valueType, | ||
value = this.value, | ||
view = this.view; | ||
var _this$props8 = this.props, | ||
calendarType = _this$props8.calendarType, | ||
locale = _this$props8.locale, | ||
maxDate = _this$props8.maxDate, | ||
minDate = _this$props8.minDate, | ||
selectRange = _this$props8.selectRange, | ||
tileClassName = _this$props8.tileClassName, | ||
tileContent = _this$props8.tileContent, | ||
tileDisabled = _this$props8.tileDisabled; | ||
var hover = this.hover; | ||
var activeStartDate = next ? getBeginNext(view, currentActiveStartDate) : getBegin(view, currentActiveStartDate); | ||
var onClick = this.drillDownAvailable ? this.drillDown : this.onChange; | ||
var commonProps = { | ||
activeStartDate: activeStartDate, | ||
hover: hover, | ||
locale: locale, | ||
maxDate: maxDate, | ||
minDate: minDate, | ||
onClick: onClick, | ||
onMouseOver: selectRange ? onMouseOver : null, | ||
tileClassName: tileClassName, | ||
tileContent: tileContent, | ||
tileDisabled: tileDisabled, | ||
value: value, | ||
valueType: valueType | ||
}; | ||
switch (view) { | ||
case 'century': | ||
{ | ||
var formatYear = this.props.formatYear; | ||
return /*#__PURE__*/React.createElement(CenturyView, _extends({ | ||
formatYear: formatYear | ||
}, commonProps)); | ||
} | ||
case 'decade': | ||
{ | ||
var _formatYear = this.props.formatYear; | ||
return /*#__PURE__*/React.createElement(DecadeView, _extends({ | ||
formatYear: _formatYear | ||
}, commonProps)); | ||
} | ||
case 'year': | ||
{ | ||
var _this$props9 = this.props, | ||
formatMonth = _this$props9.formatMonth, | ||
formatMonthYear = _this$props9.formatMonthYear; | ||
return /*#__PURE__*/React.createElement(YearView, _extends({ | ||
formatMonth: formatMonth, | ||
formatMonthYear: formatMonthYear | ||
}, commonProps)); | ||
} | ||
case 'month': | ||
{ | ||
var _this$props10 = this.props, | ||
formatDay = _this$props10.formatDay, | ||
formatLongDate = _this$props10.formatLongDate, | ||
formatShortWeekday = _this$props10.formatShortWeekday, | ||
formatWeekday = _this$props10.formatWeekday, | ||
onClickWeekNumber = _this$props10.onClickWeekNumber, | ||
showDoubleView = _this$props10.showDoubleView, | ||
showFixedNumberOfWeeks = _this$props10.showFixedNumberOfWeeks, | ||
showNeighboringMonth = _this$props10.showNeighboringMonth, | ||
showWeekNumbers = _this$props10.showWeekNumbers; | ||
var onMouseLeave = this.onMouseLeave; | ||
return /*#__PURE__*/React.createElement(MonthView, _extends({ | ||
calendarType: calendarType, | ||
formatDay: formatDay, | ||
formatLongDate: formatLongDate, | ||
formatShortWeekday: formatShortWeekday, | ||
formatWeekday: formatWeekday, | ||
onClickWeekNumber: onClickWeekNumber, | ||
onMouseLeave: selectRange ? onMouseLeave : null, | ||
showFixedNumberOfWeeks: typeof showFixedNumberOfWeeks !== 'undefined' ? showFixedNumberOfWeeks : showDoubleView, | ||
showNeighboringMonth: showNeighboringMonth, | ||
showWeekNumbers: showWeekNumbers | ||
}, commonProps)); | ||
} | ||
default: | ||
throw new Error("Invalid view: ".concat(view, ".")); | ||
} | ||
} | ||
}, { | ||
key: "renderNavigation", | ||
value: function renderNavigation() { | ||
var showNavigation = this.props.showNavigation; | ||
if (!showNavigation) { | ||
return null; | ||
} | ||
var activeStartDate = this.activeStartDate, | ||
view = this.view, | ||
views = this.views; | ||
var _this$props11 = this.props, | ||
formatMonthYear = _this$props11.formatMonthYear, | ||
formatYear = _this$props11.formatYear, | ||
locale = _this$props11.locale, | ||
maxDate = _this$props11.maxDate, | ||
minDate = _this$props11.minDate, | ||
navigationAriaLabel = _this$props11.navigationAriaLabel, | ||
navigationAriaLive = _this$props11.navigationAriaLive, | ||
navigationLabel = _this$props11.navigationLabel, | ||
next2AriaLabel = _this$props11.next2AriaLabel, | ||
next2Label = _this$props11.next2Label, | ||
nextAriaLabel = _this$props11.nextAriaLabel, | ||
nextLabel = _this$props11.nextLabel, | ||
prev2AriaLabel = _this$props11.prev2AriaLabel, | ||
prev2Label = _this$props11.prev2Label, | ||
prevAriaLabel = _this$props11.prevAriaLabel, | ||
prevLabel = _this$props11.prevLabel, | ||
showDoubleView = _this$props11.showDoubleView; | ||
return /*#__PURE__*/React.createElement(Navigation, { | ||
activeStartDate: activeStartDate, | ||
drillUp: this.drillUp, | ||
formatMonthYear: formatMonthYear, | ||
formatYear: formatYear, | ||
locale: locale, | ||
maxDate: maxDate, | ||
minDate: minDate, | ||
navigationAriaLabel: navigationAriaLabel, | ||
navigationAriaLive: navigationAriaLive, | ||
navigationLabel: navigationLabel, | ||
next2AriaLabel: next2AriaLabel, | ||
next2Label: next2Label, | ||
nextAriaLabel: nextAriaLabel, | ||
nextLabel: nextLabel, | ||
prev2AriaLabel: prev2AriaLabel, | ||
prev2Label: prev2Label, | ||
prevAriaLabel: prevAriaLabel, | ||
prevLabel: prevLabel, | ||
setActiveStartDate: this.setActiveStartDate, | ||
showDoubleView: showDoubleView, | ||
view: view, | ||
views: views | ||
}); | ||
} | ||
}, { | ||
key: "render", | ||
value: function render() { | ||
var _this$props12 = this.props, | ||
className = _this$props12.className, | ||
inputRef = _this$props12.inputRef, | ||
selectRange = _this$props12.selectRange, | ||
showDoubleView = _this$props12.showDoubleView; | ||
var onMouseLeave = this.onMouseLeave, | ||
value = this.value; | ||
var valueArray = [].concat(value); | ||
return /*#__PURE__*/React.createElement("div", { | ||
className: clsx(baseClassName, selectRange && valueArray.length === 1 && "".concat(baseClassName, "--selectRange"), showDoubleView && "".concat(baseClassName, "--doubleView"), className), | ||
ref: inputRef | ||
}, this.renderNavigation(), /*#__PURE__*/React.createElement("div", { | ||
className: "".concat(baseClassName, "__viewContainer"), | ||
onBlur: selectRange ? onMouseLeave : null, | ||
onMouseLeave: selectRange ? onMouseLeave : null | ||
}, this.renderContent(), showDoubleView && this.renderContent(true))); | ||
} | ||
}]); | ||
return Calendar; | ||
}(Component); | ||
export { Calendar as default }; | ||
Calendar.defaultProps = { | ||
goToRangeStartOnSelect: true, | ||
maxDate: defaultMaxDate, | ||
maxDetail: 'month', | ||
minDate: defaultMinDate, | ||
minDetail: 'century', | ||
returnValue: 'start', | ||
showNavigation: true, | ||
showNeighboringMonth: true | ||
}; | ||
var isActiveStartDate = PropTypes.instanceOf(Date); | ||
var isLooseValue = PropTypes.oneOfType([PropTypes.string, isValue]); | ||
Calendar.propTypes = { | ||
activeStartDate: isActiveStartDate, | ||
allowPartialRange: PropTypes.bool, | ||
calendarType: isCalendarType, | ||
className: isClassName, | ||
defaultActiveStartDate: isActiveStartDate, | ||
defaultValue: isLooseValue, | ||
defaultView: isView, | ||
formatDay: PropTypes.func, | ||
formatLongDate: PropTypes.func, | ||
formatMonth: PropTypes.func, | ||
formatMonthYear: PropTypes.func, | ||
formatShortWeekday: PropTypes.func, | ||
formatWeekday: PropTypes.func, | ||
formatYear: PropTypes.func, | ||
goToRangeStartOnSelect: PropTypes.bool, | ||
inputRef: isRef, | ||
locale: PropTypes.string, | ||
maxDate: isMaxDate, | ||
maxDetail: PropTypes.oneOf(allViews), | ||
minDate: isMinDate, | ||
minDetail: PropTypes.oneOf(allViews), | ||
navigationAriaLabel: PropTypes.string, | ||
navigationAriaLive: PropTypes.oneOf(['off', 'polite', 'assertive']), | ||
navigationLabel: PropTypes.func, | ||
next2AriaLabel: PropTypes.string, | ||
next2Label: PropTypes.node, | ||
nextAriaLabel: PropTypes.string, | ||
nextLabel: PropTypes.node, | ||
onActiveStartDateChange: PropTypes.func, | ||
onChange: PropTypes.func, | ||
onClickDay: PropTypes.func, | ||
onClickDecade: PropTypes.func, | ||
onClickMonth: PropTypes.func, | ||
onClickWeekNumber: PropTypes.func, | ||
onClickYear: PropTypes.func, | ||
onDrillDown: PropTypes.func, | ||
onDrillUp: PropTypes.func, | ||
onViewChange: PropTypes.func, | ||
prev2AriaLabel: PropTypes.string, | ||
prev2Label: PropTypes.node, | ||
prevAriaLabel: PropTypes.string, | ||
prevLabel: PropTypes.node, | ||
returnValue: PropTypes.oneOf(['start', 'end', 'range']), | ||
selectRange: PropTypes.bool, | ||
showDoubleView: PropTypes.bool, | ||
showFixedNumberOfWeeks: PropTypes.bool, | ||
showNavigation: PropTypes.bool, | ||
showNeighboringMonth: PropTypes.bool, | ||
showWeekNumbers: PropTypes.bool, | ||
tileClassName: PropTypes.oneOfType([PropTypes.func, isClassName]), | ||
tileContent: PropTypes.oneOfType([PropTypes.func, PropTypes.node]), | ||
tileDisabled: PropTypes.func, | ||
value: isLooseValue, | ||
view: isView | ||
}; | ||
}; | ||
Calendar.prototype.renderNavigation = function () { | ||
var showNavigation = this.props.showNavigation; | ||
if (!showNavigation) { | ||
return null; | ||
} | ||
var _a = this, activeStartDate = _a.activeStartDate, view = _a.view, views = _a.views; | ||
var _b = this.props, formatMonthYear = _b.formatMonthYear, formatYear = _b.formatYear, locale = _b.locale, maxDate = _b.maxDate, minDate = _b.minDate, navigationAriaLabel = _b.navigationAriaLabel, navigationAriaLive = _b.navigationAriaLive, navigationLabel = _b.navigationLabel, next2AriaLabel = _b.next2AriaLabel, next2Label = _b.next2Label, nextAriaLabel = _b.nextAriaLabel, nextLabel = _b.nextLabel, prev2AriaLabel = _b.prev2AriaLabel, prev2Label = _b.prev2Label, prevAriaLabel = _b.prevAriaLabel, prevLabel = _b.prevLabel, showDoubleView = _b.showDoubleView; | ||
return (React.createElement(Navigation, { activeStartDate: activeStartDate, drillUp: this.drillUp, formatMonthYear: formatMonthYear, formatYear: formatYear, locale: locale, maxDate: maxDate, minDate: minDate, navigationAriaLabel: navigationAriaLabel, navigationAriaLive: navigationAriaLive, navigationLabel: navigationLabel, next2AriaLabel: next2AriaLabel, next2Label: next2Label, nextAriaLabel: nextAriaLabel, nextLabel: nextLabel, prev2AriaLabel: prev2AriaLabel, prev2Label: prev2Label, prevAriaLabel: prevAriaLabel, prevLabel: prevLabel, setActiveStartDate: this.setActiveStartDate, showDoubleView: showDoubleView, view: view, views: views })); | ||
}; | ||
Calendar.prototype.render = function () { | ||
var _a = this.props, className = _a.className, inputRef = _a.inputRef, selectRange = _a.selectRange, showDoubleView = _a.showDoubleView; | ||
var _b = this, onMouseLeave = _b.onMouseLeave, value = _b.value; | ||
var valueArray = Array.isArray(value) ? value : [value]; | ||
return (React.createElement("div", { className: clsx(baseClassName, selectRange && valueArray.length === 1 && "".concat(baseClassName, "--selectRange"), showDoubleView && "".concat(baseClassName, "--doubleView"), className), ref: inputRef }, | ||
this.renderNavigation(), | ||
React.createElement("div", { className: "".concat(baseClassName, "__viewContainer"), onBlur: selectRange ? onMouseLeave : undefined, onMouseLeave: selectRange ? onMouseLeave : undefined }, | ||
this.renderContent(), | ||
showDoubleView ? this.renderContent(true) : null))); | ||
}; | ||
Calendar.defaultProps = { | ||
goToRangeStartOnSelect: true, | ||
maxDate: defaultMaxDate, | ||
maxDetail: 'month', | ||
minDate: defaultMinDate, | ||
minDetail: 'century', | ||
returnValue: 'start', | ||
showNavigation: true, | ||
showNeighboringMonth: true, | ||
}; | ||
Calendar.propTypes = { | ||
activeStartDate: isActiveStartDate, | ||
allowPartialRange: PropTypes.bool, | ||
calendarType: isCalendarType, | ||
className: isClassName, | ||
defaultActiveStartDate: isActiveStartDate, | ||
defaultValue: isLooseValue, | ||
defaultView: isView, | ||
formatDay: PropTypes.func, | ||
formatLongDate: PropTypes.func, | ||
formatMonth: PropTypes.func, | ||
formatMonthYear: PropTypes.func, | ||
formatShortWeekday: PropTypes.func, | ||
formatWeekday: PropTypes.func, | ||
formatYear: PropTypes.func, | ||
goToRangeStartOnSelect: PropTypes.bool, | ||
inputRef: isRef, | ||
locale: PropTypes.string, | ||
maxDate: isMaxDate, | ||
maxDetail: PropTypes.oneOf(allViews), | ||
minDate: isMinDate, | ||
minDetail: PropTypes.oneOf(allViews), | ||
navigationAriaLabel: PropTypes.string, | ||
navigationAriaLive: PropTypes.oneOf(['off', 'polite', 'assertive']), | ||
navigationLabel: PropTypes.func, | ||
next2AriaLabel: PropTypes.string, | ||
next2Label: PropTypes.node, | ||
nextAriaLabel: PropTypes.string, | ||
nextLabel: PropTypes.node, | ||
onActiveStartDateChange: PropTypes.func, | ||
onChange: PropTypes.func, | ||
onClickDay: PropTypes.func, | ||
onClickDecade: PropTypes.func, | ||
onClickMonth: PropTypes.func, | ||
onClickWeekNumber: PropTypes.func, | ||
onClickYear: PropTypes.func, | ||
onDrillDown: PropTypes.func, | ||
onDrillUp: PropTypes.func, | ||
onViewChange: PropTypes.func, | ||
prev2AriaLabel: PropTypes.string, | ||
prev2Label: PropTypes.node, | ||
prevAriaLabel: PropTypes.string, | ||
prevLabel: PropTypes.node, | ||
returnValue: PropTypes.oneOf(['start', 'end', 'range']), | ||
selectRange: PropTypes.bool, | ||
showDoubleView: PropTypes.bool, | ||
showFixedNumberOfWeeks: PropTypes.bool, | ||
showNavigation: PropTypes.bool, | ||
showNeighboringMonth: PropTypes.bool, | ||
showWeekNumbers: PropTypes.bool, | ||
tileClassName: PropTypes.oneOfType([PropTypes.func, isClassName]), | ||
tileContent: PropTypes.oneOfType([PropTypes.func, PropTypes.node]), | ||
tileDisabled: PropTypes.func, | ||
value: isLooseValue, | ||
view: isView, | ||
}; | ||
return Calendar; | ||
}(Component)); | ||
export default Calendar; |
import React from 'react'; | ||
import PropTypes from 'prop-types'; | ||
import { getUserLocale } from 'get-user-locale'; | ||
import { getCenturyLabel, getDecadeLabel, getBeginNext, getBeginNext2, getBeginPrevious, getBeginPrevious2, getEndPrevious, getEndPrevious2 } from '../shared/dates'; | ||
import { formatMonthYear as defaultFormatMonthYear, formatYear as defaultFormatYear } from '../shared/dateFormatter'; | ||
import { getCenturyLabel, getDecadeLabel, getBeginNext, getBeginNext2, getBeginPrevious, getBeginPrevious2, getEndPrevious, getEndPrevious2, } from '../shared/dates'; | ||
import { formatMonthYear as defaultFormatMonthYear, formatYear as defaultFormatYear, } from '../shared/dateFormatter'; | ||
import { isView, isViews } from '../shared/propTypes'; | ||
var className = 'react-calendar__navigation'; | ||
export default function Navigation(_ref) { | ||
var activeStartDate = _ref.activeStartDate, | ||
drillUp = _ref.drillUp, | ||
_ref$formatMonthYear = _ref.formatMonthYear, | ||
formatMonthYear = _ref$formatMonthYear === void 0 ? defaultFormatMonthYear : _ref$formatMonthYear, | ||
_ref$formatYear = _ref.formatYear, | ||
formatYear = _ref$formatYear === void 0 ? defaultFormatYear : _ref$formatYear, | ||
locale = _ref.locale, | ||
maxDate = _ref.maxDate, | ||
minDate = _ref.minDate, | ||
_ref$navigationAriaLa = _ref.navigationAriaLabel, | ||
navigationAriaLabel = _ref$navigationAriaLa === void 0 ? '' : _ref$navigationAriaLa, | ||
navigationAriaLive = _ref.navigationAriaLive, | ||
navigationLabel = _ref.navigationLabel, | ||
_ref$next2AriaLabel = _ref.next2AriaLabel, | ||
next2AriaLabel = _ref$next2AriaLabel === void 0 ? '' : _ref$next2AriaLabel, | ||
_ref$next2Label = _ref.next2Label, | ||
next2Label = _ref$next2Label === void 0 ? '»' : _ref$next2Label, | ||
_ref$nextAriaLabel = _ref.nextAriaLabel, | ||
nextAriaLabel = _ref$nextAriaLabel === void 0 ? '' : _ref$nextAriaLabel, | ||
_ref$nextLabel = _ref.nextLabel, | ||
nextLabel = _ref$nextLabel === void 0 ? '›' : _ref$nextLabel, | ||
_ref$prev2AriaLabel = _ref.prev2AriaLabel, | ||
prev2AriaLabel = _ref$prev2AriaLabel === void 0 ? '' : _ref$prev2AriaLabel, | ||
_ref$prev2Label = _ref.prev2Label, | ||
prev2Label = _ref$prev2Label === void 0 ? '«' : _ref$prev2Label, | ||
_ref$prevAriaLabel = _ref.prevAriaLabel, | ||
prevAriaLabel = _ref$prevAriaLabel === void 0 ? '' : _ref$prevAriaLabel, | ||
_ref$prevLabel = _ref.prevLabel, | ||
prevLabel = _ref$prevLabel === void 0 ? '‹' : _ref$prevLabel, | ||
setActiveStartDate = _ref.setActiveStartDate, | ||
showDoubleView = _ref.showDoubleView, | ||
view = _ref.view, | ||
views = _ref.views; | ||
var drillUpAvailable = views.indexOf(view) > 0; | ||
var shouldShowPrevNext2Buttons = view !== 'century'; | ||
var previousActiveStartDate = getBeginPrevious(view, activeStartDate); | ||
var previousActiveStartDate2 = shouldShowPrevNext2Buttons && getBeginPrevious2(view, activeStartDate); | ||
var nextActiveStartDate = getBeginNext(view, activeStartDate); | ||
var nextActiveStartDate2 = shouldShowPrevNext2Buttons && getBeginNext2(view, activeStartDate); | ||
var prevButtonDisabled = function () { | ||
if (previousActiveStartDate.getFullYear() < 0) { | ||
return true; | ||
export default function Navigation(_a) { | ||
var activeStartDate = _a.activeStartDate, drillUp = _a.drillUp, _b = _a.formatMonthYear, formatMonthYear = _b === void 0 ? defaultFormatMonthYear : _b, _c = _a.formatYear, formatYear = _c === void 0 ? defaultFormatYear : _c, locale = _a.locale, maxDate = _a.maxDate, minDate = _a.minDate, _d = _a.navigationAriaLabel, navigationAriaLabel = _d === void 0 ? '' : _d, navigationAriaLive = _a.navigationAriaLive, navigationLabel = _a.navigationLabel, _e = _a.next2AriaLabel, next2AriaLabel = _e === void 0 ? '' : _e, _f = _a.next2Label, next2Label = _f === void 0 ? '»' : _f, _g = _a.nextAriaLabel, nextAriaLabel = _g === void 0 ? '' : _g, _h = _a.nextLabel, nextLabel = _h === void 0 ? '›' : _h, _j = _a.prev2AriaLabel, prev2AriaLabel = _j === void 0 ? '' : _j, _k = _a.prev2Label, prev2Label = _k === void 0 ? '«' : _k, _l = _a.prevAriaLabel, prevAriaLabel = _l === void 0 ? '' : _l, _m = _a.prevLabel, prevLabel = _m === void 0 ? '‹' : _m, setActiveStartDate = _a.setActiveStartDate, showDoubleView = _a.showDoubleView, view = _a.view, views = _a.views; | ||
var drillUpAvailable = views.indexOf(view) > 0; | ||
var shouldShowPrevNext2Buttons = view !== 'century'; | ||
var previousActiveStartDate = getBeginPrevious(view, activeStartDate); | ||
var previousActiveStartDate2 = shouldShowPrevNext2Buttons | ||
? getBeginPrevious2(view, activeStartDate) | ||
: undefined; | ||
var nextActiveStartDate = getBeginNext(view, activeStartDate); | ||
var nextActiveStartDate2 = shouldShowPrevNext2Buttons | ||
? getBeginNext2(view, activeStartDate) | ||
: undefined; | ||
var prevButtonDisabled = (function () { | ||
if (previousActiveStartDate.getFullYear() < 0) { | ||
return true; | ||
} | ||
var previousActiveEndDate = getEndPrevious(view, activeStartDate); | ||
return minDate && minDate >= previousActiveEndDate; | ||
})(); | ||
var prev2ButtonDisabled = shouldShowPrevNext2Buttons && | ||
(function () { | ||
if (previousActiveStartDate2.getFullYear() < 0) { | ||
return true; | ||
} | ||
var previousActiveEndDate = getEndPrevious2(view, activeStartDate); | ||
return minDate && minDate >= previousActiveEndDate; | ||
})(); | ||
var nextButtonDisabled = maxDate && maxDate < nextActiveStartDate; | ||
var next2ButtonDisabled = shouldShowPrevNext2Buttons && maxDate && maxDate < nextActiveStartDate2; | ||
function onClickPrevious() { | ||
setActiveStartDate(previousActiveStartDate, 'prev'); | ||
} | ||
var previousActiveEndDate = getEndPrevious(view, activeStartDate); | ||
return minDate && minDate >= previousActiveEndDate; | ||
}(); | ||
var prev2ButtonDisabled = shouldShowPrevNext2Buttons && function () { | ||
if (previousActiveStartDate2.getFullYear() < 0) { | ||
return true; | ||
function onClickPrevious2() { | ||
setActiveStartDate(previousActiveStartDate2, 'prev2'); | ||
} | ||
var previousActiveEndDate = getEndPrevious2(view, activeStartDate); | ||
return minDate && minDate >= previousActiveEndDate; | ||
}(); | ||
var nextButtonDisabled = maxDate && maxDate < nextActiveStartDate; | ||
var next2ButtonDisabled = shouldShowPrevNext2Buttons && maxDate && maxDate < nextActiveStartDate2; | ||
function onClickPrevious() { | ||
setActiveStartDate(previousActiveStartDate, 'prev'); | ||
} | ||
function onClickPrevious2() { | ||
setActiveStartDate(previousActiveStartDate2, 'prev2'); | ||
} | ||
function onClickNext() { | ||
setActiveStartDate(nextActiveStartDate, 'next'); | ||
} | ||
function onClickNext2() { | ||
setActiveStartDate(nextActiveStartDate2, 'next2'); | ||
} | ||
function renderLabel(date) { | ||
var label = function () { | ||
switch (view) { | ||
case 'century': | ||
return getCenturyLabel(locale, formatYear, date); | ||
case 'decade': | ||
return getDecadeLabel(locale, formatYear, date); | ||
case 'year': | ||
return formatYear(locale, date); | ||
case 'month': | ||
return formatMonthYear(locale, date); | ||
default: | ||
throw new Error("Invalid view: ".concat(view, ".")); | ||
} | ||
}(); | ||
return navigationLabel ? navigationLabel({ | ||
date: date, | ||
label: label, | ||
locale: locale || getUserLocale(), | ||
view: view | ||
}) : label; | ||
} | ||
function renderButton() { | ||
var labelClassName = "".concat(className, "__label"); | ||
return /*#__PURE__*/React.createElement("button", { | ||
"aria-label": navigationAriaLabel, | ||
"aria-live": navigationAriaLive, | ||
className: labelClassName, | ||
disabled: !drillUpAvailable, | ||
onClick: drillUp, | ||
style: { | ||
flexGrow: 1 | ||
}, | ||
type: "button" | ||
}, /*#__PURE__*/React.createElement("span", { | ||
className: "".concat(labelClassName, "__labelText ").concat(labelClassName, "__labelText--from") | ||
}, renderLabel(activeStartDate)), showDoubleView && /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("span", { | ||
className: "".concat(labelClassName, "__divider") | ||
}, " \u2013 "), /*#__PURE__*/React.createElement("span", { | ||
className: "".concat(labelClassName, "__labelText ").concat(labelClassName, "__labelText--to") | ||
}, renderLabel(nextActiveStartDate)))); | ||
} | ||
return /*#__PURE__*/React.createElement("div", { | ||
className: className | ||
}, prev2Label !== null && shouldShowPrevNext2Buttons && /*#__PURE__*/React.createElement("button", { | ||
"aria-label": prev2AriaLabel, | ||
className: "".concat(className, "__arrow ").concat(className, "__prev2-button"), | ||
disabled: prev2ButtonDisabled, | ||
onClick: onClickPrevious2, | ||
type: "button" | ||
}, prev2Label), prevLabel !== null && /*#__PURE__*/React.createElement("button", { | ||
"aria-label": prevAriaLabel, | ||
className: "".concat(className, "__arrow ").concat(className, "__prev-button"), | ||
disabled: prevButtonDisabled, | ||
onClick: onClickPrevious, | ||
type: "button" | ||
}, prevLabel), renderButton(), nextLabel !== null && /*#__PURE__*/React.createElement("button", { | ||
"aria-label": nextAriaLabel, | ||
className: "".concat(className, "__arrow ").concat(className, "__next-button"), | ||
disabled: nextButtonDisabled, | ||
onClick: onClickNext, | ||
type: "button" | ||
}, nextLabel), next2Label !== null && shouldShowPrevNext2Buttons && /*#__PURE__*/React.createElement("button", { | ||
"aria-label": next2AriaLabel, | ||
className: "".concat(className, "__arrow ").concat(className, "__next2-button"), | ||
disabled: next2ButtonDisabled, | ||
onClick: onClickNext2, | ||
type: "button" | ||
}, next2Label)); | ||
function onClickNext() { | ||
setActiveStartDate(nextActiveStartDate, 'next'); | ||
} | ||
function onClickNext2() { | ||
setActiveStartDate(nextActiveStartDate2, 'next2'); | ||
} | ||
function renderLabel(date) { | ||
var label = (function () { | ||
switch (view) { | ||
case 'century': | ||
return getCenturyLabel(locale, formatYear, date); | ||
case 'decade': | ||
return getDecadeLabel(locale, formatYear, date); | ||
case 'year': | ||
return formatYear(locale, date); | ||
case 'month': | ||
return formatMonthYear(locale, date); | ||
default: | ||
throw new Error("Invalid view: ".concat(view, ".")); | ||
} | ||
})(); | ||
return navigationLabel | ||
? navigationLabel({ | ||
date: date, | ||
label: label, | ||
locale: locale || getUserLocale() || undefined, | ||
view: view, | ||
}) | ||
: label; | ||
} | ||
function renderButton() { | ||
var labelClassName = "".concat(className, "__label"); | ||
return (React.createElement("button", { "aria-label": navigationAriaLabel, "aria-live": navigationAriaLive, className: labelClassName, disabled: !drillUpAvailable, onClick: drillUp, style: { flexGrow: 1 }, type: "button" }, | ||
React.createElement("span", { className: "".concat(labelClassName, "__labelText ").concat(labelClassName, "__labelText--from") }, renderLabel(activeStartDate)), | ||
showDoubleView ? (React.createElement(React.Fragment, null, | ||
React.createElement("span", { className: "".concat(labelClassName, "__divider") }, " \u2013 "), | ||
React.createElement("span", { className: "".concat(labelClassName, "__labelText ").concat(labelClassName, "__labelText--to") }, renderLabel(nextActiveStartDate)))) : null)); | ||
} | ||
return (React.createElement("div", { className: className }, | ||
prev2Label !== null && shouldShowPrevNext2Buttons ? (React.createElement("button", { "aria-label": prev2AriaLabel, className: "".concat(className, "__arrow ").concat(className, "__prev2-button"), disabled: prev2ButtonDisabled, onClick: onClickPrevious2, type: "button" }, prev2Label)) : null, | ||
prevLabel !== null && (React.createElement("button", { "aria-label": prevAriaLabel, className: "".concat(className, "__arrow ").concat(className, "__prev-button"), disabled: prevButtonDisabled, onClick: onClickPrevious, type: "button" }, prevLabel)), | ||
renderButton(), | ||
nextLabel !== null && (React.createElement("button", { "aria-label": nextAriaLabel, className: "".concat(className, "__arrow ").concat(className, "__next-button"), disabled: nextButtonDisabled, onClick: onClickNext, type: "button" }, nextLabel)), | ||
next2Label !== null && shouldShowPrevNext2Buttons ? (React.createElement("button", { "aria-label": next2AriaLabel, className: "".concat(className, "__arrow ").concat(className, "__next2-button"), disabled: next2ButtonDisabled, onClick: onClickNext2, type: "button" }, next2Label)) : null)); | ||
} | ||
Navigation.propTypes = { | ||
activeStartDate: PropTypes.instanceOf(Date).isRequired, | ||
drillUp: PropTypes.func.isRequired, | ||
formatMonthYear: PropTypes.func, | ||
formatYear: PropTypes.func, | ||
locale: PropTypes.string, | ||
maxDate: PropTypes.instanceOf(Date), | ||
minDate: PropTypes.instanceOf(Date), | ||
navigationAriaLabel: PropTypes.string, | ||
navigationAriaLive: PropTypes.string, | ||
navigationLabel: PropTypes.func, | ||
next2AriaLabel: PropTypes.string, | ||
next2Label: PropTypes.node, | ||
nextAriaLabel: PropTypes.string, | ||
nextLabel: PropTypes.node, | ||
prev2AriaLabel: PropTypes.string, | ||
prev2Label: PropTypes.node, | ||
prevAriaLabel: PropTypes.string, | ||
prevLabel: PropTypes.node, | ||
setActiveStartDate: PropTypes.func.isRequired, | ||
showDoubleView: PropTypes.bool, | ||
view: isView.isRequired, | ||
views: isViews.isRequired | ||
}; | ||
activeStartDate: PropTypes.instanceOf(Date).isRequired, | ||
drillUp: PropTypes.func.isRequired, | ||
formatMonthYear: PropTypes.func, | ||
formatYear: PropTypes.func, | ||
locale: PropTypes.string, | ||
maxDate: PropTypes.instanceOf(Date), | ||
minDate: PropTypes.instanceOf(Date), | ||
navigationAriaLabel: PropTypes.string, | ||
navigationAriaLive: PropTypes.string, | ||
navigationLabel: PropTypes.func, | ||
next2AriaLabel: PropTypes.string, | ||
next2Label: PropTypes.node, | ||
nextAriaLabel: PropTypes.string, | ||
nextLabel: PropTypes.node, | ||
prev2AriaLabel: PropTypes.string, | ||
prev2Label: PropTypes.node, | ||
prevAriaLabel: PropTypes.string, | ||
prevLabel: PropTypes.node, | ||
setActiveStartDate: PropTypes.func.isRequired, | ||
showDoubleView: PropTypes.bool, | ||
view: isView.isRequired, | ||
views: isViews.isRequired, | ||
}; |
@@ -0,10 +1,19 @@ | ||
var __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
import React from 'react'; | ||
import Decades from './CenturyView/Decades'; | ||
export default function CenturyView(props) { | ||
function renderDecades() { | ||
return /*#__PURE__*/React.createElement(Decades, props); | ||
} | ||
return /*#__PURE__*/React.createElement("div", { | ||
className: "react-calendar__century-view" | ||
}, renderDecades()); | ||
} | ||
function renderDecades() { | ||
return React.createElement(Decades, __assign({}, props)); | ||
} | ||
return React.createElement("div", { className: "react-calendar__century-view" }, renderDecades()); | ||
} |
@@ -1,8 +0,32 @@ | ||
var _excluded = ["classes", "formatYear"]; | ||
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } | ||
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(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; } | ||
function _extends() { _extends = Object.assign ? Object.assign.bind() : 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 _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } | ||
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 __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
var __rest = (this && this.__rest) || function (s, e) { | ||
var t = {}; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) | ||
t[p] = s[p]; | ||
if (s != null && typeof Object.getOwnPropertySymbols === "function") | ||
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { | ||
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) | ||
t[p[i]] = s[p[i]]; | ||
} | ||
return t; | ||
}; | ||
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) { | ||
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) { | ||
if (ar || !(i in from)) { | ||
if (!ar) ar = Array.prototype.slice.call(from, 0, i); | ||
ar[i] = from[i]; | ||
} | ||
} | ||
return to.concat(ar || Array.prototype.slice.call(from)); | ||
}; | ||
import React from 'react'; | ||
@@ -16,18 +40,7 @@ import PropTypes from 'prop-types'; | ||
var className = 'react-calendar__century-view__decades__decade'; | ||
export default function Decade(_ref) { | ||
var classes = _ref.classes, | ||
_ref$formatYear = _ref.formatYear, | ||
formatYear = _ref$formatYear === void 0 ? defaultFormatYear : _ref$formatYear, | ||
otherProps = _objectWithoutProperties(_ref, _excluded); | ||
var date = otherProps.date, | ||
locale = otherProps.locale; | ||
return /*#__PURE__*/React.createElement(Tile, _extends({}, otherProps, { | ||
classes: [].concat(classes, className), | ||
maxDateTransform: getDecadeEnd, | ||
minDateTransform: getDecadeStart, | ||
view: "century" | ||
}), getDecadeLabel(locale, formatYear, date)); | ||
export default function Decade(_a) { | ||
var _b = _a.classes, classes = _b === void 0 ? [] : _b, _c = _a.formatYear, formatYear = _c === void 0 ? defaultFormatYear : _c, otherProps = __rest(_a, ["classes", "formatYear"]); | ||
var date = otherProps.date, locale = otherProps.locale; | ||
return (React.createElement(Tile, __assign({}, otherProps, { classes: __spreadArray(__spreadArray([], classes, true), [className], false), maxDateTransform: getDecadeEnd, minDateTransform: getDecadeStart, view: "century" }), getDecadeLabel(locale, formatYear, date))); | ||
} | ||
Decade.propTypes = _objectSpread(_objectSpread({}, tileProps), {}, { | ||
formatYear: PropTypes.func | ||
}); | ||
Decade.propTypes = __assign(__assign({}, tileProps), { formatYear: PropTypes.func }); |
@@ -1,5 +0,12 @@ | ||
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } | ||
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(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; } | ||
function _extends() { _extends = Object.assign ? Object.assign.bind() : 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 __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
import React from 'react'; | ||
@@ -12,15 +19,7 @@ import { getDecadeStart } from '@wojtekmaj/date-utils'; | ||
export default function Decades(props) { | ||
var activeStartDate = props.activeStartDate; | ||
var start = getBeginOfCenturyYear(activeStartDate); | ||
var end = start + 99; | ||
return /*#__PURE__*/React.createElement(TileGroup, _extends({}, props, { | ||
className: "react-calendar__century-view__decades", | ||
dateTransform: getDecadeStart, | ||
dateType: "decade", | ||
end: end, | ||
start: start, | ||
step: 10, | ||
tile: Decade | ||
})); | ||
var activeStartDate = props.activeStartDate; | ||
var start = getBeginOfCenturyYear(activeStartDate); | ||
var end = start + 99; | ||
return (React.createElement(TileGroup, __assign({}, props, { className: "react-calendar__century-view__decades", dateTransform: getDecadeStart, dateType: "decade", end: end, start: start, step: 10, tile: Decade }))); | ||
} | ||
Decades.propTypes = _objectSpread({}, tileGroupProps); | ||
Decades.propTypes = __assign({}, tileGroupProps); |
@@ -0,10 +1,19 @@ | ||
var __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
import React from 'react'; | ||
import Years from './DecadeView/Years'; | ||
export default function DecadeView(props) { | ||
function renderYears() { | ||
return /*#__PURE__*/React.createElement(Years, props); | ||
} | ||
return /*#__PURE__*/React.createElement("div", { | ||
className: "react-calendar__decade-view" | ||
}, renderYears()); | ||
} | ||
function renderYears() { | ||
return React.createElement(Years, __assign({}, props)); | ||
} | ||
return React.createElement("div", { className: "react-calendar__decade-view" }, renderYears()); | ||
} |
@@ -1,8 +0,32 @@ | ||
var _excluded = ["classes", "formatYear"]; | ||
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } | ||
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(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; } | ||
function _extends() { _extends = Object.assign ? Object.assign.bind() : 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 _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } | ||
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 __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
var __rest = (this && this.__rest) || function (s, e) { | ||
var t = {}; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) | ||
t[p] = s[p]; | ||
if (s != null && typeof Object.getOwnPropertySymbols === "function") | ||
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { | ||
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) | ||
t[p[i]] = s[p[i]]; | ||
} | ||
return t; | ||
}; | ||
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) { | ||
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) { | ||
if (ar || !(i in from)) { | ||
if (!ar) ar = Array.prototype.slice.call(from, 0, i); | ||
ar[i] = from[i]; | ||
} | ||
} | ||
return to.concat(ar || Array.prototype.slice.call(from)); | ||
}; | ||
import React from 'react'; | ||
@@ -15,18 +39,7 @@ import PropTypes from 'prop-types'; | ||
var className = 'react-calendar__decade-view__years__year'; | ||
export default function Year(_ref) { | ||
var classes = _ref.classes, | ||
_ref$formatYear = _ref.formatYear, | ||
formatYear = _ref$formatYear === void 0 ? defaultFormatYear : _ref$formatYear, | ||
otherProps = _objectWithoutProperties(_ref, _excluded); | ||
var date = otherProps.date, | ||
locale = otherProps.locale; | ||
return /*#__PURE__*/React.createElement(Tile, _extends({}, otherProps, { | ||
classes: [].concat(classes, className), | ||
maxDateTransform: getYearEnd, | ||
minDateTransform: getYearStart, | ||
view: "decade" | ||
}), formatYear(locale, date)); | ||
export default function Year(_a) { | ||
var _b = _a.classes, classes = _b === void 0 ? [] : _b, _c = _a.formatYear, formatYear = _c === void 0 ? defaultFormatYear : _c, otherProps = __rest(_a, ["classes", "formatYear"]); | ||
var date = otherProps.date, locale = otherProps.locale; | ||
return (React.createElement(Tile, __assign({}, otherProps, { classes: __spreadArray(__spreadArray([], classes, true), [className], false), maxDateTransform: getYearEnd, minDateTransform: getYearStart, view: "decade" }), formatYear(locale, date))); | ||
} | ||
Year.propTypes = _objectSpread(_objectSpread({}, tileProps), {}, { | ||
formatYear: PropTypes.func | ||
}); | ||
Year.propTypes = __assign(__assign({}, tileProps), { formatYear: PropTypes.func }); |
@@ -1,5 +0,12 @@ | ||
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } | ||
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(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; } | ||
function _extends() { _extends = Object.assign ? Object.assign.bind() : 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 __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
import React from 'react'; | ||
@@ -11,19 +18,12 @@ import TileGroup from '../TileGroup'; | ||
export default function Years(props) { | ||
var activeStartDate = props.activeStartDate; | ||
var start = getBeginOfDecadeYear(activeStartDate); | ||
var end = start + 9; | ||
return /*#__PURE__*/React.createElement(TileGroup, _extends({}, props, { | ||
className: "react-calendar__decade-view__years", | ||
dateTransform: function dateTransform(year) { | ||
var date = new Date(); | ||
date.setFullYear(year, 0, 1); | ||
date.setHours(0, 0, 0, 0); | ||
return date; | ||
}, | ||
dateType: "year", | ||
end: end, | ||
start: start, | ||
tile: Year | ||
})); | ||
var activeStartDate = props.activeStartDate; | ||
var start = getBeginOfDecadeYear(activeStartDate); | ||
var end = start + 9; | ||
return (React.createElement(TileGroup, __assign({}, props, { className: "react-calendar__decade-view__years", dateTransform: function (year) { | ||
var date = new Date(); | ||
date.setFullYear(year, 0, 1); | ||
date.setHours(0, 0, 0, 0); | ||
return date; | ||
}, dateType: "year", end: end, start: start, tile: Year }))); | ||
} | ||
Years.propTypes = _objectSpread({}, tileGroupProps); | ||
Years.propTypes = __assign({}, tileGroupProps); |
@@ -1,49 +0,48 @@ | ||
var _excluded = ["children", "className", "direction", "count", "offset", "style", "wrap"]; | ||
function _extends() { _extends = Object.assign ? Object.assign.bind() : 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 ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } | ||
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(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; } | ||
function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } | ||
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 __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
var __rest = (this && this.__rest) || function (s, e) { | ||
var t = {}; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) | ||
t[p] = s[p]; | ||
if (s != null && typeof Object.getOwnPropertySymbols === "function") | ||
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { | ||
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) | ||
t[p[i]] = s[p[i]]; | ||
} | ||
return t; | ||
}; | ||
import React from 'react'; | ||
import PropTypes from 'prop-types'; | ||
function toPercent(num) { | ||
return "".concat(num, "%"); | ||
return "".concat(num, "%"); | ||
} | ||
export default function Flex(_ref) { | ||
var children = _ref.children, | ||
className = _ref.className, | ||
direction = _ref.direction, | ||
count = _ref.count, | ||
offset = _ref.offset, | ||
style = _ref.style, | ||
wrap = _ref.wrap, | ||
otherProps = _objectWithoutProperties(_ref, _excluded); | ||
return /*#__PURE__*/React.createElement("div", _extends({ | ||
className: className, | ||
style: _objectSpread({ | ||
display: 'flex', | ||
flexDirection: direction, | ||
flexWrap: wrap ? 'wrap' : 'no-wrap' | ||
}, style) | ||
}, otherProps), React.Children.map(children, function (child, index) { | ||
return /*#__PURE__*/React.cloneElement(child, _objectSpread(_objectSpread({}, child.props), {}, { | ||
style: { | ||
flexBasis: toPercent(100 / count), | ||
flexShrink: 0, | ||
flexGrow: 0, | ||
overflow: 'hidden', | ||
marginLeft: offset && index === 0 ? toPercent(100 * offset / count) : null | ||
} | ||
})); | ||
})); | ||
export default function Flex(_a) { | ||
var children = _a.children, className = _a.className, count = _a.count, direction = _a.direction, offset = _a.offset, style = _a.style, wrap = _a.wrap, otherProps = __rest(_a, ["children", "className", "count", "direction", "offset", "style", "wrap"]); | ||
return (React.createElement("div", __assign({ className: className, style: __assign({ display: 'flex', flexDirection: direction, flexWrap: wrap ? 'wrap' : 'nowrap' }, style) }, otherProps), React.Children.map(children, function (child, index) { | ||
return React.cloneElement(child, __assign(__assign({}, child.props), { style: { | ||
flexBasis: toPercent(100 / count), | ||
flexShrink: 0, | ||
flexGrow: 0, | ||
overflow: 'hidden', | ||
marginLeft: offset && index === 0 ? toPercent((100 * offset) / count) : null, | ||
} })); | ||
}))); | ||
} | ||
Flex.propTypes = { | ||
children: PropTypes.node, | ||
className: PropTypes.string, | ||
count: PropTypes.number.isRequired, | ||
direction: PropTypes.string, | ||
offset: PropTypes.number, | ||
style: PropTypes.objectOf(PropTypes.oneOfType([PropTypes.string, PropTypes.number])), | ||
wrap: PropTypes.bool | ||
}; | ||
children: PropTypes.node, | ||
className: PropTypes.string, | ||
count: PropTypes.number.isRequired, | ||
direction: PropTypes.string, | ||
offset: PropTypes.number, | ||
style: PropTypes.objectOf(PropTypes.oneOfType([PropTypes.string, PropTypes.number])), | ||
wrap: PropTypes.bool, | ||
}; |
@@ -7,3 +7,3 @@ import Calendar from './Calendar'; | ||
import MonthView from './MonthView'; | ||
export { Calendar, Navigation, CenturyView, DecadeView, YearView, MonthView }; | ||
export default Calendar; | ||
export { Calendar, Navigation, CenturyView, DecadeView, YearView, MonthView }; |
@@ -1,5 +0,23 @@ | ||
var _excluded = ["calendarType", "formatShortWeekday", "formatWeekday", "onClickWeekNumber", "showWeekNumbers"]; | ||
function _extends() { _extends = Object.assign ? Object.assign.bind() : 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 _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } | ||
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 __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
var __rest = (this && this.__rest) || function (s, e) { | ||
var t = {}; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) | ||
t[p] = s[p]; | ||
if (s != null && typeof Object.getOwnPropertySymbols === "function") | ||
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { | ||
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) | ||
t[p[i]] = s[p[i]]; | ||
} | ||
return t; | ||
}; | ||
import React from 'react'; | ||
@@ -12,71 +30,41 @@ import PropTypes from 'prop-types'; | ||
import { CALENDAR_TYPES, CALENDAR_TYPE_LOCALES } from './shared/const'; | ||
import { isCalendarType } from './shared/propTypes'; | ||
import { isCalendarType, tileGroupProps } from './shared/propTypes'; | ||
function getCalendarTypeFromLocale(locale) { | ||
return Object.keys(CALENDAR_TYPE_LOCALES).find(function (calendarType) { | ||
return CALENDAR_TYPE_LOCALES[calendarType].includes(locale); | ||
}) || CALENDAR_TYPES.ISO_8601; | ||
for (var _i = 0, _a = Object.entries(CALENDAR_TYPE_LOCALES); _i < _a.length; _i++) { | ||
var _b = _a[_i], calendarType = _b[0], locales = _b[1]; | ||
if (locales.includes(locale)) { | ||
return calendarType; | ||
} | ||
} | ||
return CALENDAR_TYPES.ISO_8601; | ||
} | ||
export default function MonthView(props) { | ||
var activeStartDate = props.activeStartDate, | ||
locale = props.locale, | ||
onMouseLeave = props.onMouseLeave, | ||
showFixedNumberOfWeeks = props.showFixedNumberOfWeeks; | ||
var _props$calendarType = props.calendarType, | ||
calendarType = _props$calendarType === void 0 ? getCalendarTypeFromLocale(locale) : _props$calendarType, | ||
formatShortWeekday = props.formatShortWeekday, | ||
formatWeekday = props.formatWeekday, | ||
onClickWeekNumber = props.onClickWeekNumber, | ||
showWeekNumbers = props.showWeekNumbers, | ||
childProps = _objectWithoutProperties(props, _excluded); | ||
function renderWeekdays() { | ||
return /*#__PURE__*/React.createElement(Weekdays, { | ||
calendarType: calendarType, | ||
formatShortWeekday: formatShortWeekday, | ||
formatWeekday: formatWeekday, | ||
locale: locale, | ||
onMouseLeave: onMouseLeave | ||
}); | ||
} | ||
function renderWeekNumbers() { | ||
if (!showWeekNumbers) { | ||
return null; | ||
var activeStartDate = props.activeStartDate, locale = props.locale, onMouseLeave = props.onMouseLeave, showFixedNumberOfWeeks = props.showFixedNumberOfWeeks; | ||
var _a = props.calendarType, calendarType = _a === void 0 ? getCalendarTypeFromLocale(locale) : _a, formatShortWeekday = props.formatShortWeekday, formatWeekday = props.formatWeekday, onClickWeekNumber = props.onClickWeekNumber, showWeekNumbers = props.showWeekNumbers, childProps = __rest(props, ["calendarType", "formatShortWeekday", "formatWeekday", "onClickWeekNumber", "showWeekNumbers"]); | ||
function renderWeekdays() { | ||
return (React.createElement(Weekdays, { calendarType: calendarType, formatShortWeekday: formatShortWeekday, formatWeekday: formatWeekday, locale: locale, onMouseLeave: onMouseLeave })); | ||
} | ||
return /*#__PURE__*/React.createElement(WeekNumbers, { | ||
activeStartDate: activeStartDate, | ||
calendarType: calendarType, | ||
onClickWeekNumber: onClickWeekNumber, | ||
onMouseLeave: onMouseLeave, | ||
showFixedNumberOfWeeks: showFixedNumberOfWeeks | ||
}); | ||
} | ||
function renderDays() { | ||
return /*#__PURE__*/React.createElement(Days, _extends({ | ||
calendarType: calendarType | ||
}, childProps)); | ||
} | ||
var className = 'react-calendar__month-view'; | ||
return /*#__PURE__*/React.createElement("div", { | ||
className: clsx(className, showWeekNumbers ? "".concat(className, "--weekNumbers") : '') | ||
}, /*#__PURE__*/React.createElement("div", { | ||
style: { | ||
display: 'flex', | ||
alignItems: 'flex-end' | ||
function renderWeekNumbers() { | ||
if (!showWeekNumbers) { | ||
return null; | ||
} | ||
return (React.createElement(WeekNumbers, { activeStartDate: activeStartDate, calendarType: calendarType, onClickWeekNumber: onClickWeekNumber, onMouseLeave: onMouseLeave, showFixedNumberOfWeeks: showFixedNumberOfWeeks })); | ||
} | ||
}, renderWeekNumbers(), /*#__PURE__*/React.createElement("div", { | ||
style: { | ||
flexGrow: 1, | ||
width: '100%' | ||
function renderDays() { | ||
return React.createElement(Days, __assign({ calendarType: calendarType }, childProps)); | ||
} | ||
}, renderWeekdays(), renderDays()))); | ||
var className = 'react-calendar__month-view'; | ||
return (React.createElement("div", { className: clsx(className, showWeekNumbers ? "".concat(className, "--weekNumbers") : '') }, | ||
React.createElement("div", { style: { | ||
display: 'flex', | ||
alignItems: 'flex-end', | ||
} }, | ||
renderWeekNumbers(), | ||
React.createElement("div", { style: { | ||
flexGrow: 1, | ||
width: '100%', | ||
} }, | ||
renderWeekdays(), | ||
renderDays())))); | ||
} | ||
MonthView.propTypes = { | ||
activeStartDate: PropTypes.instanceOf(Date).isRequired, | ||
calendarType: isCalendarType, | ||
formatShortWeekday: PropTypes.func, | ||
formatWeekday: PropTypes.func, | ||
locale: PropTypes.string, | ||
onClickWeekNumber: PropTypes.func, | ||
onMouseLeave: PropTypes.func, | ||
showFixedNumberOfWeeks: PropTypes.bool, | ||
showWeekNumbers: PropTypes.bool | ||
}; | ||
MonthView.propTypes = __assign(__assign({}, tileGroupProps), { calendarType: isCalendarType, formatDay: PropTypes.func, formatLongDate: PropTypes.func, formatShortWeekday: PropTypes.func, formatWeekday: PropTypes.func, onClickWeekNumber: PropTypes.func, onMouseLeave: PropTypes.func, showFixedNumberOfWeeks: PropTypes.bool, showNeighboringMonth: PropTypes.bool, showWeekNumbers: PropTypes.bool }); |
@@ -1,8 +0,23 @@ | ||
var _excluded = ["formatDay", "formatLongDate", "calendarType", "classes", "currentMonthIndex"]; | ||
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } | ||
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(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; } | ||
function _extends() { _extends = Object.assign ? Object.assign.bind() : 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 _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } | ||
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 __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
var __rest = (this && this.__rest) || function (s, e) { | ||
var t = {}; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) | ||
t[p] = s[p]; | ||
if (s != null && typeof Object.getOwnPropertySymbols === "function") | ||
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { | ||
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) | ||
t[p[i]] = s[p[i]]; | ||
} | ||
return t; | ||
}; | ||
import React from 'react'; | ||
@@ -13,28 +28,23 @@ import PropTypes from 'prop-types'; | ||
import { isWeekend } from '../shared/dates'; | ||
import { formatDay as defaultFormatDay, formatLongDate as defaultFormatLongDate } from '../shared/dateFormatter'; | ||
import { formatDay as defaultFormatDay, formatLongDate as defaultFormatLongDate, } from '../shared/dateFormatter'; | ||
import { tileProps } from '../shared/propTypes'; | ||
var className = 'react-calendar__month-view__days__day'; | ||
export default function Day(_ref) { | ||
var _ref$formatDay = _ref.formatDay, | ||
formatDay = _ref$formatDay === void 0 ? defaultFormatDay : _ref$formatDay, | ||
_ref$formatLongDate = _ref.formatLongDate, | ||
formatLongDate = _ref$formatLongDate === void 0 ? defaultFormatLongDate : _ref$formatLongDate, | ||
calendarType = _ref.calendarType, | ||
classes = _ref.classes, | ||
currentMonthIndex = _ref.currentMonthIndex, | ||
otherProps = _objectWithoutProperties(_ref, _excluded); | ||
var date = otherProps.date, | ||
locale = otherProps.locale; | ||
return /*#__PURE__*/React.createElement(Tile, _extends({}, otherProps, { | ||
classes: [].concat(classes, className, isWeekend(date, calendarType) ? "".concat(className, "--weekend") : null, date.getMonth() !== currentMonthIndex ? "".concat(className, "--neighboringMonth") : null), | ||
formatAbbr: formatLongDate, | ||
maxDateTransform: getDayEnd, | ||
minDateTransform: getDayStart, | ||
view: "month" | ||
}), formatDay(locale, date)); | ||
export default function Day(_a) { | ||
var calendarType = _a.calendarType, _b = _a.classes, classes = _b === void 0 ? [] : _b, currentMonthIndex = _a.currentMonthIndex, _c = _a.formatDay, formatDay = _c === void 0 ? defaultFormatDay : _c, _d = _a.formatLongDate, formatLongDate = _d === void 0 ? defaultFormatLongDate : _d, otherProps = __rest(_a, ["calendarType", "classes", "currentMonthIndex", "formatDay", "formatLongDate"]); | ||
var date = otherProps.date, locale = otherProps.locale; | ||
var classesProps = []; | ||
if (classes) { | ||
classesProps.push.apply(classesProps, classes); | ||
} | ||
if (className) { | ||
classesProps.push(className); | ||
} | ||
if (isWeekend(date, calendarType)) { | ||
classesProps.push("".concat(className, "--weekend")); | ||
} | ||
if (date.getMonth() !== currentMonthIndex) { | ||
classesProps.push("".concat(className, "--neighboringMonth")); | ||
} | ||
return (React.createElement(Tile, __assign({}, otherProps, { classes: classesProps, formatAbbr: formatLongDate, maxDateTransform: getDayEnd, minDateTransform: getDayStart, view: "month" }), formatDay(locale, date))); | ||
} | ||
Day.propTypes = _objectSpread(_objectSpread({}, tileProps), {}, { | ||
currentMonthIndex: PropTypes.number.isRequired, | ||
formatDay: PropTypes.func, | ||
formatLongDate: PropTypes.func | ||
}); | ||
Day.propTypes = __assign(__assign({}, tileProps), { currentMonthIndex: PropTypes.number.isRequired, formatDay: PropTypes.func, formatLongDate: PropTypes.func }); |
@@ -1,8 +0,23 @@ | ||
var _excluded = ["showFixedNumberOfWeeks", "showNeighboringMonth"]; | ||
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } | ||
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(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; } | ||
function _extends() { _extends = Object.assign ? Object.assign.bind() : 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 _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } | ||
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 __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
var __rest = (this && this.__rest) || function (s, e) { | ||
var t = {}; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) | ||
t[p] = s[p]; | ||
if (s != null && typeof Object.getOwnPropertySymbols === "function") | ||
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { | ||
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) | ||
t[p[i]] = s[p[i]]; | ||
} | ||
return t; | ||
}; | ||
import React from 'react'; | ||
@@ -16,61 +31,42 @@ import PropTypes from 'prop-types'; | ||
export default function Days(props) { | ||
var activeStartDate = props.activeStartDate, | ||
calendarType = props.calendarType; | ||
var showFixedNumberOfWeeks = props.showFixedNumberOfWeeks, | ||
showNeighboringMonth = props.showNeighboringMonth, | ||
otherProps = _objectWithoutProperties(props, _excluded); | ||
var year = getYear(activeStartDate); | ||
var monthIndex = getMonth(activeStartDate); | ||
var hasFixedNumberOfWeeks = showFixedNumberOfWeeks || showNeighboringMonth; | ||
var dayOfWeek = getDayOfWeek(activeStartDate, calendarType); | ||
var offset = hasFixedNumberOfWeeks ? 0 : dayOfWeek; | ||
/** | ||
* Defines on which day of the month the grid shall start. If we simply show current | ||
* month, we obviously start on day one, but if showNeighboringMonth is set to | ||
* true, we need to find the beginning of the week the first day of the month is in. | ||
*/ | ||
var start = (hasFixedNumberOfWeeks ? -dayOfWeek : 0) + 1; | ||
/** | ||
* Defines on which day of the month the grid shall end. If we simply show current | ||
* month, we need to stop on the last day of the month, but if showNeighboringMonth | ||
* is set to true, we need to find the end of the week the last day of the month is in. | ||
*/ | ||
var end = function () { | ||
if (showFixedNumberOfWeeks) { | ||
// Always show 6 weeks | ||
return start + 6 * 7 - 1; | ||
} | ||
var daysInMonth = getDaysInMonth(activeStartDate); | ||
if (showNeighboringMonth) { | ||
var activeEndDate = new Date(); | ||
activeEndDate.setFullYear(year, monthIndex, daysInMonth); | ||
activeEndDate.setHours(0, 0, 0, 0); | ||
var daysUntilEndOfTheWeek = 7 - getDayOfWeek(activeEndDate, calendarType) - 1; | ||
return daysInMonth + daysUntilEndOfTheWeek; | ||
} | ||
return daysInMonth; | ||
}(); | ||
return /*#__PURE__*/React.createElement(TileGroup, _extends({}, otherProps, { | ||
className: "react-calendar__month-view__days", | ||
count: 7, | ||
currentMonthIndex: monthIndex, | ||
dateTransform: function dateTransform(day) { | ||
var date = new Date(); | ||
date.setFullYear(year, monthIndex, day); | ||
date.setHours(0, 0, 0, 0); | ||
return date; | ||
}, | ||
dateType: "day", | ||
end: end, | ||
offset: offset, | ||
start: start, | ||
tile: Day | ||
})); | ||
var activeStartDate = props.activeStartDate, calendarType = props.calendarType; | ||
var showFixedNumberOfWeeks = props.showFixedNumberOfWeeks, showNeighboringMonth = props.showNeighboringMonth, otherProps = __rest(props, ["showFixedNumberOfWeeks", "showNeighboringMonth"]); | ||
var year = getYear(activeStartDate); | ||
var monthIndex = getMonth(activeStartDate); | ||
var hasFixedNumberOfWeeks = showFixedNumberOfWeeks || showNeighboringMonth; | ||
var dayOfWeek = getDayOfWeek(activeStartDate, calendarType); | ||
var offset = hasFixedNumberOfWeeks ? 0 : dayOfWeek; | ||
/** | ||
* Defines on which day of the month the grid shall start. If we simply show current | ||
* month, we obviously start on day one, but if showNeighboringMonth is set to | ||
* true, we need to find the beginning of the week the first day of the month is in. | ||
*/ | ||
var start = (hasFixedNumberOfWeeks ? -dayOfWeek : 0) + 1; | ||
/** | ||
* Defines on which day of the month the grid shall end. If we simply show current | ||
* month, we need to stop on the last day of the month, but if showNeighboringMonth | ||
* is set to true, we need to find the end of the week the last day of the month is in. | ||
*/ | ||
var end = (function () { | ||
if (showFixedNumberOfWeeks) { | ||
// Always show 6 weeks | ||
return start + 6 * 7 - 1; | ||
} | ||
var daysInMonth = getDaysInMonth(activeStartDate); | ||
if (showNeighboringMonth) { | ||
var activeEndDate = new Date(); | ||
activeEndDate.setFullYear(year, monthIndex, daysInMonth); | ||
activeEndDate.setHours(0, 0, 0, 0); | ||
var daysUntilEndOfTheWeek = 7 - getDayOfWeek(activeEndDate, calendarType) - 1; | ||
return daysInMonth + daysUntilEndOfTheWeek; | ||
} | ||
return daysInMonth; | ||
})(); | ||
return (React.createElement(TileGroup, __assign({}, otherProps, { className: "react-calendar__month-view__days", count: 7, currentMonthIndex: monthIndex, dateTransform: function (day) { | ||
var date = new Date(); | ||
date.setFullYear(year, monthIndex, day); | ||
date.setHours(0, 0, 0, 0); | ||
return date; | ||
}, dateType: "day", end: end, offset: offset, start: start, tile: Day }))); | ||
} | ||
Days.propTypes = _objectSpread({ | ||
calendarType: isCalendarType.isRequired, | ||
showFixedNumberOfWeeks: PropTypes.bool, | ||
showNeighboringMonth: PropTypes.bool | ||
}, tileGroupProps); | ||
Days.propTypes = __assign({ calendarType: isCalendarType, showFixedNumberOfWeeks: PropTypes.bool, showNeighboringMonth: PropTypes.bool }, tileGroupProps); |
@@ -6,4 +6,4 @@ import React from 'react'; | ||
import Flex from '../Flex'; | ||
import { getDayOfWeek, isWeekend } from '../shared/dates'; | ||
import { formatShortWeekday as defaultFormatShortWeekday, formatWeekday as defaultFormatWeekday } from '../shared/dateFormatter'; | ||
import { getDayOfWeek, isCurrentDayOfWeek, isWeekend } from '../shared/dates'; | ||
import { formatShortWeekday as defaultFormatShortWeekday, formatWeekday as defaultFormatWeekday, } from '../shared/dateFormatter'; | ||
import { isCalendarType } from '../shared/propTypes'; | ||
@@ -13,38 +13,22 @@ var className = 'react-calendar__month-view__weekdays'; | ||
export default function Weekdays(props) { | ||
var calendarType = props.calendarType, | ||
_props$formatShortWee = props.formatShortWeekday, | ||
formatShortWeekday = _props$formatShortWee === void 0 ? defaultFormatShortWeekday : _props$formatShortWee, | ||
_props$formatWeekday = props.formatWeekday, | ||
formatWeekday = _props$formatWeekday === void 0 ? defaultFormatWeekday : _props$formatWeekday, | ||
locale = props.locale, | ||
onMouseLeave = props.onMouseLeave; | ||
var anyDate = new Date(); | ||
var beginOfMonth = getMonthStart(anyDate); | ||
var year = getYear(beginOfMonth); | ||
var monthIndex = getMonth(beginOfMonth); | ||
var weekdays = []; | ||
for (var weekday = 1; weekday <= 7; weekday += 1) { | ||
var weekdayDate = new Date(year, monthIndex, weekday - getDayOfWeek(beginOfMonth, calendarType)); | ||
var abbr = formatWeekday(locale, weekdayDate); | ||
weekdays.push( /*#__PURE__*/React.createElement("div", { | ||
key: weekday, | ||
className: clsx(weekdayClassName, isWeekend(weekdayDate, calendarType) && "".concat(weekdayClassName, "--weekend")) | ||
}, /*#__PURE__*/React.createElement("abbr", { | ||
"aria-label": abbr, | ||
title: abbr | ||
}, formatShortWeekday(locale, weekdayDate).replace('.', '')))); | ||
} | ||
return /*#__PURE__*/React.createElement(Flex, { | ||
className: className, | ||
count: 7, | ||
onFocus: onMouseLeave, | ||
onMouseOver: onMouseLeave | ||
}, weekdays); | ||
var calendarType = props.calendarType, _a = props.formatShortWeekday, formatShortWeekday = _a === void 0 ? defaultFormatShortWeekday : _a, _b = props.formatWeekday, formatWeekday = _b === void 0 ? defaultFormatWeekday : _b, locale = props.locale, onMouseLeave = props.onMouseLeave; | ||
var anyDate = new Date(); | ||
var beginOfMonth = getMonthStart(anyDate); | ||
var year = getYear(beginOfMonth); | ||
var monthIndex = getMonth(beginOfMonth); | ||
var weekdays = []; | ||
for (var weekday = 1; weekday <= 7; weekday += 1) { | ||
var weekdayDate = new Date(year, monthIndex, weekday - getDayOfWeek(beginOfMonth, calendarType)); | ||
var abbr = formatWeekday(locale, weekdayDate); | ||
weekdays.push(React.createElement("div", { key: weekday, className: clsx(weekdayClassName, isCurrentDayOfWeek(weekdayDate) && "".concat(weekdayClassName, "--current"), isWeekend(weekdayDate, calendarType) && "".concat(weekdayClassName, "--weekend")) }, | ||
React.createElement("abbr", { "aria-label": abbr, title: abbr }, formatShortWeekday(locale, weekdayDate).replace('.', '')))); | ||
} | ||
return (React.createElement(Flex, { className: className, count: 7, onFocus: onMouseLeave, onMouseOver: onMouseLeave }, weekdays)); | ||
} | ||
Weekdays.propTypes = { | ||
calendarType: isCalendarType.isRequired, | ||
formatShortWeekday: PropTypes.func, | ||
formatWeekday: PropTypes.func, | ||
locale: PropTypes.string, | ||
onMouseLeave: PropTypes.func | ||
}; | ||
calendarType: isCalendarType, | ||
formatShortWeekday: PropTypes.func, | ||
formatWeekday: PropTypes.func, | ||
locale: PropTypes.string, | ||
onMouseLeave: PropTypes.func, | ||
}; |
@@ -1,31 +0,42 @@ | ||
var _excluded = ["date", "onClickWeekNumber", "weekNumber"]; | ||
function _extends() { _extends = Object.assign ? Object.assign.bind() : 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 ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } | ||
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(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; } | ||
function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } | ||
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 __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
var __rest = (this && this.__rest) || function (s, e) { | ||
var t = {}; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) | ||
t[p] = s[p]; | ||
if (s != null && typeof Object.getOwnPropertySymbols === "function") | ||
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { | ||
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) | ||
t[p[i]] = s[p[i]]; | ||
} | ||
return t; | ||
}; | ||
import React from 'react'; | ||
import PropTypes from 'prop-types'; | ||
var className = 'react-calendar__tile'; | ||
export default function WeekNumber(_ref) { | ||
var date = _ref.date, | ||
onClickWeekNumber = _ref.onClickWeekNumber, | ||
weekNumber = _ref.weekNumber, | ||
otherProps = _objectWithoutProperties(_ref, _excluded); | ||
var props = _objectSpread({ | ||
className: className | ||
}, otherProps); | ||
var children = /*#__PURE__*/React.createElement("span", null, weekNumber); | ||
return onClickWeekNumber ? /*#__PURE__*/React.createElement("button", _extends({}, props, { | ||
onClick: function onClick(event) { | ||
return onClickWeekNumber(weekNumber, date, event); | ||
}, | ||
type: "button" | ||
}), children) : /*#__PURE__*/React.createElement("div", props, children); | ||
export default function WeekNumber(props) { | ||
var onClickWeekNumber = props.onClickWeekNumber, weekNumber = props.weekNumber; | ||
var children = React.createElement("span", null, weekNumber); | ||
if (onClickWeekNumber) { | ||
var date_1 = props.date, onClickWeekNumber_1 = props.onClickWeekNumber, weekNumber_1 = props.weekNumber, otherProps = __rest(props, ["date", "onClickWeekNumber", "weekNumber"]); | ||
return (React.createElement("button", __assign({}, otherProps, { className: className, onClick: function (event) { return onClickWeekNumber_1(weekNumber_1, date_1, event); }, type: "button" }), children)); | ||
} | ||
else { | ||
var date = props.date, onClickWeekNumber_2 = props.onClickWeekNumber, weekNumber_2 = props.weekNumber, otherProps = __rest(props, ["date", "onClickWeekNumber", "weekNumber"]); | ||
return (React.createElement("div", __assign({}, otherProps, { className: className }), children)); | ||
} | ||
} | ||
WeekNumber.propTypes = { | ||
date: PropTypes.instanceOf(Date).isRequired, | ||
onClickWeekNumber: PropTypes.func, | ||
weekNumber: PropTypes.node.isRequired | ||
}; | ||
date: PropTypes.instanceOf(Date).isRequired, | ||
onClickWeekNumber: PropTypes.func, | ||
weekNumber: PropTypes.node.isRequired, | ||
}; |
@@ -9,54 +9,37 @@ import React from 'react'; | ||
export default function WeekNumbers(props) { | ||
var activeStartDate = props.activeStartDate, | ||
calendarType = props.calendarType, | ||
onClickWeekNumber = props.onClickWeekNumber, | ||
onMouseLeave = props.onMouseLeave, | ||
showFixedNumberOfWeeks = props.showFixedNumberOfWeeks; | ||
var numberOfWeeks = function () { | ||
if (showFixedNumberOfWeeks) { | ||
return 6; | ||
} | ||
var numberOfDays = getDaysInMonth(activeStartDate); | ||
var startWeekday = getDayOfWeek(activeStartDate, calendarType); | ||
var days = numberOfDays - (7 - startWeekday); | ||
return 1 + Math.ceil(days / 7); | ||
}(); | ||
var dates = function () { | ||
var year = getYear(activeStartDate); | ||
var monthIndex = getMonth(activeStartDate); | ||
var day = getDate(activeStartDate); | ||
var result = []; | ||
for (var index = 0; index < numberOfWeeks; index += 1) { | ||
result.push(getBeginOfWeek(new Date(year, monthIndex, day + index * 7), calendarType)); | ||
} | ||
return result; | ||
}(); | ||
var weekNumbers = dates.map(function (date) { | ||
return getWeekNumber(date, calendarType); | ||
}); | ||
return /*#__PURE__*/React.createElement(Flex, { | ||
className: "react-calendar__month-view__weekNumbers", | ||
count: numberOfWeeks, | ||
direction: "column", | ||
onFocus: onMouseLeave, | ||
onMouseOver: onMouseLeave, | ||
style: { | ||
flexBasis: 'calc(100% * (1 / 8)', | ||
flexShrink: 0 | ||
} | ||
}, weekNumbers.map(function (weekNumber, weekIndex) { | ||
return /*#__PURE__*/React.createElement(WeekNumber, { | ||
key: weekNumber, | ||
date: dates[weekIndex], | ||
onClickWeekNumber: onClickWeekNumber, | ||
weekNumber: weekNumber | ||
}); | ||
})); | ||
var activeStartDate = props.activeStartDate, calendarType = props.calendarType, onClickWeekNumber = props.onClickWeekNumber, onMouseLeave = props.onMouseLeave, showFixedNumberOfWeeks = props.showFixedNumberOfWeeks; | ||
var numberOfWeeks = (function () { | ||
if (showFixedNumberOfWeeks) { | ||
return 6; | ||
} | ||
var numberOfDays = getDaysInMonth(activeStartDate); | ||
var startWeekday = getDayOfWeek(activeStartDate, calendarType); | ||
var days = numberOfDays - (7 - startWeekday); | ||
return 1 + Math.ceil(days / 7); | ||
})(); | ||
var dates = (function () { | ||
var year = getYear(activeStartDate); | ||
var monthIndex = getMonth(activeStartDate); | ||
var day = getDate(activeStartDate); | ||
var result = []; | ||
for (var index = 0; index < numberOfWeeks; index += 1) { | ||
result.push(getBeginOfWeek(new Date(year, monthIndex, day + index * 7), calendarType)); | ||
} | ||
return result; | ||
})(); | ||
var weekNumbers = dates.map(function (date) { return getWeekNumber(date, calendarType); }); | ||
return (React.createElement(Flex, { className: "react-calendar__month-view__weekNumbers", count: numberOfWeeks, direction: "column", onFocus: onMouseLeave, onMouseOver: onMouseLeave, style: { flexBasis: 'calc(100% * (1 / 8)', flexShrink: 0 } }, weekNumbers.map(function (weekNumber, weekIndex) { | ||
var date = dates[weekIndex]; | ||
if (!date) { | ||
throw new Error('date is not defined'); | ||
} | ||
return (React.createElement(WeekNumber, { key: weekNumber, date: date, onClickWeekNumber: onClickWeekNumber, weekNumber: weekNumber })); | ||
}))); | ||
} | ||
WeekNumbers.propTypes = { | ||
activeStartDate: PropTypes.instanceOf(Date).isRequired, | ||
calendarType: isCalendarType.isRequired, | ||
onClickWeekNumber: PropTypes.func, | ||
onMouseLeave: PropTypes.func, | ||
showFixedNumberOfWeeks: PropTypes.bool | ||
}; | ||
activeStartDate: PropTypes.instanceOf(Date).isRequired, | ||
calendarType: isCalendarType, | ||
onClickWeekNumber: PropTypes.func, | ||
onMouseLeave: PropTypes.func, | ||
showFixedNumberOfWeeks: PropTypes.bool, | ||
}; |
@@ -1,20 +0,54 @@ | ||
var _CALENDAR_TYPE_LOCALE; | ||
function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); } | ||
function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } | ||
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } | ||
function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); } | ||
function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); } | ||
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } | ||
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 _a; | ||
export var CALENDAR_TYPES = { | ||
ARABIC: 'Arabic', | ||
HEBREW: 'Hebrew', | ||
ISO_8601: 'ISO 8601', | ||
US: 'US' | ||
ARABIC: 'Arabic', | ||
HEBREW: 'Hebrew', | ||
ISO_8601: 'ISO 8601', | ||
US: 'US', | ||
}; | ||
export var CALENDAR_TYPE_LOCALES = (_CALENDAR_TYPE_LOCALE = {}, _defineProperty(_CALENDAR_TYPE_LOCALE, CALENDAR_TYPES.US, ['en-CA', 'en-US', 'es-AR', 'es-BO', 'es-CL', 'es-CO', 'es-CR', 'es-DO', 'es-EC', 'es-GT', 'es-HN', 'es-MX', 'es-NI', 'es-PA', 'es-PE', 'es-PR', 'es-SV', 'es-VE', 'pt-BR']), _defineProperty(_CALENDAR_TYPE_LOCALE, CALENDAR_TYPES.ARABIC, [ | ||
// ar-LB, ar-MA intentionally missing | ||
'ar', 'ar-AE', 'ar-BH', 'ar-DZ', 'ar-EG', 'ar-IQ', 'ar-JO', 'ar-KW', 'ar-LY', 'ar-OM', 'ar-QA', 'ar-SA', 'ar-SD', 'ar-SY', 'ar-YE', 'dv', 'dv-MV', 'ps', 'ps-AR']), _defineProperty(_CALENDAR_TYPE_LOCALE, CALENDAR_TYPES.HEBREW, ['he', 'he-IL']), _CALENDAR_TYPE_LOCALE); | ||
export var WEEKDAYS = _toConsumableArray(Array(7)).map(function (el, index) { | ||
return index; | ||
}); | ||
export var CALENDAR_TYPE_LOCALES = (_a = {}, | ||
_a[CALENDAR_TYPES.US] = [ | ||
'en-CA', | ||
'en-US', | ||
'es-AR', | ||
'es-BO', | ||
'es-CL', | ||
'es-CO', | ||
'es-CR', | ||
'es-DO', | ||
'es-EC', | ||
'es-GT', | ||
'es-HN', | ||
'es-MX', | ||
'es-NI', | ||
'es-PA', | ||
'es-PE', | ||
'es-PR', | ||
'es-SV', | ||
'es-VE', | ||
'pt-BR', | ||
], | ||
_a[CALENDAR_TYPES.ARABIC] = [ | ||
// ar-LB, ar-MA intentionally missing | ||
'ar', | ||
'ar-AE', | ||
'ar-BH', | ||
'ar-DZ', | ||
'ar-EG', | ||
'ar-IQ', | ||
'ar-JO', | ||
'ar-KW', | ||
'ar-LY', | ||
'ar-OM', | ||
'ar-QA', | ||
'ar-SA', | ||
'ar-SD', | ||
'ar-SY', | ||
'ar-YE', | ||
'dv', | ||
'dv-MV', | ||
'ps', | ||
'ps-AR', | ||
], | ||
_a[CALENDAR_TYPES.HEBREW] = ['he', 'he-IL'], | ||
_a); | ||
export var WEEKDAYS = [0, 1, 2, 3, 4, 5, 6]; |
import getUserLocale from 'get-user-locale'; | ||
var formatterCache = new Map(); | ||
function getFormatter(options) { | ||
return function (locale, date) { | ||
var localeWithDefault = locale || getUserLocale(); | ||
if (!formatterCache.has(localeWithDefault)) { | ||
formatterCache.set(localeWithDefault, new Map()); | ||
} | ||
var formatterCacheLocale = formatterCache.get(localeWithDefault); | ||
if (!formatterCacheLocale.has(options)) { | ||
formatterCacheLocale.set(options, new Intl.DateTimeFormat(localeWithDefault, options).format); | ||
} | ||
return formatterCacheLocale.get(options)(date); | ||
}; | ||
return function formatter(locale, date) { | ||
var localeWithDefault = locale || getUserLocale(); | ||
if (!formatterCache.has(localeWithDefault)) { | ||
formatterCache.set(localeWithDefault, new Map()); | ||
} | ||
var formatterCacheLocale = formatterCache.get(localeWithDefault); | ||
if (!formatterCacheLocale.has(options)) { | ||
formatterCacheLocale.set(options, new Intl.DateTimeFormat(localeWithDefault || undefined, options).format); | ||
} | ||
return formatterCacheLocale.get(options)(date); | ||
}; | ||
} | ||
/** | ||
@@ -27,39 +26,27 @@ * Changes the hour in a Date to ensure right date formatting even if DST is messed up. | ||
function toSafeHour(date) { | ||
var safeDate = new Date(date); | ||
return new Date(safeDate.setHours(12)); | ||
var safeDate = new Date(date); | ||
return new Date(safeDate.setHours(12)); | ||
} | ||
function getSafeFormatter(options) { | ||
return function (locale, date) { | ||
return getFormatter(options)(locale, toSafeHour(date)); | ||
}; | ||
return function (locale, date) { return getFormatter(options)(locale, toSafeHour(date)); }; | ||
} | ||
var formatDateOptions = { | ||
day: 'numeric', | ||
month: 'numeric', | ||
year: 'numeric' | ||
day: 'numeric', | ||
month: 'numeric', | ||
year: 'numeric', | ||
}; | ||
var formatDayOptions = { | ||
day: 'numeric' | ||
}; | ||
var formatDayOptions = { day: 'numeric' }; | ||
var formatLongDateOptions = { | ||
day: 'numeric', | ||
month: 'long', | ||
year: 'numeric' | ||
day: 'numeric', | ||
month: 'long', | ||
year: 'numeric', | ||
}; | ||
var formatMonthOptions = { | ||
month: 'long' | ||
}; | ||
var formatMonthOptions = { month: 'long' }; | ||
var formatMonthYearOptions = { | ||
month: 'long', | ||
year: 'numeric' | ||
month: 'long', | ||
year: 'numeric', | ||
}; | ||
var formatShortWeekdayOptions = { | ||
weekday: 'short' | ||
}; | ||
var formatWeekdayOptions = { | ||
weekday: 'long' | ||
}; | ||
var formatYearOptions = { | ||
year: 'numeric' | ||
}; | ||
var formatShortWeekdayOptions = { weekday: 'short' }; | ||
var formatWeekdayOptions = { weekday: 'long' }; | ||
var formatYearOptions = { year: 'numeric' }; | ||
export var formatDate = getSafeFormatter(formatDateOptions); | ||
@@ -72,2 +59,2 @@ export var formatDay = getSafeFormatter(formatDayOptions); | ||
export var formatWeekday = getSafeFormatter(formatWeekdayOptions); | ||
export var formatYear = getSafeFormatter(formatYearOptions); | ||
export var formatYear = getSafeFormatter(formatYearOptions); |
@@ -1,2 +0,2 @@ | ||
import { getYear, getMonth as getMonthIndex, getCenturyStart, getPreviousCenturyStart, getNextCenturyStart, getCenturyEnd, getPreviousCenturyEnd, getCenturyRange, getDecadeStart, getPreviousDecadeStart, getNextDecadeStart, getDecadeEnd, getPreviousDecadeEnd, getDecadeRange, getYearStart, getPreviousYearStart, getNextYearStart, getYearEnd, getPreviousYearEnd, getYearRange, getMonthStart, getPreviousMonthStart, getNextMonthStart, getMonthEnd, getPreviousMonthEnd, getMonthRange, getDayStart, getDayEnd, getDayRange } from '@wojtekmaj/date-utils'; | ||
import { getYear, getMonth as getMonthIndex, getCenturyStart, getPreviousCenturyStart, getNextCenturyStart, getCenturyEnd, getPreviousCenturyEnd, getCenturyRange, getDecadeStart, getPreviousDecadeStart, getNextDecadeStart, getDecadeEnd, getPreviousDecadeEnd, getDecadeRange, getYearStart, getPreviousYearStart, getNextYearStart, getYearEnd, getPreviousYearEnd, getYearRange, getMonthStart, getPreviousMonthStart, getNextMonthStart, getMonthEnd, getPreviousMonthEnd, getMonthRange, getDayStart, getDayEnd, getDayRange, } from '@wojtekmaj/date-utils'; | ||
import { CALENDAR_TYPES, WEEKDAYS } from './const'; | ||
@@ -7,31 +7,26 @@ import { formatYear as defaultFormatYear } from './dateFormatter'; | ||
var SATURDAY = WEEKDAYS[6]; | ||
/* Simple getters - getting a property of a given point in time */ | ||
export function getDayOfWeek(date) { | ||
var calendarType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : CALENDAR_TYPES.ISO_8601; | ||
var weekday = date.getDay(); | ||
switch (calendarType) { | ||
case CALENDAR_TYPES.ISO_8601: | ||
// Shifts days of the week so that Monday is 0, Sunday is 6 | ||
return (weekday + 6) % 7; | ||
case CALENDAR_TYPES.ARABIC: | ||
return (weekday + 1) % 7; | ||
case CALENDAR_TYPES.HEBREW: | ||
case CALENDAR_TYPES.US: | ||
return weekday; | ||
default: | ||
throw new Error('Unsupported calendar type.'); | ||
} | ||
export function getDayOfWeek(date, calendarType) { | ||
if (calendarType === void 0) { calendarType = CALENDAR_TYPES.ISO_8601; } | ||
var weekday = date.getDay(); | ||
switch (calendarType) { | ||
case CALENDAR_TYPES.ISO_8601: | ||
// Shifts days of the week so that Monday is 0, Sunday is 6 | ||
return (weekday + 6) % 7; | ||
case CALENDAR_TYPES.ARABIC: | ||
return (weekday + 1) % 7; | ||
case CALENDAR_TYPES.HEBREW: | ||
case CALENDAR_TYPES.US: | ||
return weekday; | ||
default: | ||
throw new Error('Unsupported calendar type.'); | ||
} | ||
} | ||
/** | ||
* Century | ||
*/ | ||
export function getBeginOfCenturyYear(date) { | ||
var beginOfCentury = getCenturyStart(date); | ||
return getYear(beginOfCentury); | ||
var beginOfCentury = getCenturyStart(date); | ||
return getYear(beginOfCentury); | ||
} | ||
/** | ||
@@ -41,10 +36,8 @@ * Decade | ||
export function getBeginOfDecadeYear(date) { | ||
var beginOfDecade = getDecadeStart(date); | ||
return getYear(beginOfDecade); | ||
var beginOfDecade = getDecadeStart(date); | ||
return getYear(beginOfDecade); | ||
} | ||
/** | ||
* Week | ||
*/ | ||
/** | ||
@@ -54,12 +47,11 @@ * Returns the beginning of a given week. | ||
* @param {Date} date Date. | ||
* @param {string} calendarType Calendar type. Can be ISO 8601 or US. | ||
* @param {string} [calendarType="ISO 8601"] Calendar type. | ||
*/ | ||
export function getBeginOfWeek(date) { | ||
var calendarType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : CALENDAR_TYPES.ISO_8601; | ||
var year = getYear(date); | ||
var monthIndex = getMonthIndex(date); | ||
var day = date.getDate() - getDayOfWeek(date, calendarType); | ||
return new Date(year, monthIndex, day); | ||
export function getBeginOfWeek(date, calendarType) { | ||
if (calendarType === void 0) { calendarType = CALENDAR_TYPES.ISO_8601; } | ||
var year = getYear(date); | ||
var monthIndex = getMonthIndex(date); | ||
var day = date.getDate() - getDayOfWeek(date, calendarType); | ||
return new Date(year, monthIndex, day); | ||
} | ||
/** | ||
@@ -71,25 +63,22 @@ * Gets week number according to ISO 8601 or US standard. | ||
* @param {Date} date Date. | ||
* @param {string} calendarType Calendar type. Can be ISO 8601 or US. | ||
* @param {string} [calendarType="ISO 8601"] Calendar type. | ||
*/ | ||
export function getWeekNumber(date) { | ||
var calendarType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : CALENDAR_TYPES.ISO_8601; | ||
var calendarTypeForWeekNumber = calendarType === CALENDAR_TYPES.US ? CALENDAR_TYPES.US : CALENDAR_TYPES.ISO_8601; | ||
var beginOfWeek = getBeginOfWeek(date, calendarType); | ||
var year = getYear(date) + 1; | ||
var dayInWeekOne; | ||
var beginOfFirstWeek; | ||
// Look for the first week one that does not come after a given date | ||
do { | ||
dayInWeekOne = new Date(year, 0, calendarTypeForWeekNumber === CALENDAR_TYPES.ISO_8601 ? 4 : 1); | ||
beginOfFirstWeek = getBeginOfWeek(dayInWeekOne, calendarType); | ||
year -= 1; | ||
} while (date < beginOfFirstWeek); | ||
return Math.round((beginOfWeek - beginOfFirstWeek) / (8.64e7 * 7)) + 1; | ||
export function getWeekNumber(date, calendarType) { | ||
if (calendarType === void 0) { calendarType = CALENDAR_TYPES.ISO_8601; } | ||
var calendarTypeForWeekNumber = calendarType === CALENDAR_TYPES.US ? CALENDAR_TYPES.US : CALENDAR_TYPES.ISO_8601; | ||
var beginOfWeek = getBeginOfWeek(date, calendarType); | ||
var year = getYear(date) + 1; | ||
var dayInWeekOne; | ||
var beginOfFirstWeek; | ||
// Look for the first week one that does not come after a given date | ||
do { | ||
dayInWeekOne = new Date(year, 0, calendarTypeForWeekNumber === CALENDAR_TYPES.ISO_8601 ? 4 : 1); | ||
beginOfFirstWeek = getBeginOfWeek(dayInWeekOne, calendarType); | ||
year -= 1; | ||
} while (date < beginOfFirstWeek); | ||
return Math.round((beginOfWeek.getTime() - beginOfFirstWeek.getTime()) / (8.64e7 * 7)) + 1; | ||
} | ||
/** | ||
* Others | ||
*/ | ||
/** | ||
@@ -102,70 +91,69 @@ * Returns the beginning of a given range. | ||
export function getBegin(rangeType, date) { | ||
switch (rangeType) { | ||
case 'century': | ||
return getCenturyStart(date); | ||
case 'decade': | ||
return getDecadeStart(date); | ||
case 'year': | ||
return getYearStart(date); | ||
case 'month': | ||
return getMonthStart(date); | ||
case 'day': | ||
return getDayStart(date); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
switch (rangeType) { | ||
case 'century': | ||
return getCenturyStart(date); | ||
case 'decade': | ||
return getDecadeStart(date); | ||
case 'year': | ||
return getYearStart(date); | ||
case 'month': | ||
return getMonthStart(date); | ||
case 'day': | ||
return getDayStart(date); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
} | ||
export function getBeginPrevious(rangeType, date) { | ||
switch (rangeType) { | ||
case 'century': | ||
return getPreviousCenturyStart(date); | ||
case 'decade': | ||
return getPreviousDecadeStart(date); | ||
case 'year': | ||
return getPreviousYearStart(date); | ||
case 'month': | ||
return getPreviousMonthStart(date); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
switch (rangeType) { | ||
case 'century': | ||
return getPreviousCenturyStart(date); | ||
case 'decade': | ||
return getPreviousDecadeStart(date); | ||
case 'year': | ||
return getPreviousYearStart(date); | ||
case 'month': | ||
return getPreviousMonthStart(date); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
} | ||
export function getBeginNext(rangeType, date) { | ||
switch (rangeType) { | ||
case 'century': | ||
return getNextCenturyStart(date); | ||
case 'decade': | ||
return getNextDecadeStart(date); | ||
case 'year': | ||
return getNextYearStart(date); | ||
case 'month': | ||
return getNextMonthStart(date); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
switch (rangeType) { | ||
case 'century': | ||
return getNextCenturyStart(date); | ||
case 'decade': | ||
return getNextDecadeStart(date); | ||
case 'year': | ||
return getNextYearStart(date); | ||
case 'month': | ||
return getNextMonthStart(date); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
} | ||
export var getBeginPrevious2 = function getBeginPrevious2(rangeType, date) { | ||
switch (rangeType) { | ||
case 'decade': | ||
return getPreviousDecadeStart(date, -100); | ||
case 'year': | ||
return getPreviousYearStart(date, -10); | ||
case 'month': | ||
return getPreviousMonthStart(date, -12); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
}; | ||
export var getBeginNext2 = function getBeginNext2(rangeType, date) { | ||
switch (rangeType) { | ||
case 'decade': | ||
return getNextDecadeStart(date, 100); | ||
case 'year': | ||
return getNextYearStart(date, 10); | ||
case 'month': | ||
return getNextMonthStart(date, 12); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
}; | ||
export function getBeginPrevious2(rangeType, date) { | ||
switch (rangeType) { | ||
case 'decade': | ||
return getPreviousDecadeStart(date, -100); | ||
case 'year': | ||
return getPreviousYearStart(date, -10); | ||
case 'month': | ||
return getPreviousMonthStart(date, -12); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
} | ||
export function getBeginNext2(rangeType, date) { | ||
switch (rangeType) { | ||
case 'decade': | ||
return getNextDecadeStart(date, 100); | ||
case 'year': | ||
return getNextYearStart(date, 10); | ||
case 'month': | ||
return getNextMonthStart(date, 12); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
} | ||
/** | ||
@@ -178,44 +166,43 @@ * Returns the end of a given range. | ||
export function getEnd(rangeType, date) { | ||
switch (rangeType) { | ||
case 'century': | ||
return getCenturyEnd(date); | ||
case 'decade': | ||
return getDecadeEnd(date); | ||
case 'year': | ||
return getYearEnd(date); | ||
case 'month': | ||
return getMonthEnd(date); | ||
case 'day': | ||
return getDayEnd(date); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
switch (rangeType) { | ||
case 'century': | ||
return getCenturyEnd(date); | ||
case 'decade': | ||
return getDecadeEnd(date); | ||
case 'year': | ||
return getYearEnd(date); | ||
case 'month': | ||
return getMonthEnd(date); | ||
case 'day': | ||
return getDayEnd(date); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
} | ||
export function getEndPrevious(rangeType, date) { | ||
switch (rangeType) { | ||
case 'century': | ||
return getPreviousCenturyEnd(date); | ||
case 'decade': | ||
return getPreviousDecadeEnd(date); | ||
case 'year': | ||
return getPreviousYearEnd(date); | ||
case 'month': | ||
return getPreviousMonthEnd(date); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
switch (rangeType) { | ||
case 'century': | ||
return getPreviousCenturyEnd(date); | ||
case 'decade': | ||
return getPreviousDecadeEnd(date); | ||
case 'year': | ||
return getPreviousYearEnd(date); | ||
case 'month': | ||
return getPreviousMonthEnd(date); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
} | ||
export var getEndPrevious2 = function getEndPrevious2(rangeType, date) { | ||
switch (rangeType) { | ||
case 'decade': | ||
return getPreviousDecadeEnd(date, -100); | ||
case 'year': | ||
return getPreviousYearEnd(date, -10); | ||
case 'month': | ||
return getPreviousMonthEnd(date, -12); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
}; | ||
export function getEndPrevious2(rangeType, date) { | ||
switch (rangeType) { | ||
case 'decade': | ||
return getPreviousDecadeEnd(date, -100); | ||
case 'year': | ||
return getPreviousYearEnd(date, -10); | ||
case 'month': | ||
return getPreviousMonthEnd(date, -12); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
} | ||
/** | ||
@@ -228,18 +215,17 @@ * Returns an array with the beginning and the end of a given range. | ||
export function getRange(rangeType, date) { | ||
switch (rangeType) { | ||
case 'century': | ||
return getCenturyRange(date); | ||
case 'decade': | ||
return getDecadeRange(date); | ||
case 'year': | ||
return getYearRange(date); | ||
case 'month': | ||
return getMonthRange(date); | ||
case 'day': | ||
return getDayRange(date); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
switch (rangeType) { | ||
case 'century': | ||
return getCenturyRange(date); | ||
case 'decade': | ||
return getDecadeRange(date); | ||
case 'year': | ||
return getYearRange(date); | ||
case 'month': | ||
return getMonthRange(date); | ||
case 'day': | ||
return getDayRange(date); | ||
default: | ||
throw new Error("Invalid rangeType: ".concat(rangeType)); | ||
} | ||
} | ||
/** | ||
@@ -253,25 +239,26 @@ * Creates a range out of two values, ensuring they are in order and covering entire period ranges. | ||
export function getValueRange(rangeType, date1, date2) { | ||
var rawNextValue = [date1, date2].sort(function (a, b) { | ||
return a - b; | ||
}); | ||
return [getBegin(rangeType, rawNextValue[0]), getEnd(rangeType, rawNextValue[1])]; | ||
var rawNextValue = [date1, date2].sort(function (a, b) { return a.getTime() - b.getTime(); }); | ||
return [getBegin(rangeType, rawNextValue[0]), getEnd(rangeType, rawNextValue[1])]; | ||
} | ||
function toYearLabel(locale) { | ||
var formatYear = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultFormatYear; | ||
var dates = arguments.length > 2 ? arguments[2] : undefined; | ||
return dates.map(function (date) { | ||
return formatYear(locale, date); | ||
}).join(' – '); | ||
function toYearLabel(locale, formatYear, dates) { | ||
if (formatYear === void 0) { formatYear = defaultFormatYear; } | ||
return dates.map(function (date) { return formatYear(locale, date); }).join(' – '); | ||
} | ||
/** | ||
* @callback FormatYear | ||
* @param {string} locale Locale. | ||
* @param {Date} date Date. | ||
* @returns {string} Formatted year. | ||
*/ | ||
/** | ||
* Returns a string labelling a century of a given date. | ||
* For example, for 2017 it will return 2001-2100. | ||
* | ||
* @param {Date|String|Number} date Date or a year as a string or as a number. | ||
* @param {string} locale Locale. | ||
* @param {FormatYear} formatYear Function to format a year. | ||
* @param {Date|string|number} date Date or a year as a string or as a number. | ||
*/ | ||
export function getCenturyLabel(locale, formatYear, date) { | ||
return toYearLabel(locale, formatYear, getCenturyRange(date)); | ||
return toYearLabel(locale, formatYear, getCenturyRange(date)); | ||
} | ||
/** | ||
@@ -281,26 +268,36 @@ * Returns a string labelling a century of a given date. | ||
* | ||
* @param {Date|String|Number} date Date or a year as a string or as a number. | ||
* @param {string} locale Locale. | ||
* @param {FormatYear} formatYear Function to format a year. | ||
* @param {Date|string|number} date Date or a year as a string or as a number. | ||
*/ | ||
export function getDecadeLabel(locale, formatYear, date) { | ||
return toYearLabel(locale, formatYear, getDecadeRange(date)); | ||
return toYearLabel(locale, formatYear, getDecadeRange(date)); | ||
} | ||
/** | ||
* Returns a boolean determining whether a given date is on Saturday or Sunday. | ||
* Returns a boolean determining whether a given date is the current day of the week. | ||
* | ||
* @param {Date} date Date. | ||
*/ | ||
export function isWeekend(date) { | ||
var calendarType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : CALENDAR_TYPES.ISO_8601; | ||
var weekday = date.getDay(); | ||
switch (calendarType) { | ||
case CALENDAR_TYPES.ARABIC: | ||
case CALENDAR_TYPES.HEBREW: | ||
return weekday === FRIDAY || weekday === SATURDAY; | ||
case CALENDAR_TYPES.ISO_8601: | ||
case CALENDAR_TYPES.US: | ||
return weekday === SATURDAY || weekday === SUNDAY; | ||
default: | ||
throw new Error('Unsupported calendar type.'); | ||
} | ||
} | ||
export function isCurrentDayOfWeek(date) { | ||
return date.getDay() === new Date().getDay(); | ||
} | ||
/** | ||
* Returns a boolean determining whether a given date is a weekend day. | ||
* | ||
* @param {Date} date Date. | ||
* @param {string} [calendarType="ISO 8601"] Calendar type. | ||
*/ | ||
export function isWeekend(date, calendarType) { | ||
if (calendarType === void 0) { calendarType = CALENDAR_TYPES.ISO_8601; } | ||
var weekday = date.getDay(); | ||
switch (calendarType) { | ||
case CALENDAR_TYPES.ARABIC: | ||
case CALENDAR_TYPES.HEBREW: | ||
return weekday === FRIDAY || weekday === SATURDAY; | ||
case CALENDAR_TYPES.ISO_8601: | ||
case CALENDAR_TYPES.US: | ||
return weekday === SATURDAY || weekday === SUNDAY; | ||
default: | ||
throw new Error('Unsupported calendar type.'); | ||
} | ||
} |
@@ -1,2 +0,1 @@ | ||
function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); } | ||
import PropTypes from 'prop-types'; | ||
@@ -7,82 +6,90 @@ import { CALENDAR_TYPES } from './const'; | ||
export var isCalendarType = PropTypes.oneOf(calendarTypes); | ||
export var isClassName = PropTypes.oneOfType([PropTypes.string, PropTypes.arrayOf(PropTypes.string)]); | ||
export var isMinDate = function isMinDate(props, propName, componentName) { | ||
var minDate = props[propName]; | ||
if (!minDate) { | ||
export var isClassName = PropTypes.oneOfType([ | ||
PropTypes.string, | ||
PropTypes.arrayOf(PropTypes.string), | ||
]); | ||
export function isMinDate(props, propName, componentName) { | ||
var _a = props, _b = propName, minDate = _a[_b]; | ||
if (!minDate) { | ||
return null; | ||
} | ||
if (!(minDate instanceof Date)) { | ||
return new Error("Invalid prop `".concat(propName, "` of type `").concat(typeof minDate, "` supplied to `").concat(componentName, "`, expected instance of `Date`.")); | ||
} | ||
var maxDate = props.maxDate; | ||
if (maxDate && minDate > maxDate) { | ||
return new Error("Invalid prop `".concat(propName, "` of type `").concat(typeof minDate, "` supplied to `").concat(componentName, "`, minDate cannot be larger than maxDate.")); | ||
} | ||
return null; | ||
} | ||
if (!(minDate instanceof Date)) { | ||
return new Error("Invalid prop `".concat(propName, "` of type `").concat(_typeof(minDate), "` supplied to `").concat(componentName, "`, expected instance of `Date`.")); | ||
} | ||
var maxDate = props.maxDate; | ||
if (maxDate && minDate > maxDate) { | ||
return new Error("Invalid prop `".concat(propName, "` of type `").concat(_typeof(minDate), "` supplied to `").concat(componentName, "`, minDate cannot be larger than maxDate.")); | ||
} | ||
return null; | ||
}; | ||
export var isMaxDate = function isMaxDate(props, propName, componentName) { | ||
var maxDate = props[propName]; | ||
if (!maxDate) { | ||
} | ||
export function isMaxDate(props, propName, componentName) { | ||
var _a = props, _b = propName, maxDate = _a[_b]; | ||
if (!maxDate) { | ||
return null; | ||
} | ||
if (!(maxDate instanceof Date)) { | ||
return new Error("Invalid prop `".concat(propName, "` of type `").concat(typeof maxDate, "` supplied to `").concat(componentName, "`, expected instance of `Date`.")); | ||
} | ||
var minDate = props.minDate; | ||
if (minDate && maxDate < minDate) { | ||
return new Error("Invalid prop `".concat(propName, "` of type `").concat(typeof maxDate, "` supplied to `").concat(componentName, "`, maxDate cannot be smaller than minDate.")); | ||
} | ||
return null; | ||
} | ||
if (!(maxDate instanceof Date)) { | ||
return new Error("Invalid prop `".concat(propName, "` of type `").concat(_typeof(maxDate), "` supplied to `").concat(componentName, "`, expected instance of `Date`.")); | ||
} | ||
var minDate = props.minDate; | ||
if (minDate && maxDate < minDate) { | ||
return new Error("Invalid prop `".concat(propName, "` of type `").concat(_typeof(maxDate), "` supplied to `").concat(componentName, "`, maxDate cannot be smaller than minDate.")); | ||
} | ||
return null; | ||
}; | ||
export var isRef = PropTypes.oneOfType([PropTypes.func, PropTypes.shape({ | ||
current: PropTypes.any | ||
})]); | ||
export var isValue = PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.arrayOf(PropTypes.instanceOf(Date))]); | ||
} | ||
export var isRef = PropTypes.oneOfType([ | ||
PropTypes.func, | ||
PropTypes.shape({ | ||
current: PropTypes.any, | ||
}), | ||
]); | ||
export var isValue = PropTypes.oneOfType([ | ||
PropTypes.instanceOf(Date), | ||
PropTypes.arrayOf(PropTypes.instanceOf(Date)), | ||
]); | ||
export var isViews = PropTypes.arrayOf(PropTypes.oneOf(allViews)); | ||
export var isView = function isView(props, propName, componentName) { | ||
var view = props[propName]; | ||
var views = props.views; | ||
var allowedViews = views || allViews; | ||
if (view !== undefined && allowedViews.indexOf(view) === -1) { | ||
return new Error("Invalid prop `".concat(propName, "` of value `").concat(view, "` supplied to `").concat(componentName, "`, expected one of [").concat(allowedViews.map(function (a) { | ||
return "\"".concat(a, "\""); | ||
}).join(', '), "].")); | ||
} | ||
// Everything is fine | ||
return null; | ||
}; | ||
export function isView(props, propName, componentName) { | ||
var _a = props, _b = propName, view = _a[_b]; | ||
var views = props.views; | ||
var allowedViews = views || allViews; | ||
if (view !== undefined && (typeof view !== 'string' || allowedViews.indexOf(view) === -1)) { | ||
return new Error("Invalid prop `".concat(propName, "` of value `").concat(view, "` supplied to `").concat(componentName, "`, expected one of [").concat(allowedViews | ||
.map(function (a) { return "\"".concat(a, "\""); }) | ||
.join(', '), "].")); | ||
} | ||
// Everything is fine | ||
return null; | ||
} | ||
isView.isRequired = function (props, propName, componentName) { | ||
var view = props[propName]; | ||
if (!view) { | ||
return new Error("The prop `".concat(propName, "` is marked as required in `").concat(componentName, "`, but its value is `").concat(view, "`.")); | ||
} | ||
return isView(props, propName, componentName); | ||
var _a = props, _b = propName, view = _a[_b]; | ||
if (!view) { | ||
return new Error("The prop `".concat(propName, "` is marked as required in `").concat(componentName, "`, but its value is `").concat(view, "`.")); | ||
} | ||
return isView(props, propName, componentName); | ||
}; | ||
export var tileGroupProps = { | ||
activeStartDate: PropTypes.instanceOf(Date).isRequired, | ||
hover: PropTypes.instanceOf(Date), | ||
locale: PropTypes.string, | ||
maxDate: isMaxDate, | ||
minDate: isMinDate, | ||
onClick: PropTypes.func, | ||
onMouseOver: PropTypes.func, | ||
tileClassName: PropTypes.oneOfType([PropTypes.func, isClassName]), | ||
tileContent: PropTypes.oneOfType([PropTypes.func, PropTypes.node]), | ||
value: isValue, | ||
valueType: PropTypes.string | ||
activeStartDate: PropTypes.instanceOf(Date).isRequired, | ||
hover: PropTypes.instanceOf(Date), | ||
locale: PropTypes.string, | ||
maxDate: isMaxDate, | ||
minDate: isMinDate, | ||
onClick: PropTypes.func, | ||
onMouseOver: PropTypes.func, | ||
tileClassName: PropTypes.oneOfType([PropTypes.func, isClassName]), | ||
tileContent: PropTypes.oneOfType([PropTypes.func, PropTypes.node]), | ||
value: isValue, | ||
valueType: PropTypes.string, | ||
}; | ||
export var tileProps = { | ||
activeStartDate: PropTypes.instanceOf(Date).isRequired, | ||
classes: PropTypes.arrayOf(PropTypes.string).isRequired, | ||
date: PropTypes.instanceOf(Date).isRequired, | ||
locale: PropTypes.string, | ||
maxDate: isMaxDate, | ||
minDate: isMinDate, | ||
onClick: PropTypes.func, | ||
onMouseOver: PropTypes.func, | ||
style: PropTypes.objectOf(PropTypes.oneOfType([PropTypes.string, PropTypes.number])), | ||
tileClassName: PropTypes.oneOfType([PropTypes.func, isClassName]), | ||
tileContent: PropTypes.oneOfType([PropTypes.func, PropTypes.node]), | ||
tileDisabled: PropTypes.func | ||
}; | ||
activeStartDate: PropTypes.instanceOf(Date).isRequired, | ||
classes: PropTypes.arrayOf(PropTypes.string).isRequired, | ||
date: PropTypes.instanceOf(Date).isRequired, | ||
locale: PropTypes.string, | ||
maxDate: isMaxDate, | ||
minDate: isMinDate, | ||
onClick: PropTypes.func, | ||
onMouseOver: PropTypes.func, | ||
style: PropTypes.objectOf(PropTypes.oneOfType([PropTypes.string, PropTypes.number])), | ||
tileClassName: PropTypes.oneOfType([PropTypes.func, isClassName]), | ||
tileContent: PropTypes.oneOfType([PropTypes.func, PropTypes.node]), | ||
tileDisabled: PropTypes.func, | ||
}; |
@@ -1,94 +0,98 @@ | ||
function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); } | ||
function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } | ||
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } | ||
function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); } | ||
function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); } | ||
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } | ||
import { getRange } from './dates'; | ||
/** | ||
* Returns a value no smaller than min and no larger than max. | ||
* | ||
* @param {*} value Value to return. | ||
* @param {*} min Minimum return value. | ||
* @param {*} max Maximum return value. | ||
* @param {Date} value Value to return. | ||
* @param {Date} min Minimum return value. | ||
* @param {Date} max Maximum return value. | ||
*/ | ||
export function between(value, min, max) { | ||
if (min && min > value) { | ||
return min; | ||
} | ||
if (max && max < value) { | ||
return max; | ||
} | ||
return value; | ||
if (min && min > value) { | ||
return min; | ||
} | ||
if (max && max < value) { | ||
return max; | ||
} | ||
return value; | ||
} | ||
export function isValueWithinRange(value, range) { | ||
return range[0] <= value && range[1] >= value; | ||
return range[0] <= value && range[1] >= value; | ||
} | ||
export function isRangeWithinRange(greaterRange, smallerRange) { | ||
return greaterRange[0] <= smallerRange[0] && greaterRange[1] >= smallerRange[1]; | ||
return greaterRange[0] <= smallerRange[0] && greaterRange[1] >= smallerRange[1]; | ||
} | ||
export function doRangesOverlap(range1, range2) { | ||
return isValueWithinRange(range1[0], range2) || isValueWithinRange(range1[1], range2); | ||
return isValueWithinRange(range1[0], range2) || isValueWithinRange(range1[1], range2); | ||
} | ||
function getRangeClassNames(valueRange, dateRange, baseClassName) { | ||
var isRange = doRangesOverlap(dateRange, valueRange); | ||
var classes = []; | ||
if (isRange) { | ||
classes.push(baseClassName); | ||
var isRangeStart = isValueWithinRange(valueRange[0], dateRange); | ||
var isRangeEnd = isValueWithinRange(valueRange[1], dateRange); | ||
if (isRangeStart) { | ||
classes.push("".concat(baseClassName, "Start")); | ||
var isRange = doRangesOverlap(dateRange, valueRange); | ||
var classes = []; | ||
if (isRange) { | ||
classes.push(baseClassName); | ||
var isRangeStart = isValueWithinRange(valueRange[0], dateRange); | ||
var isRangeEnd = isValueWithinRange(valueRange[1], dateRange); | ||
if (isRangeStart) { | ||
classes.push("".concat(baseClassName, "Start")); | ||
} | ||
if (isRangeEnd) { | ||
classes.push("".concat(baseClassName, "End")); | ||
} | ||
if (isRangeStart && isRangeEnd) { | ||
classes.push("".concat(baseClassName, "BothEnds")); | ||
} | ||
} | ||
if (isRangeEnd) { | ||
classes.push("".concat(baseClassName, "End")); | ||
return classes; | ||
} | ||
export function getTileClasses(args) { | ||
if (!args) { | ||
throw new Error('args is required'); | ||
} | ||
if (isRangeStart && isRangeEnd) { | ||
classes.push("".concat(baseClassName, "BothEnds")); | ||
var value = args.value, date = args.date, hover = args.hover; | ||
var className = 'react-calendar__tile'; | ||
var classes = [className]; | ||
if (!date) { | ||
return classes; | ||
} | ||
} | ||
return classes; | ||
var now = new Date(); | ||
var dateRange = (function () { | ||
if (Array.isArray(date)) { | ||
return date; | ||
} | ||
var dateType = args.dateType; | ||
if (!dateType) { | ||
throw new Error('dateType is required when date is not an array of two dates'); | ||
} | ||
return getRange(dateType, date); | ||
})(); | ||
if (isValueWithinRange(now, dateRange)) { | ||
classes.push("".concat(className, "--now")); | ||
} | ||
if (!value) { | ||
return classes; | ||
} | ||
var valueRange = (function () { | ||
if (Array.isArray(value)) { | ||
return value; | ||
} | ||
var valueType = args.valueType; | ||
if (!valueType) { | ||
throw new Error('valueType is required when value is not an array of two dates'); | ||
} | ||
return getRange(valueType, value); | ||
})(); | ||
if (isRangeWithinRange(valueRange, dateRange)) { | ||
classes.push("".concat(className, "--active")); | ||
} | ||
else if (doRangesOverlap(valueRange, dateRange)) { | ||
classes.push("".concat(className, "--hasActive")); | ||
} | ||
var valueRangeClassNames = getRangeClassNames(valueRange, dateRange, "".concat(className, "--range")); | ||
classes.push.apply(classes, valueRangeClassNames); | ||
var valueArray = Array.isArray(value) ? value : [value]; | ||
if (hover && valueArray.length === 1) { | ||
var hoverRange = hover > valueRange[0] ? [valueRange[0], hover] : [hover, valueRange[0]]; | ||
var hoverRangeClassNames = getRangeClassNames(hoverRange, dateRange, "".concat(className, "--hover")); | ||
classes.push.apply(classes, hoverRangeClassNames); | ||
} | ||
return classes; | ||
} | ||
export function getTileClasses() { | ||
var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}, | ||
value = _ref.value, | ||
valueType = _ref.valueType, | ||
date = _ref.date, | ||
dateType = _ref.dateType, | ||
hover = _ref.hover; | ||
var className = 'react-calendar__tile'; | ||
var classes = [className]; | ||
if (!date) { | ||
return classes; | ||
} | ||
if (!Array.isArray(date) && !dateType) { | ||
throw new Error('getTileClasses(): Unable to get tile activity classes because one or more required arguments were not passed.'); | ||
} | ||
var now = new Date(); | ||
var dateRange = Array.isArray(date) ? date : getRange(dateType, date); | ||
if (isValueWithinRange(now, dateRange)) { | ||
classes.push("".concat(className, "--now")); | ||
} | ||
if (!value) { | ||
return classes; | ||
} | ||
if (!Array.isArray(value) && !valueType) { | ||
throw new Error('getTileClasses(): Unable to get tile activity classes because one or more required arguments were not passed.'); | ||
} | ||
var valueRange = Array.isArray(value) ? value : getRange(valueType, value); | ||
if (isRangeWithinRange(valueRange, dateRange)) { | ||
classes.push("".concat(className, "--active")); | ||
} else if (doRangesOverlap(valueRange, dateRange)) { | ||
classes.push("".concat(className, "--hasActive")); | ||
} | ||
var valueRangeClassNames = getRangeClassNames(valueRange, dateRange, "".concat(className, "--range")); | ||
classes.push.apply(classes, _toConsumableArray(valueRangeClassNames)); | ||
var valueArray = [].concat(value); | ||
if (hover && valueArray.length === 1) { | ||
var hoverRange = hover > valueRange[0] ? [valueRange[0], hover] : [hover, valueRange[0]]; | ||
var hoverRangeClassNames = getRangeClassNames(hoverRange, dateRange, "".concat(className, "--hover")); | ||
classes.push.apply(classes, _toConsumableArray(hoverRangeClassNames)); | ||
} | ||
return classes; | ||
} |
@@ -1,15 +0,27 @@ | ||
function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); } | ||
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } | ||
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; } | ||
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); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } | ||
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 } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); } | ||
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } | ||
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } | ||
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); } | ||
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } | ||
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } | ||
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } | ||
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 __extends = (this && this.__extends) || (function () { | ||
var extendStatics = function (d, b) { | ||
extendStatics = Object.setPrototypeOf || | ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || | ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; | ||
return extendStatics(d, b); | ||
}; | ||
return function (d, b) { | ||
if (typeof b !== "function" && b !== null) | ||
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); | ||
extendStatics(d, b); | ||
function __() { this.constructor = d; } | ||
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); | ||
}; | ||
})(); | ||
var __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
import React, { Component } from 'react'; | ||
@@ -20,98 +32,43 @@ import PropTypes from 'prop-types'; | ||
function datesAreDifferent(date1, date2) { | ||
return date1 && !date2 || !date1 && date2 || date1 && date2 && date1.getTime() !== date2.getTime(); | ||
return ((date1 && !date2) || | ||
(!date1 && date2) || | ||
(date1 && date2 && date1.getTime() !== date2.getTime())); | ||
} | ||
function getValue(nextProps, prop) { | ||
var activeStartDate = nextProps.activeStartDate, | ||
date = nextProps.date, | ||
view = nextProps.view; | ||
return typeof prop === 'function' ? prop({ | ||
activeStartDate: activeStartDate, | ||
date: date, | ||
view: view | ||
}) : prop; | ||
} | ||
var Tile = /*#__PURE__*/function (_Component) { | ||
_inherits(Tile, _Component); | ||
var _super = _createSuper(Tile); | ||
function Tile() { | ||
var _this; | ||
_classCallCheck(this, Tile); | ||
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { | ||
args[_key] = arguments[_key]; | ||
var Tile = /** @class */ (function (_super) { | ||
__extends(Tile, _super); | ||
function Tile() { | ||
var _this = _super !== null && _super.apply(this, arguments) || this; | ||
_this.state = {}; | ||
return _this; | ||
} | ||
_this = _super.call.apply(_super, [this].concat(args)); | ||
_defineProperty(_assertThisInitialized(_this), "state", {}); | ||
return _this; | ||
} | ||
_createClass(Tile, [{ | ||
key: "render", | ||
value: function render() { | ||
var _this$props = this.props, | ||
activeStartDate = _this$props.activeStartDate, | ||
children = _this$props.children, | ||
classes = _this$props.classes, | ||
date = _this$props.date, | ||
formatAbbr = _this$props.formatAbbr, | ||
locale = _this$props.locale, | ||
maxDate = _this$props.maxDate, | ||
maxDateTransform = _this$props.maxDateTransform, | ||
minDate = _this$props.minDate, | ||
minDateTransform = _this$props.minDateTransform, | ||
onClick = _this$props.onClick, | ||
onMouseOver = _this$props.onMouseOver, | ||
style = _this$props.style, | ||
tileDisabled = _this$props.tileDisabled, | ||
view = _this$props.view; | ||
var _this$state = this.state, | ||
tileClassName = _this$state.tileClassName, | ||
tileContent = _this$state.tileContent; | ||
return /*#__PURE__*/React.createElement("button", { | ||
className: clsx(classes, tileClassName), | ||
disabled: minDate && minDateTransform(minDate) > date || maxDate && maxDateTransform(maxDate) < date || tileDisabled && tileDisabled({ | ||
activeStartDate: activeStartDate, | ||
date: date, | ||
view: view | ||
}), | ||
onClick: onClick && function (event) { | ||
return onClick(date, event); | ||
}, | ||
onFocus: onMouseOver && function () { | ||
return onMouseOver(date); | ||
}, | ||
onMouseOver: onMouseOver && function () { | ||
return onMouseOver(date); | ||
}, | ||
style: style, | ||
type: "button" | ||
}, formatAbbr ? /*#__PURE__*/React.createElement("abbr", { | ||
"aria-label": formatAbbr(locale, date) | ||
}, children) : children, tileContent); | ||
} | ||
}], [{ | ||
key: "getDerivedStateFromProps", | ||
value: function getDerivedStateFromProps(nextProps, prevState) { | ||
var activeStartDate = nextProps.activeStartDate, | ||
tileClassName = nextProps.tileClassName, | ||
tileContent = nextProps.tileContent; | ||
var nextState = {}; | ||
if (tileClassName !== prevState.tileClassNameProps || datesAreDifferent(activeStartDate, prevState.activeStartDateProps)) { | ||
nextState.tileClassName = getValue(nextProps, tileClassName); | ||
nextState.tileClassNameProps = tileClassName; | ||
} | ||
if (tileContent !== prevState.tileContentProps || datesAreDifferent(activeStartDate, prevState.activeStartDateProps)) { | ||
nextState.tileContent = getValue(nextProps, tileContent); | ||
nextState.tileContentProps = tileContent; | ||
} | ||
nextState.activeStartDateProps = activeStartDate; | ||
return nextState; | ||
} | ||
}]); | ||
return Tile; | ||
}(Component); | ||
export { Tile as default }; | ||
Tile.propTypes = _objectSpread(_objectSpread({}, tileProps), {}, { | ||
children: PropTypes.node.isRequired, | ||
formatAbbr: PropTypes.func, | ||
maxDateTransform: PropTypes.func.isRequired, | ||
minDateTransform: PropTypes.func.isRequired | ||
}); | ||
Tile.getDerivedStateFromProps = function (nextProps, prevState) { | ||
var activeStartDate = nextProps.activeStartDate, date = nextProps.date, tileClassName = nextProps.tileClassName, tileContent = nextProps.tileContent, view = nextProps.view; | ||
var nextState = {}; | ||
var args = { activeStartDate: activeStartDate, date: date, view: view }; | ||
if (tileClassName !== prevState.tileClassNameProps || | ||
datesAreDifferent(activeStartDate, prevState.activeStartDateProps)) { | ||
nextState.tileClassName = | ||
typeof tileClassName === 'function' ? tileClassName(args) : tileClassName; | ||
nextState.tileClassNameProps = tileClassName; | ||
} | ||
if (tileContent !== prevState.tileContentProps || | ||
datesAreDifferent(activeStartDate, prevState.activeStartDateProps)) { | ||
nextState.tileContent = typeof tileContent === 'function' ? tileContent(args) : tileContent; | ||
nextState.tileContentProps = tileContent; | ||
} | ||
nextState.activeStartDateProps = activeStartDate; | ||
return nextState; | ||
}; | ||
Tile.prototype.render = function () { | ||
var _a = this.props, activeStartDate = _a.activeStartDate, children = _a.children, classes = _a.classes, date = _a.date, formatAbbr = _a.formatAbbr, locale = _a.locale, maxDate = _a.maxDate, maxDateTransform = _a.maxDateTransform, minDate = _a.minDate, minDateTransform = _a.minDateTransform, onClick = _a.onClick, onMouseOver = _a.onMouseOver, style = _a.style, tileDisabled = _a.tileDisabled, view = _a.view; | ||
var _b = this.state, tileClassName = _b.tileClassName, tileContent = _b.tileContent; | ||
return (React.createElement("button", { className: clsx(classes, tileClassName), disabled: (minDate && minDateTransform(minDate) > date) || | ||
(maxDate && maxDateTransform(maxDate) < date) || | ||
(tileDisabled && tileDisabled({ activeStartDate: activeStartDate, date: date, view: view })), onClick: onClick ? function (event) { return onClick(date, event); } : undefined, onFocus: onMouseOver ? function () { return onMouseOver(date); } : undefined, onMouseOver: onMouseOver ? function () { return onMouseOver(date); } : undefined, style: style, type: "button" }, | ||
formatAbbr ? React.createElement("abbr", { "aria-label": formatAbbr(locale, date) }, children) : children, | ||
tileContent)); | ||
}; | ||
Tile.propTypes = __assign(__assign({}, tileProps), { children: PropTypes.node.isRequired, formatAbbr: PropTypes.func, maxDateTransform: PropTypes.func.isRequired, minDateTransform: PropTypes.func.isRequired }); | ||
return Tile; | ||
}(Component)); | ||
export default Tile; |
@@ -1,8 +0,23 @@ | ||
var _excluded = ["className", "count", "dateTransform", "dateType", "end", "hover", "offset", "start", "step", "tile", "value", "valueType"]; | ||
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } | ||
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(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; } | ||
function _extends() { _extends = Object.assign ? Object.assign.bind() : 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 _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } | ||
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 __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
var __rest = (this && this.__rest) || function (s, e) { | ||
var t = {}; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) | ||
t[p] = s[p]; | ||
if (s != null && typeof Object.getOwnPropertySymbols === "function") | ||
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { | ||
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) | ||
t[p[i]] = s[p[i]]; | ||
} | ||
return t; | ||
}; | ||
import React from 'react'; | ||
@@ -13,49 +28,17 @@ import PropTypes from 'prop-types'; | ||
import { tileGroupProps } from './shared/propTypes'; | ||
export default function TileGroup(_ref) { | ||
var className = _ref.className, | ||
_ref$count = _ref.count, | ||
count = _ref$count === void 0 ? 3 : _ref$count, | ||
dateTransform = _ref.dateTransform, | ||
dateType = _ref.dateType, | ||
end = _ref.end, | ||
hover = _ref.hover, | ||
offset = _ref.offset, | ||
start = _ref.start, | ||
_ref$step = _ref.step, | ||
step = _ref$step === void 0 ? 1 : _ref$step, | ||
Tile = _ref.tile, | ||
value = _ref.value, | ||
valueType = _ref.valueType, | ||
tileProps = _objectWithoutProperties(_ref, _excluded); | ||
var tiles = []; | ||
for (var point = start; point <= end; point += step) { | ||
var date = dateTransform(point); | ||
tiles.push( /*#__PURE__*/React.createElement(Tile, _extends({ | ||
key: date.getTime(), | ||
classes: getTileClasses({ | ||
value: value, | ||
valueType: valueType, | ||
date: date, | ||
dateType: dateType, | ||
hover: hover | ||
}), | ||
date: date, | ||
point: point | ||
}, tileProps))); | ||
} | ||
return /*#__PURE__*/React.createElement(Flex, { | ||
className: className, | ||
count: count, | ||
offset: offset, | ||
wrap: true | ||
}, tiles); | ||
export default function TileGroup(_a) { | ||
var className = _a.className, _b = _a.count, count = _b === void 0 ? 3 : _b, dateTransform = _a.dateTransform, dateType = _a.dateType, end = _a.end, hover = _a.hover, offset = _a.offset, start = _a.start, _c = _a.step, step = _c === void 0 ? 1 : _c, Tile = _a.tile, value = _a.value, valueType = _a.valueType, tileProps = __rest(_a, ["className", "count", "dateTransform", "dateType", "end", "hover", "offset", "start", "step", "tile", "value", "valueType"]); | ||
var tiles = []; | ||
for (var point = start; point <= end; point += step) { | ||
var date = dateTransform(point); | ||
tiles.push(React.createElement(Tile, __assign({ key: date.getTime(), classes: getTileClasses({ | ||
value: value, | ||
valueType: valueType, | ||
date: date, | ||
dateType: dateType, | ||
hover: hover, | ||
}), date: date, point: point }, tileProps))); | ||
} | ||
return (React.createElement(Flex, { className: className, count: count, offset: offset, wrap: true }, tiles)); | ||
} | ||
TileGroup.propTypes = _objectSpread(_objectSpread({}, tileGroupProps), {}, { | ||
activeStartDate: PropTypes.instanceOf(Date), | ||
count: PropTypes.number, | ||
dateTransform: PropTypes.func.isRequired, | ||
dateType: PropTypes.string, | ||
offset: PropTypes.number, | ||
step: PropTypes.number, | ||
tile: PropTypes.func.isRequired | ||
}); | ||
TileGroup.propTypes = __assign(__assign({}, tileGroupProps), { className: PropTypes.string, count: PropTypes.number, dateTransform: PropTypes.func.isRequired, dateType: PropTypes.string, end: PropTypes.number.isRequired, offset: PropTypes.number, step: PropTypes.number, start: PropTypes.number.isRequired, tile: PropTypes.func.isRequired }); |
@@ -0,10 +1,19 @@ | ||
var __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
import React from 'react'; | ||
import Months from './YearView/Months'; | ||
export default function YearView(props) { | ||
function renderMonths() { | ||
return /*#__PURE__*/React.createElement(Months, props); | ||
} | ||
return /*#__PURE__*/React.createElement("div", { | ||
className: "react-calendar__year-view" | ||
}, renderMonths()); | ||
} | ||
function renderMonths() { | ||
return React.createElement(Months, __assign({}, props)); | ||
} | ||
return React.createElement("div", { className: "react-calendar__year-view" }, renderMonths()); | ||
} |
@@ -1,8 +0,32 @@ | ||
var _excluded = ["classes", "formatMonth", "formatMonthYear"]; | ||
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } | ||
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(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; } | ||
function _extends() { _extends = Object.assign ? Object.assign.bind() : 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 _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } | ||
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 __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
var __rest = (this && this.__rest) || function (s, e) { | ||
var t = {}; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) | ||
t[p] = s[p]; | ||
if (s != null && typeof Object.getOwnPropertySymbols === "function") | ||
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { | ||
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) | ||
t[p[i]] = s[p[i]]; | ||
} | ||
return t; | ||
}; | ||
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) { | ||
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) { | ||
if (ar || !(i in from)) { | ||
if (!ar) ar = Array.prototype.slice.call(from, 0, i); | ||
ar[i] = from[i]; | ||
} | ||
} | ||
return to.concat(ar || Array.prototype.slice.call(from)); | ||
}; | ||
import React from 'react'; | ||
@@ -12,25 +36,10 @@ import PropTypes from 'prop-types'; | ||
import Tile from '../Tile'; | ||
import { formatMonth as defaultFormatMonth, formatMonthYear as defaultFormatMonthYear } from '../shared/dateFormatter'; | ||
import { formatMonth as defaultFormatMonth, formatMonthYear as defaultFormatMonthYear, } from '../shared/dateFormatter'; | ||
import { tileProps } from '../shared/propTypes'; | ||
var className = 'react-calendar__year-view__months__month'; | ||
export default function Month(_ref) { | ||
var classes = _ref.classes, | ||
_ref$formatMonth = _ref.formatMonth, | ||
formatMonth = _ref$formatMonth === void 0 ? defaultFormatMonth : _ref$formatMonth, | ||
_ref$formatMonthYear = _ref.formatMonthYear, | ||
formatMonthYear = _ref$formatMonthYear === void 0 ? defaultFormatMonthYear : _ref$formatMonthYear, | ||
otherProps = _objectWithoutProperties(_ref, _excluded); | ||
var date = otherProps.date, | ||
locale = otherProps.locale; | ||
return /*#__PURE__*/React.createElement(Tile, _extends({}, otherProps, { | ||
classes: [].concat(classes, className), | ||
formatAbbr: formatMonthYear, | ||
maxDateTransform: getMonthEnd, | ||
minDateTransform: getMonthStart, | ||
view: "year" | ||
}), formatMonth(locale, date)); | ||
export default function Month(_a) { | ||
var _b = _a.classes, classes = _b === void 0 ? [] : _b, _c = _a.formatMonth, formatMonth = _c === void 0 ? defaultFormatMonth : _c, _d = _a.formatMonthYear, formatMonthYear = _d === void 0 ? defaultFormatMonthYear : _d, otherProps = __rest(_a, ["classes", "formatMonth", "formatMonthYear"]); | ||
var date = otherProps.date, locale = otherProps.locale; | ||
return (React.createElement(Tile, __assign({}, otherProps, { classes: __spreadArray(__spreadArray([], classes, true), [className], false), formatAbbr: formatMonthYear, maxDateTransform: getMonthEnd, minDateTransform: getMonthStart, view: "year" }), formatMonth(locale, date))); | ||
} | ||
Month.propTypes = _objectSpread(_objectSpread({}, tileProps), {}, { | ||
formatMonth: PropTypes.func, | ||
formatMonthYear: PropTypes.func | ||
}); | ||
Month.propTypes = __assign(__assign({}, tileProps), { formatMonth: PropTypes.func, formatMonthYear: PropTypes.func }); |
@@ -1,5 +0,12 @@ | ||
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } | ||
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(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; } | ||
function _extends() { _extends = Object.assign ? Object.assign.bind() : 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 __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
import React from 'react'; | ||
@@ -12,22 +19,13 @@ import PropTypes from 'prop-types'; | ||
export default function Months(props) { | ||
var activeStartDate = props.activeStartDate; | ||
var start = 0; | ||
var end = 11; | ||
var year = getYear(activeStartDate); | ||
return /*#__PURE__*/React.createElement(TileGroup, _extends({}, props, { | ||
className: "react-calendar__year-view__months", | ||
dateTransform: function dateTransform(monthIndex) { | ||
var date = new Date(); | ||
date.setFullYear(year, monthIndex, 1); | ||
date.setHours(0, 0, 0, 0); | ||
return date; | ||
}, | ||
dateType: "month", | ||
end: end, | ||
start: start, | ||
tile: Month | ||
})); | ||
var activeStartDate = props.activeStartDate; | ||
var start = 0; | ||
var end = 11; | ||
var year = getYear(activeStartDate); | ||
return (React.createElement(TileGroup, __assign({}, props, { className: "react-calendar__year-view__months", dateTransform: function (monthIndex) { | ||
var date = new Date(); | ||
date.setFullYear(year, monthIndex, 1); | ||
date.setHours(0, 0, 0, 0); | ||
return date; | ||
}, dateType: "month", end: end, start: start, tile: Month }))); | ||
} | ||
Months.propTypes = _objectSpread(_objectSpread({}, tileGroupProps), {}, { | ||
locale: PropTypes.string | ||
}); | ||
Months.propTypes = __assign(__assign({}, tileGroupProps), { locale: PropTypes.string }); |
{ | ||
"name": "react-calendar", | ||
"version": "4.0.0", | ||
"version": "4.1.0", | ||
"description": "Ultimate calendar for your React app.", | ||
"main": "dist/cjs/index.js", | ||
"module": "dist/esm/index.js", | ||
"source": "src/index.js", | ||
"source": "src/index.ts", | ||
"types": "dist/cjs/index.d.ts", | ||
"sideEffects": [ | ||
"*.css", | ||
"*.less" | ||
"*.css" | ||
], | ||
"scripts": { | ||
"build": "yarn build-js && yarn copy-styles && yarn build-styles", | ||
"build": "yarn build-js && yarn copy-styles", | ||
"build-js": "yarn build-js-esm && yarn build-js-cjs", | ||
"build-js-esm": "BABEL_ENV=production-esm babel src -d dist/esm --ignore \"**/*.spec.js,**/*.spec.jsx\"", | ||
"build-js-cjs": "BABEL_ENV=production-cjs babel src -d dist/cjs --ignore \"**/*.spec.js,**/*.spec.jsx\"", | ||
"build-styles": "lessc ./dist/Calendar.less ./dist/Calendar.css", | ||
"build-js-esm": "tsc --project tsconfig.build.json --outDir dist/esm --module esnext", | ||
"build-js-cjs": "tsc --project tsconfig.build.json --outDir dist/cjs --module commonjs", | ||
"clean": "rimraf dist", | ||
"copy-styles": "node ./copy-styles.js", | ||
"jest": "jest", | ||
"lint": "eslint sample src test --ext .jsx,.js", | ||
"copy-styles": "node ./copy-styles.mjs", | ||
"lint": "eslint . --ext .js,.jsx,.ts,.tsx", | ||
"prepack": "yarn clean && yarn build", | ||
"prettier": "prettier --check . --cache", | ||
"test": "yarn lint && yarn prettier && yarn jest" | ||
"test": "yarn lint && yarn tsc && yarn prettier && yarn unit", | ||
"tsc": "tsc --noEmit", | ||
"unit": "vitest run" | ||
}, | ||
@@ -39,20 +39,15 @@ "keywords": [ | ||
"dependencies": { | ||
"@wojtekmaj/date-utils": "^1.0.2", | ||
"@types/react": "*", | ||
"@wojtekmaj/date-utils": "^1.1.3", | ||
"clsx": "^1.2.1", | ||
"get-user-locale": "^1.2.0", | ||
"get-user-locale": "^2.1.3", | ||
"prop-types": "^15.6.0" | ||
}, | ||
"devDependencies": { | ||
"@babel/cli": "^7.15.0", | ||
"@babel/core": "^7.15.0", | ||
"@babel/preset-env": "^7.15.0", | ||
"@babel/preset-react": "^7.14.0", | ||
"@testing-library/jest-dom": "^5.15.0", | ||
"@testing-library/react": "^13.4.0", | ||
"@testing-library/react": "^14.0.0", | ||
"eslint": "^8.26.0", | ||
"eslint-config-wojtekmaj": "^0.7.1", | ||
"eslint-config-wojtekmaj": "^0.8.2", | ||
"husky": "^8.0.0", | ||
"jest": "^29.0.0", | ||
"jest-environment-jsdom": "^29.0.0", | ||
"less": "^4.0.0", | ||
"jsdom": "^21.1.0", | ||
"prettier": "^2.7.0", | ||
@@ -62,3 +57,5 @@ "pretty-quick": "^3.1.0", | ||
"react-dom": "^18.2.0", | ||
"rimraf": "^3.0.0" | ||
"rimraf": "^3.0.0", | ||
"typescript": "^5.0.2", | ||
"vitest": "^0.29.2" | ||
}, | ||
@@ -69,5 +66,2 @@ "peerDependencies": { | ||
}, | ||
"resolutions": { | ||
"semver@7.0.0": "^7.0.0" | ||
}, | ||
"files": [ | ||
@@ -74,0 +68,0 @@ "dist", |
@@ -1,2 +0,2 @@ | ||
[![npm](https://img.shields.io/npm/v/react-calendar.svg)](https://www.npmjs.com/package/react-calendar) ![downloads](https://img.shields.io/npm/dt/react-calendar.svg) [![CI](https://github.com/wojtekmaj/react-calendar/workflows/CI/badge.svg)](https://github.com/wojtekmaj/react-calendar/actions) [![tested with jest](https://img.shields.io/badge/tested_with-jest-99424f.svg)](https://github.com/facebook/jest) | ||
[![npm](https://img.shields.io/npm/v/react-calendar.svg)](https://www.npmjs.com/package/react-calendar) ![downloads](https://img.shields.io/npm/dt/react-calendar.svg) [![CI](https://github.com/wojtekmaj/react-calendar/workflows/CI/badge.svg)](https://github.com/wojtekmaj/react-calendar/actions) | ||
@@ -154,12 +154,12 @@ # React-Calendar | ||
| Prop name | Description | Default value | Example values | | ||
| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | ||
| activeStartDate | The beginning of a period that shall be displayed. | n/a | `new Date(2017, 0, 1)` | | ||
| hover | The date over which the user is hovering. Used only when `selectRange` is enabled, to render a “WIP” range when the user is selecting range. | n/a | `new Date(2017, 0, 1)` | | ||
| maxDate | Maximum date that the user can select. Periods partially overlapped by maxDate will also be selectable, although react-calendar will ensure that no later date is selected. | n/a | Date: `new Date()` | | ||
| minDate | Minimum date that the user can select. Periods partially overlapped by minDate will also be selectable, although react-calendar will ensure that no earlier date is selected. | n/a | Date: `new Date()` | | ||
| onClick | Function called when the user clicks an item (day on month view, month on year view and so on). | n/a | `(value) => alert('New date is: ', value)` | | ||
| tileClassName | Class name(s) that will be applied to a given calendar item (day on month view, month on year view and so on). | n/a | <ul><li>String: `"class1 class2"`</li><li>Array of strings: `["class1", "class2 class3"]`</li><li>Function: `({ date, view }) => view === 'month' && date.getDay() === 3 ? 'saturday' : null`</li></ul> | | ||
| tileContent | Allows to render custom content within a given item (day on month view, month on year view and so on). Note: For tiles with custom content you might want to set fixed height of `react-calendar__tile` to ensure consistent layout. | n/a | `({ date, view }) => view === 'month' && date.getDay() === 0 ? <p>It's Sunday!</p> : null` | | ||
| value | Calendar value. Can be either one value or an array of two values. | n/a | <ul><li>Date: `new Date()`</li><li>An array of dates: `[new Date(2017, 0, 1), new Date(2017, 7, 1)]`</li><li>String: `2017-01-01`</li><li>An array of strings: `['2017-01-01', '2017-08-01']`</li></ul> | | ||
| Prop name | Description | Default value | Example values | | ||
| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | ||
| activeStartDate | The beginning of a period that shall be displayed. | n/a | `new Date(2017, 0, 1)` | | ||
| hover | The date over which the user is hovering. Used only when `selectRange` is enabled, to render a “WIP” range when the user is selecting range. | n/a | `new Date(2017, 0, 1)` | | ||
| maxDate | Maximum date that the user can select. Periods partially overlapped by maxDate will also be selectable, although react-calendar will ensure that no later date is selected. | n/a | Date: `new Date()` | | ||
| minDate | Minimum date that the user can select. Periods partially overlapped by minDate will also be selectable, although react-calendar will ensure that no earlier date is selected. | n/a | Date: `new Date()` | | ||
| onClick | Function called when the user clicks an item (day on month view, month on year view and so on). | n/a | `(value) => alert('New date is: ', value)` | | ||
| tileClassName | Class name(s) that will be applied to a given calendar item (day on month view, month on year view and so on). | n/a | <ul><li>String: `"class1 class2"`</li><li>Array of strings: `["class1", "class2 class3"]`</li><li>Function: `({ date, view }) => view === 'month' && date.getDay() === 3 ? 'wednesday' : null`</li></ul> | | ||
| tileContent | Allows to render custom content within a given item (day on month view, month on year view and so on). Note: For tiles with custom content you might want to set fixed height of `react-calendar__tile` to ensure consistent layout. | n/a | `({ date, view }) => view === 'month' && date.getDay() === 0 ? <p>It's Sunday!</p> : null` | | ||
| value | Calendar value. Can be either one value or an array of two values. | n/a | <ul><li>Date: `new Date()`</li><li>An array of dates: `[new Date(2017, 0, 1), new Date(2017, 7, 1)]`</li><li>String: `2017-01-01`</li><li>An array of strings: `['2017-01-01', '2017-08-01']`</li></ul> | | ||
@@ -166,0 +166,0 @@ ## Useful links |
@@ -0,1 +1,2 @@ | ||
import { describe, expect, it } from 'vitest'; | ||
import { | ||
@@ -2,0 +3,0 @@ formatDate, |
@@ -0,1 +1,2 @@ | ||
import { describe, expect, it } from 'vitest'; | ||
import { getDayStart, getDayEnd } from '@wojtekmaj/date-utils'; | ||
@@ -2,0 +3,0 @@ |
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Major refactor
Supply chain riskPackage has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.
Found 1 instance in 1 package
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
590593
13
158
12786
7
1
+ Added@types/react@*
+ Added@types/prop-types@15.7.13(transitive)
+ Added@types/react@18.3.12(transitive)
+ Addedcsstype@3.1.3(transitive)
+ Addedget-user-locale@2.3.2(transitive)
+ Addedmap-age-cleaner@0.1.3(transitive)
+ Addedmem@8.1.1(transitive)
+ Addedmimic-fn@3.1.0(transitive)
+ Addedp-defer@1.0.0(transitive)
- Removedget-user-locale@1.5.1(transitive)
- Removedlodash.memoize@4.1.2(transitive)
Updated@wojtekmaj/date-utils@^1.1.3
Updatedget-user-locale@^2.1.3