vendor: 1,965 bytes, lines 1-44
1var __assign = (this && this.__assign) || function () { 2 __assign = Object.assign || function(t) { 3 for (var s, i = 1, n = arguments.length; i < n; i++) { 4 s = arguments[i]; 5 for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) 6 t[p] = s[p]; 7 } 8 return t; 9 }; 10 return __assign.apply(this, arguments); 11}; 12var __spreadArrays = (this && this.__spreadArrays) || function () { 13 for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length; 14 for (var r = Array(s), k = 0, i = 0; i < il; i++) 15 for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) 16 r[k] = a[j]; 17 return r; 18}; 19import { defaults as defaultOptions, HOOKS, } from "./types/options.js"; 20import English from "./l10n/default.js"; 21import { arrayify, debounce, int, pad } from "./utils/index.js"; 22import { clearNode, createElement, createNumberInput, findParent, toggleClass, getEventTarget, } from "./utils/dom.js"; 23import { compareDates, createDateParser, createDateFormatter, duration, isBetween, getDefaultHours, calculateSecondsSinceMidnight, parseSeconds, } from "./utils/dates.js"; 24import { tokenRegex, monthToStr } from "./utils/formatting.js"; 25import "./utils/polyfills.js"; 26var DEBOUNCED_CHANGE_MS = 300; 27function FlatpickrInstance(element, instanceConfig) { 28 var self = { 29 config: __assign(__assign({}, defaultOptions), flatpickr.defaultConfig), 30 l10n: English, 31 }; 32 self.parseDate = createDateParser({ config: self.config, l10n: self.l10n }); 33 self._handlers = []; 34 self.pluginElements = []; 35 self.loadedPlugins = []; 36 self._bind = bind; 37 self._setHoursFromDate = setHoursFromDate; 38 self._positionCalendar = positionCalendar; 39 self.changeMonth = changeMonth; 40 self.changeYear = changeYear; 41 self.clear = clear; 42 self.close = close; 43 self.onMouseOver = onMouseOver; 44 self._createElement = createElement
vendor: 9,539 bytes, lines 44-269
44; 45 self.createDay = createDay; 46 self.destroy = destroy; 47 self.isEnabled = isEnabled; 48 self.jumpToDate = jumpToDate; 49 self.updateValue = updateValue; 50 self.open = open; 51 self.redraw = redraw; 52 self.set = set; 53 self.setDate = setDate; 54 self.toggle = toggle; 55 function setupHelperFunctions() { 56 self.utils = { 57 getDaysInMonth: function (month, yr) { 58 if (month === void 0) { month = self.currentMonth; } 59 if (yr === void 0) { yr = self.currentYear; } 60 if (month === 1 && ((yr % 4 === 0 && yr % 100 !== 0) || yr % 400 === 0)) 61 return 29; 62 return self.l10n.daysInMonth[month]; 63 }, 64 }; 65 } 66 function init() { 67 self.element = self.input = element; 68 self.isOpen = false; 69 parseConfig(); 70 setupLocale(); 71 setupInputs(); 72 setupDates(); 73 setupHelperFunctions(); 74 if (!self.isMobile) 75 build(); 76 bindEvents(); 77 if (self.selectedDates.length || self.config.noCalendar) { 78 if (self.config.enableTime) { 79 setHoursFromDate(self.config.noCalendar ? self.latestSelectedDateObj : undefined); 80 } 81 updateValue(false); 82 } 83 setCalendarWidth(); 84 var isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent); 85 if (!self.isMobile && isSafari) { 86 positionCalendar(); 87 } 88 triggerEvent("onReady"); 89 } 90 function getClosestActiveElement() { 91 var _a; 92 return (((_a = self.calendarContainer) === null || _a === void 0 ? void 0 : _a.getRootNode()) 93 .activeElement || document.activeElement); 94 } 95 function bindToInstance(fn) { 96 return fn.bind(self); 97 } 98 function setCalendarWidth() { 99 var config = self.config; 100 if (config.weekNumbers === false && config.showMonths === 1) { 101 return; 102 } 103 else if (config.noCalendar !== true) { 104 window.requestAnimationFrame(function () { 105 if (self.calendarContainer !== undefined) { 106 self.calendarContainer.style.visibility = "hidden"; 107 self.calendarContainer.style.display = "block"; 108 } 109 if (self.daysContainer !== undefined) { 110 var daysWidth = (self.days.offsetWidth + 1) * config.showMonths; 111 self.daysContainer.style.width = daysWidth + "px"; 112 self.calendarContainer.style.width = 113 daysWidth + 114 (self.weekWrapper !== undefined 115 ? self.weekWrapper.offsetWidth 116 : 0) + 117 "px"; 118 self.calendarContainer.style.removeProperty("visibility"); 119 self.calendarContainer.style.removeProperty("display"); 120 } 121 }); 122 } 123 } 124 function updateTime(e) { 125 if (self.selectedDates.length === 0) { 126 var defaultDate = self.config.minDate === undefined || 127 compareDates(new Date(), self.config.minDate) >= 0 128 ? new Date() 129 : new Date(self.config.minDate.getTime()); 130 var defaults = getDefaultHours(self.config); 131 defaultDate.setHours(defaults.hours, defaults.minutes, defaults.seconds, defaultDate.getMilliseconds()); 132 self.selectedDates = [defaultDate]; 133 self.latestSelectedDateObj = defaultDate; 134 } 135 if (e !== undefined && e.type !== "blur") { 136 timeWrapper(e); 137 } 138 var prevValue = self._input.value; 139 setHoursFromInputs(); 140 updateValue(); 141 if (self._input.value !== prevValue) { 142 self._debouncedChange(); 143 } 144 } 145 function ampm2military(hour, amPM) { 146 return (hour % 12) + 12 * int(amPM === self.l10n.amPM[1]); 147 } 148 function military2ampm(hour) { 149 switch (hour % 24) { 150 case 0: 151 case 12: 152 return 12; 153 default: 154 return hour % 12; 155 } 156 } 157 function setHoursFromInputs() { 158 if (self.hourElement === undefined || self.minuteElement === undefined) 159 return; 160 var hours = (parseInt(self.hourElement.value.slice(-2), 10) || 0) % 24, minutes = (parseInt(self.minuteElement.value, 10) || 0) % 60, seconds = self.secondElement !== undefined 161 ? (parseInt(self.secondElement.value, 10) || 0) % 60 162 : 0; 163 if (self.amPM !== undefined) { 164 hours = ampm2military(hours, self.amPM.textContent); 165 } 166 var limitMinHours = self.config.minTime !== undefined || 167 (self.config.minDate && 168 self.minDateHasTime && 169 self.latestSelectedDateObj && 170 compareDates(self.latestSelectedDateObj, self.config.minDate, true) === 171 0); 172 var limitMaxHours = self.config.maxTime !== undefined || 173 (self.config.maxDate && 174 self.maxDateHasTime && 175 self.latestSelectedDateObj && 176 compareDates(self.latestSelectedDateObj, self.config.maxDate, true) === 177 0); 178 if (self.config.maxTime !== undefined && 179 self.config.minTime !== undefined && 180 self.config.minTime > self.config.maxTime) { 181 var minBound = calculateSecondsSinceMidnight(self.config.minTime.getHours(), self.config.minTime.getMinutes(), self.config.minTime.getSeconds()); 182 var maxBound = calculateSecondsSinceMidnight(self.config.maxTime.getHours(), self.config.maxTime.getMinutes(), self.config.maxTime.getSeconds()); 183 var currentTime = calculateSecondsSinceMidnight(hours, minutes, seconds); 184 if (currentTime > maxBound && currentTime < minBound) { 185 var result = parseSeconds(minBound); 186 hours = result[0]; 187 minutes = result[1]; 188 seconds = result[2]; 189 } 190 } 191 else { 192 if (limitMaxHours) { 193 var maxTime = self.config.maxTime !== undefined 194 ? self.config.maxTime 195 : self.config.maxDate; 196 hours = Math.min(hours, maxTime.getHours()); 197 if (hours === maxTime.getHours()) 198 minutes = Math.min(minutes, maxTime.getMinutes()); 199 if (minutes === maxTime.getMinutes()) 200 seconds = Math.min(seconds, maxTime.getSeconds()); 201 } 202 if (limitMinHours) { 203 var minTime = self.config.minTime !== undefined 204 ? self.config.minTime 205 : self.config.minDate; 206 hours = Math.max(hours, minTime.getHours()); 207 if (hours === minTime.getHours() && minutes < minTime.getMinutes()) 208 minutes = minTime.getMinutes(); 209 if (minutes === minTime.getMinutes()) 210 seconds = Math.max(seconds, minTime.getSeconds()); 211 } 212 } 213 setHours(hours, minutes, seconds); 214 } 215 function setHoursFromDate(dateObj) { 216 var date = dateObj || self.latestSelectedDateObj; 217 if (date && date instanceof Date) { 218 setHours(date.getHours(), date.getMinutes(), date.getSeconds()); 219 } 220 } 221 function setHours(hours, minutes, seconds) { 222 if (self.latestSelectedDateObj !== undefined) { 223 self.latestSelectedDateObj.setHours(hours % 24, minutes, seconds || 0, 0); 224 } 225 if (!self.hourElement || !self.minuteElement || self.isMobile) 226 return; 227 self.hourElement.value = pad(!self.config.time_24hr 228 ? ((12 + hours) % 12) + 12 * int(hours % 12 === 0) 229 : hours); 230 self.minuteElement.value = pad(minutes); 231 if (self.amPM !== undefined) 232 self.amPM.textContent = self.l10n.amPM[int(hours >= 12)]; 233 if (self.secondElement !== undefined) 234 self.secondElement.value = pad(seconds); 235 } 236 function onYearInput(event) { 237 var eventTarget = getEventTarget(event); 238 var year = parseInt(eventTarget.value) + (event.delta || 0); 239 if (year / 1000 > 1 || 240 (event.key === "Enter" && !/[^\d]/.test(year.toString()))) { 241 changeYear(year); 242 } 243 } 244 function bind(element, event, handler, options) { 245 if (event instanceof Array) 246 return event.forEach(function (ev) { return bind(element, ev, handler, options); }); 247 if (element instanceof Array) 248 return element.forEach(function (el) { return bind(el, event, handler, options); }); 249 element.addEventListener(event, handler, options); 250 self._handlers.push({ 251 remove: function () { return element.removeEventListener(event, handler, options); }, 252 }); 253 } 254 function triggerChange() { 255 triggerEvent("onChange"); 256 } 257 function bindEvents() { 258 if (self.config.wrap) { 259 ["open", "close", "toggle", "clear"].forEach(function (evt) { 260 Array.prototype.forEach.call(self.element.querySelectorAll("[data-" + evt + "]"), function (el) { 261 return bind(el, "click", self[evt]); 262 }); 263 }); 264 } 265 if (self.isMobile) { 266 setupMobile(); 267 return; 268 } 269 var debouncedResize = debounce(onResize, 50);
vendor: 13,817 bytes, lines 270-556
270 self._debouncedChange = debounce(triggerChange, DEBOUNCED_CHANGE_MS); 271 if (self.daysContainer && !/iPhone|iPad|iPod/i.test(navigator.userAgent)) 272 bind(self.daysContainer, "mouseover", function (e) { 273 if (self.config.mode === "range") 274 onMouseOver(getEventTarget(e)); 275 }); 276 bind(self._input, "keydown", onKeyDown); 277 if (self.calendarContainer !== undefined) { 278 bind(self.calendarContainer, "keydown", onKeyDown); 279 } 280 if (!self.config.inline && !self.config.static) 281 bind(window, "resize", debouncedResize); 282 if (window.ontouchstart !== undefined) 283 bind(window.document, "touchstart", documentClick); 284 else 285 bind(window.document, "mousedown", documentClick); 286 bind(window.document, "focus", documentClick, { capture: true }); 287 if (self.config.clickOpens === true) { 288 bind(self._input, "focus", self.open); 289 bind(self._input, "click", self.open); 290 } 291 if (self.daysContainer !== undefined) { 292 bind(self.monthNav, "click", onMonthNavClick); 293 bind(self.monthNav, ["keyup", "increment"], onYearInput); 294 bind(self.daysContainer, "click", selectDate); 295 } 296 if (self.timeContainer !== undefined && 297 self.minuteElement !== undefined && 298 self.hourElement !== undefined) { 299 var selText = function (e) { 300 return getEventTarget(e).select(); 301 }; 302 bind(self.timeContainer, ["increment"], updateTime); 303 bind(self.timeContainer, "blur", updateTime, { capture: true }); 304 bind(self.timeContainer, "click", timeIncrement); 305 bind([self.hourElement, self.minuteElement], ["focus", "click"], selText); 306 if (self.secondElement !== undefined) 307 bind(self.secondElement, "focus", function () { return self.secondElement && self.secondElement.select(); }); 308 if (self.amPM !== undefined) { 309 bind(self.amPM, "click", function (e) { 310 updateTime(e); 311 }); 312 } 313 } 314 if (self.config.allowInput) { 315 bind(self._input, "blur", onBlur); 316 } 317 } 318 function jumpToDate(jumpDate, triggerChange) { 319 var jumpTo = jumpDate !== undefined 320 ? self.parseDate(jumpDate) 321 : self.latestSelectedDateObj || 322 (self.config.minDate && self.config.minDate > self.now 323 ? self.config.minDate 324 : self.config.maxDate && self.config.maxDate < self.now 325 ? self.config.maxDate 326 : self.now); 327 var oldYear = self.currentYear; 328 var oldMonth = self.currentMonth; 329 try { 330 if (jumpTo !== undefined) { 331 self.currentYear = jumpTo.getFullYear(); 332 self.currentMonth = jumpTo.getMonth(); 333 } 334 } 335 catch (e) { 336 e.message = "Invalid date supplied: " + jumpTo; 337 self.config.errorHandler(e); 338 } 339 if (triggerChange && self.currentYear !== oldYear) { 340 triggerEvent("onYearChange"); 341 buildMonthSwitch(); 342 } 343 if (triggerChange && 344 (self.currentYear !== oldYear || self.currentMonth !== oldMonth)) { 345 triggerEvent("onMonthChange"); 346 } 347 self.redraw(); 348 } 349 function timeIncrement(e) { 350 var eventTarget = getEventTarget(e); 351 if (~eventTarget.className.indexOf("arrow")) 352 incrementNumInput(e, eventTarget.classList.contains("arrowUp") ? 1 : -1); 353 } 354 function incrementNumInput(e, delta, inputElem) { 355 var target = e && getEventTarget(e); 356 var input = inputElem || 357 (target && target.parentNode && target.parentNode.firstChild); 358 var event = createEvent("increment"); 359 event.delta = delta; 360 input && input.dispatchEvent(event); 361 } 362 function build() { 363 var fragment = window.document.createDocumentFragment(); 364 self.calendarContainer = createElement("div", "flatpickr-calendar"); 365 self.calendarContainer.tabIndex = -1; 366 if (!self.config.noCalendar) { 367 fragment.appendChild(buildMonthNav()); 368 self.innerContainer = createElement("div", "flatpickr-innerContainer"); 369 if (self.config.weekNumbers) { 370 var _a = buildWeeks(), weekWrapper = _a.weekWrapper, weekNumbers = _a.weekNumbers; 371 self.innerContainer.appendChild(weekWrapper); 372 self.weekNumbers = weekNumbers; 373 self.weekWrapper = weekWrapper; 374 } 375 self.rContainer = createElement("div", "flatpickr-rContainer"); 376 self.rContainer.appendChild(buildWeekdays()); 377 if (!self.daysContainer) { 378 self.daysContainer = createElement("div", "flatpickr-days"); 379 self.daysContainer.tabIndex = -1; 380 } 381 buildDays(); 382 self.rContainer.appendChild(self.daysContainer); 383 self.innerContainer.appendChild(self.rContainer); 384 fragment.appendChild(self.innerContainer); 385 } 386 if (self.config.enableTime) { 387 fragment.appendChild(buildTime()); 388 } 389 toggleClass(self.calendarContainer, "rangeMode", self.config.mode === "range"); 390 toggleClass(self.calendarContainer, "animate", self.config.animate === true); 391 toggleClass(self.calendarContainer, "multiMonth", self.config.showMonths > 1); 392 self.calendarContainer.appendChild(fragment); 393 var customAppend = self.config.appendTo !== undefined && 394 self.config.appendTo.nodeType !== undefined; 395 if (self.config.inline || self.config.static) { 396 self.calendarContainer.classList.add(self.config.inline ? "inline" : "static"); 397 if (self.config.inline) { 398 if (!customAppend && self.element.parentNode) 399 self.element.parentNode.insertBefore(self.calendarContainer, self._input.nextSibling); 400 else if (self.config.appendTo !== undefined) 401 self.config.appendTo.appendChild(self.calendarContainer); 402 } 403 if (self.config.static) { 404 var wrapper = createElement("div", "flatpickr-wrapper"); 405 if (self.element.parentNode) 406 self.element.parentNode.insertBefore(wrapper, self.element); 407 wrapper.appendChild(self.element); 408 if (self.altInput) 409 wrapper.appendChild(self.altInput); 410 wrapper.appendChild(self.calendarContainer); 411 } 412 } 413 if (!self.config.static && !self.config.inline) 414 (self.config.appendTo !== undefined 415 ? self.config.appendTo 416 : window.document.body).appendChild(self.calendarContainer); 417 } 418 function createDay(className, date, _dayNumber, i) { 419 var dateIsEnabled = isEnabled(date, true), dayElement = createElement("span", className, date.getDate().toString()); 420 dayElement.dateObj = date; 421 dayElement.$i = i; 422 dayElement.setAttribute("aria-label", self.formatDate(date, self.config.ariaDateFormat)); 423 if (className.indexOf("hidden") === -1 && 424 compareDates(date, self.now) === 0) { 425 self.todayDateElem = dayElement; 426 dayElement.classList.add("today"); 427 dayElement.setAttribute("aria-current", "date"); 428 } 429 if (dateIsEnabled) { 430 dayElement.tabIndex = -1; 431 if (isDateSelected(date)) { 432 dayElement.classList.add("selected"); 433 self.selectedDateElem = dayElement; 434 if (self.config.mode === "range") { 435 toggleClass(dayElement, "startRange", self.selectedDates[0] && 436 compareDates(date, self.selectedDates[0], true) === 0); 437 toggleClass(dayElement, "endRange", self.selectedDates[1] && 438 compareDates(date, self.selectedDates[1], true) === 0); 439 if (className === "nextMonthDay") 440 dayElement.classList.add("inRange"); 441 } 442 } 443 } 444 else { 445 dayElement.classList.add("flatpickr-disabled"); 446 } 447 if (self.config.mode === "range") { 448 if (isDateInRange(date) && !isDateSelected(date)) 449 dayElement.classList.add("inRange"); 450 } 451 if (self.weekNumbers && 452 self.config.showMonths === 1 && 453 className !== "prevMonthDay" && 454 i % 7 === 6) { 455 self.weekNumbers.insertAdjacentHTML("beforeend", "<span class='flatpickr-day'>" + self.config.getWeek(date) + "</span>"); 456 } 457 triggerEvent("onDayCreate", dayElement); 458 return dayElement; 459 } 460 function focusOnDayElem(targetNode) { 461 targetNode.focus(); 462 if (self.config.mode === "range") 463 onMouseOver(targetNode); 464 } 465 function getFirstAvailableDay(delta) { 466 var startMonth = delta > 0 ? 0 : self.config.showMonths - 1; 467 var endMonth = delta > 0 ? self.config.showMonths : -1; 468 for (var m = startMonth; m != endMonth; m += delta) { 469 var month = self.daysContainer.children[m]; 470 var startIndex = delta > 0 ? 0 : month.children.length - 1; 471 var endIndex = delta > 0 ? month.children.length : -1; 472 for (var i = startIndex; i != endIndex; i += delta) { 473 var c = month.children[i]; 474 if (c.className.indexOf("hidden") === -1 && isEnabled(c.dateObj)) 475 return c; 476 } 477 } 478 return undefined; 479 } 480 function getNextAvailableDay(current, delta) { 481 var givenMonth = current.className.indexOf("Month") === -1 482 ? current.dateObj.getMonth() 483 : self.currentMonth; 484 var endMonth = delta > 0 ? self.config.showMonths : -1; 485 var loopDelta = delta > 0 ? 1 : -1; 486 for (var m = givenMonth - self.currentMonth; m != endMonth; m += loopDelta) { 487 var month = self.daysContainer.children[m]; 488 var startIndex = givenMonth - self.currentMonth === m 489 ? current.$i + delta 490 : delta < 0 491 ? month.children.length - 1 492 : 0; 493 var numMonthDays = month.children.length; 494 for (var i = startIndex; i >= 0 && i < numMonthDays && i != (delta > 0 ? numMonthDays : -1); i += loopDelta) { 495 var c = month.children[i]; 496 if (c.className.indexOf("hidden") === -1 && 497 isEnabled(c.dateObj) && 498 Math.abs(current.$i - i) >= Math.abs(delta)) 499 return focusOnDayElem(c); 500 } 501 } 502 self.changeMonth(loopDelta); 503 focusOnDay(getFirstAvailableDay(loopDelta), 0); 504 return undefined; 505 } 506 function focusOnDay(current, offset) { 507 var activeElement = getClosestActiveElement(); 508 var dayFocused = isInView(activeElement || document.body); 509 var startElem = current !== undefined 510 ? current 511 : dayFocused 512 ? activeElement 513 : self.selectedDateElem !== undefined && isInView(self.selectedDateElem) 514 ? self.selectedDateElem 515 : self.todayDateElem !== undefined && isInView(self.todayDateElem) 516 ? self.todayDateElem 517 : getFirstAvailableDay(offset > 0 ? 1 : -1); 518 if (startElem === undefined) { 519 self._input.focus(); 520 } 521 else if (!dayFocused) { 522 focusOnDayElem(startElem); 523 } 524 else { 525 getNextAvailableDay(startElem, offset); 526 } 527 } 528 function buildMonthDays(year, month) { 529 var firstOfMonth = (new Date(year, month, 1).getDay() - self.l10n.firstDayOfWeek + 7) % 7; 530 var prevMonthDays = self.utils.getDaysInMonth((month - 1 + 12) % 12, year); 531 var daysInMonth = self.utils.getDaysInMonth(month, year), days = window.document.createDocumentFragment(), isMultiMonth = self.config.showMonths > 1, prevMonthDayClass = isMultiMonth ? "prevMonthDay hidden" : "prevMonthDay", nextMonthDayClass = isMultiMonth ? "nextMonthDay hidden" : "nextMonthDay"; 532 var dayNumber = prevMonthDays + 1 - firstOfMonth, dayIndex = 0; 533 for (; dayNumber <= prevMonthDays; dayNumber++, dayIndex++) { 534 days.appendChild(createDay("flatpickr-day " + prevMonthDayClass, new Date(year, month - 1, dayNumber), dayNumber, dayIndex)); 535 } 536 for (dayNumber = 1; dayNumber <= daysInMonth; dayNumber++, dayIndex++) { 537 days.appendChild(createDay("flatpickr-day", new Date(year, month, dayNumber), dayNumber, dayIndex)); 538 } 539 for (var dayNum = daysInMonth + 1; dayNum <= 42 - firstOfMonth && 540 (self.config.showMonths === 1 || dayIndex % 7 !== 0); dayNum++, dayIndex++) { 541 days.appendChild(createDay("flatpickr-day " + nextMonthDayClass, new Date(year, month + 1, dayNum % daysInMonth), dayNum, dayIndex)); 542 } 543 var dayContainer = createElement("div", "dayContainer"); 544 dayContainer.appendChild(days); 545 return dayContainer; 546 } 547 function buildDays() { 548 if (self.daysContainer === undefined) { 549 return; 550 } 551 clearNode(self.daysContainer); 552 if (self.weekNumbers) 553 clearNode(self.weekNumbers); 554 var frag = document.createDocumentFragment(); 555 for (var i = 0; i < self.config.showMonths; i++) { 556 var d = new Date(self.currentYear, self.currentMonth, 1);
vendor: 7,528 bytes, lines 557-716
557 d.setMonth(self.currentMonth + i); 558 frag.appendChild(buildMonthDays(d.getFullYear(), d.getMonth())); 559 } 560 self.daysContainer.appendChild(frag); 561 self.days = self.daysContainer.firstChild; 562 if (self.config.mode === "range" && self.selectedDates.length === 1) { 563 onMouseOver(); 564 } 565 } 566 function buildMonthSwitch() { 567 if (self.config.showMonths > 1 || 568 self.config.monthSelectorType !== "dropdown") 569 return; 570 var shouldBuildMonth = function (month) { 571 if (self.config.minDate !== undefined && 572 self.currentYear === self.config.minDate.getFullYear() && 573 month < self.config.minDate.getMonth()) { 574 return false; 575 } 576 return !(self.config.maxDate !== undefined && 577 self.currentYear === self.config.maxDate.getFullYear() && 578 month > self.config.maxDate.getMonth()); 579 }; 580 self.monthsDropdownContainer.tabIndex = -1; 581 self.monthsDropdownContainer.innerHTML = ""; 582 for (var i = 0; i < 12; i++) { 583 if (!shouldBuildMonth(i)) 584 continue; 585 var month = createElement("option", "flatpickr-monthDropdown-month"); 586 month.value = new Date(self.currentYear, i).getMonth().toString(); 587 month.textContent = monthToStr(i, self.config.shorthandCurrentMonth, self.l10n); 588 month.tabIndex = -1; 589 if (self.currentMonth === i) { 590 month.selected = true; 591 } 592 self.monthsDropdownContainer.appendChild(month); 593 } 594 } 595 function buildMonth() { 596 var container = createElement("div", "flatpickr-month"); 597 var monthNavFragment = window.document.createDocumentFragment(); 598 var monthElement; 599 if (self.config.showMonths > 1 || 600 self.config.monthSelectorType === "static") { 601 monthElement = createElement("span", "cur-month"); 602 } 603 else { 604 self.monthsDropdownContainer = createElement("select", "flatpickr-monthDropdown-months"); 605 self.monthsDropdownContainer.setAttribute("aria-label", self.l10n.monthAriaLabel); 606 bind(self.monthsDropdownContainer, "change", function (e) { 607 var target = getEventTarget(e); 608 var selectedMonth = parseInt(target.value, 10); 609 self.changeMonth(selectedMonth - self.currentMonth); 610 triggerEvent("onMonthChange"); 611 }); 612 buildMonthSwitch(); 613 monthElement = self.monthsDropdownContainer; 614 } 615 var yearInput = createNumberInput("cur-year", { tabindex: "-1" }); 616 var yearElement = yearInput.getElementsByTagName("input")[0]; 617 yearElement.setAttribute("aria-label", self.l10n.yearAriaLabel); 618 if (self.config.minDate) { 619 yearElement.setAttribute("min", self.config.minDate.getFullYear().toString()); 620 } 621 if (self.config.maxDate) { 622 yearElement.setAttribute("max", self.config.maxDate.getFullYear().toString()); 623 yearElement.disabled = 624 !!self.config.minDate && 625 self.config.minDate.getFullYear() === self.config.maxDate.getFullYear(); 626 } 627 var currentMonth = createElement("div", "flatpickr-current-month"); 628 currentMonth.appendChild(monthElement); 629 currentMonth.appendChild(yearInput); 630 monthNavFragment.appendChild(currentMonth); 631 container.appendChild(monthNavFragment); 632 return { 633 container: container, 634 yearElement: yearElement, 635 monthElement: monthElement, 636 }; 637 } 638 function buildMonths() { 639 clearNode(self.monthNav); 640 self.monthNav.appendChild(self.prevMonthNav); 641 if (self.config.showMonths) { 642 self.yearElements = []; 643 self.monthElements = []; 644 } 645 for (var m = self.config.showMonths; m--;) { 646 var month = buildMonth(); 647 self.yearElements.push(month.yearElement); 648 self.monthElements.push(month.monthElement); 649 self.monthNav.appendChild(month.container); 650 } 651 self.monthNav.appendChild(self.nextMonthNav); 652 } 653 function buildMonthNav() { 654 self.monthNav = createElement("div", "flatpickr-months"); 655 self.yearElements = []; 656 self.monthElements = []; 657 self.prevMonthNav = createElement("span", "flatpickr-prev-month"); 658 self.prevMonthNav.innerHTML = self.config.prevArrow; 659 self.nextMonthNav = createElement("span", "flatpickr-next-month"); 660 self.nextMonthNav.innerHTML = self.config.nextArrow; 661 buildMonths(); 662 Object.defineProperty(self, "_hidePrevMonthArrow", { 663 get: function () { return self.__hidePrevMonthArrow; }, 664 set: function (bool) { 665 if (self.__hidePrevMonthArrow !== bool) { 666 toggleClass(self.prevMonthNav, "flatpickr-disabled", bool); 667 self.__hidePrevMonthArrow = bool; 668 } 669 }, 670 }); 671 Object.defineProperty(self, "_hideNextMonthArrow", { 672 get: function () { return self.__hideNextMonthArrow; }, 673 set: function (bool) { 674 if (self.__hideNextMonthArrow !== bool) { 675 toggleClass(self.nextMonthNav, "flatpickr-disabled", bool); 676 self.__hideNextMonthArrow = bool; 677 } 678 }, 679 }); 680 self.currentYearElement = self.yearElements[0]; 681 updateNavigationCurrentMonth(); 682 return self.monthNav; 683 } 684 function buildTime() { 685 self.calendarContainer.classList.add("hasTime"); 686 if (self.config.noCalendar) 687 self.calendarContainer.classList.add("noCalendar"); 688 var defaults = getDefaultHours(self.config); 689 self.timeContainer = createElement("div", "flatpickr-time"); 690 self.timeContainer.tabIndex = -1; 691 var separator = createElement("span", "flatpickr-time-separator", ":"); 692 var hourInput = createNumberInput("flatpickr-hour", { 693 "aria-label": self.l10n.hourAriaLabel, 694 }); 695 self.hourElement = hourInput.getElementsByTagName("input")[0]; 696 var minuteInput = createNumberInput("flatpickr-minute", { 697 "aria-label": self.l10n.minuteAriaLabel, 698 }); 699 self.minuteElement = minuteInput.getElementsByTagName("input")[0]; 700 self.hourElement.tabIndex = self.minuteElement.tabIndex = -1; 701 self.hourElement.value = pad(self.latestSelectedDateObj 702 ? self.latestSelectedDateObj.getHours() 703 : self.config.time_24hr 704 ? defaults.hours 705 : military2ampm(defaults.hours)); 706 self.minuteElement.value = pad(self.latestSelectedDateObj 707 ? self.latestSelectedDateObj.getMinutes() 708 : defaults.minutes); 709 self.hourElement.setAttribute("step", self.config.hourIncrement.toString()); 710 self.minuteElement.setAttribute("step", self.config.minuteIncrement.toString()); 711 self.hourElement.setAttribute("min", self.config.time_24hr ? "0" : "1"); 712 self.hourElement.setAttribute("max", self.config.time_24hr ? "23" : "12"); 713 self.hourElement.setAttribute("maxlength", "2"); 714 self.minuteElement.setAttribute("min", "0"); 715 self.minuteElement.setAttribute("max", "59"); 716 self.minuteElement.setAttribute("maxlength", "2");
vendor: 4,924 bytes, lines 717-822
717 self.timeContainer.appendChild(hourInput); 718 self.timeContainer.appendChild(separator); 719 self.timeContainer.appendChild(minuteInput); 720 if (self.config.time_24hr) 721 self.timeContainer.classList.add("time24hr"); 722 if (self.config.enableSeconds) { 723 self.timeContainer.classList.add("hasSeconds"); 724 var secondInput = createNumberInput("flatpickr-second"); 725 self.secondElement = secondInput.getElementsByTagName("input")[0]; 726 self.secondElement.value = pad(self.latestSelectedDateObj 727 ? self.latestSelectedDateObj.getSeconds() 728 : defaults.seconds); 729 self.secondElement.setAttribute("step", self.minuteElement.getAttribute("step")); 730 self.secondElement.setAttribute("min", "0"); 731 self.secondElement.setAttribute("max", "59"); 732 self.secondElement.setAttribute("maxlength", "2"); 733 self.timeContainer.appendChild(createElement("span", "flatpickr-time-separator", ":")); 734 self.timeContainer.appendChild(secondInput); 735 } 736 if (!self.config.time_24hr) { 737 self.amPM = createElement("span", "flatpickr-am-pm", self.l10n.amPM[int((self.latestSelectedDateObj 738 ? self.hourElement.value 739 : self.config.defaultHour) > 11)]); 740 self.amPM.title = self.l10n.toggleTitle; 741 self.amPM.tabIndex = -1; 742 self.timeContainer.appendChild(self.amPM); 743 } 744 return self.timeContainer; 745 } 746 function buildWeekdays() { 747 if (!self.weekdayContainer) 748 self.weekdayContainer = createElement("div", "flatpickr-weekdays"); 749 else 750 clearNode(self.weekdayContainer); 751 for (var i = self.config.showMonths; i--;) { 752 var container = createElement("div", "flatpickr-weekdaycontainer"); 753 self.weekdayContainer.appendChild(container); 754 } 755 updateWeekdays(); 756 return self.weekdayContainer; 757 } 758 function updateWeekdays() { 759 if (!self.weekdayContainer) { 760 return; 761 } 762 var firstDayOfWeek = self.l10n.firstDayOfWeek; 763 var weekdays = __spreadArrays(self.l10n.weekdays.shorthand); 764 if (firstDayOfWeek > 0 && firstDayOfWeek < weekdays.length) { 765 weekdays = __spreadArrays(weekdays.splice(firstDayOfWeek, weekdays.length), weekdays.splice(0, firstDayOfWeek)); 766 } 767 for (var i = self.config.showMonths; i--;) { 768 self.weekdayContainer.children[i].innerHTML = "\n <span class='flatpickr-weekday'>\n " + weekdays.join("</span><span class='flatpickr-weekday'>") + "\n </span>\n "; 769 } 770 } 771 function buildWeeks() { 772 self.calendarContainer.classList.add("hasWeeks"); 773 var weekWrapper = createElement("div", "flatpickr-weekwrapper"); 774 weekWrapper.appendChild(createElement("span", "flatpickr-weekday", self.l10n.weekAbbreviation)); 775 var weekNumbers = createElement("div", "flatpickr-weeks"); 776 weekWrapper.appendChild(weekNumbers); 777 return { 778 weekWrapper: weekWrapper, 779 weekNumbers: weekNumbers, 780 }; 781 } 782 function changeMonth(value, isOffset) { 783 if (isOffset === void 0) { isOffset = true; } 784 var delta = isOffset ? value : value - self.currentMonth; 785 if ((delta < 0 && self._hidePrevMonthArrow === true) || 786 (delta > 0 && self._hideNextMonthArrow === true)) 787 return; 788 self.currentMonth += delta; 789 if (self.currentMonth < 0 || self.currentMonth > 11) { 790 self.currentYear += self.currentMonth > 11 ? 1 : -1; 791 self.currentMonth = (self.currentMonth + 12) % 12; 792 triggerEvent("onYearChange"); 793 buildMonthSwitch(); 794 } 795 buildDays(); 796 triggerEvent("onMonthChange"); 797 updateNavigationCurrentMonth(); 798 } 799 function clear(triggerChangeEvent, toInitial) { 800 if (triggerChangeEvent === void 0) { triggerChangeEvent = true; } 801 if (toInitial === void 0) { toInitial = true; } 802 self.input.value = ""; 803 if (self.altInput !== undefined) 804 self.altInput.value = ""; 805 if (self.mobileInput !== undefined) 806 self.mobileInput.value = ""; 807 self.selectedDates = []; 808 self.latestSelectedDateObj = undefined; 809 if (toInitial === true) { 810 self.currentYear = self._initialDate.getFullYear(); 811 self.currentMonth = self._initialDate.getMonth(); 812 } 813 if (self.config.enableTime === true) { 814 var _a = getDefaultHours(self.config), hours = _a.hours, minutes = _a.minutes, seconds = _a.seconds; 815 setHours(hours, minutes, seconds); 816 } 817 self.redraw(); 818 if (triggerChangeEvent) 819 triggerEvent("onChange"); 820 } 821 function close() { 822 self.isOpen = false;
vendor: 6,159 bytes, lines 823-977
823 if (!self.isMobile) { 824 if (self.calendarContainer !== undefined) { 825 self.calendarContainer.classList.remove("open"); 826 } 827 if (self._input !== undefined) { 828 self._input.classList.remove("active"); 829 } 830 } 831 triggerEvent("onClose"); 832 } 833 function destroy() { 834 if (self.config !== undefined) 835 triggerEvent("onDestroy"); 836 for (var i = self._handlers.length; i--;) { 837 self._handlers[i].remove(); 838 } 839 self._handlers = []; 840 if (self.mobileInput) { 841 if (self.mobileInput.parentNode) 842 self.mobileInput.parentNode.removeChild(self.mobileInput); 843 self.mobileInput = undefined; 844 } 845 else if (self.calendarContainer && self.calendarContainer.parentNode) { 846 if (self.config.static && self.calendarContainer.parentNode) { 847 var wrapper = self.calendarContainer.parentNode; 848 wrapper.lastChild && wrapper.removeChild(wrapper.lastChild); 849 if (wrapper.parentNode) { 850 while (wrapper.firstChild) 851 wrapper.parentNode.insertBefore(wrapper.firstChild, wrapper); 852 wrapper.parentNode.removeChild(wrapper); 853 } 854 } 855 else 856 self.calendarContainer.parentNode.removeChild(self.calendarContainer); 857 } 858 if (self.altInput) { 859 self.input.type = "text"; 860 if (self.altInput.parentNode) 861 self.altInput.parentNode.removeChild(self.altInput); 862 delete self.altInput; 863 } 864 if (self.input) { 865 self.input.type = self.input._type; 866 self.input.classList.remove("flatpickr-input"); 867 self.input.removeAttribute("readonly"); 868 } 869 [ 870 "_showTimeInput", 871 "latestSelectedDateObj", 872 "_hideNextMonthArrow", 873 "_hidePrevMonthArrow", 874 "__hideNextMonthArrow", 875 "__hidePrevMonthArrow", 876 "isMobile", 877 "isOpen", 878 "selectedDateElem", 879 "minDateHasTime", 880 "maxDateHasTime", 881 "days", 882 "daysContainer", 883 "_input", 884 "_positionElement", 885 "innerContainer", 886 "rContainer", 887 "monthNav", 888 "todayDateElem", 889 "calendarContainer", 890 "weekdayContainer", 891 "prevMonthNav", 892 "nextMonthNav", 893 "monthsDropdownContainer", 894 "currentMonthElement", 895 "currentYearElement", 896 "navigationCurrentMonth", 897 "selectedDateElem", 898 "config", 899 ].forEach(function (k) { 900 try { 901 delete self[k]; 902 } 903 catch (_) { } 904 }); 905 } 906 function isCalendarElem(elem) { 907 return self.calendarContainer.contains(elem); 908 } 909 function documentClick(e) { 910 if (self.isOpen && !self.config.inline) { 911 var eventTarget_1 = getEventTarget(e); 912 var isCalendarElement = isCalendarElem(eventTarget_1); 913 var isInput = eventTarget_1 === self.input || 914 eventTarget_1 === self.altInput || 915 self.element.contains(eventTarget_1) || 916 (e.path && 917 e.path.indexOf && 918 (~e.path.indexOf(self.input) || 919 ~e.path.indexOf(self.altInput))); 920 var lostFocus = !isInput && 921 !isCalendarElement && 922 !isCalendarElem(e.relatedTarget); 923 var isIgnored = !self.config.ignoredFocusElements.some(function (elem) { 924 return elem.contains(eventTarget_1); 925 }); 926 if (lostFocus && isIgnored) { 927 if (self.config.allowInput) { 928 self.setDate(self._input.value, false, self.config.altInput 929 ? self.config.altFormat 930 : self.config.dateFormat); 931 } 932 if (self.timeContainer !== undefined && 933 self.minuteElement !== undefined && 934 self.hourElement !== undefined && 935 self.input.value !== "" && 936 self.input.value !== undefined) { 937 updateTime(); 938 } 939 self.close(); 940 if (self.config && 941 self.config.mode === "range" && 942 self.selectedDates.length === 1) 943 self.clear(false); 944 } 945 } 946 } 947 function changeYear(newYear) { 948 if (!newYear || 949 (self.config.minDate && newYear < self.config.minDate.getFullYear()) || 950 (self.config.maxDate && newYear > self.config.maxDate.getFullYear())) 951 return; 952 var newYearNum = newYear, isNewYear = self.currentYear !== newYearNum; 953 self.currentYear = newYearNum || self.currentYear; 954 if (self.config.maxDate && 955 self.currentYear === self.config.maxDate.getFullYear()) { 956 self.currentMonth = Math.min(self.config.maxDate.getMonth(), self.currentMonth); 957 } 958 else if (self.config.minDate && 959 self.currentYear === self.config.minDate.getFullYear()) { 960 self.currentMonth = Math.max(self.config.minDate.getMonth(), self.currentMonth); 961 } 962 if (isNewYear) { 963 self.redraw(); 964 triggerEvent("onYearChange"); 965 buildMonthSwitch(); 966 } 967 } 968 function isEnabled(date, timeless) { 969 var _a; 970 if (timeless === void 0) { timeless = true; } 971 var dateToCheck = self.parseDate(date, undefined, timeless); 972 if ((self.config.minDate && 973 dateToCheck && 974 compareDates(dateToCheck, self.config.minDate, timeless !== undefined ? timeless : !self.minDateHasTime) < 0) || 975 (self.config.maxDate && 976 dateToCheck && 977 compareDates(dateToCheck, self.config.maxDate, timeless !== undefined ? timeless : !self.maxDateHasTime) >
vendor: 7,428 bytes, lines 977-1154
977 0)) 978 return false; 979 if (!self.config.enable && self.config.disable.length === 0) 980 return true; 981 if (dateToCheck === undefined) 982 return false; 983 var bool = !!self.config.enable, array = (_a = self.config.enable) !== null && _a !== void 0 ? _a : self.config.disable; 984 for (var i = 0, d = void 0; i < array.length; i++) { 985 d = array[i]; 986 if (typeof d === "function" && 987 d(dateToCheck)) 988 return bool; 989 else if (d instanceof Date && 990 dateToCheck !== undefined && 991 d.getTime() === dateToCheck.getTime()) 992 return bool; 993 else if (typeof d === "string") { 994 var parsed = self.parseDate(d, undefined, true); 995 return parsed && parsed.getTime() === dateToCheck.getTime() 996 ? bool 997 : !bool; 998 } 999 else if (typeof d === "object" && 1000 dateToCheck !== undefined && 1001 d.from && 1002 d.to && 1003 dateToCheck.getTime() >= d.from.getTime() && 1004 dateToCheck.getTime() <= d.to.getTime()) 1005 return bool; 1006 } 1007 return !bool; 1008 } 1009 function isInView(elem) { 1010 if (self.daysContainer !== undefined) 1011 return (elem.className.indexOf("hidden") === -1 && 1012 elem.className.indexOf("flatpickr-disabled") === -1 && 1013 self.daysContainer.contains(elem)); 1014 return false; 1015 } 1016 function onBlur(e) { 1017 var isInput = e.target === self._input; 1018 var valueChanged = self._input.value.trimEnd() !== getDateStr(); 1019 if (isInput && 1020 valueChanged && 1021 !(e.relatedTarget && isCalendarElem(e.relatedTarget))) { 1022 self.setDate(self._input.value, true, e.target === self.altInput 1023 ? self.config.altFormat 1024 : self.config.dateFormat); 1025 } 1026 } 1027 function onKeyDown(e) { 1028 var eventTarget = getEventTarget(e); 1029 var isInput = self.config.wrap 1030 ? element.contains(eventTarget) 1031 : eventTarget === self._input; 1032 var allowInput = self.config.allowInput; 1033 var allowKeydown = self.isOpen && (!allowInput || !isInput); 1034 var allowInlineKeydown = self.config.inline && isInput && !allowInput; 1035 if (e.keyCode === 13 && isInput) { 1036 if (allowInput) { 1037 self.setDate(self._input.value, true, eventTarget === self.altInput 1038 ? self.config.altFormat 1039 : self.config.dateFormat); 1040 self.close(); 1041 return eventTarget.blur(); 1042 } 1043 else { 1044 self.open(); 1045 } 1046 } 1047 else if (isCalendarElem(eventTarget) || 1048 allowKeydown || 1049 allowInlineKeydown) { 1050 var isTimeObj = !!self.timeContainer && 1051 self.timeContainer.contains(eventTarget); 1052 switch (e.keyCode) { 1053 case 13: 1054 if (isTimeObj) { 1055 e.preventDefault(); 1056 updateTime(); 1057 focusAndClose(); 1058 } 1059 else 1060 selectDate(e); 1061 break; 1062 case 27: 1063 e.preventDefault(); 1064 focusAndClose(); 1065 break; 1066 case 8: 1067 case 46: 1068 if (isInput && !self.config.allowInput) { 1069 e.preventDefault(); 1070 self.clear(); 1071 } 1072 break; 1073 case 37: 1074 case 39: 1075 if (!isTimeObj && !isInput) { 1076 e.preventDefault(); 1077 var activeElement = getClosestActiveElement(); 1078 if (self.daysContainer !== undefined && 1079 (allowInput === false || 1080 (activeElement && isInView(activeElement)))) { 1081 var delta_1 = e.keyCode === 39 ? 1 : -1; 1082 if (!e.ctrlKey) 1083 focusOnDay(undefined, delta_1); 1084 else { 1085 e.stopPropagation(); 1086 changeMonth(delta_1); 1087 focusOnDay(getFirstAvailableDay(1), 0); 1088 } 1089 } 1090 } 1091 else if (self.hourElement) 1092 self.hourElement.focus(); 1093 break; 1094 case 38: 1095 case 40: 1096 e.preventDefault(); 1097 var delta = e.keyCode === 40 ? 1 : -1; 1098 if ((self.daysContainer && 1099 eventTarget.$i !== undefined) || 1100 eventTarget === self.input || 1101 eventTarget === self.altInput) { 1102 if (e.ctrlKey) { 1103 e.stopPropagation(); 1104 changeYear(self.currentYear - delta); 1105 focusOnDay(getFirstAvailableDay(1), 0); 1106 } 1107 else if (!isTimeObj) 1108 focusOnDay(undefined, delta * 7); 1109 } 1110 else if (eventTarget === self.currentYearElement) { 1111 changeYear(self.currentYear - delta); 1112 } 1113 else if (self.config.enableTime) { 1114 if (!isTimeObj && self.hourElement) 1115 self.hourElement.focus(); 1116 updateTime(e); 1117 self._debouncedChange(); 1118 } 1119 break; 1120 case 9: 1121 if (isTimeObj) { 1122 var elems = [ 1123 self.hourElement, 1124 self.minuteElement, 1125 self.secondElement, 1126 self.amPM, 1127 ] 1128 .concat(self.pluginElements) 1129 .filter(function (x) { return x; }); 1130 var i = elems.indexOf(eventTarget); 1131 if (i !== -1) { 1132 var target = elems[i + (e.shiftKey ? -1 : 1)]; 1133 e.preventDefault(); 1134 (target || self._input).focus(); 1135 } 1136 } 1137 else if (!self.config.noCalendar && 1138 self.daysContainer && 1139 self.daysContainer.contains(eventTarget) && 1140 e.shiftKey) { 1141 e.preventDefault(); 1142 self._input.focus(); 1143 } 1144 break; 1145 default: 1146 break; 1147 } 1148 } 1149 if (self.amPM !== undefined && eventTarget === self.amPM) { 1150 switch (e.key) { 1151 case self.l10n.amPM[0].charAt(0): 1152 case self.l10n.amPM[0].charAt(0).toLowerCase(): 1153 self.amPM.textContent = self.l10n.amPM[0]; 1154 setHoursFromInputs();
vendor: 5,586 bytes, lines 1155-1277
1155 updateValue(); 1156 break; 1157 case self.l10n.amPM[1].charAt(0): 1158 case self.l10n.amPM[1].charAt(0).toLowerCase(): 1159 self.amPM.textContent = self.l10n.amPM[1]; 1160 setHoursFromInputs(); 1161 updateValue(); 1162 break; 1163 } 1164 } 1165 if (isInput || isCalendarElem(eventTarget)) { 1166 triggerEvent("onKeyDown", e); 1167 } 1168 } 1169 function onMouseOver(elem, cellClass) { 1170 if (cellClass === void 0) { cellClass = "flatpickr-day"; } 1171 if (self.selectedDates.length !== 1 || 1172 (elem && 1173 (!elem.classList.contains(cellClass) || 1174 elem.classList.contains("flatpickr-disabled")))) 1175 return; 1176 var hoverDate = elem 1177 ? elem.dateObj.getTime() 1178 : self.days.firstElementChild.dateObj.getTime(), initialDate = self.parseDate(self.selectedDates[0], undefined, true).getTime(), rangeStartDate = Math.min(hoverDate, self.selectedDates[0].getTime()), rangeEndDate = Math.max(hoverDate, self.selectedDates[0].getTime()); 1179 var containsDisabled = false; 1180 var minRange = 0, maxRange = 0; 1181 for (var t = rangeStartDate; t < rangeEndDate; t += duration.DAY) { 1182 if (!isEnabled(new Date(t), true)) { 1183 containsDisabled = 1184 containsDisabled || (t > rangeStartDate && t < rangeEndDate); 1185 if (t < initialDate && (!minRange || t > minRange)) 1186 minRange = t; 1187 else if (t > initialDate && (!maxRange || t < maxRange)) 1188 maxRange = t; 1189 } 1190 } 1191 var hoverableCells = Array.from(self.rContainer.querySelectorAll("*:nth-child(-n+" + self.config.showMonths + ") > ." + cellClass)); 1192 hoverableCells.forEach(function (dayElem) { 1193 var date = dayElem.dateObj; 1194 var timestamp = date.getTime(); 1195 var outOfRange = (minRange > 0 && timestamp < minRange) || 1196 (maxRange > 0 && timestamp > maxRange); 1197 if (outOfRange) { 1198 dayElem.classList.add("notAllowed"); 1199 ["inRange", "startRange", "endRange"].forEach(function (c) { 1200 dayElem.classList.remove(c); 1201 }); 1202 return; 1203 } 1204 else if (containsDisabled && !outOfRange) 1205 return; 1206 ["startRange", "inRange", "endRange", "notAllowed"].forEach(function (c) { 1207 dayElem.classList.remove(c); 1208 }); 1209 if (elem !== undefined) { 1210 elem.classList.add(hoverDate <= self.selectedDates[0].getTime() 1211 ? "startRange" 1212 : "endRange"); 1213 if (initialDate < hoverDate && timestamp === initialDate) 1214 dayElem.classList.add("startRange"); 1215 else if (initialDate > hoverDate && timestamp === initialDate) 1216 dayElem.classList.add("endRange"); 1217 if (timestamp >= minRange && 1218 (maxRange === 0 || timestamp <= maxRange) && 1219 isBetween(timestamp, initialDate, hoverDate)) 1220 dayElem.classList.add("inRange"); 1221 } 1222 }); 1223 } 1224 function onResize() { 1225 if (self.isOpen && !self.config.static && !self.config.inline) 1226 positionCalendar(); 1227 } 1228 function open(e, positionElement) { 1229 if (positionElement === void 0) { positionElement = self._positionElement; } 1230 if (self.isMobile === true) { 1231 if (e) { 1232 e.preventDefault(); 1233 var eventTarget = getEventTarget(e); 1234 if (eventTarget) { 1235 eventTarget.blur(); 1236 } 1237 } 1238 if (self.mobileInput !== undefined) { 1239 self.mobileInput.focus(); 1240 self.mobileInput.click(); 1241 } 1242 triggerEvent("onOpen"); 1243 return; 1244 } 1245 else if (self._input.disabled || self.config.inline) { 1246 return; 1247 } 1248 var wasOpen = self.isOpen; 1249 self.isOpen = true; 1250 if (!wasOpen) { 1251 self.calendarContainer.classList.add("open"); 1252 self._input.classList.add("active"); 1253 triggerEvent("onOpen"); 1254 positionCalendar(positionElement); 1255 } 1256 if (self.config.enableTime === true && self.config.noCalendar === true) { 1257 if (self.config.allowInput === false && 1258 (e === undefined || 1259 !self.timeContainer.contains(e.relatedTarget))) { 1260 setTimeout(function () { return self.hourElement.select(); }, 50); 1261 } 1262 } 1263 } 1264 function minMaxDateSetter(type) { 1265 return function (date) { 1266 var dateObj = (self.config["_" + type + "Date"] = self.parseDate(date, self.config.dateFormat)); 1267 var inverseDateObj = self.config["_" + (type === "min" ? "max" : "min") + "Date"]; 1268 if (dateObj !== undefined) { 1269 self[type === "min" ? "minDateHasTime" : "maxDateHasTime"] = 1270 dateObj.getHours() > 0 || 1271 dateObj.getMinutes() > 0 || 1272 dateObj.getSeconds() > 0; 1273 } 1274 if (self.selectedDates) { 1275 self.selectedDates = self.selectedDates.filter(function (d) { return isEnabled(d); }); 1276 if (!self.selectedDates.length && type === "min") 1277 setHoursFromDate(dateObj);
vendor: 2,611 bytes, lines 1278-1340
1278 updateValue(); 1279 } 1280 if (self.daysContainer) { 1281 redraw(); 1282 if (dateObj !== undefined) 1283 self.currentYearElement[type] = dateObj.getFullYear().toString(); 1284 else 1285 self.currentYearElement.removeAttribute(type); 1286 self.currentYearElement.disabled = 1287 !!inverseDateObj && 1288 dateObj !== undefined && 1289 inverseDateObj.getFullYear() === dateObj.getFullYear(); 1290 } 1291 }; 1292 } 1293 function parseConfig() { 1294 var boolOpts = [ 1295 "wrap", 1296 "weekNumbers", 1297 "allowInput", 1298 "allowInvalidPreload", 1299 "clickOpens", 1300 "time_24hr", 1301 "enableTime", 1302 "noCalendar", 1303 "altInput", 1304 "shorthandCurrentMonth", 1305 "inline", 1306 "static", 1307 "enableSeconds", 1308 "disableMobile", 1309 ]; 1310 var userConfig = __assign(__assign({}, JSON.parse(JSON.stringify(element.dataset || {}))), instanceConfig); 1311 var formats = {}; 1312 self.config.parseDate = userConfig.parseDate; 1313 self.config.formatDate = userConfig.formatDate; 1314 Object.defineProperty(self.config, "enable", { 1315 get: function () { return self.config._enable; }, 1316 set: function (dates) { 1317 self.config._enable = parseDateRules(dates); 1318 }, 1319 }); 1320 Object.defineProperty(self.config, "disable", { 1321 get: function () { return self.config._disable; }, 1322 set: function (dates) { 1323 self.config._disable = parseDateRules(dates); 1324 }, 1325 }); 1326 var timeMode = userConfig.mode === "time"; 1327 if (!userConfig.dateFormat && (userConfig.enableTime || timeMode)) { 1328 var defaultDateFormat = flatpickr.defaultConfig.dateFormat || defaultOptions.dateFormat; 1329 formats.dateFormat = 1330 userConfig.noCalendar || timeMode 1331 ? "H:i" + (userConfig.enableSeconds ? ":S" : "") 1332 : defaultDateFormat + " H:i" + (userConfig.enableSeconds ? ":S" : ""); 1333 } 1334 if (userConfig.altInput && 1335 (userConfig.enableTime || timeMode) && 1336 !userConfig.altFormat) { 1337 var defaultAltFormat = flatpickr.defaultConfig.altFormat || defaultOptions.altFormat; 1338 formats.altFormat = 1339 userConfig.noCalendar || timeMode 1340 ? "h:i" + (userConfig.enableSeconds ? ":S K" : " K")
vendor: 5,789 bytes, lines 1341-1447
1341 : defaultAltFormat + (" h:i" + (userConfig.enableSeconds ? ":S" : "") + " K"); 1342 } 1343 Object.defineProperty(self.config, "minDate", { 1344 get: function () { return self.config._minDate; }, 1345 set: minMaxDateSetter("min"), 1346 }); 1347 Object.defineProperty(self.config, "maxDate", { 1348 get: function () { return self.config._maxDate; }, 1349 set: minMaxDateSetter("max"), 1350 }); 1351 var minMaxTimeSetter = function (type) { return function (val) { 1352 self.config[type === "min" ? "_minTime" : "_maxTime"] = self.parseDate(val, "H:i:S"); 1353 }; }; 1354 Object.defineProperty(self.config, "minTime", { 1355 get: function () { return self.config._minTime; }, 1356 set: minMaxTimeSetter("min"), 1357 }); 1358 Object.defineProperty(self.config, "maxTime", { 1359 get: function () { return self.config._maxTime; }, 1360 set: minMaxTimeSetter("max"), 1361 }); 1362 if (userConfig.mode === "time") { 1363 self.config.noCalendar = true; 1364 self.config.enableTime = true; 1365 } 1366 Object.assign(self.config, formats, userConfig); 1367 for (var i = 0; i < boolOpts.length; i++) 1368 self.config[boolOpts[i]] = 1369 self.config[boolOpts[i]] === true || 1370 self.config[boolOpts[i]] === "true"; 1371 HOOKS.filter(function (hook) { return self.config[hook] !== undefined; }).forEach(function (hook) { 1372 self.config[hook] = arrayify(self.config[hook] || []).map(bindToInstance); 1373 }); 1374 self.isMobile = 1375 !self.config.disableMobile && 1376 !self.config.inline && 1377 self.config.mode === "single" && 1378 !self.config.disable.length && 1379 !self.config.enable && 1380 !self.config.weekNumbers && 1381 /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent); 1382 for (var i = 0; i < self.config.plugins.length; i++) { 1383 var pluginConf = self.config.plugins[i](self) || {}; 1384 for (var key in pluginConf) { 1385 if (HOOKS.indexOf(key) > -1) { 1386 self.config[key] = arrayify(pluginConf[key]) 1387 .map(bindToInstance) 1388 .concat(self.config[key]); 1389 } 1390 else if (typeof userConfig[key] === "undefined") 1391 self.config[key] = pluginConf[key]; 1392 } 1393 } 1394 if (!userConfig.altInputClass) { 1395 self.config.altInputClass = 1396 getInputElem().className + " " + self.config.altInputClass; 1397 } 1398 triggerEvent("onParseConfig"); 1399 } 1400 function getInputElem() { 1401 return self.config.wrap 1402 ? element.querySelector("[data-input]") 1403 : element; 1404 } 1405 function setupLocale() { 1406 if (typeof self.config.locale !== "object" && 1407 typeof flatpickr.l10ns[self.config.locale] === "undefined") 1408 self.config.errorHandler(new Error("flatpickr: invalid locale " + self.config.locale)); 1409 self.l10n = __assign(__assign({}, flatpickr.l10ns.default), (typeof self.config.locale === "object" 1410 ? self.config.locale 1411 : self.config.locale !== "default" 1412 ? flatpickr.l10ns[self.config.locale] 1413 : undefined)); 1414 tokenRegex.D = "(" + self.l10n.weekdays.shorthand.join("|") + ")"; 1415 tokenRegex.l = "(" + self.l10n.weekdays.longhand.join("|") + ")"; 1416 tokenRegex.M = "(" + self.l10n.months.shorthand.join("|") + ")"; 1417 tokenRegex.F = "(" + self.l10n.months.longhand.join("|") + ")"; 1418 tokenRegex.K = "(" + self.l10n.amPM[0] + "|" + self.l10n.amPM[1] + "|" + self.l10n.amPM[0].toLowerCase() + "|" + self.l10n.amPM[1].toLowerCase() + ")"; 1419 var userConfig = __assign(__assign({}, instanceConfig), JSON.parse(JSON.stringify(element.dataset || {}))); 1420 if (userConfig.time_24hr === undefined && 1421 flatpickr.defaultConfig.time_24hr === undefined) { 1422 self.config.time_24hr = self.l10n.time_24hr; 1423 } 1424 self.formatDate = createDateFormatter(self); 1425 self.parseDate = createDateParser({ config: self.config, l10n: self.l10n }); 1426 } 1427 function positionCalendar(customPositionElement) { 1428 if (typeof self.config.position === "function") { 1429 return void self.config.position(self, customPositionElement); 1430 } 1431 if (self.calendarContainer === undefined) 1432 return; 1433 triggerEvent("onPreCalendarPosition"); 1434 var positionElement = customPositionElement || self._positionElement; 1435 var calendarHeight = Array.prototype.reduce.call(self.calendarContainer.children, (function (acc, child) { return acc + child.offsetHeight; }), 0), calendarWidth = self.calendarContainer.offsetWidth, configPos = self.config.position.split(" "), configPosVertical = configPos[0], configPosHorizontal = configPos.length > 1 ? configPos[1] : null, inputBounds = positionElement.getBoundingClientRect(), distanceFromBottom = window.innerHeight - inputBounds.bottom, showOnTop = configPosVertical === "above" || 1436 (configPosVertical !== "below" && 1437 distanceFromBottom < calendarHeight && 1438 inputBounds.top > calendarHeight); 1439 var top = window.pageYOffset + 1440 inputBounds.top + 1441 (!showOnTop ? positionElement.offsetHeight + 2 : -calendarHeight - 2); 1442 toggleClass(self.calendarContainer, "arrowTop", !showOnTop); 1443 toggleClass(self.calendarContainer, "arrowBottom", showOnTop); 1444 if (self.config.inline) 1445 return; 1446 var left = window.pageXOffset + inputBounds.left; 1447 var isCenter = false;
vendor: 5,549 bytes, lines 1448-1581
1448 var isRight = false; 1449 if (configPosHorizontal === "center") { 1450 left -= (calendarWidth - inputBounds.width) / 2; 1451 isCenter = true; 1452 } 1453 else if (configPosHorizontal === "right") { 1454 left -= calendarWidth - inputBounds.width; 1455 isRight = true; 1456 } 1457 toggleClass(self.calendarContainer, "arrowLeft", !isCenter && !isRight); 1458 toggleClass(self.calendarContainer, "arrowCenter", isCenter); 1459 toggleClass(self.calendarContainer, "arrowRight", isRight); 1460 var right = window.document.body.offsetWidth - 1461 (window.pageXOffset + inputBounds.right); 1462 var rightMost = left + calendarWidth > window.document.body.offsetWidth; 1463 var centerMost = right + calendarWidth > window.document.body.offsetWidth; 1464 toggleClass(self.calendarContainer, "rightMost", rightMost); 1465 if (self.config.static) 1466 return; 1467 self.calendarContainer.style.top = top + "px"; 1468 if (!rightMost) { 1469 self.calendarContainer.style.left = left + "px"; 1470 self.calendarContainer.style.right = "auto"; 1471 } 1472 else if (!centerMost) { 1473 self.calendarContainer.style.left = "auto"; 1474 self.calendarContainer.style.right = right + "px"; 1475 } 1476 else { 1477 var doc = getDocumentStyleSheet(); 1478 if (doc === undefined) 1479 return; 1480 var bodyWidth = window.document.body.offsetWidth; 1481 var centerLeft = Math.max(0, bodyWidth / 2 - calendarWidth / 2); 1482 var centerBefore = ".flatpickr-calendar.centerMost:before"; 1483 var centerAfter = ".flatpickr-calendar.centerMost:after"; 1484 var centerIndex = doc.cssRules.length; 1485 var centerStyle = "{left:" + inputBounds.left + "px;right:auto;}"; 1486 toggleClass(self.calendarContainer, "rightMost", false); 1487 toggleClass(self.calendarContainer, "centerMost", true); 1488 doc.insertRule(centerBefore + "," + centerAfter + centerStyle, centerIndex); 1489 self.calendarContainer.style.left = centerLeft + "px"; 1490 self.calendarContainer.style.right = "auto"; 1491 } 1492 } 1493 function getDocumentStyleSheet() { 1494 var editableSheet = null; 1495 for (var i = 0; i < document.styleSheets.length; i++) { 1496 var sheet = document.styleSheets[i]; 1497 if (!sheet.cssRules) 1498 continue; 1499 try { 1500 sheet.cssRules; 1501 } 1502 catch (err) { 1503 continue; 1504 } 1505 editableSheet = sheet; 1506 break; 1507 } 1508 return editableSheet != null ? editableSheet : createStyleSheet(); 1509 } 1510 function createStyleSheet() { 1511 var style = document.createElement("style"); 1512 document.head.appendChild(style); 1513 return style.sheet; 1514 } 1515 function redraw() { 1516 if (self.config.noCalendar || self.isMobile) 1517 return; 1518 buildMonthSwitch(); 1519 updateNavigationCurrentMonth(); 1520 buildDays(); 1521 } 1522 function focusAndClose() { 1523 self._input.focus(); 1524 if (window.navigator.userAgent.indexOf("MSIE") !== -1 || 1525 navigator.msMaxTouchPoints !== undefined) { 1526 setTimeout(self.close, 0); 1527 } 1528 else { 1529 self.close(); 1530 } 1531 } 1532 function selectDate(e) { 1533 e.preventDefault(); 1534 e.stopPropagation(); 1535 var isSelectable = function (day) { 1536 return day.classList && 1537 day.classList.contains("flatpickr-day") && 1538 !day.classList.contains("flatpickr-disabled") && 1539 !day.classList.contains("notAllowed"); 1540 }; 1541 var t = findParent(getEventTarget(e), isSelectable); 1542 if (t === undefined) 1543 return; 1544 var target = t; 1545 var selectedDate = (self.latestSelectedDateObj = new Date(target.dateObj.getTime())); 1546 var shouldChangeMonth = (selectedDate.getMonth() < self.currentMonth || 1547 selectedDate.getMonth() > 1548 self.currentMonth + self.config.showMonths - 1) && 1549 self.config.mode !== "range"; 1550 self.selectedDateElem = target; 1551 if (self.config.mode === "single") 1552 self.selectedDates = [selectedDate]; 1553 else if (self.config.mode === "multiple") { 1554 var selectedIndex = isDateSelected(selectedDate); 1555 if (selectedIndex) 1556 self.selectedDates.splice(parseInt(selectedIndex), 1); 1557 else 1558 self.selectedDates.push(selectedDate); 1559 } 1560 else if (self.config.mode === "range") { 1561 if (self.selectedDates.length === 2) { 1562 self.clear(false, false); 1563 } 1564 self.latestSelectedDateObj = selectedDate; 1565 self.selectedDates.push(selectedDate); 1566 if (compareDates(selectedDate, self.selectedDates[0], true) !== 0) 1567 self.selectedDates.sort(function (a, b) { return a.getTime() - b.getTime(); }); 1568 } 1569 setHoursFromInputs(); 1570 if (shouldChangeMonth) { 1571 var isNewYear = self.currentYear !== selectedDate.getFullYear(); 1572 self.currentYear = selectedDate.getFullYear(); 1573 self.currentMonth = selectedDate.getMonth(); 1574 if (isNewYear) { 1575 triggerEvent("onYearChange"); 1576 buildMonthSwitch(); 1577 } 1578 triggerEvent("onMonthChange"); 1579 } 1580 updateNavigationCurrentMonth(); 1581 buildDays();
vendor: 1,222 bytes, lines 1582-1612
1582 updateValue(); 1583 if (!shouldChangeMonth && 1584 self.config.mode !== "range" && 1585 self.config.showMonths === 1) 1586 focusOnDayElem(target); 1587 else if (self.selectedDateElem !== undefined && 1588 self.hourElement === undefined) { 1589 self.selectedDateElem && self.selectedDateElem.focus(); 1590 } 1591 if (self.hourElement !== undefined) 1592 self.hourElement !== undefined && self.hourElement.focus(); 1593 if (self.config.closeOnSelect) { 1594 var single = self.config.mode === "single" && !self.config.enableTime; 1595 var range = self.config.mode === "range" && 1596 self.selectedDates.length === 2 && 1597 !self.config.enableTime; 1598 if (single || range) { 1599 focusAndClose(); 1600 } 1601 } 1602 triggerChange(); 1603 } 1604 var CALLBACKS = { 1605 locale: [setupLocale, updateWeekdays], 1606 showMonths: [buildMonths, setCalendarWidth, buildWeekdays], 1607 minDate: [jumpToDate], 1608 maxDate: [jumpToDate], 1609 positionElement: [updatePositionElement], 1610 clickOpens: [ 1611 function () { 1612 if (self.config.clickOpens === true) {
vendor: 18,169 bytes, lines 1613-2046
1613 bind(self._input, "focus", self.open); 1614 bind(self._input, "click", self.open); 1615 } 1616 else { 1617 self._input.removeEventListener("focus", self.open); 1618 self._input.removeEventListener("click", self.open); 1619 } 1620 }, 1621 ], 1622 }; 1623 function set(option, value) { 1624 if (option !== null && typeof option === "object") { 1625 Object.assign(self.config, option); 1626 for (var key in option) { 1627 if (CALLBACKS[key] !== undefined) 1628 CALLBACKS[key].forEach(function (x) { return x(); }); 1629 } 1630 } 1631 else { 1632 self.config[option] = value; 1633 if (CALLBACKS[option] !== undefined) 1634 CALLBACKS[option].forEach(function (x) { return x(); }); 1635 else if (HOOKS.indexOf(option) > -1) 1636 self.config[option] = arrayify(value); 1637 } 1638 self.redraw(); 1639 updateValue(true); 1640 } 1641 function setSelectedDate(inputDate, format) { 1642 var dates = []; 1643 if (inputDate instanceof Array) 1644 dates = inputDate.map(function (d) { return self.parseDate(d, format); }); 1645 else if (inputDate instanceof Date || typeof inputDate === "number") 1646 dates = [self.parseDate(inputDate, format)]; 1647 else if (typeof inputDate === "string") { 1648 switch (self.config.mode) { 1649 case "single": 1650 case "time": 1651 dates = [self.parseDate(inputDate, format)]; 1652 break; 1653 case "multiple": 1654 dates = inputDate 1655 .split(self.config.conjunction) 1656 .map(function (date) { return self.parseDate(date, format); }); 1657 break; 1658 case "range": 1659 dates = inputDate 1660 .split(self.l10n.rangeSeparator) 1661 .map(function (date) { return self.parseDate(date, format); }); 1662 break; 1663 default: 1664 break; 1665 } 1666 } 1667 else 1668 self.config.errorHandler(new Error("Invalid date supplied: " + JSON.stringify(inputDate))); 1669 self.selectedDates = (self.config.allowInvalidPreload 1670 ? dates 1671 : dates.filter(function (d) { return d instanceof Date && isEnabled(d, false); })); 1672 if (self.config.mode === "range") 1673 self.selectedDates.sort(function (a, b) { return a.getTime() - b.getTime(); }); 1674 } 1675 function setDate(date, triggerChange, format) { 1676 if (triggerChange === void 0) { triggerChange = false; } 1677 if (format === void 0) { format = self.config.dateFormat; } 1678 if ((date !== 0 && !date) || (date instanceof Array && date.length === 0)) 1679 return self.clear(triggerChange); 1680 setSelectedDate(date, format); 1681 self.latestSelectedDateObj = 1682 self.selectedDates[self.selectedDates.length - 1]; 1683 self.redraw(); 1684 jumpToDate(undefined, triggerChange); 1685 setHoursFromDate(); 1686 if (self.selectedDates.length === 0) { 1687 self.clear(false); 1688 } 1689 updateValue(triggerChange); 1690 if (triggerChange) 1691 triggerEvent("onChange"); 1692 } 1693 function parseDateRules(arr) { 1694 return arr 1695 .slice() 1696 .map(function (rule) { 1697 if (typeof rule === "string" || 1698 typeof rule === "number" || 1699 rule instanceof Date) { 1700 return self.parseDate(rule, undefined, true); 1701 } 1702 else if (rule && 1703 typeof rule === "object" && 1704 rule.from && 1705 rule.to) 1706 return { 1707 from: self.parseDate(rule.from, undefined), 1708 to: self.parseDate(rule.to, undefined), 1709 }; 1710 return rule; 1711 }) 1712 .filter(function (x) { return x; }); 1713 } 1714 function setupDates() { 1715 self.selectedDates = []; 1716 self.now = self.parseDate(self.config.now) || new Date(); 1717 var preloadedDate = self.config.defaultDate || 1718 ((self.input.nodeName === "INPUT" || 1719 self.input.nodeName === "TEXTAREA") && 1720 self.input.placeholder && 1721 self.input.value === self.input.placeholder 1722 ? null 1723 : self.input.value); 1724 if (preloadedDate) 1725 setSelectedDate(preloadedDate, self.config.dateFormat); 1726 self._initialDate = 1727 self.selectedDates.length > 0 1728 ? self.selectedDates[0] 1729 : self.config.minDate && 1730 self.config.minDate.getTime() > self.now.getTime() 1731 ? self.config.minDate 1732 : self.config.maxDate && 1733 self.config.maxDate.getTime() < self.now.getTime() 1734 ? self.config.maxDate 1735 : self.now; 1736 self.currentYear = self._initialDate.getFullYear(); 1737 self.currentMonth = self._initialDate.getMonth(); 1738 if (self.selectedDates.length > 0) 1739 self.latestSelectedDateObj = self.selectedDates[0]; 1740 if (self.config.minTime !== undefined) 1741 self.config.minTime = self.parseDate(self.config.minTime, "H:i"); 1742 if (self.config.maxTime !== undefined) 1743 self.config.maxTime = self.parseDate(self.config.maxTime, "H:i"); 1744 self.minDateHasTime = 1745 !!self.config.minDate && 1746 (self.config.minDate.getHours() > 0 || 1747 self.config.minDate.getMinutes() > 0 || 1748 self.config.minDate.getSeconds() > 0); 1749 self.maxDateHasTime = 1750 !!self.config.maxDate && 1751 (self.config.maxDate.getHours() > 0 || 1752 self.config.maxDate.getMinutes() > 0 || 1753 self.config.maxDate.getSeconds() > 0); 1754 } 1755 function setupInputs() { 1756 self.input = getInputElem(); 1757 if (!self.input) { 1758 self.config.errorHandler(new Error("Invalid input element specified")); 1759 return; 1760 } 1761 self.input._type = self.input.type; 1762 self.input.type = "text"; 1763 self.input.classList.add("flatpickr-input"); 1764 self._input = self.input; 1765 if (self.config.altInput) { 1766 self.altInput = createElement(self.input.nodeName, self.config.altInputClass); 1767 self._input = self.altInput; 1768 self.altInput.placeholder = self.input.placeholder; 1769 self.altInput.disabled = self.input.disabled; 1770 self.altInput.required = self.input.required; 1771 self.altInput.tabIndex = self.input.tabIndex; 1772 self.altInput.type = "text"; 1773 self.input.setAttribute("type", "hidden"); 1774 if (!self.config.static && self.input.parentNode) 1775 self.input.parentNode.insertBefore(self.altInput, self.input.nextSibling); 1776 } 1777 if (!self.config.allowInput) 1778 self._input.setAttribute("readonly", "readonly"); 1779 updatePositionElement(); 1780 } 1781 function updatePositionElement() { 1782 self._positionElement = self.config.positionElement || self._input; 1783 } 1784 function setupMobile() { 1785 var inputType = self.config.enableTime 1786 ? self.config.noCalendar 1787 ? "time" 1788 : "datetime-local" 1789 : "date"; 1790 self.mobileInput = createElement("input", self.input.className + " flatpickr-mobile"); 1791 self.mobileInput.tabIndex = 1; 1792 self.mobileInput.type = inputType; 1793 self.mobileInput.disabled = self.input.disabled; 1794 self.mobileInput.required = self.input.required; 1795 self.mobileInput.placeholder = self.input.placeholder; 1796 self.mobileFormatStr = 1797 inputType === "datetime-local" 1798 ? "Y-m-d\\TH:i:S" 1799 : inputType === "date" 1800 ? "Y-m-d" 1801 : "H:i:S"; 1802 if (self.selectedDates.length > 0) { 1803 self.mobileInput.defaultValue = self.mobileInput.value = self.formatDate(self.selectedDates[0], self.mobileFormatStr); 1804 } 1805 if (self.config.minDate) 1806 self.mobileInput.min = self.formatDate(self.config.minDate, "Y-m-d"); 1807 if (self.config.maxDate) 1808 self.mobileInput.max = self.formatDate(self.config.maxDate, "Y-m-d"); 1809 if (self.input.getAttribute("step")) 1810 self.mobileInput.step = String(self.input.getAttribute("step")); 1811 self.input.type = "hidden"; 1812 if (self.altInput !== undefined) 1813 self.altInput.type = "hidden"; 1814 try { 1815 if (self.input.parentNode) 1816 self.input.parentNode.insertBefore(self.mobileInput, self.input.nextSibling); 1817 } 1818 catch (_a) { } 1819 bind(self.mobileInput, "change", function (e) { 1820 self.setDate(getEventTarget(e).value, false, self.mobileFormatStr); 1821 triggerEvent("onChange"); 1822 triggerEvent("onClose"); 1823 }); 1824 } 1825 function toggle(e) { 1826 if (self.isOpen === true) 1827 return self.close(); 1828 self.open(e); 1829 } 1830 function triggerEvent(event, data) { 1831 if (self.config === undefined) 1832 return; 1833 var hooks = self.config[event]; 1834 if (hooks !== undefined && hooks.length > 0) { 1835 for (var i = 0; hooks[i] && i < hooks.length; i++) 1836 hooks[i](self.selectedDates, self.input.value, self, data); 1837 } 1838 if (event === "onChange") { 1839 self.input.dispatchEvent(createEvent("change")); 1840 self.input.dispatchEvent(createEvent("input")); 1841 } 1842 } 1843 function createEvent(name) { 1844 var e = document.createEvent("Event"); 1845 e.initEvent(name, true, true); 1846 return e; 1847 } 1848 function isDateSelected(date) { 1849 for (var i = 0; i < self.selectedDates.length; i++) { 1850 var selectedDate = self.selectedDates[i]; 1851 if (selectedDate instanceof Date && 1852 compareDates(selectedDate, date) === 0) 1853 return "" + i; 1854 } 1855 return false; 1856 } 1857 function isDateInRange(date) { 1858 if (self.config.mode !== "range" || self.selectedDates.length < 2) 1859 return false; 1860 return (compareDates(date, self.selectedDates[0]) >= 0 && 1861 compareDates(date, self.selectedDates[1]) <= 0); 1862 } 1863 function updateNavigationCurrentMonth() { 1864 if (self.config.noCalendar || self.isMobile || !self.monthNav) 1865 return; 1866 self.yearElements.forEach(function (yearElement, i) { 1867 var d = new Date(self.currentYear, self.currentMonth, 1); 1868 d.setMonth(self.currentMonth + i); 1869 if (self.config.showMonths > 1 || 1870 self.config.monthSelectorType === "static") { 1871 self.monthElements[i].textContent = 1872 monthToStr(d.getMonth(), self.config.shorthandCurrentMonth, self.l10n) + " "; 1873 } 1874 else { 1875 self.monthsDropdownContainer.value = d.getMonth().toString(); 1876 } 1877 yearElement.value = d.getFullYear().toString(); 1878 }); 1879 self._hidePrevMonthArrow = 1880 self.config.minDate !== undefined && 1881 (self.currentYear === self.config.minDate.getFullYear() 1882 ? self.currentMonth <= self.config.minDate.getMonth() 1883 : self.currentYear < self.config.minDate.getFullYear()); 1884 self._hideNextMonthArrow = 1885 self.config.maxDate !== undefined && 1886 (self.currentYear === self.config.maxDate.getFullYear() 1887 ? self.currentMonth + 1 > self.config.maxDate.getMonth() 1888 : self.currentYear > self.config.maxDate.getFullYear()); 1889 } 1890 function getDateStr(specificFormat) { 1891 var format = specificFormat || 1892 (self.config.altInput ? self.config.altFormat : self.config.dateFormat); 1893 return self.selectedDates 1894 .map(function (dObj) { return self.formatDate(dObj, format); }) 1895 .filter(function (d, i, arr) { 1896 return self.config.mode !== "range" || 1897 self.config.enableTime || 1898 arr.indexOf(d) === i; 1899 }) 1900 .join(self.config.mode !== "range" 1901 ? self.config.conjunction 1902 : self.l10n.rangeSeparator); 1903 } 1904 function updateValue(triggerChange) { 1905 if (triggerChange === void 0) { triggerChange = true; } 1906 if (self.mobileInput !== undefined && self.mobileFormatStr) { 1907 self.mobileInput.value = 1908 self.latestSelectedDateObj !== undefined 1909 ? self.formatDate(self.latestSelectedDateObj, self.mobileFormatStr) 1910 : ""; 1911 } 1912 self.input.value = getDateStr(self.config.dateFormat); 1913 if (self.altInput !== undefined) { 1914 self.altInput.value = getDateStr(self.config.altFormat); 1915 } 1916 if (triggerChange !== false) 1917 triggerEvent("onValueUpdate"); 1918 } 1919 function onMonthNavClick(e) { 1920 var eventTarget = getEventTarget(e); 1921 var isPrevMonth = self.prevMonthNav.contains(eventTarget); 1922 var isNextMonth = self.nextMonthNav.contains(eventTarget); 1923 if (isPrevMonth || isNextMonth) { 1924 changeMonth(isPrevMonth ? -1 : 1); 1925 } 1926 else if (self.yearElements.indexOf(eventTarget) >= 0) { 1927 eventTarget.select(); 1928 } 1929 else if (eventTarget.classList.contains("arrowUp")) { 1930 self.changeYear(self.currentYear + 1); 1931 } 1932 else if (eventTarget.classList.contains("arrowDown")) { 1933 self.changeYear(self.currentYear - 1); 1934 } 1935 } 1936 function timeWrapper(e) { 1937 e.preventDefault(); 1938 var isKeyDown = e.type === "keydown", eventTarget = getEventTarget(e), input = eventTarget; 1939 if (self.amPM !== undefined && eventTarget === self.amPM) { 1940 self.amPM.textContent = 1941 self.l10n.amPM[int(self.amPM.textContent === self.l10n.amPM[0])]; 1942 } 1943 var min = parseFloat(input.getAttribute("min")), max = parseFloat(input.getAttribute("max")), step = parseFloat(input.getAttribute("step")), curValue = parseInt(input.value, 10), delta = e.delta || 1944 (isKeyDown ? (e.which === 38 ? 1 : -1) : 0); 1945 var newValue = curValue + step * delta; 1946 if (typeof input.value !== "undefined" && input.value.length === 2) { 1947 var isHourElem = input === self.hourElement, isMinuteElem = input === self.minuteElement; 1948 if (newValue < min) { 1949 newValue = 1950 max + 1951 newValue + 1952 int(!isHourElem) + 1953 (int(isHourElem) && int(!self.amPM)); 1954 if (isMinuteElem) 1955 incrementNumInput(undefined, -1, self.hourElement); 1956 } 1957 else if (newValue > max) { 1958 newValue = 1959 input === self.hourElement ? newValue - max - int(!self.amPM) : min; 1960 if (isMinuteElem) 1961 incrementNumInput(undefined, 1, self.hourElement); 1962 } 1963 if (self.amPM && 1964 isHourElem && 1965 (step === 1 1966 ? newValue + curValue === 23 1967 : Math.abs(newValue - curValue) > step)) { 1968 self.amPM.textContent = 1969 self.l10n.amPM[int(self.amPM.textContent === self.l10n.amPM[0])]; 1970 } 1971 input.value = pad(newValue); 1972 } 1973 } 1974 init(); 1975 return self; 1976} 1977function _flatpickr(nodeList, config) { 1978 var nodes = Array.prototype.slice 1979 .call(nodeList) 1980 .filter(function (x) { return x instanceof HTMLElement; }); 1981 var instances = []; 1982 for (var i = 0; i < nodes.length; i++) { 1983 var node = nodes[i]; 1984 try { 1985 if (node.getAttribute("data-fp-omit") !== null) 1986 continue; 1987 if (node._flatpickr !== undefined) { 1988 node._flatpickr.destroy(); 1989 node._flatpickr = undefined; 1990 } 1991 node._flatpickr = FlatpickrInstance(node, config || {}); 1992 instances.push(node._flatpickr); 1993 } 1994 catch (e) { 1995 console.error(e); 1996 } 1997 } 1998 return instances.length === 1 ? instances[0] : instances; 1999} 2000if (typeof HTMLElement !== "undefined" && 2001 typeof HTMLCollection !== "undefined" && 2002 typeof NodeList !== "undefined") { 2003 HTMLCollection.prototype.flatpickr = NodeList.prototype.flatpickr = function (config) { 2004 return _flatpickr(this, config); 2005 }; 2006 HTMLElement.prototype.flatpickr = function (config) { 2007 return _flatpickr([this], config); 2008 }; 2009} 2010var flatpickr = function (selector, config) { 2011 if (typeof selector === "string") { 2012 return _flatpickr(window.document.querySelectorAll(selector), config); 2013 } 2014 else if (selector instanceof Node) { 2015 return _flatpickr([selector], config); 2016 } 2017 else { 2018 return _flatpickr(selector, config); 2019 } 2020}; 2021flatpickr.defaultConfig = {}; 2022flatpickr.l10ns = { 2023 en: __assign({}, English), 2024 default: __assign({}, English), 2025}; 2026flatpickr.localize = function (l10n) { 2027 flatpickr.l10ns.default = __assign(__assign({}, flatpickr.l10ns.default), l10n); 2028}; 2029flatpickr.setDefaults = function (config) { 2030 flatpickr.defaultConfig = __assign(__assign({}, flatpickr.defaultConfig), config); 2031}; 2032flatpickr.parseDate = createDateParser({}); 2033flatpickr.formatDate = createDateFormatter({}); 2034flatpickr.compareDates = compareDates; 2035if (typeof jQuery !== "undefined" && typeof jQuery.fn !== "undefined") { 2036 jQuery.fn.flatpickr = function (config) { 2037 return _flatpickr(this, config); 2038 }; 2039} 2040Date.prototype.fp_incr = function (days) { 2041 return new Date(this.getFullYear(), this.getMonth(), this.getDate() + (typeof days === "string" ? parseInt(days, 10) : days)); 2042}; 2043if (typeof window !== "undefined") { 2044 window.flatpickr = flatpickr; 2045} 2046export default flatpickr;
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.