vendor: 21,254 bytes, lines 1-708
1/* flatpickr v4.6.13, @license MIT */ 2(function (global, factory) { 3 typeof exports === 'object' && typeof module !== 'undefined' 4 ? (module.exports = factory()) 5 : typeof define === 'function' && define.amd 6 ? define(factory) 7 : ((global = 8 typeof globalThis !== 'undefined' ? globalThis : global || self), 9 (global.flatpickr = factory())); 10})(this, function () { 11 'use strict'; 12 13 /*! ***************************************************************************** 14 Copyright (c) Microsoft Corporation. 15 16 Permission to use, copy, modify, and/or distribute this software for any 17 purpose with or without fee is hereby granted. 18 19 THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH 20 REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 21 AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, 22 INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM 23 LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR 24 OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 25 PERFORMANCE OF THIS SOFTWARE. 26 ***************************************************************************** */ 27 28 var __assign = function () { 29 __assign = 30 Object.assign || 31 function __assign(t) { 32 for (var s, i = 1, n = arguments.length; i < n; i++) { 33 s = arguments[i]; 34 for (var p in s) 35 if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p]; 36 } 37 return t; 38 }; 39 return __assign.apply(this, arguments); 40 }; 41 42 function __spreadArrays() { 43 for (var s = 0, i = 0, il = arguments.length; i < il; i++) 44 s += arguments[i].length; 45 for (var r = Array(s), k = 0, i = 0; i < il; i++) 46 for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) 47 r[k] = a[j]; 48 return r; 49 } 50 51 var HOOKS = [ 52 'onChange', 53 'onClose', 54 'onDayCreate', 55 'onDestroy', 56 'onKeyDown', 57 'onMonthChange', 58 'onOpen', 59 'onParseConfig', 60 'onReady', 61 'onValueUpdate', 62 'onYearChange', 63 'onPreCalendarPosition', 64 ]; 65 var defaults = { 66 _disable: [], 67 allowInput: false, 68 allowInvalidPreload: false, 69 altFormat: 'F j, Y', 70 altInput: false, 71 altInputClass: 'form-control input', 72 animate: 73 typeof window === 'object' && 74 window.navigator.userAgent.indexOf('MSIE') === -1, 75 ariaDateFormat: 'F j, Y', 76 autoFillDefaultTime: true, 77 clickOpens: true, 78 closeOnSelect: true, 79 conjunction: ', ', 80 dateFormat: 'Y-m-d', 81 defaultHour: 12, 82 defaultMinute: 0, 83 defaultSeconds: 0, 84 disable: [], 85 disableMobile: false, 86 enableSeconds: false, 87 enableTime: false, 88 errorHandler: function (err) { 89 return typeof console !== 'undefined' && console.warn(err); 90 }, 91 getWeek: function (givenDate) { 92 var date = new Date(givenDate.getTime()); 93 date.setHours(0, 0, 0, 0); 94 // Thursday in current week decides the year. 95 date.setDate(date.getDate() + 3 - ((date.getDay() + 6) % 7)); 96 // January 4 is always in week 1. 97 var week1 = new Date(date.getFullYear(), 0, 4); 98 // Adjust to Thursday in week 1 and count number of weeks from date to week1. 99 return ( 100 1 + 101 Math.round( 102 ((date.getTime() - week1.getTime()) / 86400000 - 103 3 + 104 ((week1.getDay() + 6) % 7)) / 105 7, 106 ) 107 ); 108 }, 109 hourIncrement: 1, 110 ignoredFocusElements: [], 111 inline: false, 112 locale: 'default', 113 minuteIncrement: 5, 114 mode: 'single', 115 monthSelectorType: 'dropdown', 116 nextArrow: 117 "<svg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' viewBox='0 0 17 17'><g></g><path d='M13.207 8.472l-7.854 7.854-0.707-0.707 7.146-7.146-7.146-7.148 0.707-0.707 7.854 7.854z' /></svg>", 118 noCalendar: false, 119 now: new Date(), 120 onChange: [], 121 onClose: [], 122 onDayCreate: [], 123 onDestroy: [], 124 onKeyDown: [], 125 onMonthChange: [], 126 onOpen: [], 127 onParseConfig: [], 128 onReady: [], 129 onValueUpdate: [], 130 onYearChange: [], 131 onPreCalendarPosition: [], 132 plugins: [], 133 position: 'auto', 134 positionElement: undefined, 135 prevArrow: 136 "<svg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' viewBox='0 0 17 17'><g></g><path d='M5.207 8.471l7.146 7.147-0.707 0.707-7.853-7.854 7.854-7.853 0.707 0.707-7.147 7.146z' /></svg>", 137 shorthandCurrentMonth: false, 138 showMonths: 1, 139 static: false, 140 time_24hr: false, 141 weekNumbers: false, 142 wrap: false, 143 }; 144 145 var english = { 146 weekdays: { 147 shorthand: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'], 148 longhand: [ 149 'Sunday', 150 'Monday', 151 'Tuesday', 152 'Wednesday', 153 'Thursday', 154 'Friday', 155 'Saturday', 156 ], 157 }, 158 months: { 159 shorthand: [ 160 'Jan', 161 'Feb', 162 'Mar', 163 'Apr', 164 'May', 165 'Jun', 166 'Jul', 167 'Aug', 168 'Sep', 169 'Oct', 170 'Nov', 171 'Dec', 172 ], 173 longhand: [ 174 'January', 175 'February', 176 'March', 177 'April', 178 'May', 179 'June', 180 'July', 181 'August', 182 'September', 183 'October', 184 'November', 185 'December', 186 ], 187 }, 188 daysInMonth: [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], 189 firstDayOfWeek: 0, 190 ordinal: function (nth) { 191 var s = nth % 100; 192 if (s > 3 && s < 21) return 'th'; 193 switch (s % 10) { 194 case 1: 195 return 'st'; 196 case 2: 197 return 'nd'; 198 case 3: 199 return 'rd'; 200 default: 201 return 'th'; 202 } 203 }, 204 rangeSeparator: ' to ', 205 weekAbbreviation: 'Wk', 206 scrollTitle: 'Scroll to increment', 207 toggleTitle: 'Click to toggle', 208 amPM: ['AM', 'PM'], 209 yearAriaLabel: 'Year', 210 monthAriaLabel: 'Month', 211 hourAriaLabel: 'Hour', 212 minuteAriaLabel: 'Minute', 213 time_24hr: false, 214 }; 215 216 var pad = function (number, length) { 217 if (length === void 0) { 218 length = 2; 219 } 220 return ('000' + number).slice(length * -1); 221 }; 222 var int = function (bool) { 223 return bool === true ? 1 : 0; 224 }; 225 /* istanbul ignore next */ 226 function debounce(fn, wait) { 227 var t; 228 return function () { 229 var _this = this; 230 var args = arguments; 231 clearTimeout(t); 232 t = setTimeout(function () { 233 return fn.apply(_this, args); 234 }, wait); 235 }; 236 } 237 var arrayify = function (obj) { 238 return obj instanceof Array ? obj : [obj]; 239 }; 240 241 function toggleClass(elem, className, bool) { 242 if (bool === true) return elem.classList.add(className); 243 elem.classList.remove(className); 244 } 245 function createElement(tag, className, content) { 246 var e = window.document.createElement(tag); 247 className = className || ''; 248 content = content || ''; 249 e.className = className; 250 if (content !== undefined) e.textContent = content; 251 return e; 252 } 253 function clearNode(node) { 254 while (node.firstChild) node.removeChild(node.firstChild); 255 } 256 function findParent(node, condition) { 257 if (condition(node)) return node; 258 else if (node.parentNode) return findParent(node.parentNode, condition); 259 return undefined; // nothing found 260 } 261 function createNumberInput(inputClassName, opts) { 262 var wrapper = createElement('div', 'numInputWrapper'), 263 numInput = createElement('input', 'numInput ' + inputClassName), 264 arrowUp = createElement('span', 'arrowUp'), 265 arrowDown = createElement('span', 'arrowDown'); 266 if (navigator.userAgent.indexOf('MSIE 9.0') === -1) { 267 numInput.type = 'number'; 268 } else { 269 numInput.type = 'text'; 270 numInput.pattern = '\\d*'; 271 } 272 if (opts !== undefined) 273 for (var key in opts) numInput.setAttribute(key, opts[key]); 274 wrapper.appendChild(numInput); 275 wrapper.appendChild(arrowUp); 276 wrapper.appendChild(arrowDown); 277 return wrapper; 278 } 279 function getEventTarget(event) { 280 try { 281 if (typeof event.composedPath === 'function') { 282 var path = event.composedPath(); 283 return path[0]; 284 } 285 return event.target; 286 } catch (error) { 287 return event.target; 288 } 289 } 290 291 var doNothing = function () { 292 return undefined; 293 }; 294 var monthToStr = function (monthNumber, shorthand, locale) { 295 return locale.months[shorthand ? 'shorthand' : 'longhand'][monthNumber]; 296 }; 297 var revFormat = { 298 D: doNothing, 299 F: function (dateObj, monthName, locale) { 300 dateObj.setMonth(locale.months.longhand.indexOf(monthName)); 301 }, 302 G: function (dateObj, hour) { 303 dateObj.setHours((dateObj.getHours() >= 12 ? 12 : 0) + parseFloat(hour)); 304 }, 305 H: function (dateObj, hour) { 306 dateObj.setHours(parseFloat(hour)); 307 }, 308 J: function (dateObj, day) { 309 dateObj.setDate(parseFloat(day)); 310 }, 311 K: function (dateObj, amPM, locale) { 312 dateObj.setHours( 313 (dateObj.getHours() % 12) + 314 12 * int(new RegExp(locale.amPM[1], 'i').test(amPM)), 315 ); 316 }, 317 M: function (dateObj, shortMonth, locale) { 318 dateObj.setMonth(locale.months.shorthand.indexOf(shortMonth)); 319 }, 320 S: function (dateObj, seconds) { 321 dateObj.setSeconds(parseFloat(seconds)); 322 }, 323 U: function (_, unixSeconds) { 324 return new Date(parseFloat(unixSeconds) * 1000); 325 }, 326 W: function (dateObj, weekNum, locale) { 327 var weekNumber = parseInt(weekNum); 328 var date = new Date( 329 dateObj.getFullYear(), 330 0, 331 2 + (weekNumber - 1) * 7, 332 0, 333 0, 334 0, 335 0, 336 ); 337 date.setDate(date.getDate() - date.getDay() + locale.firstDayOfWeek); 338 return date; 339 }, 340 Y: function (dateObj, year) { 341 dateObj.setFullYear(parseFloat(year)); 342 }, 343 Z: function (_, ISODate) { 344 return new Date(ISODate); 345 }, 346 d: function (dateObj, day) { 347 dateObj.setDate(parseFloat(day)); 348 }, 349 h: function (dateObj, hour) { 350 dateObj.setHours((dateObj.getHours() >= 12 ? 12 : 0) + parseFloat(hour)); 351 }, 352 i: function (dateObj, minutes) { 353 dateObj.setMinutes(parseFloat(minutes)); 354 }, 355 j: function (dateObj, day) { 356 dateObj.setDate(parseFloat(day)); 357 }, 358 l: doNothing, 359 m: function (dateObj, month) { 360 dateObj.setMonth(parseFloat(month) - 1); 361 }, 362 n: function (dateObj, month) { 363 dateObj.setMonth(parseFloat(month) - 1); 364 }, 365 s: function (dateObj, seconds) { 366 dateObj.setSeconds(parseFloat(seconds)); 367 }, 368 u: function (_, unixMillSeconds) { 369 return new Date(parseFloat(unixMillSeconds)); 370 }, 371 w: doNothing, 372 y: function (dateObj, year) { 373 dateObj.setFullYear(2000 + parseFloat(year)); 374 }, 375 }; 376 var tokenRegex = { 377 D: '', 378 F: '', 379 G: '(\\d\\d|\\d)', 380 H: '(\\d\\d|\\d)', 381 J: '(\\d\\d|\\d)\\w+', 382 K: '', 383 M: '', 384 S: '(\\d\\d|\\d)', 385 U: '(.+)', 386 W: '(\\d\\d|\\d)', 387 Y: '(\\d{4})', 388 Z: '(.+)', 389 d: '(\\d\\d|\\d)', 390 h: '(\\d\\d|\\d)', 391 i: '(\\d\\d|\\d)', 392 j: '(\\d\\d|\\d)', 393 l: '', 394 m: '(\\d\\d|\\d)', 395 n: '(\\d\\d|\\d)', 396 s: '(\\d\\d|\\d)', 397 u: '(.+)', 398 w: '(\\d\\d|\\d)', 399 y: '(\\d{2})', 400 }; 401 var formats = { 402 // get the date in UTC 403 Z: function (date) { 404 return date.toISOString(); 405 }, 406 // weekday name, short, e.g. Thu 407 D: function (date, locale, options) { 408 return locale.weekdays.shorthand[formats.w(date, locale, options)]; 409 }, 410 // full month name e.g. January 411 F: function (date, locale, options) { 412 return monthToStr(formats.n(date, locale, options) - 1, false, locale); 413 }, 414 // padded hour 1-12 415 G: function (date, locale, options) { 416 return pad(formats.h(date, locale, options)); 417 }, 418 // hours with leading zero e.g. 03 419 H: function (date) { 420 return pad(date.getHours()); 421 }, 422 // day (1-30) with ordinal suffix e.g. 1st, 2nd 423 J: function (date, locale) { 424 return locale.ordinal !== undefined 425 ? date.getDate() + locale.ordinal(date.getDate()) 426 : date.getDate(); 427 }, 428 // AM/PM 429 K: function (date, locale) { 430 return locale.amPM[int(date.getHours() > 11)]; 431 }, 432 // shorthand month e.g. Jan, Sep, Oct, etc 433 M: function (date, locale) { 434 return monthToStr(date.getMonth(), true, locale); 435 }, 436 // seconds 00-59 437 S: function (date) { 438 return pad(date.getSeconds()); 439 }, 440 // unix timestamp 441 U: function (date) { 442 return date.getTime() / 1000; 443 }, 444 W: function (date, _, options) { 445 return options.getWeek(date); 446 }, 447 // full year e.g. 2016, padded (0001-9999) 448 Y: function (date) { 449 return pad(date.getFullYear(), 4); 450 }, 451 // day in month, padded (01-30) 452 d: function (date) { 453 return pad(date.getDate()); 454 }, 455 // hour from 1-12 (am/pm) 456 h: function (date) { 457 return date.getHours() % 12 ? date.getHours() % 12 : 12; 458 }, 459 // minutes, padded with leading zero e.g. 09 460 i: function (date) { 461 return pad(date.getMinutes()); 462 }, 463 // day in month (1-30) 464 j: function (date) { 465 return date.getDate(); 466 }, 467 // weekday name, full, e.g. Thursday 468 l: function (date, locale) { 469 return locale.weekdays.longhand[date.getDay()]; 470 }, 471 // padded month number (01-12) 472 m: function (date) { 473 return pad(date.getMonth() + 1); 474 }, 475 // the month number (1-12) 476 n: function (date) { 477 return date.getMonth() + 1; 478 }, 479 // seconds 0-59 480 s: function (date) { 481 return date.getSeconds(); 482 }, 483 // Unix Milliseconds 484 u: function (date) { 485 return date.getTime(); 486 }, 487 // number of the day of the week 488 w: function (date) { 489 return date.getDay(); 490 }, 491 // last two digits of year e.g. 16 for 2016 492 y: function (date) { 493 return String(date.getFullYear()).substring(2); 494 }, 495 }; 496 497 var createDateFormatter = function (_a) { 498 var _b = _a.config, 499 config = _b === void 0 ? defaults : _b, 500 _c = _a.l10n, 501 l10n = _c === void 0 ? english : _c, 502 _d = _a.isMobile, 503 isMobile = _d === void 0 ? false : _d; 504 return function (dateObj, frmt, overrideLocale) { 505 var locale = overrideLocale || l10n; 506 if (config.formatDate !== undefined && !isMobile) { 507 return config.formatDate(dateObj, frmt, locale); 508 } 509 return frmt 510 .split('') 511 .map(function (c, i, arr) { 512 return formats[c] && arr[i - 1] !== '\\' 513 ? formats[c](dateObj, locale, config) 514 : c !== '\\' 515 ? c 516 : ''; 517 }) 518 .join(''); 519 }; 520 }; 521 var createDateParser = function (_a) { 522 var _b = _a.config, 523 config = _b === void 0 ? defaults : _b, 524 _c = _a.l10n, 525 l10n = _c === void 0 ? english : _c; 526 return function (date, givenFormat, timeless, customLocale) { 527 if (date !== 0 && !date) return undefined; 528 var locale = customLocale || l10n; 529 var parsedDate; 530 var dateOrig = date; 531 if (date instanceof Date) parsedDate = new Date(date.getTime()); 532 else if ( 533 typeof date !== 'string' && 534 date.toFixed !== undefined // timestamp 535 ) 536 // create a copy 537 parsedDate = new Date(date); 538 else if (typeof date === 'string') { 539 // date string 540 var format = givenFormat || (config || defaults).dateFormat; 541 var datestr = String(date).trim(); 542 if (datestr === 'today') { 543 parsedDate = new Date(); 544 timeless = true; 545 } else if (config && config.parseDate) { 546 parsedDate = config.parseDate(date, format); 547 } else if ( 548 /Z$/.test(datestr) || 549 /GMT$/.test(datestr) // datestrings w/ timezone 550 ) { 551 parsedDate = new Date(date); 552 } else { 553 var matched = void 0, 554 ops = []; 555 for ( 556 var i = 0, matchIndex = 0, regexStr = ''; 557 i < format.length; 558 i++ 559 ) { 560 var token_1 = format[i]; 561 var isBackSlash = token_1 === '\\'; 562 var escaped = format[i - 1] === '\\' || isBackSlash; 563 if (tokenRegex[token_1] && !escaped) { 564 regexStr += tokenRegex[token_1]; 565 var match = new RegExp(regexStr).exec(date); 566 if (match && (matched = true)) { 567 ops[token_1 !== 'Y' ? 'push' : 'unshift']({ 568 fn: revFormat[token_1], 569 val: match[++matchIndex], 570 }); 571 } 572 } else if (!isBackSlash) regexStr += '.'; // don't really care 573 } 574 parsedDate = 575 !config || !config.noCalendar 576 ? new Date(new Date().getFullYear(), 0, 1, 0, 0, 0, 0) 577 : new Date(new Date().setHours(0, 0, 0, 0)); 578 ops.forEach(function (_a) { 579 var fn = _a.fn, 580 val = _a.val; 581 return (parsedDate = fn(parsedDate, val, locale) || parsedDate); 582 }); 583 parsedDate = matched ? parsedDate : undefined; 584 } 585 } 586 /* istanbul ignore next */ 587 if (!(parsedDate instanceof Date && !isNaN(parsedDate.getTime()))) { 588 config.errorHandler(new Error('Invalid date provided: ' + dateOrig)); 589 return undefined; 590 } 591 if (timeless === true) parsedDate.setHours(0, 0, 0, 0); 592 return parsedDate; 593 }; 594 }; 595 /** 596 * Compute the difference in dates, measured in ms 597 */ 598 function compareDates(date1, date2, timeless) { 599 if (timeless === void 0) { 600 timeless = true; 601 } 602 if (timeless !== false) { 603 return ( 604 new Date(date1.getTime()).setHours(0, 0, 0, 0) - 605 new Date(date2.getTime()).setHours(0, 0, 0, 0) 606 ); 607 } 608 return date1.getTime() - date2.getTime(); 609 } 610 var isBetween = function (ts, ts1, ts2) { 611 return ts > Math.min(ts1, ts2) && ts < Math.max(ts1, ts2); 612 }; 613 var calculateSecondsSinceMidnight = function (hours, minutes, seconds) { 614 return hours * 3600 + minutes * 60 + seconds; 615 }; 616 var parseSeconds = function (secondsSinceMidnight) { 617 var hours = Math.floor(secondsSinceMidnight / 3600), 618 minutes = (secondsSinceMidnight - hours * 3600) / 60; 619 return [hours, minutes, secondsSinceMidnight - hours * 3600 - minutes * 60]; 620 }; 621 var duration = { 622 DAY: 86400000, 623 }; 624 function getDefaultHours(config) { 625 var hours = config.defaultHour; 626 var minutes = config.defaultMinute; 627 var seconds = config.defaultSeconds; 628 if (config.minDate !== undefined) { 629 var minHour = config.minDate.getHours(); 630 var minMinutes = config.minDate.getMinutes(); 631 var minSeconds = config.minDate.getSeconds(); 632 if (hours < minHour) { 633 hours = minHour; 634 } 635 if (hours === minHour && minutes < minMinutes) { 636 minutes = minMinutes; 637 } 638 if (hours === minHour && minutes === minMinutes && seconds < minSeconds) 639 seconds = config.minDate.getSeconds(); 640 } 641 if (config.maxDate !== undefined) { 642 var maxHr = config.maxDate.getHours(); 643 var maxMinutes = config.maxDate.getMinutes(); 644 hours = Math.min(hours, maxHr); 645 if (hours === maxHr) minutes = Math.min(maxMinutes, minutes); 646 if (hours === maxHr && minutes === maxMinutes) 647 seconds = config.maxDate.getSeconds(); 648 } 649 return { hours: hours, minutes: minutes, seconds: seconds }; 650 } 651 652 if (typeof Object.assign !== 'function') { 653 Object.assign = function (target) { 654 var args = []; 655 for (var _i = 1; _i < arguments.length; _i++) { 656 args[_i - 1] = arguments[_i]; 657 } 658 if (!target) { 659 throw TypeError('Cannot convert undefined or null to object'); 660 } 661 var _loop_1 = function (source) { 662 if (source) { 663 Object.keys(source).forEach(function (key) { 664 return (target[key] = source[key]); 665 }); 666 } 667 }; 668 for (var _a = 0, args_1 = args; _a < args_1.length; _a++) { 669 var source = args_1[_a]; 670 _loop_1(source); 671 } 672 return target; 673 }; 674 } 675 676 var DEBOUNCED_CHANGE_MS = 300; 677 function FlatpickrInstance(element, instanceConfig) { 678 var self = { 679 config: __assign(__assign({}, defaults), flatpickr.defaultConfig), 680 l10n: english, 681 }; 682 self.parseDate = createDateParser({ config: self.config, l10n: self.l10n }); 683 self._handlers = []; 684 self.pluginElements = []; 685 self.loadedPlugins = []; 686 self._bind = bind; 687 self._setHoursFromDate = setHoursFromDate; 688 self._positionCalendar = positionCalendar; 689 self.changeMonth = changeMonth; 690 self.changeYear = changeYear; 691 self.clear = clear; 692 self.close = close; 693 self.onMouseOver = onMouseOver; 694 self._createElement = createElement; 695 self.createDay = createDay; 696 self.destroy = destroy; 697 self.isEnabled = isEnabled; 698 self.jumpToDate = jumpToDate; 699 self.updateValue = updateValue; 700 self.open = open; 701 self.redraw = redraw; 702 self.set = set; 703 self.setDate = setDate; 704 self.toggle = toggle; 705 function setupHelperFunctions() { 706 self.utils = { 707 getDaysInMonth: function (month, yr) { 708 if (month === void 0) {
vendor: 43,579 bytes, lines 709-1954
709 month = self.currentMonth; 710 } 711 if (yr === void 0) { 712 yr = self.currentYear; 713 } 714 if ( 715 month === 1 && 716 ((yr % 4 === 0 && yr % 100 !== 0) || yr % 400 === 0) 717 ) 718 return 29; 719 return self.l10n.daysInMonth[month]; 720 }, 721 }; 722 } 723 function init() { 724 self.element = self.input = element; 725 self.isOpen = false; 726 parseConfig(); 727 setupLocale(); 728 setupInputs(); 729 setupDates(); 730 setupHelperFunctions(); 731 if (!self.isMobile) build(); 732 bindEvents(); 733 if (self.selectedDates.length || self.config.noCalendar) { 734 if (self.config.enableTime) { 735 setHoursFromDate( 736 self.config.noCalendar ? self.latestSelectedDateObj : undefined, 737 ); 738 } 739 updateValue(false); 740 } 741 setCalendarWidth(); 742 var isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent); 743 /* TODO: investigate this further 744 745 Currently, there is weird positioning behavior in safari causing pages 746 to scroll up. https://github.com/chmln/flatpickr/issues/563 747 748 However, most browsers are not Safari and positioning is expensive when used 749 in scale. https://github.com/chmln/flatpickr/issues/1096 750 */ 751 if (!self.isMobile && isSafari) { 752 positionCalendar(); 753 } 754 triggerEvent('onReady'); 755 } 756 function getClosestActiveElement() { 757 var _a; 758 return ( 759 ((_a = self.calendarContainer) === null || _a === void 0 760 ? void 0 761 : _a.getRootNode() 762 ).activeElement || document.activeElement 763 ); 764 } 765 function bindToInstance(fn) { 766 return fn.bind(self); 767 } 768 function setCalendarWidth() { 769 var config = self.config; 770 if (config.weekNumbers === false && config.showMonths === 1) { 771 return; 772 } else if (config.noCalendar !== true) { 773 window.requestAnimationFrame(function () { 774 if (self.calendarContainer !== undefined) { 775 self.calendarContainer.style.visibility = 'hidden'; 776 self.calendarContainer.style.display = 'block'; 777 } 778 if (self.daysContainer !== undefined) { 779 var daysWidth = (self.days.offsetWidth + 1) * config.showMonths; 780 self.daysContainer.style.width = daysWidth + 'px'; 781 self.calendarContainer.style.width = 782 daysWidth + 783 (self.weekWrapper !== undefined 784 ? self.weekWrapper.offsetWidth 785 : 0) + 786 'px'; 787 self.calendarContainer.style.removeProperty('visibility'); 788 self.calendarContainer.style.removeProperty('display'); 789 } 790 }); 791 } 792 } 793 /** 794 * The handler for all events targeting the time inputs 795 */ 796 function updateTime(e) { 797 if (self.selectedDates.length === 0) { 798 var defaultDate = 799 self.config.minDate === undefined || 800 compareDates(new Date(), self.config.minDate) >= 0 801 ? new Date() 802 : new Date(self.config.minDate.getTime()); 803 var defaults = getDefaultHours(self.config); 804 defaultDate.setHours( 805 defaults.hours, 806 defaults.minutes, 807 defaults.seconds, 808 defaultDate.getMilliseconds(), 809 ); 810 self.selectedDates = [defaultDate]; 811 self.latestSelectedDateObj = defaultDate; 812 } 813 if (e !== undefined && e.type !== 'blur') { 814 timeWrapper(e); 815 } 816 var prevValue = self._input.value; 817 setHoursFromInputs(); 818 updateValue(); 819 if (self._input.value !== prevValue) { 820 self._debouncedChange(); 821 } 822 } 823 function ampm2military(hour, amPM) { 824 return (hour % 12) + 12 * int(amPM === self.l10n.amPM[1]); 825 } 826 function military2ampm(hour) { 827 switch (hour % 24) { 828 case 0: 829 case 12: 830 return 12; 831 default: 832 return hour % 12; 833 } 834 } 835 /** 836 * Syncs the selected date object time with user's time input 837 */ 838 function setHoursFromInputs() { 839 if (self.hourElement === undefined || self.minuteElement === undefined) 840 return; 841 var hours = (parseInt(self.hourElement.value.slice(-2), 10) || 0) % 24, 842 minutes = (parseInt(self.minuteElement.value, 10) || 0) % 60, 843 seconds = 844 self.secondElement !== undefined 845 ? (parseInt(self.secondElement.value, 10) || 0) % 60 846 : 0; 847 if (self.amPM !== undefined) { 848 hours = ampm2military(hours, self.amPM.textContent); 849 } 850 var limitMinHours = 851 self.config.minTime !== undefined || 852 (self.config.minDate && 853 self.minDateHasTime && 854 self.latestSelectedDateObj && 855 compareDates( 856 self.latestSelectedDateObj, 857 self.config.minDate, 858 true, 859 ) === 0); 860 var limitMaxHours = 861 self.config.maxTime !== undefined || 862 (self.config.maxDate && 863 self.maxDateHasTime && 864 self.latestSelectedDateObj && 865 compareDates( 866 self.latestSelectedDateObj, 867 self.config.maxDate, 868 true, 869 ) === 0); 870 if ( 871 self.config.maxTime !== undefined && 872 self.config.minTime !== undefined && 873 self.config.minTime > self.config.maxTime 874 ) { 875 var minBound = calculateSecondsSinceMidnight( 876 self.config.minTime.getHours(), 877 self.config.minTime.getMinutes(), 878 self.config.minTime.getSeconds(), 879 ); 880 var maxBound = calculateSecondsSinceMidnight( 881 self.config.maxTime.getHours(), 882 self.config.maxTime.getMinutes(), 883 self.config.maxTime.getSeconds(), 884 ); 885 var currentTime = calculateSecondsSinceMidnight( 886 hours, 887 minutes, 888 seconds, 889 ); 890 if (currentTime > maxBound && currentTime < minBound) { 891 var result = parseSeconds(minBound); 892 hours = result[0]; 893 minutes = result[1]; 894 seconds = result[2]; 895 } 896 } else { 897 if (limitMaxHours) { 898 var maxTime = 899 self.config.maxTime !== undefined 900 ? self.config.maxTime 901 : self.config.maxDate; 902 hours = Math.min(hours, maxTime.getHours()); 903 if (hours === maxTime.getHours()) 904 minutes = Math.min(minutes, maxTime.getMinutes()); 905 if (minutes === maxTime.getMinutes()) 906 seconds = Math.min(seconds, maxTime.getSeconds()); 907 } 908 if (limitMinHours) { 909 var minTime = 910 self.config.minTime !== undefined 911 ? self.config.minTime 912 : self.config.minDate; 913 hours = Math.max(hours, minTime.getHours()); 914 if (hours === minTime.getHours() && minutes < minTime.getMinutes()) 915 minutes = minTime.getMinutes(); 916 if (minutes === minTime.getMinutes()) 917 seconds = Math.max(seconds, minTime.getSeconds()); 918 } 919 } 920 setHours(hours, minutes, seconds); 921 } 922 /** 923 * Syncs time input values with a date 924 */ 925 function setHoursFromDate(dateObj) { 926 var date = dateObj || self.latestSelectedDateObj; 927 if (date && date instanceof Date) { 928 setHours(date.getHours(), date.getMinutes(), date.getSeconds()); 929 } 930 } 931 /** 932 * Sets the hours, minutes, and optionally seconds 933 * of the latest selected date object and the 934 * corresponding time inputs 935 * @param {Number} hours the hour. whether its military 936 * or am-pm gets inferred from config 937 * @param {Number} minutes the minutes 938 * @param {Number} seconds the seconds (optional) 939 */ 940 function setHours(hours, minutes, seconds) { 941 if (self.latestSelectedDateObj !== undefined) { 942 self.latestSelectedDateObj.setHours( 943 hours % 24, 944 minutes, 945 seconds || 0, 946 0, 947 ); 948 } 949 if (!self.hourElement || !self.minuteElement || self.isMobile) return; 950 self.hourElement.value = pad( 951 !self.config.time_24hr 952 ? ((12 + hours) % 12) + 12 * int(hours % 12 === 0) 953 : hours, 954 ); 955 self.minuteElement.value = pad(minutes); 956 if (self.amPM !== undefined) 957 self.amPM.textContent = self.l10n.amPM[int(hours >= 12)]; 958 if (self.secondElement !== undefined) 959 self.secondElement.value = pad(seconds); 960 } 961 /** 962 * Handles the year input and incrementing events 963 * @param {Event} event the keyup or increment event 964 */ 965 function onYearInput(event) { 966 var eventTarget = getEventTarget(event); 967 var year = parseInt(eventTarget.value) + (event.delta || 0); 968 if ( 969 year / 1000 > 1 || 970 (event.key === 'Enter' && !/[^\d]/.test(year.toString())) 971 ) { 972 changeYear(year); 973 } 974 } 975 /** 976 * Essentially addEventListener + tracking 977 * @param {Element} element the element to addEventListener to 978 * @param {String} event the event name 979 * @param {Function} handler the event handler 980 */ 981 function bind(element, event, handler, options) { 982 if (event instanceof Array) 983 return event.forEach(function (ev) { 984 return bind(element, ev, handler, options); 985 }); 986 if (element instanceof Array) 987 return element.forEach(function (el) { 988 return bind(el, event, handler, options); 989 }); 990 element.addEventListener(event, handler, options); 991 self._handlers.push({ 992 remove: function () { 993 return element.removeEventListener(event, handler, options); 994 }, 995 }); 996 } 997 function triggerChange() { 998 triggerEvent('onChange'); 999 } 1000 /** 1001 * Adds all the necessary event listeners 1002 */ 1003 function bindEvents() { 1004 if (self.config.wrap) { 1005 ['open', 'close', 'toggle', 'clear'].forEach(function (evt) { 1006 Array.prototype.forEach.call( 1007 self.element.querySelectorAll('[data-' + evt + ']'), 1008 function (el) { 1009 return bind(el, 'click', self[evt]); 1010 }, 1011 ); 1012 }); 1013 } 1014 if (self.isMobile) { 1015 setupMobile(); 1016 return; 1017 } 1018 var debouncedResize = debounce(onResize, 50); 1019 self._debouncedChange = debounce(triggerChange, DEBOUNCED_CHANGE_MS); 1020 if (self.daysContainer && !/iPhone|iPad|iPod/i.test(navigator.userAgent)) 1021 bind(self.daysContainer, 'mouseover', function (e) { 1022 if (self.config.mode === 'range') onMouseOver(getEventTarget(e)); 1023 }); 1024 bind(self._input, 'keydown', onKeyDown); 1025 if (self.calendarContainer !== undefined) { 1026 bind(self.calendarContainer, 'keydown', onKeyDown); 1027 } 1028 if (!self.config.inline && !self.config.static) 1029 bind(window, 'resize', debouncedResize); 1030 if (window.ontouchstart !== undefined) 1031 bind(window.document, 'touchstart', documentClick); 1032 else bind(window.document, 'mousedown', documentClick); 1033 bind(window.document, 'focus', documentClick, { capture: true }); 1034 if (self.config.clickOpens === true) { 1035 bind(self._input, 'focus', self.open); 1036 bind(self._input, 'click', self.open); 1037 } 1038 if (self.daysContainer !== undefined) { 1039 bind(self.monthNav, 'click', onMonthNavClick); 1040 bind(self.monthNav, ['keyup', 'increment'], onYearInput); 1041 bind(self.daysContainer, 'click', selectDate); 1042 } 1043 if ( 1044 self.timeContainer !== undefined && 1045 self.minuteElement !== undefined && 1046 self.hourElement !== undefined 1047 ) { 1048 var selText = function (e) { 1049 return getEventTarget(e).select(); 1050 }; 1051 bind(self.timeContainer, ['increment'], updateTime); 1052 bind(self.timeContainer, 'blur', updateTime, { capture: true }); 1053 bind(self.timeContainer, 'click', timeIncrement); 1054 bind( 1055 [self.hourElement, self.minuteElement], 1056 ['focus', 'click'], 1057 selText, 1058 ); 1059 if (self.secondElement !== undefined) 1060 bind(self.secondElement, 'focus', function () { 1061 return self.secondElement && self.secondElement.select(); 1062 }); 1063 if (self.amPM !== undefined) { 1064 bind(self.amPM, 'click', function (e) { 1065 updateTime(e); 1066 }); 1067 } 1068 } 1069 if (self.config.allowInput) { 1070 bind(self._input, 'blur', onBlur); 1071 } 1072 } 1073 /** 1074 * Set the calendar view to a particular date. 1075 * @param {Date} jumpDate the date to set the view to 1076 * @param {boolean} triggerChange if change events should be triggered 1077 */ 1078 function jumpToDate(jumpDate, triggerChange) { 1079 var jumpTo = 1080 jumpDate !== undefined 1081 ? self.parseDate(jumpDate) 1082 : self.latestSelectedDateObj || 1083 (self.config.minDate && self.config.minDate > self.now 1084 ? self.config.minDate 1085 : self.config.maxDate && self.config.maxDate < self.now 1086 ? self.config.maxDate 1087 : self.now); 1088 var oldYear = self.currentYear; 1089 var oldMonth = self.currentMonth; 1090 try { 1091 if (jumpTo !== undefined) { 1092 self.currentYear = jumpTo.getFullYear(); 1093 self.currentMonth = jumpTo.getMonth(); 1094 } 1095 } catch (e) { 1096 /* istanbul ignore next */ 1097 e.message = 'Invalid date supplied: ' + jumpTo; 1098 self.config.errorHandler(e); 1099 } 1100 if (triggerChange && self.currentYear !== oldYear) { 1101 triggerEvent('onYearChange'); 1102 buildMonthSwitch(); 1103 } 1104 if ( 1105 triggerChange && 1106 (self.currentYear !== oldYear || self.currentMonth !== oldMonth) 1107 ) { 1108 triggerEvent('onMonthChange'); 1109 } 1110 self.redraw(); 1111 } 1112 /** 1113 * The up/down arrow handler for time inputs 1114 * @param {Event} e the click event 1115 */ 1116 function timeIncrement(e) { 1117 var eventTarget = getEventTarget(e); 1118 if (~eventTarget.className.indexOf('arrow')) 1119 incrementNumInput( 1120 e, 1121 eventTarget.classList.contains('arrowUp') ? 1 : -1, 1122 ); 1123 } 1124 /** 1125 * Increments/decrements the value of input associ- 1126 * ated with the up/down arrow by dispatching an 1127 * "increment" event on the input. 1128 * 1129 * @param {Event} e the click event 1130 * @param {Number} delta the diff (usually 1 or -1) 1131 * @param {Element} inputElem the input element 1132 */ 1133 function incrementNumInput(e, delta, inputElem) { 1134 var target = e && getEventTarget(e); 1135 var input = 1136 inputElem || 1137 (target && target.parentNode && target.parentNode.firstChild); 1138 var event = createEvent('increment'); 1139 event.delta = delta; 1140 input && input.dispatchEvent(event); 1141 } 1142 function build() { 1143 var fragment = window.document.createDocumentFragment(); 1144 self.calendarContainer = createElement('div', 'flatpickr-calendar'); 1145 self.calendarContainer.tabIndex = -1; 1146 if (!self.config.noCalendar) { 1147 fragment.appendChild(buildMonthNav()); 1148 self.innerContainer = createElement('div', 'flatpickr-innerContainer'); 1149 if (self.config.weekNumbers) { 1150 var _a = buildWeeks(), 1151 weekWrapper = _a.weekWrapper, 1152 weekNumbers = _a.weekNumbers; 1153 self.innerContainer.appendChild(weekWrapper); 1154 self.weekNumbers = weekNumbers; 1155 self.weekWrapper = weekWrapper; 1156 } 1157 self.rContainer = createElement('div', 'flatpickr-rContainer'); 1158 self.rContainer.appendChild(buildWeekdays()); 1159 if (!self.daysContainer) { 1160 self.daysContainer = createElement('div', 'flatpickr-days'); 1161 self.daysContainer.tabIndex = -1; 1162 } 1163 buildDays(); 1164 self.rContainer.appendChild(self.daysContainer); 1165 self.innerContainer.appendChild(self.rContainer); 1166 fragment.appendChild(self.innerContainer); 1167 } 1168 if (self.config.enableTime) { 1169 fragment.appendChild(buildTime()); 1170 } 1171 toggleClass( 1172 self.calendarContainer, 1173 'rangeMode', 1174 self.config.mode === 'range', 1175 ); 1176 toggleClass( 1177 self.calendarContainer, 1178 'animate', 1179 self.config.animate === true, 1180 ); 1181 toggleClass( 1182 self.calendarContainer, 1183 'multiMonth', 1184 self.config.showMonths > 1, 1185 ); 1186 self.calendarContainer.appendChild(fragment); 1187 var customAppend = 1188 self.config.appendTo !== undefined && 1189 self.config.appendTo.nodeType !== undefined; 1190 if (self.config.inline || self.config.static) { 1191 self.calendarContainer.classList.add( 1192 self.config.inline ? 'inline' : 'static', 1193 ); 1194 if (self.config.inline) { 1195 if (!customAppend && self.element.parentNode) 1196 self.element.parentNode.insertBefore( 1197 self.calendarContainer, 1198 self._input.nextSibling, 1199 ); 1200 else if (self.config.appendTo !== undefined) 1201 self.config.appendTo.appendChild(self.calendarContainer); 1202 } 1203 if (self.config.static) { 1204 var wrapper = createElement('div', 'flatpickr-wrapper'); 1205 if (self.element.parentNode) 1206 self.element.parentNode.insertBefore(wrapper, self.element); 1207 wrapper.appendChild(self.element); 1208 if (self.altInput) wrapper.appendChild(self.altInput); 1209 wrapper.appendChild(self.calendarContainer); 1210 } 1211 } 1212 if (!self.config.static && !self.config.inline) 1213 (self.config.appendTo !== undefined 1214 ? self.config.appendTo 1215 : window.document.body 1216 ).appendChild(self.calendarContainer); 1217 } 1218 function createDay(className, date, _dayNumber, i) { 1219 var dateIsEnabled = isEnabled(date, true), 1220 dayElement = createElement( 1221 'span', 1222 className, 1223 date.getDate().toString(), 1224 ); 1225 dayElement.dateObj = date; 1226 dayElement.$i = i; 1227 dayElement.setAttribute( 1228 'aria-label', 1229 self.formatDate(date, self.config.ariaDateFormat), 1230 ); 1231 if ( 1232 className.indexOf('hidden') === -1 && 1233 compareDates(date, self.now) === 0 1234 ) { 1235 self.todayDateElem = dayElement; 1236 dayElement.classList.add('today'); 1237 dayElement.setAttribute('aria-current', 'date'); 1238 } 1239 if (dateIsEnabled) { 1240 dayElement.tabIndex = -1; 1241 if (isDateSelected(date)) { 1242 dayElement.classList.add('selected'); 1243 self.selectedDateElem = dayElement; 1244 if (self.config.mode === 'range') { 1245 toggleClass( 1246 dayElement, 1247 'startRange', 1248 self.selectedDates[0] && 1249 compareDates(date, self.selectedDates[0], true) === 0, 1250 ); 1251 toggleClass( 1252 dayElement, 1253 'endRange', 1254 self.selectedDates[1] && 1255 compareDates(date, self.selectedDates[1], true) === 0, 1256 ); 1257 if (className === 'nextMonthDay') 1258 dayElement.classList.add('inRange'); 1259 } 1260 } 1261 } else { 1262 dayElement.classList.add('flatpickr-disabled'); 1263 } 1264 if (self.config.mode === 'range') { 1265 if (isDateInRange(date) && !isDateSelected(date)) 1266 dayElement.classList.add('inRange'); 1267 } 1268 if ( 1269 self.weekNumbers && 1270 self.config.showMonths === 1 && 1271 className !== 'prevMonthDay' && 1272 i % 7 === 6 1273 ) { 1274 self.weekNumbers.insertAdjacentHTML( 1275 'beforeend', 1276 "<span class='flatpickr-day'>" + 1277 self.config.getWeek(date) + 1278 '</span>', 1279 ); 1280 } 1281 triggerEvent('onDayCreate', dayElement); 1282 return dayElement; 1283 } 1284 function focusOnDayElem(targetNode) { 1285 targetNode.focus(); 1286 if (self.config.mode === 'range') onMouseOver(targetNode); 1287 } 1288 function getFirstAvailableDay(delta) { 1289 var startMonth = delta > 0 ? 0 : self.config.showMonths - 1; 1290 var endMonth = delta > 0 ? self.config.showMonths : -1; 1291 for (var m = startMonth; m != endMonth; m += delta) { 1292 var month = self.daysContainer.children[m]; 1293 var startIndex = delta > 0 ? 0 : month.children.length - 1; 1294 var endIndex = delta > 0 ? month.children.length : -1; 1295 for (var i = startIndex; i != endIndex; i += delta) { 1296 var c = month.children[i]; 1297 if (c.className.indexOf('hidden') === -1 && isEnabled(c.dateObj)) 1298 return c; 1299 } 1300 } 1301 return undefined; 1302 } 1303 function getNextAvailableDay(current, delta) { 1304 var givenMonth = 1305 current.className.indexOf('Month') === -1 1306 ? current.dateObj.getMonth() 1307 : self.currentMonth; 1308 var endMonth = delta > 0 ? self.config.showMonths : -1; 1309 var loopDelta = delta > 0 ? 1 : -1; 1310 for ( 1311 var m = givenMonth - self.currentMonth; 1312 m != endMonth; 1313 m += loopDelta 1314 ) { 1315 var month = self.daysContainer.children[m]; 1316 var startIndex = 1317 givenMonth - self.currentMonth === m 1318 ? current.$i + delta 1319 : delta < 0 1320 ? month.children.length - 1 1321 : 0; 1322 var numMonthDays = month.children.length; 1323 for ( 1324 var i = startIndex; 1325 i >= 0 && i < numMonthDays && i != (delta > 0 ? numMonthDays : -1); 1326 i += loopDelta 1327 ) { 1328 var c = month.children[i]; 1329 if ( 1330 c.className.indexOf('hidden') === -1 && 1331 isEnabled(c.dateObj) && 1332 Math.abs(current.$i - i) >= Math.abs(delta) 1333 ) 1334 return focusOnDayElem(c); 1335 } 1336 } 1337 self.changeMonth(loopDelta); 1338 focusOnDay(getFirstAvailableDay(loopDelta), 0); 1339 return undefined; 1340 } 1341 function focusOnDay(current, offset) { 1342 var activeElement = getClosestActiveElement(); 1343 var dayFocused = isInView(activeElement || document.body); 1344 var startElem = 1345 current !== undefined 1346 ? current 1347 : dayFocused 1348 ? activeElement 1349 : self.selectedDateElem !== undefined && 1350 isInView(self.selectedDateElem) 1351 ? self.selectedDateElem 1352 : self.todayDateElem !== undefined && isInView(self.todayDateElem) 1353 ? self.todayDateElem 1354 : getFirstAvailableDay(offset > 0 ? 1 : -1); 1355 if (startElem === undefined) { 1356 self._input.focus(); 1357 } else if (!dayFocused) { 1358 focusOnDayElem(startElem); 1359 } else { 1360 getNextAvailableDay(startElem, offset); 1361 } 1362 } 1363 function buildMonthDays(year, month) { 1364 var firstOfMonth = 1365 (new Date(year, month, 1).getDay() - self.l10n.firstDayOfWeek + 7) % 7; 1366 var prevMonthDays = self.utils.getDaysInMonth( 1367 (month - 1 + 12) % 12, 1368 year, 1369 ); 1370 var daysInMonth = self.utils.getDaysInMonth(month, year), 1371 days = window.document.createDocumentFragment(), 1372 isMultiMonth = self.config.showMonths > 1, 1373 prevMonthDayClass = isMultiMonth 1374 ? 'prevMonthDay hidden' 1375 : 'prevMonthDay', 1376 nextMonthDayClass = isMultiMonth 1377 ? 'nextMonthDay hidden' 1378 : 'nextMonthDay'; 1379 var dayNumber = prevMonthDays + 1 - firstOfMonth, 1380 dayIndex = 0; 1381 // prepend days from the ending of previous month 1382 for (; dayNumber <= prevMonthDays; dayNumber++, dayIndex++) { 1383 days.appendChild( 1384 createDay( 1385 'flatpickr-day ' + prevMonthDayClass, 1386 new Date(year, month - 1, dayNumber), 1387 dayNumber, 1388 dayIndex, 1389 ), 1390 ); 1391 } 1392 // Start at 1 since there is no 0th day 1393 for (dayNumber = 1; dayNumber <= daysInMonth; dayNumber++, dayIndex++) { 1394 days.appendChild( 1395 createDay( 1396 'flatpickr-day', 1397 new Date(year, month, dayNumber), 1398 dayNumber, 1399 dayIndex, 1400 ), 1401 ); 1402 } 1403 // append days from the next month 1404 for ( 1405 var dayNum = daysInMonth + 1; 1406 dayNum <= 42 - firstOfMonth && 1407 (self.config.showMonths === 1 || dayIndex % 7 !== 0); 1408 dayNum++, dayIndex++ 1409 ) { 1410 days.appendChild( 1411 createDay( 1412 'flatpickr-day ' + nextMonthDayClass, 1413 new Date(year, month + 1, dayNum % daysInMonth), 1414 dayNum, 1415 dayIndex, 1416 ), 1417 ); 1418 } 1419 //updateNavigationCurrentMonth(); 1420 var dayContainer = createElement('div', 'dayContainer'); 1421 dayContainer.appendChild(days); 1422 return dayContainer; 1423 } 1424 function buildDays() { 1425 if (self.daysContainer === undefined) { 1426 return; 1427 } 1428 clearNode(self.daysContainer); 1429 // TODO: week numbers for each month 1430 if (self.weekNumbers) clearNode(self.weekNumbers); 1431 var frag = document.createDocumentFragment(); 1432 for (var i = 0; i < self.config.showMonths; i++) { 1433 var d = new Date(self.currentYear, self.currentMonth, 1); 1434 d.setMonth(self.currentMonth + i); 1435 frag.appendChild(buildMonthDays(d.getFullYear(), d.getMonth())); 1436 } 1437 self.daysContainer.appendChild(frag); 1438 self.days = self.daysContainer.firstChild; 1439 if (self.config.mode === 'range' && self.selectedDates.length === 1) { 1440 onMouseOver(); 1441 } 1442 } 1443 function buildMonthSwitch() { 1444 if ( 1445 self.config.showMonths > 1 || 1446 self.config.monthSelectorType !== 'dropdown' 1447 ) 1448 return; 1449 var shouldBuildMonth = function (month) { 1450 if ( 1451 self.config.minDate !== undefined && 1452 self.currentYear === self.config.minDate.getFullYear() && 1453 month < self.config.minDate.getMonth() 1454 ) { 1455 return false; 1456 } 1457 return !( 1458 self.config.maxDate !== undefined && 1459 self.currentYear === self.config.maxDate.getFullYear() && 1460 month > self.config.maxDate.getMonth() 1461 ); 1462 }; 1463 self.monthsDropdownContainer.tabIndex = -1; 1464 self.monthsDropdownContainer.innerHTML = ''; 1465 for (var i = 0; i < 12; i++) { 1466 if (!shouldBuildMonth(i)) continue; 1467 var month = createElement('option', 'flatpickr-monthDropdown-month'); 1468 month.value = new Date(self.currentYear, i).getMonth().toString(); 1469 month.textContent = monthToStr( 1470 i, 1471 self.config.shorthandCurrentMonth, 1472 self.l10n, 1473 ); 1474 month.tabIndex = -1; 1475 if (self.currentMonth === i) { 1476 month.selected = true; 1477 } 1478 self.monthsDropdownContainer.appendChild(month); 1479 } 1480 } 1481 function buildMonth() { 1482 var container = createElement('div', 'flatpickr-month'); 1483 var monthNavFragment = window.document.createDocumentFragment(); 1484 var monthElement; 1485 if ( 1486 self.config.showMonths > 1 || 1487 self.config.monthSelectorType === 'static' 1488 ) { 1489 monthElement = createElement('span', 'cur-month'); 1490 } else { 1491 self.monthsDropdownContainer = createElement( 1492 'select', 1493 'flatpickr-monthDropdown-months', 1494 ); 1495 self.monthsDropdownContainer.setAttribute( 1496 'aria-label', 1497 self.l10n.monthAriaLabel, 1498 ); 1499 bind(self.monthsDropdownContainer, 'change', function (e) { 1500 var target = getEventTarget(e); 1501 var selectedMonth = parseInt(target.value, 10); 1502 self.changeMonth(selectedMonth - self.currentMonth); 1503 triggerEvent('onMonthChange'); 1504 }); 1505 buildMonthSwitch(); 1506 monthElement = self.monthsDropdownContainer; 1507 } 1508 var yearInput = createNumberInput('cur-year', { tabindex: '-1' }); 1509 var yearElement = yearInput.getElementsByTagName('input')[0]; 1510 yearElement.setAttribute('aria-label', self.l10n.yearAriaLabel); 1511 if (self.config.minDate) { 1512 yearElement.setAttribute( 1513 'min', 1514 self.config.minDate.getFullYear().toString(), 1515 ); 1516 } 1517 if (self.config.maxDate) { 1518 yearElement.setAttribute( 1519 'max', 1520 self.config.maxDate.getFullYear().toString(), 1521 ); 1522 yearElement.disabled = 1523 !!self.config.minDate && 1524 self.config.minDate.getFullYear() === 1525 self.config.maxDate.getFullYear(); 1526 } 1527 var currentMonth = createElement('div', 'flatpickr-current-month'); 1528 currentMonth.appendChild(monthElement); 1529 currentMonth.appendChild(yearInput); 1530 monthNavFragment.appendChild(currentMonth); 1531 container.appendChild(monthNavFragment); 1532 return { 1533 container: container, 1534 yearElement: yearElement, 1535 monthElement: monthElement, 1536 }; 1537 } 1538 function buildMonths() { 1539 clearNode(self.monthNav); 1540 self.monthNav.appendChild(self.prevMonthNav); 1541 if (self.config.showMonths) { 1542 self.yearElements = []; 1543 self.monthElements = []; 1544 } 1545 for (var m = self.config.showMonths; m--; ) { 1546 var month = buildMonth(); 1547 self.yearElements.push(month.yearElement); 1548 self.monthElements.push(month.monthElement); 1549 self.monthNav.appendChild(month.container); 1550 } 1551 self.monthNav.appendChild(self.nextMonthNav); 1552 } 1553 function buildMonthNav() { 1554 self.monthNav = createElement('div', 'flatpickr-months'); 1555 self.yearElements = []; 1556 self.monthElements = []; 1557 self.prevMonthNav = createElement('span', 'flatpickr-prev-month'); 1558 self.prevMonthNav.innerHTML = self.config.prevArrow; 1559 self.nextMonthNav = createElement('span', 'flatpickr-next-month'); 1560 self.nextMonthNav.innerHTML = self.config.nextArrow; 1561 buildMonths(); 1562 Object.defineProperty(self, '_hidePrevMonthArrow', { 1563 get: function () { 1564 return self.__hidePrevMonthArrow; 1565 }, 1566 set: function (bool) { 1567 if (self.__hidePrevMonthArrow !== bool) { 1568 toggleClass(self.prevMonthNav, 'flatpickr-disabled', bool); 1569 self.__hidePrevMonthArrow = bool; 1570 } 1571 }, 1572 }); 1573 Object.defineProperty(self, '_hideNextMonthArrow', { 1574 get: function () { 1575 return self.__hideNextMonthArrow; 1576 }, 1577 set: function (bool) { 1578 if (self.__hideNextMonthArrow !== bool) { 1579 toggleClass(self.nextMonthNav, 'flatpickr-disabled', bool); 1580 self.__hideNextMonthArrow = bool; 1581 } 1582 }, 1583 }); 1584 self.currentYearElement = self.yearElements[0]; 1585 updateNavigationCurrentMonth(); 1586 return self.monthNav; 1587 } 1588 function buildTime() { 1589 self.calendarContainer.classList.add('hasTime'); 1590 if (self.config.noCalendar) 1591 self.calendarContainer.classList.add('noCalendar'); 1592 var defaults = getDefaultHours(self.config); 1593 self.timeContainer = createElement('div', 'flatpickr-time'); 1594 self.timeContainer.tabIndex = -1; 1595 var separator = createElement('span', 'flatpickr-time-separator', ':'); 1596 var hourInput = createNumberInput('flatpickr-hour', { 1597 'aria-label': self.l10n.hourAriaLabel, 1598 }); 1599 self.hourElement = hourInput.getElementsByTagName('input')[0]; 1600 var minuteInput = createNumberInput('flatpickr-minute', { 1601 'aria-label': self.l10n.minuteAriaLabel, 1602 }); 1603 self.minuteElement = minuteInput.getElementsByTagName('input')[0]; 1604 self.hourElement.tabIndex = self.minuteElement.tabIndex = -1; 1605 self.hourElement.value = pad( 1606 self.latestSelectedDateObj 1607 ? self.latestSelectedDateObj.getHours() 1608 : self.config.time_24hr 1609 ? defaults.hours 1610 : military2ampm(defaults.hours), 1611 ); 1612 self.minuteElement.value = pad( 1613 self.latestSelectedDateObj 1614 ? self.latestSelectedDateObj.getMinutes() 1615 : defaults.minutes, 1616 ); 1617 self.hourElement.setAttribute( 1618 'step', 1619 self.config.hourIncrement.toString(), 1620 ); 1621 self.minuteElement.setAttribute( 1622 'step', 1623 self.config.minuteIncrement.toString(), 1624 ); 1625 self.hourElement.setAttribute('min', self.config.time_24hr ? '0' : '1'); 1626 self.hourElement.setAttribute('max', self.config.time_24hr ? '23' : '12'); 1627 self.hourElement.setAttribute('maxlength', '2'); 1628 self.minuteElement.setAttribute('min', '0'); 1629 self.minuteElement.setAttribute('max', '59'); 1630 self.minuteElement.setAttribute('maxlength', '2'); 1631 self.timeContainer.appendChild(hourInput); 1632 self.timeContainer.appendChild(separator); 1633 self.timeContainer.appendChild(minuteInput); 1634 if (self.config.time_24hr) self.timeContainer.classList.add('time24hr'); 1635 if (self.config.enableSeconds) { 1636 self.timeContainer.classList.add('hasSeconds'); 1637 var secondInput = createNumberInput('flatpickr-second'); 1638 self.secondElement = secondInput.getElementsByTagName('input')[0]; 1639 self.secondElement.value = pad( 1640 self.latestSelectedDateObj 1641 ? self.latestSelectedDateObj.getSeconds() 1642 : defaults.seconds, 1643 ); 1644 self.secondElement.setAttribute( 1645 'step', 1646 self.minuteElement.getAttribute('step'), 1647 ); 1648 self.secondElement.setAttribute('min', '0'); 1649 self.secondElement.setAttribute('max', '59'); 1650 self.secondElement.setAttribute('maxlength', '2'); 1651 self.timeContainer.appendChild( 1652 createElement('span', 'flatpickr-time-separator', ':'), 1653 ); 1654 self.timeContainer.appendChild(secondInput); 1655 } 1656 if (!self.config.time_24hr) { 1657 // add self.amPM if appropriate 1658 self.amPM = createElement( 1659 'span', 1660 'flatpickr-am-pm', 1661 self.l10n.amPM[ 1662 int( 1663 (self.latestSelectedDateObj 1664 ? self.hourElement.value 1665 : self.config.defaultHour) > 11, 1666 ) 1667 ], 1668 ); 1669 self.amPM.title = self.l10n.toggleTitle; 1670 self.amPM.tabIndex = -1; 1671 self.timeContainer.appendChild(self.amPM); 1672 } 1673 return self.timeContainer; 1674 } 1675 function buildWeekdays() { 1676 if (!self.weekdayContainer) 1677 self.weekdayContainer = createElement('div', 'flatpickr-weekdays'); 1678 else clearNode(self.weekdayContainer); 1679 for (var i = self.config.showMonths; i--; ) { 1680 var container = createElement('div', 'flatpickr-weekdaycontainer'); 1681 self.weekdayContainer.appendChild(container); 1682 } 1683 updateWeekdays(); 1684 return self.weekdayContainer; 1685 } 1686 function updateWeekdays() { 1687 if (!self.weekdayContainer) { 1688 return; 1689 } 1690 var firstDayOfWeek = self.l10n.firstDayOfWeek; 1691 var weekdays = __spreadArrays(self.l10n.weekdays.shorthand); 1692 if (firstDayOfWeek > 0 && firstDayOfWeek < weekdays.length) { 1693 weekdays = __spreadArrays( 1694 weekdays.splice(firstDayOfWeek, weekdays.length), 1695 weekdays.splice(0, firstDayOfWeek), 1696 ); 1697 } 1698 for (var i = self.config.showMonths; i--; ) { 1699 self.weekdayContainer.children[i].innerHTML = 1700 "\n <span class='flatpickr-weekday'>\n " + 1701 weekdays.join("</span><span class='flatpickr-weekday'>") + 1702 '\n </span>\n '; 1703 } 1704 } 1705 /* istanbul ignore next */ 1706 function buildWeeks() { 1707 self.calendarContainer.classList.add('hasWeeks'); 1708 var weekWrapper = createElement('div', 'flatpickr-weekwrapper'); 1709 weekWrapper.appendChild( 1710 createElement('span', 'flatpickr-weekday', self.l10n.weekAbbreviation), 1711 ); 1712 var weekNumbers = createElement('div', 'flatpickr-weeks'); 1713 weekWrapper.appendChild(weekNumbers); 1714 return { 1715 weekWrapper: weekWrapper, 1716 weekNumbers: weekNumbers, 1717 }; 1718 } 1719 function changeMonth(value, isOffset) { 1720 if (isOffset === void 0) { 1721 isOffset = true; 1722 } 1723 var delta = isOffset ? value : value - self.currentMonth; 1724 if ( 1725 (delta < 0 && self._hidePrevMonthArrow === true) || 1726 (delta > 0 && self._hideNextMonthArrow === true) 1727 ) 1728 return; 1729 self.currentMonth += delta; 1730 if (self.currentMonth < 0 || self.currentMonth > 11) { 1731 self.currentYear += self.currentMonth > 11 ? 1 : -1; 1732 self.currentMonth = (self.currentMonth + 12) % 12; 1733 triggerEvent('onYearChange'); 1734 buildMonthSwitch(); 1735 } 1736 buildDays(); 1737 triggerEvent('onMonthChange'); 1738 updateNavigationCurrentMonth(); 1739 } 1740 function clear(triggerChangeEvent, toInitial) { 1741 if (triggerChangeEvent === void 0) { 1742 triggerChangeEvent = true; 1743 } 1744 if (toInitial === void 0) { 1745 toInitial = true; 1746 } 1747 self.input.value = ''; 1748 if (self.altInput !== undefined) self.altInput.value = ''; 1749 if (self.mobileInput !== undefined) self.mobileInput.value = ''; 1750 self.selectedDates = []; 1751 self.latestSelectedDateObj = undefined; 1752 if (toInitial === true) { 1753 self.currentYear = self._initialDate.getFullYear(); 1754 self.currentMonth = self._initialDate.getMonth(); 1755 } 1756 if (self.config.enableTime === true) { 1757 var _a = getDefaultHours(self.config), 1758 hours = _a.hours, 1759 minutes = _a.minutes, 1760 seconds = _a.seconds; 1761 setHours(hours, minutes, seconds); 1762 } 1763 self.redraw(); 1764 if (triggerChangeEvent) 1765 // triggerChangeEvent is true (default) or an Event 1766 triggerEvent('onChange'); 1767 } 1768 function close() { 1769 self.isOpen = false; 1770 if (!self.isMobile) { 1771 if (self.calendarContainer !== undefined) { 1772 self.calendarContainer.classList.remove('open'); 1773 } 1774 if (self._input !== undefined) { 1775 self._input.classList.remove('active'); 1776 } 1777 } 1778 triggerEvent('onClose'); 1779 } 1780 function destroy() { 1781 if (self.config !== undefined) triggerEvent('onDestroy'); 1782 for (var i = self._handlers.length; i--; ) { 1783 self._handlers[i].remove(); 1784 } 1785 self._handlers = []; 1786 if (self.mobileInput) { 1787 if (self.mobileInput.parentNode) 1788 self.mobileInput.parentNode.removeChild(self.mobileInput); 1789 self.mobileInput = undefined; 1790 } else if (self.calendarContainer && self.calendarContainer.parentNode) { 1791 if (self.config.static && self.calendarContainer.parentNode) { 1792 var wrapper = self.calendarContainer.parentNode; 1793 wrapper.lastChild && wrapper.removeChild(wrapper.lastChild); 1794 if (wrapper.parentNode) { 1795 while (wrapper.firstChild) 1796 wrapper.parentNode.insertBefore(wrapper.firstChild, wrapper); 1797 wrapper.parentNode.removeChild(wrapper); 1798 } 1799 } else 1800 self.calendarContainer.parentNode.removeChild(self.calendarContainer); 1801 } 1802 if (self.altInput) { 1803 self.input.type = 'text'; 1804 if (self.altInput.parentNode) 1805 self.altInput.parentNode.removeChild(self.altInput); 1806 delete self.altInput; 1807 } 1808 if (self.input) { 1809 self.input.type = self.input._type; 1810 self.input.classList.remove('flatpickr-input'); 1811 self.input.removeAttribute('readonly'); 1812 } 1813 [ 1814 '_showTimeInput', 1815 'latestSelectedDateObj', 1816 '_hideNextMonthArrow', 1817 '_hidePrevMonthArrow', 1818 '__hideNextMonthArrow', 1819 '__hidePrevMonthArrow', 1820 'isMobile', 1821 'isOpen', 1822 'selectedDateElem', 1823 'minDateHasTime', 1824 'maxDateHasTime', 1825 'days', 1826 'daysContainer', 1827 '_input', 1828 '_positionElement', 1829 'innerContainer', 1830 'rContainer', 1831 'monthNav', 1832 'todayDateElem', 1833 'calendarContainer', 1834 'weekdayContainer', 1835 'prevMonthNav', 1836 'nextMonthNav', 1837 'monthsDropdownContainer', 1838 'currentMonthElement', 1839 'currentYearElement', 1840 'navigationCurrentMonth', 1841 'selectedDateElem', 1842 'config', 1843 ].forEach(function (k) { 1844 try { 1845 delete self[k]; 1846 } catch (_) {} 1847 }); 1848 } 1849 function isCalendarElem(elem) { 1850 return self.calendarContainer.contains(elem); 1851 } 1852 function documentClick(e) { 1853 if (self.isOpen && !self.config.inline) { 1854 var eventTarget_1 = getEventTarget(e); 1855 var isCalendarElement = isCalendarElem(eventTarget_1); 1856 var isInput = 1857 eventTarget_1 === self.input || 1858 eventTarget_1 === self.altInput || 1859 self.element.contains(eventTarget_1) || 1860 // web components 1861 // e.path is not present in all browsers. circumventing typechecks 1862 (e.path && 1863 e.path.indexOf && 1864 (~e.path.indexOf(self.input) || ~e.path.indexOf(self.altInput))); 1865 var lostFocus = 1866 !isInput && !isCalendarElement && !isCalendarElem(e.relatedTarget); 1867 var isIgnored = !self.config.ignoredFocusElements.some(function (elem) { 1868 return elem.contains(eventTarget_1); 1869 }); 1870 if (lostFocus && isIgnored) { 1871 if (self.config.allowInput) { 1872 self.setDate( 1873 self._input.value, 1874 false, 1875 self.config.altInput 1876 ? self.config.altFormat 1877 : self.config.dateFormat, 1878 ); 1879 } 1880 if ( 1881 self.timeContainer !== undefined && 1882 self.minuteElement !== undefined && 1883 self.hourElement !== undefined && 1884 self.input.value !== '' && 1885 self.input.value !== undefined 1886 ) { 1887 updateTime(); 1888 } 1889 self.close(); 1890 if ( 1891 self.config && 1892 self.config.mode === 'range' && 1893 self.selectedDates.length === 1 1894 ) 1895 self.clear(false); 1896 } 1897 } 1898 } 1899 function changeYear(newYear) { 1900 if ( 1901 !newYear || 1902 (self.config.minDate && newYear < self.config.minDate.getFullYear()) || 1903 (self.config.maxDate && newYear > self.config.maxDate.getFullYear()) 1904 ) 1905 return; 1906 var newYearNum = newYear, 1907 isNewYear = self.currentYear !== newYearNum; 1908 self.currentYear = newYearNum || self.currentYear; 1909 if ( 1910 self.config.maxDate && 1911 self.currentYear === self.config.maxDate.getFullYear() 1912 ) { 1913 self.currentMonth = Math.min( 1914 self.config.maxDate.getMonth(), 1915 self.currentMonth, 1916 ); 1917 } else if ( 1918 self.config.minDate && 1919 self.currentYear === self.config.minDate.getFullYear() 1920 ) { 1921 self.currentMonth = Math.max( 1922 self.config.minDate.getMonth(), 1923 self.currentMonth, 1924 ); 1925 } 1926 if (isNewYear) { 1927 self.redraw(); 1928 triggerEvent('onYearChange'); 1929 buildMonthSwitch(); 1930 } 1931 } 1932 function isEnabled(date, timeless) { 1933 var _a; 1934 if (timeless === void 0) { 1935 timeless = true; 1936 } 1937 var dateToCheck = self.parseDate(date, undefined, timeless); // timeless 1938 if ( 1939 (self.config.minDate && 1940 dateToCheck && 1941 compareDates( 1942 dateToCheck, 1943 self.config.minDate, 1944 timeless !== undefined ? timeless : !self.minDateHasTime, 1945 ) < 0) || 1946 (self.config.maxDate && 1947 dateToCheck && 1948 compareDates( 1949 dateToCheck, 1950 self.config.maxDate, 1951 timeless !== undefined ? timeless : !self.maxDateHasTime, 1952 ) > 0) 1953 ) 1954 return false;
vendor: 7,018 bytes, lines 1955-2160
1955 if (!self.config.enable && self.config.disable.length === 0) return true; 1956 if (dateToCheck === undefined) return false; 1957 var bool = !!self.config.enable, 1958 array = 1959 (_a = self.config.enable) !== null && _a !== void 0 1960 ? _a 1961 : self.config.disable; 1962 for (var i = 0, d = void 0; i < array.length; i++) { 1963 d = array[i]; 1964 if ( 1965 typeof d === 'function' && 1966 d(dateToCheck) // disabled by function 1967 ) 1968 return bool; 1969 else if ( 1970 d instanceof Date && 1971 dateToCheck !== undefined && 1972 d.getTime() === dateToCheck.getTime() 1973 ) 1974 // disabled by date 1975 return bool; 1976 else if (typeof d === 'string') { 1977 // disabled by date string 1978 var parsed = self.parseDate(d, undefined, true); 1979 return parsed && parsed.getTime() === dateToCheck.getTime() 1980 ? bool 1981 : !bool; 1982 } else if ( 1983 // disabled by range 1984 typeof d === 'object' && 1985 dateToCheck !== undefined && 1986 d.from && 1987 d.to && 1988 dateToCheck.getTime() >= d.from.getTime() && 1989 dateToCheck.getTime() <= d.to.getTime() 1990 ) 1991 return bool; 1992 } 1993 return !bool; 1994 } 1995 function isInView(elem) { 1996 if (self.daysContainer !== undefined) 1997 return ( 1998 elem.className.indexOf('hidden') === -1 && 1999 elem.className.indexOf('flatpickr-disabled') === -1 && 2000 self.daysContainer.contains(elem) 2001 ); 2002 return false; 2003 } 2004 function onBlur(e) { 2005 var isInput = e.target === self._input; 2006 var valueChanged = self._input.value.trimEnd() !== getDateStr(); 2007 if ( 2008 isInput && 2009 valueChanged && 2010 !(e.relatedTarget && isCalendarElem(e.relatedTarget)) 2011 ) { 2012 self.setDate( 2013 self._input.value, 2014 true, 2015 e.target === self.altInput 2016 ? self.config.altFormat 2017 : self.config.dateFormat, 2018 ); 2019 } 2020 } 2021 function onKeyDown(e) { 2022 // e.key e.keyCode 2023 // "Backspace" 8 2024 // "Tab" 9 2025 // "Enter" 13 2026 // "Escape" (IE "Esc") 27 2027 // "ArrowLeft" (IE "Left") 37 2028 // "ArrowUp" (IE "Up") 38 2029 // "ArrowRight" (IE "Right") 39 2030 // "ArrowDown" (IE "Down") 40 2031 // "Delete" (IE "Del") 46 2032 var eventTarget = getEventTarget(e); 2033 var isInput = self.config.wrap 2034 ? element.contains(eventTarget) 2035 : eventTarget === self._input; 2036 var allowInput = self.config.allowInput; 2037 var allowKeydown = self.isOpen && (!allowInput || !isInput); 2038 var allowInlineKeydown = self.config.inline && isInput && !allowInput; 2039 if ( 2040 (e.keyCode === 13 && isInput) || 2041 (e.keyCode === 27 && isInput && allowInput) 2042 ) { 2043 if (allowInput) { 2044 self.setDate( 2045 self._input.value, 2046 true, 2047 eventTarget === self.altInput 2048 ? self.config.altFormat 2049 : self.config.dateFormat, 2050 ); 2051 self.close(); 2052 return eventTarget.blur(); 2053 } else { 2054 self.open(); 2055 } 2056 } else if ( 2057 isCalendarElem(eventTarget) || 2058 allowKeydown || 2059 allowInlineKeydown || 2060 (allowInput && [38, 40].includes(e.keyCode)) 2061 ) { 2062 var isTimeObj = 2063 !!self.timeContainer && self.timeContainer.contains(eventTarget); 2064 switch (e.keyCode) { 2065 case 13: 2066 if (isTimeObj) { 2067 e.preventDefault(); 2068 updateTime(); 2069 focusAndClose(); 2070 } else selectDate(e); 2071 break; 2072 case 27: // escape 2073 e.preventDefault(); 2074 focusAndClose(); 2075 break; 2076 case 8: 2077 case 46: 2078 if (isInput && !self.config.allowInput) { 2079 e.preventDefault(); 2080 self.clear(); 2081 } 2082 break; 2083 case 37: 2084 case 39: 2085 if (!isTimeObj && !isInput) { 2086 e.preventDefault(); 2087 var activeElement = getClosestActiveElement(); 2088 if ( 2089 self.daysContainer !== undefined && 2090 (allowInput === false || 2091 (activeElement && isInView(activeElement))) 2092 ) { 2093 var delta_1 = e.keyCode === 39 ? 1 : -1; 2094 if (!e.ctrlKey) focusOnDay(undefined, delta_1); 2095 else { 2096 e.stopPropagation(); 2097 changeMonth(delta_1); 2098 focusOnDay(getFirstAvailableDay(1), 0); 2099 } 2100 } 2101 } else if (self.hourElement) self.hourElement.focus(); 2102 break; 2103 case 38: 2104 case 40: 2105 e.preventDefault(); 2106 var delta = e.keyCode === 40 ? 1 : -1; 2107 if ( 2108 (self.daysContainer && eventTarget.$i !== undefined) || 2109 eventTarget === self.input || 2110 eventTarget === self.altInput 2111 ) { 2112 if (e.ctrlKey) { 2113 e.stopPropagation(); 2114 changeYear(self.currentYear - delta); 2115 focusOnDay(getFirstAvailableDay(1), 0); 2116 } else if (!isTimeObj) focusOnDay(undefined, delta * 7); 2117 } else if (eventTarget === self.currentYearElement) { 2118 changeYear(self.currentYear - delta); 2119 } else if (self.config.enableTime) { 2120 if (!isTimeObj && self.hourElement) self.hourElement.focus(); 2121 updateTime(e); 2122 self._debouncedChange(); 2123 } 2124 break; 2125 case 9: 2126 if (isTimeObj) { 2127 var elems = [ 2128 self.hourElement, 2129 self.minuteElement, 2130 self.secondElement, 2131 self.amPM, 2132 ] 2133 .concat(self.pluginElements) 2134 .filter(function (x) { 2135 return x; 2136 }); 2137 var i = elems.indexOf(eventTarget); 2138 if (i !== -1) { 2139 var target = elems[i + (e.shiftKey ? -1 : 1)]; 2140 e.preventDefault(); 2141 (target || self._input).focus(); 2142 } 2143 } else if ( 2144 !self.config.noCalendar && 2145 self.daysContainer && 2146 self.daysContainer.contains(eventTarget) && 2147 e.shiftKey 2148 ) { 2149 e.preventDefault(); 2150 self._input.focus(); 2151 } 2152 break; 2153 } 2154 } 2155 if (self.amPM !== undefined && eventTarget === self.amPM) { 2156 switch (e.key) { 2157 case self.l10n.amPM[0].charAt(0): 2158 case self.l10n.amPM[0].charAt(0).toLowerCase(): 2159 self.amPM.textContent = self.l10n.amPM[0]; 2160 setHoursFromInputs();
vendor: 19,033 bytes, lines 2161-2682
2161 updateValue(); 2162 break; 2163 case self.l10n.amPM[1].charAt(0): 2164 case self.l10n.amPM[1].charAt(0).toLowerCase(): 2165 self.amPM.textContent = self.l10n.amPM[1]; 2166 setHoursFromInputs(); 2167 updateValue(); 2168 break; 2169 } 2170 } 2171 if (isInput || isCalendarElem(eventTarget)) { 2172 triggerEvent('onKeyDown', e); 2173 } 2174 } 2175 function onMouseOver(elem, cellClass) { 2176 if (cellClass === void 0) { 2177 cellClass = 'flatpickr-day'; 2178 } 2179 if ( 2180 self.selectedDates.length !== 1 || 2181 (elem && 2182 (!elem.classList.contains(cellClass) || 2183 elem.classList.contains('flatpickr-disabled'))) 2184 ) 2185 return; 2186 var hoverDate = elem 2187 ? elem.dateObj.getTime() 2188 : self.days.firstElementChild.dateObj.getTime(), 2189 initialDate = self 2190 .parseDate(self.selectedDates[0], undefined, true) 2191 .getTime(), 2192 rangeStartDate = Math.min(hoverDate, self.selectedDates[0].getTime()), 2193 rangeEndDate = Math.max(hoverDate, self.selectedDates[0].getTime()); 2194 var containsDisabled = false; 2195 var minRange = 0, 2196 maxRange = 0; 2197 for (var t = rangeStartDate; t < rangeEndDate; t += duration.DAY) { 2198 if (!isEnabled(new Date(t), true)) { 2199 containsDisabled = 2200 containsDisabled || (t > rangeStartDate && t < rangeEndDate); 2201 if (t < initialDate && (!minRange || t > minRange)) minRange = t; 2202 else if (t > initialDate && (!maxRange || t < maxRange)) maxRange = t; 2203 } 2204 } 2205 var hoverableCells = Array.from( 2206 self.rContainer.querySelectorAll( 2207 '*:nth-child(-n+' + self.config.showMonths + ') > .' + cellClass, 2208 ), 2209 ); 2210 hoverableCells.forEach(function (dayElem) { 2211 var date = dayElem.dateObj; 2212 var timestamp = date.getTime(); 2213 var outOfRange = 2214 (minRange > 0 && timestamp < minRange) || 2215 (maxRange > 0 && timestamp > maxRange); 2216 if (outOfRange) { 2217 dayElem.classList.add('notAllowed'); 2218 ['inRange', 'startRange', 'endRange'].forEach(function (c) { 2219 dayElem.classList.remove(c); 2220 }); 2221 return; 2222 } else if (containsDisabled && !outOfRange) return; 2223 ['startRange', 'inRange', 'endRange', 'notAllowed'].forEach(function ( 2224 c, 2225 ) { 2226 dayElem.classList.remove(c); 2227 }); 2228 if (elem !== undefined) { 2229 elem.classList.add( 2230 hoverDate <= self.selectedDates[0].getTime() 2231 ? 'startRange' 2232 : 'endRange', 2233 ); 2234 if (initialDate < hoverDate && timestamp === initialDate) 2235 dayElem.classList.add('startRange'); 2236 else if (initialDate > hoverDate && timestamp === initialDate) 2237 dayElem.classList.add('endRange'); 2238 if ( 2239 timestamp >= minRange && 2240 (maxRange === 0 || timestamp <= maxRange) && 2241 isBetween(timestamp, initialDate, hoverDate) 2242 ) 2243 dayElem.classList.add('inRange'); 2244 } 2245 }); 2246 } 2247 function onResize() { 2248 if (self.isOpen && !self.config.static && !self.config.inline) 2249 positionCalendar(); 2250 } 2251 function open(e, positionElement) { 2252 if (positionElement === void 0) { 2253 positionElement = self._positionElement; 2254 } 2255 if (self.isMobile === true) { 2256 if (e) { 2257 e.preventDefault(); 2258 var eventTarget = getEventTarget(e); 2259 if (eventTarget) { 2260 eventTarget.blur(); 2261 } 2262 } 2263 if (self.mobileInput !== undefined) { 2264 self.mobileInput.focus(); 2265 self.mobileInput.click(); 2266 } 2267 triggerEvent('onOpen'); 2268 return; 2269 } else if (self._input.disabled || self.config.inline) { 2270 return; 2271 } 2272 var wasOpen = self.isOpen; 2273 self.isOpen = true; 2274 if (!wasOpen) { 2275 self.calendarContainer.classList.add('open'); 2276 self._input.classList.add('active'); 2277 triggerEvent('onOpen'); 2278 positionCalendar(positionElement); 2279 } 2280 if (self.config.enableTime === true && self.config.noCalendar === true) { 2281 if ( 2282 self.config.allowInput === false && 2283 (e === undefined || !self.timeContainer.contains(e.relatedTarget)) 2284 ) { 2285 setTimeout(function () { 2286 return self.hourElement.select(); 2287 }, 50); 2288 } 2289 } 2290 } 2291 function minMaxDateSetter(type) { 2292 return function (date) { 2293 var dateObj = (self.config['_' + type + 'Date'] = self.parseDate( 2294 date, 2295 self.config.dateFormat, 2296 )); 2297 var inverseDateObj = 2298 self.config['_' + (type === 'min' ? 'max' : 'min') + 'Date']; 2299 if (dateObj !== undefined) { 2300 self[type === 'min' ? 'minDateHasTime' : 'maxDateHasTime'] = 2301 dateObj.getHours() > 0 || 2302 dateObj.getMinutes() > 0 || 2303 dateObj.getSeconds() > 0; 2304 } 2305 if (self.selectedDates) { 2306 self.selectedDates = self.selectedDates.filter(function (d) { 2307 return isEnabled(d); 2308 }); 2309 if (!self.selectedDates.length && type === 'min') 2310 setHoursFromDate(dateObj); 2311 updateValue(); 2312 } 2313 if (self.daysContainer) { 2314 redraw(); 2315 if (dateObj !== undefined) 2316 self.currentYearElement[type] = dateObj.getFullYear().toString(); 2317 else self.currentYearElement.removeAttribute(type); 2318 self.currentYearElement.disabled = 2319 !!inverseDateObj && 2320 dateObj !== undefined && 2321 inverseDateObj.getFullYear() === dateObj.getFullYear(); 2322 } 2323 }; 2324 } 2325 function parseConfig() { 2326 var boolOpts = [ 2327 'wrap', 2328 'weekNumbers', 2329 'allowInput', 2330 'allowInvalidPreload', 2331 'clickOpens', 2332 'time_24hr', 2333 'enableTime', 2334 'noCalendar', 2335 'altInput', 2336 'shorthandCurrentMonth', 2337 'inline', 2338 'static', 2339 'enableSeconds', 2340 'disableMobile', 2341 ]; 2342 var userConfig = __assign( 2343 __assign({}, JSON.parse(JSON.stringify(element.dataset || {}))), 2344 instanceConfig, 2345 ); 2346 var formats = {}; 2347 self.config.parseDate = userConfig.parseDate; 2348 self.config.formatDate = userConfig.formatDate; 2349 Object.defineProperty(self.config, 'enable', { 2350 get: function () { 2351 return self.config._enable; 2352 }, 2353 set: function (dates) { 2354 self.config._enable = parseDateRules(dates); 2355 }, 2356 }); 2357 Object.defineProperty(self.config, 'disable', { 2358 get: function () { 2359 return self.config._disable; 2360 }, 2361 set: function (dates) { 2362 self.config._disable = parseDateRules(dates); 2363 }, 2364 }); 2365 var timeMode = userConfig.mode === 'time'; 2366 if (!userConfig.dateFormat && (userConfig.enableTime || timeMode)) { 2367 var defaultDateFormat = 2368 flatpickr.defaultConfig.dateFormat || defaults.dateFormat; 2369 formats.dateFormat = 2370 userConfig.noCalendar || timeMode 2371 ? 'H:i' + (userConfig.enableSeconds ? ':S' : '') 2372 : defaultDateFormat + 2373 ' H:i' + 2374 (userConfig.enableSeconds ? ':S' : ''); 2375 } 2376 if ( 2377 userConfig.altInput && 2378 (userConfig.enableTime || timeMode) && 2379 !userConfig.altFormat 2380 ) { 2381 var defaultAltFormat = 2382 flatpickr.defaultConfig.altFormat || defaults.altFormat; 2383 formats.altFormat = 2384 userConfig.noCalendar || timeMode 2385 ? 'h:i' + (userConfig.enableSeconds ? ':S K' : ' K') 2386 : defaultAltFormat + 2387 (' h:i' + (userConfig.enableSeconds ? ':S' : '') + ' K'); 2388 } 2389 Object.defineProperty(self.config, 'minDate', { 2390 get: function () { 2391 return self.config._minDate; 2392 }, 2393 set: minMaxDateSetter('min'), 2394 }); 2395 Object.defineProperty(self.config, 'maxDate', { 2396 get: function () { 2397 return self.config._maxDate; 2398 }, 2399 set: minMaxDateSetter('max'), 2400 }); 2401 var minMaxTimeSetter = function (type) { 2402 return function (val) { 2403 self.config[type === 'min' ? '_minTime' : '_maxTime'] = 2404 self.parseDate(val, 'H:i:S'); 2405 }; 2406 }; 2407 Object.defineProperty(self.config, 'minTime', { 2408 get: function () { 2409 return self.config._minTime; 2410 }, 2411 set: minMaxTimeSetter('min'), 2412 }); 2413 Object.defineProperty(self.config, 'maxTime', { 2414 get: function () { 2415 return self.config._maxTime; 2416 }, 2417 set: minMaxTimeSetter('max'), 2418 }); 2419 if (userConfig.mode === 'time') { 2420 self.config.noCalendar = true; 2421 self.config.enableTime = true; 2422 } 2423 Object.assign(self.config, formats, userConfig); 2424 for (var i = 0; i < boolOpts.length; i++) 2425 // https://github.com/microsoft/TypeScript/issues/31663 2426 self.config[boolOpts[i]] = 2427 self.config[boolOpts[i]] === true || 2428 self.config[boolOpts[i]] === 'true'; 2429 HOOKS.filter(function (hook) { 2430 return self.config[hook] !== undefined; 2431 }).forEach(function (hook) { 2432 self.config[hook] = arrayify(self.config[hook] || []).map( 2433 bindToInstance, 2434 ); 2435 }); 2436 self.isMobile = 2437 !self.config.disableMobile && 2438 !self.config.inline && 2439 self.config.mode === 'single' && 2440 !self.config.disable.length && 2441 !self.config.enable && 2442 !self.config.weekNumbers && 2443 /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test( 2444 navigator.userAgent, 2445 ); 2446 for (var i = 0; i < self.config.plugins.length; i++) { 2447 var pluginConf = self.config.plugins[i](self) || {}; 2448 for (var key in pluginConf) { 2449 if (HOOKS.indexOf(key) > -1) { 2450 self.config[key] = arrayify(pluginConf[key]) 2451 .map(bindToInstance) 2452 .concat(self.config[key]); 2453 } else if (typeof userConfig[key] === 'undefined') 2454 self.config[key] = pluginConf[key]; 2455 } 2456 } 2457 if (!userConfig.altInputClass) { 2458 self.config.altInputClass = 2459 getInputElem().className + ' ' + self.config.altInputClass; 2460 } 2461 triggerEvent('onParseConfig'); 2462 } 2463 function getInputElem() { 2464 return self.config.wrap ? element.querySelector('[data-input]') : element; 2465 } 2466 function setupLocale() { 2467 if ( 2468 typeof self.config.locale !== 'object' && 2469 typeof flatpickr.l10ns[self.config.locale] === 'undefined' 2470 ) 2471 self.config.errorHandler( 2472 new Error('flatpickr: invalid locale ' + self.config.locale), 2473 ); 2474 self.l10n = __assign( 2475 __assign({}, flatpickr.l10ns.default), 2476 typeof self.config.locale === 'object' 2477 ? self.config.locale 2478 : self.config.locale !== 'default' 2479 ? flatpickr.l10ns[self.config.locale] 2480 : undefined, 2481 ); 2482 tokenRegex.D = '(' + self.l10n.weekdays.shorthand.join('|') + ')'; 2483 tokenRegex.l = '(' + self.l10n.weekdays.longhand.join('|') + ')'; 2484 tokenRegex.M = '(' + self.l10n.months.shorthand.join('|') + ')'; 2485 tokenRegex.F = '(' + self.l10n.months.longhand.join('|') + ')'; 2486 tokenRegex.K = 2487 '(' + 2488 self.l10n.amPM[0] + 2489 '|' + 2490 self.l10n.amPM[1] + 2491 '|' + 2492 self.l10n.amPM[0].toLowerCase() + 2493 '|' + 2494 self.l10n.amPM[1].toLowerCase() + 2495 ')'; 2496 var userConfig = __assign( 2497 __assign({}, instanceConfig), 2498 JSON.parse(JSON.stringify(element.dataset || {})), 2499 ); 2500 if ( 2501 userConfig.time_24hr === undefined && 2502 flatpickr.defaultConfig.time_24hr === undefined 2503 ) { 2504 self.config.time_24hr = self.l10n.time_24hr; 2505 } 2506 self.formatDate = createDateFormatter(self); 2507 self.parseDate = createDateParser({ 2508 config: self.config, 2509 l10n: self.l10n, 2510 }); 2511 } 2512 function positionCalendar(customPositionElement) { 2513 if (typeof self.config.position === 'function') { 2514 return void self.config.position(self, customPositionElement); 2515 } 2516 if (self.calendarContainer === undefined) return; 2517 triggerEvent('onPreCalendarPosition'); 2518 var positionElement = customPositionElement || self._positionElement; 2519 var calendarHeight = Array.prototype.reduce.call( 2520 self.calendarContainer.children, 2521 function (acc, child) { 2522 return acc + child.offsetHeight; 2523 }, 2524 0, 2525 ), 2526 calendarWidth = self.calendarContainer.offsetWidth, 2527 configPos = self.config.position.split(' '), 2528 configPosVertical = configPos[0], 2529 configPosHorizontal = configPos.length > 1 ? configPos[1] : null, 2530 inputBounds = positionElement.getBoundingClientRect(), 2531 distanceFromBottom = window.innerHeight - inputBounds.bottom, 2532 showOnTop = 2533 configPosVertical === 'above' || 2534 (configPosVertical !== 'below' && 2535 distanceFromBottom < calendarHeight && 2536 inputBounds.top > calendarHeight); 2537 var top = 2538 window.pageYOffset + 2539 inputBounds.top + 2540 (!showOnTop ? positionElement.offsetHeight + 2 : -calendarHeight - 2); 2541 toggleClass(self.calendarContainer, 'arrowTop', !showOnTop); 2542 toggleClass(self.calendarContainer, 'arrowBottom', showOnTop); 2543 if (self.config.inline) return; 2544 var left = window.pageXOffset + inputBounds.left; 2545 var isCenter = false; 2546 var isRight = false; 2547 if (configPosHorizontal === 'center') { 2548 left -= (calendarWidth - inputBounds.width) / 2; 2549 isCenter = true; 2550 } else if (configPosHorizontal === 'right') { 2551 left -= calendarWidth - inputBounds.width; 2552 isRight = true; 2553 } 2554 toggleClass(self.calendarContainer, 'arrowLeft', !isCenter && !isRight); 2555 toggleClass(self.calendarContainer, 'arrowCenter', isCenter); 2556 toggleClass(self.calendarContainer, 'arrowRight', isRight); 2557 var right = 2558 window.document.body.offsetWidth - 2559 (window.pageXOffset + inputBounds.right); 2560 var rightMost = left + calendarWidth > window.document.body.offsetWidth; 2561 var centerMost = right + calendarWidth > window.document.body.offsetWidth; 2562 toggleClass(self.calendarContainer, 'rightMost', rightMost); 2563 if (self.config.static) return; 2564 self.calendarContainer.style.top = top + 'px'; 2565 if (!rightMost) { 2566 self.calendarContainer.style.left = left + 'px'; 2567 self.calendarContainer.style.right = 'auto'; 2568 } else if (!centerMost) { 2569 self.calendarContainer.style.left = 'auto'; 2570 self.calendarContainer.style.right = right + 'px'; 2571 } else { 2572 var doc = getDocumentStyleSheet(); 2573 // some testing environments don't have css support 2574 if (doc === undefined) return; 2575 var bodyWidth = window.document.body.offsetWidth; 2576 var centerLeft = Math.max(0, bodyWidth / 2 - calendarWidth / 2); 2577 var centerBefore = '.flatpickr-calendar.centerMost:before'; 2578 var centerAfter = '.flatpickr-calendar.centerMost:after'; 2579 var centerIndex = doc.cssRules.length; 2580 var centerStyle = '{left:' + inputBounds.left + 'px;right:auto;}'; 2581 toggleClass(self.calendarContainer, 'rightMost', false); 2582 toggleClass(self.calendarContainer, 'centerMost', true); 2583 doc.insertRule( 2584 centerBefore + ',' + centerAfter + centerStyle, 2585 centerIndex, 2586 ); 2587 self.calendarContainer.style.left = centerLeft + 'px'; 2588 self.calendarContainer.style.right = 'auto'; 2589 } 2590 } 2591 function getDocumentStyleSheet() { 2592 var editableSheet = null; 2593 for (var i = 0; i < document.styleSheets.length; i++) { 2594 var sheet = document.styleSheets[i]; 2595 if (!sheet.cssRules) continue; 2596 try { 2597 sheet.cssRules; 2598 } catch (err) { 2599 continue; 2600 } 2601 editableSheet = sheet; 2602 break; 2603 } 2604 return editableSheet != null ? editableSheet : createStyleSheet(); 2605 } 2606 function createStyleSheet() { 2607 var style = document.createElement('style'); 2608 document.head.appendChild(style); 2609 return style.sheet; 2610 } 2611 function redraw() { 2612 if (self.config.noCalendar || self.isMobile) return; 2613 buildMonthSwitch(); 2614 updateNavigationCurrentMonth(); 2615 buildDays(); 2616 } 2617 function focusAndClose() { 2618 self._input.focus(); 2619 if ( 2620 window.navigator.userAgent.indexOf('MSIE') !== -1 || 2621 navigator.msMaxTouchPoints !== undefined 2622 ) { 2623 // hack - bugs in the way IE handles focus keeps the calendar open 2624 setTimeout(self.close, 0); 2625 } else { 2626 self.close(); 2627 } 2628 } 2629 function selectDate(e) { 2630 e.preventDefault(); 2631 e.stopPropagation(); 2632 var isSelectable = function (day) { 2633 return ( 2634 day.classList && 2635 day.classList.contains('flatpickr-day') && 2636 !day.classList.contains('flatpickr-disabled') && 2637 !day.classList.contains('notAllowed') 2638 ); 2639 }; 2640 var t = findParent(getEventTarget(e), isSelectable); 2641 if (t === undefined) return; 2642 var target = t; 2643 var selectedDate = (self.latestSelectedDateObj = new Date( 2644 target.dateObj.getTime(), 2645 )); 2646 var shouldChangeMonth = 2647 (selectedDate.getMonth() < self.currentMonth || 2648 selectedDate.getMonth() > 2649 self.currentMonth + self.config.showMonths - 1) && 2650 self.config.mode !== 'range'; 2651 self.selectedDateElem = target; 2652 if (self.config.mode === 'single') self.selectedDates = [selectedDate]; 2653 else if (self.config.mode === 'multiple') { 2654 var selectedIndex = isDateSelected(selectedDate); 2655 if (selectedIndex) 2656 self.selectedDates.splice(parseInt(selectedIndex), 1); 2657 else self.selectedDates.push(selectedDate); 2658 } else if (self.config.mode === 'range') { 2659 if (self.selectedDates.length === 2) { 2660 self.clear(false, false); 2661 } 2662 self.latestSelectedDateObj = selectedDate; 2663 self.selectedDates.push(selectedDate); 2664 // unless selecting same date twice, sort ascendingly 2665 if (compareDates(selectedDate, self.selectedDates[0], true) !== 0) 2666 self.selectedDates.sort(function (a, b) { 2667 return a.getTime() - b.getTime(); 2668 }); 2669 } 2670 setHoursFromInputs(); 2671 if (shouldChangeMonth) { 2672 var isNewYear = self.currentYear !== selectedDate.getFullYear(); 2673 self.currentYear = selectedDate.getFullYear(); 2674 self.currentMonth = selectedDate.getMonth(); 2675 if (isNewYear) { 2676 triggerEvent('onYearChange'); 2677 buildMonthSwitch(); 2678 } 2679 triggerEvent('onMonthChange'); 2680 } 2681 updateNavigationCurrentMonth(); 2682 buildDays();
vendor: 4,263 bytes, lines 2683-2811
2683 updateValue(); 2684 // maintain focus 2685 if ( 2686 !shouldChangeMonth && 2687 self.config.mode !== 'range' && 2688 self.config.showMonths === 1 2689 ) 2690 focusOnDayElem(target); 2691 else if ( 2692 self.selectedDateElem !== undefined && 2693 self.hourElement === undefined 2694 ) { 2695 self.selectedDateElem && self.selectedDateElem.focus(); 2696 } 2697 if (self.hourElement !== undefined) 2698 self.hourElement !== undefined && self.hourElement.focus(); 2699 if (self.config.closeOnSelect) { 2700 var single = self.config.mode === 'single' && !self.config.enableTime; 2701 var range = 2702 self.config.mode === 'range' && 2703 self.selectedDates.length === 2 && 2704 !self.config.enableTime; 2705 if (single || range) { 2706 focusAndClose(); 2707 } 2708 } 2709 triggerChange(); 2710 } 2711 var CALLBACKS = { 2712 locale: [setupLocale, updateWeekdays], 2713 showMonths: [buildMonths, setCalendarWidth, buildWeekdays], 2714 minDate: [jumpToDate], 2715 maxDate: [jumpToDate], 2716 positionElement: [updatePositionElement], 2717 clickOpens: [ 2718 function () { 2719 if (self.config.clickOpens === true) { 2720 bind(self._input, 'focus', self.open); 2721 bind(self._input, 'click', self.open); 2722 } else { 2723 self._input.removeEventListener('focus', self.open); 2724 self._input.removeEventListener('click', self.open); 2725 } 2726 }, 2727 ], 2728 }; 2729 function set(option, value) { 2730 if (option !== null && typeof option === 'object') { 2731 Object.assign(self.config, option); 2732 for (var key in option) { 2733 if (CALLBACKS[key] !== undefined) 2734 CALLBACKS[key].forEach(function (x) { 2735 return x(); 2736 }); 2737 } 2738 } else { 2739 self.config[option] = value; 2740 if (CALLBACKS[option] !== undefined) 2741 CALLBACKS[option].forEach(function (x) { 2742 return x(); 2743 }); 2744 else if (HOOKS.indexOf(option) > -1) 2745 self.config[option] = arrayify(value); 2746 } 2747 self.redraw(); 2748 updateValue(true); 2749 } 2750 function setSelectedDate(inputDate, format) { 2751 var dates = []; 2752 if (inputDate instanceof Array) 2753 dates = inputDate.map(function (d) { 2754 return self.parseDate(d, format); 2755 }); 2756 else if (inputDate instanceof Date || typeof inputDate === 'number') 2757 dates = [self.parseDate(inputDate, format)]; 2758 else if (typeof inputDate === 'string') { 2759 switch (self.config.mode) { 2760 case 'single': 2761 case 'time': 2762 dates = [self.parseDate(inputDate, format)]; 2763 break; 2764 case 'multiple': 2765 dates = inputDate 2766 .split(self.config.conjunction) 2767 .map(function (date) { 2768 return self.parseDate(date, format); 2769 }); 2770 break; 2771 case 'range': 2772 dates = inputDate 2773 .split(self.l10n.rangeSeparator) 2774 .map(function (date) { 2775 return self.parseDate(date, format); 2776 }); 2777 break; 2778 } 2779 } else 2780 self.config.errorHandler( 2781 new Error('Invalid date supplied: ' + JSON.stringify(inputDate)), 2782 ); 2783 self.selectedDates = self.config.allowInvalidPreload 2784 ? dates 2785 : dates.filter(function (d) { 2786 return d instanceof Date && isEnabled(d, false); 2787 }); 2788 if (self.config.mode === 'range') 2789 self.selectedDates.sort(function (a, b) { 2790 return a.getTime() - b.getTime(); 2791 }); 2792 } 2793 function setDate(date, triggerChange, format) { 2794 if (triggerChange === void 0) { 2795 triggerChange = false; 2796 } 2797 if (format === void 0) { 2798 format = self.config.dateFormat; 2799 } 2800 if ((date !== 0 && !date) || (date instanceof Array && date.length === 0)) 2801 return self.clear(triggerChange); 2802 setSelectedDate(date, format); 2803 self.latestSelectedDateObj = 2804 self.selectedDates[self.selectedDates.length - 1]; 2805 2806 self.redraw(); 2807 jumpToDate(undefined, triggerChange); 2808 setHoursFromDate(); 2809 if (self.selectedDates.length === 0) { 2810 self.clear(false); 2811 }
vendor: 12,493 bytes, lines 2812-3143
2812 updateValue(triggerChange); 2813 if (triggerChange) triggerEvent('onChange'); 2814 } 2815 function parseDateRules(arr) { 2816 return arr 2817 .slice() 2818 .map(function (rule) { 2819 if ( 2820 typeof rule === 'string' || 2821 typeof rule === 'number' || 2822 rule instanceof Date 2823 ) { 2824 return self.parseDate(rule, undefined, true); 2825 } else if (rule && typeof rule === 'object' && rule.from && rule.to) 2826 return { 2827 from: self.parseDate(rule.from, undefined), 2828 to: self.parseDate(rule.to, undefined), 2829 }; 2830 return rule; 2831 }) 2832 .filter(function (x) { 2833 return x; 2834 }); // remove falsy values 2835 } 2836 function setupDates() { 2837 self.selectedDates = []; 2838 self.now = self.parseDate(self.config.now) || new Date(); 2839 // Workaround IE11 setting placeholder as the input's value 2840 var preloadedDate = 2841 self.config.defaultDate || 2842 ((self.input.nodeName === 'INPUT' || 2843 self.input.nodeName === 'TEXTAREA') && 2844 self.input.placeholder && 2845 self.input.value === self.input.placeholder 2846 ? null 2847 : self.input.value); 2848 if (preloadedDate) setSelectedDate(preloadedDate, self.config.dateFormat); 2849 self._initialDate = 2850 self.selectedDates.length > 0 2851 ? self.selectedDates[0] 2852 : self.config.minDate && 2853 self.config.minDate.getTime() > self.now.getTime() 2854 ? self.config.minDate 2855 : self.config.maxDate && 2856 self.config.maxDate.getTime() < self.now.getTime() 2857 ? self.config.maxDate 2858 : self.now; 2859 self.currentYear = self._initialDate.getFullYear(); 2860 self.currentMonth = self._initialDate.getMonth(); 2861 if (self.selectedDates.length > 0) 2862 self.latestSelectedDateObj = self.selectedDates[0]; 2863 if (self.config.minTime !== undefined) 2864 self.config.minTime = self.parseDate(self.config.minTime, 'H:i'); 2865 if (self.config.maxTime !== undefined) 2866 self.config.maxTime = self.parseDate(self.config.maxTime, 'H:i'); 2867 self.minDateHasTime = 2868 !!self.config.minDate && 2869 (self.config.minDate.getHours() > 0 || 2870 self.config.minDate.getMinutes() > 0 || 2871 self.config.minDate.getSeconds() > 0); 2872 self.maxDateHasTime = 2873 !!self.config.maxDate && 2874 (self.config.maxDate.getHours() > 0 || 2875 self.config.maxDate.getMinutes() > 0 || 2876 self.config.maxDate.getSeconds() > 0); 2877 } 2878 function setupInputs() { 2879 self.input = getInputElem(); 2880 /* istanbul ignore next */ 2881 if (!self.input) { 2882 self.config.errorHandler(new Error('Invalid input element specified')); 2883 return; 2884 } 2885 // hack: store previous type to restore it after destroy() 2886 self.input._type = self.input.type; 2887 self.input.type = 'text'; 2888 self.input.classList.add('flatpickr-input'); 2889 self._input = self.input; 2890 if (self.config.altInput) { 2891 // replicate self.element 2892 self.altInput = createElement( 2893 self.input.nodeName, 2894 self.config.altInputClass, 2895 ); 2896 self._input = self.altInput; 2897 self.altInput.placeholder = self.input.placeholder; 2898 self.altInput.disabled = self.input.disabled; 2899 self.altInput.required = self.input.required; 2900 self.altInput.tabIndex = self.input.tabIndex; 2901 self.altInput.type = 'text'; 2902 self.input.setAttribute('type', 'hidden'); 2903 if (!self.config.static && self.input.parentNode) 2904 self.input.parentNode.insertBefore( 2905 self.altInput, 2906 self.input.nextSibling, 2907 ); 2908 } 2909 if (!self.config.allowInput) 2910 self._input.setAttribute('readonly', 'readonly'); 2911 updatePositionElement(); 2912 } 2913 function updatePositionElement() { 2914 self._positionElement = self.config.positionElement || self._input; 2915 } 2916 function setupMobile() { 2917 var inputType = self.config.enableTime 2918 ? self.config.noCalendar 2919 ? 'time' 2920 : 'datetime-local' 2921 : 'date'; 2922 self.mobileInput = createElement( 2923 'input', 2924 self.input.className + ' flatpickr-mobile', 2925 ); 2926 self.mobileInput.tabIndex = 1; 2927 self.mobileInput.type = inputType; 2928 self.mobileInput.disabled = self.input.disabled; 2929 self.mobileInput.required = self.input.required; 2930 self.mobileInput.placeholder = self.input.placeholder; 2931 self.mobileFormatStr = 2932 inputType === 'datetime-local' 2933 ? 'Y-m-d\\TH:i:S' 2934 : inputType === 'date' 2935 ? 'Y-m-d' 2936 : 'H:i:S'; 2937 if (self.selectedDates.length > 0) { 2938 self.mobileInput.defaultValue = self.mobileInput.value = 2939 self.formatDate(self.selectedDates[0], self.mobileFormatStr); 2940 } 2941 if (self.config.minDate) 2942 self.mobileInput.min = self.formatDate(self.config.minDate, 'Y-m-d'); 2943 if (self.config.maxDate) 2944 self.mobileInput.max = self.formatDate(self.config.maxDate, 'Y-m-d'); 2945 if (self.input.getAttribute('step')) 2946 self.mobileInput.step = String(self.input.getAttribute('step')); 2947 self.input.type = 'hidden'; 2948 if (self.altInput !== undefined) self.altInput.type = 'hidden'; 2949 try { 2950 if (self.input.parentNode) 2951 self.input.parentNode.insertBefore( 2952 self.mobileInput, 2953 self.input.nextSibling, 2954 ); 2955 } catch (_a) {} 2956 bind(self.mobileInput, 'change', function (e) { 2957 self.setDate(getEventTarget(e).value, false, self.mobileFormatStr); 2958 triggerEvent('onChange'); 2959 triggerEvent('onClose'); 2960 }); 2961 } 2962 function toggle(e) { 2963 if (self.isOpen === true) return self.close(); 2964 self.open(e); 2965 } 2966 function triggerEvent(event, data) { 2967 // If the instance has been destroyed already, all hooks have been removed 2968 if (self.config === undefined) return; 2969 var hooks = self.config[event]; 2970 if (hooks !== undefined && hooks.length > 0) { 2971 for (var i = 0; hooks[i] && i < hooks.length; i++) 2972 hooks[i](self.selectedDates, self.input.value, self, data); 2973 } 2974 if (event === 'onChange') { 2975 self.input.dispatchEvent(createEvent('change')); 2976 // many front-end frameworks bind to the input event 2977 self.input.dispatchEvent(createEvent('input')); 2978 } 2979 } 2980 function createEvent(name) { 2981 var e = document.createEvent('Event'); 2982 e.initEvent(name, true, true); 2983 return e; 2984 } 2985 function isDateSelected(date) { 2986 for (var i = 0; i < self.selectedDates.length; i++) { 2987 var selectedDate = self.selectedDates[i]; 2988 if ( 2989 selectedDate instanceof Date && 2990 compareDates(selectedDate, date) === 0 2991 ) 2992 return '' + i; 2993 } 2994 return false; 2995 } 2996 function isDateInRange(date) { 2997 if (self.config.mode !== 'range' || self.selectedDates.length < 2) 2998 return false; 2999 return ( 3000 compareDates(date, self.selectedDates[0]) >= 0 && 3001 compareDates(date, self.selectedDates[1]) <= 0 3002 ); 3003 } 3004 function updateNavigationCurrentMonth() { 3005 if (self.config.noCalendar || self.isMobile || !self.monthNav) return; 3006 self.yearElements.forEach(function (yearElement, i) { 3007 var d = new Date(self.currentYear, self.currentMonth, 1); 3008 d.setMonth(self.currentMonth + i); 3009 if ( 3010 self.config.showMonths > 1 || 3011 self.config.monthSelectorType === 'static' 3012 ) { 3013 self.monthElements[i].textContent = 3014 monthToStr( 3015 d.getMonth(), 3016 self.config.shorthandCurrentMonth, 3017 self.l10n, 3018 ) + ' '; 3019 } else { 3020 self.monthsDropdownContainer.value = d.getMonth().toString(); 3021 } 3022 yearElement.value = d.getFullYear().toString(); 3023 }); 3024 self._hidePrevMonthArrow = 3025 self.config.minDate !== undefined && 3026 (self.currentYear === self.config.minDate.getFullYear() 3027 ? self.currentMonth <= self.config.minDate.getMonth() 3028 : self.currentYear < self.config.minDate.getFullYear()); 3029 self._hideNextMonthArrow = 3030 self.config.maxDate !== undefined && 3031 (self.currentYear === self.config.maxDate.getFullYear() 3032 ? self.currentMonth + 1 > self.config.maxDate.getMonth() 3033 : self.currentYear > self.config.maxDate.getFullYear()); 3034 } 3035 function getDateStr(specificFormat) { 3036 var format = 3037 specificFormat || 3038 (self.config.altInput ? self.config.altFormat : self.config.dateFormat); 3039 return self.selectedDates 3040 .map(function (dObj) { 3041 return self.formatDate(dObj, format); 3042 }) 3043 .filter(function (d, i, arr) { 3044 return ( 3045 self.config.mode !== 'range' || 3046 self.config.enableTime || 3047 arr.indexOf(d) === i 3048 ); 3049 }) 3050 .join( 3051 self.config.mode !== 'range' 3052 ? self.config.conjunction 3053 : self.l10n.rangeSeparator, 3054 ); 3055 } 3056 /** 3057 * Updates the values of inputs associated with the calendar 3058 */ 3059 function updateValue(triggerChange) { 3060 if (triggerChange === void 0) { 3061 triggerChange = true; 3062 } 3063 if (self.mobileInput !== undefined && self.mobileFormatStr) { 3064 self.mobileInput.value = 3065 self.latestSelectedDateObj !== undefined 3066 ? self.formatDate(self.latestSelectedDateObj, self.mobileFormatStr) 3067 : ''; 3068 } 3069 self.input.value = getDateStr(self.config.dateFormat); 3070 if (self.altInput !== undefined) { 3071 self.altInput.value = getDateStr(self.config.altFormat); 3072 } 3073 if (triggerChange !== false) triggerEvent('onValueUpdate'); 3074 } 3075 function onMonthNavClick(e) { 3076 var eventTarget = getEventTarget(e); 3077 var isPrevMonth = self.prevMonthNav.contains(eventTarget); 3078 var isNextMonth = self.nextMonthNav.contains(eventTarget); 3079 if (isPrevMonth || isNextMonth) { 3080 changeMonth(isPrevMonth ? -1 : 1); 3081 } else if (self.yearElements.indexOf(eventTarget) >= 0) { 3082 eventTarget.select(); 3083 } else if (eventTarget.classList.contains('arrowUp')) { 3084 self.changeYear(self.currentYear + 1); 3085 } else if (eventTarget.classList.contains('arrowDown')) { 3086 self.changeYear(self.currentYear - 1); 3087 } 3088 } 3089 function timeWrapper(e) { 3090 e.preventDefault(); 3091 var isKeyDown = e.type === 'keydown', 3092 eventTarget = getEventTarget(e), 3093 input = eventTarget; 3094 if (self.amPM !== undefined && eventTarget === self.amPM) { 3095 self.amPM.textContent = 3096 self.l10n.amPM[int(self.amPM.textContent === self.l10n.amPM[0])]; 3097 } 3098 var min = parseFloat(input.getAttribute('min')), 3099 max = parseFloat(input.getAttribute('max')), 3100 step = parseFloat(input.getAttribute('step')), 3101 curValue = parseInt(input.value, 10), 3102 delta = e.delta || (isKeyDown ? (e.which === 38 ? 1 : -1) : 0); 3103 var newValue = curValue + step * delta; 3104 if (typeof input.value !== 'undefined' && input.value.length === 2) { 3105 var isHourElem = input === self.hourElement, 3106 isMinuteElem = input === self.minuteElement; 3107 if (newValue < min) { 3108 newValue = 3109 max + 3110 newValue + 3111 int(!isHourElem) + 3112 (int(isHourElem) && int(!self.amPM)); 3113 if (isMinuteElem) incrementNumInput(undefined, -1, self.hourElement); 3114 } else if (newValue > max) { 3115 newValue = 3116 input === self.hourElement ? newValue - max - int(!self.amPM) : min; 3117 if (isMinuteElem) incrementNumInput(undefined, 1, self.hourElement); 3118 } 3119 if ( 3120 self.amPM && 3121 isHourElem && 3122 (step === 1 3123 ? newValue + curValue === 23 3124 : Math.abs(newValue - curValue) > step) 3125 ) { 3126 self.amPM.textContent = 3127 self.l10n.amPM[int(self.amPM.textContent === self.l10n.amPM[0])]; 3128 } 3129 input.value = pad(newValue); 3130 } 3131 } 3132 init(); 3133 return self; 3134 } 3135 /* istanbul ignore next */ 3136 function _flatpickr(nodeList, config) { 3137 // static list 3138 var nodes = Array.prototype.slice.call(nodeList).filter(function (x) { 3139 return x instanceof HTMLElement; 3140 }); 3141 var instances = []; 3142 for (var i = 0; i < nodes.length; i++) { 3143 var node = nodes[i];
vendor: 2,339 bytes, lines 3144-3222
3144 try { 3145 if (node.getAttribute('data-fp-omit') !== null) continue; 3146 if (node._flatpickr !== undefined) { 3147 node._flatpickr.destroy(); 3148 node._flatpickr = undefined; 3149 } 3150 node._flatpickr = FlatpickrInstance(node, config || {}); 3151 instances.push(node._flatpickr); 3152 } catch (e) { 3153 console.error(e); 3154 } 3155 } 3156 return instances.length === 1 ? instances[0] : instances; 3157 } 3158 /* istanbul ignore next */ 3159 if ( 3160 typeof HTMLElement !== 'undefined' && 3161 typeof HTMLCollection !== 'undefined' && 3162 typeof NodeList !== 'undefined' 3163 ) { 3164 // browser env 3165 HTMLCollection.prototype.flatpickr = NodeList.prototype.flatpickr = 3166 function (config) { 3167 return _flatpickr(this, config); 3168 }; 3169 HTMLElement.prototype.flatpickr = function (config) { 3170 return _flatpickr([this], config); 3171 }; 3172 } 3173 /* istanbul ignore next */ 3174 var flatpickr = function (selector, config) { 3175 if (typeof selector === 'string') { 3176 return _flatpickr(window.document.querySelectorAll(selector), config); 3177 } else if (selector instanceof Node) { 3178 return _flatpickr([selector], config); 3179 } else { 3180 return _flatpickr(selector, config); 3181 } 3182 }; 3183 /* istanbul ignore next */ 3184 flatpickr.defaultConfig = {}; 3185 flatpickr.l10ns = { 3186 en: __assign({}, english), 3187 default: __assign({}, english), 3188 }; 3189 flatpickr.localize = function (l10n) { 3190 flatpickr.l10ns.default = __assign( 3191 __assign({}, flatpickr.l10ns.default), 3192 l10n, 3193 ); 3194 }; 3195 flatpickr.setDefaults = function (config) { 3196 flatpickr.defaultConfig = __assign( 3197 __assign({}, flatpickr.defaultConfig), 3198 config, 3199 ); 3200 }; 3201 flatpickr.parseDate = createDateParser({}); 3202 flatpickr.formatDate = createDateFormatter({}); 3203 flatpickr.compareDates = compareDates; 3204 /* istanbul ignore next */ 3205 if (typeof jQuery !== 'undefined' && typeof jQuery.fn !== 'undefined') { 3206 jQuery.fn.flatpickr = function (config) { 3207 return _flatpickr(this, config); 3208 }; 3209 } 3210 Date.prototype.fp_incr = function (days) { 3211 return new Date( 3212 this.getFullYear(), 3213 this.getMonth(), 3214 this.getDate() + (typeof days === 'string' ? parseInt(days, 10) : days), 3215 ); 3216 }; 3217 if (typeof window !== 'undefined') { 3218 window.flatpickr = flatpickr; 3219 } 3220 3221 return flatpickr; 3222});
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.