bk-magic-vue 2.5.6 → 2.5.7

package/lib/option.js

@@ -185,63 +185,556 @@
 
 	var isArray$1 = isArray;
 
+	function _regeneratorRuntime() {
+	  _regeneratorRuntime = function () {
+	    return exports;
+	  };
+	  var exports = {},
+	    Op = Object.prototype,
+	    hasOwn = Op.hasOwnProperty,
+	    defineProperty = Object.defineProperty || function (obj, key, desc) {
+	      obj[key] = desc.value;
+	    },
+	    $Symbol = "function" == typeof Symbol ? Symbol : {},
+	    iteratorSymbol = $Symbol.iterator || "@@iterator",
+	    asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
+	    toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
+	  function define(obj, key, value) {
+	    return Object.defineProperty(obj, key, {
+	      value: value,
+	      enumerable: !0,
+	      configurable: !0,
+	      writable: !0
+	    }), obj[key];
+	  }
+	  try {
+	    define({}, "");
+	  } catch (err) {
+	    define = function (obj, key, value) {
+	      return obj[key] = value;
+	    };
+	  }
+	  function wrap(innerFn, outerFn, self, tryLocsList) {
+	    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
+	      generator = Object.create(protoGenerator.prototype),
+	      context = new Context(tryLocsList || []);
+	    return defineProperty(generator, "_invoke", {
+	      value: makeInvokeMethod(innerFn, self, context)
+	    }), generator;
+	  }
+	  function tryCatch(fn, obj, arg) {
+	    try {
+	      return {
+	        type: "normal",
+	        arg: fn.call(obj, arg)
+	      };
+	    } catch (err) {
+	      return {
+	        type: "throw",
+	        arg: err
+	      };
+	    }
+	  }
+	  exports.wrap = wrap;
+	  var ContinueSentinel = {};
+	  function Generator() {}
+	  function GeneratorFunction() {}
+	  function GeneratorFunctionPrototype() {}
+	  var IteratorPrototype = {};
+	  define(IteratorPrototype, iteratorSymbol, function () {
+	    return this;
+	  });
+	  var getProto = Object.getPrototypeOf,
+	    NativeIteratorPrototype = getProto && getProto(getProto(values([])));
+	  NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
+	  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
+	  function defineIteratorMethods(prototype) {
+	    ["next", "throw", "return"].forEach(function (method) {
+	      define(prototype, method, function (arg) {
+	        return this._invoke(method, arg);
+	      });
+	    });
+	  }
+	  function AsyncIterator(generator, PromiseImpl) {
+	    function invoke(method, arg, resolve, reject) {
+	      var record = tryCatch(generator[method], generator, arg);
+	      if ("throw" !== record.type) {
+	        var result = record.arg,
+	          value = result.value;
+	        return value && "object" == typeof value && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
+	          invoke("next", value, resolve, reject);
+	        }, function (err) {
+	          invoke("throw", err, resolve, reject);
+	        }) : PromiseImpl.resolve(value).then(function (unwrapped) {
+	          result.value = unwrapped, resolve(result);
+	        }, function (error) {
+	          return invoke("throw", error, resolve, reject);
+	        });
+	      }
+	      reject(record.arg);
+	    }
+	    var previousPromise;
+	    defineProperty(this, "_invoke", {
+	      value: function (method, arg) {
+	        function callInvokeWithMethodAndArg() {
+	          return new PromiseImpl(function (resolve, reject) {
+	            invoke(method, arg, resolve, reject);
+	          });
+	        }
+	        return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+	      }
+	    });
+	  }
+	  function makeInvokeMethod(innerFn, self, context) {
+	    var state = "suspendedStart";
+	    return function (method, arg) {
+	      if ("executing" === state) throw new Error("Generator is already running");
+	      if ("completed" === state) {
+	        if ("throw" === method) throw arg;
+	        return doneResult();
+	      }
+	      for (context.method = method, context.arg = arg;;) {
+	        var delegate = context.delegate;
+	        if (delegate) {
+	          var delegateResult = maybeInvokeDelegate(delegate, context);
+	          if (delegateResult) {
+	            if (delegateResult === ContinueSentinel) continue;
+	            return delegateResult;
+	          }
+	        }
+	        if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
+	          if ("suspendedStart" === state) throw state = "completed", context.arg;
+	          context.dispatchException(context.arg);
+	        } else "return" === context.method && context.abrupt("return", context.arg);
+	        state = "executing";
+	        var record = tryCatch(innerFn, self, context);
+	        if ("normal" === record.type) {
+	          if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
+	          return {
+	            value: record.arg,
+	            done: context.done
+	          };
+	        }
+	        "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
+	      }
+	    };
+	  }
+	  function maybeInvokeDelegate(delegate, context) {
+	    var method = delegate.iterator[context.method];
+	    if (undefined === method) {
+	      if (context.delegate = null, "throw" === context.method) {
+	        if (delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method)) return ContinueSentinel;
+	        context.method = "throw", context.arg = new TypeError("The iterator does not provide a 'throw' method");
+	      }
+	      return ContinueSentinel;
+	    }
+	    var record = tryCatch(method, delegate.iterator, context.arg);
+	    if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
+	    var info = record.arg;
+	    return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
+	  }
+	  function pushTryEntry(locs) {
+	    var entry = {
+	      tryLoc: locs[0]
+	    };
+	    1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
+	  }
+	  function resetTryEntry(entry) {
+	    var record = entry.completion || {};
+	    record.type = "normal", delete record.arg, entry.completion = record;
+	  }
+	  function Context(tryLocsList) {
+	    this.tryEntries = [{
+	      tryLoc: "root"
+	    }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
+	  }
+	  function values(iterable) {
+	    if (iterable) {
+	      var iteratorMethod = iterable[iteratorSymbol];
+	      if (iteratorMethod) return iteratorMethod.call(iterable);
+	      if ("function" == typeof iterable.next) return iterable;
+	      if (!isNaN(iterable.length)) {
+	        var i = -1,
+	          next = function next() {
+	            for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
+	            return next.value = undefined, next.done = !0, next;
+	          };
+	        return next.next = next;
+	      }
+	    }
+	    return {
+	      next: doneResult
+	    };
+	  }
+	  function doneResult() {
+	    return {
+	      value: undefined,
+	      done: !0
+	    };
+	  }
+	  return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, "constructor", {
+	    value: GeneratorFunctionPrototype,
+	    configurable: !0
+	  }), defineProperty(GeneratorFunctionPrototype, "constructor", {
+	    value: GeneratorFunction,
+	    configurable: !0
+	  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
+	    var ctor = "function" == typeof genFun && genFun.constructor;
+	    return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
+	  }, exports.mark = function (genFun) {
+	    return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
+	  }, exports.awrap = function (arg) {
+	    return {
+	      __await: arg
+	    };
+	  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
+	    return this;
+	  }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
+	    void 0 === PromiseImpl && (PromiseImpl = Promise);
+	    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
+	    return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
+	      return result.done ? result.value : iter.next();
+	    });
+	  }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
+	    return this;
+	  }), define(Gp, "toString", function () {
+	    return "[object Generator]";
+	  }), exports.keys = function (val) {
+	    var object = Object(val),
+	      keys = [];
+	    for (var key in object) keys.push(key);
+	    return keys.reverse(), function next() {
+	      for (; keys.length;) {
+	        var key = keys.pop();
+	        if (key in object) return next.value = key, next.done = !1, next;
+	      }
+	      return next.done = !0, next;
+	    };
+	  }, exports.values = values, Context.prototype = {
+	    constructor: Context,
+	    reset: function (skipTempReset) {
+	      if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);
+	    },
+	    stop: function () {
+	      this.done = !0;
+	      var rootRecord = this.tryEntries[0].completion;
+	      if ("throw" === rootRecord.type) throw rootRecord.arg;
+	      return this.rval;
+	    },
+	    dispatchException: function (exception) {
+	      if (this.done) throw exception;
+	      var context = this;
+	      function handle(loc, caught) {
+	        return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
+	      }
+	      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+	        var entry = this.tryEntries[i],
+	          record = entry.completion;
+	        if ("root" === entry.tryLoc) return handle("end");
+	        if (entry.tryLoc <= this.prev) {
+	          var hasCatch = hasOwn.call(entry, "catchLoc"),
+	            hasFinally = hasOwn.call(entry, "finallyLoc");
+	          if (hasCatch && hasFinally) {
+	            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
+	            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
+	          } else if (hasCatch) {
+	            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
+	          } else {
+	            if (!hasFinally) throw new Error("try statement without catch or finally");
+	            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
+	          }
+	        }
+	      }
+	    },
+	    abrupt: function (type, arg) {
+	      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+	        var entry = this.tryEntries[i];
+	        if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
+	          var finallyEntry = entry;
+	          break;
+	        }
+	      }
+	      finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
+	      var record = finallyEntry ? finallyEntry.completion : {};
+	      return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
+	    },
+	    complete: function (record, afterLoc) {
+	      if ("throw" === record.type) throw record.arg;
+	      return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;
+	    },
+	    finish: function (finallyLoc) {
+	      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+	        var entry = this.tryEntries[i];
+	        if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
+	      }
+	    },
+	    catch: function (tryLoc) {
+	      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+	        var entry = this.tryEntries[i];
+	        if (entry.tryLoc === tryLoc) {
+	          var record = entry.completion;
+	          if ("throw" === record.type) {
+	            var thrown = record.arg;
+	            resetTryEntry(entry);
+	          }
+	          return thrown;
+	        }
+	      }
+	      throw new Error("illegal catch attempt");
+	    },
+	    delegateYield: function (iterable, resultName, nextLoc) {
+	      return this.delegate = {
+	        iterator: values(iterable),
+	        resultName: resultName,
+	        nextLoc: nextLoc
+	      }, "next" === this.method && (this.arg = undefined), ContinueSentinel;
+	    }
+	  }, exports;
+	}
+	function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+	  try {
+	    var info = gen[key](arg);
+	    var value = info.value;
+	  } catch (error) {
+	    reject(error);
+	    return;
+	  }
+	  if (info.done) {
+	    resolve(value);
+	  } else {
+	    Promise.resolve(value).then(_next, _throw);
+	  }
+	}
+	function _asyncToGenerator(fn) {
+	  return function () {
+	    var self = this,
+	      args = arguments;
+	    return new Promise(function (resolve, reject) {
+	      var gen = fn.apply(self, args);
+	      function _next(value) {
+	        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+	      }
+	      function _throw(err) {
+	        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+	      }
+	      _next(undefined);
+	    });
+	  };
+	}
+
+	var emitter = {
+	  methods: {
+	    dispatch: function dispatch(componentName, eventName, params) {
+	      var parent = this.$parent || this.$root;
+	      var name = parent.$options.name;
+	      while (parent && (!name || name !== componentName)) {
+	        parent = parent.$parent;
+	        if (parent) {
+	          name = parent.$options.name;
+	        }
+	      }
+	      if (parent) {
+	        parent.$emit.apply(parent, [eventName].concat(params));
+	      }
+	    }
+	  }
+	};
+
+	var checkboxSeed = 0;
+	function getCheckboxName() {
+	  return "bk-checkbox_".concat(checkboxSeed++);
+	}
+
 	var script = {
-	  name: 'bk-option',
+	  name: 'bk-checkbox',
+	  mixins: [emitter],
+	  inject: {
+	    handleRemoveItem: {
+	      default: null
+	    },
+	    handleAddItem: {
+	      default: null
+	    }
+	  },
 	  props: {
-	    id: {
-	      type: [String, Number],
-	      required: true
+	    value: {
+	      type: [String, Number, Boolean],
+	      default: undefined
+	    },
+	    checked: {
+	      type: Boolean,
+	      default: undefined
+	    },
+	    trueValue: {
+	      type: [String, Number, Boolean],
+	      default: true
+	    },
+	    falseValue: {
+	      type: [String, Number, Boolean],
+	      default: false
+	    },
+	    label: {
+	      type: [String, Number]
 	    },
 	    name: {
-	      type: [String, Number],
-	      required: true
+	      type: String,
+	      default: function _default() {
+	        return getCheckboxName();
+	      }
 	    },
-	    disabled: Boolean
+	    disabled: Boolean,
+	    indeterminate: Boolean,
+	    extCls: {
+	      type: String,
+	      default: ''
+	    },
+	    beforeChange: Function
 	  },
-	  inject: ['select', 'optionGroup'],
 	  data: function data() {
 	    return {
-	      unmatched: false,
-	      isHighlight: false
+	      parent: null,
+	      localValue: undefined
 	    };
 	  },
 	  computed: {
-	    isSelected: function isSelected() {
-	      if (this.select.multiple && isArray$1(this.select.selected)) {
-	        return this.select.selected.includes(this.id);
+	    selected: function selected() {
+	      return this.localValue === this.localTrueValue;
+	    },
+	    parentValue: function parentValue() {
+	      return this.parent ? this.parent.localValue : null;
+	    },
+	    localTrueValue: function localTrueValue() {
+	      var localValue;
+	      if (this.parent) {
+	        if (this.label === undefined && this.value === undefined) {
+	          localValue = this.trueValue;
+	        } else if (this.value !== undefined) {
+	          localValue = this.value;
+	        } else {
+	          localValue = this.label;
+	        }
+	      } else {
+	        if (this.label === undefined) {
+	          localValue = this.trueValue;
+	        } else {
+	          localValue = this.label;
+	        }
 	      }
-	      return this.select.selected === this.id;
+	      return localValue;
+	    }
+	  },
+	  watch: {
+	    value: function value(val) {
+	      this.setLocalValue(val);
 	    },
-	    lowerName: function lowerName() {
-	      return String(this.name).toLowerCase();
+	    checked: function checked() {
+	      this.setLocalValue();
+	    },
+	    parentValue: function parentValue() {
+	      this.setLocalValue();
 	    }
 	  },
 	  created: function created() {
-	    this.select.registerOption(this);
-	    if (this.optionGroup) {
-	      this.optionGroup.registerOption(this);
+	    if (this.handleAddItem && typeof this.handleAddItem === 'function') {
+	      this.handleAddItem(this);
 	    }
+	    this.init();
 	  },
-	  beforeDestroy: function beforeDestroy() {
-	    this.select.removeOption(this);
-	    if (this.optionGroup) {
-	      this.optionGroup.removeOption(this);
+	  destroyed: function destroyed() {
+	    if (this.handleRemoveItem && typeof this.handleRemoveItem === 'function') {
+	      this.handleRemoveItem(this);
 	    }
 	  },
 	  methods: {
-	    handleOptionClick: function handleOptionClick() {
-	      if (this.disabled) {
-	        return false;
+	    getValue: function getValue() {
+	      if (this.selected) {
+	        return {
+	          isChecked: true,
+	          value: this.localTrueValue
+	        };
+	      } else {
+	        return {
+	          isChecked: false,
+	          value: this.falseValue
+	        };
 	      }
-	      var select = this.select;
-	      if (this.isSelected && select.multiple) {
-	        select.unselectOption(this);
-	      } else if (!this.isSelected) {
-	        select.selectOption(this);
+	    },
+	    init: function init() {
+	      var parent = this.$parent;
+	      while (parent && !parent.isCheckboxGroup && !parent.$options.name !== 'bk-checkbox-group') {
+	        parent = parent.$parent;
 	      }
-	      if (!select.multiple) {
-	        select.close();
+	      this.parent = parent;
+	      this.setLocalValue();
+	    },
+	    setLocalValue: function setLocalValue(val) {
+	      if (val !== undefined) {
+	        this.localValue = val;
+	        return;
 	      }
+	      if (this.parent) {
+	        var trueValue = this.localTrueValue;
+	        var isSelected = this.parent.localValue.includes(trueValue);
+	        this.localValue = isSelected ? trueValue : this.falseValue;
+	      } else {
+	        if (this.checked !== undefined) {
+	          this.localValue = this.checked ? this.localTrueValue : this.falseValue;
+	        } else if (this.value === undefined) {
+	          this.localValue = this.falseValue;
+	        } else {
+	          this.localValue = this.value;
+	        }
+	      }
+	    },
+	    handleClick: function handleClick() {
+	      var _this = this;
+	      return _asyncToGenerator( _regeneratorRuntime().mark(function _callee() {
+	        var shouldChange, oldValue, newValue, groupValue;
+	        return _regeneratorRuntime().wrap(function _callee$(_context) {
+	          while (1) {
+	            switch (_context.prev = _context.next) {
+	              case 0:
+	                if (!_this.disabled) {
+	                  _context.next = 2;
+	                  break;
+	                }
+	                return _context.abrupt("return", false);
+	              case 2:
+	                if (!(typeof _this.beforeChange === 'function')) {
+	                  _context.next = 8;
+	                  break;
+	                }
+	                _context.next = 5;
+	                return _this.beforeChange();
+	              case 5:
+	                shouldChange = _context.sent;
+	                if (!(shouldChange === false)) {
+	                  _context.next = 8;
+	                  break;
+	                }
+	                return _context.abrupt("return");
+	              case 8:
+	                oldValue = _this.localValue;
+	                if (_this.indeterminate) {
+	                  newValue = _this.localTrueValue;
+	                } else {
+	                  newValue = oldValue === _this.localTrueValue ? _this.falseValue : _this.localTrueValue;
+	                }
+	                _this.localValue = newValue;
+	                _this.$emit('input', newValue, _this.localTrueValue);
+	                _this.$emit('change', newValue, oldValue, _this.localTrueValue);
+	                _this.dispatch('bk-form-item', 'form-change');
+	                if (_this.parent) {
+	                  groupValue = _this.localTrueValue === undefined ? newValue : _this.localTrueValue;
+	                  _this.parent.handleChange(_this.selected, groupValue);
+	                }
+	              case 15:
+	              case "end":
+	                return _context.stop();
+	            }
+	          }
+	        }, _callee);
+	      }))();
 	    }
 	  }
 	};
@@ -307,43 +800,44 @@
 
 	/* script */
 	var __vue_script__ = script;
-
 	/* template */
 	var __vue_render__ = function __vue_render__() {
 	  var _vm = this;
 	  var _h = _vm.$createElement;
 	  var _c = _vm._self._c || _h;
-	  return _c('li', {
-	    directives: [{
-	      name: "show",
-	      rawName: "v-show",
-	      value: !_vm.unmatched,
-	      expression: "!unmatched"
-	    }],
-	    staticClass: "bk-option",
-	    class: {
-	      'is-selected': _vm.isSelected,
+	  return _c('label', {
+	    staticClass: "bk-form-checkbox",
+	    class: [{
 	      'is-disabled': _vm.disabled,
-	      'is-highlight': _vm.isHighlight
-	    },
+	      'is-indeterminate': _vm.indeterminate,
+	      'is-checked': _vm.selected
+	    }, _vm.extCls],
 	    on: {
-	      "click": _vm.handleOptionClick
-	    }
-	  }, [_c('div', {
-	    staticClass: "bk-option-content"
-	  }, [_vm._t("default", function () {
-	    return [_c('div', {
-	      staticClass: "bk-option-content-default",
-	      attrs: {
-	        "title": _vm.name
+	      "click": _vm.handleClick,
+	      "keydown": function keydown($event) {
+	        if (!$event.type.indexOf('key') && _vm._k($event.keyCode, "enter", 13, $event.key, "Enter")) {
+	          return null;
+	        }
+	        $event.preventDefault();
+	        return _vm.handleClick.apply(null, arguments);
 	      }
-	    }, [_vm.select.multiple && _vm.isSelected ? _c('i', {
-	      staticClass: "bk-option-icon bk-icon icon-check-1"
-	    }) : _vm._e(), _c('span', {
-	      staticClass: "bk-option-name",
-	      class: _vm.select.fontSizeCls
-	    }, [_vm._v("\n          " + _vm._s(_vm.name) + "\n        ")])])];
-	  })], 2)]);
+	    }
+	  }, [_c('span', {
+	    staticClass: "bk-checkbox",
+	    attrs: {
+	      "tabindex": _vm.disabled ? false : 0
+	    }
+	  }), _c('input', {
+	    attrs: {
+	      "type": "hidden",
+	      "name": _vm.name
+	    },
+	    domProps: {
+	      "value": _vm.label === undefined ? _vm.localValue : _vm.label
+	    }
+	  }), _vm.$slots.default ? _c('span', {
+	    staticClass: "bk-checkbox-text"
+	  }, [_vm._t("default")], 2) : _vm._e()]);
 	};
 	var __vue_staticRenderFns__ = [];
 
@@ -502,7 +996,142 @@
 
 	setInstaller(__vue_component__);
 
-	exports.default = __vue_component__;
+	var script$1 = {
+	  name: 'bk-option',
+	  components: {
+	    'bk-checkbox': __vue_component__
+	  },
+	  props: {
+	    id: {
+	      type: [String, Number],
+	      required: true
+	    },
+	    name: {
+	      type: [String, Number],
+	      required: true
+	    },
+	    disabled: Boolean
+	  },
+	  inject: ['select', 'optionGroup'],
+	  data: function data() {
+	    return {
+	      unmatched: false,
+	      isHighlight: false
+	    };
+	  },
+	  computed: {
+	    isSelected: function isSelected() {
+	      if (this.select.multiple && isArray$1(this.select.selected)) {
+	        return this.select.selected.includes(this.id);
+	      }
+	      return this.select.selected === this.id;
+	    },
+	    lowerName: function lowerName() {
+	      return String(this.name).toLowerCase();
+	    },
+	    selectedStyle: function selectedStyle() {
+	      return this.select.selectedStyle;
+	    }
+	  },
+	  created: function created() {
+	    this.select.registerOption(this);
+	    if (this.optionGroup) {
+	      this.optionGroup.registerOption(this);
+	    }
+	  },
+	  beforeDestroy: function beforeDestroy() {
+	    this.select.removeOption(this);
+	    if (this.optionGroup) {
+	      this.optionGroup.removeOption(this);
+	    }
+	  },
+	  methods: {
+	    handleOptionClick: function handleOptionClick() {
+	      if (this.disabled) {
+	        return false;
+	      }
+	      var select = this.select;
+	      if (this.isSelected && select.multiple) {
+	        select.unselectOption(this);
+	      } else if (!this.isSelected) {
+	        select.selectOption(this);
+	      }
+	      if (!select.multiple) {
+	        select.close();
+	      }
+	    }
+	  }
+	};
+
+	/* script */
+	var __vue_script__$1 = script$1;
+
+	/* template */
+	var __vue_render__$1 = function __vue_render__() {
+	  var _vm = this;
+	  var _h = _vm.$createElement;
+	  var _c = _vm._self._c || _h;
+	  return _c('li', {
+	    directives: [{
+	      name: "show",
+	      rawName: "v-show",
+	      value: !_vm.unmatched,
+	      expression: "!unmatched"
+	    }],
+	    staticClass: "bk-option",
+	    class: {
+	      'is-selected': _vm.isSelected,
+	      'is-disabled': _vm.disabled,
+	      'is-highlight': _vm.isHighlight
+	    },
+	    on: {
+	      "click": _vm.handleOptionClick
+	    }
+	  }, [_c('div', {
+	    staticClass: "bk-option-content"
+	  }, [_vm._t("default", function () {
+	    return [_c('div', {
+	      staticClass: "bk-option-content-default",
+	      attrs: {
+	        "title": _vm.name
+	      }
+	    }, [_vm.selectedStyle === 'checkbox' && _vm.select.multiple ? [_c('bk-checkbox', {
+	      staticClass: "bk-option-checkbox",
+	      attrs: {
+	        "value": _vm.isSelected
+	      }
+	    }, [_vm._v(_vm._s(_vm.name))])] : [_vm.select.multiple && _vm.isSelected ? _c('i', {
+	      staticClass: "bk-option-icon bk-icon icon-check-1"
+	    }) : _vm._e(), _c('span', {
+	      staticClass: "bk-option-name",
+	      class: _vm.select.fontSizeCls
+	    }, [_vm._v("\n            " + _vm._s(_vm.name) + "\n          ")])]], 2)];
+	  })], 2)]);
+	};
+	var __vue_staticRenderFns__$1 = [];
+
+	/* style */
+	var __vue_inject_styles__$1 = undefined;
+	/* scoped */
+	var __vue_scope_id__$1 = undefined;
+	/* module identifier */
+	var __vue_module_identifier__$1 = undefined;
+	/* functional template */
+	var __vue_is_functional_template__$1 = false;
+	/* style inject */
+
+	/* style inject SSR */
+
+	/* style inject shadow dom */
+
+	var __vue_component__$1 = /*#__PURE__*/normalizeComponent_1({
+	  render: __vue_render__$1,
+	  staticRenderFns: __vue_staticRenderFns__$1
+	}, __vue_inject_styles__$1, __vue_script__$1, __vue_scope_id__$1, __vue_is_functional_template__$1, __vue_module_identifier__$1, false, undefined, undefined, undefined);
+
+	setInstaller(__vue_component__$1);
+
+	exports.default = __vue_component__$1;
 
 	Object.defineProperty(exports, '__esModule', { value: true });