bk-magic-vue 2.4.4 → 2.4.5

package/dist/bk-magic-vue.js

@@ -32540,6 +32540,10 @@
         default: ''
       },
       displayTag: Boolean,
+      autoHeight: {
+        type: Boolean,
+        default: true
+      },
       collapseTag: {
         type: Boolean,
         default: true
@@ -32848,7 +32852,7 @@
       },
       handleDropdownShow: function handleDropdownShow() {
         this.defaultWidth = this.$el.offsetWidth;
-        this.focus = true;
+        if (this.autoHeight) this.focus = true;
       },
       handleDropdownHide: function handleDropdownHide() {
         this.focus = false;
@@ -39295,6 +39299,7 @@
         this.fixedBodyHeight = this.scrollX ? this.bodyHeight - this.gutterWidth : this.bodyHeight;
         var noData = !this.table.data || this.table.data.length === 0;
         this.viewportHeight = this.scrollX ? tableHeight - (noData ? 0 : this.gutterWidth) : tableHeight;
+        this.syncRowHeight();
         this.updateScrollY();
         this.notifyObservers('scrollable');
       }
@@ -41382,6 +41387,10 @@
         type: Boolean,
         default: true
       },
+      rowAutoHeight: {
+        type: Boolean,
+        default: false
+      },
       stripe: Boolean,
       border: Boolean,
       outerBorder: {
@@ -41878,7 +41887,8 @@
         'bk-table-fluid-height': _vm.maxHeight,
         'bk-table-scrollable-x': _vm.layout.scrollX,
         'bk-table-scrollable-y': _vm.layout.scrollY,
-        'bk-table-enable-row-transition': (_vm.store.states.data || []).length !== 0 && (_vm.store.states.data || []).length < 100
+        'bk-table-enable-row-transition': (_vm.store.states.data || []).length !== 0 && (_vm.store.states.data || []).length < 100,
+        'bk-table-row-auto-height': _vm.rowAutoHeight
       }, _vm.tableSize ? "bk-table-" + _vm.tableSize : '', _vm.extCls],
       on: {
         "mouseleave": function mouseleave($event) {
@@ -46242,6 +46252,462 @@
 
   setInstaller(__vue_component__$19);
 
+  var sparkMd5 = createCommonjsModule(function (module, exports) {
+  (function (factory) {
+      {
+          module.exports = factory();
+      }
+  }(function (undefined$1) {
+      var hex_chr = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'];
+      function md5cycle(x, k) {
+          var a = x[0],
+              b = x[1],
+              c = x[2],
+              d = x[3];
+          a += (b & c | ~b & d) + k[0] - 680876936 | 0;
+          a  = (a << 7 | a >>> 25) + b | 0;
+          d += (a & b | ~a & c) + k[1] - 389564586 | 0;
+          d  = (d << 12 | d >>> 20) + a | 0;
+          c += (d & a | ~d & b) + k[2] + 606105819 | 0;
+          c  = (c << 17 | c >>> 15) + d | 0;
+          b += (c & d | ~c & a) + k[3] - 1044525330 | 0;
+          b  = (b << 22 | b >>> 10) + c | 0;
+          a += (b & c | ~b & d) + k[4] - 176418897 | 0;
+          a  = (a << 7 | a >>> 25) + b | 0;
+          d += (a & b | ~a & c) + k[5] + 1200080426 | 0;
+          d  = (d << 12 | d >>> 20) + a | 0;
+          c += (d & a | ~d & b) + k[6] - 1473231341 | 0;
+          c  = (c << 17 | c >>> 15) + d | 0;
+          b += (c & d | ~c & a) + k[7] - 45705983 | 0;
+          b  = (b << 22 | b >>> 10) + c | 0;
+          a += (b & c | ~b & d) + k[8] + 1770035416 | 0;
+          a  = (a << 7 | a >>> 25) + b | 0;
+          d += (a & b | ~a & c) + k[9] - 1958414417 | 0;
+          d  = (d << 12 | d >>> 20) + a | 0;
+          c += (d & a | ~d & b) + k[10] - 42063 | 0;
+          c  = (c << 17 | c >>> 15) + d | 0;
+          b += (c & d | ~c & a) + k[11] - 1990404162 | 0;
+          b  = (b << 22 | b >>> 10) + c | 0;
+          a += (b & c | ~b & d) + k[12] + 1804603682 | 0;
+          a  = (a << 7 | a >>> 25) + b | 0;
+          d += (a & b | ~a & c) + k[13] - 40341101 | 0;
+          d  = (d << 12 | d >>> 20) + a | 0;
+          c += (d & a | ~d & b) + k[14] - 1502002290 | 0;
+          c  = (c << 17 | c >>> 15) + d | 0;
+          b += (c & d | ~c & a) + k[15] + 1236535329 | 0;
+          b  = (b << 22 | b >>> 10) + c | 0;
+          a += (b & d | c & ~d) + k[1] - 165796510 | 0;
+          a  = (a << 5 | a >>> 27) + b | 0;
+          d += (a & c | b & ~c) + k[6] - 1069501632 | 0;
+          d  = (d << 9 | d >>> 23) + a | 0;
+          c += (d & b | a & ~b) + k[11] + 643717713 | 0;
+          c  = (c << 14 | c >>> 18) + d | 0;
+          b += (c & a | d & ~a) + k[0] - 373897302 | 0;
+          b  = (b << 20 | b >>> 12) + c | 0;
+          a += (b & d | c & ~d) + k[5] - 701558691 | 0;
+          a  = (a << 5 | a >>> 27) + b | 0;
+          d += (a & c | b & ~c) + k[10] + 38016083 | 0;
+          d  = (d << 9 | d >>> 23) + a | 0;
+          c += (d & b | a & ~b) + k[15] - 660478335 | 0;
+          c  = (c << 14 | c >>> 18) + d | 0;
+          b += (c & a | d & ~a) + k[4] - 405537848 | 0;
+          b  = (b << 20 | b >>> 12) + c | 0;
+          a += (b & d | c & ~d) + k[9] + 568446438 | 0;
+          a  = (a << 5 | a >>> 27) + b | 0;
+          d += (a & c | b & ~c) + k[14] - 1019803690 | 0;
+          d  = (d << 9 | d >>> 23) + a | 0;
+          c += (d & b | a & ~b) + k[3] - 187363961 | 0;
+          c  = (c << 14 | c >>> 18) + d | 0;
+          b += (c & a | d & ~a) + k[8] + 1163531501 | 0;
+          b  = (b << 20 | b >>> 12) + c | 0;
+          a += (b & d | c & ~d) + k[13] - 1444681467 | 0;
+          a  = (a << 5 | a >>> 27) + b | 0;
+          d += (a & c | b & ~c) + k[2] - 51403784 | 0;
+          d  = (d << 9 | d >>> 23) + a | 0;
+          c += (d & b | a & ~b) + k[7] + 1735328473 | 0;
+          c  = (c << 14 | c >>> 18) + d | 0;
+          b += (c & a | d & ~a) + k[12] - 1926607734 | 0;
+          b  = (b << 20 | b >>> 12) + c | 0;
+          a += (b ^ c ^ d) + k[5] - 378558 | 0;
+          a  = (a << 4 | a >>> 28) + b | 0;
+          d += (a ^ b ^ c) + k[8] - 2022574463 | 0;
+          d  = (d << 11 | d >>> 21) + a | 0;
+          c += (d ^ a ^ b) + k[11] + 1839030562 | 0;
+          c  = (c << 16 | c >>> 16) + d | 0;
+          b += (c ^ d ^ a) + k[14] - 35309556 | 0;
+          b  = (b << 23 | b >>> 9) + c | 0;
+          a += (b ^ c ^ d) + k[1] - 1530992060 | 0;
+          a  = (a << 4 | a >>> 28) + b | 0;
+          d += (a ^ b ^ c) + k[4] + 1272893353 | 0;
+          d  = (d << 11 | d >>> 21) + a | 0;
+          c += (d ^ a ^ b) + k[7] - 155497632 | 0;
+          c  = (c << 16 | c >>> 16) + d | 0;
+          b += (c ^ d ^ a) + k[10] - 1094730640 | 0;
+          b  = (b << 23 | b >>> 9) + c | 0;
+          a += (b ^ c ^ d) + k[13] + 681279174 | 0;
+          a  = (a << 4 | a >>> 28) + b | 0;
+          d += (a ^ b ^ c) + k[0] - 358537222 | 0;
+          d  = (d << 11 | d >>> 21) + a | 0;
+          c += (d ^ a ^ b) + k[3] - 722521979 | 0;
+          c  = (c << 16 | c >>> 16) + d | 0;
+          b += (c ^ d ^ a) + k[6] + 76029189 | 0;
+          b  = (b << 23 | b >>> 9) + c | 0;
+          a += (b ^ c ^ d) + k[9] - 640364487 | 0;
+          a  = (a << 4 | a >>> 28) + b | 0;
+          d += (a ^ b ^ c) + k[12] - 421815835 | 0;
+          d  = (d << 11 | d >>> 21) + a | 0;
+          c += (d ^ a ^ b) + k[15] + 530742520 | 0;
+          c  = (c << 16 | c >>> 16) + d | 0;
+          b += (c ^ d ^ a) + k[2] - 995338651 | 0;
+          b  = (b << 23 | b >>> 9) + c | 0;
+          a += (c ^ (b | ~d)) + k[0] - 198630844 | 0;
+          a  = (a << 6 | a >>> 26) + b | 0;
+          d += (b ^ (a | ~c)) + k[7] + 1126891415 | 0;
+          d  = (d << 10 | d >>> 22) + a | 0;
+          c += (a ^ (d | ~b)) + k[14] - 1416354905 | 0;
+          c  = (c << 15 | c >>> 17) + d | 0;
+          b += (d ^ (c | ~a)) + k[5] - 57434055 | 0;
+          b  = (b << 21 |b >>> 11) + c | 0;
+          a += (c ^ (b | ~d)) + k[12] + 1700485571 | 0;
+          a  = (a << 6 | a >>> 26) + b | 0;
+          d += (b ^ (a | ~c)) + k[3] - 1894986606 | 0;
+          d  = (d << 10 | d >>> 22) + a | 0;
+          c += (a ^ (d | ~b)) + k[10] - 1051523 | 0;
+          c  = (c << 15 | c >>> 17) + d | 0;
+          b += (d ^ (c | ~a)) + k[1] - 2054922799 | 0;
+          b  = (b << 21 |b >>> 11) + c | 0;
+          a += (c ^ (b | ~d)) + k[8] + 1873313359 | 0;
+          a  = (a << 6 | a >>> 26) + b | 0;
+          d += (b ^ (a | ~c)) + k[15] - 30611744 | 0;
+          d  = (d << 10 | d >>> 22) + a | 0;
+          c += (a ^ (d | ~b)) + k[6] - 1560198380 | 0;
+          c  = (c << 15 | c >>> 17) + d | 0;
+          b += (d ^ (c | ~a)) + k[13] + 1309151649 | 0;
+          b  = (b << 21 |b >>> 11) + c | 0;
+          a += (c ^ (b | ~d)) + k[4] - 145523070 | 0;
+          a  = (a << 6 | a >>> 26) + b | 0;
+          d += (b ^ (a | ~c)) + k[11] - 1120210379 | 0;
+          d  = (d << 10 | d >>> 22) + a | 0;
+          c += (a ^ (d | ~b)) + k[2] + 718787259 | 0;
+          c  = (c << 15 | c >>> 17) + d | 0;
+          b += (d ^ (c | ~a)) + k[9] - 343485551 | 0;
+          b  = (b << 21 | b >>> 11) + c | 0;
+          x[0] = a + x[0] | 0;
+          x[1] = b + x[1] | 0;
+          x[2] = c + x[2] | 0;
+          x[3] = d + x[3] | 0;
+      }
+      function md5blk(s) {
+          var md5blks = [],
+              i;
+          for (i = 0; i < 64; i += 4) {
+              md5blks[i >> 2] = s.charCodeAt(i) + (s.charCodeAt(i + 1) << 8) + (s.charCodeAt(i + 2) << 16) + (s.charCodeAt(i + 3) << 24);
+          }
+          return md5blks;
+      }
+      function md5blk_array(a) {
+          var md5blks = [],
+              i;
+          for (i = 0; i < 64; i += 4) {
+              md5blks[i >> 2] = a[i] + (a[i + 1] << 8) + (a[i + 2] << 16) + (a[i + 3] << 24);
+          }
+          return md5blks;
+      }
+      function md51(s) {
+          var n = s.length,
+              state = [1732584193, -271733879, -1732584194, 271733878],
+              i,
+              length,
+              tail,
+              tmp,
+              lo,
+              hi;
+          for (i = 64; i <= n; i += 64) {
+              md5cycle(state, md5blk(s.substring(i - 64, i)));
+          }
+          s = s.substring(i - 64);
+          length = s.length;
+          tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+          for (i = 0; i < length; i += 1) {
+              tail[i >> 2] |= s.charCodeAt(i) << ((i % 4) << 3);
+          }
+          tail[i >> 2] |= 0x80 << ((i % 4) << 3);
+          if (i > 55) {
+              md5cycle(state, tail);
+              for (i = 0; i < 16; i += 1) {
+                  tail[i] = 0;
+              }
+          }
+          tmp = n * 8;
+          tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+          lo = parseInt(tmp[2], 16);
+          hi = parseInt(tmp[1], 16) || 0;
+          tail[14] = lo;
+          tail[15] = hi;
+          md5cycle(state, tail);
+          return state;
+      }
+      function md51_array(a) {
+          var n = a.length,
+              state = [1732584193, -271733879, -1732584194, 271733878],
+              i,
+              length,
+              tail,
+              tmp,
+              lo,
+              hi;
+          for (i = 64; i <= n; i += 64) {
+              md5cycle(state, md5blk_array(a.subarray(i - 64, i)));
+          }
+          a = (i - 64) < n ? a.subarray(i - 64) : new Uint8Array(0);
+          length = a.length;
+          tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+          for (i = 0; i < length; i += 1) {
+              tail[i >> 2] |= a[i] << ((i % 4) << 3);
+          }
+          tail[i >> 2] |= 0x80 << ((i % 4) << 3);
+          if (i > 55) {
+              md5cycle(state, tail);
+              for (i = 0; i < 16; i += 1) {
+                  tail[i] = 0;
+              }
+          }
+          tmp = n * 8;
+          tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+          lo = parseInt(tmp[2], 16);
+          hi = parseInt(tmp[1], 16) || 0;
+          tail[14] = lo;
+          tail[15] = hi;
+          md5cycle(state, tail);
+          return state;
+      }
+      function rhex(n) {
+          var s = '',
+              j;
+          for (j = 0; j < 4; j += 1) {
+              s += hex_chr[(n >> (j * 8 + 4)) & 0x0F] + hex_chr[(n >> (j * 8)) & 0x0F];
+          }
+          return s;
+      }
+      function hex(x) {
+          var i;
+          for (i = 0; i < x.length; i += 1) {
+              x[i] = rhex(x[i]);
+          }
+          return x.join('');
+      }
+      if (hex(md51('hello')) !== '5d41402abc4b2a76b9719d911017c592') ;
+      if (typeof ArrayBuffer !== 'undefined' && !ArrayBuffer.prototype.slice) {
+          (function () {
+              function clamp(val, length) {
+                  val = (val | 0) || 0;
+                  if (val < 0) {
+                      return Math.max(val + length, 0);
+                  }
+                  return Math.min(val, length);
+              }
+              ArrayBuffer.prototype.slice = function (from, to) {
+                  var length = this.byteLength,
+                      begin = clamp(from, length),
+                      end = length,
+                      num,
+                      target,
+                      targetArray,
+                      sourceArray;
+                  if (to !== undefined$1) {
+                      end = clamp(to, length);
+                  }
+                  if (begin > end) {
+                      return new ArrayBuffer(0);
+                  }
+                  num = end - begin;
+                  target = new ArrayBuffer(num);
+                  targetArray = new Uint8Array(target);
+                  sourceArray = new Uint8Array(this, begin, num);
+                  targetArray.set(sourceArray);
+                  return target;
+              };
+          })();
+      }
+      function toUtf8(str) {
+          if (/[\u0080-\uFFFF]/.test(str)) {
+              str = unescape(encodeURIComponent(str));
+          }
+          return str;
+      }
+      function utf8Str2ArrayBuffer(str, returnUInt8Array) {
+          var length = str.length,
+             buff = new ArrayBuffer(length),
+             arr = new Uint8Array(buff),
+             i;
+          for (i = 0; i < length; i += 1) {
+              arr[i] = str.charCodeAt(i);
+          }
+          return returnUInt8Array ? arr : buff;
+      }
+      function arrayBuffer2Utf8Str(buff) {
+          return String.fromCharCode.apply(null, new Uint8Array(buff));
+      }
+      function concatenateArrayBuffers(first, second, returnUInt8Array) {
+          var result = new Uint8Array(first.byteLength + second.byteLength);
+          result.set(new Uint8Array(first));
+          result.set(new Uint8Array(second), first.byteLength);
+          return returnUInt8Array ? result : result.buffer;
+      }
+      function hexToBinaryString(hex) {
+          var bytes = [],
+              length = hex.length,
+              x;
+          for (x = 0; x < length - 1; x += 2) {
+              bytes.push(parseInt(hex.substr(x, 2), 16));
+          }
+          return String.fromCharCode.apply(String, bytes);
+      }
+      function SparkMD5() {
+          this.reset();
+      }
+      SparkMD5.prototype.append = function (str) {
+          this.appendBinary(toUtf8(str));
+          return this;
+      };
+      SparkMD5.prototype.appendBinary = function (contents) {
+          this._buff += contents;
+          this._length += contents.length;
+          var length = this._buff.length,
+              i;
+          for (i = 64; i <= length; i += 64) {
+              md5cycle(this._hash, md5blk(this._buff.substring(i - 64, i)));
+          }
+          this._buff = this._buff.substring(i - 64);
+          return this;
+      };
+      SparkMD5.prototype.end = function (raw) {
+          var buff = this._buff,
+              length = buff.length,
+              i,
+              tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+              ret;
+          for (i = 0; i < length; i += 1) {
+              tail[i >> 2] |= buff.charCodeAt(i) << ((i % 4) << 3);
+          }
+          this._finish(tail, length);
+          ret = hex(this._hash);
+          if (raw) {
+              ret = hexToBinaryString(ret);
+          }
+          this.reset();
+          return ret;
+      };
+      SparkMD5.prototype.reset = function () {
+          this._buff = '';
+          this._length = 0;
+          this._hash = [1732584193, -271733879, -1732584194, 271733878];
+          return this;
+      };
+      SparkMD5.prototype.getState = function () {
+          return {
+              buff: this._buff,
+              length: this._length,
+              hash: this._hash.slice()
+          };
+      };
+      SparkMD5.prototype.setState = function (state) {
+          this._buff = state.buff;
+          this._length = state.length;
+          this._hash = state.hash;
+          return this;
+      };
+      SparkMD5.prototype.destroy = function () {
+          delete this._hash;
+          delete this._buff;
+          delete this._length;
+      };
+      SparkMD5.prototype._finish = function (tail, length) {
+          var i = length,
+              tmp,
+              lo,
+              hi;
+          tail[i >> 2] |= 0x80 << ((i % 4) << 3);
+          if (i > 55) {
+              md5cycle(this._hash, tail);
+              for (i = 0; i < 16; i += 1) {
+                  tail[i] = 0;
+              }
+          }
+          tmp = this._length * 8;
+          tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+          lo = parseInt(tmp[2], 16);
+          hi = parseInt(tmp[1], 16) || 0;
+          tail[14] = lo;
+          tail[15] = hi;
+          md5cycle(this._hash, tail);
+      };
+      SparkMD5.hash = function (str, raw) {
+          return SparkMD5.hashBinary(toUtf8(str), raw);
+      };
+      SparkMD5.hashBinary = function (content, raw) {
+          var hash = md51(content),
+              ret = hex(hash);
+          return raw ? hexToBinaryString(ret) : ret;
+      };
+      SparkMD5.ArrayBuffer = function () {
+          this.reset();
+      };
+      SparkMD5.ArrayBuffer.prototype.append = function (arr) {
+          var buff = concatenateArrayBuffers(this._buff.buffer, arr, true),
+              length = buff.length,
+              i;
+          this._length += arr.byteLength;
+          for (i = 64; i <= length; i += 64) {
+              md5cycle(this._hash, md5blk_array(buff.subarray(i - 64, i)));
+          }
+          this._buff = (i - 64) < length ? new Uint8Array(buff.buffer.slice(i - 64)) : new Uint8Array(0);
+          return this;
+      };
+      SparkMD5.ArrayBuffer.prototype.end = function (raw) {
+          var buff = this._buff,
+              length = buff.length,
+              tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+              i,
+              ret;
+          for (i = 0; i < length; i += 1) {
+              tail[i >> 2] |= buff[i] << ((i % 4) << 3);
+          }
+          this._finish(tail, length);
+          ret = hex(this._hash);
+          if (raw) {
+              ret = hexToBinaryString(ret);
+          }
+          this.reset();
+          return ret;
+      };
+      SparkMD5.ArrayBuffer.prototype.reset = function () {
+          this._buff = new Uint8Array(0);
+          this._length = 0;
+          this._hash = [1732584193, -271733879, -1732584194, 271733878];
+          return this;
+      };
+      SparkMD5.ArrayBuffer.prototype.getState = function () {
+          var state = SparkMD5.prototype.getState.call(this);
+          state.buff = arrayBuffer2Utf8Str(state.buff);
+          return state;
+      };
+      SparkMD5.ArrayBuffer.prototype.setState = function (state) {
+          state.buff = utf8Str2ArrayBuffer(state.buff, true);
+          return SparkMD5.prototype.setState.call(this, state);
+      };
+      SparkMD5.ArrayBuffer.prototype.destroy = SparkMD5.prototype.destroy;
+      SparkMD5.ArrayBuffer.prototype._finish = SparkMD5.prototype._finish;
+      SparkMD5.ArrayBuffer.hash = function (arr, raw) {
+          var hash = md51_array(new Uint8Array(arr)),
+              ret = hex(hash);
+          return raw ? hexToBinaryString(ret) : ret;
+      };
+      return SparkMD5;
+  }));
+  });
+
+  var _this = undefined;
   var parseResponse = function parseResponse(response) {
     if (!response) {
       return response || {};
@@ -46252,7 +46718,7 @@
       return response || {};
     }
   };
-  function upload(options) {
+  var defaultRequest = function defaultRequest(options) {
     var xhr = new XMLHttpRequest();
     options.fileObj.xhr = xhr;
     var formData = new FormData();
@@ -46295,7 +46761,166 @@
         xhr.abort();
       }
     };
-  }
+  };
+  var blobSlice = File.prototype.slice || File.prototype.mozSlice || File.prototype.webkitSlice;
+  var sliceRequest = function () {
+    var _ref = _asyncToGenerator( regenerator.mark(function _callee(options) {
+      var chunkSize, file, blockCount, hash, progressList;
+      return regenerator.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              chunkSize = options.chunkSize * 1024 * 1024;
+              file = options.fileObj.origin;
+              if (file) {
+                _context.next = 5;
+                break;
+              }
+              _this.$bkMessage({
+                theme: 'warning',
+                message: '没有获取到文件',
+                offsetY: 80
+              });
+              return _context.abrupt("return");
+            case 5:
+              blockCount = Math.ceil(file.size / chunkSize);
+              _context.next = 8;
+              return hashFile(file, chunkSize);
+            case 8:
+              hash = _context.sent;
+              progressList = [];
+              sliceUpload(options, file, blockCount, hash, progressList, chunkSize);
+              _context.next = 13;
+              return promise$1.all(progressList).then(function () {
+                var data = {
+                  size: file.size,
+                  name: file.name,
+                  total: blockCount,
+                  hash: hash
+                };
+                var req = new XMLHttpRequest();
+                req.open(options.method, options.mergeUrl, true);
+                req.onreadystatechange = function () {
+                  if (req.readyState === 4) {
+                    var reponseText = parseResponse(req.responseText || req.response);
+                    if (req.status < 200 || req.status >= 300) {
+                      options.fileObj.progress = 100 + '%';
+                      options.fileObj.errorMsg = reponseText.message || _t('bk.uploadFile.uploadFailed');
+                      options.onError(options.fileObj, options.fileList, req.response);
+                    } else {
+                      options.onSuccess(reponseText, options.fileObj);
+                    }
+                    options.onDone(options.fileObj);
+                  }
+                };
+                req.setRequestHeader('Content-type', 'application/JSON');
+                req.send(stringify$1(data));
+              });
+            case 13:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+    return function sliceRequest(_x) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+  var sliceUpload = function sliceUpload(options, file, blockCount, hash, progressList, chunkSize) {
+    var _loop = function _loop(i) {
+      var pooltask = new promise$1(function (resolve, reject) {
+        var start = i * chunkSize;
+        var end = Math.min(file.size, start + chunkSize);
+        var formData = new FormData();
+        options.data.forEach(function (item) {
+          formData.append(item.name, item.value);
+        });
+        formData.append('file', blobSlice.call(file, start, end));
+        formData.append('name', file.name);
+        formData.append('total', blockCount);
+        formData.append('index', i);
+        formData.append('size', file.size);
+        formData.append('hash', hash);
+        var xhr = new XMLHttpRequest();
+        options.fileObj.xhr = xhr;
+        xhr.onreadystatechange = function () {
+          if (xhr.readyState === 4) {
+            var reponseText = parseResponse(xhr.responseText || xhr.response);
+            if (xhr.status < 200 || xhr.status >= 300) {
+              reject(xhr.response);
+              options.fileObj.progress = 100 + '%';
+              options.fileObj.errorMsg = reponseText.message || _t('bk.uploadFile.uploadFailed');
+              options.onError(options.fileObj, options.fileList, xhr.response);
+            } else {
+              resolve('reponseText');
+            }
+            options.onDone(options.fileObj);
+          }
+        };
+        xhr.upload.addEventListener('progress', function (e) {
+          return options.onProgress(e, i);
+        }, false);
+        xhr.withCredentials = options.withCredentials;
+        xhr.open(options.method, options.sliceUrl, true);
+        if (options.header) {
+          if (isArray$1(options.header)) {
+            options.header.forEach(function (head) {
+              var headerKey = head.name;
+              var headerVal = head.value;
+              xhr.setRequestHeader(headerKey, headerVal);
+            });
+          } else {
+            var headerKey = options.header.name;
+            var headerVal = options.header.value;
+            xhr.setRequestHeader(headerKey, headerVal);
+          }
+        }
+        xhr.send(formData);
+      });
+      progressList.push(pooltask);
+    };
+    for (var i = 0; i < blockCount; i++) {
+      _loop(i);
+    }
+  };
+  var hashFile = function hashFile(file, chunkSize) {
+    return new promise$1(function (resolve, reject) {
+      var chunks = Math.ceil(file.size / chunkSize);
+      var currentChunk = 0;
+      var spark = new sparkMd5.ArrayBuffer();
+      var fileReader = new FileReader();
+      function loadNext() {
+        var start = currentChunk * chunkSize;
+        var end = start + chunkSize >= file.size ? file.size : start + chunkSize;
+        fileReader.readAsArrayBuffer(blobSlice.call(file, start, end));
+      }
+      fileReader.onload = function (e) {
+        spark.append(e.target.result);
+        currentChunk += 1;
+        if (currentChunk < chunks) {
+          loadNext();
+        } else {
+          var result = spark.end();
+          var sparkMd5$1 = new sparkMd5();
+          sparkMd5$1.append(result);
+          sparkMd5$1.append(file.name);
+          var hexHash = sparkMd5$1.end();
+          resolve(hexHash);
+        }
+      };
+      fileReader.onerror = function () {
+        _this.$bkMessage({
+          theme: 'warning',
+          message: '文件分片失败',
+          offsetY: 80
+        });
+      };
+      loadNext();
+    }).catch(function (err) {
+      console.log(err);
+    });
+  };
 
   var script$18 = {
     name: 'bk-upload',
@@ -46330,7 +46955,7 @@
         default: 0
       },
       url: {
-        required: true,
+        required: false,
         type: String
       },
       size: {
@@ -46374,7 +46999,23 @@
         type: String,
         default: ''
       },
-      customRequest: Function
+      customRequest: Function,
+      sliceUpload: {
+        type: Boolean,
+        default: false
+      },
+      sliceUrl: {
+        type: String,
+        default: ''
+      },
+      mergeUrl: {
+        type: String,
+        default: ''
+      },
+      chunkSize: {
+        type: Number,
+        default: 10
+      }
     },
     data: function data() {
       return {
@@ -46521,6 +47162,9 @@
             fileHeader: '',
             origin: file,
             url: '',
+            sliceUrl: '',
+            mergeUrl: '',
+            chunkSize: 10,
             base64: '',
             status: '',
             done: false,
@@ -46587,9 +47231,10 @@
           this.$emit('on-error', fileObj, this.fileList);
           return;
         }
-        var uploadProgress = function uploadProgress(e) {
-          if (e.lengthComputable) {
-            var percentComplete = Math.round(e.loaded * 100 / e.total);
+        var progressList = [];
+        var uploadProgress = function uploadProgress(e, val) {
+          if (e.lengthComputable && !_this5.sliceUpload) {
+            var percentComplete = val || Math.round(e.loaded * 100 / e.total);
             var kb = Math.round(e.loaded / 1000);
             fileObj.progress = percentComplete + '%';
             _this5.speed = kb - _this5.total;
@@ -46601,6 +47246,24 @@
             }
             _this5.$emit('on-progress', e, fileObj, _this5.fileList);
           }
+          if (e.lengthComputable && _this5.sliceUpload) {
+            progressList[val] = e.loaded;
+            var complete = progressList.reduce(function (p, c) {
+              return p + c;
+            });
+            var _kb = Math.round(complete / 1000);
+            _this5.speed = _kb - _this5.total;
+            _this5.total = _kb;
+            _this5.unit = 'kb/s';
+            if (_this5.speed > 1000) {
+              _this5.speed = Math.round(_this5.speed / 1000);
+              _this5.unit = 'mb/s';
+            }
+            fileObj.progress = Math.round(complete * 100 / fileObj.origin.size) + '%';
+            if (fileObj.progress === 100 + '%') {
+              _this5.$emit('on-progress', e, fileObj, _this5.fileList);
+            }
+          }
           fileObj.status = 'running';
         };
         var options = {
@@ -46612,8 +47275,11 @@
           method: 'POST',
           header: this.header,
           url: this.url,
-          onProgress: function onProgress(event) {
-            uploadProgress(event);
+          sliceUrl: this.sliceUrl,
+          mergeUrl: this.mergeUrl,
+          chunkSize: this.chunkSize,
+          onProgress: function onProgress(event, val) {
+            uploadProgress(event, val);
           },
           onSuccess: function onSuccess(reponseText, fileObj) {
             _this5.handleSuccess(reponseText, fileObj);
@@ -46626,7 +47292,7 @@
           }
         };
         this.isdrag = false;
-        var request = this.customRequest || upload;
+        var request = this.customRequest ? this.customRequest : this.sliceUpload ? sliceRequest : defaultRequest;
         request(options);
       },
       handleSuccess: function handleSuccess(response, file) {
@@ -53487,6 +54153,9 @@
         }
       },
       removeTag: function removeTag(item, index) {
+        if (this.disabled) {
+          return;
+        }
         var oldId = JSON.parse(stringify$1(this.multipleCurrentList));
         this.multipleCurrentList = this.multipleCurrentList.filter(function (itemInfo) {
           return itemInfo.join(',') !== item.id.join(',');
@@ -54244,7 +54913,7 @@
           case 'zoomIn':
             transform.scale = _parseFloat$2((transform.scale + zoomRate).toFixed(3));
             break;
-          case 'clocelise':
+          case 'clockwise':
             transform.deg += rotateDeg;
             break;
           case 'anticlocelise':
@@ -54290,7 +54959,7 @@
     }), _vm.isShowTitle && _vm.urlList.length ? _c('div', {
       staticClass: "bk-image-viewer-header"
     }, [_c('div', [_vm._v(_vm._s(_vm.currentName))]), _c('div', {
-      staticClass: "tc"
+      staticClass: "tc "
     }, [_vm._v(_vm._s(_vm.index + 1) + "/" + _vm._s(_vm.urlList.length))]), _c('div', {
       staticClass: "quit-box tr"
     }, [_c('div', {