@rc-component/tree-select 1.0.0

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

package/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) {
+  const funcRef = React.useRef();
+  funcRef.current = callback;
+  const cacheFn = React.useCallback((...args) => {
+    return funcRef.current(...args);
+  }, []);
+  return cacheFn;
+}

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

package/es/hooks/useTreeData.js

@@ -0,0 +1,52 @@
+import * as React from 'react';
+import { convertChildrenToData } from "../utils/legacyUtil";
+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` 没有变化，则不会重新计算。
+ */
+export default 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 convertChildrenToData(children);
+  }, [children, simpleMode, treeData]);
+}

package/es/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/es/index.js

@@ -0,0 +1,5 @@
+import TreeSelect 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 default TreeSelect;

package/es/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/es/interface.js

@@ -0,0 +1 @@
+export {};

package/es/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/es/utils/legacyUtil.js

@@ -0,0 +1,120 @@
+import * as React from 'react';
+import toArray from "@rc-component/util/es/Children/toArray";
+import warning from "@rc-component/util/es/warning";
+import TreeNode from "../TreeNode";
+export function convertChildrenToData(nodes) {
+  return toArray(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);
+}
+export function fillLegacyProps(dataNode) {
+  if (!dataNode) {
+    return dataNode;
+  }
+  const cloneNode = {
+    ...dataNode
+  };
+  if (!('props' in cloneNode)) {
+    Object.defineProperty(cloneNode, 'props', {
+      get() {
+        warning(false, 'New `rc-tree-select` not support return node instance as argument anymore. Please consider to remove `props` access.');
+        return cloneNode;
+      }
+    });
+  }
+  return cloneNode;
+}
+export 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, 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() {
+      warning(false, '`triggerNode` is deprecated. Please consider decoupling data with node.');
+      generateMap();
+      return triggerNode;
+    }
+  });
+  Object.defineProperty(extra, 'allCheckedNodes', {
+    get() {
+      warning(false, '`allCheckedNodes` is deprecated. Please consider decoupling data with node.');
+      generateMap();
+      if (showPosition) {
+        return nodeList;
+      }
+      return nodeList.map(({
+        node
+      }) => node);
+    }
+  });
+}

package/es/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/es/utils/strategyUtil.js

@@ -0,0 +1,25 @@
+import { isCheckDisabled } from "./valueUtil";
+export const SHOW_ALL = 'SHOW_ALL';
+export const SHOW_PARENT = 'SHOW_PARENT';
+export const SHOW_CHILD = 'SHOW_CHILD';
+export 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
+      }) => 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 || isCheckDisabled(parent.node) || !valueSet.has(parent.key);
+    });
+  }
+  return values;
+}

package/es/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/es/utils/valueUtil.js

@@ -0,0 +1,30 @@
+export const toArray = value => Array.isArray(value) ? value : value !== undefined ? [value] : [];
+export const fillFieldNames = fieldNames => {
+  const {
+    label,
+    value,
+    children
+  } = fieldNames || {};
+  return {
+    _title: label ? [label] : ['title', 'label'],
+    value: value || 'value',
+    key: value || 'value',
+    children: children || 'children'
+  };
+};
+export const isCheckDisabled = node => !node || node.disabled || node.disableCheckbox || node.checkable === false;
+export 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;
+};
+export const isNil = val => val === null || val === undefined;

package/es/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/es/utils/warningPropsUtil.js

@@ -0,0 +1,30 @@
+import warning from "@rc-component/util/es/warning";
+import { toArray } from "./valueUtil";
+function warningProps(props) {
+  const {
+    searchPlaceholder,
+    treeCheckStrictly,
+    treeCheckable,
+    labelInValue,
+    value,
+    multiple,
+    showCheckedStrategy,
+    maxCount
+  } = props;
+  warning(!searchPlaceholder, '`searchPlaceholder` has been removed.');
+  if (treeCheckStrictly && labelInValue === false) {
+    warning(false, '`treeCheckStrictly` will force set `labelInValue` to `true`.');
+  }
+  if (labelInValue || treeCheckStrictly) {
+    warning(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) {
+    warning(!value || Array.isArray(value), '`value` should be an array when `TreeSelect` is checkable or multiple.');
+  } else {
+    warning(!Array.isArray(value), '`value` should not be array when `TreeSelect` is single mode.');
+  }
+  if (maxCount && (showCheckedStrategy === 'SHOW_ALL' && !treeCheckStrictly || showCheckedStrategy === 'SHOW_PARENT')) {
+    warning(false, '`maxCount` not work with `showCheckedStrategy=SHOW_ALL` (when `treeCheckStrictly=false`) or `showCheckedStrategy=SHOW_PARENT`.');
+  }
+}
+export default warningProps;

package/lib/LegacyContext.d.ts

@@ -0,0 +1,24 @@
+import * as React from 'react';
+import type { DataEntity, IconType } from 'rc-tree/lib/interface';
+import type { LegacyDataNode, SafeKey, Key } from './interface';
+interface LegacyContextProps {
+    checkable: boolean | React.ReactNode;
+    checkedKeys: Key[];
+    halfCheckedKeys: Key[];
+    treeExpandedKeys: Key[];
+    treeDefaultExpandedKeys: Key[];
+    onTreeExpand: (keys: Key[]) => void;
+    treeDefaultExpandAll: boolean;
+    treeIcon: IconType;
+    showTreeIcon: boolean;
+    switcherIcon: IconType;
+    treeLine: boolean;
+    treeNodeFilterProp: string;
+    treeLoadedKeys: Key[];
+    treeMotion: any;
+    loadData: (treeNode: LegacyDataNode) => Promise<unknown>;
+    onTreeLoad: (loadedKeys: Key[]) => void;
+    keyEntities: Record<SafeKey, DataEntity<any>>;
+}
+declare const LegacySelectContext: React.Context<LegacyContextProps>;
+export default LegacySelectContext;

package/lib/LegacyContext.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+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; }
+const LegacySelectContext = /*#__PURE__*/React.createContext(null);
+var _default = exports.default = LegacySelectContext;

package/lib/OptionList.d.ts

@@ -0,0 +1,8 @@
+import type { RefOptionListProps } from '@rc-component/select/lib/OptionList';
+import type { ScrollTo } from 'rc-tree/lib/interface';
+import * as React from 'react';
+type ReviseRefOptionListProps = Omit<RefOptionListProps, 'scrollTo'> & {
+    scrollTo: ScrollTo;
+};
+declare const RefOptionList: React.ForwardRefExoticComponent<React.RefAttributes<ReviseRefOptionListProps>>;
+export default RefOptionList;