ant-design-vue
Version:
An enterprise-class UI design language and Vue-based implementation
311 lines (247 loc) • 10.3 kB
JavaScript
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
function _toArray(arr) { return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest(); }
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
import { warning } from '../../vc-util/warning';
import { cloneVNode, isVNode } from 'vue';
import { toArray } from './commonUtil';
function getKey(data, index) {
var key = data.key;
var value;
if ('value' in data) {
value = data.value;
}
if (key !== null && key !== undefined) {
return key;
}
if (value !== undefined) {
return value;
}
return "rc-index-key-".concat(index);
}
/**
* Flat options into flatten list.
* We use `optionOnly` here is aim to avoid user use nested option group.
* Here is simply set `key` to the index if not provided.
*/
export function flattenOptions(options) {
var flattenList = [];
function dig(list, isGroupOption) {
list.forEach(function (data) {
if (isGroupOption || !('options' in data)) {
// Option
flattenList.push({
key: getKey(data, flattenList.length),
groupOption: isGroupOption,
data: data
});
} else {
// Option Group
flattenList.push({
key: getKey(data, flattenList.length),
group: true,
data: data
});
dig(data.options, true);
}
});
}
dig(options, false);
return flattenList;
}
/**
* Inject `props` into `option` for legacy usage
*/
function injectPropsWithOption(option) {
var newOption = _extends({}, option);
if (!('props' in newOption)) {
Object.defineProperty(newOption, 'props', {
get: function get() {
warning(false, 'Return type is option instead of Option instance. Please read value directly instead of reading from `props`.');
return newOption;
}
});
}
return newOption;
}
export function findValueOption(values, options) {
var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
_ref$prevValueOptions = _ref.prevValueOptions,
prevValueOptions = _ref$prevValueOptions === void 0 ? [] : _ref$prevValueOptions;
var optionMap = new Map();
options.forEach(function (flattenItem) {
if (!flattenItem.group) {
var data = flattenItem.data; // Check if match
optionMap.set(data.value, data);
}
});
return values.map(function (val) {
var option = optionMap.get(val); // Fallback to try to find prev options
if (!option) {
option = _extends({}, prevValueOptions.find(function (opt) {
return opt._INTERNAL_OPTION_VALUE_ === val;
}));
}
return injectPropsWithOption(option);
});
}
export var getLabeledValue = function getLabeledValue(value, _ref2) {
var options = _ref2.options,
prevValue = _ref2.prevValue,
labelInValue = _ref2.labelInValue,
optionLabelProp = _ref2.optionLabelProp;
var item = findValueOption([value], options)[0];
var result = {
value: value
};
var prevValItem;
var prevValues = toArray(prevValue);
if (labelInValue) {
prevValItem = prevValues.find(function (prevItem) {
if (_typeof(prevItem) === 'object' && 'value' in prevItem) {
return prevItem.value === value;
} // [Legacy] Support `key` as `value`
return prevItem.key === value;
});
}
if (prevValItem && _typeof(prevValItem) === 'object' && 'label' in prevValItem) {
result.label = prevValItem.label;
if (item && typeof prevValItem.label === 'string' && typeof item[optionLabelProp] === 'string' && prevValItem.label.trim() !== item[optionLabelProp].trim()) {
warning(false, '`label` of `value` is not same as `label` in Select options.');
}
} else if (item && optionLabelProp in item) {
if (Array.isArray(item[optionLabelProp])) {
result.label = isVNode(item[optionLabelProp][0]) ? cloneVNode(item[optionLabelProp][0]) : item[optionLabelProp];
} else {
result.label = item[optionLabelProp];
}
} else {
result.label = value;
} // Used for motion control
result.key = result.value;
return result;
};
function toRawString(content) {
return toArray(content).map(function (item) {
var _a, _b;
if (isVNode(item)) {
return ((_a = item === null || item === void 0 ? void 0 : item.el) === null || _a === void 0 ? void 0 : _a.innerText) || ((_b = item === null || item === void 0 ? void 0 : item.el) === null || _b === void 0 ? void 0 : _b.wholeText);
} else {
return item;
}
}).join('');
}
/** Filter single option if match the search text */
function getFilterFunction(optionFilterProp) {
return function (searchValue, option) {
var lowerSearchText = searchValue.toLowerCase(); // Group label search
if ('options' in option) {
return toRawString(option.label).toLowerCase().includes(lowerSearchText);
} // Option value search
var rawValue = option[optionFilterProp];
var value = toRawString(rawValue).toLowerCase();
return value.includes(lowerSearchText);
};
}
/** Filter options and return a new options by the search text */
export function filterOptions(searchValue, options, _ref3) {
var optionFilterProp = _ref3.optionFilterProp,
filterOption = _ref3.filterOption;
var filteredOptions = [];
var filterFunc;
if (filterOption === false) {
return options;
}
if (typeof filterOption === 'function') {
filterFunc = filterOption;
} else {
filterFunc = getFilterFunction(optionFilterProp);
}
options.forEach(function (item) {
// Group should check child options
if ('options' in item) {
// Check group first
var matchGroup = filterFunc(searchValue, item);
if (matchGroup) {
filteredOptions.push(item);
} else {
// Check option
var subOptions = item.options.filter(function (subItem) {
return filterFunc(searchValue, subItem);
});
if (subOptions.length) {
filteredOptions.push(_extends(_extends({}, item), {
options: subOptions
}));
}
}
return;
}
if (filterFunc(searchValue, injectPropsWithOption(item))) {
filteredOptions.push(item);
}
});
return filteredOptions;
}
export function getSeparatedContent(text, tokens) {
if (!tokens || !tokens.length) {
return null;
}
var match = false;
function separate(str, _ref4) {
var _ref5 = _toArray(_ref4),
token = _ref5[0],
restTokens = _ref5.slice(1);
if (!token) {
return [str];
}
var list = str.split(token);
match = match || list.length > 1;
return list.reduce(function (prevList, unitStr) {
return [].concat(_toConsumableArray(prevList), _toConsumableArray(separate(unitStr, restTokens)));
}, []).filter(function (unit) {
return unit;
});
}
var list = separate(text, tokens);
return match ? list : null;
}
export function isValueDisabled(value, options) {
var option = findValueOption([value], options)[0];
return option.disabled;
}
/**
* `tags` mode should fill un-list item into the option list
*/
export function fillOptionsWithMissingValue(options, value, optionLabelProp, labelInValue) {
var values = toArray(value).slice().sort();
var cloneOptions = _toConsumableArray(options); // Convert options value to set
var optionValues = new Set();
options.forEach(function (opt) {
if (opt.options) {
opt.options.forEach(function (subOpt) {
optionValues.add(subOpt.value);
});
} else {
optionValues.add(opt.value);
}
}); // Fill missing value
values.forEach(function (item) {
var val = labelInValue ? item.value : item;
if (!optionValues.has(val)) {
var _ref6;
cloneOptions.push(labelInValue ? (_ref6 = {}, _defineProperty(_ref6, optionLabelProp, item.label), _defineProperty(_ref6, "value", val), _ref6) : {
value: val
});
}
});
return cloneOptions;
}