flatpickr-ce 0.0.0-stage → 4.7.1

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