flatpickr 4.5.2.0 → 4.6.6.0

data/vendor/assets/javascripts/flatpickr/plugins/momentPlugin.js

@@ -0,0 +1,69 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+  typeof define === 'function' && define.amd ? define(factory) :
+  (global = global || self, global.momentPlugin = factory());
+}(this, (function () { 'use strict';
+
+  function getEventTarget(event) {
+      try {
+          if (typeof event.composedPath === "function") {
+              var path = event.composedPath();
+              return path[0];
+          }
+          return event.target;
+      }
+      catch (error) {
+          return event.target;
+      }
+  }
+
+  function momentPlugin(config) {
+      var moment = config.moment;
+      return function (fp) {
+          function captureIncrement(e) {
+              var event = e;
+              event.stopPropagation();
+              var date = moment(fp.selectedDates[0]);
+              var input = getEventTarget(event);
+              var unit = Array.from(input.classList)
+                  .filter(function (name) { return name.startsWith("flatpickr-"); })
+                  .map(function (name) { return name.substring(10); })[0];
+              var step = parseFloat(input.getAttribute("step"));
+              date.add(step * event.delta, unit);
+              fp.setDate(date.toDate());
+          }
+          return {
+              parseDate: function (datestr, format) {
+                  return moment(datestr, format, true).toDate();
+              },
+              formatDate: function (date, format) {
+                  // locale can also be used
+                  var momentDate = moment(date);
+                  if (typeof fp.config.locale === "string") {
+                      momentDate.locale(fp.config.locale);
+                  }
+                  return momentDate.format(format);
+              },
+              onReady: function () {
+                  [fp.hourElement, fp.minuteElement, fp.secondElement].forEach(function (element) {
+                      return element &&
+                          element.addEventListener("increment", captureIncrement, {
+                              capture: true,
+                          });
+                  });
+              },
+              onDestroy: function () {
+                  [fp.hourElement, fp.minuteElement, fp.secondElement].forEach(function (element) {
+                      return element &&
+                          element.removeEventListener("increment", captureIncrement, {
+                              capture: true,
+                          });
+                  });
+              },
+          };
+      };
+  }
+
+  return momentPlugin;
+
+})));

data/vendor/assets/javascripts/flatpickr/plugins/monthSelect/index.js

@@ -0,0 +1,233 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+    typeof define === 'function' && define.amd ? define(factory) :
+    (global = global || self, global.monthSelectPlugin = factory());
+}(this, (function () { 'use strict';
+
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+
+    var __assign = function() {
+        __assign = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign.apply(this, arguments);
+    };
+
+    var monthToStr = function (monthNumber, shorthand, locale) { return locale.months[shorthand ? "shorthand" : "longhand"][monthNumber]; };
+
+    function getEventTarget(event) {
+        try {
+            if (typeof event.composedPath === "function") {
+                var path = event.composedPath();
+                return path[0];
+            }
+            return event.target;
+        }
+        catch (error) {
+            return event.target;
+        }
+    }
+
+    var defaultConfig = {
+        shorthand: false,
+        dateFormat: "F Y",
+        altFormat: "F Y",
+        theme: "light",
+    };
+    function monthSelectPlugin(pluginConfig) {
+        var config = __assign(__assign({}, defaultConfig), pluginConfig);
+        return function (fp) {
+            fp.config.dateFormat = config.dateFormat;
+            fp.config.altFormat = config.altFormat;
+            var self = { monthsContainer: null };
+            function clearUnnecessaryDOMElements() {
+                if (!fp.rContainer || !fp.daysContainer || !fp.weekdayContainer)
+                    return;
+                fp.rContainer.removeChild(fp.daysContainer);
+                fp.rContainer.removeChild(fp.weekdayContainer);
+                for (var index = 0; index < fp.monthElements.length; index++) {
+                    var element = fp.monthElements[index];
+                    if (!element.parentNode)
+                        continue;
+                    element.parentNode.removeChild(element);
+                }
+            }
+            function addListeners() {
+                fp._bind(fp.prevMonthNav, "click", function (e) {
+                    var _a;
+                    e.preventDefault();
+                    e.stopPropagation();
+                    var selectedMonth = (_a = fp.rContainer) === null || _a === void 0 ? void 0 : _a.querySelector(".flatpickr-monthSelect-month.selected").dateObj.getMonth();
+                    if (selectedMonth === 0) {
+                        fp.currentYear--;
+                    }
+                    selectYear();
+                });
+                fp._bind(fp.nextMonthNav, "click", function (e) {
+                    var _a;
+                    e.preventDefault();
+                    e.stopPropagation();
+                    var selectedMonth = (_a = fp.rContainer) === null || _a === void 0 ? void 0 : _a.querySelector(".flatpickr-monthSelect-month.selected").dateObj.getMonth();
+                    if (selectedMonth === 11) {
+                        fp.currentYear++;
+                    }
+                    selectYear();
+                });
+            }
+            function addMonths() {
+                if (!fp.rContainer)
+                    return;
+                self.monthsContainer = fp._createElement("div", "flatpickr-monthSelect-months");
+                self.monthsContainer.tabIndex = -1;
+                fp.calendarContainer.classList.add("flatpickr-monthSelect-theme-" + config.theme);
+                for (var i = 0; i < 12; i++) {
+                    var month = fp._createElement("span", "flatpickr-monthSelect-month");
+                    month.dateObj = new Date(fp.currentYear, i);
+                    month.$i = i;
+                    month.textContent = monthToStr(i, config.shorthand, fp.l10n);
+                    month.tabIndex = -1;
+                    month.addEventListener("click", selectMonth);
+                    self.monthsContainer.appendChild(month);
+                    if ((fp.config.minDate && month.dateObj < fp.config.minDate) ||
+                        (fp.config.maxDate && month.dateObj > fp.config.maxDate)) {
+                        month.classList.add("disabled");
+                    }
+                }
+                fp.rContainer.appendChild(self.monthsContainer);
+            }
+            function setCurrentlySelected() {
+                if (!fp.rContainer)
+                    return;
+                var currentlySelected = fp.rContainer.querySelectorAll(".flatpickr-monthSelect-month.selected");
+                for (var index = 0; index < currentlySelected.length; index++) {
+                    currentlySelected[index].classList.remove("selected");
+                }
+                var month = fp.rContainer.querySelector(".flatpickr-monthSelect-month:nth-child(" + (fp.currentMonth + 1) + ")");
+                if (month) {
+                    month.classList.add("selected");
+                }
+            }
+            function selectYear() {
+                var selectedDate = fp.selectedDates[0];
+                if (selectedDate) {
+                    selectedDate = new Date(selectedDate);
+                    selectedDate.setFullYear(fp.currentYear);
+                    if (fp.config.minDate && selectedDate < fp.config.minDate) {
+                        selectedDate = fp.config.minDate;
+                    }
+                    if (fp.config.maxDate && selectedDate > fp.config.maxDate) {
+                        selectedDate = fp.config.maxDate;
+                    }
+                    fp.currentYear = selectedDate.getFullYear();
+                    fp.currentYearElement.value = String(fp.currentYear);
+                    fp.currentMonth = selectedDate.getMonth();
+                }
+                if (fp.rContainer) {
+                    var months = fp.rContainer.querySelectorAll(".flatpickr-monthSelect-month");
+                    months.forEach(function (month) {
+                        month.dateObj.setFullYear(fp.currentYear);
+                        if ((fp.config.minDate && month.dateObj < fp.config.minDate) ||
+                            (fp.config.maxDate && month.dateObj > fp.config.maxDate)) {
+                            month.classList.add("disabled");
+                        }
+                        else {
+                            month.classList.remove("disabled");
+                        }
+                    });
+                }
+                setCurrentlySelected();
+            }
+            function selectMonth(e) {
+                e.preventDefault();
+                e.stopPropagation();
+                var eventTarget = getEventTarget(e);
+                if (eventTarget instanceof Element &&
+                    !eventTarget.classList.contains("disabled")) {
+                    setMonth(eventTarget.dateObj);
+                    fp.close();
+                }
+            }
+            function setMonth(date) {
+                var selectedDate = new Date(date);
+                selectedDate.setFullYear(fp.currentYear);
+                fp.currentMonth = selectedDate.getMonth();
+                fp.setDate(selectedDate, true);
+                setCurrentlySelected();
+            }
+            var shifts = {
+                37: -1,
+                39: 1,
+                40: 3,
+                38: -3,
+            };
+            function onKeyDown(_, __, ___, e) {
+                var shouldMove = shifts[e.keyCode] !== undefined;
+                if (!shouldMove && e.keyCode !== 13) {
+                    return;
+                }
+                if (!fp.rContainer || !self.monthsContainer)
+                    return;
+                var currentlySelected = fp.rContainer.querySelector(".flatpickr-monthSelect-month.selected");
+                var index = Array.prototype.indexOf.call(self.monthsContainer.children, document.activeElement);
+                if (index === -1) {
+                    var target = currentlySelected || self.monthsContainer.firstElementChild;
+                    target.focus();
+                    index = target.$i;
+                }
+                if (shouldMove) {
+                    self.monthsContainer.children[(12 + index + shifts[e.keyCode]) % 12].focus();
+                }
+                else if (e.keyCode === 13 &&
+                    self.monthsContainer.contains(document.activeElement)) {
+                    setMonth(document.activeElement.dateObj);
+                }
+            }
+            function destroyPluginInstance() {
+                if (self.monthsContainer !== null) {
+                    var months = self.monthsContainer.querySelectorAll(".flatpickr-monthSelect-month");
+                    for (var index = 0; index < months.length; index++) {
+                        months[index].removeEventListener("click", selectMonth);
+                    }
+                }
+            }
+            return {
+                onParseConfig: function () {
+                    fp.config.mode = "single";
+                    fp.config.enableTime = false;
+                },
+                onValueUpdate: setCurrentlySelected,
+                onKeyDown: onKeyDown,
+                onReady: [
+                    clearUnnecessaryDOMElements,
+                    addListeners,
+                    addMonths,
+                    setCurrentlySelected,
+                    function () {
+                        fp.loadedPlugins.push("monthSelect");
+                    },
+                ],
+                onDestroy: destroyPluginInstance,
+            };
+        };
+    }
+
+    return monthSelectPlugin;
+
+})));

data/vendor/assets/javascripts/flatpickr/plugins/rangePlugin.js

@@ -1,19 +1,49 @@
-/* flatpickr v4.5.2, @license MIT */
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
     typeof define === 'function' && define.amd ? define(factory) :
-    (global.rangePlugin = factory());
+    (global = global || self, global.rangePlugin = factory());
 }(this, (function () { 'use strict';
 
-    function rangePlugin(config = {}) {
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+
+    function __spreadArrays() {
+        for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+        for (var r = Array(s), k = 0, i = 0; i < il; i++)
+            for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+                r[k] = a[j];
+        return r;
+    }
+
+    function rangePlugin(config) {
+        if (config === void 0) { config = {}; }
         return function (fp) {
-            let dateFormat = "", secondInput, _firstInputFocused, _secondInputFocused, _prevDates;
-            const createSecondInput = () => {
+            var dateFormat = "", secondInput, _secondInputFocused, _prevDates;
+            var createSecondInput = function () {
                 if (config.input) {
                     secondInput =
                         config.input instanceof Element
                             ? config.input
                             : window.document.querySelector(config.input);
+                    if (!secondInput) {
+                        fp.config.errorHandler(new Error("Invalid input element specified"));
+                        return;
+                    }
+                    if (fp.config.wrap) {
+                        secondInput = secondInput.querySelector("[data-input]");
+                    }
                 }
                 else {
                     secondInput = fp._input.cloneNode();
@@ -21,28 +51,28 @@
                     secondInput._flatpickr = undefined;
                 }
                 if (secondInput.value) {
-                    const parsedDate = fp.parseDate(secondInput.value);
+                    var parsedDate = fp.parseDate(secondInput.value);
                     if (parsedDate)
                         fp.selectedDates.push(parsedDate);
                 }
                 secondInput.setAttribute("data-fp-omit", "");
-                fp._bind(secondInput, ["focus", "click"], () => {
+                fp._bind(secondInput, ["focus", "click"], function () {
                     if (fp.selectedDates[1]) {
                         fp.latestSelectedDateObj = fp.selectedDates[1];
                         fp._setHoursFromDate(fp.selectedDates[1]);
                         fp.jumpToDate(fp.selectedDates[1]);
                     }
-                    [_firstInputFocused, _secondInputFocused] = [false, true];
+                    _secondInputFocused = true;
                     fp.isOpen = false;
-                    fp.open(undefined, secondInput);
+                    fp.open(undefined, config.position === "left" ? fp._input : secondInput);
                 });
-                fp._bind(fp._input, ["focus", "click"], (e) => {
+                fp._bind(fp._input, ["focus", "click"], function (e) {
                     e.preventDefault();
                     fp.isOpen = false;
                     fp.open();
                 });
                 if (fp.config.allowInput)
-                    fp._bind(secondInput, "keydown", (e) => {
+                    fp._bind(secondInput, "keydown", function (e) {
                         if (e.key === "Enter") {
                             fp.setDate([fp.selectedDates[0], secondInput.value], true, dateFormat);
                             secondInput.click();
@@ -52,14 +82,14 @@
                     fp._input.parentNode &&
                         fp._input.parentNode.insertBefore(secondInput, fp._input.nextSibling);
             };
-            const plugin = {
-                onParseConfig() {
+            var plugin = {
+                onParseConfig: function () {
                     fp.config.mode = "range";
                     dateFormat = fp.config.altInput
                         ? fp.config.altFormat
                         : fp.config.dateFormat;
                 },
-                onReady() {
+                onReady: function () {
                     createSecondInput();
                     fp.config.ignoredFocusElements.push(secondInput);
                     if (fp.config.allowInput) {
@@ -69,31 +99,32 @@
                     else {
                         secondInput.setAttribute("readonly", "readonly");
                     }
-                    fp._bind(fp._input, "focus", () => {
+                    fp._bind(fp._input, "focus", function () {
                         fp.latestSelectedDateObj = fp.selectedDates[0];
                         fp._setHoursFromDate(fp.selectedDates[0]);
-                        [_firstInputFocused, _secondInputFocused] = [true, false];
+                        _secondInputFocused = false;
                         fp.jumpToDate(fp.selectedDates[0]);
                     });
                     if (fp.config.allowInput)
-                        fp._bind(fp._input, "keydown", (e) => {
+                        fp._bind(fp._input, "keydown", function (e) {
                             if (e.key === "Enter")
                                 fp.setDate([fp._input.value, fp.selectedDates[1]], true, dateFormat);
                         });
                     fp.setDate(fp.selectedDates, false);
                     plugin.onValueUpdate(fp.selectedDates);
+                    fp.loadedPlugins.push("range");
                 },
-                onPreCalendarPosition() {
+                onPreCalendarPosition: function () {
                     if (_secondInputFocused) {
                         fp._positionElement = secondInput;
-                        setTimeout(() => {
+                        setTimeout(function () {
                             fp._positionElement = fp._input;
                         }, 0);
                     }
                 },
-                onChange() {
+                onChange: function () {
                     if (!fp.selectedDates.length) {
-                        setTimeout(() => {
+                        setTimeout(function () {
                             if (fp.selectedDates.length)
                                 return;
                             secondInput.value = "";
@@ -101,32 +132,32 @@
                         }, 10);
                     }
                     if (_secondInputFocused) {
-                        setTimeout(() => {
+                        setTimeout(function () {
                             secondInput.focus();
                         }, 0);
                     }
                 },
-                onDestroy() {
+                onDestroy: function () {
                     if (!config.input)
                         secondInput.parentNode &&
                             secondInput.parentNode.removeChild(secondInput);
                 },
-                onValueUpdate(selDates) {
+                onValueUpdate: function (selDates) {
+                    var _a, _b, _c;
                     if (!secondInput)
                         return;
                     _prevDates =
                         !_prevDates || selDates.length >= _prevDates.length
-                            ? [...selDates]
-                            : _prevDates;
+                            ? __spreadArrays(selDates) : _prevDates;
                     if (_prevDates.length > selDates.length) {
-                        const newSelectedDate = selDates[0];
-                        const newDates = _secondInputFocused
+                        var newSelectedDate = selDates[0];
+                        var newDates = _secondInputFocused
                             ? [_prevDates[0], newSelectedDate]
                             : [newSelectedDate, _prevDates[1]];
                         fp.setDate(newDates, false);
-                        _prevDates = [...newDates];
+                        _prevDates = __spreadArrays(newDates);
                     }
-                    [fp._input.value = "", secondInput.value = ""] = fp.selectedDates.map(d => fp.formatDate(d, dateFormat));
+                    _a = fp.selectedDates.map(function (d) { return fp.formatDate(d, dateFormat); }), _b = _a[0], fp._input.value = _b === void 0 ? "" : _b, _c = _a[1], secondInput.value = _c === void 0 ? "" : _c;
                 },
             };
             return plugin;