@rc-component/cascader 1.0.0

package/es/hooks/useEntities.js

@@ -0,0 +1,35 @@
+import * as React from 'react';
+import { convertDataToEntities } from "rc-tree/es/utils/treeUtil";
+import { VALUE_SPLIT } from "../utils/commonUtil";
+/** Lazy parse options data into conduct-able info to avoid perf issue in single mode */
+export 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 = convertDataToEntities(options, {
+        fieldNames: fieldNames,
+        initWrapper: wrapper => ({
+          ...wrapper,
+          pathKeyEntities: {}
+        }),
+        processEntity: (entity, wrapper) => {
+          const pathKey = entity.nodes.map(node => node[fieldNames.value]).join(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;
+});

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

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import { toPathOptions } from "../utils/treeUtil";
+export default function useMissingValues(options, fieldNames) {
+  return React.useCallback(rawValues => {
+    const missingValues = [];
+    const existsValues = [];
+    rawValues.forEach(valueCell => {
+      const pathOptions = toPathOptions(valueCell, options, fieldNames);
+      if (pathOptions.every(opt => opt.option)) {
+        existsValues.push(valueCell);
+      } else {
+        missingValues.push(valueCell);
+      }
+    });
+    return [existsValues, missingValues];
+  }, [options, fieldNames]);
+}

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

@@ -0,0 +1,20 @@
+import * as React from 'react';
+import useEntities from "./useEntities";
+export default 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 = useEntities(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/es/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/es/hooks/useSearchConfig.js

@@ -0,0 +1,27 @@
+import warning from "@rc-component/util/es/warning";
+import * as React from 'react';
+// Convert `showSearch` to unique config
+export default 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') {
+        warning(false, "'limit' of showSearch should be positive number or false.");
+      }
+    }
+    return [true, searchConfig];
+  }, [showSearch]);
+}

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

@@ -0,0 +1,63 @@
+import * as React from 'react';
+export const 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]);
+};
+export default useSearchOptions;

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

@@ -0,0 +1,49 @@
+import { conductCheck } from "rc-tree/es/utils/conductUtil";
+import { toPathKey, toPathKeys } from "../utils/commonUtil";
+import { formatStrategyValues } from "../utils/treeUtil";
+export default function useSelect(multiple, triggerChange, checkedValues, halfCheckedValues, missingCheckedValues, getPathKeyEntities, getValueByKeyPath, showCheckedStrategy) {
+  return valuePath => {
+    if (!multiple) {
+      triggerChange(valuePath);
+    } else {
+      // Prepare conduct required info
+      const pathKey = toPathKey(valuePath);
+      const checkedPathKeys = toPathKeys(checkedValues);
+      const halfCheckedPathKeys = toPathKeys(halfCheckedValues);
+      const existInChecked = checkedPathKeys.includes(pathKey);
+      const existInMissing = missingCheckedValues.some(valueCells => toPathKey(valueCells) === pathKey);
+
+      // Do update
+      let nextCheckedValues = checkedValues;
+      let nextMissingValues = missingCheckedValues;
+      if (existInMissing && !existInChecked) {
+        // Missing value only do filter
+        nextMissingValues = missingCheckedValues.filter(valueCells => 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
+          } = conductCheck(nextRawCheckedKeys, {
+            checked: false,
+            halfCheckedKeys: halfCheckedPathKeys
+          }, pathKeyEntities));
+        } else {
+          ({
+            checkedKeys
+          } = conductCheck(nextRawCheckedKeys, true, pathKeyEntities));
+        }
+
+        // Roll up to parent level keys
+        const deDuplicatedKeys = formatStrategyValues(checkedKeys, getPathKeyEntities, showCheckedStrategy);
+        nextCheckedValues = getValueByKeyPath(deDuplicatedKeys);
+      }
+      triggerChange([...nextMissingValues, ...nextCheckedValues]);
+    }
+  };
+}

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

@@ -0,0 +1,21 @@
+import { conductCheck } from "rc-tree/es/utils/conductUtil";
+import * as React from 'react';
+import { toPathKeys } from "../utils/commonUtil";
+export default 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 = toPathKeys(existValues);
+    const keyPathEntities = getPathKeyEntities();
+    const {
+      checkedKeys,
+      halfCheckedKeys
+    } = conductCheck(keyPathValues, true, keyPathEntities);
+
+    // Convert key back to value cells
+    return [getValueByKeyPath(checkedKeys), getValueByKeyPath(halfCheckedKeys), missingValues];
+  }, [multiple, rawValues, getPathKeyEntities, getValueByKeyPath, getMissingValues]);
+}

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

@@ -0,0 +1,4 @@
+import Cascader from "./Cascader";
+import Panel from "./Panel";
+export { Panel };
+export default Cascader;

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

@@ -0,0 +1,69 @@
+import { SEARCH_MARK } from "../hooks/useSearchOptions";
+export const VALUE_SPLIT = '__RC_CASCADER_SPLIT__';
+export const SHOW_PARENT = 'SHOW_PARENT';
+export const SHOW_CHILD = 'SHOW_CHILD';
+
+/**
+ * Will convert value to string, and join with `VALUE_SPLIT`
+ */
+export function toPathKey(value) {
+  return value.join(VALUE_SPLIT);
+}
+
+/**
+ * Batch convert value to string, and join with `VALUE_SPLIT`
+ */
+export function toPathKeys(value) {
+  return value.map(toPathKey);
+}
+export function toPathValueStr(pathKey) {
+  return pathKey.split(VALUE_SPLIT);
+}
+export function fillFieldNames(fieldNames) {
+  const {
+    label,
+    value,
+    children
+  } = fieldNames || {};
+  const val = value || 'value';
+  return {
+    label: label || 'label',
+    value: val,
+    key: val,
+    children: children || 'children'
+  };
+}
+export function isLeaf(option, fieldNames) {
+  return option.isLeaf ?? !option[fieldNames.children]?.length;
+}
+export 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
+    });
+  }
+}
+export function getFullPathKeys(options, fieldNames) {
+  return options.map(item => item[SEARCH_MARK]?.map(opt => opt[fieldNames.value]));
+}
+function isMultipleValue(value) {
+  return Array.isArray(value) && Array.isArray(value[0]);
+}
+export function toRawValues(value) {
+  if (!value) {
+    return [];
+  }
+  if (isMultipleValue(value)) {
+    return value;
+  }
+  return (value.length === 0 ? [] : [value]).map(val => Array.isArray(val) ? val : [val]);
+}

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

@@ -0,0 +1,35 @@
+import { SHOW_CHILD } from "./commonUtil";
+export 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 === SHOW_CHILD ? !(children && children.some(child => child.key && valueSet.has(child.key))) : !(parent && !parent.node.disabled && valueSet.has(parent.key));
+  });
+}
+export 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/es/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/es/utils/warningPropsUtil.js

@@ -0,0 +1,29 @@
+import warning from "@rc-component/util/es/warning";
+function warningProps(props) {
+  const {
+    popupVisible,
+    popupPlacement
+  } = props;
+  warning(popupVisible === undefined, '`popupVisible` is deprecated. Please use `open` instead.');
+  warning(popupPlacement === undefined, '`popupPlacement` is deprecated. Please use `placement` instead.');
+}
+
+// value in Cascader options should not be null
+export 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) {
+          warning(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);
+  }
+}
+export default warningProps;

package/lib/Cascader.d.ts

@@ -0,0 +1,88 @@
+import type { BuildInPlacements } from '@rc-component/trigger/lib/interface';
+import type { BaseSelectPropsWithoutPrivate, BaseSelectRef } from '@rc-component/select';
+import type { Placement } from '@rc-component/select/lib/BaseSelect';
+import * as React from 'react';
+import Panel from './Panel';
+import { SHOW_CHILD, SHOW_PARENT } from './utils/commonUtil';
+export interface BaseOptionType {
+    disabled?: boolean;
+    disableCheckbox?: boolean;
+    label?: React.ReactNode;
+    value?: string | number | null;
+    children?: DefaultOptionType[];
+}
+export type DefaultOptionType = BaseOptionType & Record<string, any>;
+export interface ShowSearchType<OptionType extends DefaultOptionType = DefaultOptionType, ValueField extends keyof OptionType = keyof OptionType> {
+    filter?: (inputValue: string, options: OptionType[], fieldNames: FieldNames<OptionType, ValueField>) => boolean;
+    render?: (inputValue: string, path: OptionType[], prefixCls: string, fieldNames: FieldNames<OptionType, ValueField>) => React.ReactNode;
+    sort?: (a: OptionType[], b: OptionType[], inputValue: string, fieldNames: FieldNames<OptionType, ValueField>) => number;
+    matchInputWidth?: boolean;
+    limit?: number | false;
+}
+export type ShowCheckedStrategy = typeof SHOW_PARENT | typeof SHOW_CHILD;
+interface BaseCascaderProps<OptionType extends DefaultOptionType = DefaultOptionType, ValueField extends keyof OptionType = keyof OptionType> extends Omit<BaseSelectPropsWithoutPrivate, 'tokenSeparators' | 'labelInValue' | 'mode' | 'showSearch'> {
+    id?: string;
+    prefixCls?: string;
+    fieldNames?: FieldNames<OptionType, ValueField>;
+    optionRender?: (option: OptionType) => React.ReactNode;
+    children?: React.ReactElement;
+    changeOnSelect?: boolean;
+    displayRender?: (label: string[], selectedOptions?: OptionType[]) => React.ReactNode;
+    checkable?: boolean | React.ReactNode;
+    showCheckedStrategy?: ShowCheckedStrategy;
+    autoClearSearchValue?: boolean;
+    showSearch?: boolean | ShowSearchType<OptionType>;
+    searchValue?: string;
+    onSearch?: (value: string) => void;
+    expandTrigger?: 'hover' | 'click';
+    options?: OptionType[];
+    /** @private Internal usage. Do not use in your production. */
+    dropdownPrefixCls?: string;
+    loadData?: (selectOptions: OptionType[]) => void;
+    /** @deprecated Use `open` instead */
+    popupVisible?: boolean;
+    popupClassName?: string;
+    dropdownMenuColumnStyle?: React.CSSProperties;
+    /** @deprecated Use `placement` instead */
+    popupPlacement?: Placement;
+    placement?: Placement;
+    builtinPlacements?: BuildInPlacements;
+    onPopupVisibleChange?: (open: boolean) => void;
+    expandIcon?: React.ReactNode;
+    loadingIcon?: React.ReactNode;
+}
+export interface FieldNames<OptionType extends DefaultOptionType = DefaultOptionType, ValueField extends keyof OptionType = keyof OptionType> {
+    label?: keyof OptionType;
+    value?: keyof OptionType | ValueField;
+    children?: keyof OptionType;
+}
+export type ValueType<OptionType extends DefaultOptionType = DefaultOptionType, ValueField extends keyof OptionType = keyof OptionType> = keyof OptionType extends ValueField ? unknown extends OptionType['value'] ? OptionType[ValueField] : OptionType['value'] : OptionType[ValueField];
+export type GetValueType<OptionType extends DefaultOptionType = DefaultOptionType, ValueField extends keyof OptionType = keyof OptionType, Multiple extends boolean | React.ReactNode = false> = false extends Multiple ? ValueType<Required<OptionType>, ValueField>[] : ValueType<Required<OptionType>, ValueField>[][];
+export interface CascaderProps<OptionType extends DefaultOptionType = DefaultOptionType, ValueField extends keyof OptionType = keyof OptionType, Multiple extends boolean | React.ReactNode = false> extends BaseCascaderProps<OptionType, ValueField> {
+    checkable?: Multiple;
+    value?: GetValueType<OptionType, ValueField, Multiple>;
+    defaultValue?: GetValueType<OptionType, ValueField, Multiple>;
+    onChange?: (value: GetValueType<OptionType, ValueField, Multiple>, selectOptions: OptionType[]) => void;
+}
+export type SingleValueType = (string | number)[];
+export type InternalValueType = SingleValueType | SingleValueType[];
+export interface InternalFieldNames extends Required<FieldNames> {
+    key: string;
+}
+export type InternalCascaderProps = Omit<CascaderProps, 'onChange' | 'value' | 'defaultValue'> & {
+    value?: InternalValueType;
+    defaultValue?: InternalValueType;
+    onChange?: (value: InternalValueType, selectOptions: BaseOptionType[] | BaseOptionType[][]) => void;
+};
+export type CascaderRef = Omit<BaseSelectRef, 'scrollTo'>;
+declare const Cascader: (<OptionType extends DefaultOptionType = DefaultOptionType, ValueField extends keyof OptionType = keyof OptionType, Multiple extends React.ReactNode = false>(props: CascaderProps<OptionType, ValueField, Multiple> & {
+    children?: React.ReactNode;
+} & {
+    ref?: React.Ref<CascaderRef> | undefined;
+}) => React.ReactElement) & {
+    displayName?: string | undefined;
+    SHOW_PARENT: typeof SHOW_PARENT;
+    SHOW_CHILD: typeof SHOW_CHILD;
+    Panel: typeof Panel;
+};
+export default Cascader;