@coreui/react-pro 5.0.0-rc.0 → 5.0.0-rc.1

package/src/components/card/__tests__/CCardImage.spec.tsx

@@ -9,9 +9,7 @@ test('loads and displays CCardImage component', async () => {
 })
 
 test('CCardImage customize', async () => {
-  const { container } = render(
-    <CCardImage className="bazinga" component="div" orientation="bottom" />,
-  )
+  const { container } = render(<CCardImage className="bazinga" as="div" orientation="bottom" />)
   expect(container).toMatchSnapshot()
   expect(container.firstChild).toHaveClass('bazinga')
   expect(container.firstChild).toHaveClass('card-img-bottom')

package/src/components/card/__tests__/CCardSubtitle.spec.tsx

@@ -10,7 +10,7 @@ test('loads and displays CCardSubtitle component', async () => {
 
 test('CCardSubtitle customize', async () => {
   const { container } = render(
-    <CCardSubtitle className="bazinga" component="h3">
+    <CCardSubtitle className="bazinga" as="h3">
       Test
     </CCardSubtitle>,
   )

package/src/components/card/__tests__/CCardText.spec.tsx

@@ -10,7 +10,7 @@ test('loads and displays CCardText component', async () => {
 
 test('CCardText customize', async () => {
   const { container } = render(
-    <CCardText className="bazinga" component="h3">
+    <CCardText className="bazinga" as="h3">
       Test
     </CCardText>,
   )

package/src/components/card/__tests__/CCardTitle.spec.tsx

@@ -10,7 +10,7 @@ test('loads and displays CCardTitle component', async () => {
 
 test('CCardTitle customize', async () => {
   const { container } = render(
-    <CCardTitle className="bazinga" component="h3">
+    <CCardTitle className="bazinga" as="h3">
       Test
     </CCardTitle>,
   )

package/src/components/conditional-portal/CConditionalPortal.tsx

@@ -17,7 +17,7 @@ export interface CConditionalPortalProps {
   children: ReactNode
   /**
    * An HTML element or function that returns a single element, with `document.body` as the default.
-   * 
+   *
    * @since v4.11.0
    */
   container?: Element | (() => Element | null) | null

package/src/components/date-range-picker/CDateRangePicker.tsx

@@ -98,20 +98,20 @@ export interface CDateRangePickerProps
   indicator?: ReactNode | boolean
   /**
    * Custom function to format the selected date into a string according to a custom format.
-   * 
-   * @since v5.0.0-rc.0
+   *
+   * @since v5.0.0-rc.1
    */
   inputDateFormat?: (date: Date) => string
   /**
    * Custom function to parse the input value into a valid Date object.
-   * 
-   * @since v5.0.0-rc.0
+   *
+   * @since v5.0.0-rc.1
    */
   inputDateParse?: (date: string | Date) => Date
   /**
    * Defines the delay (in milliseconds) for the input field's onChange event.
-   * 
-   * @since v5.0.0-rc.0
+   *
+   * @since v5.0.0-rc.1
    */
   inputOnChangeDelay?: number
   /**
@@ -345,8 +345,8 @@ export const CDateRangePicker = forwardRef<HTMLDivElement | HTMLLIElement, CDate
       return inputDateFormat
         ? inputDateFormat(_date)
         : timepicker
-        ? _date.toLocaleString(locale)
-        : _date.toLocaleDateString(locale)
+          ? _date.toLocaleString(locale)
+          : _date.toLocaleDateString(locale)
     }
 
     const setInputValue = (el: HTMLInputElement | null, date: Date | string | null) => {
@@ -512,7 +512,7 @@ export const CDateRangePicker = forwardRef<HTMLDivElement | HTMLLIElement, CDate
                   onClick={() => {
                     const date = new Date()
                     handleStartDateChange(date)
-                    handleEndDateChange(date)
+                    range && handleEndDateChange(date)
                     setCalendarDate(date)
                   }}
                 >
@@ -526,7 +526,7 @@ export const CDateRangePicker = forwardRef<HTMLDivElement | HTMLLIElement, CDate
                   variant={cancelButtonVariant}
                   onClick={() => {
                     handleStartDateChange(initialStartDate)
-                    handleEndDateChange(initialEndDate)
+                    range && handleEndDateChange(initialEndDate)
                     setVisible(false)
                   }}
                 >
@@ -641,8 +641,8 @@ export const CDateRangePicker = forwardRef<HTMLDivElement | HTMLLIElement, CDate
                             ? true
                             : false
                           : _endDate === null
-                          ? true
-                          : false
+                            ? true
+                            : false
                       }
                       key={index}
                       locale={locale}

package/src/components/dropdown/CDropdown.tsx

@@ -11,6 +11,7 @@ import React, {
 import PropTypes from 'prop-types'
 import classNames from 'classnames'
 
+import { PolymorphicRefForwardingComponent } from '../../helpers'
 import { useForkedRef, usePopper } from '../../hooks'
 import { placementPropType } from '../../props'
 import type { Placements } from '../../types'
@@ -26,6 +27,10 @@ export interface CDropdownProps extends HTMLAttributes<HTMLDivElement | HTMLLIEl
    * @type 'start' | 'end' | { xs: 'start' | 'end' } | { sm: 'start' | 'end' } | { md: 'start' | 'end' } | { lg: 'start' | 'end' } | { xl: 'start' | 'end'} | { xxl: 'start' | 'end'}
    */
   alignment?: Alignments
+  /**
+   * Component used for the root node. Either a string to use a HTML element or a component.
+   */
+  as?: ElementType
   /**
    * Configure the auto close behavior of the dropdown:
    * - `true` - the dropdown will be closed by clicking outside or inside the dropdown menu.
@@ -38,10 +43,6 @@ export interface CDropdownProps extends HTMLAttributes<HTMLDivElement | HTMLLIEl
    * A string of all className you want applied to the base component.
    */
   className?: string
-  /**
-   * Component used for the root node. Either a string to use a HTML element or a component.
-   */
-  component?: string | ElementType
   /**
    * Appends the react dropdown menu to a specific element. You can pass an HTML element or function that returns a single element. By default `document.body`.
    *
@@ -106,11 +107,15 @@ interface ContextProps extends CDropdownProps {
 
 export const CDropdownContext = createContext({} as ContextProps)
 
-export const CDropdown = forwardRef<HTMLDivElement | HTMLLIElement, CDropdownProps>(
+export const CDropdown: PolymorphicRefForwardingComponent<'div', CDropdownProps> = forwardRef<
+  HTMLDivElement | HTMLLIElement,
+  CDropdownProps
+>(
   (
     {
       children,
       alignment,
+      as = 'div',
       autoClose = true,
       className,
       container,
@@ -123,7 +128,6 @@ export const CDropdown = forwardRef<HTMLDivElement | HTMLLIElement, CDropdownPro
       popper = true,
       portal = false,
       variant = 'btn-group',
-      component = 'div',
       visible = false,
       ...rest
     },
@@ -137,7 +141,7 @@ export const CDropdown = forwardRef<HTMLDivElement | HTMLLIElement, CDropdownPro
     const [_visible, setVisible] = useState(visible)
     const { initPopper, destroyPopper } = usePopper()
 
-    const Component = variant === 'nav-item' ? 'li' : component
+    const Component = variant === 'nav-item' ? 'li' : as
 
     // Disable popper if responsive aligment is set.
     if (typeof alignment === 'object') {
@@ -279,13 +283,13 @@ CDropdown.propTypes = {
     PropTypes.shape({ xl: alignmentDirection.isRequired }),
     PropTypes.shape({ xxl: alignmentDirection.isRequired }),
   ]),
+  as: PropTypes.elementType,
   autoClose: PropTypes.oneOfType([
     PropTypes.bool,
     PropTypes.oneOf<'inside' | 'outside'>(['inside', 'outside']),
   ]),
   children: PropTypes.node,
   className: PropTypes.string,
-  component: PropTypes.elementType,
   dark: PropTypes.bool,
   direction: PropTypes.oneOf(['center', 'dropup', 'dropup-center', 'dropend', 'dropstart']),
   offset: PropTypes.any, // TODO: find good proptype

package/src/components/dropdown/CDropdownHeader.tsx

@@ -2,31 +2,34 @@ import React, { ElementType, forwardRef, HTMLAttributes } from 'react'
 import PropTypes from 'prop-types'
 import classNames from 'classnames'
 
+import { PolymorphicRefForwardingComponent } from '../../helpers'
+
 export interface CDropdownHeaderProps extends HTMLAttributes<HTMLHeadingElement> {
   /**
-   * A string of all className you want applied to the component.
+   * Component used for the root node. Either a string to use a HTML element or a component.
    */
-  className?: string
+  as?: ElementType
   /**
-   * Component used for the root node. Either a string to use a HTML element or a component.
+   * A string of all className you want applied to the component.
    */
-  component?: string | ElementType
+  className?: string
 }
 
-export const CDropdownHeader = forwardRef<HTMLHeadingElement, CDropdownHeaderProps>(
-  ({ children, className, component: Component = 'h6', ...rest }, ref) => {
-    return (
-      <Component className={classNames('dropdown-header', className)} {...rest} ref={ref}>
-        {children}
-      </Component>
-    )
-  },
-)
+export const CDropdownHeader: PolymorphicRefForwardingComponent<'h6', CDropdownHeaderProps> =
+  forwardRef<HTMLHeadingElement, CDropdownHeaderProps>(
+    ({ children, as: Component = 'h6', className, ...rest }, ref) => {
+      return (
+        <Component className={classNames('dropdown-header', className)} {...rest} ref={ref}>
+          {children}
+        </Component>
+      )
+    },
+  )
 
 CDropdownHeader.propTypes = {
+  as: PropTypes.elementType,
   children: PropTypes.node,
   className: PropTypes.string,
-  component: PropTypes.elementType,
 }
 
 CDropdownHeader.displayName = 'CDropdownHeader'

package/src/components/dropdown/CDropdownItem.tsx

@@ -1,39 +1,33 @@
-import React, { ElementType, forwardRef } from 'react'
+import React, { forwardRef } from 'react'
 import PropTypes from 'prop-types'
 import classNames from 'classnames'
 
 import { CLink, CLinkProps } from '../link/CLink'
 
+import { PolymorphicRefForwardingComponent } from '../../helpers'
+
 export interface CDropdownItemProps extends CLinkProps {
   /**
    * A string of all className you want applied to the component.
    */
   className?: string
-  /**
-   * Component used for the root node. Either a string to use a HTML element or a component.
-   */
-  component?: string | ElementType
 }
 
-export const CDropdownItem = forwardRef<HTMLButtonElement | HTMLAnchorElement, CDropdownItemProps>(
-  ({ children, className, component = 'a', ...rest }, ref) => {
-    return (
-      <CLink
-        className={classNames('dropdown-item', className)}
-        component={component}
-        {...rest}
-        ref={ref}
-      >
-        {children}
-      </CLink>
-    )
-  },
-)
+export const CDropdownItem: PolymorphicRefForwardingComponent<'a', CDropdownItemProps> = forwardRef<
+  HTMLButtonElement | HTMLAnchorElement,
+  CDropdownItemProps
+>(({ children, as = 'a', className, ...rest }, ref) => {
+  return (
+    <CLink className={classNames('dropdown-item', className)} as={as} {...rest} ref={ref}>
+      {children}
+    </CLink>
+  )
+})
 
 CDropdownItem.propTypes = {
+  as: PropTypes.elementType,
   children: PropTypes.node,
   className: PropTypes.string,
-  component: PropTypes.elementType,
 }
 
 CDropdownItem.displayName = 'CDropdownItem'

package/src/components/dropdown/CDropdownItemPlain.tsx

@@ -2,19 +2,24 @@ import React, { ElementType, forwardRef, HTMLAttributes } from 'react'
 import PropTypes from 'prop-types'
 import classNames from 'classnames'
 
+import { PolymorphicRefForwardingComponent } from '../../helpers'
+
 export interface CDropdownItemPlainProps extends HTMLAttributes<HTMLSpanElement> {
   /**
-   * A string of all className you want applied to the component.
+   * Component used for the root node. Either a string to use a HTML element or a component.
    */
-  className?: string
+  as?: ElementType
   /**
-   * Component used for the root node. Either a string to use a HTML element or a component.
+   * A string of all className you want applied to the component.
    */
-  component?: string | ElementType
+  className?: string
 }
 
-export const CDropdownItemPlain = forwardRef<HTMLSpanElement, CDropdownItemPlainProps>(
-  ({ children, className, component: Component = 'span', ...rest }, ref) => {
+export const CDropdownItemPlain: PolymorphicRefForwardingComponent<
+  'span',
+  CDropdownItemPlainProps
+> = forwardRef<HTMLSpanElement, CDropdownItemPlainProps>(
+  ({ children, as: Component = 'span', className, ...rest }, ref) => {
     return (
       <Component className={classNames('dropdown-item-text', className)} {...rest} ref={ref}>
         {children}
@@ -24,9 +29,9 @@ export const CDropdownItemPlain = forwardRef<HTMLSpanElement, CDropdownItemPlain
 )
 
 CDropdownItemPlain.propTypes = {
+  as: PropTypes.elementType,
   children: PropTypes.node,
   className: PropTypes.string,
-  component: PropTypes.elementType,
 }
 
 CDropdownItemPlain.displayName = 'CDropdownItemPlain'

package/src/components/dropdown/CDropdownMenu.tsx

@@ -5,64 +5,66 @@ import classNames from 'classnames'
 import { CDropdownContext } from './CDropdown'
 import { CConditionalPortal } from '../conditional-portal'
 
+import { PolymorphicRefForwardingComponent } from '../../helpers'
 import { useForkedRef } from '../../hooks'
 
 import { getAlignmentClassNames } from './utils'
 
 export interface CDropdownMenuProps extends HTMLAttributes<HTMLDivElement | HTMLUListElement> {
   /**
-   * A string of all className you want applied to the base component.
+   * Component used for the root node. Either a string to use a HTML element or a component.
    */
-  className?: string
+  as?: ElementType
   /**
-   * Component used for the root node. Either a string to use a HTML element or a component.
+   * A string of all className you want applied to the base component.
    */
-  component?: string | ElementType
+  className?: string
 }
 
-export const CDropdownMenu = forwardRef<HTMLDivElement | HTMLUListElement, CDropdownMenuProps>(
-  ({ children, className, component: Component = 'ul', ...rest }, ref) => {
-    const { alignment, container, dark, dropdownMenuRef, popper, portal, visible } =
-      useContext(CDropdownContext)
+export const CDropdownMenu: PolymorphicRefForwardingComponent<'ul', CDropdownMenuProps> =
+  forwardRef<HTMLDivElement | HTMLUListElement, CDropdownMenuProps>(
+    ({ children, as: Component = 'ul', className, ...rest }, ref) => {
+      const { alignment, container, dark, dropdownMenuRef, popper, portal, visible } =
+        useContext(CDropdownContext)
 
-    const forkedRef = useForkedRef(ref, dropdownMenuRef)
+      const forkedRef = useForkedRef(ref, dropdownMenuRef)
 
-    return (
-      <CConditionalPortal container={container} portal={portal ?? false}>
-        <Component
-          className={classNames(
-            'dropdown-menu',
-            {
-              show: visible,
-            },
-            alignment && getAlignmentClassNames(alignment),
-            className,
-          )}
-          ref={forkedRef}
-          role="menu"
-          aria-hidden={!visible}
-          {...(!popper && { 'data-coreui-popper': 'static' })}
-          {...(dark && { 'data-coreui-theme': 'dark' })}
-          {...rest}
-        >
-          {Component === 'ul'
-            ? React.Children.map(children, (child, index) => {
-                if (React.isValidElement(child)) {
-                  return <li key={index}>{React.cloneElement(child)}</li>
-                }
-                return
-              })
-            : children}
-        </Component>
-      </CConditionalPortal>
-    )
-  },
-)
+      return (
+        <CConditionalPortal container={container} portal={portal ?? false}>
+          <Component
+            className={classNames(
+              'dropdown-menu',
+              {
+                show: visible,
+              },
+              alignment && getAlignmentClassNames(alignment),
+              className,
+            )}
+            ref={forkedRef}
+            role="menu"
+            aria-hidden={!visible}
+            {...(!popper && { 'data-coreui-popper': 'static' })}
+            {...(dark && { 'data-coreui-theme': 'dark' })}
+            {...rest}
+          >
+            {Component === 'ul'
+              ? React.Children.map(children, (child, index) => {
+                  if (React.isValidElement(child)) {
+                    return <li key={index}>{React.cloneElement(child)}</li>
+                  }
+                  return
+                })
+              : children}
+          </Component>
+        </CConditionalPortal>
+      )
+    },
+  )
 
 CDropdownMenu.propTypes = {
+  as: PropTypes.elementType,
   children: PropTypes.node,
   className: PropTypes.string,
-  component: PropTypes.elementType,
 }
 
 CDropdownMenu.displayName = 'CDropdownMenu'

package/src/components/dropdown/CDropdownToggle.tsx

@@ -21,7 +21,7 @@ export interface CDropdownToggleProps extends Omit<CButtonProps, 'type'> {
   /**
    * If a dropdown `variant` is set to `nav-item` then render the toggler as a link instead of a button.
    *
-   * @since v5.0.0-rc.0
+   * @since v5.0.0-rc.1
    */
   navLink?: boolean
   /**

package/src/components/dropdown/__tests__/CDropdown.spec.tsx

@@ -21,7 +21,7 @@ test('CDropdown customize', async () => {
     <CDropdown
       alignment={{ lg: 'start' }}
       className="bazinga"
-      component="h3"
+      as="h3"
       dark={true}
       direction="dropstart"
       placement="right-end"

package/src/components/dropdown/__tests__/CDropdownHeader.spec.tsx

@@ -10,7 +10,7 @@ test('loads and displays CDropdownHeader component', async () => {
 
 test('CDropdownHeader customize', async () => {
   const { container } = render(
-    <CDropdownHeader className="bazinga" component="h3">
+    <CDropdownHeader className="bazinga" as="h3">
       Test
     </CDropdownHeader>,
   )

package/src/components/dropdown/__tests__/CDropdownItem.spec.tsx

@@ -10,7 +10,7 @@ test('loads and displays CDropdownItem component', async () => {
 
 test('CDropdownItem customize', async () => {
   const { container } = render(
-    <CDropdownItem className="bazinga" component="div">
+    <CDropdownItem className="bazinga" as="div">
       Test
     </CDropdownItem>,
   )

package/src/components/dropdown/__tests__/CDropdownItemPlain.spec.tsx

@@ -10,7 +10,7 @@ test('loads and displays CDropdownItemPlain component', async () => {
 
 test('CDropdownItemPlain customize', async () => {
   const { container } = render(
-    <CDropdownItemPlain className="bazinga" component="div">
+    <CDropdownItemPlain className="bazinga" as="div">
       Test
     </CDropdownItemPlain>,
   )

package/src/components/dropdown/__tests__/CDropdownMenu.spec.tsx

@@ -11,7 +11,7 @@ test('loads and displays CDropdownMenu component', async () => {
 test('CDropdownMenu customize', async () => {
   const { container } = render(
     <CDropdown visible={true}>
-      <CDropdownMenu className="bazinga" component="div">
+      <CDropdownMenu className="bazinga" as="div">
         Test
       </CDropdownMenu>
     </CDropdown>,

package/src/components/dropdown/types.ts

@@ -8,4 +8,4 @@ export type Breakpoints =
   | { xl: Directions }
   | { xxl: Directions }
 
-export type Alignments = Directions | Breakpoints
+export type Alignments = Directions | Breakpoints

package/src/components/form/CFormFeedback.tsx

@@ -2,15 +2,18 @@ import React, { ElementType, forwardRef, HTMLAttributes } from 'react'
 import PropTypes from 'prop-types'
 import classNames from 'classnames'
 
+import { PolymorphicRefForwardingComponent } from '../../helpers'
+
 export interface CFormFeedbackProps extends HTMLAttributes<HTMLDivElement | HTMLSpanElement> {
   /**
-   * A string of all className you want applied to the component.
+   * Component used for the root node. Either a string to use a HTML element or a component.
    */
-  className?: string
+  as?: ElementType
   /**
-   * Component used for the root node. Either a string to use a HTML element or a component.
+   * A string of all className you want applied to the component.
    */
-  component?: string | ElementType
+  className?: string
+
   /**
    * Method called immediately after the `value` prop changes.
    */
@@ -25,33 +28,31 @@ export interface CFormFeedbackProps extends HTMLAttributes<HTMLDivElement | HTML
   valid?: boolean
 }
 
-export const CFormFeedback = forwardRef<HTMLDivElement | HTMLSpanElement, CFormFeedbackProps>(
-  (
-    { children, className, component: Component = 'div', invalid, tooltip, valid, ...rest },
-    ref,
-  ) => {
-    return (
-      <Component
-        className={classNames(
-          {
-            [`invalid-${tooltip ? 'tooltip' : 'feedback'}`]: invalid,
-            [`valid-${tooltip ? 'tooltip' : 'feedback'}`]: valid,
-          },
-          className,
-        )}
-        {...rest}
-        ref={ref}
-      >
-        {children}
-      </Component>
-    )
-  },
-)
+export const CFormFeedback: PolymorphicRefForwardingComponent<'div', CFormFeedbackProps> =
+  forwardRef<HTMLDivElement | HTMLSpanElement, CFormFeedbackProps>(
+    ({ children, as: Component = 'div', className, invalid, tooltip, valid, ...rest }, ref) => {
+      return (
+        <Component
+          className={classNames(
+            {
+              [`invalid-${tooltip ? 'tooltip' : 'feedback'}`]: invalid,
+              [`valid-${tooltip ? 'tooltip' : 'feedback'}`]: valid,
+            },
+            className,
+          )}
+          {...rest}
+          ref={ref}
+        >
+          {children}
+        </Component>
+      )
+    },
+  )
 
 CFormFeedback.propTypes = {
+  as: PropTypes.elementType,
   children: PropTypes.node,
   className: PropTypes.string,
-  component: PropTypes.elementType,
   invalid: PropTypes.bool,
   tooltip: PropTypes.bool,
   valid: PropTypes.bool,

package/src/components/form/CFormText.tsx

@@ -2,31 +2,34 @@ import React, { ElementType, forwardRef, HTMLAttributes } from 'react'
 import PropTypes from 'prop-types'
 import classNames from 'classnames'
 
+import { PolymorphicRefForwardingComponent } from '../../helpers'
+
 export interface CFormTextProps extends HTMLAttributes<HTMLDivElement | HTMLSpanElement> {
   /**
-   * A string of all className you want applied to the component.
+   * Component used for the root node. Either a string to use a HTML element or a component.
    */
-  className?: string
+  as?: ElementType
   /**
-   * Component used for the root node. Either a string to use a HTML element or a component.
+   * A string of all className you want applied to the component.
    */
-  component?: string | ElementType
+  className?: string
 }
 
-export const CFormText = forwardRef<HTMLDivElement | HTMLSpanElement, CFormTextProps>(
-  ({ children, className, component: Component = 'div', ...rest }, ref) => {
-    return (
-      <Component className={classNames('form-text', className)} {...rest} ref={ref}>
-        {children}
-      </Component>
-    )
-  },
-)
+export const CFormText: PolymorphicRefForwardingComponent<'div', CFormTextProps> = forwardRef<
+  HTMLDivElement | HTMLSpanElement,
+  CFormTextProps
+>(({ children, as: Component = 'div', className, ...rest }, ref) => {
+  return (
+    <Component className={classNames('form-text', className)} {...rest} ref={ref}>
+      {children}
+    </Component>
+  )
+})
 
 CFormText.propTypes = {
+  as: PropTypes.elementType,
   children: PropTypes.node,
   className: PropTypes.string,
-  component: PropTypes.elementType,
 }
 
 CFormText.displayName = 'CFormText'