Latest updates from IceHrmPro

web/node_modules/rc-tree-select/es/hooks/useKeyValueMap.d.ts

@@ -0,0 +1,6 @@
+import { FlattenDataNode } from '../interface';
+/**
+ * Return cached Key Value map with DataNode.
+ * Only re-calculate when `flattenOptions` changed.
+ */
+export default function useKeyValueMap(flattenOptions: FlattenDataNode[]): Map<string | number, FlattenDataNode>[];

web/node_modules/rc-tree-select/es/hooks/useKeyValueMap.js

@@ -0,0 +1,18 @@
+import React from 'react';
+/**
+ * Return cached Key Value map with DataNode.
+ * Only re-calculate when `flattenOptions` changed.
+ */
+
+export default function useKeyValueMap(flattenOptions) {
+  return React.useMemo(function () {
+    var cacheKeyMap = new Map();
+    var cacheValueMap = new Map(); // Cache options by key
+
+    flattenOptions.forEach(function (dataNode) {
+      cacheKeyMap.set(dataNode.key, dataNode);
+      cacheValueMap.set(dataNode.data.value, dataNode);
+    });
+    return [cacheKeyMap, cacheValueMap];
+  }, [flattenOptions]);
+}

web/node_modules/rc-tree-select/es/hooks/useKeyValueMapping.d.ts

@@ -0,0 +1,4 @@
+import { FlattenDataNode, Key, RawValueType } from '../interface';
+export declare type SkipType = null | 'select' | 'checkbox';
+export declare function isDisabled(dataNode: FlattenDataNode, skipType: SkipType): boolean;
+export default function useKeyValueMapping(cacheKeyMap: Map<Key, FlattenDataNode>, cacheValueMap: Map<RawValueType, FlattenDataNode>): [(key: Key, skipType?: SkipType) => FlattenDataNode, (value: RawValueType, skipType?: SkipType) => FlattenDataNode];

web/node_modules/rc-tree-select/es/hooks/useKeyValueMapping.js

@@ -0,0 +1,43 @@
+import React from 'react';
+export function isDisabled(dataNode, skipType) {
+  if (!dataNode) {
+    return true;
+  }
+
+  var _dataNode$data = dataNode.data,
+      disabled = _dataNode$data.disabled,
+      disableCheckbox = _dataNode$data.disableCheckbox;
+
+  switch (skipType) {
+    case 'select':
+      return disabled;
+
+    case 'checkbox':
+      return disabled || disableCheckbox;
+  }
+
+  return false;
+}
+export default function useKeyValueMapping(cacheKeyMap, cacheValueMap) {
+  var getEntityByKey = React.useCallback(function (key) {
+    var skipType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'select';
+    var dataNode = cacheKeyMap.get(key);
+
+    if (isDisabled(dataNode, skipType)) {
+      return null;
+    }
+
+    return dataNode;
+  }, [cacheKeyMap]);
+  var getEntityByValue = React.useCallback(function (value) {
+    var skipType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'select';
+    var dataNode = cacheValueMap.get(value);
+
+    if (isDisabled(dataNode, skipType)) {
+      return null;
+    }
+
+    return dataNode;
+  }, [cacheValueMap]);
+  return [getEntityByKey, getEntityByValue];
+}

web/node_modules/rc-tree-select/es/hooks/useSelectValues.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import { DefaultValueType } from 'rc-select/lib/interface/generator';
+import { DataEntity } from 'rc-tree/lib/interface';
+import { RawValueType, FlattenDataNode, Key, LabelValueType, DataNode } from '../interface';
+import { SkipType } from './useKeyValueMapping';
+import { CheckedStrategy } from '../utils/strategyUtil';
+interface Config {
+    treeConduction: boolean;
+    /** Current `value` of TreeSelect */
+    value: DefaultValueType;
+    showCheckedStrategy: CheckedStrategy;
+    conductKeyEntities: Record<Key, DataEntity>;
+    getEntityByKey: (key: Key, skipType?: SkipType) => FlattenDataNode;
+    getEntityByValue: (value: RawValueType, skipType?: SkipType) => FlattenDataNode;
+    getLabelProp: (node: DataNode) => React.ReactNode;
+}
+/** Return  */
+export default function useSelectValues(rawValues: RawValueType[], { value, getEntityByValue, getEntityByKey, treeConduction, showCheckedStrategy, conductKeyEntities, getLabelProp, }: Config): LabelValueType[];
+export {};

web/node_modules/rc-tree-select/es/hooks/useSelectValues.js

@@ -0,0 +1,30 @@
+import React from 'react';
+import { getRawValueLabeled } from '../utils/valueUtil';
+import { formatStrategyKeys } from '../utils/strategyUtil';
+/** Return  */
+
+export default function useSelectValues(rawValues, _ref) {
+  var value = _ref.value,
+      getEntityByValue = _ref.getEntityByValue,
+      getEntityByKey = _ref.getEntityByKey,
+      treeConduction = _ref.treeConduction,
+      showCheckedStrategy = _ref.showCheckedStrategy,
+      conductKeyEntities = _ref.conductKeyEntities,
+      getLabelProp = _ref.getLabelProp;
+  return React.useMemo(function () {
+    var mergedRawValues = rawValues;
+
+    if (treeConduction) {
+      var rawKeys = formatStrategyKeys(rawValues.map(function (val) {
+        var entity = getEntityByValue(val);
+        return entity ? entity.key : val;
+      }), showCheckedStrategy, conductKeyEntities);
+      mergedRawValues = rawKeys.map(function (key) {
+        var entity = getEntityByKey(key);
+        return entity ? entity.data.value : key;
+      });
+    }
+
+    return getRawValueLabeled(mergedRawValues, value, getEntityByValue, getLabelProp);
+  }, [rawValues, value, treeConduction, showCheckedStrategy, getEntityByValue]);
+}

web/node_modules/rc-tree-select/es/hooks/useTreeData.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { DataNode, InnerDataNode, SimpleModeConfig } from '../interface';
+/**
+ * Convert `treeData` or `children` into formatted `treeData`.
+ * Will not re-calculate if `treeData` or `children` not change.
+ */
+export default function useTreeData(treeData: DataNode[], children: React.ReactNode, { getLabelProp, simpleMode, }: {
+    getLabelProp: (node: DataNode) => React.ReactNode;
+    simpleMode: boolean | SimpleModeConfig;
+}): InnerDataNode[];

web/node_modules/rc-tree-select/es/hooks/useTreeData.js

@@ -0,0 +1,116 @@
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+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; }
+
+import React from 'react';
+import warning from "rc-util/es/warning";
+import { convertChildrenToData } from '../utils/legacyUtil';
+var MAX_WARNING_TIMES = 10;
+
+function parseSimpleTreeData(treeData, _ref) {
+  var id = _ref.id,
+      pId = _ref.pId,
+      rootPId = _ref.rootPId;
+  var keyNodes = {};
+  var rootNodeList = []; // Fill in the map
+
+  var nodeList = treeData.map(function (node) {
+    var clone = _objectSpread({}, node);
+
+    var key = clone[id];
+    keyNodes[key] = clone;
+    clone.key = clone.key || key;
+    return clone;
+  }); // Connect tree
+
+  nodeList.forEach(function (node) {
+    var parentKey = node[pId];
+    var parent = keyNodes[parentKey]; // Fill parent
+
+    if (parent) {
+      parent.children = parent.children || [];
+      parent.children.push(node);
+    } // Fill root tree node
+
+
+    if (parentKey === rootPId || !parent && rootPId === null) {
+      rootNodeList.push(node);
+    }
+  });
+  return rootNodeList;
+}
+/**
+ * Format `treeData` with `value` & `key` which is used for calculation
+ */
+
+
+function formatTreeData(treeData, getLabelProp) {
+  var warningTimes = 0;
+  var valueSet = new Set();
+
+  function dig(dataNodes) {
+    return (dataNodes || []).map(function (node) {
+      var key = node.key,
+          value = node.value,
+          children = node.children,
+          rest = _objectWithoutProperties(node, ["key", "value", "children"]);
+
+      var mergedValue = 'value' in node ? value : key;
+
+      var dataNode = _objectSpread({}, rest, {
+        key: key !== null && key !== undefined ? key : mergedValue,
+        value: mergedValue,
+        title: getLabelProp(node)
+      }); // Check `key` & `value` and warning user
+
+
+      if (process.env.NODE_ENV !== 'production') {
+        if (key !== null && key !== undefined && value !== undefined && String(key) !== String(value) && warningTimes < MAX_WARNING_TIMES) {
+          warningTimes += 1;
+          warning(false, "`key` or `value` with TreeNode must be the same or you can remove one of them. key: ".concat(key, ", value: ").concat(value, "."));
+        }
+
+        warning(!valueSet.has(value), "Same `value` exist in the tree: ".concat(value));
+        valueSet.add(value);
+      }
+
+      if ('children' in node) {
+        dataNode.children = dig(children);
+      }
+
+      return dataNode;
+    });
+  }
+
+  return dig(treeData);
+}
+/**
+ * Convert `treeData` or `children` into formatted `treeData`.
+ * Will not re-calculate if `treeData` or `children` not change.
+ */
+
+
+export default function useTreeData(treeData, children, _ref2) {
+  var getLabelProp = _ref2.getLabelProp,
+      simpleMode = _ref2.simpleMode;
+  var cacheRef = React.useRef({});
+
+  if (treeData) {
+    cacheRef.current.formatTreeData = cacheRef.current.treeData === treeData ? cacheRef.current.formatTreeData : formatTreeData(simpleMode ? parseSimpleTreeData(treeData, _objectSpread({
+      id: 'id',
+      pId: 'pId',
+      rootPId: null
+    }, simpleMode !== true ? simpleMode : {})) : treeData, getLabelProp);
+    cacheRef.current.treeData = treeData;
+  } else {
+    cacheRef.current.formatTreeData = cacheRef.current.children === children ? cacheRef.current.formatTreeData : formatTreeData(convertChildrenToData(children), getLabelProp);
+  }
+
+  return cacheRef.current.formatTreeData;
+}