@rc-component/tree-select 1.0.0

package/lib/hooks/useDataEntities.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _treeUtil = require("rc-tree/lib/utils/treeUtil");
+var _warning = _interopRequireDefault(require("@rc-component/util/lib/warning"));
+var _valueUtil = require("../utils/valueUtil");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+var _default = (treeData, fieldNames) => React.useMemo(() => {
+  const collection = (0, _treeUtil.convertDataToEntities)(treeData, {
+    fieldNames,
+    initWrapper: wrapper => ({
+      ...wrapper,
+      valueEntities: new Map()
+    }),
+    processEntity: (entity, wrapper) => {
+      const val = entity.node[fieldNames.value];
+
+      // Check if exist same value
+      if (process.env.NODE_ENV !== 'production') {
+        const key = entity.node.key;
+        (0, _warning.default)(!(0, _valueUtil.isNil)(val), 'TreeNode `value` is invalidate: undefined');
+        (0, _warning.default)(!wrapper.valueEntities.has(val), `Same \`value\` exist in the tree: ${val}`);
+        (0, _warning.default)(!key || String(key) === String(val), `\`key\` or \`value\` with TreeNode must be the same or you can remove one of them. key: ${key}, value: ${val}.`);
+      }
+      wrapper.valueEntities.set(val, entity);
+    }
+  });
+  return collection;
+}, [treeData, fieldNames]);
+exports.default = _default;

package/lib/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;

package/lib/hooks/useFilterTreeData.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _legacyUtil = require("../utils/legacyUtil");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+const useFilterTreeData = (treeData, searchValue, options) => {
+  const {
+    fieldNames,
+    treeNodeFilterProp,
+    filterTreeNode
+  } = options;
+  const {
+    children: fieldChildren
+  } = fieldNames;
+  return React.useMemo(() => {
+    if (!searchValue || filterTreeNode === false) {
+      return treeData;
+    }
+    const filterOptionFunc = typeof filterTreeNode === 'function' ? filterTreeNode : (_, dataNode) => String(dataNode[treeNodeFilterProp]).toUpperCase().includes(searchValue.toUpperCase());
+    const filterTreeNodes = (nodes, keepAll = false) => nodes.reduce((filtered, node) => {
+      const children = node[fieldChildren];
+      const isMatch = keepAll || filterOptionFunc(searchValue, (0, _legacyUtil.fillLegacyProps)(node));
+      const filteredChildren = filterTreeNodes(children || [], isMatch);
+      if (isMatch || filteredChildren.length) {
+        filtered.push({
+          ...node,
+          isLeaf: undefined,
+          [fieldChildren]: filteredChildren
+        });
+      }
+      return filtered;
+    }, []);
+    return filterTreeNodes(treeData);
+  }, [treeData, searchValue, fieldChildren, treeNodeFilterProp, filterTreeNode]);
+};
+var _default = exports.default = useFilterTreeData;

package/lib/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;

package/lib/hooks/useRefFunc.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useRefFunc;
+var React = _interopRequireWildcard(require("react"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/**
+ * Same as `React.useCallback` but always return a memoized function
+ * but redirect to real function.
+ */
+function useRefFunc(callback) {
+  const funcRef = React.useRef();
+  funcRef.current = callback;
+  const cacheFn = React.useCallback((...args) => {
+    return funcRef.current(...args);
+  }, []);
+  return cacheFn;
+}

package/lib/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[];

package/lib/hooks/useTreeData.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useTreeData;
+var React = _interopRequireWildcard(require("react"));
+var _legacyUtil = require("../utils/legacyUtil");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function buildTreeStructure(nodes, config) {
+  const {
+    id,
+    pId,
+    rootPId
+  } = config;
+  const nodeMap = new Map();
+  const rootNodes = [];
+  nodes.forEach(node => {
+    const nodeKey = node[id];
+    const clonedNode = {
+      ...node,
+      key: node.key || nodeKey
+    };
+    nodeMap.set(nodeKey, clonedNode);
+  });
+  nodeMap.forEach(node => {
+    const parentKey = node[pId];
+    const 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` 没有变化，则不会重新计算。
+ */
+function useTreeData(treeData, children, simpleMode) {
+  return React.useMemo(() => {
+    if (treeData) {
+      if (simpleMode) {
+        const config = {
+          id: 'id',
+          pId: 'pId',
+          rootPId: null,
+          ...(typeof simpleMode === 'object' ? simpleMode : {})
+        };
+        return buildTreeStructure(treeData, config);
+      }
+      return treeData;
+    }
+    return (0, _legacyUtil.convertChildrenToData)(children);
+  }, [children, simpleMode, treeData]);
+}

package/lib/index.d.ts

@@ -0,0 +1,7 @@
+import TreeSelect from './TreeSelect';
+import type { TreeSelectProps } from './TreeSelect';
+import TreeNode from './TreeNode';
+import { SHOW_ALL, SHOW_CHILD, SHOW_PARENT } from './utils/strategyUtil';
+export { TreeNode, SHOW_ALL, SHOW_CHILD, SHOW_PARENT };
+export type { TreeSelectProps };
+export default TreeSelect;

package/lib/index.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "SHOW_ALL", {
+  enumerable: true,
+  get: function () {
+    return _strategyUtil.SHOW_ALL;
+  }
+});
+Object.defineProperty(exports, "SHOW_CHILD", {
+  enumerable: true,
+  get: function () {
+    return _strategyUtil.SHOW_CHILD;
+  }
+});
+Object.defineProperty(exports, "SHOW_PARENT", {
+  enumerable: true,
+  get: function () {
+    return _strategyUtil.SHOW_PARENT;
+  }
+});
+Object.defineProperty(exports, "TreeNode", {
+  enumerable: true,
+  get: function () {
+    return _TreeNode.default;
+  }
+});
+exports.default = void 0;
+var _TreeSelect = _interopRequireDefault(require("./TreeSelect"));
+var _TreeNode = _interopRequireDefault(require("./TreeNode"));
+var _strategyUtil = require("./utils/strategyUtil");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _default = exports.default = _TreeSelect.default;

package/lib/interface.d.ts

@@ -0,0 +1,57 @@
+import type * as React from 'react';
+import type { SafeKey, Key, DataNode as TreeDataNode } from 'rc-tree/lib/interface';
+export type { SafeKey, Key };
+export interface DataNode extends Record<string, any>, Omit<TreeDataNode, 'key' | 'children'> {
+    key?: Key;
+    value?: SafeKey;
+    children?: DataNode[];
+}
+export type SelectSource = 'option' | 'selection' | 'input' | 'clear';
+export interface LabeledValueType {
+    key?: Key;
+    value?: SafeKey;
+    label?: React.ReactNode;
+    /** Only works on `treeCheckStrictly` */
+    halfChecked?: boolean;
+}
+export type DefaultValueType = SafeKey | LabeledValueType | (SafeKey | LabeledValueType)[];
+export interface LegacyDataNode extends DataNode {
+    props: any;
+}
+export interface FlattenDataNode {
+    data: DataNode;
+    key: Key;
+    value: SafeKey;
+    level: number;
+    parent?: FlattenDataNode;
+}
+export interface SimpleModeConfig {
+    id?: SafeKey;
+    pId?: SafeKey;
+    rootPId?: SafeKey;
+}
+/** @deprecated This is only used for legacy compatible. Not works on new code. */
+export interface LegacyCheckedNode {
+    pos: string;
+    node: React.ReactElement;
+    children?: LegacyCheckedNode[];
+}
+export interface ChangeEventExtra {
+    /** @deprecated Please save prev value by control logic instead */
+    preValue: LabeledValueType[];
+    triggerValue: SafeKey;
+    /** @deprecated Use `onSelect` or `onDeselect` instead. */
+    selected?: boolean;
+    /** @deprecated Use `onSelect` or `onDeselect` instead. */
+    checked?: boolean;
+    /** @deprecated This prop not work as react node anymore. */
+    triggerNode: React.ReactElement;
+    /** @deprecated This prop not work as react node anymore. */
+    allCheckedNodes: LegacyCheckedNode[];
+}
+export interface FieldNames {
+    value?: string;
+    label?: string;
+    children?: string;
+    _title?: string[];
+}

package/lib/interface.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/utils/legacyUtil.d.ts

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

package/lib/utils/legacyUtil.js

@@ -0,0 +1,131 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertChildrenToData = convertChildrenToData;
+exports.fillAdditionalInfo = fillAdditionalInfo;
+exports.fillLegacyProps = fillLegacyProps;
+var React = _interopRequireWildcard(require("react"));
+var _toArray = _interopRequireDefault(require("@rc-component/util/lib/Children/toArray"));
+var _warning = _interopRequireDefault(require("@rc-component/util/lib/warning"));
+var _TreeNode = _interopRequireDefault(require("../TreeNode"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function convertChildrenToData(nodes) {
+  return (0, _toArray.default)(nodes).map(node => {
+    if (! /*#__PURE__*/React.isValidElement(node) || !node.type) {
+      return null;
+    }
+    const {
+      key,
+      props: {
+        children,
+        value,
+        ...restProps
+      }
+    } = node;
+    const data = {
+      key,
+      value,
+      ...restProps
+    };
+    const childData = convertChildrenToData(children);
+    if (childData.length) {
+      data.children = childData;
+    }
+    return data;
+  }).filter(data => data);
+}
+function fillLegacyProps(dataNode) {
+  if (!dataNode) {
+    return dataNode;
+  }
+  const cloneNode = {
+    ...dataNode
+  };
+  if (!('props' in cloneNode)) {
+    Object.defineProperty(cloneNode, 'props', {
+      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, fieldNames) {
+  let triggerNode = null;
+  let nodeList = null;
+  function generateMap() {
+    function dig(list, level = '0', parentIncluded = false) {
+      return list.map((option, index) => {
+        const pos = `${level}-${index}`;
+        const value = option[fieldNames.value];
+        const included = checkedValues.includes(value);
+        const children = dig(option[fieldNames.children] || [], pos, included);
+        const node = /*#__PURE__*/React.createElement(_TreeNode.default, option, children.map(child => child.node));
+
+        // Link with trigger node
+        if (triggerValue === value) {
+          triggerNode = node;
+        }
+        if (included) {
+          const checkedNode = {
+            pos,
+            node,
+            children
+          };
+          if (!parentIncluded) {
+            nodeList.push(checkedNode);
+          }
+          return checkedNode;
+        }
+        return null;
+      }).filter(node => node);
+    }
+    if (!nodeList) {
+      nodeList = [];
+      dig(treeData);
+
+      // Sort to keep the checked node length
+      nodeList.sort(({
+        node: {
+          props: {
+            value: val1
+          }
+        }
+      }, {
+        node: {
+          props: {
+            value: val2
+          }
+        }
+      }) => {
+        const index1 = checkedValues.indexOf(val1);
+        const index2 = checkedValues.indexOf(val2);
+        return index1 - index2;
+      });
+    }
+  }
+  Object.defineProperty(extra, 'triggerNode', {
+    get() {
+      (0, _warning.default)(false, '`triggerNode` is deprecated. Please consider decoupling data with node.');
+      generateMap();
+      return triggerNode;
+    }
+  });
+  Object.defineProperty(extra, 'allCheckedNodes', {
+    get() {
+      (0, _warning.default)(false, '`allCheckedNodes` is deprecated. Please consider decoupling data with node.');
+      generateMap();
+      if (showPosition) {
+        return nodeList;
+      }
+      return nodeList.map(({
+        node
+      }) => node);
+    }
+  });
+}

package/lib/utils/strategyUtil.d.ts

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

package/lib/utils/strategyUtil.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SHOW_PARENT = exports.SHOW_CHILD = exports.SHOW_ALL = void 0;
+exports.formatStrategyValues = formatStrategyValues;
+var _valueUtil = require("./valueUtil");
+const SHOW_ALL = exports.SHOW_ALL = 'SHOW_ALL';
+const SHOW_PARENT = exports.SHOW_PARENT = 'SHOW_PARENT';
+const SHOW_CHILD = exports.SHOW_CHILD = 'SHOW_CHILD';
+function formatStrategyValues(values, strategy, keyEntities, fieldNames) {
+  const valueSet = new Set(values);
+  if (strategy === SHOW_CHILD) {
+    return values.filter(key => {
+      const entity = keyEntities[key];
+      return !entity || !entity.children || !entity.children.some(({
+        node
+      }) => valueSet.has(node[fieldNames.value])) || !entity.children.every(({
+        node
+      }) => (0, _valueUtil.isCheckDisabled)(node) || valueSet.has(node[fieldNames.value]));
+    });
+  }
+  if (strategy === SHOW_PARENT) {
+    return values.filter(key => {
+      const entity = keyEntities[key];
+      const parent = entity ? entity.parent : null;
+      return !parent || (0, _valueUtil.isCheckDisabled)(parent.node) || !valueSet.has(parent.key);
+    });
+  }
+  return values;
+}

package/lib/utils/valueUtil.d.ts

@@ -0,0 +1,11 @@
+import type { DataNode, FieldNames, SafeKey } from '../interface';
+export declare const toArray: <T>(value: T | T[]) => T[];
+export declare const fillFieldNames: (fieldNames?: FieldNames) => {
+    _title: string[];
+    value: string;
+    key: string;
+    children: string;
+};
+export declare const isCheckDisabled: (node: DataNode) => boolean;
+export declare const getAllKeys: (treeData: DataNode[], fieldNames: FieldNames) => SafeKey[];
+export declare const isNil: (val: any) => boolean;

package/lib/utils/valueUtil.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toArray = exports.isNil = exports.isCheckDisabled = exports.getAllKeys = exports.fillFieldNames = void 0;
+const toArray = value => Array.isArray(value) ? value : value !== undefined ? [value] : [];
+exports.toArray = toArray;
+const fillFieldNames = fieldNames => {
+  const {
+    label,
+    value,
+    children
+  } = fieldNames || {};
+  return {
+    _title: label ? [label] : ['title', 'label'],
+    value: value || 'value',
+    key: value || 'value',
+    children: children || 'children'
+  };
+};
+exports.fillFieldNames = fillFieldNames;
+const isCheckDisabled = node => !node || node.disabled || node.disableCheckbox || node.checkable === false;
+exports.isCheckDisabled = isCheckDisabled;
+const getAllKeys = (treeData, fieldNames) => {
+  const keys = [];
+  const dig = list => {
+    list.forEach(item => {
+      const children = item[fieldNames.children];
+      if (children) {
+        keys.push(item[fieldNames.value]);
+        dig(children);
+      }
+    });
+  };
+  dig(treeData);
+  return keys;
+};
+exports.getAllKeys = getAllKeys;
+const isNil = val => val === null || val === undefined;
+exports.isNil = isNil;

package/lib/utils/warningPropsUtil.d.ts

@@ -0,0 +1,5 @@
+import type { TreeSelectProps } from '../TreeSelect';
+declare function warningProps(props: TreeSelectProps & {
+    searchPlaceholder?: string;
+}): void;
+export default warningProps;

package/lib/utils/warningPropsUtil.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _warning = _interopRequireDefault(require("@rc-component/util/lib/warning"));
+var _valueUtil = require("./valueUtil");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function warningProps(props) {
+  const {
+    searchPlaceholder,
+    treeCheckStrictly,
+    treeCheckable,
+    labelInValue,
+    value,
+    multiple,
+    showCheckedStrategy,
+    maxCount
+  } = props;
+  (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(val => 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.');
+  }
+  if (maxCount && (showCheckedStrategy === 'SHOW_ALL' && !treeCheckStrictly || showCheckedStrategy === 'SHOW_PARENT')) {
+    (0, _warning.default)(false, '`maxCount` not work with `showCheckedStrategy=SHOW_ALL` (when `treeCheckStrictly=false`) or `showCheckedStrategy=SHOW_PARENT`.');
+  }
+}
+var _default = exports.default = warningProps;

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "@rc-component/tree-select",
+  "version": "1.0.0",
+  "description": "tree-select ui component for react",
+  "keywords": [
+    "react",
+    "react-component",
+    "react-tree-select",
+    "tree-select"
+  ],
+  "homepage": "https://github.com/react-component/tree-select",
+  "bugs": {
+    "url": "https://github.com/react-component/tree-select/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/react-component/tree-select.git"
+  },
+  "license": "MIT",
+  "author": "smith3816@gmail.com",
+  "main": "./lib/index",
+  "module": "./es/index",
+  "files": [
+    "es",
+    "lib",
+    "dist",
+    "assets/*.less",
+    "assets/*.css",
+    "assets/*.png",
+    "assets/*.gif"
+  ],
+  "scripts": {
+    "build": "dumi build",
+    "compile": "father build",
+    "lint": "eslint src/ examples/ --ext .tsx,.ts,.jsx,.js",
+    "now-build": "npm run build",
+    "prepare": "husky && dumi setup",
+    "prepublishOnly": "npm run compile && rc-np",
+    "prettier": "prettier '{src,tests}/**/*.{ts,tsx}' 'tests/**/*.js' --write",
+    "start": "dumi dev",
+    "test": "rc-test"
+  },
+  "lint-staged": {
+    "*": "prettier --write --ignore-unknown"
+  },
+  "dependencies": {
+    "classnames": "2.x",
+    "@rc-component/select": "~1.0.0",
+    "rc-tree": "~5.13.1",
+    "@rc-component/util": "^1.2.1"
+  },
+  "devDependencies": {
+    "@rc-component/father-plugin": "^2.0.2",
+    "@rc-component/np": "^1.0.3",
+    "@rc-component/trigger": "^3.0.0",
+    "@testing-library/react": "^12.1.5",
+    "@types/jest": "^29.5.13",
+    "@types/node": "^22.7.5",
+    "@types/react": "^18.3.11",
+    "@types/react-dom": "^19.0.1",
+    "@types/warning": "^3.0.3",
+    "@umijs/fabric": "^4.0.1",
+    "cheerio": "1.0.0-rc.12",
+    "cross-env": "^7.0.3",
+    "dumi": "^2.4.12",
+    "enzyme": "^3.11.0",
+    "enzyme-adapter-react-16": "^1.15.8",
+    "enzyme-to-json": "^3.6.2",
+    "eslint": "^8.57.1",
+    "eslint-plugin-jest": "^28.10.0",
+    "eslint-plugin-unicorn": "^56.0.0",
+    "father": "^4.5.0",
+    "glob": "^11.0.0",
+    "husky": "^9.1.6",
+    "lint-staged": "^15.2.10",
+    "prettier": "^3.3.3",
+    "rc-dialog": "^9.6.0",
+    "rc-field-form": "^2.4.0",
+    "rc-test": "^7.1.1",
+    "rc-virtual-list": "^3.14.8",
+    "react": "^16.0.0",
+    "react-dom": "^16.0.0",
+    "typescript": "^5.6.3"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-dom": "*"
+  }
+}