tdesign-mobile-vue
Version:
tdesign-mobile-vue
374 lines (352 loc) • 12 kB
JavaScript
/**
* tdesign v1.7.0
* (c) 2024 TDesign Group
* @license MIT
*/
import './dep-8bf3054e.mjs';
import { _ as _copyObject, k as keysIn_1, a as _cloneBuffer, b as _cloneTypedArray, c as _copyArray, d as _initCloneObject, i as isPlainObject_1, e as _Stack } from './dep-d2161895.mjs';
import { _ as _baseAssignValue } from './dep-10f4d030.mjs';
import { e as eq_1 } from './dep-4931819d.mjs';
import { i as isArguments_1, a as isBuffer$1, b as isTypedArray_1 } from './dep-e57d46f3.mjs';
import { i as isArray_1 } from './dep-019e292f.mjs';
import './dep-32364550.mjs';
import { i as isArrayLikeObject_1, _ as _baseRest } from './dep-154c1925.mjs';
import { i as isFunction_1 } from './dep-91d696ea.mjs';
import './dep-6bc862af.mjs';
import { i as isObject_1 } from './dep-e6c129ab.mjs';
import { _ as _isIterateeCall } from './dep-007f294e.mjs';
import defaultConfig from '../_common/js/global-config/mobile/default-config.mjs';
import zhCn from '../_common/js/global-config/mobile/locale/zh_CN.mjs';
var baseAssignValue = _baseAssignValue,
eq = eq_1;
/**
* This function is like `assignValue` except that it doesn't assign
* `undefined` values.
*
* @private
* @param {Object} object The object to modify.
* @param {string} key The key of the property to assign.
* @param {*} value The value to assign.
*/
function assignMergeValue$2(object, key, value) {
if (value !== undefined && !eq(object[key], value) || value === undefined && !(key in object)) {
baseAssignValue(object, key, value);
}
}
var _assignMergeValue = assignMergeValue$2;
/**
* Creates a base function for methods like `_.forIn` and `_.forOwn`.
*
* @private
* @param {boolean} [fromRight] Specify iterating from right to left.
* @returns {Function} Returns the new base function.
*/
function createBaseFor$1(fromRight) {
return function (object, iteratee, keysFunc) {
var index = -1,
iterable = Object(object),
props = keysFunc(object),
length = props.length;
while (length--) {
var key = props[fromRight ? length : ++index];
if (iteratee(iterable[key], key, iterable) === false) {
break;
}
}
return object;
};
}
var _createBaseFor = createBaseFor$1;
var createBaseFor = _createBaseFor;
/**
* The base implementation of `baseForOwn` which iterates over `object`
* properties returned by `keysFunc` and invokes `iteratee` for each property.
* Iteratee functions may exit iteration early by explicitly returning `false`.
*
* @private
* @param {Object} object The object to iterate over.
* @param {Function} iteratee The function invoked per iteration.
* @param {Function} keysFunc The function to get the keys of `object`.
* @returns {Object} Returns `object`.
*/
var baseFor$1 = createBaseFor();
var _baseFor = baseFor$1;
/**
* Gets the value at `key`, unless `key` is "__proto__" or "constructor".
*
* @private
* @param {Object} object The object to query.
* @param {string} key The key of the property to get.
* @returns {*} Returns the property value.
*/
function safeGet$2(object, key) {
if (key === 'constructor' && typeof object[key] === 'function') {
return;
}
if (key == '__proto__') {
return;
}
return object[key];
}
var _safeGet = safeGet$2;
var copyObject = _copyObject,
keysIn$1 = keysIn_1;
/**
* Converts `value` to a plain object flattening inherited enumerable string
* keyed properties of `value` to own properties of the plain object.
*
* @static
* @memberOf _
* @since 3.0.0
* @category Lang
* @param {*} value The value to convert.
* @returns {Object} Returns the converted plain object.
* @example
*
* function Foo() {
* this.b = 2;
* }
*
* Foo.prototype.c = 3;
*
* _.assign({ 'a': 1 }, new Foo);
* // => { 'a': 1, 'b': 2 }
*
* _.assign({ 'a': 1 }, _.toPlainObject(new Foo));
* // => { 'a': 1, 'b': 2, 'c': 3 }
*/
function toPlainObject$1(value) {
return copyObject(value, keysIn$1(value));
}
var toPlainObject_1 = toPlainObject$1;
var assignMergeValue$1 = _assignMergeValue,
cloneBuffer = _cloneBuffer.exports,
cloneTypedArray = _cloneTypedArray,
copyArray = _copyArray,
initCloneObject = _initCloneObject,
isArguments = isArguments_1,
isArray = isArray_1,
isArrayLikeObject = isArrayLikeObject_1,
isBuffer = isBuffer$1.exports,
isFunction = isFunction_1,
isObject$1 = isObject_1,
isPlainObject = isPlainObject_1,
isTypedArray = isTypedArray_1,
safeGet$1 = _safeGet,
toPlainObject = toPlainObject_1;
/**
* A specialized version of `baseMerge` for arrays and objects which performs
* deep merges and tracks traversed objects enabling objects with circular
* references to be merged.
*
* @private
* @param {Object} object The destination object.
* @param {Object} source The source object.
* @param {string} key The key of the value to merge.
* @param {number} srcIndex The index of `source`.
* @param {Function} mergeFunc The function to merge values.
* @param {Function} [customizer] The function to customize assigned values.
* @param {Object} [stack] Tracks traversed source values and their merged
* counterparts.
*/
function baseMergeDeep$1(object, source, key, srcIndex, mergeFunc, customizer, stack) {
var objValue = safeGet$1(object, key),
srcValue = safeGet$1(source, key),
stacked = stack.get(srcValue);
if (stacked) {
assignMergeValue$1(object, key, stacked);
return;
}
var newValue = customizer ? customizer(objValue, srcValue, key + '', object, source, stack) : undefined;
var isCommon = newValue === undefined;
if (isCommon) {
var isArr = isArray(srcValue),
isBuff = !isArr && isBuffer(srcValue),
isTyped = !isArr && !isBuff && isTypedArray(srcValue);
newValue = srcValue;
if (isArr || isBuff || isTyped) {
if (isArray(objValue)) {
newValue = objValue;
} else if (isArrayLikeObject(objValue)) {
newValue = copyArray(objValue);
} else if (isBuff) {
isCommon = false;
newValue = cloneBuffer(srcValue, true);
} else if (isTyped) {
isCommon = false;
newValue = cloneTypedArray(srcValue, true);
} else {
newValue = [];
}
} else if (isPlainObject(srcValue) || isArguments(srcValue)) {
newValue = objValue;
if (isArguments(objValue)) {
newValue = toPlainObject(objValue);
} else if (!isObject$1(objValue) || isFunction(objValue)) {
newValue = initCloneObject(srcValue);
}
} else {
isCommon = false;
}
}
if (isCommon) {
// Recursively merge objects and arrays (susceptible to call stack limits).
stack.set(srcValue, newValue);
mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
stack['delete'](srcValue);
}
assignMergeValue$1(object, key, newValue);
}
var _baseMergeDeep = baseMergeDeep$1;
var Stack = _Stack,
assignMergeValue = _assignMergeValue,
baseFor = _baseFor,
baseMergeDeep = _baseMergeDeep,
isObject = isObject_1,
keysIn = keysIn_1,
safeGet = _safeGet;
/**
* The base implementation of `_.merge` without support for multiple sources.
*
* @private
* @param {Object} object The destination object.
* @param {Object} source The source object.
* @param {number} srcIndex The index of `source`.
* @param {Function} [customizer] The function to customize merged values.
* @param {Object} [stack] Tracks traversed source values and their merged
* counterparts.
*/
function baseMerge$2(object, source, srcIndex, customizer, stack) {
if (object === source) {
return;
}
baseFor(source, function (srcValue, key) {
stack || (stack = new Stack());
if (isObject(srcValue)) {
baseMergeDeep(object, source, key, srcIndex, baseMerge$2, customizer, stack);
} else {
var newValue = customizer ? customizer(safeGet(object, key), srcValue, key + '', object, source, stack) : undefined;
if (newValue === undefined) {
newValue = srcValue;
}
assignMergeValue(object, key, newValue);
}
}, keysIn);
}
var _baseMerge = baseMerge$2;
var baseRest = _baseRest,
isIterateeCall = _isIterateeCall;
/**
* Creates a function like `_.assign`.
*
* @private
* @param {Function} assigner The function to assign values.
* @returns {Function} Returns the new assigner function.
*/
function createAssigner$2(assigner) {
return baseRest(function (object, sources) {
var index = -1,
length = sources.length,
customizer = length > 1 ? sources[length - 1] : undefined,
guard = length > 2 ? sources[2] : undefined;
customizer = assigner.length > 3 && typeof customizer == 'function' ? (length--, customizer) : undefined;
if (guard && isIterateeCall(sources[0], sources[1], guard)) {
customizer = length < 3 ? undefined : customizer;
length = 1;
}
object = Object(object);
while (++index < length) {
var source = sources[index];
if (source) {
assigner(object, source, index, customizer);
}
}
return object;
});
}
var _createAssigner = createAssigner$2;
var baseMerge$1 = _baseMerge,
createAssigner$1 = _createAssigner;
/**
* This method is like `_.merge` except that it accepts `customizer` which
* is invoked to produce the merged values of the destination and source
* properties. If `customizer` returns `undefined`, merging is handled by the
* method instead. The `customizer` is invoked with six arguments:
* (objValue, srcValue, key, object, source, stack).
*
* **Note:** This method mutates `object`.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Object
* @param {Object} object The destination object.
* @param {...Object} sources The source objects.
* @param {Function} customizer The function to customize assigned values.
* @returns {Object} Returns `object`.
* @example
*
* function customizer(objValue, srcValue) {
* if (_.isArray(objValue)) {
* return objValue.concat(srcValue);
* }
* }
*
* var object = { 'a': [1], 'b': [2] };
* var other = { 'a': [3], 'b': [4] };
*
* _.mergeWith(object, other, customizer);
* // => { 'a': [1, 3], 'b': [2, 4] }
*/
var mergeWith$1 = createAssigner$1(function (object, source, srcIndex, customizer) {
baseMerge$1(object, source, srcIndex, customizer);
});
var mergeWith_1 = mergeWith$1;
var baseMerge = _baseMerge,
createAssigner = _createAssigner;
/**
* This method is like `_.assign` except that it recursively merges own and
* inherited enumerable string keyed properties of source objects into the
* destination object. Source properties that resolve to `undefined` are
* skipped if a destination value exists. Array and plain object properties
* are merged recursively. Other objects and value types are overridden by
* assignment. Source objects are applied from left to right. Subsequent
* sources overwrite property assignments of previous sources.
*
* **Note:** This method mutates `object`.
*
* @static
* @memberOf _
* @since 0.5.0
* @category Object
* @param {Object} object The destination object.
* @param {...Object} [sources] The source objects.
* @returns {Object} Returns `object`.
* @example
*
* var object = {
* 'a': [{ 'b': 2 }, { 'd': 4 }]
* };
*
* var other = {
* 'a': [{ 'c': 3 }, { 'e': 5 }]
* };
*
* _.merge(object, other);
* // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }
*/
var merge = createAssigner(function (object, source, srcIndex) {
baseMerge(object, source, srcIndex);
});
var merge_1 = merge;
var defaultGlobalConfig = merge_1(defaultConfig, zhCn);
var configProviderInjectKey = Symbol("configProvide");
var mergeWith = function mergeWith(defaultGlobalConfig2, injectConfig) {
return mergeWith_1(defaultGlobalConfig2, injectConfig, function (objValue, srcValue) {
if (isArray_1(objValue)) {
return srcValue;
}
});
};
export { _createAssigner as _, mergeWith as a, configProviderInjectKey as c, defaultGlobalConfig as d, merge_1 as m };
//# sourceMappingURL=dep-ac139980.mjs.map