@rc-component/select 1.0.0

package/es/Selector/index.js

@@ -0,0 +1,184 @@
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+/**
+ * Cursor rule:
+ * 1. Only `showSearch` enabled
+ * 2. Only `open` is `true`
+ * 3. When typing, set `open` to `true` which hit rule of 2
+ *
+ * Accessibility:
+ * - https://www.w3.org/TR/wai-aria-practices/examples/combobox/aria1.1pattern/listbox-combo.html
+ */
+
+import KeyCode from "@rc-component/util/es/KeyCode";
+import * as React from 'react';
+import { useRef } from 'react';
+import useLock from "../hooks/useLock";
+import { isValidateOpenKey } from "../utils/keyUtil";
+import MultipleSelector from "./MultipleSelector";
+import SingleSelector from "./SingleSelector";
+const Selector = (props, ref) => {
+  const inputRef = useRef(null);
+  const compositionStatusRef = useRef(false);
+  const {
+    prefixCls,
+    open,
+    mode,
+    showSearch,
+    tokenWithEnter,
+    disabled,
+    prefix,
+    autoClearSearchValue,
+    onSearch,
+    onSearchSubmit,
+    onToggleOpen,
+    onInputKeyDown,
+    onInputBlur,
+    domRef
+  } = props;
+
+  // ======================= Ref =======================
+  React.useImperativeHandle(ref, () => ({
+    focus: options => {
+      inputRef.current.focus(options);
+    },
+    blur: () => {
+      inputRef.current.blur();
+    }
+  }));
+
+  // ====================== Input ======================
+  const [getInputMouseDown, setInputMouseDown] = useLock(0);
+  const onInternalInputKeyDown = event => {
+    const {
+      which
+    } = event;
+
+    // Compatible with multiple lines in TextArea
+    const isTextAreaElement = inputRef.current instanceof HTMLTextAreaElement;
+    if (!isTextAreaElement && open && (which === KeyCode.UP || which === KeyCode.DOWN)) {
+      event.preventDefault();
+    }
+    if (onInputKeyDown) {
+      onInputKeyDown(event);
+    }
+    if (which === KeyCode.ENTER && mode === 'tags' && !compositionStatusRef.current && !open) {
+      // When menu isn't open, OptionList won't trigger a value change
+      // So when enter is pressed, the tag's input value should be emitted here to let selector know
+      onSearchSubmit?.(event.target.value);
+    }
+    // Move within the text box
+    if (isTextAreaElement && !open && ~[KeyCode.UP, KeyCode.DOWN, KeyCode.LEFT, KeyCode.RIGHT].indexOf(which)) {
+      return;
+    }
+    if (isValidateOpenKey(which)) {
+      onToggleOpen(true);
+    }
+  };
+
+  /**
+   * We can not use `findDOMNode` sine it will get warning,
+   * have to use timer to check if is input element.
+   */
+  const onInternalInputMouseDown = () => {
+    setInputMouseDown(true);
+  };
+
+  // When paste come, ignore next onChange
+  const pastedTextRef = useRef(null);
+  const triggerOnSearch = value => {
+    if (onSearch(value, true, compositionStatusRef.current) !== false) {
+      onToggleOpen(true);
+    }
+  };
+  const onInputCompositionStart = () => {
+    compositionStatusRef.current = true;
+  };
+  const onInputCompositionEnd = e => {
+    compositionStatusRef.current = false;
+
+    // Trigger search again to support `tokenSeparators` with typewriting
+    if (mode !== 'combobox') {
+      triggerOnSearch(e.target.value);
+    }
+  };
+  const onInputChange = event => {
+    let {
+      target: {
+        value
+      }
+    } = event;
+
+    // Pasted text should replace back to origin content
+    if (tokenWithEnter && pastedTextRef.current && /[\r\n]/.test(pastedTextRef.current)) {
+      // CRLF will be treated as a single space for input element
+      const replacedText = pastedTextRef.current.replace(/[\r\n]+$/, '').replace(/\r\n/g, ' ').replace(/[\r\n]/g, ' ');
+      value = value.replace(replacedText, pastedTextRef.current);
+    }
+    pastedTextRef.current = null;
+    triggerOnSearch(value);
+  };
+  const onInputPaste = e => {
+    const {
+      clipboardData
+    } = e;
+    const value = clipboardData?.getData('text');
+    pastedTextRef.current = value || '';
+  };
+  const onClick = ({
+    target
+  }) => {
+    if (target !== inputRef.current) {
+      // Should focus input if click the selector
+      const isIE = document.body.style.msTouchAction !== undefined;
+      if (isIE) {
+        setTimeout(() => {
+          inputRef.current.focus();
+        });
+      } else {
+        inputRef.current.focus();
+      }
+    }
+  };
+  const onMouseDown = event => {
+    const inputMouseDown = getInputMouseDown();
+
+    // when mode is combobox and it is disabled, don't prevent default behavior
+    // https://github.com/ant-design/ant-design/issues/37320
+    // https://github.com/ant-design/ant-design/issues/48281
+    if (event.target !== inputRef.current && !inputMouseDown && !(mode === 'combobox' && disabled)) {
+      event.preventDefault();
+    }
+    if (mode !== 'combobox' && (!showSearch || !inputMouseDown) || !open) {
+      if (open && autoClearSearchValue !== false) {
+        onSearch('', true, false);
+      }
+      onToggleOpen();
+    }
+  };
+
+  // ================= Inner Selector ==================
+  const sharedProps = {
+    inputRef,
+    onInputKeyDown: onInternalInputKeyDown,
+    onInputMouseDown: onInternalInputMouseDown,
+    onInputChange,
+    onInputPaste,
+    onInputCompositionStart,
+    onInputCompositionEnd,
+    onInputBlur
+  };
+  const selectNode = mode === 'multiple' || mode === 'tags' ? /*#__PURE__*/React.createElement(MultipleSelector, _extends({}, props, sharedProps)) : /*#__PURE__*/React.createElement(SingleSelector, _extends({}, props, sharedProps));
+  return /*#__PURE__*/React.createElement("div", {
+    ref: domRef,
+    className: `${prefixCls}-selector`,
+    onClick: onClick,
+    onMouseDown: onMouseDown
+  }, prefix && /*#__PURE__*/React.createElement("div", {
+    className: `${prefixCls}-prefix`
+  }, prefix), selectNode);
+};
+const ForwardSelector = /*#__PURE__*/React.forwardRef(Selector);
+if (process.env.NODE_ENV !== 'production') {
+  ForwardSelector.displayName = 'Selector';
+}
+export default ForwardSelector;

package/es/TransBtn.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import type { RenderNode } from './BaseSelect';
+export interface TransBtnProps {
+    className: string;
+    customizeIcon: RenderNode;
+    customizeIconProps?: any;
+    onMouseDown?: React.MouseEventHandler<HTMLSpanElement>;
+    onClick?: React.MouseEventHandler<HTMLSpanElement>;
+    children?: React.ReactNode;
+}
+declare const TransBtn: React.FC<TransBtnProps>;
+export default TransBtn;

package/es/TransBtn.js

@@ -0,0 +1,30 @@
+import * as React from 'react';
+import classNames from 'classnames';
+const TransBtn = props => {
+  const {
+    className,
+    customizeIcon,
+    customizeIconProps,
+    children,
+    onMouseDown,
+    onClick
+  } = props;
+  const icon = typeof customizeIcon === 'function' ? customizeIcon(customizeIconProps) : customizeIcon;
+  return /*#__PURE__*/React.createElement("span", {
+    className: className,
+    onMouseDown: event => {
+      event.preventDefault();
+      onMouseDown?.(event);
+    },
+    style: {
+      userSelect: 'none',
+      WebkitUserSelect: 'none'
+    },
+    unselectable: "on",
+    onClick: onClick,
+    "aria-hidden": true
+  }, icon !== undefined ? icon : /*#__PURE__*/React.createElement("span", {
+    className: classNames(className.split(/\s+/).map(cls => `${cls}-icon`))
+  }, children));
+};
+export default TransBtn;

package/es/hooks/useAllowClear.d.ts

@@ -0,0 +1,8 @@
+import type { DisplayValueType, Mode, RenderNode } from '../interface';
+import React from 'react';
+export declare const useAllowClear: (prefixCls: string, onClearMouseDown: React.MouseEventHandler<HTMLSpanElement>, displayValues: DisplayValueType[], allowClear?: boolean | {
+    clearIcon?: RenderNode;
+}, clearIcon?: RenderNode, disabled?: boolean, mergedSearchValue?: string, mode?: Mode) => {
+    allowClear: boolean;
+    clearIcon: React.JSX.Element;
+};

package/es/hooks/useAllowClear.js

@@ -0,0 +1,26 @@
+import TransBtn from "../TransBtn";
+import React from 'react';
+export const useAllowClear = (prefixCls, onClearMouseDown, displayValues, allowClear, clearIcon, disabled = false, mergedSearchValue, mode) => {
+  const mergedClearIcon = React.useMemo(() => {
+    if (typeof allowClear === 'object') {
+      return allowClear.clearIcon;
+    }
+    if (clearIcon) {
+      return clearIcon;
+    }
+  }, [allowClear, clearIcon]);
+  const mergedAllowClear = React.useMemo(() => {
+    if (!disabled && !!allowClear && (displayValues.length || mergedSearchValue) && !(mode === 'combobox' && mergedSearchValue === '')) {
+      return true;
+    }
+    return false;
+  }, [allowClear, disabled, displayValues.length, mergedSearchValue, mode]);
+  return {
+    allowClear: mergedAllowClear,
+    clearIcon: /*#__PURE__*/React.createElement(TransBtn, {
+      className: `${prefixCls}-clear`,
+      onMouseDown: onClearMouseDown,
+      customizeIcon: mergedClearIcon
+    }, "\xD7")
+  };
+};

package/es/hooks/useBaseProps.d.ts

@@ -0,0 +1,13 @@
+/**
+ * BaseSelect provide some parsed data into context.
+ * You can use this hooks to get them.
+ */
+import * as React from 'react';
+import type { BaseSelectProps } from '../BaseSelect';
+export interface BaseSelectContextProps extends BaseSelectProps {
+    triggerOpen: boolean;
+    multiple: boolean;
+    toggleOpen: (open?: boolean) => void;
+}
+export declare const BaseSelectContext: React.Context<BaseSelectContextProps>;
+export default function useBaseProps(): BaseSelectContextProps;

package/es/hooks/useBaseProps.js

@@ -0,0 +1,10 @@
+/**
+ * BaseSelect provide some parsed data into context.
+ * You can use this hooks to get them.
+ */
+
+import * as React from 'react';
+export const BaseSelectContext = /*#__PURE__*/React.createContext(null);
+export default function useBaseProps() {
+  return React.useContext(BaseSelectContext);
+}

package/es/hooks/useCache.d.ts

@@ -0,0 +1,7 @@
+import type { RawValueType } from '../BaseSelect';
+import type { DefaultOptionType, LabelInValueType } from '../Select';
+/**
+ * Cache `value` related LabeledValue & options.
+ */
+declare const _default: (labeledValues: LabelInValueType[], valueOptions: Map<RawValueType, DefaultOptionType>) => [LabelInValueType[], (val: RawValueType) => DefaultOptionType];
+export default _default;

package/es/hooks/useCache.js

@@ -0,0 +1,40 @@
+import * as React from 'react';
+/**
+ * Cache `value` related LabeledValue & options.
+ */
+export default ((labeledValues, valueOptions) => {
+  const cacheRef = React.useRef({
+    values: new Map(),
+    options: new Map()
+  });
+  const filledLabeledValues = React.useMemo(() => {
+    const {
+      values: prevValueCache,
+      options: prevOptionCache
+    } = cacheRef.current;
+
+    // Fill label by cache
+    const patchedValues = labeledValues.map(item => {
+      if (item.label === undefined) {
+        return {
+          ...item,
+          label: prevValueCache.get(item.value)?.label
+        };
+      }
+      return item;
+    });
+
+    // Refresh cache
+    const valueCache = new Map();
+    const optionCache = new Map();
+    patchedValues.forEach(item => {
+      valueCache.set(item.value, item);
+      optionCache.set(item.value, valueOptions.get(item.value) || prevOptionCache.get(item.value));
+    });
+    cacheRef.current.values = valueCache;
+    cacheRef.current.options = optionCache;
+    return patchedValues;
+  }, [labeledValues, valueOptions]);
+  const getOption = React.useCallback(val => valueOptions.get(val) || cacheRef.current.options.get(val), [valueOptions]);
+  return [filledLabeledValues, getOption];
+});

package/es/hooks/useDelayReset.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Similar with `useLock`, but this hook will always execute last value.
+ * When set to `true`, it will keep `true` for a short time even if `false` is set.
+ */
+export default function useDelayReset(timeout?: number): [boolean, (val: boolean, callback?: () => void) => void, () => void];

package/es/hooks/useDelayReset.js

@@ -0,0 +1,24 @@
+import * as React from 'react';
+
+/**
+ * Similar with `useLock`, but this hook will always execute last value.
+ * When set to `true`, it will keep `true` for a short time even if `false` is set.
+ */
+export default function useDelayReset(timeout = 10) {
+  const [bool, setBool] = React.useState(false);
+  const delayRef = React.useRef(null);
+  const cancelLatest = () => {
+    window.clearTimeout(delayRef.current);
+  };
+  React.useEffect(() => cancelLatest, []);
+  const delaySetBool = (value, callback) => {
+    cancelLatest();
+    delayRef.current = window.setTimeout(() => {
+      setBool(value);
+      if (callback) {
+        callback();
+      }
+    }, timeout);
+  };
+  return [bool, delaySetBool, cancelLatest];
+}

package/es/hooks/useFilterOptions.d.ts

@@ -0,0 +1,3 @@
+import type { FieldNames, DefaultOptionType, SelectProps } from '../Select';
+declare const _default: (options: DefaultOptionType[], fieldNames: FieldNames, searchValue?: string, filterOption?: SelectProps['filterOption'], optionFilterProp?: string) => DefaultOptionType[];
+export default _default;

package/es/hooks/useFilterOptions.js

@@ -0,0 +1,57 @@
+import * as React from 'react';
+import { toArray } from "../utils/commonUtil";
+import { injectPropsWithOption } from "../utils/valueUtil";
+function includes(test, search) {
+  return toArray(test).join('').toUpperCase().includes(search);
+}
+export default ((options, fieldNames, searchValue, filterOption, optionFilterProp) => React.useMemo(() => {
+  if (!searchValue || filterOption === false) {
+    return options;
+  }
+  const {
+    options: fieldOptions,
+    label: fieldLabel,
+    value: fieldValue
+  } = fieldNames;
+  const filteredOptions = [];
+  const customizeFilter = typeof filterOption === 'function';
+  const upperSearch = searchValue.toUpperCase();
+  const filterFunc = customizeFilter ? filterOption : (_, option) => {
+    // Use provided `optionFilterProp`
+    if (optionFilterProp) {
+      return includes(option[optionFilterProp], upperSearch);
+    }
+
+    // Auto select `label` or `value` by option type
+    if (option[fieldOptions]) {
+      // hack `fieldLabel` since `OptionGroup` children is not `label`
+      return includes(option[fieldLabel !== 'children' ? fieldLabel : 'label'], upperSearch);
+    }
+    return includes(option[fieldValue], upperSearch);
+  };
+  const wrapOption = customizeFilter ? opt => injectPropsWithOption(opt) : opt => opt;
+  options.forEach(item => {
+    // Group should check child options
+    if (item[fieldOptions]) {
+      // Check group first
+      const matchGroup = filterFunc(searchValue, wrapOption(item));
+      if (matchGroup) {
+        filteredOptions.push(item);
+      } else {
+        // Check option
+        const subOptions = item[fieldOptions].filter(subItem => filterFunc(searchValue, wrapOption(subItem)));
+        if (subOptions.length) {
+          filteredOptions.push({
+            ...item,
+            [fieldOptions]: subOptions
+          });
+        }
+      }
+      return;
+    }
+    if (filterFunc(searchValue, wrapOption(item))) {
+      filteredOptions.push(item);
+    }
+  });
+  return filteredOptions;
+}, [options, filterOption, optionFilterProp, searchValue, fieldNames]));

package/es/hooks/useId.d.ts

@@ -0,0 +1,5 @@
+/** Is client side and not jsdom */
+export declare const isBrowserClient: boolean;
+/** Get unique id for accessibility usage */
+export declare function getUUID(): number | string;
+export default function useId(id?: string): string;

package/es/hooks/useId.js

@@ -0,0 +1,29 @@
+import * as React from 'react';
+import canUseDom from "@rc-component/util/es/Dom/canUseDom";
+let uuid = 0;
+
+/** Is client side and not jsdom */
+export const isBrowserClient = process.env.NODE_ENV !== 'test' && canUseDom();
+
+/** Get unique id for accessibility usage */
+export function getUUID() {
+  let retId;
+
+  // Test never reach
+  /* istanbul ignore if */
+  if (isBrowserClient) {
+    retId = uuid;
+    uuid += 1;
+  } else {
+    retId = 'TEST_OR_SSR';
+  }
+  return retId;
+}
+export default function useId(id) {
+  // Inner id for accessibility usage. Only work in client side
+  const [innerId, setInnerId] = React.useState();
+  React.useEffect(() => {
+    setInnerId(`rc_select_${getUUID()}`);
+  }, []);
+  return id || innerId;
+}

package/es/hooks/useLayoutEffect.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+/**
+ * Wrap `React.useLayoutEffect` which will not throw warning message in test env
+ */
+export default function useLayoutEffect(effect: React.EffectCallback, deps?: React.DependencyList): void;

package/es/hooks/useLayoutEffect.js

@@ -0,0 +1,17 @@
+/* eslint-disable react-hooks/rules-of-hooks */
+import * as React from 'react';
+import { isBrowserClient } from "../utils/commonUtil";
+
+/**
+ * Wrap `React.useLayoutEffect` which will not throw warning message in test env
+ */
+export default function useLayoutEffect(effect, deps) {
+  // Never happen in test env
+  if (isBrowserClient) {
+    /* istanbul ignore next */
+    React.useLayoutEffect(effect, deps);
+  } else {
+    React.useEffect(effect, deps);
+  }
+}
+/* eslint-enable */

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

@@ -0,0 +1,27 @@
+import * as React from 'react';
+
+/**
+ * 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 = 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/es/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/es/hooks/useOptions.js

@@ -0,0 +1,45 @@
+import * as React from 'react';
+import { convertChildrenToData } from "../utils/legacyUtil";
+
+/**
+ * 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 = 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]);
+};
+export default useOptions;

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

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

package/es/hooks/useSelectTriggerControl.js

@@ -0,0 +1,27 @@
+import * as React from 'react';
+export default 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/es/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/es/index.js

@@ -0,0 +1,7 @@
+import Select from "./Select";
+import Option from "./Option";
+import OptGroup from "./OptGroup";
+import BaseSelect from "./BaseSelect";
+import useBaseProps from "./hooks/useBaseProps";
+export { Option, OptGroup, BaseSelect, useBaseProps };
+export default Select;