add all frontend files

node_modules/rc-tree-select/es/hooks/useCache.d.ts

@@ -0,0 +1,7 @@
+import type { LabeledValueType } from '../interface';
+/**
+ * This function will try to call requestIdleCallback if available to save performance.
+ * No need `getLabel` here since already fetch on `rawLabeledValue`.
+ */
+declare const _default: (values: LabeledValueType[]) => [LabeledValueType[]];
+export default _default;

node_modules/rc-tree-select/es/hooks/useCache.js

@@ -0,0 +1,28 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import * as React from 'react';
+/**
+ * This function will try to call requestIdleCallback if available to save performance.
+ * No need `getLabel` here since already fetch on `rawLabeledValue`.
+ */
+export default (function (values) {
+  var cacheRef = React.useRef({
+    valueLabels: new Map()
+  });
+  return React.useMemo(function () {
+    var valueLabels = cacheRef.current.valueLabels;
+    var valueLabelsCache = new Map();
+    var filledValues = values.map(function (item) {
+      var value = item.value,
+        label = item.label;
+      var mergedLabel = label !== null && label !== void 0 ? label : valueLabels.get(value);
+
+      // Save in cache
+      valueLabelsCache.set(value, mergedLabel);
+      return _objectSpread(_objectSpread({}, item), {}, {
+        label: mergedLabel
+      });
+    });
+    cacheRef.current.valueLabels = valueLabelsCache;
+    return [filledValues];
+  }, [values]);
+});

node_modules/rc-tree-select/es/hooks/useCheckedKeys.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+import type { DataEntity } from 'rc-tree/lib/interface';
+import type { LabeledValueType, SafeKey } from '../interface';
+declare const useCheckedKeys: (rawLabeledValues: LabeledValueType[], rawHalfCheckedValues: LabeledValueType[], treeConduction: boolean, keyEntities: Record<SafeKey, DataEntity>) => React.Key[][];
+export default useCheckedKeys;

node_modules/rc-tree-select/es/hooks/useCheckedKeys.js

@@ -0,0 +1,27 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import * as React from 'react';
+import { conductCheck } from "rc-tree/es/utils/conductUtil";
+var useCheckedKeys = function useCheckedKeys(rawLabeledValues, rawHalfCheckedValues, treeConduction, keyEntities) {
+  return React.useMemo(function () {
+    var extractValues = function extractValues(values) {
+      return values.map(function (_ref) {
+        var value = _ref.value;
+        return value;
+      });
+    };
+    var checkedKeys = extractValues(rawLabeledValues);
+    var halfCheckedKeys = extractValues(rawHalfCheckedValues);
+    var missingValues = checkedKeys.filter(function (key) {
+      return !keyEntities[key];
+    });
+    var finalCheckedKeys = checkedKeys;
+    var finalHalfCheckedKeys = halfCheckedKeys;
+    if (treeConduction) {
+      var conductResult = conductCheck(checkedKeys, true, keyEntities);
+      finalCheckedKeys = conductResult.checkedKeys;
+      finalHalfCheckedKeys = conductResult.halfCheckedKeys;
+    }
+    return [Array.from(new Set([].concat(_toConsumableArray(missingValues), _toConsumableArray(finalCheckedKeys)))), finalHalfCheckedKeys];
+  }, [rawLabeledValues, rawHalfCheckedValues, treeConduction, keyEntities]);
+};
+export default useCheckedKeys;

node_modules/rc-tree-select/es/hooks/useDataEntities.d.ts

@@ -0,0 +1,7 @@
+import type { DataEntity } from 'rc-tree/lib/interface';
+import type { SafeKey, FieldNames } from '../interface';
+declare const _default: (treeData: any, fieldNames: FieldNames) => {
+    valueEntities: Map<SafeKey, DataEntity>;
+    keyEntities: Record<string, DataEntity>;
+};
+export default _default;

node_modules/rc-tree-select/es/hooks/useDataEntities.js

@@ -0,0 +1,30 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import * as React from 'react';
+import { convertDataToEntities } from "rc-tree/es/utils/treeUtil";
+import warning from "rc-util/es/warning";
+import { isNil } from "../utils/valueUtil";
+export default (function (treeData, fieldNames) {
+  return React.useMemo(function () {
+    var collection = convertDataToEntities(treeData, {
+      fieldNames: fieldNames,
+      initWrapper: function initWrapper(wrapper) {
+        return _objectSpread(_objectSpread({}, wrapper), {}, {
+          valueEntities: new Map()
+        });
+      },
+      processEntity: function processEntity(entity, wrapper) {
+        var val = entity.node[fieldNames.value];
+
+        // Check if exist same value
+        if (process.env.NODE_ENV !== 'production') {
+          var key = entity.node.key;
+          warning(!isNil(val), 'TreeNode `value` is invalidate: undefined');
+          warning(!wrapper.valueEntities.has(val), "Same `value` exist in the tree: ".concat(val));
+          warning(!key || String(key) === String(val), "`key` or `value` with TreeNode must be the same or you can remove one of them. key: ".concat(key, ", value: ").concat(val, "."));
+        }
+        wrapper.valueEntities.set(val, entity);
+      }
+    });
+    return collection;
+  }, [treeData, fieldNames]);
+});

node_modules/rc-tree-select/es/hooks/useFilterTreeData.d.ts

@@ -0,0 +1,8 @@
+import type { TreeSelectProps } from '../TreeSelect';
+import type { DataNode, FieldNames } from '../interface';
+declare const useFilterTreeData: (treeData: DataNode[], searchValue: string, options: {
+    fieldNames: FieldNames;
+    treeNodeFilterProp: string;
+    filterTreeNode: TreeSelectProps['filterTreeNode'];
+}) => DataNode[];
+export default useFilterTreeData;

node_modules/rc-tree-select/es/hooks/useFilterTreeData.js

@@ -0,0 +1,34 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import * as React from 'react';
+import { fillLegacyProps } from "../utils/legacyUtil";
+var useFilterTreeData = function useFilterTreeData(treeData, searchValue, options) {
+  var fieldNames = options.fieldNames,
+    treeNodeFilterProp = options.treeNodeFilterProp,
+    filterTreeNode = options.filterTreeNode;
+  var fieldChildren = fieldNames.children;
+  return React.useMemo(function () {
+    if (!searchValue || filterTreeNode === false) {
+      return treeData;
+    }
+    var filterOptionFunc = typeof filterTreeNode === 'function' ? filterTreeNode : function (_, dataNode) {
+      return String(dataNode[treeNodeFilterProp]).toUpperCase().includes(searchValue.toUpperCase());
+    };
+    var filterTreeNodes = function filterTreeNodes(nodes) {
+      var keepAll = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      return nodes.reduce(function (filtered, node) {
+        var children = node[fieldChildren];
+        var isMatch = keepAll || filterOptionFunc(searchValue, fillLegacyProps(node));
+        var filteredChildren = filterTreeNodes(children || [], isMatch);
+        if (isMatch || filteredChildren.length) {
+          filtered.push(_objectSpread(_objectSpread({}, node), {}, _defineProperty({
+            isLeaf: undefined
+          }, fieldChildren, filteredChildren)));
+        }
+        return filtered;
+      }, []);
+    };
+    return filterTreeNodes(treeData);
+  }, [treeData, searchValue, fieldChildren, treeNodeFilterProp, filterTreeNode]);
+};
+export default useFilterTreeData;

node_modules/rc-tree-select/es/hooks/useRefFunc.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Same as `React.useCallback` but always return a memoized function
+ * but redirect to real function.
+ */
+export default function useRefFunc<T extends (...args: any[]) => any>(callback: T): T;

node_modules/rc-tree-select/es/hooks/useRefFunc.js

@@ -0,0 +1,14 @@
+import * as React from 'react';
+
+/**
+ * Same as `React.useCallback` but always return a memoized function
+ * but redirect to real function.
+ */
+export default function useRefFunc(callback) {
+  var funcRef = React.useRef();
+  funcRef.current = callback;
+  var cacheFn = React.useCallback(function () {
+    return funcRef.current.apply(funcRef, arguments);
+  }, []);
+  return cacheFn;
+}

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

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import type { DataNode, SimpleModeConfig } from '../interface';
+/**
+ * 将 `treeData` 或 `children` 转换为格式化的 `treeData`。
+ * 如果 `treeData` 或 `children` 没有变化，则不会重新计算。
+ */
+export default function useTreeData(treeData: DataNode[], children: React.ReactNode, simpleMode: boolean | SimpleModeConfig): DataNode[];

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

@@ -0,0 +1,50 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import * as React from 'react';
+import { convertChildrenToData } from "../utils/legacyUtil";
+function buildTreeStructure(nodes, config) {
+  var id = config.id,
+    pId = config.pId,
+    rootPId = config.rootPId;
+  var nodeMap = new Map();
+  var rootNodes = [];
+  nodes.forEach(function (node) {
+    var nodeKey = node[id];
+    var clonedNode = _objectSpread(_objectSpread({}, node), {}, {
+      key: node.key || nodeKey
+    });
+    nodeMap.set(nodeKey, clonedNode);
+  });
+  nodeMap.forEach(function (node) {
+    var parentKey = node[pId];
+    var parent = nodeMap.get(parentKey);
+    if (parent) {
+      parent.children = parent.children || [];
+      parent.children.push(node);
+    } else if (parentKey === rootPId || rootPId === null) {
+      rootNodes.push(node);
+    }
+  });
+  return rootNodes;
+}
+
+/**
+ * 将 `treeData` 或 `children` 转换为格式化的 `treeData`。
+ * 如果 `treeData` 或 `children` 没有变化，则不会重新计算。
+ */
+export default function useTreeData(treeData, children, simpleMode) {
+  return React.useMemo(function () {
+    if (treeData) {
+      if (simpleMode) {
+        var config = _objectSpread({
+          id: 'id',
+          pId: 'pId',
+          rootPId: null
+        }, _typeof(simpleMode) === 'object' ? simpleMode : {});
+        return buildTreeStructure(treeData, config);
+      }
+      return treeData;
+    }
+    return convertChildrenToData(children);
+  }, [children, simpleMode, treeData]);
+}