buefy 1.0.0 → 1.0.2

package/dist/cjs/Select-DayPKwCY.js

@@ -0,0 +1,147 @@
+'use strict';
+
+var vue = require('vue');
+var Icon = require('./Icon-lsDKE2wQ.js');
+var CompatFallthroughMixin = require('./CompatFallthroughMixin-hhK0Gkhr.js');
+var FormElementMixin = require('./FormElementMixin-DavX4iOv.js');
+var _pluginVue_exportHelper = require('./_plugin-vue_export-helper-Die8u8yB.js');
+
+var _sfc_main = vue.defineComponent({
+  name: "BSelect",
+  components: {
+    BIcon: Icon.BIcon
+  },
+  mixins: [CompatFallthroughMixin.CompatFallthroughMixin, FormElementMixin.FormElementMixin],
+  props: {
+    modelValue: {
+      type: [
+        String,
+        Number,
+        Boolean,
+        Object,
+        Array,
+        Function,
+        Date,
+        null
+      ],
+      default: null
+    },
+    placeholder: String,
+    multiple: Boolean,
+    nativeSize: [String, Number]
+  },
+  emits: {
+    /* eslint-disable @typescript-eslint/no-unused-vars */
+    blur: (_event) => true,
+    focus: (_event) => true,
+    "update:modelValue": (_value) => true
+    /* eslint-enable @typescript-eslint/no-unused-vars */
+  },
+  data() {
+    return {
+      selected: this.modelValue,
+      _elementRef: "select"
+    };
+  },
+  computed: {
+    computedValue: {
+      get() {
+        return this.selected;
+      },
+      set(value) {
+        this.selected = value;
+        this.$emit("update:modelValue", value);
+        !this.isValid && this.checkHtml5Validity();
+      }
+    },
+    spanClasses() {
+      return [this.size, this.statusType, {
+        "is-fullwidth": this.expanded,
+        "is-loading": this.loading,
+        "is-multiple": this.multiple,
+        "is-rounded": this.rounded,
+        "is-empty": this.selected === null
+      }];
+    }
+  },
+  watch: {
+    /*
+    * When v-model is changed:
+    *   1. Set the selected option.
+    *   2. If it's invalid, validate again.
+    */
+    modelValue(value) {
+      this.selected = value;
+      !this.isValid && this.checkHtml5Validity();
+    }
+  }
+});
+
+const _hoisted_1 = ["multiple", "size"];
+const _hoisted_2 = {
+  key: 0,
+  value: null,
+  disabled: "",
+  hidden: ""
+};
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_b_icon = vue.resolveComponent("b-icon");
+  return vue.openBlock(), vue.createElementBlock(
+    "div",
+    vue.mergeProps({
+      class: ["control", { "is-expanded": _ctx.expanded, "has-icons-left": _ctx.icon }]
+    }, _ctx.rootAttrs),
+    [
+      vue.createElementVNode(
+        "span",
+        {
+          class: vue.normalizeClass(["select", _ctx.spanClasses])
+        },
+        [
+          vue.withDirectives(vue.createElementVNode("select", vue.mergeProps({
+            "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.computedValue = $event),
+            ref: "select",
+            multiple: _ctx.multiple,
+            size: _ctx.nativeSize
+          }, _ctx.fallthroughAttrs, {
+            onBlur: _cache[1] || (_cache[1] = (...args) => _ctx.onBlur && _ctx.onBlur(...args)),
+            onFocus: _cache[2] || (_cache[2] = ($event) => _ctx.$emit("focus", $event))
+          }), [
+            _ctx.placeholder ? (vue.openBlock(), vue.createElementBlock(
+              vue.Fragment,
+              { key: 0 },
+              [
+                _ctx.computedValue == null ? (vue.openBlock(), vue.createElementBlock(
+                  "option",
+                  _hoisted_2,
+                  vue.toDisplayString(_ctx.placeholder),
+                  1
+                  /* TEXT */
+                )) : vue.createCommentVNode("v-if", true)
+              ],
+              64
+              /* STABLE_FRAGMENT */
+            )) : vue.createCommentVNode("v-if", true),
+            vue.renderSlot(_ctx.$slots, "default")
+          ], 16, _hoisted_1), [
+            [vue.vModelSelect, _ctx.computedValue]
+          ])
+        ],
+        2
+        /* CLASS */
+      ),
+      _ctx.icon ? (vue.openBlock(), vue.createBlock(_component_b_icon, {
+        key: 0,
+        class: "is-left",
+        icon: _ctx.icon,
+        pack: _ctx.iconPack,
+        size: _ctx.iconSize
+      }, null, 8, ["icon", "pack", "size"])) : vue.createCommentVNode("v-if", true)
+    ],
+    16
+    /* FULL_PROPS */
+  );
+}
+var BSelect = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["render", _sfc_render]]);
+
+exports.BSelect = BSelect;

package/dist/cjs/SlotComponent-BruGdRW3.js

@@ -0,0 +1,41 @@
+'use strict';
+
+var vue = require('vue');
+
+var BSlotComponent = vue.defineComponent({
+  name: "BSlotComponent",
+  props: {
+    component: {
+      type: Object,
+      required: true
+    },
+    name: {
+      type: String,
+      default: "default"
+    },
+    scoped: {
+      type: Boolean
+    },
+    props: {
+      type: Object
+    },
+    tag: {
+      type: [String, Object],
+      default: "div"
+    }
+  },
+  methods: {
+    refresh() {
+      this.$forceUpdate();
+    }
+  },
+  render() {
+    return vue.h(
+      this.tag,
+      {},
+      this.component.$slots ? this.scoped ? this.component.$slots[this.name](this.props) : this.component.$slots[this.name]() : void 0
+    );
+  }
+});
+
+exports.BSlotComponent = BSlotComponent;

package/dist/cjs/TabbedChildMixin-B3JUUwcf.js

@@ -0,0 +1,211 @@
+'use strict';
+
+var vue = require('vue');
+var Icon = require('./Icon-lsDKE2wQ.js');
+var SlotComponent = require('./SlotComponent-BruGdRW3.js');
+var InjectedChildMixin = require('./InjectedChildMixin-CUKn09dB.js');
+var helpers = require('./helpers.js');
+
+var TabbedMixin = (cmp) => vue.defineComponent({
+  components: {
+    BIcon: Icon.BIcon,
+    BSlotComponent: SlotComponent.BSlotComponent
+  },
+  mixins: [InjectedChildMixin.ProviderParentMixin(cmp, InjectedChildMixin.Sorted)],
+  props: {
+    modelValue: {
+      type: [String, Number, null],
+      default: void 0
+    },
+    size: String,
+    animated: {
+      type: Boolean,
+      default: true
+    },
+    animation: String,
+    animateInitially: Boolean,
+    vertical: {
+      type: Boolean,
+      default: false
+    },
+    position: String,
+    destroyOnHide: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    "update:modelValue": (_value) => true
+  },
+  data() {
+    return {
+      activeId: this.modelValue,
+      // Internal state
+      defaultSlots: [],
+      contentHeight: 0,
+      isTransitioning: false
+    };
+  },
+  computed: {
+    activeItem() {
+      const childItems = this.childItems;
+      return this.activeId === void 0 ? this.items[0] : this.activeId === null ? null : childItems.find((i) => i.uniqueValue === this.activeId);
+    },
+    items() {
+      return this.sortedItems;
+    }
+  },
+  watch: {
+    /*
+     * When v-model is changed set the new active tab.
+     */
+    modelValue(value) {
+      if (typeof value === "number") {
+        value = helpers.bound(value, 0, this.items.length - 1);
+        this.activeId = this.items[value].uniqueValue;
+      } else {
+        this.activeId = value;
+      }
+    },
+    /*
+     * Sync internal state with external state
+     */
+    activeId(val, oldValue) {
+      const oldTab = oldValue !== void 0 && oldValue !== null ? this.childItems.find((i) => i.uniqueValue === oldValue) : null;
+      if (oldTab && this.activeItem) {
+        oldTab.deactivate(this.activeItem.index);
+        this.activeItem.activate(oldTab.index);
+      }
+      val = this.activeItem ? typeof this.modelValue === "number" ? this.items.indexOf(this.activeItem) : this.activeItem.uniqueValue : void 0;
+      if (val !== this.modelValue) {
+        this.$emit("update:modelValue", val);
+      }
+    }
+  },
+  methods: {
+    /*
+    * Child click listener, emit input event and change active child.
+    */
+    childClick(child) {
+      this.activeId = child.uniqueValue;
+    },
+    getNextItemIdx(fromIdx, skipDisabled = false) {
+      let nextItemIdx = null;
+      for (let i = 0; i < this.items.length; i++) {
+        const item = this.items[i];
+        if (fromIdx < item.index && (item.visible && (!skipDisabled || skipDisabled && !item.disabled))) {
+          nextItemIdx = item.index;
+          break;
+        }
+      }
+      return nextItemIdx;
+    },
+    getPrevItemIdx(fromIdx, skipDisabled = false) {
+      let prevItemIdx = null;
+      for (let i = this.items.length - 1; i >= 0; i--) {
+        const item = this.items[i];
+        if (item.index < fromIdx && (item.visible && (!skipDisabled || skipDisabled && !item.disabled))) {
+          prevItemIdx = item.index;
+          break;
+        }
+      }
+      return prevItemIdx;
+    }
+  },
+  mounted() {
+    if (typeof this.modelValue === "number") {
+      const value = helpers.bound(this.modelValue, 0, this.items.length - 1);
+      this.activeId = this.items[value].uniqueValue;
+    } else {
+      this.activeId = this.modelValue;
+    }
+  }
+});
+
+var TabbedChildMixin = (parentCmp) => vue.defineComponent({
+  mixins: [InjectedChildMixin.InjectedChildMixin(parentCmp, InjectedChildMixin.Sorted$1)],
+  props: {
+    label: String,
+    icon: String,
+    iconPack: String,
+    visible: {
+      type: Boolean,
+      default: true
+    },
+    headerClass: {
+      type: [String, Array, Object],
+      default: null
+    }
+  },
+  data() {
+    return {
+      transitionName: null,
+      elementClass: "item",
+      elementRole: null
+    };
+  },
+  computed: {
+    isActive() {
+      return this.parent.activeItem === this;
+    }
+  },
+  methods: {
+    /*
+     * Activate element, alter animation name based on the index.
+     */
+    activate(oldIndex) {
+      this.transitionName = this.index < oldIndex ? this.parent.vertical ? "slide-down" : "slide-next" : this.parent.vertical ? "slide-up" : "slide-prev";
+    },
+    /*
+     * Deactivate element, alter animation name based on the index.
+     */
+    deactivate(newIndex) {
+      this.transitionName = newIndex < this.index ? this.parent.vertical ? "slide-down" : "slide-next" : this.parent.vertical ? "slide-up" : "slide-prev";
+    }
+  },
+  render() {
+    var _a;
+    if (this.parent.destroyOnHide) {
+      if (!this.isActive || !this.visible) {
+        return;
+      }
+    }
+    const vnode = vue.withDirectives(
+      vue.h(
+        "div",
+        {
+          // NOTE: possible regression of #3272
+          // https://github.com/buefy/buefy/issues/3272
+          class: this.elementClass,
+          role: this.elementRole,
+          id: `${this.uniqueValue}-content`,
+          "aria-labelledby": this.elementRole ? `${this.uniqueValue}-label` : null,
+          tabindex: this.isActive ? 0 : -1
+        },
+        this.$slots
+      ),
+      [[vue.vShow, this.isActive && this.visible]]
+    );
+    if (this.parent.animated) {
+      return vue.h(
+        vue.Transition,
+        {
+          name: (_a = this.parent.animation || this.transitionName) != null ? _a : void 0,
+          appear: this.parent.animateInitially === true || void 0,
+          onBeforeEnter: () => {
+            this.parent.isTransitioning = true;
+          },
+          onAfterEnter: () => {
+            this.parent.isTransitioning = false;
+          }
+        },
+        { default: () => vnode }
+      );
+    }
+    return vnode;
+  }
+});
+
+exports.TabbedChildMixin = TabbedChildMixin;
+exports.TabbedMixin = TabbedMixin;

package/dist/cjs/Tag-BprnwJJ1.js

@@ -0,0 +1,167 @@
+'use strict';
+
+var vue = require('vue');
+var Icon = require('./Icon-lsDKE2wQ.js');
+var _pluginVue_exportHelper = require('./_plugin-vue_export-helper-Die8u8yB.js');
+
+var _sfc_main = vue.defineComponent({
+  name: "BTag",
+  components: { BIcon: Icon.BIcon },
+  props: {
+    attached: Boolean,
+    closable: Boolean,
+    type: [String, Object],
+    size: String,
+    rounded: Boolean,
+    disabled: Boolean,
+    ellipsis: Boolean,
+    tabstop: {
+      type: Boolean,
+      default: true
+    },
+    ariaCloseLabel: String,
+    icon: String,
+    iconType: String,
+    iconPack: String,
+    closeType: String,
+    closeIcon: String,
+    closeIconPack: String,
+    closeIconType: String
+  },
+  emits: {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    click: (_) => true,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    close: (_) => true
+  },
+  computed: {
+    // setting a boolean attribute `false` does not remove it on Vue 3.
+    // `null` or `undefined` has to be given to remove it.
+    disabledOrUndefined() {
+      return this.disabled || void 0;
+    }
+  },
+  methods: {
+    /*
+    * Emit close event when delete button is clicked
+    * or delete key is pressed.
+    */
+    close(event) {
+      if (this.disabled) return;
+      this.$emit("close", event);
+    },
+    /*
+    * Emit click event when tag is clicked.
+    */
+    click(event) {
+      if (this.disabled) return;
+      this.$emit("click", event);
+    }
+  }
+});
+
+const _hoisted_1 = {
+  key: 0,
+  class: "tags has-addons inline-tags"
+};
+const _hoisted_2 = ["aria-label", "tabindex", "disabled"];
+const _hoisted_3 = ["aria-label", "disabled", "tabindex"];
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_b_icon = vue.resolveComponent("b-icon");
+  return _ctx.attached && _ctx.closable ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
+    vue.createElementVNode(
+      "span",
+      {
+        class: vue.normalizeClass(["tag", [_ctx.type, _ctx.size, { "is-rounded": _ctx.rounded }]])
+      },
+      [
+        _ctx.icon ? (vue.openBlock(), vue.createBlock(_component_b_icon, {
+          key: 0,
+          icon: _ctx.icon,
+          size: _ctx.size,
+          type: _ctx.iconType,
+          pack: _ctx.iconPack
+        }, null, 8, ["icon", "size", "type", "pack"])) : vue.createCommentVNode("v-if", true),
+        vue.createElementVNode(
+          "span",
+          {
+            class: vue.normalizeClass({ "has-ellipsis": _ctx.ellipsis }),
+            onClick: _cache[0] || (_cache[0] = (...args) => _ctx.click && _ctx.click(...args))
+          },
+          [
+            vue.renderSlot(_ctx.$slots, "default")
+          ],
+          2
+          /* CLASS */
+        )
+      ],
+      2
+      /* CLASS */
+    ),
+    vue.createElementVNode("a", {
+      class: vue.normalizeClass(["tag", [
+        _ctx.size,
+        _ctx.closeType,
+        { "is-rounded": _ctx.rounded },
+        _ctx.closeIcon ? "has-delete-icon" : "is-delete"
+      ]]),
+      role: "button",
+      "aria-label": _ctx.ariaCloseLabel,
+      tabindex: _ctx.tabstop ? 0 : void 0,
+      disabled: _ctx.disabledOrUndefined,
+      onClick: _cache[1] || (_cache[1] = (...args) => _ctx.close && _ctx.close(...args)),
+      onKeyup: _cache[2] || (_cache[2] = vue.withKeys(vue.withModifiers((...args) => _ctx.close && _ctx.close(...args), ["prevent"]), ["delete"]))
+    }, [
+      _ctx.closeIcon ? (vue.openBlock(), vue.createBlock(_component_b_icon, {
+        key: 0,
+        "custom-class": "",
+        icon: _ctx.closeIcon,
+        size: _ctx.size,
+        type: _ctx.closeIconType,
+        pack: _ctx.closeIconPack
+      }, null, 8, ["icon", "size", "type", "pack"])) : vue.createCommentVNode("v-if", true)
+    ], 42, _hoisted_2)
+  ])) : (vue.openBlock(), vue.createElementBlock(
+    "span",
+    {
+      key: 1,
+      class: vue.normalizeClass(["tag", [_ctx.type, _ctx.size, { "is-rounded": _ctx.rounded }]])
+    },
+    [
+      _ctx.icon ? (vue.openBlock(), vue.createBlock(_component_b_icon, {
+        key: 0,
+        icon: _ctx.icon,
+        size: _ctx.size,
+        type: _ctx.iconType,
+        pack: _ctx.iconPack
+      }, null, 8, ["icon", "size", "type", "pack"])) : vue.createCommentVNode("v-if", true),
+      vue.createElementVNode(
+        "span",
+        {
+          class: vue.normalizeClass({ "has-ellipsis": _ctx.ellipsis }),
+          onClick: _cache[3] || (_cache[3] = (...args) => _ctx.click && _ctx.click(...args))
+        },
+        [
+          vue.renderSlot(_ctx.$slots, "default")
+        ],
+        2
+        /* CLASS */
+      ),
+      _ctx.closable ? (vue.openBlock(), vue.createElementBlock("a", {
+        key: 1,
+        role: "button",
+        "aria-label": _ctx.ariaCloseLabel,
+        class: vue.normalizeClass(["delete is-small", _ctx.closeType]),
+        disabled: _ctx.disabledOrUndefined,
+        tabindex: _ctx.tabstop ? 0 : void 0,
+        onClick: _cache[4] || (_cache[4] = (...args) => _ctx.close && _ctx.close(...args)),
+        onKeyup: _cache[5] || (_cache[5] = vue.withKeys(vue.withModifiers((...args) => _ctx.close && _ctx.close(...args), ["prevent"]), ["delete"]))
+      }, null, 42, _hoisted_3)) : vue.createCommentVNode("v-if", true)
+    ],
+    2
+    /* CLASS */
+  ));
+}
+var BTag = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["render", _sfc_render]]);
+
+exports.BTag = BTag;