element-plus/lib/components/button/index.js

> TODO: description

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var vue = require('vue');
var tokens = require('../../tokens');
var util = require('../../utils/util');
var validators = require('../../utils/validators');

var script = vue.defineComponent({
  name: "ElButton",
  props: {
    type: {
      type: String,
      default: "default",
      validator: (val) => {
        return [
          "default",
          "primary",
          "success",
          "warning",
          "info",
          "danger",
          "text"
        ].includes(val);
      }
    },
    size: {
      type: String,
      validator: validators.isValidComponentSize
    },
    icon: {
      type: String,
      default: ""
    },
    nativeType: {
      type: String,
      default: "button",
      validator: (val) => {
        return ["button", "submit", "reset"].includes(val);
      }
    },
    loading: Boolean,
    disabled: Boolean,
    plain: Boolean,
    autofocus: Boolean,
    round: Boolean,
    circle: Boolean
  },
  emits: ["click"],
  setup(props, { emit }) {
    const $ELEMENT = util.useGlobalConfig();
    const elForm = vue.inject(tokens.elFormKey, {});
    const elFormItem = vue.inject(tokens.elFormItemKey, {});
    const buttonSize = vue.computed(() => {
      return props.size || elFormItem.size || $ELEMENT.size;
    });
    const buttonDisabled = vue.computed(() => {
      return props.disabled || elForm.disabled;
    });
    const handleClick = (evt) => {
      emit("click", evt);
    };
    return {
      buttonSize,
      buttonDisabled,
      handleClick
    };
  }
});

const _hoisted_1 = ["disabled", "autofocus", "type"];
const _hoisted_2 = {
  key: 0,
  class: "el-icon-loading"
};
const _hoisted_3 = { key: 2 };
function render(_ctx, _cache, $props, $setup, $data, $options) {
  return vue.openBlock(), vue.createElementBlock("button", {
    class: vue.normalizeClass([
      "el-button",
      _ctx.type ? "el-button--" + _ctx.type : "",
      _ctx.buttonSize ? "el-button--" + _ctx.buttonSize : "",
      {
        "is-disabled": _ctx.buttonDisabled,
        "is-loading": _ctx.loading,
        "is-plain": _ctx.plain,
        "is-round": _ctx.round,
        "is-circle": _ctx.circle
      }
    ]),
    disabled: _ctx.buttonDisabled || _ctx.loading,
    autofocus: _ctx.autofocus,
    type: _ctx.nativeType,
    onClick: _cache[0] || (_cache[0] = (...args) => _ctx.handleClick && _ctx.handleClick(...args))
  }, [
    _ctx.loading ? (vue.openBlock(), vue.createElementBlock("i", _hoisted_2)) : vue.createCommentVNode("v-if", true),
    _ctx.icon && !_ctx.loading ? (vue.openBlock(), vue.createElementBlock("i", {
      key: 1,
      class: vue.normalizeClass(_ctx.icon)
    }, null, 2)) : vue.createCommentVNode("v-if", true),
    _ctx.$slots.default ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_3, [
      vue.renderSlot(_ctx.$slots, "default")
    ])) : vue.createCommentVNode("v-if", true)
  ], 10, _hoisted_1);
}

script.render = render;
script.__file = "packages/components/button/src/button.vue";

var script$1 = vue.defineComponent({
  name: "ElButtonGroup"
});

const _hoisted_1$1 = { class: "el-button-group" };
function render$1(_ctx, _cache, $props, $setup, $data, $options) {
  return vue.openBlock(), vue.createElementBlock("div", _hoisted_1$1, [
    vue.renderSlot(_ctx.$slots, "default")
  ]);
}

script$1.render = render$1;
script$1.__file = "packages/components/button/src/button-group.vue";

script.install = (app) => {
  app.component(script.name, script);
  app.component(script$1.name, script$1);
};
script.ButtonGroup = script$1;
const _Button = script;
const ElButton = _Button;
const ElButtonGroup = script$1;

exports.ElButton = ElButton;
exports.ElButtonGroup = ElButtonGroup;
exports.default = _Button;