117 lines
4.0 KiB
JavaScript
117 lines
4.0 KiB
JavaScript
import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
|
|
import _typeof from "@babel/runtime/helpers/esm/typeof";
|
|
import getValue from "rc-util/es/utils/get";
|
|
import setValue from "rc-util/es/utils/set";
|
|
import { toArray } from "./typeUtil";
|
|
export { getValue, setValue };
|
|
|
|
/**
|
|
* Convert name to internal supported format.
|
|
* This function should keep since we still thinking if need support like `a.b.c` format.
|
|
* 'a' => ['a']
|
|
* 123 => [123]
|
|
* ['a', 123] => ['a', 123]
|
|
*/
|
|
export function getNamePath(path) {
|
|
return toArray(path);
|
|
}
|
|
export function cloneByNamePathList(store, namePathList) {
|
|
var newStore = {};
|
|
namePathList.forEach(function (namePath) {
|
|
var value = getValue(store, namePath);
|
|
newStore = setValue(newStore, namePath, value);
|
|
});
|
|
return newStore;
|
|
}
|
|
|
|
/**
|
|
* Check if `namePathList` includes `namePath`.
|
|
* @param namePathList A list of `InternalNamePath[]`
|
|
* @param namePath Compare `InternalNamePath`
|
|
* @param partialMatch True will make `[a, b]` match `[a, b, c]`
|
|
*/
|
|
export function containsNamePath(namePathList, namePath) {
|
|
var partialMatch = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
|
|
return namePathList && namePathList.some(function (path) {
|
|
return matchNamePath(namePath, path, partialMatch);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Check if `namePath` is super set or equal of `subNamePath`.
|
|
* @param namePath A list of `InternalNamePath[]`
|
|
* @param subNamePath Compare `InternalNamePath`
|
|
* @param partialMatch True will make `[a, b]` match `[a, b, c]`
|
|
*/
|
|
export function matchNamePath(namePath, subNamePath) {
|
|
var partialMatch = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
|
|
if (!namePath || !subNamePath) {
|
|
return false;
|
|
}
|
|
if (!partialMatch && namePath.length !== subNamePath.length) {
|
|
return false;
|
|
}
|
|
return subNamePath.every(function (nameUnit, i) {
|
|
return namePath[i] === nameUnit;
|
|
});
|
|
}
|
|
|
|
// Like `shallowEqual`, but we not check the data which may cause re-render
|
|
|
|
export function isSimilar(source, target) {
|
|
if (source === target) {
|
|
return true;
|
|
}
|
|
if (!source && target || source && !target) {
|
|
return false;
|
|
}
|
|
if (!source || !target || _typeof(source) !== 'object' || _typeof(target) !== 'object') {
|
|
return false;
|
|
}
|
|
var sourceKeys = Object.keys(source);
|
|
var targetKeys = Object.keys(target);
|
|
var keys = new Set([].concat(sourceKeys, targetKeys));
|
|
return _toConsumableArray(keys).every(function (key) {
|
|
var sourceValue = source[key];
|
|
var targetValue = target[key];
|
|
if (typeof sourceValue === 'function' && typeof targetValue === 'function') {
|
|
return true;
|
|
}
|
|
return sourceValue === targetValue;
|
|
});
|
|
}
|
|
export function defaultGetValueFromEvent(valuePropName) {
|
|
var event = arguments.length <= 1 ? undefined : arguments[1];
|
|
if (event && event.target && _typeof(event.target) === 'object' && valuePropName in event.target) {
|
|
return event.target[valuePropName];
|
|
}
|
|
return event;
|
|
}
|
|
|
|
/**
|
|
* Moves an array item from one position in an array to another.
|
|
*
|
|
* Note: This is a pure function so a new array will be returned, instead
|
|
* of altering the array argument.
|
|
*
|
|
* @param array Array in which to move an item. (required)
|
|
* @param moveIndex The index of the item to move. (required)
|
|
* @param toIndex The index to move item at moveIndex to. (required)
|
|
*/
|
|
export function move(array, moveIndex, toIndex) {
|
|
var length = array.length;
|
|
if (moveIndex < 0 || moveIndex >= length || toIndex < 0 || toIndex >= length) {
|
|
return array;
|
|
}
|
|
var item = array[moveIndex];
|
|
var diff = moveIndex - toIndex;
|
|
if (diff > 0) {
|
|
// move left
|
|
return [].concat(_toConsumableArray(array.slice(0, toIndex)), [item], _toConsumableArray(array.slice(toIndex, moveIndex)), _toConsumableArray(array.slice(moveIndex + 1, length)));
|
|
}
|
|
if (diff < 0) {
|
|
// move right
|
|
return [].concat(_toConsumableArray(array.slice(0, moveIndex)), _toConsumableArray(array.slice(moveIndex + 1, toIndex + 1)), [item], _toConsumableArray(array.slice(toIndex + 1, length)));
|
|
}
|
|
return array;
|
|
} |