@rc-component/cascader 1.0.0

package/lib/hooks/useDisplayValues.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _treeUtil = require("../utils/treeUtil");
+var React = _interopRequireWildcard(require("react"));
+var _commonUtil = require("../utils/commonUtil");
+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 = (rawValues, options, fieldNames, multiple, displayRender) => {
+  return React.useMemo(() => {
+    const mergedDisplayRender = displayRender || (
+    // Default displayRender
+    labels => {
+      const mergedLabels = multiple ? labels.slice(-1) : labels;
+      const SPLIT = ' / ';
+      if (mergedLabels.every(label => ['string', 'number'].includes(typeof label))) {
+        return mergedLabels.join(SPLIT);
+      }
+
+      // If exist non-string value, use ReactNode instead
+      return mergedLabels.reduce((list, label, index) => {
+        const keyedLabel = /*#__PURE__*/React.isValidElement(label) ? /*#__PURE__*/React.cloneElement(label, {
+          key: index
+        }) : label;
+        if (index === 0) {
+          return [keyedLabel];
+        }
+        return [...list, SPLIT, keyedLabel];
+      }, []);
+    });
+    return rawValues.map(valueCells => {
+      const valueOptions = (0, _treeUtil.toPathOptions)(valueCells, options, fieldNames);
+      const label = mergedDisplayRender(valueOptions.map(({
+        option,
+        value
+      }) => option?.[fieldNames.label] ?? value), valueOptions.map(({
+        option
+      }) => option));
+      const value = (0, _commonUtil.toPathKey)(valueCells);
+      return {
+        label,
+        value,
+        key: value,
+        valueCells,
+        disabled: valueOptions[valueOptions.length - 1]?.option?.disabled
+      };
+    });
+  }, [rawValues, options, fieldNames, displayRender, multiple]);
+};
+exports.default = _default;

package/lib/hooks/useEntities.d.ts

@@ -0,0 +1,10 @@
+import type { DefaultOptionType, InternalFieldNames } from '../Cascader';
+import type { DataEntity } from 'rc-tree/lib/interface';
+export interface OptionsInfo {
+    keyEntities: Record<string, DataEntity>;
+    pathKeyEntities: Record<string, DataEntity>;
+}
+export type GetEntities = () => OptionsInfo['pathKeyEntities'];
+/** Lazy parse options data into conduct-able info to avoid perf issue in single mode */
+declare const _default: (options: DefaultOptionType[], fieldNames: InternalFieldNames) => GetEntities;
+export default _default;

package/lib/hooks/useEntities.js

@@ -0,0 +1,44 @@
+"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 _commonUtil = require("../utils/commonUtil");
+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; }
+/** Lazy parse options data into conduct-able info to avoid perf issue in single mode */
+var _default = (options, fieldNames) => {
+  const cacheRef = React.useRef({
+    options: [],
+    info: {
+      keyEntities: {},
+      pathKeyEntities: {}
+    }
+  });
+  const getEntities = React.useCallback(() => {
+    if (cacheRef.current.options !== options) {
+      cacheRef.current.options = options;
+      cacheRef.current.info = (0, _treeUtil.convertDataToEntities)(options, {
+        fieldNames: fieldNames,
+        initWrapper: wrapper => ({
+          ...wrapper,
+          pathKeyEntities: {}
+        }),
+        processEntity: (entity, wrapper) => {
+          const pathKey = entity.nodes.map(node => node[fieldNames.value]).join(_commonUtil.VALUE_SPLIT);
+          wrapper.pathKeyEntities[pathKey] = entity;
+
+          // Overwrite origin key.
+          // this is very hack but we need let conduct logic work with connect path
+          entity.key = pathKey;
+        }
+      });
+    }
+    return cacheRef.current.info.pathKeyEntities;
+  }, [fieldNames, options]);
+  return getEntities;
+};
+exports.default = _default;

package/lib/hooks/useMissingValues.d.ts

@@ -0,0 +1,3 @@
+import type { DefaultOptionType, InternalFieldNames, SingleValueType } from '../Cascader';
+export type GetMissValues = ReturnType<typeof useMissingValues>;
+export default function useMissingValues(options: DefaultOptionType[], fieldNames: InternalFieldNames): (rawValues: SingleValueType[]) => [SingleValueType[], SingleValueType[]];

package/lib/hooks/useMissingValues.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useMissingValues;
+var React = _interopRequireWildcard(require("react"));
+var _treeUtil = require("../utils/treeUtil");
+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 useMissingValues(options, fieldNames) {
+  return React.useCallback(rawValues => {
+    const missingValues = [];
+    const existsValues = [];
+    rawValues.forEach(valueCell => {
+      const pathOptions = (0, _treeUtil.toPathOptions)(valueCell, options, fieldNames);
+      if (pathOptions.every(opt => opt.option)) {
+        existsValues.push(valueCell);
+      } else {
+        missingValues.push(valueCell);
+      }
+    });
+    return [existsValues, missingValues];
+  }, [options, fieldNames]);
+}

package/lib/hooks/useOptions.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import type { DefaultOptionType } from '..';
+import type { InternalFieldNames, SingleValueType } from '../Cascader';
+import { type GetEntities } from './useEntities';
+export default function useOptions(mergedFieldNames: InternalFieldNames, options?: DefaultOptionType[]): [
+    mergedOptions: DefaultOptionType[],
+    getPathKeyEntities: GetEntities,
+    getValueByKeyPath: (pathKeys: React.Key[]) => SingleValueType[]
+];

package/lib/hooks/useOptions.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useOptions;
+var React = _interopRequireWildcard(require("react"));
+var _useEntities = _interopRequireDefault(require("./useEntities"));
+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 useOptions(mergedFieldNames, options) {
+  const mergedOptions = React.useMemo(() => options || [], [options]);
+
+  // Only used in multiple mode, this fn will not call in single mode
+  const getPathKeyEntities = (0, _useEntities.default)(mergedOptions, mergedFieldNames);
+
+  /** Convert path key back to value format */
+  const getValueByKeyPath = React.useCallback(pathKeys => {
+    const keyPathEntities = getPathKeyEntities();
+    return pathKeys.map(pathKey => {
+      const {
+        nodes
+      } = keyPathEntities[pathKey];
+      return nodes.map(node => node[mergedFieldNames.value]);
+    });
+  }, [getPathKeyEntities, mergedFieldNames]);
+  return [mergedOptions, getPathKeyEntities, getValueByKeyPath];
+}

package/lib/hooks/useSearchConfig.d.ts

@@ -0,0 +1,2 @@
+import type { CascaderProps, ShowSearchType } from '../Cascader';
+export default function useSearchConfig(showSearch?: CascaderProps['showSearch']): [boolean, ShowSearchType<import("../Cascader").DefaultOptionType, string>];

package/lib/hooks/useSearchConfig.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useSearchConfig;
+var _warning = _interopRequireDefault(require("@rc-component/util/lib/warning"));
+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; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// Convert `showSearch` to unique config
+function useSearchConfig(showSearch) {
+  return React.useMemo(() => {
+    if (!showSearch) {
+      return [false, {}];
+    }
+    let searchConfig = {
+      matchInputWidth: true,
+      limit: 50
+    };
+    if (showSearch && typeof showSearch === 'object') {
+      searchConfig = {
+        ...searchConfig,
+        ...showSearch
+      };
+    }
+    if (searchConfig.limit <= 0) {
+      searchConfig.limit = false;
+      if (process.env.NODE_ENV !== 'production') {
+        (0, _warning.default)(false, "'limit' of showSearch should be positive number or false.");
+      }
+    }
+    return [true, searchConfig];
+  }, [showSearch]);
+}

package/lib/hooks/useSearchOptions.d.ts

@@ -0,0 +1,4 @@
+import type { DefaultOptionType, InternalFieldNames, ShowSearchType } from '../Cascader';
+export declare const SEARCH_MARK = "__rc_cascader_search_mark__";
+declare const useSearchOptions: (search: string, options: DefaultOptionType[], fieldNames: InternalFieldNames, prefixCls: string, config: ShowSearchType, enableHalfPath?: boolean) => DefaultOptionType[];
+export default useSearchOptions;

package/lib/hooks/useSearchOptions.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.SEARCH_MARK = 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 SEARCH_MARK = exports.SEARCH_MARK = '__rc_cascader_search_mark__';
+const defaultFilter = (search, options, {
+  label = ''
+}) => options.some(opt => String(opt[label]).toLowerCase().includes(search.toLowerCase()));
+const defaultRender = (inputValue, path, prefixCls, fieldNames) => path.map(opt => opt[fieldNames.label]).join(' / ');
+const useSearchOptions = (search, options, fieldNames, prefixCls, config, enableHalfPath) => {
+  const {
+    filter = defaultFilter,
+    render = defaultRender,
+    limit = 50,
+    sort
+  } = config;
+  return React.useMemo(() => {
+    const filteredOptions = [];
+    if (!search) {
+      return [];
+    }
+    function dig(list, pathOptions, parentDisabled = false) {
+      list.forEach(option => {
+        // Perf saving when `sort` is disabled and `limit` is provided
+        if (!sort && limit !== false && limit > 0 && filteredOptions.length >= limit) {
+          return;
+        }
+        const connectedPathOptions = [...pathOptions, option];
+        const children = option[fieldNames.children];
+        const mergedDisabled = parentDisabled || option.disabled;
+
+        // If current option is filterable
+        if (
+        // If is leaf option
+        !children || children.length === 0 ||
+        // If is changeOnSelect or multiple
+        enableHalfPath) {
+          if (filter(search, connectedPathOptions, {
+            label: fieldNames.label
+          })) {
+            filteredOptions.push({
+              ...option,
+              disabled: mergedDisabled,
+              [fieldNames.label]: render(search, connectedPathOptions, prefixCls, fieldNames),
+              [SEARCH_MARK]: connectedPathOptions,
+              [fieldNames.children]: undefined
+            });
+          }
+        }
+        if (children) {
+          dig(option[fieldNames.children], connectedPathOptions, mergedDisabled);
+        }
+      });
+    }
+    dig(options, []);
+
+    // Do sort
+    if (sort) {
+      filteredOptions.sort((a, b) => {
+        return sort(a[SEARCH_MARK], b[SEARCH_MARK], search, fieldNames);
+      });
+    }
+    return limit !== false && limit > 0 ? filteredOptions.slice(0, limit) : filteredOptions;
+  }, [search, options, fieldNames, prefixCls, render, enableHalfPath, filter, sort, limit]);
+};
+var _default = exports.default = useSearchOptions;

package/lib/hooks/useSelect.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import type { InternalValueType, ShowCheckedStrategy, SingleValueType } from '../Cascader';
+import type { GetEntities } from './useEntities';
+export default function useSelect(multiple: boolean, triggerChange: (nextValues: InternalValueType) => void, checkedValues: SingleValueType[], halfCheckedValues: SingleValueType[], missingCheckedValues: SingleValueType[], getPathKeyEntities: GetEntities, getValueByKeyPath: (pathKeys: React.Key[]) => SingleValueType[], showCheckedStrategy?: ShowCheckedStrategy): (valuePath: SingleValueType) => void;

package/lib/hooks/useSelect.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useSelect;
+var _conductUtil = require("rc-tree/lib/utils/conductUtil");
+var _commonUtil = require("../utils/commonUtil");
+var _treeUtil = require("../utils/treeUtil");
+function useSelect(multiple, triggerChange, checkedValues, halfCheckedValues, missingCheckedValues, getPathKeyEntities, getValueByKeyPath, showCheckedStrategy) {
+  return valuePath => {
+    if (!multiple) {
+      triggerChange(valuePath);
+    } else {
+      // Prepare conduct required info
+      const pathKey = (0, _commonUtil.toPathKey)(valuePath);
+      const checkedPathKeys = (0, _commonUtil.toPathKeys)(checkedValues);
+      const halfCheckedPathKeys = (0, _commonUtil.toPathKeys)(halfCheckedValues);
+      const existInChecked = checkedPathKeys.includes(pathKey);
+      const existInMissing = missingCheckedValues.some(valueCells => (0, _commonUtil.toPathKey)(valueCells) === pathKey);
+
+      // Do update
+      let nextCheckedValues = checkedValues;
+      let nextMissingValues = missingCheckedValues;
+      if (existInMissing && !existInChecked) {
+        // Missing value only do filter
+        nextMissingValues = missingCheckedValues.filter(valueCells => (0, _commonUtil.toPathKey)(valueCells) !== pathKey);
+      } else {
+        // Update checked key first
+        const nextRawCheckedKeys = existInChecked ? checkedPathKeys.filter(key => key !== pathKey) : [...checkedPathKeys, pathKey];
+        const pathKeyEntities = getPathKeyEntities();
+
+        // Conduction by selected or not
+        let checkedKeys;
+        if (existInChecked) {
+          ({
+            checkedKeys
+          } = (0, _conductUtil.conductCheck)(nextRawCheckedKeys, {
+            checked: false,
+            halfCheckedKeys: halfCheckedPathKeys
+          }, pathKeyEntities));
+        } else {
+          ({
+            checkedKeys
+          } = (0, _conductUtil.conductCheck)(nextRawCheckedKeys, true, pathKeyEntities));
+        }
+
+        // Roll up to parent level keys
+        const deDuplicatedKeys = (0, _treeUtil.formatStrategyValues)(checkedKeys, getPathKeyEntities, showCheckedStrategy);
+        nextCheckedValues = getValueByKeyPath(deDuplicatedKeys);
+      }
+      triggerChange([...nextMissingValues, ...nextCheckedValues]);
+    }
+  };
+}

package/lib/hooks/useValues.d.ts

@@ -0,0 +1,9 @@
+import type { DataEntity } from 'rc-tree/lib/interface';
+import * as React from 'react';
+import type { SingleValueType } from '../Cascader';
+import type { GetMissValues } from './useMissingValues';
+export default function useValues(multiple: boolean, rawValues: SingleValueType[], getPathKeyEntities: () => Record<string, DataEntity>, getValueByKeyPath: (pathKeys: React.Key[]) => SingleValueType[], getMissingValues: GetMissValues): [
+    checkedValues: SingleValueType[],
+    halfCheckedValues: SingleValueType[],
+    missingCheckedValues: SingleValueType[]
+];

package/lib/hooks/useValues.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useValues;
+var _conductUtil = require("rc-tree/lib/utils/conductUtil");
+var React = _interopRequireWildcard(require("react"));
+var _commonUtil = require("../utils/commonUtil");
+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 useValues(multiple, rawValues, getPathKeyEntities, getValueByKeyPath, getMissingValues) {
+  // Fill `rawValues` with checked conduction values
+  return React.useMemo(() => {
+    const [existValues, missingValues] = getMissingValues(rawValues);
+    if (!multiple || !rawValues.length) {
+      return [existValues, [], missingValues];
+    }
+    const keyPathValues = (0, _commonUtil.toPathKeys)(existValues);
+    const keyPathEntities = getPathKeyEntities();
+    const {
+      checkedKeys,
+      halfCheckedKeys
+    } = (0, _conductUtil.conductCheck)(keyPathValues, true, keyPathEntities);
+
+    // Convert key back to value cells
+    return [getValueByKeyPath(checkedKeys), getValueByKeyPath(halfCheckedKeys), missingValues];
+  }, [multiple, rawValues, getPathKeyEntities, getValueByKeyPath, getMissingValues]);
+}

package/lib/index.d.ts

@@ -0,0 +1,5 @@
+import Cascader from './Cascader';
+import Panel from './Panel';
+export type { BaseOptionType, DefaultOptionType, CascaderProps, FieldNames, ShowSearchType, CascaderRef, } from './Cascader';
+export { Panel };
+export default Cascader;

package/lib/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Panel", {
+  enumerable: true,
+  get: function () {
+    return _Panel.default;
+  }
+});
+exports.default = void 0;
+var _Cascader = _interopRequireDefault(require("./Cascader"));
+var _Panel = _interopRequireDefault(require("./Panel"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _default = exports.default = _Cascader.default;

package/lib/utils/commonUtil.d.ts

@@ -0,0 +1,18 @@
+import type { DefaultOptionType, FieldNames, InternalFieldNames, InternalValueType, SingleValueType } from '../Cascader';
+export declare const VALUE_SPLIT = "__RC_CASCADER_SPLIT__";
+export declare const SHOW_PARENT = "SHOW_PARENT";
+export declare const SHOW_CHILD = "SHOW_CHILD";
+/**
+ * Will convert value to string, and join with `VALUE_SPLIT`
+ */
+export declare function toPathKey(value: SingleValueType): string;
+/**
+ * Batch convert value to string, and join with `VALUE_SPLIT`
+ */
+export declare function toPathKeys(value: SingleValueType[]): string[];
+export declare function toPathValueStr(pathKey: string): string[];
+export declare function fillFieldNames(fieldNames?: FieldNames): InternalFieldNames;
+export declare function isLeaf(option: DefaultOptionType, fieldNames: FieldNames): any;
+export declare function scrollIntoParentView(element: HTMLElement): void;
+export declare function getFullPathKeys(options: DefaultOptionType[], fieldNames: FieldNames): any[];
+export declare function toRawValues(value?: InternalValueType): SingleValueType[];

package/lib/utils/commonUtil.js

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.VALUE_SPLIT = exports.SHOW_PARENT = exports.SHOW_CHILD = void 0;
+exports.fillFieldNames = fillFieldNames;
+exports.getFullPathKeys = getFullPathKeys;
+exports.isLeaf = isLeaf;
+exports.scrollIntoParentView = scrollIntoParentView;
+exports.toPathKey = toPathKey;
+exports.toPathKeys = toPathKeys;
+exports.toPathValueStr = toPathValueStr;
+exports.toRawValues = toRawValues;
+var _useSearchOptions = require("../hooks/useSearchOptions");
+const VALUE_SPLIT = exports.VALUE_SPLIT = '__RC_CASCADER_SPLIT__';
+const SHOW_PARENT = exports.SHOW_PARENT = 'SHOW_PARENT';
+const SHOW_CHILD = exports.SHOW_CHILD = 'SHOW_CHILD';
+
+/**
+ * Will convert value to string, and join with `VALUE_SPLIT`
+ */
+function toPathKey(value) {
+  return value.join(VALUE_SPLIT);
+}
+
+/**
+ * Batch convert value to string, and join with `VALUE_SPLIT`
+ */
+function toPathKeys(value) {
+  return value.map(toPathKey);
+}
+function toPathValueStr(pathKey) {
+  return pathKey.split(VALUE_SPLIT);
+}
+function fillFieldNames(fieldNames) {
+  const {
+    label,
+    value,
+    children
+  } = fieldNames || {};
+  const val = value || 'value';
+  return {
+    label: label || 'label',
+    value: val,
+    key: val,
+    children: children || 'children'
+  };
+}
+function isLeaf(option, fieldNames) {
+  return option.isLeaf ?? !option[fieldNames.children]?.length;
+}
+function scrollIntoParentView(element) {
+  const parent = element.parentElement;
+  if (!parent) {
+    return;
+  }
+  const elementToParent = element.offsetTop - parent.offsetTop; // offsetParent may not be parent.
+  if (elementToParent - parent.scrollTop < 0) {
+    parent.scrollTo({
+      top: elementToParent
+    });
+  } else if (elementToParent + element.offsetHeight - parent.scrollTop > parent.offsetHeight) {
+    parent.scrollTo({
+      top: elementToParent + element.offsetHeight - parent.offsetHeight
+    });
+  }
+}
+function getFullPathKeys(options, fieldNames) {
+  return options.map(item => item[_useSearchOptions.SEARCH_MARK]?.map(opt => opt[fieldNames.value]));
+}
+function isMultipleValue(value) {
+  return Array.isArray(value) && Array.isArray(value[0]);
+}
+function toRawValues(value) {
+  if (!value) {
+    return [];
+  }
+  if (isMultipleValue(value)) {
+    return value;
+  }
+  return (value.length === 0 ? [] : [value]).map(val => Array.isArray(val) ? val : [val]);
+}

package/lib/utils/treeUtil.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import type { SingleValueType, DefaultOptionType, InternalFieldNames, ShowCheckedStrategy } from '../Cascader';
+import type { GetEntities } from '../hooks/useEntities';
+export declare function formatStrategyValues(pathKeys: React.Key[], getKeyPathEntities: GetEntities, showCheckedStrategy?: ShowCheckedStrategy): import("react").Key[];
+export declare function toPathOptions(valueCells: SingleValueType, options: DefaultOptionType[], fieldNames: InternalFieldNames, stringMode?: boolean): {
+    value: SingleValueType[number];
+    index: number;
+    option: DefaultOptionType;
+}[];

package/lib/utils/treeUtil.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatStrategyValues = formatStrategyValues;
+exports.toPathOptions = toPathOptions;
+var _commonUtil = require("./commonUtil");
+function formatStrategyValues(pathKeys, getKeyPathEntities, showCheckedStrategy) {
+  const valueSet = new Set(pathKeys);
+  const keyPathEntities = getKeyPathEntities();
+  return pathKeys.filter(key => {
+    const entity = keyPathEntities[key];
+    const parent = entity ? entity.parent : null;
+    const children = entity ? entity.children : null;
+    if (entity && entity.node.disabled) {
+      return true;
+    }
+    return showCheckedStrategy === _commonUtil.SHOW_CHILD ? !(children && children.some(child => child.key && valueSet.has(child.key))) : !(parent && !parent.node.disabled && valueSet.has(parent.key));
+  });
+}
+function toPathOptions(valueCells, options, fieldNames,
+// Used for loadingKeys which saved loaded keys as string
+stringMode = false) {
+  let currentList = options;
+  const valueOptions = [];
+  for (let i = 0; i < valueCells.length; i += 1) {
+    const valueCell = valueCells[i];
+    const foundIndex = currentList?.findIndex(option => {
+      const val = option[fieldNames.value];
+      return stringMode ? String(val) === String(valueCell) : val === valueCell;
+    });
+    const foundOption = foundIndex !== -1 ? currentList?.[foundIndex] : null;
+    valueOptions.push({
+      value: foundOption?.[fieldNames.value] ?? valueCell,
+      index: foundIndex,
+      option: foundOption
+    });
+    currentList = foundOption?.[fieldNames.children];
+  }
+  return valueOptions;
+}

package/lib/utils/warningPropsUtil.d.ts

@@ -0,0 +1,4 @@
+import type { DefaultOptionType, FieldNames, InternalCascaderProps } from '../Cascader';
+declare function warningProps(props: InternalCascaderProps): void;
+export declare function warningNullOptions(options: DefaultOptionType[], fieldNames: FieldNames): 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;
+exports.warningNullOptions = warningNullOptions;
+var _warning = _interopRequireDefault(require("@rc-component/util/lib/warning"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function warningProps(props) {
+  const {
+    popupVisible,
+    popupPlacement
+  } = props;
+  (0, _warning.default)(popupVisible === undefined, '`popupVisible` is deprecated. Please use `open` instead.');
+  (0, _warning.default)(popupPlacement === undefined, '`popupPlacement` is deprecated. Please use `placement` instead.');
+}
+
+// value in Cascader options should not be null
+function warningNullOptions(options, fieldNames) {
+  if (options) {
+    const recursiveOptions = optionsList => {
+      for (let i = 0; i < optionsList.length; i++) {
+        const option = optionsList[i];
+        if (option[fieldNames?.value] === null) {
+          (0, _warning.default)(false, '`value` in Cascader options should not be `null`.');
+          return true;
+        }
+        if (Array.isArray(option[fieldNames?.children]) && recursiveOptions(option[fieldNames?.children])) {
+          return true;
+        }
+      }
+    };
+    recursiveOptions(options);
+  }
+}
+var _default = exports.default = warningProps;