antdv-eoi
Version:
An enterprise-class UI design language and Vue-based implementation
281 lines (232 loc) • 7.88 kB
JavaScript
import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
import _toArray from "@babel/runtime/helpers/esm/toArray";
import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
import _typeof from "@babel/runtime/helpers/esm/typeof";
import _extends from "@babel/runtime/helpers/esm/extends";
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,
prevValueMap = _ref2.prevValueMap,
labelInValue = _ref2.labelInValue,
optionLabelProp = _ref2.optionLabelProp;
var item = findValueOption([value], options)[0];
var result = {
value: value
};
var prevValItem = labelInValue ? prevValueMap.get(value) : undefined;
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;
result.isCacheable = true;
} // 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 _toConsumableArray(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;
}