178、elementUI之el-tag源码

module.exports =
  (function (modules) {
    var installedModules = {};
    function __webpack_require__(moduleId) {
      if (installedModules[moduleId]) {
        return installedModules[moduleId].exports;
      }
      var module = installedModules[moduleId] = {
        i: moduleId,
        l: false,
        exports: {}
      };
      modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
      module.l = true;
      return module.exports;
    }
    __webpack_require__.m = modules;
    __webpack_require__.c = installedModules;
    __webpack_require__.d = function (exports, name, getter) {
      if (!__webpack_require__.o(exports, name)) {
        Object.defineProperty(exports, name, { enumerable: true, get: getter });
      }
    };
    __webpack_require__.r = function (exports) {
      if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {
        Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
      }
      Object.defineProperty(exports, '__esModule', { value: true });
    };
    __webpack_require__.t = function (value, mode) {
      if (mode & 1) value = __webpack_require__(value);
      if (mode & 8) return value;
      if ((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
      var ns = Object.create(null);
      __webpack_require__.r(ns);
      Object.defineProperty(ns, 'default', { enumerable: true, value: value });
      if (mode & 2 && typeof value != 'string') for (var key in value) __webpack_require__.d(ns, key, function (key) { return value[key]; }.bind(null, key));
      return ns;
    };
    __webpack_require__.n = function (module) {
      var getter = module && module.__esModule ?
        function getDefault() { return module['default']; } :
        function getModuleExports() { return module; };
      __webpack_require__.d(getter, 'a', getter);
      return getter;
    };
    __webpack_require__.o = function (object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
    __webpack_require__.p = "/dist/";
    return __webpack_require__(__webpack_require__.s = 124);
  })({
    0: (function (module, __webpack_exports__, __webpack_require__) {
      "use strict";
      __webpack_require__.d(__webpack_exports__, "a", function () { return normalizeComponent; });
      function normalizeComponent(
        scriptExports,
        render,
        staticRenderFns,
        functionalTemplate,
        injectStyles,
        scopeId,
        moduleIdentifier,
        shadowMode
      ) {
        var options = typeof scriptExports === 'function'
          ? scriptExports.options
          : scriptExports
        if (render) {
          options.render = render
          options.staticRenderFns = staticRenderFns
          options._compiled = true
        }
        if (functionalTemplate) {
          options.functional = true
        }
        if (scopeId) {
          options._scopeId = 'data-v-' + scopeId
        }
        var hook
        if (moduleIdentifier) {
          hook = function (context) {
            context =
              context || (this.$vnode && this.$vnode.ssrContext) || (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext)
            if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {
              context = __VUE_SSR_CONTEXT__
            }
            if (injectStyles) {
              injectStyles.call(this, context)
            }
            if (context && context._registeredComponents) {
              context._registeredComponents.add(moduleIdentifier)
            }
          }
          options._ssrRegister = hook
        } else if (injectStyles) {
          hook = shadowMode
            ? function () { injectStyles.call(this, this.$root.$options.shadowRoot) }
            : injectStyles
        }
        if (hook) {
          if (options.functional) {
            options._injectStyles = hook
            var originalRender = options.render
            options.render = function renderWithStyleInjection(h, context) {
              hook.call(context)
              return originalRender(h, context)
            }
          } else {
            var existing = options.beforeCreate
            options.beforeCreate = existing
              ? [].concat(existing, hook)
              : [hook]
          }
        }
        return {
          exports: scriptExports,
          options: options
        }
      }
    }),
    124: (function (module, __webpack_exports__, __webpack_require__) {
      "use strict";
      __webpack_require__.r(__webpack_exports__);
      var tagvue_type_script_lang_js_ = ({
        name: 'ElTag',
        props: {
          text: String,
          closable: Boolean,
          type: String,
          hit: Boolean,
          disableTransitions: Boolean,
          color: String,
          size: String,
          effect: {
            type: String,
            default: 'light',
            validator: function validator(val) {
              return ['dark', 'light', 'plain'].indexOf(val) !== -1;
            }
          }
        },
        methods: {
          handleClose: function handleClose(event) {
            event.stopPropagation();
            this.$emit('close', event);
          },
          handleClick: function handleClick(event) {
            this.$emit('click', event);
          }
        },
        computed: {
          tagSize: function tagSize() {
            return this.size || (this.$ELEMENT || {}).size;
          }
        },
        render: function render(h) {
          var type = this.type,
            tagSize = this.tagSize,
            hit = this.hit,
            effect = this.effect;
          var classes = ['el-tag', type ? 'el-tag--' + type : '', tagSize ? 'el-tag--' + tagSize : '', effect ? 'el-tag--' + effect : '', hit && 'is-hit'];
          var tagEl = h(
            'span',
            {
              'class': classes,
              style: { backgroundColor: this.color },
              on: {
                'click': this.handleClick
              }
            },
            [this.$slots.default, this.closable && h('i', {
              'class': 'el-tag__close el-icon-close', on: {
                'click': this.handleClose
              }
            })]
          );

          return this.disableTransitions ? tagEl : h(
            'transition',
            {
              attrs: { name: 'el-zoom-in-center' }
            },
            [tagEl]
          );
        }
      });
      var src_tagvue_type_script_lang_js_ = (tagvue_type_script_lang_js_);
      var componentNormalizer = __webpack_require__(0);
      var render, staticRenderFns
      var component = Object(componentNormalizer["a"])(
        src_tagvue_type_script_lang_js_,
        render,
        staticRenderFns,
        false,
        null,
        null,
        null
      )
      if (false) { var api; }
      component.options.__file = "packages/tag/src/tag.vue"
      var tag = (component.exports);
      tag.install = function (Vue) {
        Vue.component(tag.name, tag);
      };
      var packages_tag = __webpack_exports__["default"] = (tag);
    })
  });