bk-magic-vue 2.5.9-beta.2 → 2.5.9-beta.21

package/lib/date-picker.js

@@ -2820,7 +2820,7 @@
       if (this.shortcutSelectedIndex !== -1) {
         shortcut = this.shortcuts[this.shortcutSelectedIndex] || null;
         if (shortcut) {
-          initialValue = shortcut.value();
+          initialValue = [shortcut.value()];
         }
       }
       var focusedTime = initialValue.map(extractTime);

package/lib/dialog.js

@@ -1793,6 +1793,480 @@
   })();
   var popManager = window['__bk_pop_manager'];
 
+  var _iterStep = function (done, value) {
+    return { value: value, done: !!done };
+  };
+
+  var es6_array_iterator = _iterDefine(Array, 'Array', function (iterated, kind) {
+    this._t = _toIobject(iterated);
+    this._i = 0;
+    this._k = kind;
+  }, function () {
+    var O = this._t;
+    var kind = this._k;
+    var index = this._i++;
+    if (!O || index >= O.length) {
+      this._t = undefined;
+      return _iterStep(1);
+    }
+    if (kind == 'keys') return _iterStep(0, index);
+    if (kind == 'values') return _iterStep(0, O[index]);
+    return _iterStep(0, [index, O[index]]);
+  }, 'values');
+  _iterators.Arguments = _iterators.Array;
+
+  var TO_STRING_TAG = _wks('toStringTag');
+  var DOMIterables = ('CSSRuleList,CSSStyleDeclaration,CSSValueList,ClientRectList,DOMRectList,DOMStringList,' +
+    'DOMTokenList,DataTransferItemList,FileList,HTMLAllCollection,HTMLCollection,HTMLFormElement,HTMLSelectElement,' +
+    'MediaList,MimeTypeArray,NamedNodeMap,NodeList,PaintRequestList,Plugin,PluginArray,SVGLengthList,SVGNumberList,' +
+    'SVGPathSegList,SVGPointList,SVGStringList,SVGTransformList,SourceBufferList,StyleSheetList,TextTrackCueList,' +
+    'TextTrackList,TouchList').split(',');
+  for (var i = 0; i < DOMIterables.length; i++) {
+    var NAME = DOMIterables[i];
+    var Collection = _global[NAME];
+    var proto = Collection && Collection.prototype;
+    if (proto && !proto[TO_STRING_TAG]) _hide(proto, TO_STRING_TAG, NAME);
+    _iterators[NAME] = _iterators.Array;
+  }
+
+  var SPECIES = _wks('species');
+  var _arraySpeciesConstructor = function (original) {
+    var C;
+    if (_isArray(original)) {
+      C = original.constructor;
+      if (typeof C == 'function' && (C === Array || _isArray(C.prototype))) C = undefined;
+      if (_isObject(C)) {
+        C = C[SPECIES];
+        if (C === null) C = undefined;
+      }
+    } return C === undefined ? Array : C;
+  };
+
+  var _arraySpeciesCreate = function (original, length) {
+    return new (_arraySpeciesConstructor(original))(length);
+  };
+
+  var _arrayMethods = function (TYPE, $create) {
+    var IS_MAP = TYPE == 1;
+    var IS_FILTER = TYPE == 2;
+    var IS_SOME = TYPE == 3;
+    var IS_EVERY = TYPE == 4;
+    var IS_FIND_INDEX = TYPE == 6;
+    var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;
+    var create = $create || _arraySpeciesCreate;
+    return function ($this, callbackfn, that) {
+      var O = _toObject($this);
+      var self = _iobject(O);
+      var f = _ctx(callbackfn, that, 3);
+      var length = _toLength(self.length);
+      var index = 0;
+      var result = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined;
+      var val, res;
+      for (;length > index; index++) if (NO_HOLES || index in self) {
+        val = self[index];
+        res = f(val, index, O);
+        if (TYPE) {
+          if (IS_MAP) result[index] = res;
+          else if (res) switch (TYPE) {
+            case 3: return true;
+            case 5: return val;
+            case 6: return index;
+            case 2: result.push(val);
+          } else if (IS_EVERY) return false;
+        }
+      }
+      return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : result;
+    };
+  };
+
+  var _meta = createCommonjsModule(function (module) {
+  var META = _uid('meta');
+  var setDesc = _objectDp.f;
+  var id = 0;
+  var isExtensible = Object.isExtensible || function () {
+    return true;
+  };
+  var FREEZE = !_fails(function () {
+    return isExtensible(Object.preventExtensions({}));
+  });
+  var setMeta = function (it) {
+    setDesc(it, META, { value: {
+      i: 'O' + ++id,
+      w: {}
+    } });
+  };
+  var fastKey = function (it, create) {
+    if (!_isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;
+    if (!_has(it, META)) {
+      if (!isExtensible(it)) return 'F';
+      if (!create) return 'E';
+      setMeta(it);
+    } return it[META].i;
+  };
+  var getWeak = function (it, create) {
+    if (!_has(it, META)) {
+      if (!isExtensible(it)) return true;
+      if (!create) return false;
+      setMeta(it);
+    } return it[META].w;
+  };
+  var onFreeze = function (it) {
+    if (FREEZE && meta.NEED && isExtensible(it) && !_has(it, META)) setMeta(it);
+    return it;
+  };
+  var meta = module.exports = {
+    KEY: META,
+    NEED: false,
+    fastKey: fastKey,
+    getWeak: getWeak,
+    onFreeze: onFreeze
+  };
+  });
+  var _meta_1 = _meta.KEY;
+  var _meta_2 = _meta.NEED;
+  var _meta_3 = _meta.fastKey;
+  var _meta_4 = _meta.getWeak;
+  var _meta_5 = _meta.onFreeze;
+
+  var f$1 = Object.getOwnPropertySymbols;
+  var _objectGops = {
+  	f: f$1
+  };
+
+  var f$2 = {}.propertyIsEnumerable;
+  var _objectPie = {
+  	f: f$2
+  };
+
+  var $assign = Object.assign;
+  var _objectAssign = !$assign || _fails(function () {
+    var A = {};
+    var B = {};
+    var S = Symbol();
+    var K = 'abcdefghijklmnopqrst';
+    A[S] = 7;
+    K.split('').forEach(function (k) { B[k] = k; });
+    return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K;
+  }) ? function assign(target, source) {
+    var T = _toObject(target);
+    var aLen = arguments.length;
+    var index = 1;
+    var getSymbols = _objectGops.f;
+    var isEnum = _objectPie.f;
+    while (aLen > index) {
+      var S = _iobject(arguments[index++]);
+      var keys = getSymbols ? _objectKeys(S).concat(getSymbols(S)) : _objectKeys(S);
+      var length = keys.length;
+      var j = 0;
+      var key;
+      while (length > j) {
+        key = keys[j++];
+        if (!_descriptors || isEnum.call(S, key)) T[key] = S[key];
+      }
+    } return T;
+  } : $assign;
+
+  var _redefineAll = function (target, src, safe) {
+    for (var key in src) {
+      if (safe && target[key]) target[key] = src[key];
+      else _hide(target, key, src[key]);
+    } return target;
+  };
+
+  var _anInstance = function (it, Constructor, name, forbiddenField) {
+    if (!(it instanceof Constructor) || (forbiddenField !== undefined && forbiddenField in it)) {
+      throw TypeError(name + ': incorrect invocation!');
+    } return it;
+  };
+
+  var _forOf = createCommonjsModule(function (module) {
+  var BREAK = {};
+  var RETURN = {};
+  var exports = module.exports = function (iterable, entries, fn, that, ITERATOR) {
+    var iterFn = ITERATOR ? function () { return iterable; } : core_getIteratorMethod(iterable);
+    var f = _ctx(fn, that, entries ? 2 : 1);
+    var index = 0;
+    var length, step, iterator, result;
+    if (typeof iterFn != 'function') throw TypeError(iterable + ' is not iterable!');
+    if (_isArrayIter(iterFn)) for (length = _toLength(iterable.length); length > index; index++) {
+      result = entries ? f(_anObject(step = iterable[index])[0], step[1]) : f(iterable[index]);
+      if (result === BREAK || result === RETURN) return result;
+    } else for (iterator = iterFn.call(iterable); !(step = iterator.next()).done;) {
+      result = _iterCall(iterator, f, step.value, entries);
+      if (result === BREAK || result === RETURN) return result;
+    }
+  };
+  exports.BREAK = BREAK;
+  exports.RETURN = RETURN;
+  });
+
+  var _validateCollection = function (it, TYPE) {
+    if (!_isObject(it) || it._t !== TYPE) throw TypeError('Incompatible receiver, ' + TYPE + ' required!');
+    return it;
+  };
+
+  var getWeak = _meta.getWeak;
+  var arrayFind = _arrayMethods(5);
+  var arrayFindIndex = _arrayMethods(6);
+  var id$1 = 0;
+  var uncaughtFrozenStore = function (that) {
+    return that._l || (that._l = new UncaughtFrozenStore());
+  };
+  var UncaughtFrozenStore = function () {
+    this.a = [];
+  };
+  var findUncaughtFrozen = function (store, key) {
+    return arrayFind(store.a, function (it) {
+      return it[0] === key;
+    });
+  };
+  UncaughtFrozenStore.prototype = {
+    get: function (key) {
+      var entry = findUncaughtFrozen(this, key);
+      if (entry) return entry[1];
+    },
+    has: function (key) {
+      return !!findUncaughtFrozen(this, key);
+    },
+    set: function (key, value) {
+      var entry = findUncaughtFrozen(this, key);
+      if (entry) entry[1] = value;
+      else this.a.push([key, value]);
+    },
+    'delete': function (key) {
+      var index = arrayFindIndex(this.a, function (it) {
+        return it[0] === key;
+      });
+      if (~index) this.a.splice(index, 1);
+      return !!~index;
+    }
+  };
+  var _collectionWeak = {
+    getConstructor: function (wrapper, NAME, IS_MAP, ADDER) {
+      var C = wrapper(function (that, iterable) {
+        _anInstance(that, C, NAME, '_i');
+        that._t = NAME;
+        that._i = id$1++;
+        that._l = undefined;
+        if (iterable != undefined) _forOf(iterable, IS_MAP, that[ADDER], that);
+      });
+      _redefineAll(C.prototype, {
+        'delete': function (key) {
+          if (!_isObject(key)) return false;
+          var data = getWeak(key);
+          if (data === true) return uncaughtFrozenStore(_validateCollection(this, NAME))['delete'](key);
+          return data && _has(data, this._i) && delete data[this._i];
+        },
+        has: function has(key) {
+          if (!_isObject(key)) return false;
+          var data = getWeak(key);
+          if (data === true) return uncaughtFrozenStore(_validateCollection(this, NAME)).has(key);
+          return data && _has(data, this._i);
+        }
+      });
+      return C;
+    },
+    def: function (that, key, value) {
+      var data = getWeak(_anObject(key), true);
+      if (data === true) uncaughtFrozenStore(that).set(key, value);
+      else data[that._i] = value;
+      return that;
+    },
+    ufstore: uncaughtFrozenStore
+  };
+
+  var dP$1 = _objectDp.f;
+  var each = _arrayMethods(0);
+  var _collection = function (NAME, wrapper, methods, common, IS_MAP, IS_WEAK) {
+    var Base = _global[NAME];
+    var C = Base;
+    var ADDER = IS_MAP ? 'set' : 'add';
+    var proto = C && C.prototype;
+    var O = {};
+    if (!_descriptors || typeof C != 'function' || !(IS_WEAK || proto.forEach && !_fails(function () {
+      new C().entries().next();
+    }))) {
+      C = common.getConstructor(wrapper, NAME, IS_MAP, ADDER);
+      _redefineAll(C.prototype, methods);
+      _meta.NEED = true;
+    } else {
+      C = wrapper(function (target, iterable) {
+        _anInstance(target, C, NAME, '_c');
+        target._c = new Base();
+        if (iterable != undefined) _forOf(iterable, IS_MAP, target[ADDER], target);
+      });
+      each('add,clear,delete,forEach,get,has,set,keys,values,entries,toJSON'.split(','), function (KEY) {
+        var IS_ADDER = KEY == 'add' || KEY == 'set';
+        if (KEY in proto && !(IS_WEAK && KEY == 'clear')) _hide(C.prototype, KEY, function (a, b) {
+          _anInstance(this, C, KEY);
+          if (!IS_ADDER && IS_WEAK && !_isObject(a)) return KEY == 'get' ? undefined : false;
+          var result = this._c[KEY](a === 0 ? 0 : a, b);
+          return IS_ADDER ? this : result;
+        });
+      });
+      IS_WEAK || dP$1(C.prototype, 'size', {
+        get: function () {
+          return this._c.size;
+        }
+      });
+    }
+    _setToStringTag(C, NAME);
+    O[NAME] = C;
+    _export(_export.G + _export.W + _export.F, O);
+    if (!IS_WEAK) common.setStrong(C, NAME, IS_MAP);
+    return C;
+  };
+
+  var es6_weakMap = createCommonjsModule(function (module) {
+  var each = _arrayMethods(0);
+  var NATIVE_WEAK_MAP = _validateCollection;
+  var IS_IE11 = !_global.ActiveXObject && 'ActiveXObject' in _global;
+  var WEAK_MAP = 'WeakMap';
+  var getWeak = _meta.getWeak;
+  var isExtensible = Object.isExtensible;
+  var uncaughtFrozenStore = _collectionWeak.ufstore;
+  var InternalMap;
+  var wrapper = function (get) {
+    return function WeakMap() {
+      return get(this, arguments.length > 0 ? arguments[0] : undefined);
+    };
+  };
+  var methods = {
+    get: function get(key) {
+      if (_isObject(key)) {
+        var data = getWeak(key);
+        if (data === true) return uncaughtFrozenStore(_validateCollection(this, WEAK_MAP)).get(key);
+        return data ? data[this._i] : undefined;
+      }
+    },
+    set: function set(key, value) {
+      return _collectionWeak.def(_validateCollection(this, WEAK_MAP), key, value);
+    }
+  };
+  var $WeakMap = module.exports = _collection(WEAK_MAP, wrapper, methods, _collectionWeak, true, true);
+  if (NATIVE_WEAK_MAP && IS_IE11) {
+    InternalMap = _collectionWeak.getConstructor(wrapper, WEAK_MAP);
+    _objectAssign(InternalMap.prototype, methods);
+    _meta.NEED = true;
+    each(['delete', 'has', 'get', 'set'], function (key) {
+      var proto = $WeakMap.prototype;
+      var method = proto[key];
+      _redefine(proto, key, function (a, b) {
+        if (_isObject(a) && !isExtensible(a)) {
+          if (!this._f) this._f = new InternalMap();
+          var result = this._f[key](a, b);
+          return key == 'set' ? this : result;
+        } return method.call(this, a, b);
+      });
+    });
+  }
+  });
+
+  var _setCollectionOf = function (COLLECTION) {
+    _export(_export.S, COLLECTION, { of: function of() {
+      var length = arguments.length;
+      var A = new Array(length);
+      while (length--) A[length] = arguments[length];
+      return new this(A);
+    } });
+  };
+
+  _setCollectionOf('WeakMap');
+
+  var _setCollectionFrom = function (COLLECTION) {
+    _export(_export.S, COLLECTION, { from: function from(source ) {
+      var mapFn = arguments[1];
+      var mapping, A, n, cb;
+      _aFunction(this);
+      mapping = mapFn !== undefined;
+      if (mapping) _aFunction(mapFn);
+      if (source == undefined) return new this();
+      A = [];
+      if (mapping) {
+        n = 0;
+        cb = _ctx(mapFn, arguments[2], 2);
+        _forOf(source, false, function (nextItem) {
+          A.push(cb(nextItem, n++));
+        });
+      } else {
+        _forOf(source, false, A.push, A);
+      }
+      return new this(A);
+    } });
+  };
+
+  _setCollectionFrom('WeakMap');
+
+  var weakMap = _core.WeakMap;
+
+  var weakMap$1 = weakMap;
+
+  var instanceStore = new weakMap$1();
+  var activeModal;
+  var appendMaskDiv = function appendMaskDiv(target) {
+    var div = document.createElement('div');
+    div.style.setProperty('position', 'fixed');
+    div.style.setProperty('left', '0');
+    div.style.setProperty('top', '0');
+    div.style.setProperty('width', '100%');
+    div.style.setProperty('height', '100%');
+    if (target.firstChild) {
+      return target.insertBefore(div, target.firstChild);
+    }
+    return null;
+  };
+  var loopSetMaskStyle = function loopSetMaskStyle(modal, show) {
+    if (!modal) {
+      return;
+    }
+    if (instanceStore.has(modal)) {
+      var _instanceStore$get = instanceStore.get(modal),
+        mask = _instanceStore$get.mask,
+        backgroundColor = _instanceStore$get.backgroundColor;
+      if (mask) {
+        mask.style.setProperty('background-color', show ? 'transparent' : backgroundColor);
+      }
+    }
+  };
+  var showMask = function showMask(options) {
+    if (!options.el || options.showMask === false) {
+      return;
+    }
+    if (!instanceStore.has(options.el)) {
+      var _mask = appendMaskDiv(options.el);
+      _mask.style.setProperty('background-color', options.backgroundColor);
+      instanceStore.set(options.el, _objectSpread({}, options, {
+        mask: _mask,
+        referenceParent: activeModal
+      }));
+      if (typeof options.onClick === 'function') {
+        _mask.addEventListener('click', options.onClick);
+      }
+    }
+    var mask = instanceStore.get(options.el).mask;
+    if (mask) {
+      mask.style.setProperty('display', 'inherit');
+    }
+    loopSetMaskStyle(activeModal, options.showMask);
+    activeModal = options.el;
+  };
+  var hideMask = function hideMask(options) {
+    if (options.el && instanceStore.has(options.el)) {
+      var _instanceStore$get2 = instanceStore.get(options.el),
+        referenceParent = _instanceStore$get2.referenceParent,
+        mask = _instanceStore$get2.mask;
+      activeModal = referenceParent;
+      loopSetMaskStyle(referenceParent, false);
+      if (mask) {
+        mask.style.setProperty('display', 'none');
+      }
+    }
+  };
+  var mask = {
+    showMask: showMask,
+    hideMask: hideMask
+  };
+
   function getTarget(node) {
     if (node === void 0) {
       node = document.body;
@@ -2238,7 +2712,10 @@
             }
             _this.removeScrollEffect();
           }, 300);
-          this.showMask && popManager.hide(this.popUid);
+          mask.hideMask({
+            el: this.$el,
+            showMask: this.showMask
+          });
         } else {
           this.addScrollEffect();
           this.$nextTick(function () {
@@ -2256,14 +2733,11 @@
               }, 0);
             }
             _this.dialogIndex = _this.zIndex !== undefined ? _this.zIndex : _this.getLocalZIndex();
-            if (_this.showMask) {
-              var options = {
-                tplAction: 'keepAll',
-                zIndex: _this.dialogIndex,
-                ignoreExistMask: _this.ignoreExistMask
-              };
-              _this.popUid = popManager.show("bk-dialog-".concat(_this.uuid), _this.$el, options);
-            }
+            mask.showMask({
+              el: _this.$el,
+              showMask: _this.showMask,
+              backgroundColor: 'rgba(0, 0, 0, 0.6)'
+            });
           });
         }
         this.$emit('value-change', val);
@@ -2532,6 +3006,7 @@
         "top": "-100000px",
         "left": "-100000px"
       },
+      style: _vm.wrapStyles,
       attrs: {
         "data-transfer": _vm.transfer
       }