byt-ui 0.1.27 → 0.1.29

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/lib/byt-ui.umd.js CHANGED
@@ -264327,7 +264327,7 @@ function entry_lib_error (msg, err) {
264327
264327
 
264328
264328
  var entry_lib_isArray = Array.isArray;
264329
264329
 
264330
- function entry_lib_vue_i18n_esm_isObject (obj) {
264330
+ function entry_lib_isObject (obj) {
264331
264331
  return obj !== null && typeof obj === 'object'
264332
264332
  }
264333
264333
 
@@ -264335,7 +264335,7 @@ function entry_lib_isBoolean (val) {
264335
264335
  return typeof val === 'boolean'
264336
264336
  }
264337
264337
 
264338
- function entry_lib_vue_i18n_esm_isString (val) {
264338
+ function entry_lib_isString (val) {
264339
264339
  return typeof val === 'string'
264340
264340
  }
264341
264341
 
@@ -264360,7 +264360,7 @@ function entry_lib_parseArgs () {
264360
264360
  var locale = null;
264361
264361
  var params = null;
264362
264362
  if (args.length === 1) {
264363
- if (entry_lib_vue_i18n_esm_isObject(args[0]) || entry_lib_isArray(args[0])) {
264363
+ if (entry_lib_isObject(args[0]) || entry_lib_isArray(args[0])) {
264364
264364
  params = args[0];
264365
264365
  } else if (typeof args[0] === 'string') {
264366
264366
  locale = args[0];
@@ -264370,7 +264370,7 @@ function entry_lib_parseArgs () {
264370
264370
  locale = args[0];
264371
264371
  }
264372
264372
  /* istanbul ignore if */
264373
- if (entry_lib_vue_i18n_esm_isObject(args[1]) || entry_lib_isArray(args[1])) {
264373
+ if (entry_lib_isObject(args[1]) || entry_lib_isArray(args[1])) {
264374
264374
  params = args[1];
264375
264375
  }
264376
264376
  }
@@ -264413,7 +264413,7 @@ function entry_lib_merge (target) {
264413
264413
  var key = (void 0);
264414
264414
  for (key in source) {
264415
264415
  if (entry_lib_hasOwn(source, key)) {
264416
- if (entry_lib_vue_i18n_esm_isObject(source[key])) {
264416
+ if (entry_lib_isObject(source[key])) {
264417
264417
  output[key] = entry_lib_merge(output[key], source[key]);
264418
264418
  } else {
264419
264419
  output[key] = source[key];
@@ -264427,8 +264427,8 @@ function entry_lib_merge (target) {
264427
264427
 
264428
264428
  function entry_lib_looseEqual (a, b) {
264429
264429
  if (a === b) { return true }
264430
- var isObjectA = entry_lib_vue_i18n_esm_isObject(a);
264431
- var isObjectB = entry_lib_vue_i18n_esm_isObject(b);
264430
+ var isObjectA = entry_lib_isObject(a);
264431
+ var isObjectB = entry_lib_isObject(b);
264432
264432
  if (isObjectA && isObjectB) {
264433
264433
  try {
264434
264434
  var isArrayA = entry_lib_isArray(a);
@@ -264827,9 +264827,9 @@ var entry_lib_numberComponent = {
264827
264827
  var key = null;
264828
264828
  var options = null;
264829
264829
 
264830
- if (entry_lib_vue_i18n_esm_isString(props.format)) {
264830
+ if (entry_lib_isString(props.format)) {
264831
264831
  key = props.format;
264832
- } else if (entry_lib_vue_i18n_esm_isObject(props.format)) {
264832
+ } else if (entry_lib_isObject(props.format)) {
264833
264833
  if (props.format.key) {
264834
264834
  key = props.format.key;
264835
264835
  }
@@ -264960,7 +264960,7 @@ function entry_lib_parseValue (value) {
264960
264960
  var args;
264961
264961
  var choice;
264962
264962
 
264963
- if (entry_lib_vue_i18n_esm_isString(value)) {
264963
+ if (entry_lib_isString(value)) {
264964
264964
  path = value;
264965
264965
  } else if (entry_lib_isPlainObject(value)) {
264966
264966
  path = value.path;
@@ -264983,7 +264983,7 @@ function entry_lib_makeParams (locale, args) {
264983
264983
  return params
264984
264984
  }
264985
264985
 
264986
- var entry_lib_vue_i18n_esm_Vue;
264986
+ var entry_lib_Vue;
264987
264987
 
264988
264988
  function entry_lib_install (_Vue, options) {
264989
264989
  if ( options === void 0 ) options = { bridge: false };
@@ -264992,20 +264992,20 @@ function entry_lib_install (_Vue, options) {
264992
264992
  if (false) {}
264993
264993
  entry_lib_install.installed = true;
264994
264994
 
264995
- entry_lib_vue_i18n_esm_Vue = _Vue;
264995
+ entry_lib_Vue = _Vue;
264996
264996
 
264997
- var version = (entry_lib_vue_i18n_esm_Vue.version && Number(entry_lib_vue_i18n_esm_Vue.version.split('.')[0])) || -1;
264997
+ var version = (entry_lib_Vue.version && Number(entry_lib_Vue.version.split('.')[0])) || -1;
264998
264998
  /* istanbul ignore if */
264999
264999
  if (false) {}
265000
265000
 
265001
- entry_lib_extend(entry_lib_vue_i18n_esm_Vue);
265002
- entry_lib_vue_i18n_esm_Vue.mixin(entry_lib_defineMixin(options.bridge));
265003
- entry_lib_vue_i18n_esm_Vue.directive('t', { bind: entry_lib_bind, update: entry_lib_update, unbind: entry_lib_unbind });
265004
- entry_lib_vue_i18n_esm_Vue.component(entry_lib_interpolationComponent.name, entry_lib_interpolationComponent);
265005
- entry_lib_vue_i18n_esm_Vue.component(entry_lib_numberComponent.name, entry_lib_numberComponent);
265001
+ entry_lib_extend(entry_lib_Vue);
265002
+ entry_lib_Vue.mixin(entry_lib_defineMixin(options.bridge));
265003
+ entry_lib_Vue.directive('t', { bind: entry_lib_bind, update: entry_lib_update, unbind: entry_lib_unbind });
265004
+ entry_lib_Vue.component(entry_lib_interpolationComponent.name, entry_lib_interpolationComponent);
265005
+ entry_lib_Vue.component(entry_lib_numberComponent.name, entry_lib_numberComponent);
265006
265006
 
265007
265007
  // use simple mergeStrategies to prevent i18n instance lose '__proto__'
265008
- var strats = entry_lib_vue_i18n_esm_Vue.config.optionMergeStrategies;
265008
+ var strats = entry_lib_Vue.config.optionMergeStrategies;
265009
265009
  strats.i18n = function (parentVal, childVal) {
265010
265010
  return childVal === undefined
265011
265011
  ? parentVal
@@ -265084,7 +265084,7 @@ function entry_lib_compile (tokens, values) {
265084
265084
 
265085
265085
  var mode = Array.isArray(values)
265086
265086
  ? 'list'
265087
- : entry_lib_vue_i18n_esm_isObject(values)
265087
+ : entry_lib_isObject(values)
265088
265088
  ? 'named'
265089
265089
  : 'unknown';
265090
265090
  if (mode === 'unknown') { return compiled }
@@ -265390,7 +265390,7 @@ entry_lib_I18nPath.prototype.parsePath = function parsePath (path) {
265390
265390
  * Get path value from path string
265391
265391
  */
265392
265392
  entry_lib_I18nPath.prototype.getPathValue = function getPathValue (obj, path) {
265393
- if (!entry_lib_vue_i18n_esm_isObject(obj)) { return null }
265393
+ if (!entry_lib_isObject(obj)) { return null }
265394
265394
 
265395
265395
  var paths = this.parsePath(path);
265396
265396
  if (paths.length === 0) {
@@ -265436,7 +265436,7 @@ var entry_lib_VueI18n = function VueI18n (options) {
265436
265436
  // To allow users to avoid auto-installation in some cases,
265437
265437
  // this code should be placed here. See #290
265438
265438
  /* istanbul ignore if */
265439
- if (!entry_lib_vue_i18n_esm_Vue && typeof window !== 'undefined' && window.Vue) {
265439
+ if (!entry_lib_Vue && typeof window !== 'undefined' && window.Vue) {
265440
265440
  entry_lib_install(window.Vue);
265441
265441
  }
265442
265442
 
@@ -265579,7 +265579,7 @@ entry_lib_VueI18n.prototype._checkLocaleMessage = function _checkLocaleMessage (
265579
265579
  paths.pop();
265580
265580
  }
265581
265581
  });
265582
- } else if (entry_lib_vue_i18n_esm_isString(message)) {
265582
+ } else if (entry_lib_isString(message)) {
265583
265583
  var ret = entry_lib_htmlTagMatcher.test(message);
265584
265584
  if (ret) {
265585
265585
  var msg = "Detected HTML in message '" + message + "' of keypath '" + (paths.join('')) + "' at '" + locale + "'. Consider component interpolation with '<i18n>' to avoid XSS. See https://bit.ly/2ZqJzkp";
@@ -265596,10 +265596,10 @@ entry_lib_VueI18n.prototype._checkLocaleMessage = function _checkLocaleMessage (
265596
265596
  };
265597
265597
 
265598
265598
  entry_lib_VueI18n.prototype._initVM = function _initVM (data) {
265599
- var silent = entry_lib_vue_i18n_esm_Vue.config.silent;
265600
- entry_lib_vue_i18n_esm_Vue.config.silent = true;
265601
- this._vm = new entry_lib_vue_i18n_esm_Vue({ data: data, __VUE18N__INSTANCE__: true });
265602
- entry_lib_vue_i18n_esm_Vue.config.silent = silent;
265599
+ var silent = entry_lib_Vue.config.silent;
265600
+ entry_lib_Vue.config.silent = true;
265601
+ this._vm = new entry_lib_Vue({ data: data, __VUE18N__INSTANCE__: true });
265602
+ entry_lib_Vue.config.silent = silent;
265603
265603
  };
265604
265604
 
265605
265605
  entry_lib_VueI18n.prototype.destroyVM = function destroyVM () {
@@ -265620,7 +265620,7 @@ entry_lib_VueI18n.prototype.watchI18nData = function watchI18nData () {
265620
265620
  var listeners = entry_lib_arrayFrom(this$1._dataListeners);
265621
265621
  var i = listeners.length;
265622
265622
  while(i--) {
265623
- entry_lib_vue_i18n_esm_Vue.nextTick(function () {
265623
+ entry_lib_Vue.nextTick(function () {
265624
265624
  listeners[i] && listeners[i].$forceUpdate();
265625
265625
  });
265626
265626
  }
@@ -265721,7 +265721,7 @@ entry_lib_VueI18n.prototype._warnDefault = function _warnDefault (locale, key, r
265721
265721
  if (!entry_lib_isNull(result)) { return result }
265722
265722
  if (this._missing) {
265723
265723
  var missingRet = this._missing.apply(null, [locale, key, vm, values]);
265724
- if (entry_lib_vue_i18n_esm_isString(missingRet)) {
265724
+ if (entry_lib_isString(missingRet)) {
265725
265725
  return missingRet
265726
265726
  }
265727
265727
  } else {
@@ -265775,7 +265775,7 @@ entry_lib_VueI18n.prototype._interpolate = function _interpolate (
265775
265775
  /* istanbul ignore else */
265776
265776
  if (entry_lib_isPlainObject(message)) {
265777
265777
  ret = message[key];
265778
- if (!(entry_lib_vue_i18n_esm_isString(ret) || entry_lib_isFunction(ret))) {
265778
+ if (!(entry_lib_isString(ret) || entry_lib_isFunction(ret))) {
265779
265779
  if (false) {}
265780
265780
  return null
265781
265781
  }
@@ -265784,7 +265784,7 @@ entry_lib_VueI18n.prototype._interpolate = function _interpolate (
265784
265784
  }
265785
265785
  } else {
265786
265786
  /* istanbul ignore else */
265787
- if (entry_lib_vue_i18n_esm_isString(pathRet) || entry_lib_isFunction(pathRet)) {
265787
+ if (entry_lib_isString(pathRet) || entry_lib_isFunction(pathRet)) {
265788
265788
  ret = pathRet;
265789
265789
  } else {
265790
265790
  if (false) {}
@@ -265793,7 +265793,7 @@ entry_lib_VueI18n.prototype._interpolate = function _interpolate (
265793
265793
  }
265794
265794
 
265795
265795
  // Check for the existence of links within the translated string
265796
- if (entry_lib_vue_i18n_esm_isString(ret) && (ret.indexOf('@:') >= 0 || ret.indexOf('@.') >= 0)) {
265796
+ if (entry_lib_isString(ret) && (ret.indexOf('@:') >= 0 || ret.indexOf('@.') >= 0)) {
265797
265797
  ret = this._link(locale, message, ret, host, 'raw', values, visitedLinkStack);
265798
265798
  }
265799
265799
 
@@ -265880,7 +265880,7 @@ entry_lib_VueI18n.prototype._createMessageContext = function _createMessageConte
265880
265880
  var this$1 = this;
265881
265881
 
265882
265882
  var _list = entry_lib_isArray(values) ? values : [];
265883
- var _named = entry_lib_vue_i18n_esm_isObject(values) ? values : {};
265883
+ var _named = entry_lib_isObject(values) ? values : {};
265884
265884
  var list = function (index) { return _list[index]; };
265885
265885
  var named = function (key) { return _named[key]; };
265886
265886
  var messages = this._getMessages();
@@ -265914,7 +265914,7 @@ entry_lib_VueI18n.prototype._render = function _render (message, interpolateMode
265914
265914
 
265915
265915
  // if interpolateMode is **not** 'string' ('row'),
265916
265916
  // return the compiled data (e.g. ['foo', VNode, 'bar']) with formatter
265917
- return interpolateMode === 'string' && !entry_lib_vue_i18n_esm_isString(ret) ? ret.join('') : ret
265917
+ return interpolateMode === 'string' && !entry_lib_isString(ret) ? ret.join('') : ret
265918
265918
  };
265919
265919
 
265920
265920
  entry_lib_VueI18n.prototype._appendItemToChain = function _appendItemToChain (chain, item, blocks) {
@@ -265948,7 +265948,7 @@ entry_lib_VueI18n.prototype._appendBlockToChain = function _appendBlockToChain (
265948
265948
  var follow = true;
265949
265949
  for (var i = 0; (i < block.length) && (entry_lib_isBoolean(follow)); i++) {
265950
265950
  var locale = block[i];
265951
- if (entry_lib_vue_i18n_esm_isString(locale)) {
265951
+ if (entry_lib_isString(locale)) {
265952
265952
  follow = this._appendLocaleToChain(chain, locale, blocks);
265953
265953
  }
265954
265954
  }
@@ -265985,7 +265985,7 @@ entry_lib_VueI18n.prototype._getLocaleChain = function _getLocaleChain (start, f
265985
265985
  var defaults;
265986
265986
  if (entry_lib_isArray(fallbackLocale)) {
265987
265987
  defaults = fallbackLocale;
265988
- } else if (entry_lib_vue_i18n_esm_isObject(fallbackLocale)) {
265988
+ } else if (entry_lib_isObject(fallbackLocale)) {
265989
265989
  /* $FlowFixMe */
265990
265990
  if (fallbackLocale['default']) {
265991
265991
  defaults = fallbackLocale['default'];
@@ -265997,7 +265997,7 @@ entry_lib_VueI18n.prototype._getLocaleChain = function _getLocaleChain (start, f
265997
265997
  }
265998
265998
 
265999
265999
  // convert defaults to array
266000
- if (entry_lib_vue_i18n_esm_isString(defaults)) {
266000
+ if (entry_lib_isString(defaults)) {
266001
266001
  block = [defaults];
266002
266002
  } else {
266003
266003
  block = defaults;
@@ -266093,7 +266093,7 @@ entry_lib_VueI18n.prototype.i = function i (key, locale, values) {
266093
266093
  /* istanbul ignore if */
266094
266094
  if (!key) { return '' }
266095
266095
 
266096
- if (!entry_lib_vue_i18n_esm_isString(locale)) {
266096
+ if (!entry_lib_isString(locale)) {
266097
266097
  locale = this.locale;
266098
266098
  }
266099
266099
 
@@ -266125,7 +266125,7 @@ entry_lib_VueI18n.prototype._tc = function _tc (
266125
266125
 
266126
266126
  entry_lib_VueI18n.prototype.fetchChoice = function fetchChoice (message, choice) {
266127
266127
  /* istanbul ignore if */
266128
- if (!message || !entry_lib_vue_i18n_esm_isString(message)) { return null }
266128
+ if (!message || !entry_lib_isString(message)) { return null }
266129
266129
  var choices = message.split('|');
266130
266130
 
266131
266131
  choice = this.getChoiceIndex(choice, choices.length);
@@ -266278,9 +266278,9 @@ entry_lib_VueI18n.prototype.d = function d (value) {
266278
266278
  var options = null;
266279
266279
 
266280
266280
  if (args.length === 1) {
266281
- if (entry_lib_vue_i18n_esm_isString(args[0])) {
266281
+ if (entry_lib_isString(args[0])) {
266282
266282
  key = args[0];
266283
- } else if (entry_lib_vue_i18n_esm_isObject(args[0])) {
266283
+ } else if (entry_lib_isObject(args[0])) {
266284
266284
  if (args[0].locale) {
266285
266285
  locale = args[0].locale;
266286
266286
  }
@@ -266299,10 +266299,10 @@ entry_lib_VueI18n.prototype.d = function d (value) {
266299
266299
  }, null);
266300
266300
 
266301
266301
  } else if (args.length === 2) {
266302
- if (entry_lib_vue_i18n_esm_isString(args[0])) {
266302
+ if (entry_lib_isString(args[0])) {
266303
266303
  key = args[0];
266304
266304
  }
266305
- if (entry_lib_vue_i18n_esm_isString(args[1])) {
266305
+ if (entry_lib_isString(args[1])) {
266306
266306
  locale = args[1];
266307
266307
  }
266308
266308
  }
@@ -266415,9 +266415,9 @@ entry_lib_VueI18n.prototype.n = function n (value) {
266415
266415
  var options = null;
266416
266416
 
266417
266417
  if (args.length === 1) {
266418
- if (entry_lib_vue_i18n_esm_isString(args[0])) {
266418
+ if (entry_lib_isString(args[0])) {
266419
266419
  key = args[0];
266420
- } else if (entry_lib_vue_i18n_esm_isObject(args[0])) {
266420
+ } else if (entry_lib_isObject(args[0])) {
266421
266421
  if (args[0].locale) {
266422
266422
  locale = args[0].locale;
266423
266423
  }
@@ -266436,10 +266436,10 @@ entry_lib_VueI18n.prototype.n = function n (value) {
266436
266436
  }, null);
266437
266437
  }
266438
266438
  } else if (args.length === 2) {
266439
- if (entry_lib_vue_i18n_esm_isString(args[0])) {
266439
+ if (entry_lib_isString(args[0])) {
266440
266440
  key = args[0];
266441
266441
  }
266442
- if (entry_lib_vue_i18n_esm_isString(args[1])) {
266442
+ if (entry_lib_isString(args[1])) {
266443
266443
  locale = args[1];
266444
266444
  }
266445
266445
  }
@@ -266545,308 +266545,19 @@ var entry_lib_en_US = __webpack_require__(14373);
266545
266545
  }
266546
266546
  }
266547
266547
  });
266548
- ;// ./node_modules/element-ui/src/utils/types.js
266549
-
266550
-
266551
- function entry_lib_types_isString(obj) {
266552
- return Object.prototype.toString.call(obj) === '[object String]';
266553
- }
266554
-
266555
- function entry_lib_types_isObject(obj) {
266556
- return Object.prototype.toString.call(obj) === '[object Object]';
266557
- }
266558
-
266559
- function entry_lib_isHtmlElement(node) {
266560
- return node && node.nodeType === Node.ELEMENT_NODE;
266561
- }
266562
-
266563
- /**
266564
- * - Inspired:
266565
- * https://github.com/jashkenas/underscore/blob/master/modules/isFunction.js
266566
- */
266567
- let entry_lib_types_isFunction = (functionToCheck) => {
266568
- var getType = {};
266569
- return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';
266570
- };
266571
-
266572
- if ( true && typeof Int8Array !== 'object' && ((entry_lib_external_commonjs_vue_commonjs2_vue_root_Vue_default()).prototype.$isServer || typeof document.childNodes !== 'function')) {
266573
- entry_lib_types_isFunction = function(obj) {
266574
- return typeof obj === 'function' || false;
266575
- };
266576
- }
266577
-
266578
-
266579
-
266580
- const entry_lib_isUndefined = (val)=> {
266581
- return val === void 0;
266582
- };
266583
-
266584
- const entry_lib_isDefined = (val) => {
266585
- return val !== undefined && val !== null;
266586
- };
266587
-
266588
- ;// ./node_modules/element-ui/src/utils/util.js
266589
-
266590
-
266591
-
266592
- const entry_lib_util_hasOwnProperty = Object.prototype.hasOwnProperty;
266593
-
266594
- function entry_lib_noop() {};
266595
-
266596
- function entry_lib_util_hasOwn(obj, key) {
266597
- return entry_lib_util_hasOwnProperty.call(obj, key);
266598
- };
266599
-
266600
- function entry_lib_util_extend(to, _from) {
266601
- for (let key in _from) {
266602
- to[key] = _from[key];
266603
- }
266604
- return to;
266605
- };
266606
-
266607
- function entry_lib_toObject(arr) {
266608
- var res = {};
266609
- for (let i = 0; i < arr.length; i++) {
266610
- if (arr[i]) {
266611
- entry_lib_util_extend(res, arr[i]);
266612
- }
266613
- }
266614
- return res;
266615
- };
266616
-
266617
- const entry_lib_getValueByPath = function(object, prop) {
266618
- prop = prop || '';
266619
- const paths = prop.split('.');
266620
- let current = object;
266621
- let result = null;
266622
- for (let i = 0, j = paths.length; i < j; i++) {
266623
- const path = paths[i];
266624
- if (!current) break;
266625
-
266626
- if (i === j - 1) {
266627
- result = current[path];
266628
- break;
266629
- }
266630
- current = current[path];
266631
- }
266632
- return result;
266633
- };
266634
-
266635
- function entry_lib_getPropByPath(obj, path, strict) {
266636
- let tempObj = obj;
266637
- path = path.replace(/\[(\w+)\]/g, '.$1');
266638
- path = path.replace(/^\./, '');
266639
-
266640
- let keyArr = path.split('.');
266641
- let i = 0;
266642
- for (let len = keyArr.length; i < len - 1; ++i) {
266643
- if (!tempObj && !strict) break;
266644
- let key = keyArr[i];
266645
- if (key in tempObj) {
266646
- tempObj = tempObj[key];
266647
- } else {
266648
- if (strict) {
266649
- throw new Error('please transfer a valid prop path to form item!');
266650
- }
266651
- break;
266652
- }
266653
- }
266654
- return {
266655
- o: tempObj,
266656
- k: keyArr[i],
266657
- v: tempObj ? tempObj[keyArr[i]] : null
266658
- };
266659
- };
266660
-
266661
- const entry_lib_generateId = function() {
266662
- return Math.floor(Math.random() * 10000);
266663
- };
266664
-
266665
- const entry_lib_valueEquals = (a, b) => {
266666
- // see: https://stackoverflow.com/questions/3115982/how-to-check-if-two-arrays-are-equal-with-javascript
266667
- if (a === b) return true;
266668
- if (!(a instanceof Array)) return false;
266669
- if (!(b instanceof Array)) return false;
266670
- if (a.length !== b.length) return false;
266671
- for (let i = 0; i !== a.length; ++i) {
266672
- if (a[i] !== b[i]) return false;
266673
- }
266674
- return true;
266675
- };
266676
-
266677
- const entry_lib_escapeRegexpString = (value = '') => String(value).replace(/[|\\{}()[\]^$+*?.]/g, '\\$&');
266678
-
266679
- // TODO: use native Array.find, Array.findIndex when IE support is dropped
266680
- const entry_lib_arrayFindIndex = function(arr, pred) {
266681
- for (let i = 0; i !== arr.length; ++i) {
266682
- if (pred(arr[i])) {
266683
- return i;
266684
- }
266685
- }
266686
- return -1;
266687
- };
266688
-
266689
- const entry_lib_arrayFind = function(arr, pred) {
266690
- const idx = entry_lib_arrayFindIndex(arr, pred);
266691
- return idx !== -1 ? arr[idx] : undefined;
266692
- };
266693
-
266694
- // coerce truthy value to array
266695
- const entry_lib_coerceTruthyValueToArray = function(val) {
266696
- if (Array.isArray(val)) {
266697
- return val;
266698
- } else if (val) {
266699
- return [val];
266700
- } else {
266701
- return [];
266702
- }
266703
- };
266704
-
266705
- const entry_lib_isIE = function() {
266706
- return !Vue.prototype.$isServer && !isNaN(Number(document.documentMode));
266707
- };
266708
-
266709
- const entry_lib_isEdge = function() {
266710
- return !Vue.prototype.$isServer && navigator.userAgent.indexOf('Edge') > -1;
266711
- };
266712
-
266713
- const entry_lib_isFirefox = function() {
266714
- return !Vue.prototype.$isServer && !!window.navigator.userAgent.match(/firefox/i);
266715
- };
266716
-
266717
- const entry_lib_autoprefixer = function(style) {
266718
- if (typeof style !== 'object') return style;
266719
- const rules = ['transform', 'transition', 'animation'];
266720
- const prefixes = ['ms-', 'webkit-'];
266721
- rules.forEach(rule => {
266722
- const value = style[rule];
266723
- if (rule && value) {
266724
- prefixes.forEach(prefix => {
266725
- style[prefix + rule] = value;
266726
- });
266727
- }
266728
- });
266729
- return style;
266730
- };
266731
-
266732
- const entry_lib_kebabCase = function(str) {
266733
- const hyphenateRE = /([^-])([A-Z])/g;
266734
- return str
266735
- .replace(hyphenateRE, '$1-$2')
266736
- .replace(hyphenateRE, '$1-$2')
266737
- .toLowerCase();
266738
- };
266739
-
266740
- const entry_lib_capitalize = function(str) {
266741
- if (!isString(str)) return str;
266742
- return str.charAt(0).toUpperCase() + str.slice(1);
266743
- };
266744
-
266745
- const entry_lib_util_looseEqual = function(a, b) {
266746
- const isObjectA = isObject(a);
266747
- const isObjectB = isObject(b);
266748
- if (isObjectA && isObjectB) {
266749
- return JSON.stringify(a) === JSON.stringify(b);
266750
- } else if (!isObjectA && !isObjectB) {
266751
- return String(a) === String(b);
266752
- } else {
266753
- return false;
266754
- }
266755
- };
266756
-
266757
- const entry_lib_arrayEquals = function(arrayA, arrayB) {
266758
- arrayA = arrayA || [];
266759
- arrayB = arrayB || [];
266760
-
266761
- if (arrayA.length !== arrayB.length) {
266762
- return false;
266763
- }
266764
-
266765
- for (let i = 0; i < arrayA.length; i++) {
266766
- if (!entry_lib_util_looseEqual(arrayA[i], arrayB[i])) {
266767
- return false;
266768
- }
266769
- }
266770
-
266771
- return true;
266772
- };
266773
-
266774
- const entry_lib_isEqual = function(value1, value2) {
266775
- if (Array.isArray(value1) && Array.isArray(value2)) {
266776
- return entry_lib_arrayEquals(value1, value2);
266777
- }
266778
- return entry_lib_util_looseEqual(value1, value2);
266779
- };
266780
-
266781
- const entry_lib_isEmpty = function(val) {
266782
- // null or undefined
266783
- if (val == null) return true;
266784
-
266785
- if (typeof val === 'boolean') return false;
266786
-
266787
- if (typeof val === 'number') return !val;
266788
-
266789
- if (val instanceof Error) return val.message === '';
266790
-
266791
- switch (Object.prototype.toString.call(val)) {
266792
- // String or Array
266793
- case '[object String]':
266794
- case '[object Array]':
266795
- return !val.length;
266796
-
266797
- // Map or Set or File
266798
- case '[object File]':
266799
- case '[object Map]':
266800
- case '[object Set]': {
266801
- return !val.size;
266802
- }
266803
- // Plain Object
266804
- case '[object Object]': {
266805
- return !Object.keys(val).length;
266806
- }
266807
- }
266808
-
266809
- return false;
266810
- };
266811
-
266812
- function entry_lib_rafThrottle(fn) {
266813
- let locked = false;
266814
- return function(...args) {
266815
- if (locked) return;
266816
- locked = true;
266817
- window.requestAnimationFrame(_ => {
266818
- fn.apply(this, args);
266819
- locked = false;
266820
- });
266821
- };
266822
- }
266823
-
266824
- function entry_lib_objToArray(obj) {
266825
- if (Array.isArray(obj)) {
266826
- return obj;
266827
- }
266828
- return entry_lib_isEmpty(obj) ? [] : [obj];
266829
- }
266830
-
266831
- const entry_lib_isMac = function() {
266832
- return !Vue.prototype.$isServer && /macintosh|mac os x/i.test(navigator.userAgent);
266833
- };
266834
-
266835
266548
  ;// ./packages/locale/format.js
266836
-
266549
+ const entry_lib_format_hasOwnProperty = Object.prototype.hasOwnProperty;
266550
+ const entry_lib_format_hasOwn = function (obj, key) {
266551
+ return entry_lib_format_hasOwnProperty.call(obj, key);
266552
+ };
266837
266553
  const entry_lib_RE_NARGS = /(%|)\{([0-9a-zA-Z_]+)\}/g;
266838
- /**
266839
- * String format template
266840
- * - Inspired:
266841
- * https://github.com/Matt-Esch/string-template/index.js
266842
- */
266843
266554
  /* harmony default export */ function entry_lib_format(Vue) {
266844
- /**
266845
- * template
266846
- *
266847
- * @param {String} string
266848
- * @param {Array} ...args
266849
- * @return {String}
266555
+ /**
266556
+ * template
266557
+ *
266558
+ * @param {String} string
266559
+ * @param {Array} ...args
266560
+ * @return {String}
266850
266561
  */
266851
266562
 
266852
266563
  function template(string, ...args) {
@@ -266861,7 +266572,7 @@ const entry_lib_RE_NARGS = /(%|)\{([0-9a-zA-Z_]+)\}/g;
266861
266572
  if (string[index - 1] === '{' && string[index + match.length] === '}') {
266862
266573
  return i;
266863
266574
  } else {
266864
- result = entry_lib_util_hasOwn(args, i) ? args[i] : null;
266575
+ result = entry_lib_format_hasOwn(args, i) ? args[i] : null;
266865
266576
  if (result === null || result === undefined) {
266866
266577
  return '';
266867
266578
  }
@@ -266876,7 +266587,7 @@ const entry_lib_RE_NARGS = /(%|)\{([0-9a-zA-Z_]+)\}/g;
266876
266587
  * @Description:
266877
266588
  * @Author: 王国火
266878
266589
  * @Date: 2025-02-09 11:18:10
266879
- * @LastEditTime: 2025-03-12 13:11:45
266590
+ * @LastEditTime: 2025-03-26 12:36:05
266880
266591
  * @LastEditors: 王国火
266881
266592
  */
266882
266593
 
@@ -266888,8 +266599,6 @@ const entry_lib_RE_NARGS = /(%|)\{([0-9a-zA-Z_]+)\}/g;
266888
266599
 
266889
266600
 
266890
266601
 
266891
- // Vue.use(VueI18n);
266892
-
266893
266602
  const entry_lib_defaultLang = 'zh-CN';
266894
266603
  const entry_lib_messages = {
266895
266604
  [entry_lib_defaultLang]: {
@@ -266906,6 +266615,7 @@ const entry_lib_messages = {
266906
266615
  const entry_lib_locale_format = entry_lib_format((entry_lib_external_commonjs_vue_commonjs2_vue_root_Vue_default()));
266907
266616
  let entry_lib_lang = entry_lib_messages[entry_lib_defaultLang];
266908
266617
  let entry_lib_i18nHandler = function (key, value) {
266618
+ entry_lib_external_commonjs_vue_commonjs2_vue_root_Vue_default().use(entry_lib_vue_i18n_esm);
266909
266619
  const i18n = new entry_lib_vue_i18n_esm({
266910
266620
  locale: entry_lib_defaultLang,
266911
266621
  // 设置默认语种
@@ -266934,9 +266644,9 @@ const entry_lib_locale_t = function (path, options) {
266934
266644
  const entry_lib_use = function (l) {
266935
266645
  entry_lib_lang = l || entry_lib_lang;
266936
266646
  };
266937
- const entry_lib_i18n = function (fn) {
266647
+ const entry_lib_i18n = function (Vue, fn) {
266938
266648
  entry_lib_i18nHandler = fn || entry_lib_i18nHandler;
266939
- (entry_lib_external_commonjs_vue_commonjs2_vue_root_Vue_default()).prototype.$t = entry_lib_locale_t;
266649
+ if (!fn) Vue.prototype.$t = entry_lib_locale_t;
266940
266650
  };
266941
266651
  /* harmony default export */ var entry_lib_locale = ({
266942
266652
  use: entry_lib_use,
@@ -267061,7 +266771,7 @@ entry_lib_packages_components.map(component => {
267061
266771
  // install组件api
267062
266772
  const entry_lib_packages_install = function (Vue, opts = {}) {
267063
266773
  entry_lib_locale.use(opts.locale);
267064
- entry_lib_locale.i18n(opts.i18n);
266774
+ entry_lib_locale.i18n(Vue, opts.i18n);
267065
266775
  entry_lib_useElementUI(Vue, opts);
267066
266776
  entry_lib_useVxeTable(Vue, opts);
267067
266777
  entry_lib_packages_components.map(component => {