@paperless/core 2.0.1-beta.4 → 2.0.1-beta.40

package/dist/cjs/p-datepicker.cjs.entry.js

@@ -2,9 +2,34 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-const index$1 = require('./index-02e05522.js');
-const childOf = require('./child-of-af405fc2.js');
-const index = require('./index-b59a0544.js');
+const index$1 = require('./index-3f9bbc0c.js');
+const childOf = require('./child-of-8fbd3ebe.js');
+const isMobileBrowser = require('./is-mobile-browser-0e393879.js');
+const index = require('./index-64168fc4.js');
+
+/**
+ * @name isWeekend
+ * @category Weekday Helpers
+ * @summary Does the given date fall on a weekend?
+ *
+ * @description
+ * Does the given date fall on a weekend?
+ *
+ * @param {Date|Number} date - the date to check
+ * @returns {Boolean} the date falls on a weekend
+ * @throws {TypeError} 1 argument required
+ *
+ * @example
+ * // Does 5 October 2014 fall on a weekend?
+ * const result = isWeekend(new Date(2014, 9, 5))
+ * //=> true
+ */
+function isWeekend(dirtyDate) {
+  index.requiredArgs(1, arguments);
+  var date = index.toDate(dirtyDate);
+  var day = date.getDay();
+  return day === 0 || day === 6;
+}
 
 /**
  * Days in 1 week.
@@ -45,6 +70,33 @@ var millisecondsInHour = 3600000;
  */
 var millisecondsInSecond = 1000;
 
+/**
+ * @name startOfYear
+ * @category Year Helpers
+ * @summary Return the start of a year for the given date.
+ *
+ * @description
+ * Return the start of a year for the given date.
+ * The result will be in the local timezone.
+ *
+ * @param {Date|Number} date - the original date
+ * @returns {Date} the start of a year
+ * @throws {TypeError} 1 argument required
+ *
+ * @example
+ * // The start of a year for 2 September 2014 11:55:00:
+ * const result = startOfYear(new Date(2014, 8, 2, 11, 55, 00))
+ * //=> Wed Jan 01 2014 00:00:00
+ */
+function startOfYear(dirtyDate) {
+  index.requiredArgs(1, arguments);
+  var cleanDate = index.toDate(dirtyDate);
+  var date = new Date(0);
+  date.setFullYear(cleanDate.getFullYear(), 0, 1);
+  date.setHours(0, 0, 0, 0);
+  return date;
+}
+
 function assign(target, object) {
   if (target == null) {
     throw new TypeError('assign requires that input parameter not be null or undefined');
@@ -57,201 +109,166 @@ function assign(target, object) {
   return target;
 }
 
-function _arrayLikeToArray(arr, len) {
-  if (len == null || len > arr.length) len = arr.length;
-  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-  return arr2;
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
 }
 
-function _unsupportedIterableToArray(o, minLen) {
-  if (!o) return;
-  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-  var n = Object.prototype.toString.call(o).slice(8, -1);
-  if (n === "Object" && o.constructor) n = o.constructor.name;
-  if (n === "Map" || n === "Set") return Array.from(o);
-  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
 }
 
-function _createForOfIteratorHelper(o, allowArrayLike) {
-  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
-  if (!it) {
-    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
-      if (it) o = it;
-      var i = 0;
-      var F = function F() {};
+function _createForOfIteratorHelper(r, e) {
+  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (!t) {
+    if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
+      t && (r = t);
+      var _n = 0,
+        F = function F() {};
       return {
         s: F,
         n: function n() {
-          if (i >= o.length) return {
-            done: true
-          };
-          return {
-            done: false,
-            value: o[i++]
+          return _n >= r.length ? {
+            done: !0
+          } : {
+            done: !1,
+            value: r[_n++]
           };
         },
-        e: function e(_e) {
-          throw _e;
+        e: function e(r) {
+          throw r;
         },
         f: F
       };
     }
     throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
   }
-  var normalCompletion = true,
-    didErr = false,
-    err;
+  var o,
+    a = !0,
+    u = !1;
   return {
     s: function s() {
-      it = it.call(o);
+      t = t.call(r);
     },
     n: function n() {
-      var step = it.next();
-      normalCompletion = step.done;
-      return step;
+      var r = t.next();
+      return a = r.done, r;
     },
-    e: function e(_e2) {
-      didErr = true;
-      err = _e2;
+    e: function e(r) {
+      u = !0, o = r;
     },
     f: function f() {
       try {
-        if (!normalCompletion && it["return"] != null) it["return"]();
+        a || null == t["return"] || t["return"]();
       } finally {
-        if (didErr) throw err;
+        if (u) throw o;
       }
     }
   };
 }
 
-function _assertThisInitialized(self) {
-  if (self === void 0) {
-    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-  }
-  return self;
+function _assertThisInitialized(e) {
+  if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return e;
 }
 
-function _setPrototypeOf(o, p) {
-  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
-    o.__proto__ = p;
-    return o;
-  };
-  return _setPrototypeOf(o, p);
+function _setPrototypeOf(t, e) {
+  return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
+    return t.__proto__ = e, t;
+  }, _setPrototypeOf(t, e);
 }
 
-function _inherits(subClass, superClass) {
-  if (typeof superClass !== "function" && superClass !== null) {
-    throw new TypeError("Super expression must either be null or a function");
-  }
-  subClass.prototype = Object.create(superClass && superClass.prototype, {
+function _inherits(t, e) {
+  if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function");
+  t.prototype = Object.create(e && e.prototype, {
     constructor: {
-      value: subClass,
-      writable: true,
-      configurable: true
+      value: t,
+      writable: !0,
+      configurable: !0
     }
-  });
-  Object.defineProperty(subClass, "prototype", {
-    writable: false
-  });
-  if (superClass) _setPrototypeOf(subClass, superClass);
+  }), Object.defineProperty(t, "prototype", {
+    writable: !1
+  }), e && _setPrototypeOf(t, e);
 }
 
-function _getPrototypeOf(o) {
-  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
-    return o.__proto__ || Object.getPrototypeOf(o);
-  };
-  return _getPrototypeOf(o);
+function _getPrototypeOf(t) {
+  return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) {
+    return t.__proto__ || Object.getPrototypeOf(t);
+  }, _getPrototypeOf(t);
 }
 
 function _isNativeReflectConstruct() {
-  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
-  if (Reflect.construct.sham) return false;
-  if (typeof Proxy === "function") return true;
   try {
-    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
-    return true;
-  } catch (e) {
-    return false;
-  }
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+  } catch (t) {}
+  return (_isNativeReflectConstruct = function _isNativeReflectConstruct() {
+    return !!t;
+  })();
 }
 
-function _possibleConstructorReturn(self, call) {
-  if (call && (index._typeof(call) === "object" || typeof call === "function")) {
-    return call;
-  } else if (call !== void 0) {
-    throw new TypeError("Derived constructors may only return object or undefined");
-  }
-  return _assertThisInitialized(self);
+function _possibleConstructorReturn(t, e) {
+  if (e && ("object" == index._typeof(e) || "function" == typeof e)) return e;
+  if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined");
+  return _assertThisInitialized(t);
 }
 
-function _createSuper(Derived) {
-  var hasNativeReflectConstruct = _isNativeReflectConstruct();
-  return function _createSuperInternal() {
-    var Super = _getPrototypeOf(Derived),
-      result;
-    if (hasNativeReflectConstruct) {
-      var NewTarget = _getPrototypeOf(this).constructor;
-      result = Reflect.construct(Super, arguments, NewTarget);
-    } else {
-      result = Super.apply(this, arguments);
-    }
-    return _possibleConstructorReturn(this, result);
+function _createSuper(t) {
+  var r = _isNativeReflectConstruct();
+  return function () {
+    var e,
+      o = _getPrototypeOf(t);
+    if (r) {
+      var s = _getPrototypeOf(this).constructor;
+      e = Reflect.construct(o, arguments, s);
+    } else e = o.apply(this, arguments);
+    return _possibleConstructorReturn(this, e);
   };
 }
 
-function _classCallCheck(instance, Constructor) {
-  if (!(instance instanceof Constructor)) {
-    throw new TypeError("Cannot call a class as a function");
-  }
+function _classCallCheck(a, n) {
+  if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
 }
 
-function _toPrimitive(input, hint) {
-  if (index._typeof(input) !== "object" || input === null) return input;
-  var prim = input[Symbol.toPrimitive];
-  if (prim !== undefined) {
-    var res = prim.call(input, hint || "default");
-    if (index._typeof(res) !== "object") return res;
+function toPrimitive(t, r) {
+  if ("object" != index._typeof(t) || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != index._typeof(i)) return i;
     throw new TypeError("@@toPrimitive must return a primitive value.");
   }
-  return (hint === "string" ? String : Number)(input);
+  return ("string" === r ? String : Number)(t);
 }
 
-function _toPropertyKey(arg) {
-  var key = _toPrimitive(arg, "string");
-  return index._typeof(key) === "symbol" ? key : String(key);
+function toPropertyKey(t) {
+  var i = toPrimitive(t, "string");
+  return "symbol" == index._typeof(i) ? i : i + "";
 }
 
-function _defineProperties(target, props) {
-  for (var i = 0; i < props.length; i++) {
-    var descriptor = props[i];
-    descriptor.enumerable = descriptor.enumerable || false;
-    descriptor.configurable = true;
-    if ("value" in descriptor) descriptor.writable = true;
-    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+function _defineProperties(e, r) {
+  for (var t = 0; t < r.length; t++) {
+    var o = r[t];
+    o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, toPropertyKey(o.key), o);
   }
 }
-function _createClass(Constructor, protoProps, staticProps) {
-  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-  if (staticProps) _defineProperties(Constructor, staticProps);
-  Object.defineProperty(Constructor, "prototype", {
-    writable: false
-  });
-  return Constructor;
+function _createClass(e, r, t) {
+  return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
+    writable: !1
+  }), e;
 }
 
-function _defineProperty(obj, key, value) {
-  key = _toPropertyKey(key);
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
+function _defineProperty(e, r, t) {
+  return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[r] = t, e;
 }
 
 var TIMEZONE_UNIT_PRIORITY = 10;
@@ -2699,7 +2716,7 @@ function parse(dirtyDateString, dirtyFormatString, dirtyReferenceDate, options)
   var dateString = String(dirtyDateString);
   var formatString = String(dirtyFormatString);
   var defaultOptions = index.getDefaultOptions();
-  var locale = (_ref = (_options$locale = options === null || options === void 0 ? void 0 : options.locale) !== null && _options$locale !== void 0 ? _options$locale : defaultOptions.locale) !== null && _ref !== void 0 ? _ref : index.locale;
+  var locale = (_ref = (_options$locale = options === null || options === void 0 ? void 0 : options.locale) !== null && _options$locale !== void 0 ? _options$locale : defaultOptions.locale) !== null && _ref !== void 0 ? _ref : index.defaultLocale;
   if (!locale.match) {
     throw new RangeError('locale must contain match property');
   }
@@ -2864,188 +2881,237 @@ function cleanEscapedString(input) {
   return input.match(escapedStringRegExp)[1].replace(doubleQuoteRegExp, "'");
 }
 
-const datepickerComponentCss = ".flex{display:flex!important}*{box-sizing:border-box}:host{display:flex;flex-direction:column}:host input.read-only{text-overflow:ellipsis}.static{position:static!important}.absolute{position:absolute!important}.cursor-pointer{cursor:pointer!important}.filter{filter:var(--tw-blur) var(--tw-brightness) var(--tw-contrast) var(--tw-grayscale) var(--tw-hue-rotate) var(--tw-invert) var(--tw-saturate) var(--tw-sepia) var(--tw-drop-shadow)!important}";
+const datepickerComponentCss = "*{box-sizing:border-box}.static{position:static!important}.absolute{position:absolute!important}.h-0{height:0!important}.overflow-hidden{overflow:hidden!important}.blur{--tw-blur:blur(8px)!important}.blur,.filter{filter:var(--tw-blur) var(--tw-brightness) var(--tw-contrast) var(--tw-grayscale) var(--tw-hue-rotate) var(--tw-invert) var(--tw-saturate) var(--tw-sepia) var(--tw-drop-shadow)!important}";
+const PDatepickerStyle0 = datepickerComponentCss;
 
 const Datepicker = class {
-  constructor(hostRef) {
-    index$1.registerInstance(this, hostRef);
-    this.valueChange = index$1.createEvent(this, "valueChange", 3);
-    this._defaultFormats = {
-      year: 'yyyy',
-      month: 'LLLL, yyyy',
-      day: 'dd-MM-yyyy',
+    constructor(hostRef) {
+        index$1.registerInstance(this, hostRef);
+        this.valueChange = index$1.createEvent(this, "valueChange", 3);
+        this.placeholder = undefined;
+        this.value = undefined;
+        this.preselectToday = false;
+        this.enableNativePicker = true;
+        this.disabledDates = undefined;
+        this.minDate = undefined;
+        this.maxDate = undefined;
+        this.disableWeekends = false;
+        this.mode = 'day';
+        this.format = 'dd-MM-yyyy';
+        this.hideIconWhenFilled = false;
+        this.size = 'base';
+        this.prefix = undefined;
+        this.label = undefined;
+        this.helper = undefined;
+        this.required = undefined;
+        this.error = undefined;
+        this.disabled = false;
+        this.strategy = 'absolute';
+        this.placement = 'bottom-start';
+        this._showDropdown = false;
+        this._value = undefined;
+        this._minDate = undefined;
+        this._maxDate = undefined;
+        this._disabledDates = [];
+        this._isMobileBrowser = false;
+    }
+    /**
+     * Event when the value changes
+     */
+    valueChange;
+    get _el() { return index$1.getElement(this); }
+    _onInputTimeout;
+    _inputRef;
+    _dateInputRef;
+    _defaultFormats = {
+        year: 'yyyy',
+        month: 'LLLL, yyyy',
+        day: 'dd-MM-yyyy',
     };
-    this.placeholder = undefined;
-    this.value = undefined;
-    this.preselectToday = false;
-    this.disabledDates = undefined;
-    this.minDate = undefined;
-    this.maxDate = undefined;
-    this.disableWeekends = false;
-    this.mode = 'day';
-    this.format = 'dd-MM-yyyy';
-    this.hideIconWhenFilled = false;
-    this.size = 'medium';
-    this.prefix = undefined;
-    this.label = undefined;
-    this.helper = undefined;
-    this.required = undefined;
-    this.error = undefined;
-    this.disabled = false;
-    this.strategy = 'absolute';
-    this.placement = 'bottom-start';
-    this._showDropdown = false;
-    this._value = undefined;
-    this._minDate = undefined;
-    this._maxDate = undefined;
-    this._disabledDates = [];
-  }
-  parseValue(value) {
-    if (!value && this.preselectToday) {
-      value = new Date();
-    }
-    if (typeof value === 'string') {
-      value = new Date(value);
-    }
-    this._setValue(value);
-  }
-  parseMinDate(minDate) {
-    if (typeof minDate === 'string') {
-      minDate = new Date(minDate);
-    }
-    if (!index.isValid(minDate)) {
-      return;
-    }
-    this._minDate = minDate;
-    if (index.isBefore(this._value, this._minDate)) {
-      this._setValue(null);
-    }
-  }
-  parseMaxDate(maxDate) {
-    if (typeof maxDate === 'string') {
-      maxDate = new Date(maxDate);
-    }
-    if (!index.isValid(maxDate)) {
-      return;
-    }
-    this._maxDate = maxDate;
-    if (index.isAfter(this._value, this._maxDate)) {
-      this._setValue(null);
-    }
-  }
-  parseDisabledDates(disabledDates) {
-    if (typeof disabledDates === 'string') {
-      disabledDates = JSON.parse(disabledDates);
-    }
-    if (!disabledDates || !Array.isArray(disabledDates)) {
-      return;
-    }
-    // normalize all to date
-    this._disabledDates = disabledDates
-      .map(date => {
-      if (typeof date === 'string') {
-        return new Date(date);
-      }
-      return date;
-    })
-      .filter(date => index.isValid(date));
-    if (this._isDisabledDay(this._value)) {
-      this._setValue(null);
-    }
-  }
-  componentWillLoad() {
-    if (this.disabledDates) {
-      this.parseDisabledDates(this.disabledDates);
-    }
-    if (this.minDate) {
-      this.parseMinDate(this.minDate);
-    }
-    if (this.maxDate) {
-      this.parseMaxDate(this.maxDate);
-    }
-    if (this.mode !== 'day' && this.format === this._defaultFormats['day']) {
-      this.format = this._defaultFormats[this.mode];
+    parseValue(value) {
+        if (!value && this.preselectToday) {
+            value = new Date();
+        }
+        if (typeof value === 'string') {
+            value = new Date(value);
+        }
+        this._setValue(value);
     }
-    this.parseValue(this.value);
-  }
-  render() {
-    return (index$1.h(index$1.Host, { class: 'p-datepicker' }, index$1.h("p-dropdown", { strategy: this.strategy, placement: this.placement, disableTriggerClick: true, applyMaxWidth: false, applyFullWidth: false, insideClick: true, show: this._showDropdown }, index$1.h("p-input-group", { slot: 'trigger', icon: this.hideIconWhenFilled && !!this._value ? null : 'calendar', iconPosition: 'start', size: this.size, prefix: this.prefix, label: this.label, helper: this.helper, required: this.required, error: this.error, disabled: this.disabled, focused: this._showDropdown }, index$1.h("input", { slot: 'input', type: 'text', placeholder: this.placeholder, value: this._getFormattedDate(), class: 'p-input cursor-pointer', onFocus: () => this._onFocus(), onBlur: ev => this._onBlur(ev), onInput: ev => this._onInput(ev) })), index$1.h("div", { slot: 'items' }, index$1.h("p-calendar", { variant: 'embedded', value: this._value, onValueChange: ({ detail }) => (this.value = detail), preselectToday: this.preselectToday, disabledDates: this.disabledDates, minDate: this.minDate, maxDate: this.maxDate, disableWeekends: this.disableWeekends, mode: this.mode })))));
-  }
-  documentClickHandler({ target }) {
-    if (!this._showDropdown || childOf.childOf(target, this._el)) {
-      return;
+    parseMinDate(minDate) {
+        if (typeof minDate === 'string') {
+            minDate = new Date(minDate);
+        }
+        if (!index.isValid(minDate)) {
+            return;
+        }
+        this._minDate = minDate;
+        if (index.isBefore(this._value, this._minDate)) {
+            this._setValue(null);
+        }
     }
-    this._showDropdown = false;
-  }
-  _onFocus() {
-    this._showDropdown = true;
-  }
-  _onBlur(ev) {
-    if (ev.target.value === null) {
-      return;
+    parseMaxDate(maxDate) {
+        if (typeof maxDate === 'string') {
+            maxDate = new Date(maxDate);
+        }
+        if (!index.isValid(maxDate)) {
+            return;
+        }
+        this._maxDate = maxDate;
+        if (index.isAfter(this._value, this._maxDate)) {
+            this._setValue(null);
+        }
     }
-    const value = parse(ev.target.value, this.format, new Date());
-    if (!index.isValid(value) || this._isDisabledDay(value)) {
-      ev.target.value = this._getFormattedDate();
-      return;
+    parseDisabledDates(disabledDates) {
+        if (typeof disabledDates === 'string') {
+            disabledDates = JSON.parse(disabledDates);
+        }
+        if (!disabledDates || !Array.isArray(disabledDates)) {
+            return;
+        }
+        // normalize all to date
+        this._disabledDates = disabledDates
+            .map(date => {
+            if (typeof date === 'string') {
+                return new Date(date);
+            }
+            return date;
+        })
+            .filter(date => index.isValid(date));
+        if (this._isDisabledDay(this._value)) {
+            this._setValue(null);
+        }
     }
-  }
-  _onInput(ev) {
-    if (this._onInputTimeout) {
-      clearTimeout(this._onInputTimeout);
-      this._onInputTimeout = null;
-    }
-    this._onInputTimeout = setTimeout(() => {
-      const value = parse(ev.target.value, this.format, new Date());
-      if (!index.isValid(value)) {
-        return;
-      }
-      this._setValue(value, false);
-    }, 250);
-  }
-  _setValue(value, hideDropdown = true) {
-    if (value === null) {
-      this._value = null;
-      this.valueChange.emit(null);
-      return;
+    componentWillLoad() {
+        if (this.disabledDates) {
+            this.parseDisabledDates(this.disabledDates);
+        }
+        if (this.minDate) {
+            this.parseMinDate(this.minDate);
+        }
+        if (this.maxDate) {
+            this.parseMaxDate(this.maxDate);
+        }
+        if (this.mode !== 'day' && this.format === this._defaultFormats['day']) {
+            this.format = this._defaultFormats[this.mode];
+        }
+        this._isMobileBrowser = isMobileBrowser.isMobileBrowser();
+        this.parseValue(this.value);
     }
-    if (!index.isValid(value)) {
-      return;
+    render() {
+        return (index$1.h(index$1.Host, { key: '859b876921f336859ff7e95b5c78517c74d795f7', class: 'p-datepicker' }, index$1.h("p-dropdown", { key: '4f89918eee02180a5a5e75618c01949c37259a01', strategy: this.strategy, placement: this.placement, disableTriggerClick: true, applyMaxWidth: false, applyFullWidth: false, insideClick: true, show: this._showDropdown }, index$1.h("p-field", { key: '70bac67fc5253c58b8a9ea85458decc98680c789', slot: 'trigger', icon: this.hideIconWhenFilled && !!this._value ? null : 'calendar-multi', iconPosition: 'start', size: this.size, prefix: this.prefix, label: this.label, helper: this.helper, required: this.required, error: this.error, disabled: this.disabled, focused: this._showDropdown, value: this._getFormattedDate(), placeholder: this.placeholder, onFocus: () => this._onFocus(), onBlur: () => this._onBlur(), onValueChange: ev => this._onValueChange(ev.detail), onInputRefChange: ev => (this._inputRef = ev.detail) }), this.enableNativePicker && this._isMobileBrowser && (index$1.h("input", { key: 'fbb07a9c49a08e16c741839eab8020ab7b520d7d', slot: 'trigger', type: this.mode === 'day' ? 'date' : 'month', class: 'h-0 overflow-hidden' // we use h-0 here so location dependent pickers can correctly place itself
+            ,
+            onInput: ev => this._onNativeInput(ev), ref: ref => (this._dateInputRef = ref), value: this._value && index.format(this._value, 'yyyy-MM-dd'), min: this.minDate && index.format(new Date(this.minDate), 'yyyy-MM-dd'), max: this.maxDate && index.format(new Date(this.maxDate), 'yyyy-MM-dd') })), index$1.h("div", { key: '932e4d12ff014bd5c87fcf4eabf2f4a8ca8d7855', slot: 'items' }, index$1.h("p-calendar", { key: '54e2aecf8ec972795cbba708075e26561b7b4ea5', variant: 'embedded', value: this._value, onValueChange: ({ detail }) => (this.value = detail), preselectToday: this.preselectToday, disabledDates: this.disabledDates, minDate: this.minDate, maxDate: this.maxDate, disableWeekends: this.disableWeekends, mode: this.mode })))));
     }
-    if (this._isDisabledDay(value)) {
-      return;
+    documentClickHandler({ target }) {
+        if (!this._showDropdown || childOf.childOf(target, this._el)) {
+            return;
+        }
+        this._showDropdown = false;
     }
-    value = index.startOfDay(value);
-    const isSameValue = index.isSameDay(value, this._value);
-    if (isSameValue) {
-      return;
+    _onFocus() {
+        if (this._isMobileBrowser && this._dateInputRef) {
+            this._dateInputRef.showPicker();
+            this._inputRef.blur();
+            return;
+        }
+        this._showDropdown = true;
     }
-    if (hideDropdown) {
-      this._showDropdown = false;
+    _onBlur() {
+        if (this._isMobileBrowser && this._dateInputRef) {
+            return;
+        }
+        const target = this._inputRef;
+        if (target.value === null) {
+            return;
+        }
+        const value = parse(target.value, this.format, new Date());
+        if (value === this._value) {
+            return;
+        }
+        if (!index.isValid(value) || this._isDisabledDay(value)) {
+            target.value = this._getFormattedDate();
+            return;
+        }
+        this._setValue(value, false);
     }
-    this._value = value;
-    this.valueChange.emit(value);
-  }
-  _isDisabledDay(day) {
-    return ((index.isBefore(day, this._minDate) && !index.isSameDay(day, this._minDate)) ||
-      (index.isAfter(day, this._maxDate) && !index.isSameDay(day, this._maxDate)) ||
-      this._disabledDates.findIndex(date => index.isSameDay(date, day)) >= 0);
-  }
-  _getFormattedDate() {
-    if (!this._value) {
-      return '';
+    _onValueChange(value) {
+        if (this._onInputTimeout) {
+            clearTimeout(this._onInputTimeout);
+            this._onInputTimeout = null;
+        }
+        this._onInputTimeout = setTimeout(() => {
+            const parsedValue = parse(value, this.format, new Date());
+            if (!index.isValid(parsedValue)) {
+                return;
+            }
+            this._setValue(parsedValue, false);
+        }, 300);
+    }
+    _onNativeInput(ev) {
+        if (!ev.target) {
+            return;
+        }
+        if (this._onInputTimeout) {
+            clearTimeout(this._onInputTimeout);
+            this._onInputTimeout = null;
+        }
+        this._onInputTimeout = setTimeout(() => {
+            this._setValue(ev.target.value === '' ? null : new Date(ev.target.value), false);
+        });
     }
-    return index.format(this._value, this.format);
-  }
-  get _el() { return index$1.getElement(this); }
-  static get watchers() { return {
-    "value": ["parseValue"],
-    "minDate": ["parseMinDate"],
-    "maxDate": ["parseMaxDate"],
-    "disabledDates": ["parseDisabledDates"]
-  }; }
+    _setValue(value, hideDropdown = true) {
+        if (value === null) {
+            this._value = null;
+            this.valueChange.emit(null);
+            return;
+        }
+        if (!index.isValid(value)) {
+            return;
+        }
+        if (this._isDisabledDay(value)) {
+            if (!!this._dateInputRef?.value) {
+                this._dateInputRef.value = this._value
+                    ? index.format(this._value, 'yyyy-MM-dd')
+                    : null;
+            }
+            return;
+        }
+        value =
+            this.mode === 'day'
+                ? index.startOfDay(value)
+                : this.mode === 'month'
+                    ? index.startOfMonth(value)
+                    : startOfYear(value);
+        const isSameValue = index.isSameDay(value, this._value);
+        if (isSameValue) {
+            return;
+        }
+        if (hideDropdown) {
+            this._showDropdown = false;
+        }
+        this._value = value;
+        this.valueChange.emit(value);
+    }
+    _isDisabledDay(day) {
+        return ((this.disableWeekends && isWeekend(day)) ||
+            (index.isBefore(day, this._minDate) && !index.isSameDay(day, this._minDate)) ||
+            (index.isAfter(day, this._maxDate) && !index.isSameDay(day, this._maxDate)) ||
+            this._disabledDates.findIndex(date => index.isSameDay(date, day)) >= 0);
+    }
+    _getFormattedDate() {
+        if (!this._value) {
+            return '';
+        }
+        return index.format(this._value, this.format);
+    }
+    static get watchers() { return {
+        "value": ["parseValue"],
+        "minDate": ["parseMinDate"],
+        "maxDate": ["parseMaxDate"],
+        "disabledDates": ["parseDisabledDates"]
+    }; }
 };
-Datepicker.style = datepickerComponentCss;
+Datepicker.style = PDatepickerStyle0;
 
 exports.p_datepicker = Datepicker;