buefy 0.7.9 → 0.8.2

package/dist/esm/chunk-0566c90d.js

@@ -0,0 +1,152 @@
+/*! Buefy v0.7.10 | MIT License | github.com/buefy/buefy */
+import { c as config } from './chunk-2cb6f867.js';
+
+var FormElementMixin = {
+  props: {
+    size: String,
+    expanded: Boolean,
+    loading: Boolean,
+    rounded: Boolean,
+    icon: String,
+    iconPack: String,
+    // Native options to use in HTML5 validation
+    autocomplete: String,
+    maxlength: [Number, String],
+    useHtml5Validation: {
+      type: Boolean,
+      default: function _default() {
+        return config.defaultUseHtml5Validation;
+      }
+    },
+    validationMessage: String
+  },
+  data: function data() {
+    return {
+      isValid: true,
+      isFocused: false,
+      newIconPack: this.iconPack || config.defaultIconPack
+    };
+  },
+  computed: {
+    /**
+     * Find parent Field, max 3 levels deep.
+     */
+    parentField: function parentField() {
+      var parent = this.$parent;
+
+      for (var i = 0; i < 3; i++) {
+        if (parent && !parent.$data._isField) {
+          parent = parent.$parent;
+        }
+      }
+
+      return parent;
+    },
+
+    /**
+     * Get the type prop from parent if it's a Field.
+     */
+    statusType: function statusType() {
+      if (!this.parentField) return;
+      if (!this.parentField.newType) return;
+
+      if (typeof this.parentField.newType === 'string') {
+        return this.parentField.newType;
+      } else {
+        for (var key in this.parentField.newType) {
+          if (this.parentField.newType[key]) {
+            return key;
+          }
+        }
+      }
+    },
+
+    /**
+     * Get the message prop from parent if it's a Field.
+     */
+    statusMessage: function statusMessage() {
+      if (!this.parentField) return;
+      return this.parentField.newMessage;
+    },
+
+    /**
+     * Fix icon size for inputs, large was too big
+     */
+    iconSize: function iconSize() {
+      switch (this.size) {
+        case 'is-small':
+          return this.size;
+
+        case 'is-medium':
+          return;
+
+        case 'is-large':
+          return this.newIconPack === 'mdi' ? 'is-medium' : '';
+      }
+    }
+  },
+  methods: {
+    /**
+     * Focus method that work dynamically depending on the component.
+     */
+    focus: function focus() {
+      var _this = this;
+
+      if (this.$data._elementRef === undefined) return;
+      this.$nextTick(function () {
+        var el = _this.$el.querySelector(_this.$data._elementRef);
+
+        if (el) el.focus();
+      });
+    },
+    onBlur: function onBlur($event) {
+      this.isFocused = false;
+      this.$emit('blur', $event);
+      this.checkHtml5Validity();
+    },
+    onFocus: function onFocus($event) {
+      this.isFocused = true;
+      this.$emit('focus', $event);
+    },
+
+    /**
+     * Check HTML5 validation, set isValid property.
+     * If validation fail, send 'is-danger' type,
+     * and error message to parent if it's a Field.
+     */
+    checkHtml5Validity: function checkHtml5Validity() {
+      var _this2 = this;
+
+      if (!this.useHtml5Validation) return;
+      if (this.$refs[this.$data._elementRef] === undefined) return;
+      var el = this.$el.querySelector(this.$data._elementRef);
+      var type = null;
+      var message = null;
+      var isValid = true;
+
+      if (!el.checkValidity()) {
+        type = 'is-danger';
+        message = this.validationMessage || el.validationMessage;
+        isValid = false;
+      }
+
+      this.isValid = isValid;
+      this.$nextTick(function () {
+        if (_this2.parentField) {
+          // Set type only if not defined
+          if (!_this2.parentField.type) {
+            _this2.parentField.newType = type;
+          } // Set message only if not defined
+
+
+          if (!_this2.parentField.message) {
+            _this2.parentField.newMessage = message;
+          }
+        }
+      });
+      return this.isValid;
+    }
+  }
+};
+
+export { FormElementMixin as F };

package/dist/esm/chunk-07e19446.js

@@ -0,0 +1,545 @@
+import { i as isMobile } from './chunk-e5fce48f.js';
+import { c as config } from './chunk-9e3207cc.js';
+import { F as FormElementMixin } from './chunk-10c85529.js';
+
+var AM = 'AM';
+var PM = 'PM';
+var HOUR_FORMAT_24 = '24';
+var HOUR_FORMAT_12 = '12';
+
+var defaultTimeFormatter = function defaultTimeFormatter(date, vm) {
+  var hours = date.getHours();
+  var minutes = date.getMinutes();
+  var seconds = date.getSeconds();
+  var period = '';
+
+  if (vm.hourFormat === HOUR_FORMAT_12) {
+    period = ' ' + (hours < 12 ? AM : PM);
+
+    if (hours > 12) {
+      hours -= 12;
+    } else if (hours === 0) {
+      hours = 12;
+    }
+  }
+
+  return vm.pad(hours) + ':' + vm.pad(minutes) + (vm.enableSeconds ? ':' + vm.pad(seconds) : '') + period;
+};
+
+var defaultTimeParser = function defaultTimeParser(timeString, vm) {
+  if (timeString) {
+    var am = false;
+
+    if (vm.hourFormat === HOUR_FORMAT_12) {
+      var dateString12 = timeString.split(' ');
+      timeString = dateString12[0];
+      am = dateString12[1] === AM;
+    }
+
+    var time = timeString.split(':');
+    var hours = parseInt(time[0], 10);
+    var minutes = parseInt(time[1], 10);
+    var seconds = vm.enableSeconds ? parseInt(time[2], 10) : 0;
+
+    if (isNaN(hours) || hours < 0 || hours > 23 || vm.hourFormat === HOUR_FORMAT_12 && (hours < 1 || hours > 12) || isNaN(minutes) || minutes < 0 || minutes > 59) {
+      return null;
+    }
+
+    var d = null;
+
+    if (vm.computedValue && !isNaN(vm.computedValue)) {
+      d = new Date(vm.computedValue);
+    } else {
+      d = new Date();
+      d.setMilliseconds(0);
+    }
+
+    d.setSeconds(seconds);
+    d.setMinutes(minutes);
+
+    if (vm.hourFormat === HOUR_FORMAT_12) {
+      if (am && hours === 12) {
+        hours = 0;
+      } else if (!am && hours !== 12) {
+        hours += 12;
+      }
+    }
+
+    d.setHours(hours);
+    return new Date(d.getTime());
+  }
+
+  return null;
+};
+
+var TimepickerMixin = {
+  mixins: [FormElementMixin],
+  inheritAttrs: false,
+  props: {
+    value: Date,
+    inline: Boolean,
+    minTime: Date,
+    maxTime: Date,
+    placeholder: String,
+    editable: Boolean,
+    disabled: Boolean,
+    hourFormat: {
+      type: String,
+      default: HOUR_FORMAT_24,
+      validator: function validator(value) {
+        return value === HOUR_FORMAT_24 || value === HOUR_FORMAT_12;
+      }
+    },
+    incrementMinutes: {
+      type: Number,
+      default: 1
+    },
+    incrementSeconds: {
+      type: Number,
+      default: 1
+    },
+    timeFormatter: {
+      type: Function,
+      default: function _default(date, vm) {
+        if (typeof config.defaultTimeFormatter === 'function') {
+          return config.defaultTimeFormatter(date);
+        } else {
+          return defaultTimeFormatter(date, vm);
+        }
+      }
+    },
+    timeParser: {
+      type: Function,
+      default: function _default(date, vm) {
+        if (typeof config.defaultTimeParser === 'function') {
+          return config.defaultTimeParser(date);
+        } else {
+          return defaultTimeParser(date, vm);
+        }
+      }
+    },
+    mobileNative: {
+      type: Boolean,
+      default: function _default() {
+        return config.defaultTimepickerMobileNative;
+      }
+    },
+    position: String,
+    unselectableTimes: Array,
+    openOnFocus: Boolean,
+    enableSeconds: Boolean,
+    defaultMinutes: Number,
+    defaultSeconds: Number
+  },
+  data: function data() {
+    return {
+      dateSelected: this.value,
+      hoursSelected: null,
+      minutesSelected: null,
+      secondsSelected: null,
+      meridienSelected: null,
+      _elementRef: 'input',
+      AM: AM,
+      PM: PM,
+      HOUR_FORMAT_24: HOUR_FORMAT_24,
+      HOUR_FORMAT_12: HOUR_FORMAT_12
+    };
+  },
+  computed: {
+    computedValue: {
+      get: function get() {
+        return this.dateSelected;
+      },
+      set: function set(value) {
+        this.dateSelected = value;
+        this.$emit('input', value);
+      }
+    },
+    hours: function hours() {
+      var hours = [];
+      var numberOfHours = this.isHourFormat24 ? 24 : 12;
+
+      for (var i = 0; i < numberOfHours; i++) {
+        var value = i;
+        var label = value;
+
+        if (!this.isHourFormat24) {
+          value = i + 1;
+          label = value;
+
+          if (this.meridienSelected === this.AM) {
+            if (value === 12) {
+              value = 0;
+            }
+          } else if (this.meridienSelected === this.PM) {
+            if (value !== 12) {
+              value += 12;
+            }
+          }
+        }
+
+        hours.push({
+          label: this.formatNumber(label),
+          value: value
+        });
+      }
+
+      return hours;
+    },
+    minutes: function minutes() {
+      var minutes = [];
+
+      for (var i = 0; i < 60; i += this.incrementMinutes) {
+        minutes.push({
+          label: this.formatNumber(i, true),
+          value: i
+        });
+      }
+
+      return minutes;
+    },
+    seconds: function seconds() {
+      var seconds = [];
+
+      for (var i = 0; i < 60; i += this.incrementSeconds) {
+        seconds.push({
+          label: this.formatNumber(i, true),
+          value: i
+        });
+      }
+
+      return seconds;
+    },
+    meridiens: function meridiens() {
+      return [AM, PM];
+    },
+    isMobile: function isMobile$1() {
+      return this.mobileNative && isMobile.any();
+    },
+    isHourFormat24: function isHourFormat24() {
+      return this.hourFormat === HOUR_FORMAT_24;
+    }
+  },
+  watch: {
+    hourFormat: function hourFormat() {
+      if (this.hoursSelected !== null) {
+        this.meridienSelected = this.hoursSelected >= 12 ? PM : AM;
+      }
+    },
+
+    /**
+     * When v-model is changed:
+     *   1. Update internal value.
+     *   2. If it's invalid, validate again.
+     */
+    value: {
+      handler: function handler(value) {
+        this.updateInternalState(value);
+        !this.isValid && this.$refs.input.checkHtml5Validity();
+      },
+      immediate: true
+    }
+  },
+  methods: {
+    onMeridienChange: function onMeridienChange(value) {
+      if (this.hoursSelected !== null) {
+        if (value === PM) {
+          this.hoursSelected += 12;
+        } else if (value === AM) {
+          this.hoursSelected -= 12;
+        }
+      }
+
+      this.updateDateSelected(this.hoursSelected, this.minutesSelected, this.enableSeconds ? this.secondsSelected : 0, value);
+    },
+    onHoursChange: function onHoursChange(value) {
+      if (!this.minutesSelected && this.defaultMinutes) {
+        this.minutesSelected = this.defaultMinutes;
+      }
+
+      if (!this.secondsSelected && this.defaultSeconds) {
+        this.secondsSelected = this.defaultSeconds;
+      }
+
+      this.updateDateSelected(parseInt(value, 10), this.minutesSelected, this.enableSeconds ? this.secondsSelected : 0, this.meridienSelected);
+    },
+    onMinutesChange: function onMinutesChange(value) {
+      if (!this.secondsSelected && this.defaultSeconds) {
+        this.secondsSelected = this.defaultSeconds;
+      }
+
+      this.updateDateSelected(this.hoursSelected, parseInt(value, 10), this.enableSeconds ? this.secondsSelected : 0, this.meridienSelected);
+    },
+    onSecondsChange: function onSecondsChange(value) {
+      this.updateDateSelected(this.hoursSelected, this.minutesSelected, parseInt(value, 10), this.meridienSelected);
+    },
+    updateDateSelected: function updateDateSelected(hours, minutes, seconds, meridiens) {
+      if (hours != null && minutes != null && (!this.isHourFormat24 && meridiens !== null || this.isHourFormat24)) {
+        var time = null;
+
+        if (this.computedValue && !isNaN(this.computedValue)) {
+          time = new Date(this.computedValue);
+        } else {
+          time = new Date();
+          time.setMilliseconds(0);
+        }
+
+        time.setHours(hours);
+        time.setMinutes(minutes);
+        time.setSeconds(seconds);
+        this.computedValue = new Date(time.getTime());
+      }
+    },
+    updateInternalState: function updateInternalState(value) {
+      if (value) {
+        this.hoursSelected = value.getHours();
+        this.minutesSelected = value.getMinutes();
+        this.secondsSelected = value.getSeconds();
+        this.meridienSelected = value.getHours() >= 12 ? PM : AM;
+      } else {
+        this.hoursSelected = null;
+        this.minutesSelected = null;
+        this.secondsSelected = null;
+        this.meridienSelected = AM;
+      }
+
+      this.dateSelected = value;
+    },
+    isHourDisabled: function isHourDisabled(hour) {
+      var _this = this;
+
+      var disabled = false;
+
+      if (this.minTime) {
+        var minHours = this.minTime.getHours();
+        disabled = hour < minHours;
+      }
+
+      if (this.maxTime) {
+        if (!disabled) {
+          var maxHours = this.maxTime.getHours();
+          disabled = hour > maxHours;
+        }
+      }
+
+      if (this.unselectableTimes) {
+        if (!disabled) {
+          var unselectable = this.unselectableTimes.filter(function (time) {
+            if (_this.enableSeconds && _this.secondsSelected !== null) {
+              return time.getHours() === hour && time.getMinutes() === _this.minutesSelected && time.getSeconds() === _this.secondsSelected;
+            } else if (_this.minutesSelected !== null) {
+              return time.getHours() === hour && time.getMinutes() === _this.minutesSelected;
+            } else {
+              return time.getHours() === hour;
+            }
+          });
+          disabled = unselectable.length > 0;
+        }
+      }
+
+      return disabled;
+    },
+    isMinuteDisabled: function isMinuteDisabled(minute) {
+      var _this2 = this;
+
+      var disabled = false;
+
+      if (this.hoursSelected !== null) {
+        if (this.isHourDisabled(this.hoursSelected)) {
+          disabled = true;
+        } else {
+          if (this.minTime) {
+            var minHours = this.minTime.getHours();
+            var minMinutes = this.minTime.getMinutes();
+            disabled = this.hoursSelected === minHours && minute < minMinutes;
+          }
+
+          if (this.maxTime) {
+            if (!disabled) {
+              var maxHours = this.maxTime.getHours();
+              var maxMinutes = this.maxTime.getMinutes();
+              disabled = this.hoursSelected === maxHours && minute > maxMinutes;
+            }
+          }
+        }
+
+        if (this.unselectableTimes) {
+          if (!disabled) {
+            var unselectable = this.unselectableTimes.filter(function (time) {
+              if (_this2.enableSeconds && _this2.secondsSelected !== null) {
+                return time.getHours() === _this2.hoursSelected && time.getMinutes() === minute && time.getSeconds() === _this2.secondsSelected;
+              } else {
+                return time.getHours() === _this2.hoursSelected && time.getMinutes() === minute;
+              }
+            });
+            disabled = unselectable.length > 0;
+          }
+        }
+      }
+
+      return disabled;
+    },
+    isSecondDisabled: function isSecondDisabled(second) {
+      var _this3 = this;
+
+      var disabled = false;
+
+      if (this.minutesSelected !== null) {
+        if (this.isMinuteDisabled(this.minutesSelected)) {
+          disabled = true;
+        } else {
+          if (this.minTime) {
+            var minHours = this.minTime.getHours();
+            var minMinutes = this.minTime.getMinutes();
+            var minSeconds = this.minTime.getSeconds();
+            disabled = this.hoursSelected === minHours && this.minutesSelected === minMinutes && second < minSeconds;
+          }
+
+          if (this.maxTime) {
+            if (!disabled) {
+              var maxHours = this.maxTime.getHours();
+              var maxMinutes = this.maxTime.getMinutes();
+              var maxSeconds = this.maxTime.getSeconds();
+              disabled = this.hoursSelected === maxHours && this.minutesSelected === maxMinutes && second > maxSeconds;
+            }
+          }
+        }
+
+        if (this.unselectableTimes) {
+          if (!disabled) {
+            var unselectable = this.unselectableTimes.filter(function (time) {
+              return time.getHours() === _this3.hoursSelected && time.getMinutes() === _this3.minutesSelected && time.getSeconds() === second;
+            });
+            disabled = unselectable.length > 0;
+          }
+        }
+      }
+
+      return disabled;
+    },
+
+    /*
+    * Parse string into date
+    */
+    onChange: function onChange(value) {
+      var date = this.timeParser(value, this);
+      this.updateInternalState(date);
+
+      if (date && !isNaN(date)) {
+        this.computedValue = date;
+      } else {
+        // Force refresh input value when not valid date
+        this.computedValue = null;
+        this.$refs.input.newValue = this.computedValue;
+      }
+    },
+
+    /*
+    * Toggle timepicker
+    */
+    toggle: function toggle(active) {
+      if (this.$refs.dropdown) {
+        this.$refs.dropdown.isActive = typeof active === 'boolean' ? active : !this.$refs.dropdown.isActive;
+      }
+    },
+
+    /*
+    * Close timepicker
+    */
+    close: function close() {
+      this.toggle(false);
+    },
+
+    /*
+    * Call default onFocus method and show timepicker
+    */
+    handleOnFocus: function handleOnFocus() {
+      this.onFocus();
+
+      if (this.openOnFocus) {
+        this.toggle(true);
+      }
+    },
+
+    /*
+    * Format date into string 'HH-MM-SS'
+    */
+    formatHHMMSS: function formatHHMMSS(value) {
+      var date = new Date(value);
+
+      if (value && !isNaN(date)) {
+        var hours = date.getHours();
+        var minutes = date.getMinutes();
+        var seconds = date.getSeconds();
+        return this.formatNumber(hours, true) + ':' + this.formatNumber(minutes, true) + ':' + this.formatNumber(seconds, true);
+      }
+
+      return '';
+    },
+
+    /*
+    * Parse time from string
+    */
+    onChangeNativePicker: function onChangeNativePicker(event) {
+      var date = event.target.value;
+
+      if (date) {
+        var time = null;
+
+        if (this.computedValue && !isNaN(this.computedValue)) {
+          time = new Date(this.computedValue);
+        } else {
+          time = new Date();
+          time.setMilliseconds(0);
+        }
+
+        var t = date.split(':');
+        time.setHours(parseInt(t[0], 10));
+        time.setMinutes(parseInt(t[1], 10));
+        time.setSeconds(t[2] ? parseInt(t[2], 10) : 0);
+        this.computedValue = new Date(time.getTime());
+      } else {
+        this.computedValue = null;
+      }
+    },
+    formatNumber: function formatNumber(value, prependZero) {
+      return this.isHourFormat24 || prependZero ? this.pad(value) : value;
+    },
+    pad: function pad(value) {
+      return (value < 10 ? '0' : '') + value;
+    },
+
+    /*
+    * Format date into string
+    */
+    formatValue: function formatValue(date) {
+      if (date && !isNaN(date)) {
+        return this.timeFormatter(date, this);
+      } else {
+        return null;
+      }
+    },
+
+    /**
+     * Keypress event that is bound to the document.
+     */
+    keyPress: function keyPress(event) {
+      // Esc key
+      if (this.$refs.dropdown && this.$refs.dropdown.isActive && event.keyCode === 27) {
+        this.toggle(false);
+      }
+    }
+  },
+  created: function created() {
+    if (typeof window !== 'undefined') {
+      document.addEventListener('keyup', this.keyPress);
+    }
+  },
+  beforeDestroy: function beforeDestroy() {
+    if (typeof window !== 'undefined') {
+      document.removeEventListener('keyup', this.keyPress);
+    }
+  }
+};
+
+export { TimepickerMixin as T };

package/dist/esm/chunk-085a700d.js

@@ -0,0 +1,7 @@
+/*! Buefy v0.7.10 | MIT License | github.com/buefy/buefy */
+// Polyfills for SSR
+var isSSR = typeof window === 'undefined';
+var HTMLElement = isSSR ? Object : window.HTMLElement;
+var File = isSSR ? Object : window.File;
+
+export { File as F, HTMLElement as H };