docs: add searchable Tree demo (#3693)

components/tree/demo/search.md

@@ -0,0 +1,156 @@
+---
+order: 4
+title:
+  zh-CN: 可搜索
+  en-US: Searchable
+---
+
+## zh-CN
+
+可搜索的树。
+
+## en-US
+
+Searchable Tree.
+
+````jsx
+import { Tree, Input } from 'antd';
+
+const TreeNode = Tree.TreeNode;
+
+const x = 3;
+const y = 2;
+const z = 1;
+const gData = [];
+
+const generateData = (_level, _preKey, _tns) => {
+  const preKey = _preKey || '0';
+  const tns = _tns || gData;
+
+  const children = [];
+  for (let i = 0; i < x; i++) {
+    const key = `${preKey}-${i}`;
+    tns.push({ title: key, key });
+    if (i < y) {
+      children.push(key);
+    }
+  }
+  if (_level < 0) {
+    return tns;
+  }
+  const level = _level - 1;
+  children.forEach((key, index) => {
+    tns[index].children = [];
+    return generateData(level, key, tns[index].children);
+  });
+};
+generateData(z);
+
+const dataList = [];
+const generateList = (data) => {
+  for (let i = 0; i < data.length; i++) {
+    const node = data[i];
+    const key = node.key;
+    dataList.push({ key, title: key });
+    if (node.children) {
+      generateList(node.children, node.key);
+    }
+  }
+};
+generateList(gData);
+
+const getParentKey = (key, tree) => {
+  let parentKey;
+  for (let i = 0; i < tree.length; i++) {
+    const node = tree[i];
+    if (node.children) {
+      if (node.children.some(item => item.key === key)) {
+        parentKey = node.key;
+      } else if (getParentKey(key, node.children)) {
+        parentKey = getParentKey(key, node.children);
+      }
+    }
+  }
+  return parentKey;
+};
+
+
+class SearchTree extends React.Component {
+  constructor(props) {
+    super(props);
+    this.state = {
+      expandedKeys: [],
+      searchValue: '',
+    };
+  }
+  onExpand = (expandedKeys) => {
+    this.setState({ expandedKeys });
+  }
+  onChange = (e) => {
+    const value = e.target.value;
+    const expandedKeys = [];
+    dataList.forEach((item) => {
+      if (item.key.indexOf(value) > -1) {
+        expandedKeys.push(getParentKey(item.key, gData));
+      }
+    });
+    const uniqueExpandedKeys = [];
+    expandedKeys.forEach((item) => {
+      if (item && uniqueExpandedKeys.indexOf(item) === -1) {
+        uniqueExpandedKeys.push(item);
+      }
+    });
+    this.setState({
+      expandedKeys: uniqueExpandedKeys,
+      searchValue: value,
+    });
+  }
+  render() {
+    const { searchValue, expandedKeys } = this.state;
+    const loop = data => data.map((item) => {
+      const index = item.key.search(searchValue);
+      const beforeStr = item.key.substr(0, index);
+      const afterStr = item.key.substr(index + searchValue.length);
+      const title = index > -1 ?
+            <span>
+              {beforeStr}
+              <span className="ant-tree-searchable-filter">{searchValue}</span>
+              {afterStr}
+            </span>
+            : <span>{item.key}</span>;
+      if (item.children) {
+        return (
+          <TreeNode key={item.key} title={title}>
+            {loop(item.children)}
+          </TreeNode>
+        );
+      }
+      return <TreeNode key={item.key} title={title} />;
+    });
+    return (
+      <div>
+        <Input
+          style={{ width: 200 }}
+          placeholder="Search"
+          onChange={this.onChange}
+        />
+        <Tree
+          onExpand={this.onExpand}
+          expandedKeys={expandedKeys}
+        >
+          {loop(gData)}
+        </Tree>
+      </div>
+    );
+  }
+}
+
+ReactDOM.render(<SearchTree />, mountNode);
+````
+
+````css
+.ant-tree-searchable-filter {
+  color: #f50;
+  transition: all .3s ease;
+}
+````