first commit

frontend/node_modules/rc-field-form/es/utils/valueUtil.js

@@ -0,0 +1,117 @@
+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;
+}