Latest updates from IceHrmPro

web/node_modules/rc-tree-select/lib/utils/legacyUtil.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { DataNode, LegacyDataNode, ChangeEventExtra, InnerDataNode, RawValueType } from '../interface';
+export declare function convertChildrenToData(nodes: React.ReactNode): DataNode[];
+export declare function fillLegacyProps(dataNode: DataNode): LegacyDataNode;
+export declare function fillAdditionalInfo(extra: ChangeEventExtra, triggerValue: RawValueType, checkedValues: RawValueType[], treeData: InnerDataNode[], showPosition: boolean): void;

web/node_modules/rc-tree-select/lib/utils/legacyUtil.js

@@ -0,0 +1,157 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertChildrenToData = convertChildrenToData;
+exports.fillLegacyProps = fillLegacyProps;
+exports.fillAdditionalInfo = fillAdditionalInfo;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _toArray = _interopRequireDefault(require("rc-util/lib/Children/toArray"));
+
+var _warning = _interopRequireDefault(require("rc-util/lib/warning"));
+
+var _TreeNode = _interopRequireDefault(require("../TreeNode"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+
+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 convertChildrenToData(nodes) {
+  return (0, _toArray.default)(nodes).map(function (node) {
+    if (!_react.default.isValidElement(node) || !node.type) {
+      return null;
+    }
+
+    var key = node.key,
+        _node$props = node.props,
+        children = _node$props.children,
+        value = _node$props.value,
+        restProps = _objectWithoutProperties(_node$props, ["children", "value"]);
+
+    var data = _objectSpread({
+      key: key,
+      value: value
+    }, restProps);
+
+    var childData = convertChildrenToData(children);
+
+    if (childData.length) {
+      data.children = childData;
+    }
+
+    return data;
+  }).filter(function (data) {
+    return data;
+  });
+}
+
+function fillLegacyProps(dataNode) {
+  // Skip if not dataNode exist
+  if (!dataNode) {
+    return dataNode;
+  }
+
+  var cloneNode = _objectSpread({}, dataNode);
+
+  if (!('props' in cloneNode)) {
+    Object.defineProperty(cloneNode, 'props', {
+      get: function get() {
+        (0, _warning.default)(false, 'New `rc-tree-select` not support return node instance as argument anymore. Please consider to remove `props` access.');
+        return cloneNode;
+      }
+    });
+  }
+
+  return cloneNode;
+}
+
+function fillAdditionalInfo(extra, triggerValue, checkedValues, treeData, showPosition) {
+  var triggerNode = null;
+  var nodeList = null;
+
+  function generateMap() {
+    function dig(list) {
+      var level = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '0';
+      var parentIncluded = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+      return list.map(function (dataNode, index) {
+        var pos = "".concat(level, "-").concat(index);
+        var included = checkedValues.includes(dataNode.value);
+        var children = dig(dataNode.children || [], pos, included);
+
+        var node = _react.default.createElement(_TreeNode.default, Object.assign({}, dataNode), children.map(function (child) {
+          return child.node;
+        })); // Link with trigger node
+
+
+        if (triggerValue === dataNode.value) {
+          triggerNode = node;
+        }
+
+        if (included) {
+          var checkedNode = {
+            pos: pos,
+            node: node,
+            children: children
+          };
+
+          if (!parentIncluded) {
+            nodeList.push(checkedNode);
+          }
+
+          return checkedNode;
+        }
+
+        return null;
+      }).filter(function (node) {
+        return node;
+      });
+    }
+
+    if (!nodeList) {
+      nodeList = [];
+      dig(treeData); // Sort to keep the checked node length
+
+      nodeList.sort(function (_ref, _ref2) {
+        var val1 = _ref.node.props.value;
+        var val2 = _ref2.node.props.value;
+        var index1 = checkedValues.indexOf(val1);
+        var index2 = checkedValues.indexOf(val2);
+        return index1 - index2;
+      });
+    }
+  }
+
+  Object.defineProperty(extra, 'triggerNode', {
+    get: function get() {
+      (0, _warning.default)(false, '`triggerNode` is deprecated. Please consider decoupling data with node.');
+      generateMap();
+      return triggerNode;
+    }
+  });
+  Object.defineProperty(extra, 'allCheckedNodes', {
+    get: function get() {
+      (0, _warning.default)(false, '`allCheckedNodes` is deprecated. Please consider decoupling data with node.');
+      generateMap();
+
+      if (showPosition) {
+        return nodeList;
+      }
+
+      return nodeList.map(function (_ref3) {
+        var node = _ref3.node;
+        return node;
+      });
+    }
+  });
+}

web/node_modules/rc-tree-select/lib/utils/strategyUtil.d.ts

@@ -0,0 +1,7 @@
+import { DataEntity } from 'rc-tree/lib/interface';
+import { RawValueType, Key } from '../interface';
+export declare const SHOW_ALL = "SHOW_ALL";
+export declare const SHOW_PARENT = "SHOW_PARENT";
+export declare const SHOW_CHILD = "SHOW_CHILD";
+export declare type CheckedStrategy = typeof SHOW_ALL | typeof SHOW_PARENT | typeof SHOW_CHILD;
+export declare function formatStrategyKeys(keys: Key[], strategy: CheckedStrategy, keyEntities: Record<Key, DataEntity>): RawValueType[];

web/node_modules/rc-tree-select/lib/utils/strategyUtil.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatStrategyKeys = formatStrategyKeys;
+exports.SHOW_CHILD = exports.SHOW_PARENT = exports.SHOW_ALL = void 0;
+
+var _valueUtil = require("./valueUtil");
+
+var SHOW_ALL = 'SHOW_ALL';
+exports.SHOW_ALL = SHOW_ALL;
+var SHOW_PARENT = 'SHOW_PARENT';
+exports.SHOW_PARENT = SHOW_PARENT;
+var SHOW_CHILD = 'SHOW_CHILD';
+exports.SHOW_CHILD = SHOW_CHILD;
+
+function formatStrategyKeys(keys, strategy, keyEntities) {
+  var keySet = new Set(keys);
+
+  if (strategy === SHOW_CHILD) {
+    return keys.filter(function (key) {
+      var entity = keyEntities[key];
+
+      if (entity && entity.children && entity.children.every(function (_ref) {
+        var node = _ref.node;
+        return (0, _valueUtil.isCheckDisabled)(node) || keySet.has(node.key);
+      })) {
+        return false;
+      }
+
+      return true;
+    });
+  }
+
+  if (strategy === SHOW_PARENT) {
+    return keys.filter(function (key) {
+      var entity = keyEntities[key];
+      var parent = entity ? entity.parent : null;
+
+      if (parent && !(0, _valueUtil.isCheckDisabled)(parent.node) && keySet.has(parent.node.key)) {
+        return false;
+      }
+
+      return true;
+    });
+  }
+
+  return keys;
+}

web/node_modules/rc-tree-select/lib/utils/valueUtil.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="react" />
+import { FilterFunc } from 'rc-select/lib/interface/generator';
+import { FlattenDataNode, RawValueType, DataNode, DefaultValueType, LabelValueType, LegacyDataNode } from '../interface';
+import { SkipType } from '../hooks/useKeyValueMapping';
+export declare function toArray<T>(value: T | T[]): T[];
+export declare function findValueOption(values: RawValueType[], options: FlattenDataNode[]): DataNode[];
+export declare function isValueDisabled(value: RawValueType, options: FlattenDataNode[]): boolean;
+export declare function isCheckDisabled(node: DataNode): boolean;
+/**
+ * Before reuse `rc-tree` logic, we need to add key since TreeSelect use `value` instead of `key`.
+ */
+export declare function flattenOptions(options: DataNode[]): FlattenDataNode[];
+/** Filter options and return a new options by the search text */
+export declare function filterOptions(searchValue: string, options: DataNode[], { optionFilterProp, filterOption, }: {
+    optionFilterProp: string;
+    filterOption: boolean | FilterFunc<LegacyDataNode>;
+}): DataNode[];
+export declare function getRawValueLabeled(values: RawValueType[], prevValue: DefaultValueType, getEntityByValue: (value: RawValueType, skipType?: SkipType) => FlattenDataNode, getLabelProp: (node: DataNode) => React.ReactNode): LabelValueType[];
+export declare function addValue(rawValues: RawValueType[], value: RawValueType): (string | number)[];
+export declare function removeValue(rawValues: RawValueType[], value: RawValueType): (string | number)[];

web/node_modules/rc-tree-select/lib/utils/valueUtil.js

@@ -0,0 +1,194 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toArray = toArray;
+exports.findValueOption = findValueOption;
+exports.isValueDisabled = isValueDisabled;
+exports.isCheckDisabled = isCheckDisabled;
+exports.flattenOptions = flattenOptions;
+exports.filterOptions = filterOptions;
+exports.getRawValueLabeled = getRawValueLabeled;
+exports.addValue = addValue;
+exports.removeValue = removeValue;
+
+var _treeUtil = require("rc-tree/lib/utils/treeUtil");
+
+var _legacyUtil = require("./legacyUtil");
+
+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 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; }
+
+function toArray(value) {
+  if (Array.isArray(value)) {
+    return value;
+  }
+
+  return value !== undefined ? [value] : [];
+}
+
+function findValueOption(values, options) {
+  var optionMap = new Map();
+  options.forEach(function (flattenItem) {
+    var data = flattenItem.data;
+    optionMap.set(data.value, data);
+  });
+  return values.map(function (val) {
+    return (0, _legacyUtil.fillLegacyProps)(optionMap.get(val));
+  });
+}
+
+function isValueDisabled(value, options) {
+  var option = findValueOption([value], options)[0];
+
+  if (option) {
+    return option.disabled;
+  }
+
+  return false;
+}
+
+function isCheckDisabled(node) {
+  return node.disabled || node.disableCheckbox || node.checkable === false;
+}
+
+function getLevel(_ref) {
+  var parent = _ref.parent;
+  var level = 0;
+  var current = parent;
+
+  while (current) {
+    current = current.parent;
+    level += 1;
+  }
+
+  return level;
+}
+/**
+ * Before reuse `rc-tree` logic, we need to add key since TreeSelect use `value` instead of `key`.
+ */
+
+
+function flattenOptions(options) {
+  // Add missing key
+  function fillKey(list) {
+    return (list || []).map(function (node) {
+      var value = node.value,
+          key = node.key,
+          children = node.children;
+
+      var clone = _objectSpread({}, node, {
+        key: 'key' in node ? key : value
+      });
+
+      if (children) {
+        clone.children = fillKey(children);
+      }
+
+      return clone;
+    });
+  }
+
+  var flattenList = (0, _treeUtil.flattenTreeData)(fillKey(options), true);
+  return flattenList.map(function (node) {
+    return {
+      key: node.data.key,
+      data: node.data,
+      level: getLevel(node)
+    };
+  });
+}
+
+function getDefaultFilterOption(optionFilterProp) {
+  return function (searchValue, dataNode) {
+    var value = dataNode[optionFilterProp];
+    return String(value).toLowerCase().includes(String(searchValue).toLowerCase());
+  };
+}
+/** Filter options and return a new options by the search text */
+
+
+function filterOptions(searchValue, options, _ref2) {
+  var optionFilterProp = _ref2.optionFilterProp,
+      filterOption = _ref2.filterOption;
+
+  if (filterOption === false) {
+    return options;
+  }
+
+  var filterOptionFunc;
+
+  if (typeof filterOption === 'function') {
+    filterOptionFunc = filterOption;
+  } else {
+    filterOptionFunc = getDefaultFilterOption(optionFilterProp);
+  }
+
+  function dig(list) {
+    var keepAll = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    return list.map(function (dataNode) {
+      var children = dataNode.children;
+      var match = keepAll || filterOptionFunc(searchValue, (0, _legacyUtil.fillLegacyProps)(dataNode));
+      var childList = dig(children || [], match);
+
+      if (match || childList.length) {
+        return _objectSpread({}, dataNode, {
+          children: childList
+        });
+      }
+
+      return null;
+    }).filter(function (node) {
+      return node;
+    });
+  }
+
+  return dig(options);
+}
+
+function getRawValueLabeled(values, prevValue, getEntityByValue, getLabelProp) {
+  var valueMap = new Map();
+  toArray(prevValue).forEach(function (item) {
+    if (item && _typeof(item) === 'object' && 'value' in item) {
+      valueMap.set(item.value, item);
+    }
+  });
+  return values.map(function (val) {
+    var item = {
+      value: val
+    };
+    var entity = getEntityByValue(val);
+    var label = entity ? getLabelProp(entity.data) : val;
+
+    if (valueMap.has(val)) {
+      var labeledValue = valueMap.get(val);
+      item.label = 'label' in labeledValue ? labeledValue.label : label;
+
+      if ('halfChecked' in labeledValue) {
+        item.halfChecked = labeledValue.halfChecked;
+      }
+    } else {
+      item.label = label;
+    }
+
+    return item;
+  });
+}
+
+function addValue(rawValues, value) {
+  var values = new Set(rawValues);
+  values.add(value);
+  return Array.from(values);
+}
+
+function removeValue(rawValues, value) {
+  var values = new Set(rawValues);
+  values.delete(value);
+  return Array.from(values);
+}

web/node_modules/rc-tree-select/lib/utils/warningPropsUtil.d.ts

@@ -0,0 +1,3 @@
+import { TreeSelectProps } from '../TreeSelect';
+declare function warningProps(props: TreeSelectProps): void;
+export default warningProps;

web/node_modules/rc-tree-select/lib/utils/warningPropsUtil.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _warning = _interopRequireDefault(require("rc-util/lib/warning"));
+
+var _valueUtil = require("./valueUtil");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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 warningProps(props) {
+  var searchPlaceholder = props.searchPlaceholder,
+      treeCheckStrictly = props.treeCheckStrictly,
+      treeCheckable = props.treeCheckable,
+      labelInValue = props.labelInValue,
+      value = props.value,
+      multiple = props.multiple;
+  (0, _warning.default)(!searchPlaceholder, '`searchPlaceholder` has been removed.');
+
+  if (treeCheckStrictly && labelInValue === false) {
+    (0, _warning.default)(false, '`treeCheckStrictly` will force set `labelInValue` to `true`.');
+  }
+
+  if (labelInValue || treeCheckStrictly) {
+    (0, _warning.default)((0, _valueUtil.toArray)(value).every(function (val) {
+      return val && _typeof(val) === 'object' && 'value' in val;
+    }), 'Invalid prop `value` supplied to `TreeSelect`. You should use { label: string, value: string | number } or [{ label: string, value: string | number }] instead.');
+  }
+
+  if (treeCheckStrictly || multiple || treeCheckable) {
+    (0, _warning.default)(!value || Array.isArray(value), '`value` should be an array when `TreeSelect` is checkable or multiple.');
+  } else {
+    (0, _warning.default)(!Array.isArray(value), '`value` should not be array when `TreeSelect` is single mode.');
+  }
+}
+
+var _default = warningProps;
+exports.default = _default;