@rc-component/select 1.0.0

package/lib/hooks/useLock.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Locker return cached mark.
+ * If set to `true`, will return `true` in a short time even if set `false`.
+ * If set to `false` and then set to `true`, will change to `true`.
+ * And after time duration, it will back to `null` automatically.
+ */
+export default function useLock(duration?: number): [() => boolean, (lock: boolean) => void];

package/lib/hooks/useLock.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useLock;
+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; }
+/**
+ * Locker return cached mark.
+ * If set to `true`, will return `true` in a short time even if set `false`.
+ * If set to `false` and then set to `true`, will change to `true`.
+ * And after time duration, it will back to `null` automatically.
+ */
+function useLock(duration = 250) {
+  const lockRef = React.useRef(null);
+  const timeoutRef = React.useRef(null);
+
+  // Clean up
+  React.useEffect(() => () => {
+    window.clearTimeout(timeoutRef.current);
+  }, []);
+  function doLock(locked) {
+    if (locked || lockRef.current === null) {
+      lockRef.current = locked;
+    }
+    window.clearTimeout(timeoutRef.current);
+    timeoutRef.current = window.setTimeout(() => {
+      lockRef.current = null;
+    }, duration);
+  }
+  return [() => lockRef.current, doLock];
+}

package/lib/hooks/useOptions.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import type { FieldNames, RawValueType } from '../Select';
+/**
+ * Parse `children` to `options` if `options` is not provided.
+ * Then flatten the `options`.
+ */
+declare const useOptions: <OptionType>(options: OptionType[], children: React.ReactNode, fieldNames: FieldNames, optionFilterProp: string, optionLabelProp: string) => {
+    options: OptionType[];
+    valueOptions: Map<RawValueType, OptionType>;
+    labelOptions: Map<React.ReactNode, OptionType>;
+};
+export default useOptions;

package/lib/hooks/useOptions.js

@@ -0,0 +1,52 @@
+"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; }
+/**
+ * Parse `children` to `options` if `options` is not provided.
+ * Then flatten the `options`.
+ */
+const useOptions = (options, children, fieldNames, optionFilterProp, optionLabelProp) => {
+  return React.useMemo(() => {
+    let mergedOptions = options;
+    const childrenAsData = !options;
+    if (childrenAsData) {
+      mergedOptions = (0, _legacyUtil.convertChildrenToData)(children);
+    }
+    const valueOptions = new Map();
+    const labelOptions = new Map();
+    const setLabelOptions = (labelOptionsMap, option, key) => {
+      if (key && typeof key === 'string') {
+        labelOptionsMap.set(option[key], option);
+      }
+    };
+    const dig = (optionList, isChildren = false) => {
+      // for loop to speed up collection speed
+      for (let i = 0; i < optionList.length; i += 1) {
+        const option = optionList[i];
+        if (!option[fieldNames.options] || isChildren) {
+          valueOptions.set(option[fieldNames.value], option);
+          setLabelOptions(labelOptions, option, fieldNames.label);
+          // https://github.com/ant-design/ant-design/issues/35304
+          setLabelOptions(labelOptions, option, optionFilterProp);
+          setLabelOptions(labelOptions, option, optionLabelProp);
+        } else {
+          dig(option[fieldNames.options], true);
+        }
+      }
+    };
+    dig(mergedOptions);
+    return {
+      options: mergedOptions,
+      valueOptions,
+      labelOptions
+    };
+  }, [options, children, fieldNames, optionFilterProp, optionLabelProp]);
+};
+var _default = exports.default = useOptions;

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/useSelectTriggerControl.d.ts

@@ -0,0 +1 @@
+export default function useSelectTriggerControl(elements: () => (HTMLElement | undefined)[], open: boolean, triggerOpen: (open: boolean) => void, customizedTrigger: boolean): void;

package/lib/hooks/useSelectTriggerControl.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useSelectTriggerControl;
+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 useSelectTriggerControl(elements, open, triggerOpen, customizedTrigger) {
+  const propsRef = React.useRef(null);
+  propsRef.current = {
+    open,
+    triggerOpen,
+    customizedTrigger
+  };
+  React.useEffect(() => {
+    function onGlobalMouseDown(event) {
+      // If trigger is customized, Trigger will take control of popupVisible
+      if (propsRef.current?.customizedTrigger) {
+        return;
+      }
+      let target = event.target;
+      if (target.shadowRoot && event.composed) {
+        target = event.composedPath()[0] || target;
+      }
+      if (propsRef.current.open && elements().filter(element => element).every(element => !element.contains(target) && element !== target)) {
+        // Should trigger close
+        propsRef.current.triggerOpen(false);
+      }
+    }
+    window.addEventListener('mousedown', onGlobalMouseDown);
+    return () => window.removeEventListener('mousedown', onGlobalMouseDown);
+  }, []);
+}

package/lib/index.d.ts

@@ -0,0 +1,10 @@
+import Select from './Select';
+import Option from './Option';
+import OptGroup from './OptGroup';
+import type { SelectProps } from './Select';
+import BaseSelect from './BaseSelect';
+import type { BaseSelectProps, BaseSelectRef, BaseSelectPropsWithoutPrivate } from './BaseSelect';
+import useBaseProps from './hooks/useBaseProps';
+export { Option, OptGroup, BaseSelect, useBaseProps };
+export type { SelectProps, BaseSelectProps, BaseSelectRef, BaseSelectPropsWithoutPrivate };
+export default Select;

package/lib/index.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "BaseSelect", {
+  enumerable: true,
+  get: function () {
+    return _BaseSelect.default;
+  }
+});
+Object.defineProperty(exports, "OptGroup", {
+  enumerable: true,
+  get: function () {
+    return _OptGroup.default;
+  }
+});
+Object.defineProperty(exports, "Option", {
+  enumerable: true,
+  get: function () {
+    return _Option.default;
+  }
+});
+exports.default = void 0;
+Object.defineProperty(exports, "useBaseProps", {
+  enumerable: true,
+  get: function () {
+    return _useBaseProps.default;
+  }
+});
+var _Select = _interopRequireDefault(require("./Select"));
+var _Option = _interopRequireDefault(require("./Option"));
+var _OptGroup = _interopRequireDefault(require("./OptGroup"));
+var _BaseSelect = _interopRequireDefault(require("./BaseSelect"));
+var _useBaseProps = _interopRequireDefault(require("./hooks/useBaseProps"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _default = exports.default = _Select.default;

package/lib/interface.d.ts

@@ -0,0 +1,23 @@
+import type * as React from 'react';
+export type RawValueType = string | number;
+export interface FlattenOptionData<OptionType> {
+    label?: React.ReactNode;
+    data: OptionType;
+    key: React.Key;
+    value?: RawValueType;
+    groupOption?: boolean;
+    group?: boolean;
+}
+export interface DisplayValueType {
+    key?: React.Key;
+    value?: RawValueType;
+    label?: React.ReactNode;
+    title?: React.ReactNode;
+    disabled?: boolean;
+    index?: number;
+}
+export type RenderNode = React.ReactNode | ((props: any) => React.ReactNode);
+export type RenderDOMFunc = (props: any) => HTMLElement;
+export type Mode = 'multiple' | 'tags' | 'combobox';
+export type Placement = 'bottomLeft' | 'bottomRight' | 'topLeft' | 'topRight';
+export type DisplayInfoType = 'add' | 'remove' | 'clear';

package/lib/interface.js

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

package/lib/utils/__mocks__/platformUtil.d.ts

@@ -0,0 +1 @@
+export declare function isPlatformMac(): boolean;

package/lib/utils/__mocks__/platformUtil.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isPlatformMac = isPlatformMac;
+function isPlatformMac() {
+  return true;
+}

package/lib/utils/commonUtil.d.ts

@@ -0,0 +1,9 @@
+import type { DisplayValueType } from '../BaseSelect';
+export declare function toArray<T>(value: T | T[]): T[];
+export declare const isClient: HTMLElement;
+/** Is client side and not jsdom */
+export declare const isBrowserClient: HTMLElement;
+export declare function hasValue(value: any): boolean;
+/** combo mode no value judgment function */
+export declare function isComboNoValue(value: any): boolean;
+export declare function getTitle(item: DisplayValueType): string;

package/lib/utils/commonUtil.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getTitle = getTitle;
+exports.hasValue = hasValue;
+exports.isClient = exports.isBrowserClient = void 0;
+exports.isComboNoValue = isComboNoValue;
+exports.toArray = toArray;
+function toArray(value) {
+  if (Array.isArray(value)) {
+    return value;
+  }
+  return value !== undefined ? [value] : [];
+}
+const isClient = exports.isClient = typeof window !== 'undefined' && window.document && window.document.documentElement;
+
+/** Is client side and not jsdom */
+const isBrowserClient = exports.isBrowserClient = process.env.NODE_ENV !== 'test' && isClient;
+function hasValue(value) {
+  return value !== undefined && value !== null;
+}
+
+/** combo mode no value judgment function */
+function isComboNoValue(value) {
+  return !value && value !== 0;
+}
+function isTitleType(title) {
+  return ['string', 'number'].includes(typeof title);
+}
+function getTitle(item) {
+  let title = undefined;
+  if (item) {
+    if (isTitleType(item.title)) {
+      title = item.title.toString();
+    } else if (isTitleType(item.label)) {
+      title = item.label.toString();
+    }
+  }
+  return title;
+}

package/lib/utils/keyUtil.d.ts

@@ -0,0 +1,2 @@
+/** keyCode Judgment function */
+export declare function isValidateOpenKey(currentKeyCode: number): boolean;

package/lib/utils/keyUtil.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isValidateOpenKey = isValidateOpenKey;
+var _KeyCode = _interopRequireDefault(require("@rc-component/util/lib/KeyCode"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/** keyCode Judgment function */
+function isValidateOpenKey(currentKeyCode) {
+  return (
+    // Undefined for Edge bug:
+    // https://github.com/ant-design/ant-design/issues/51292
+    currentKeyCode &&
+    // Other keys
+    ![
+    // System function button
+    _KeyCode.default.ESC, _KeyCode.default.SHIFT, _KeyCode.default.BACKSPACE, _KeyCode.default.TAB, _KeyCode.default.WIN_KEY, _KeyCode.default.ALT, _KeyCode.default.META, _KeyCode.default.WIN_KEY_RIGHT, _KeyCode.default.CTRL, _KeyCode.default.SEMICOLON, _KeyCode.default.EQUALS, _KeyCode.default.CAPS_LOCK, _KeyCode.default.CONTEXT_MENU,
+    // F1-F12
+    _KeyCode.default.F1, _KeyCode.default.F2, _KeyCode.default.F3, _KeyCode.default.F4, _KeyCode.default.F5, _KeyCode.default.F6, _KeyCode.default.F7, _KeyCode.default.F8, _KeyCode.default.F9, _KeyCode.default.F10, _KeyCode.default.F11, _KeyCode.default.F12].includes(currentKeyCode)
+  );
+}

package/lib/utils/legacyUtil.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+import type { BaseOptionType, DefaultOptionType } from '../Select';
+export declare function convertChildrenToData<OptionType extends BaseOptionType = DefaultOptionType>(nodes: React.ReactNode, optionOnly?: boolean): OptionType[];

package/lib/utils/legacyUtil.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertChildrenToData = convertChildrenToData;
+var React = _interopRequireWildcard(require("react"));
+var _toArray = _interopRequireDefault(require("@rc-component/util/lib/Children/toArray"));
+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 convertNodeToOption(node) {
+  const {
+    key,
+    props: {
+      children,
+      value,
+      ...restProps
+    }
+  } = node;
+  return {
+    key,
+    value: value !== undefined ? value : key,
+    children,
+    ...restProps
+  };
+}
+function convertChildrenToData(nodes, optionOnly = false) {
+  return (0, _toArray.default)(nodes).map((node, index) => {
+    if (! /*#__PURE__*/React.isValidElement(node) || !node.type) {
+      return null;
+    }
+    const {
+      type: {
+        isSelectOptGroup
+      },
+      key,
+      props: {
+        children,
+        ...restProps
+      }
+    } = node;
+    if (optionOnly || !isSelectOptGroup) {
+      return convertNodeToOption(node);
+    }
+    return {
+      key: `__RC_SELECT_GRP__${key === null ? index : key}__`,
+      label: key,
+      ...restProps,
+      options: convertChildrenToData(children)
+    };
+  }).filter(data => data);
+}

package/lib/utils/platformUtil.d.ts

@@ -0,0 +1 @@
+export declare function isPlatformMac(): boolean;

package/lib/utils/platformUtil.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isPlatformMac = isPlatformMac;
+/* istanbul ignore file */
+function isPlatformMac() {
+  return /(mac\sos|macintosh)/i.test(navigator.appVersion);
+}

package/lib/utils/valueUtil.d.ts

@@ -0,0 +1,24 @@
+import type { BaseOptionType, DefaultOptionType } from '../Select';
+import type { FieldNames } from '../Select';
+import type { FlattenOptionData } from '../interface';
+export declare function isValidCount(value?: number): boolean;
+export declare function fillFieldNames(fieldNames: FieldNames | undefined, childrenAsData: boolean): {
+    label: string;
+    value: string;
+    options: string;
+    groupLabel: string;
+};
+/**
+ * Flat options into flatten list.
+ * We use `optionOnly` here is aim to avoid user use nested option group.
+ * Here is simply set `key` to the index if not provided.
+ */
+export declare function flattenOptions<OptionType extends BaseOptionType = DefaultOptionType>(options: OptionType[], { fieldNames, childrenAsData }?: {
+    fieldNames?: FieldNames;
+    childrenAsData?: boolean;
+}): FlattenOptionData<OptionType>[];
+/**
+ * Inject `props` into `option` for legacy usage
+ */
+export declare function injectPropsWithOption<T extends object>(option: T): T;
+export declare const getSeparatedContent: (text: string, tokens: string[], end?: number) => string[];

package/lib/utils/valueUtil.js

@@ -0,0 +1,140 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fillFieldNames = fillFieldNames;
+exports.flattenOptions = flattenOptions;
+exports.getSeparatedContent = void 0;
+exports.injectPropsWithOption = injectPropsWithOption;
+exports.isValidCount = isValidCount;
+var _warning = _interopRequireDefault(require("@rc-component/util/lib/warning"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function getKey(data, index) {
+  const {
+    key
+  } = data;
+  let value;
+  if ('value' in data) {
+    ({
+      value
+    } = data);
+  }
+  if (key !== null && key !== undefined) {
+    return key;
+  }
+  if (value !== undefined) {
+    return value;
+  }
+  return `rc-index-key-${index}`;
+}
+function isValidCount(value) {
+  return typeof value !== 'undefined' && !Number.isNaN(value);
+}
+function fillFieldNames(fieldNames, childrenAsData) {
+  const {
+    label,
+    value,
+    options,
+    groupLabel
+  } = fieldNames || {};
+  const mergedLabel = label || (childrenAsData ? 'children' : 'label');
+  return {
+    label: mergedLabel,
+    value: value || 'value',
+    options: options || 'options',
+    groupLabel: groupLabel || mergedLabel
+  };
+}
+
+/**
+ * Flat options into flatten list.
+ * We use `optionOnly` here is aim to avoid user use nested option group.
+ * Here is simply set `key` to the index if not provided.
+ */
+function flattenOptions(options, {
+  fieldNames,
+  childrenAsData
+} = {}) {
+  const flattenList = [];
+  const {
+    label: fieldLabel,
+    value: fieldValue,
+    options: fieldOptions,
+    groupLabel
+  } = fillFieldNames(fieldNames, false);
+  function dig(list, isGroupOption) {
+    if (!Array.isArray(list)) {
+      return;
+    }
+    list.forEach(data => {
+      if (isGroupOption || !(fieldOptions in data)) {
+        const value = data[fieldValue];
+
+        // Option
+        flattenList.push({
+          key: getKey(data, flattenList.length),
+          groupOption: isGroupOption,
+          data,
+          label: data[fieldLabel],
+          value
+        });
+      } else {
+        let grpLabel = data[groupLabel];
+        if (grpLabel === undefined && childrenAsData) {
+          grpLabel = data.label;
+        }
+
+        // Option Group
+        flattenList.push({
+          key: getKey(data, flattenList.length),
+          group: true,
+          data,
+          label: grpLabel
+        });
+        dig(data[fieldOptions], true);
+      }
+    });
+  }
+  dig(options, false);
+  return flattenList;
+}
+
+/**
+ * Inject `props` into `option` for legacy usage
+ */
+function injectPropsWithOption(option) {
+  const newOption = {
+    ...option
+  };
+  if (!('props' in newOption)) {
+    Object.defineProperty(newOption, 'props', {
+      get() {
+        (0, _warning.default)(false, 'Return type is option instead of Option instance. Please read value directly instead of reading from `props`.');
+        return newOption;
+      }
+    });
+  }
+  return newOption;
+}
+const getSeparatedContent = (text, tokens, end) => {
+  if (!tokens || !tokens.length) {
+    return null;
+  }
+  let match = false;
+  const separate = (str, [token, ...restTokens]) => {
+    if (!token) {
+      return [str];
+    }
+    const list = str.split(token);
+    match = match || list.length > 1;
+    return list.reduce((prevList, unitStr) => [...prevList, ...separate(unitStr, restTokens)], []).filter(Boolean);
+  };
+  const list = separate(text, tokens);
+  if (match) {
+    return typeof end !== 'undefined' ? list.slice(0, end) : list;
+  } else {
+    return null;
+  }
+};
+exports.getSeparatedContent = getSeparatedContent;

package/lib/utils/warningPropsUtil.d.ts

@@ -0,0 +1,4 @@
+import type { DefaultOptionType, FieldNames, SelectProps } from '../Select';
+declare function warningProps(props: SelectProps): void;
+export declare function warningNullOptions(options: DefaultOptionType[], fieldNames: FieldNames): void;
+export default warningProps;