buefy 0.9.26 → 0.9.28

package/dist/esm/Field-3ceba31e.js

@@ -0,0 +1,313 @@
+import { _ as _defineProperty } from './_rollupPluginBabelHelpers-df313029.js';
+import { c as config } from './config-e7d4b9c2.js';
+import { n as normalizeComponent } from './plugins-218aea86.js';
+
+var script$1 = {
+  name: 'BFieldBody',
+  props: {
+    message: {
+      type: [String, Array]
+    },
+    type: {
+      type: [String, Object]
+    }
+  },
+  render: function render(createElement) {
+    var _this = this;
+    var first = true;
+    return createElement('div', {
+      attrs: {
+        'class': 'field-body'
+      }
+    }, this.$slots.default.map(function (element) {
+      // skip returns and comments
+      if (!element.tag) {
+        return element;
+      }
+      var message;
+      if (first) {
+        message = _this.message;
+        first = false;
+      }
+      return createElement('b-field', {
+        attrs: {
+          type: _this.type,
+          message: message
+        }
+      }, [element]);
+    }));
+  }
+};
+
+/* script */
+const __vue_script__$1 = script$1;
+
+/* template */
+
+  /* style */
+  const __vue_inject_styles__$1 = undefined;
+  /* scoped */
+  const __vue_scope_id__$1 = undefined;
+  /* module identifier */
+  const __vue_module_identifier__$1 = undefined;
+  /* functional template */
+  const __vue_is_functional_template__$1 = undefined;
+  /* style inject */
+  
+  /* style inject SSR */
+  
+  /* style inject shadow dom */
+  
+
+  
+  const __vue_component__$1 = /*#__PURE__*/normalizeComponent(
+    {},
+    __vue_inject_styles__$1,
+    __vue_script__$1,
+    __vue_scope_id__$1,
+    __vue_is_functional_template__$1,
+    __vue_module_identifier__$1,
+    false,
+    undefined,
+    undefined,
+    undefined
+  );
+
+  var FieldBody = __vue_component__$1;
+
+var script = {
+  name: 'BField',
+  components: _defineProperty({}, FieldBody.name, FieldBody),
+  provide: function provide() {
+    return {
+      'BField': this
+    };
+  },
+  inject: {
+    parent: {
+      from: 'BField',
+      default: false
+    }
+  },
+  // Used internally only when using Field in Field
+  props: {
+    type: [String, Object],
+    label: String,
+    labelFor: String,
+    message: [String, Array, Object],
+    grouped: Boolean,
+    groupMultiline: Boolean,
+    position: String,
+    expanded: Boolean,
+    horizontal: Boolean,
+    addons: {
+      type: Boolean,
+      default: true
+    },
+    customClass: String,
+    labelPosition: {
+      type: String,
+      default: function _default() {
+        return config.defaultFieldLabelPosition;
+      }
+    }
+  },
+  data: function data() {
+    return {
+      newType: this.type,
+      newMessage: this.message,
+      fieldLabelSize: null,
+      _isField: true // Used internally by Input and Select
+    };
+  },
+  computed: {
+    rootClasses: function rootClasses() {
+      return [{
+        'is-expanded': this.expanded,
+        'is-horizontal': this.horizontal,
+        'is-floating-in-label': this.hasLabel && !this.horizontal && this.labelPosition === 'inside',
+        'is-floating-label': this.hasLabel && !this.horizontal && this.labelPosition === 'on-border'
+      }, this.numberInputClasses];
+    },
+    innerFieldClasses: function innerFieldClasses() {
+      return [this.fieldType(), this.newPosition, {
+        'is-grouped-multiline': this.groupMultiline
+      }];
+    },
+    hasInnerField: function hasInnerField() {
+      return this.grouped || this.groupMultiline || this.hasAddons();
+    },
+    /**
+    * Correct Bulma class for the side of the addon or group.
+    *
+    * This is not kept like the others (is-small, etc.),
+    * because since 'has-addons' is set automatically it
+    * doesn't make sense to teach users what addons are exactly.
+    */
+    newPosition: function newPosition() {
+      if (this.position === undefined) return;
+      var position = this.position.split('-');
+      if (position.length < 1) return;
+      var prefix = this.grouped ? 'is-grouped-' : 'has-addons-';
+      if (this.position) return prefix + position[1];
+    },
+    /**
+    * Formatted message in case it's an array
+    * (each element is separated by <br> tag)
+    */
+    formattedMessage: function formattedMessage() {
+      if (this.parent && this.parent.hasInnerField) {
+        return ''; // Message will be displayed in parent field
+      }
+      if (typeof this.newMessage === 'string') {
+        return [this.newMessage];
+      }
+      var messages = [];
+      if (Array.isArray(this.newMessage)) {
+        this.newMessage.forEach(function (message) {
+          if (typeof message === 'string') {
+            messages.push(message);
+          } else {
+            for (var key in message) {
+              if (message[key]) {
+                messages.push(key);
+              }
+            }
+          }
+        });
+      } else {
+        for (var key in this.newMessage) {
+          if (this.newMessage[key]) {
+            messages.push(key);
+          }
+        }
+      }
+      return messages.filter(function (m) {
+        if (m) return m;
+      });
+    },
+    hasLabel: function hasLabel() {
+      return this.label || this.$slots.label;
+    },
+    hasMessage: function hasMessage() {
+      return (!this.parent || !this.parent.hasInnerField) && this.newMessage || this.$slots.message;
+    },
+    numberInputClasses: function numberInputClasses() {
+      if (this.$slots.default) {
+        var numberinput = this.$slots.default.filter(function (node) {
+          return node.tag && node.tag.toLowerCase().indexOf('numberinput') >= 0;
+        })[0];
+        if (numberinput) {
+          var classes = ['has-numberinput'];
+          var controlsPosition = numberinput.componentOptions.propsData.controlsPosition;
+          var size = numberinput.componentOptions.propsData.size;
+          if (controlsPosition) {
+            classes.push("has-numberinput-".concat(controlsPosition));
+          }
+          if (size) {
+            classes.push("has-numberinput-".concat(size));
+          }
+          return classes;
+        }
+      }
+      return null;
+    }
+  },
+  watch: {
+    /**
+    * Set internal type when prop change.
+    */
+    type: function type(value) {
+      this.newType = value;
+    },
+    /**
+    * Set internal message when prop change.
+    */
+    message: function message(value) {
+      this.newMessage = value;
+    },
+    /**
+    * Set parent message if we use Field in Field.
+    */
+    newMessage: function newMessage(value) {
+      if (this.parent && this.parent.hasInnerField) {
+        if (!this.parent.type) {
+          this.parent.newType = this.newType;
+        }
+        if (!this.parent.message) {
+          this.parent.newMessage = value;
+        }
+      }
+    }
+  },
+  methods: {
+    /**
+    * Field has addons if there are more than one slot
+    * (element / component) in the Field.
+    * Or is grouped when prop is set.
+    * Is a method to be called when component re-render.
+    */
+    fieldType: function fieldType() {
+      if (this.grouped) return 'is-grouped';
+      if (this.hasAddons()) return 'has-addons';
+    },
+    hasAddons: function hasAddons() {
+      var renderedNode = 0;
+      if (this.$slots.default) {
+        renderedNode = this.$slots.default.reduce(function (i, node) {
+          return node.tag ? i + 1 : i;
+        }, 0);
+      }
+      return renderedNode > 1 && this.addons && !this.horizontal;
+    }
+  },
+  mounted: function mounted() {
+    if (this.horizontal) {
+      // Bulma docs: .is-normal for any .input or .button
+      var elements = this.$el.querySelectorAll('.input, .select, .button, .textarea, .b-slider');
+      if (elements.length > 0) {
+        this.fieldLabelSize = 'is-normal';
+      }
+    }
+  }
+};
+
+/* script */
+const __vue_script__ = script;
+
+/* template */
+var __vue_render__ = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticClass:"field",class:_vm.rootClasses},[(_vm.horizontal)?_c('div',{staticClass:"field-label",class:[_vm.customClass, _vm.fieldLabelSize]},[(_vm.hasLabel)?_c('label',{staticClass:"label",class:_vm.customClass,attrs:{"for":_vm.labelFor}},[(_vm.$slots.label)?_vm._t("label"):[_vm._v(_vm._s(_vm.label))]],2):_vm._e()]):[(_vm.hasLabel)?_c('label',{staticClass:"label",class:_vm.customClass,attrs:{"for":_vm.labelFor}},[(_vm.$slots.label)?_vm._t("label"):[_vm._v(_vm._s(_vm.label))]],2):_vm._e()],(_vm.horizontal)?_c('b-field-body',{attrs:{"message":_vm.newMessage ? _vm.formattedMessage : '',"type":_vm.newType}},[_vm._t("default")],2):(_vm.hasInnerField)?_c('div',{staticClass:"field-body"},[_c('b-field',{class:_vm.innerFieldClasses,attrs:{"addons":false,"type":_vm.type}},[_vm._t("default")],2)],1):[_vm._t("default")],(_vm.hasMessage && !_vm.horizontal)?_c('p',{staticClass:"help",class:_vm.newType},[(_vm.$slots.message)?_vm._t("message",null,{"messages":_vm.formattedMessage}):[_vm._l((_vm.formattedMessage),function(mess,i){return [_vm._v(" "+_vm._s(mess)+" "),((i + 1) < _vm.formattedMessage.length)?_c('br',{key:i}):_vm._e()]})]],2):_vm._e()],2)};
+var __vue_staticRenderFns__ = [];
+
+  /* style */
+  const __vue_inject_styles__ = undefined;
+  /* scoped */
+  const __vue_scope_id__ = undefined;
+  /* module identifier */
+  const __vue_module_identifier__ = undefined;
+  /* functional template */
+  const __vue_is_functional_template__ = false;
+  /* style inject */
+  
+  /* style inject SSR */
+  
+  /* style inject shadow dom */
+  
+
+  
+  const __vue_component__ = /*#__PURE__*/normalizeComponent(
+    { render: __vue_render__, staticRenderFns: __vue_staticRenderFns__ },
+    __vue_inject_styles__,
+    __vue_script__,
+    __vue_scope_id__,
+    __vue_is_functional_template__,
+    __vue_module_identifier__,
+    false,
+    undefined,
+    undefined,
+    undefined
+  );
+
+  var Field = __vue_component__;
+
+export { Field as F };

package/dist/esm/FormElementMixin-b223d3c7.js

@@ -0,0 +1,161 @@
+import { c as config } from './config-e7d4b9c2.js';
+import { isVueComponent } from './helpers.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,
+    locale: {
+      type: [String, Array],
+      default: function _default() {
+        return config.defaultLocale;
+      }
+    },
+    statusIcon: {
+      type: Boolean,
+      default: function _default() {
+        return config.defaultStatusIcon;
+      }
+    }
+  },
+  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() {
+      var _ref = this.parentField || {},
+        newType = _ref.newType;
+      if (!newType) return;
+      if (typeof newType === 'string') {
+        return newType;
+      } else {
+        for (var key in newType) {
+          if (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 || this.parentField.$slots.message;
+    },
+    /**
+     * 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 el = this.getElement();
+      if (el === undefined) return;
+      this.$nextTick(function () {
+        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);
+    },
+    getElement: function getElement() {
+      var el = this.$refs[this.$data._elementRef];
+      while (isVueComponent(el)) {
+        el = el.$refs[el.$data._elementRef];
+      }
+      return el;
+    },
+    setInvalid: function setInvalid() {
+      var type = 'is-danger';
+      var message = this.validationMessage || this.getElement().validationMessage;
+      this.setValidity(type, message);
+    },
+    setValidity: function setValidity(type, message) {
+      var _this = this;
+      this.$nextTick(function () {
+        if (_this.parentField) {
+          // Set type only if not defined
+          if (!_this.parentField.type) {
+            _this.parentField.newType = type;
+          }
+          // Set message only if not defined
+          if (!_this.parentField.message) {
+            _this.parentField.newMessage = message;
+          }
+        }
+      });
+    },
+    /**
+     * 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() {
+      if (!this.useHtml5Validation) return;
+      var el = this.getElement();
+      if (el === undefined) return;
+      if (!el.checkValidity()) {
+        this.setInvalid();
+        this.isValid = false;
+      } else {
+        this.setValidity(null, null);
+        this.isValid = true;
+      }
+      return this.isValid;
+    }
+  }
+};
+
+export { FormElementMixin as F };

package/dist/esm/Icon-60d47b31.js

@@ -0,0 +1,187 @@
+import { m as _toArray } from './_rollupPluginBabelHelpers-df313029.js';
+import { c as config } from './config-e7d4b9c2.js';
+import { merge } from './helpers.js';
+import { n as normalizeComponent } from './plugins-218aea86.js';
+
+var mdiIcons = {
+  sizes: {
+    'default': 'mdi-24px',
+    'is-small': null,
+    'is-medium': 'mdi-36px',
+    'is-large': 'mdi-48px'
+  },
+  iconPrefix: 'mdi-'
+};
+var faIcons = function faIcons() {
+  var faIconPrefix = config && config.defaultIconComponent ? '' : 'fa-';
+  return {
+    sizes: {
+      'default': null,
+      'is-small': null,
+      'is-medium': faIconPrefix + 'lg',
+      'is-large': faIconPrefix + '2x'
+    },
+    iconPrefix: faIconPrefix,
+    internalIcons: {
+      'information': 'info-circle',
+      'alert': 'exclamation-triangle',
+      'alert-circle': 'exclamation-circle',
+      'chevron-right': 'angle-right',
+      'chevron-left': 'angle-left',
+      'chevron-down': 'angle-down',
+      'eye-off': 'eye-slash',
+      'menu-down': 'caret-down',
+      'menu-up': 'caret-up',
+      'close-circle': 'times-circle'
+    }
+  };
+};
+var getIcons = function getIcons() {
+  var icons = {
+    mdi: mdiIcons,
+    fa: faIcons(),
+    fas: faIcons(),
+    far: faIcons(),
+    fad: faIcons(),
+    fab: faIcons(),
+    fal: faIcons(),
+    'fa-solid': faIcons(),
+    'fa-regular': faIcons(),
+    'fa-light': faIcons(),
+    'fa-thin': faIcons(),
+    'fa-duotone': faIcons(),
+    'fa-brands': faIcons()
+  };
+  if (config && config.customIconPacks) {
+    icons = merge(icons, config.customIconPacks, true);
+  }
+  return icons;
+};
+var getIcons$1 = getIcons;
+
+var script = {
+  name: 'BIcon',
+  props: {
+    type: [String, Object],
+    component: String,
+    pack: String,
+    icon: String,
+    size: String,
+    customSize: String,
+    customClass: String,
+    both: Boolean // This is used internally to show both MDI and FA icon
+  },
+  computed: {
+    iconConfig: function iconConfig() {
+      var allIcons = getIcons$1();
+      return allIcons[this.newPack];
+    },
+    iconPrefix: function iconPrefix() {
+      if (this.iconConfig && this.iconConfig.iconPrefix) {
+        return this.iconConfig.iconPrefix;
+      }
+      return '';
+    },
+    /**
+    * Internal icon name based on the pack.
+    * If pack is 'fa', gets the equivalent FA icon name of the MDI,
+    * internal icons are always MDI.
+    */
+    newIcon: function newIcon() {
+      return "".concat(this.iconPrefix).concat(this.getEquivalentIconOf(this.icon));
+    },
+    newPack: function newPack() {
+      return this.pack || config.defaultIconPack;
+    },
+    newType: function newType() {
+      if (!this.type) return;
+      var splitType = [];
+      if (typeof this.type === 'string') {
+        splitType = this.type.split('-');
+      } else {
+        for (var key in this.type) {
+          if (this.type[key]) {
+            splitType = key.split('-');
+            break;
+          }
+        }
+      }
+      if (splitType.length <= 1) return;
+      var _splitType = splitType,
+        _splitType2 = _toArray(_splitType),
+        type = _splitType2.slice(1);
+      return "has-text-".concat(type.join('-'));
+    },
+    newCustomSize: function newCustomSize() {
+      return this.customSize || this.customSizeByPack;
+    },
+    customSizeByPack: function customSizeByPack() {
+      if (this.iconConfig && this.iconConfig.sizes) {
+        if (this.size && this.iconConfig.sizes[this.size] !== undefined) {
+          return this.iconConfig.sizes[this.size];
+        } else if (this.iconConfig.sizes.default) {
+          return this.iconConfig.sizes.default;
+        }
+      }
+      return null;
+    },
+    useIconComponent: function useIconComponent() {
+      return this.component || config.defaultIconComponent;
+    }
+  },
+  methods: {
+    /**
+    * Equivalent icon name of the MDI.
+    */
+    getEquivalentIconOf: function getEquivalentIconOf(value) {
+      // Only transform the class if the both prop is set to true
+      if (!this.both) {
+        return value;
+      }
+      if (this.iconConfig && this.iconConfig.internalIcons && this.iconConfig.internalIcons[value]) {
+        return this.iconConfig.internalIcons[value];
+      }
+      return value;
+    }
+  }
+};
+
+/* script */
+const __vue_script__ = script;
+
+/* template */
+var __vue_render__ = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('span',{staticClass:"icon",class:[_vm.newType, _vm.size]},[(!_vm.useIconComponent)?_c('i',{class:[_vm.newPack, _vm.newIcon, _vm.newCustomSize, _vm.customClass]}):_c(_vm.useIconComponent,{tag:"component",class:[_vm.customClass],attrs:{"icon":[_vm.newPack, _vm.newIcon],"size":_vm.newCustomSize}})],1)};
+var __vue_staticRenderFns__ = [];
+
+  /* style */
+  const __vue_inject_styles__ = undefined;
+  /* scoped */
+  const __vue_scope_id__ = undefined;
+  /* module identifier */
+  const __vue_module_identifier__ = undefined;
+  /* functional template */
+  const __vue_is_functional_template__ = false;
+  /* style inject */
+  
+  /* style inject SSR */
+  
+  /* style inject shadow dom */
+  
+
+  
+  const __vue_component__ = /*#__PURE__*/normalizeComponent(
+    { render: __vue_render__, staticRenderFns: __vue_staticRenderFns__ },
+    __vue_inject_styles__,
+    __vue_script__,
+    __vue_scope_id__,
+    __vue_is_functional_template__,
+    __vue_module_identifier__,
+    false,
+    undefined,
+    undefined,
+    undefined
+  );
+
+  var Icon = __vue_component__;
+
+export { Icon as I };