@coreui/react 5.0.0-rc.3 → 5.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coreui/react",
-  "version": "5.0.0-rc.3",
+  "version": "5.1.0",
   "description": "UI Components Library for React.js",
   "keywords": [
     "react",
@@ -41,31 +41,31 @@
     "test:update": "jest --coverage --updateSnapshot"
   },
   "dependencies": {
-    "@coreui/coreui": "^5.0.0-rc.3",
+    "@coreui/coreui": "^5.0.2",
     "@popperjs/core": "^2.11.8",
     "prop-types": "^15.8.1"
   },
   "devDependencies": {
-    "@rollup/plugin-commonjs": "^25.0.7",
+    "@rollup/plugin-commonjs": "^25.0.8",
     "@rollup/plugin-node-resolve": "^15.2.3",
     "@rollup/plugin-typescript": "^11.1.6",
-    "@testing-library/jest-dom": "^6.4.2",
-    "@testing-library/react": "^14.2.2",
+    "@testing-library/jest-dom": "^6.4.5",
+    "@testing-library/react": "^14.3.1",
     "@types/jest": "^29.5.12",
-    "@types/react": "18.2.67",
-    "@types/react-dom": "^18.2.22",
+    "@types/react": "18.3.3",
+    "@types/react-dom": "^18.3.0",
     "@types/react-transition-group": "^4.4.10",
     "classnames": "^2.5.1",
     "cross-env": "^7.0.3",
     "jest": "^29.7.0",
     "jest-environment-jsdom": "^29.7.0",
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
     "react-transition-group": "^4.4.5",
-    "rollup": "^4.13.0",
-    "ts-jest": "^29.1.2",
+    "rollup": "^4.18.0",
+    "ts-jest": "^29.1.3",
     "tslib": "^2.6.2",
-    "typescript": "^5.4.3"
+    "typescript": "^5.4.5"
   },
   "peerDependencies": {
     "react": ">=17",

package/src/components/badge/CBadge.tsx

@@ -39,7 +39,7 @@ export interface CBadgeProps extends HTMLAttributes<HTMLDivElement | HTMLSpanEle
    * Sets the component's color scheme to one of CoreUI's themed colors, ensuring the text color contrast adheres to the WCAG 4.5:1 contrast ratio standard for accessibility.
    *
    * @type 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'info' | 'dark' | 'light' | string
-   * @since 5.0.0-rc.3
+   * @since 5.0.0
    */
   textBgColor?: Colors
   /**

package/src/components/card/CCard.tsx

@@ -26,7 +26,7 @@ export interface CCardProps extends HTMLAttributes<HTMLDivElement> {
    * Sets the component's color scheme to one of CoreUI's themed colors, ensuring the text color contrast adheres to the WCAG 4.5:1 contrast ratio standard for accessibility.
    *
    * @type 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'info' | 'dark' | 'light' | string
-   * @since 5.0.0-rc.3
+   * @since 5.0.0
    */
   textBgColor?: Colors
 }

package/src/components/dropdown/CDropdown.tsx

@@ -15,10 +15,10 @@ import { PolymorphicRefForwardingComponent } from '../../helpers'
 import { useForkedRef, usePopper } from '../../hooks'
 import { placementPropType } from '../../props'
 import type { Placements } from '../../types'
-import { isRTL } from '../../utils'
+import { getNextActiveElement, isRTL } from '../../utils'
 
 import type { Alignments, Directions } from './types'
-import { getNextActiveElement, getPlacement } from './utils'
+import { getPlacement } from './utils'
 
 export interface CDropdownProps extends HTMLAttributes<HTMLDivElement | HTMLLIElement> {
   /**

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.3
+   * @since v5.0.0
    */
   navLink?: boolean
   /**

package/src/components/dropdown/utils.ts

@@ -19,28 +19,6 @@ export const getAlignmentClassNames = (alignment: Alignments) => {
   return classNames
 }
 
-export const getNextActiveElement = (
-  list: HTMLElement[],
-  activeElement: HTMLElement,
-  shouldGetNext: boolean,
-  isCycleAllowed: boolean,
-) => {
-  const listLength = list.length
-  let index = list.indexOf(activeElement)
-
-  if (index === -1) {
-    return !shouldGetNext && isCycleAllowed ? list[listLength - 1] : list[0]
-  }
-
-  index += shouldGetNext ? 1 : -1
-
-  if (isCycleAllowed) {
-    index = (index + listLength) % listLength
-  }
-
-  return list[Math.max(0, Math.min(index, listLength - 1))]
-}
-
 export const getPlacement = (
   placement: Placement,
   direction: string | undefined,

package/src/components/nav/CNavGroup.tsx

@@ -22,7 +22,7 @@ export interface CNavGroupProps extends HTMLAttributes<HTMLDivElement | HTMLLIEl
   /**
    * Component used for the root node. Either a string to use a HTML element or a component.
    *
-   * @since 5.0.0-rc.3
+   * @since 5.0.0
    */
   as?: ElementType
   /**

package/src/components/nav/CNavGroupItems.tsx

@@ -8,7 +8,7 @@ export interface CNavGroupItemsProps extends HTMLAttributes<HTMLDivElement | HTM
   /**
    * Component used for the root node. Either a string to use a HTML element or a component.
    *
-   * @since 5.0.0-rc.3
+   * @since 5.0.0
    */
   as?: ElementType
   /**

package/src/components/nav/CNavItem.tsx

@@ -10,7 +10,7 @@ export interface CNavItemProps extends Omit<CNavLinkProps, 'component'> {
   /**
    * Component used for the root node. Either a string to use a HTML element or a component.
    *
-   * @since 5.0.0-rc.3
+   * @since 5.0.0
    */
   as?: ElementType
 }

package/src/components/popover/CPopover.tsx

@@ -1,13 +1,12 @@
 import React, { forwardRef, HTMLAttributes, ReactNode, useRef, useEffect, useState } from 'react'
 import classNames from 'classnames'
 import PropTypes from 'prop-types'
-import { Transition } from 'react-transition-group'
 
 import { CConditionalPortal } from '../conditional-portal'
 import { useForkedRef, usePopper } from '../../hooks'
 import { fallbackPlacementsPropType, triggerPropType } from '../../props'
 import type { Placements, Triggers } from '../../types'
-import { getRTLPlacement, getTransitionDurationFromElement } from '../../utils'
+import { executeAfterTransition, getRTLPlacement } from '../../utils'
 
 export interface CPopoverProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title' | 'content'> {
   /**
@@ -101,6 +100,7 @@ export const CPopover = forwardRef<HTMLDivElement, CPopoverProps>(
     const uID = useRef(`popover${Math.floor(Math.random() * 1_000_000)}`)
 
     const { initPopper, destroyPopper } = usePopper()
+    const [mounted, setMounted] = useState(false)
     const [_visible, setVisible] = useState(visible)
 
     const _delay = typeof delay === 'number' ? { show: delay, hide: delay } : delay
@@ -133,14 +133,39 @@ export const CPopover = forwardRef<HTMLDivElement, CPopoverProps>(
       setVisible(visible)
     }, [visible])
 
-    const toggleVisible = (visible: boolean) => {
-      if (visible) {
-        setTimeout(() => setVisible(true), _delay.show)
-        return
+    useEffect(() => {
+      if (_visible) {
+        setMounted(true)
+
+        if (popoverRef.current) {
+          popoverRef.current.classList.remove('fade', 'show')
+          destroyPopper()
+        }
+
+        setTimeout(() => {
+          if (togglerRef.current && popoverRef.current) {
+            if (animation) {
+              popoverRef.current.classList.add('fade')
+            }
+
+            initPopper(togglerRef.current, popoverRef.current, popperConfig)
+            popoverRef.current.classList.add('show')
+            onShow && onShow()
+          }
+        }, _delay.show)
       }
 
-      setTimeout(() => setVisible(false), _delay.hide)
-    }
+      return () => {
+        if (popoverRef.current) {
+          popoverRef.current.classList.remove('show')
+          onHide && onHide()
+          executeAfterTransition(() => {
+            destroyPopper()
+            setMounted(false)
+          }, popoverRef.current)
+        }
+      }
+    }, [_visible])
 
     return (
       <>
@@ -150,71 +175,31 @@ export const CPopover = forwardRef<HTMLDivElement, CPopoverProps>(
           }),
           ref: togglerRef,
           ...((trigger === 'click' || trigger.includes('click')) && {
-            onClick: () => toggleVisible(!_visible),
+            onClick: () => setVisible(!_visible),
           }),
           ...((trigger === 'focus' || trigger.includes('focus')) && {
-            onFocus: () => toggleVisible(true),
-            onBlur: () => toggleVisible(false),
+            onFocus: () => setVisible(true),
+            onBlur: () => setVisible(false),
           }),
           ...((trigger === 'hover' || trigger.includes('hover')) && {
-            onMouseEnter: () => toggleVisible(true),
-            onMouseLeave: () => toggleVisible(false),
+            onMouseEnter: () => setVisible(true),
+            onMouseLeave: () => setVisible(false),
           }),
         })}
         <CConditionalPortal container={container} portal={true}>
-          <Transition
-            in={_visible}
-            mountOnEnter
-            nodeRef={popoverRef}
-            onEnter={() => {
-              if (togglerRef.current && popoverRef.current) {
-                initPopper(togglerRef.current, popoverRef.current, popperConfig)
-              }
-
-              onShow
-            }}
-            onEntering={() => {
-              if (togglerRef.current && popoverRef.current) {
-                popoverRef.current.style.display = 'initial'
-              }
-            }}
-            onExit={onHide}
-            onExited={() => {
-              destroyPopper()
-            }}
-            timeout={{
-              enter: 0,
-              exit: popoverRef.current
-                ? getTransitionDurationFromElement(popoverRef.current) + 50
-                : 200,
-            }}
-            unmountOnExit
-          >
-            {(state) => (
-              <div
-                className={classNames(
-                  'popover',
-                  'bs-popover-auto',
-                  {
-                    fade: animation,
-                    show: state === 'entered',
-                  },
-                  className,
-                )}
-                id={uID.current}
-                ref={forkedRef}
-                role="tooltip"
-                style={{
-                  display: 'none',
-                }}
-                {...rest}
-              >
-                <div className="popover-arrow"></div>
-                <div className="popover-header">{title}</div>
-                <div className="popover-body">{content}</div>
-              </div>
-            )}
-          </Transition>
+          {mounted && (
+            <div
+              className={classNames('popover', 'bs-popover-auto', className)}
+              id={uID.current}
+              ref={forkedRef}
+              role="tooltip"
+              {...rest}
+            >
+              <div className="popover-arrow"></div>
+              <div className="popover-header">{title}</div>
+              <div className="popover-body">{content}</div>
+            </div>
+          )}
         </CConditionalPortal>
       </>
     )

package/src/components/sidebar/CSidebarBrand.tsx

@@ -8,7 +8,7 @@ export interface CSidebarBrandProps extends HTMLAttributes<HTMLAnchorElement | H
   /**
    * Component used for the root node. Either a string to use a HTML element or a component.
    *
-   * @since 5.0.0-rc.3
+   * @since 5.0.0
    */
   as?: ElementType
   /**

package/src/components/sidebar/CSidebarNav.tsx

@@ -16,7 +16,7 @@ export interface CSidebarNavProps extends HTMLAttributes<HTMLUListElement> {
   /**
    * Component used for the root node. Either a string to use a HTML element or a component.
    *
-   * @since 5.0.0-rc.3
+   * @since 5.0.0
    */
   as?: ElementType
   /**

package/src/components/tabs/CTab.tsx

@@ -0,0 +1,56 @@
+import React, { forwardRef, HTMLAttributes, useContext } from 'react'
+import PropTypes from 'prop-types'
+import classNames from 'classnames'
+
+import { TabsContext } from './CTabs'
+
+export interface CTabProps extends HTMLAttributes<HTMLButtonElement> {
+  /**
+   * A string of all className you want applied to the base component.
+   */
+  className?: string
+  /**
+   * Item key.
+   */
+  itemKey: number | string
+}
+
+export const CTab = forwardRef<HTMLButtonElement, CTabProps>(
+  ({ children, className, itemKey, ...rest }, ref) => {
+    const { _activeItemKey, setActiveItemKey, id } = useContext(TabsContext)
+
+    const isActive = () => itemKey === _activeItemKey
+
+    return (
+      <button
+        className={classNames(
+          'nav-link',
+          {
+            active: isActive(),
+          },
+          className,
+        )}
+        id={`${id}${itemKey}-tab`}
+        onClick={() => setActiveItemKey(itemKey)}
+        onFocus={() => setActiveItemKey(itemKey)}
+        role="tab"
+        tabIndex={isActive() ? 0 : -1}
+        type="button"
+        aria-controls={`${id}${itemKey}-tab-pane`}
+        aria-selected={isActive()}
+        ref={ref}
+        {...rest}
+      >
+        {children}
+      </button>
+    )
+  },
+)
+
+CTab.propTypes = {
+  children: PropTypes.node,
+  className: PropTypes.string,
+  itemKey: PropTypes.oneOfType([PropTypes.number, PropTypes.string]).isRequired,
+}
+
+CTab.displayName = 'CTab'

package/src/components/tabs/CTabList.tsx

@@ -0,0 +1,92 @@
+import React, { forwardRef, HTMLAttributes, KeyboardEvent, useRef } from 'react'
+import PropTypes from 'prop-types'
+import classNames from 'classnames'
+
+import { useForkedRef } from '../../hooks'
+import { getNextActiveElement } from '../../utils'
+
+export interface CTabListProps extends HTMLAttributes<HTMLDivElement> {
+  /**
+   * A string of all className you want applied to the base component.
+   */
+  className?: string
+  /**
+   * Specify a layout type for component.
+   */
+  layout?: 'fill' | 'justified'
+  /**
+   * Set the nav variant to tabs or pills.
+   */
+  variant?: 'pills' | 'tabs' | 'underline' | 'underline-border'
+}
+
+export const CTabList = forwardRef<HTMLDivElement, CTabListProps>(
+  ({ children, className, layout, variant, ...rest }, ref) => {
+    const tabListRef = useRef<HTMLDivElement>(null)
+    const forkedRef = useForkedRef(ref, tabListRef)
+
+    const handleKeydown = (event: KeyboardEvent<HTMLDivElement>) => {
+      if (
+        tabListRef.current !== null &&
+        (event.key === 'ArrowDown' ||
+          event.key === 'ArrowUp' ||
+          event.key === 'ArrowLeft' ||
+          event.key === 'ArrowRight' ||
+          event.key === 'Home' ||
+          event.key === 'End')
+      ) {
+        event.preventDefault()
+        const target = event.target as HTMLElement
+        // eslint-disable-next-line unicorn/prefer-spread
+        const items: HTMLElement[] = Array.from(
+          tabListRef.current.querySelectorAll('.nav-link:not(.disabled):not(:disabled)'),
+        )
+
+        let nextActiveElement
+
+        if (event.key === 'Home' || event.key === 'End') {
+          nextActiveElement = event.key === 'End' ? items.at(-1) : items[0]
+        } else {
+          nextActiveElement = getNextActiveElement(
+            items,
+            target,
+            event.key === 'ArrowDown' || event.key === 'ArrowRight',
+            true,
+          )
+        }
+
+        if (nextActiveElement) {
+          nextActiveElement.focus({ preventScroll: true })
+        }
+      }
+    }
+
+    return (
+      <div
+        className={classNames(
+          'nav',
+          {
+            [`nav-${layout}`]: layout,
+            [`nav-${variant}`]: variant,
+          },
+          className,
+        )}
+        role="tablist"
+        onKeyDown={handleKeydown}
+        ref={forkedRef}
+        {...rest}
+      >
+        {children}
+      </div>
+    )
+  },
+)
+
+CTabList.propTypes = {
+  children: PropTypes.node,
+  className: PropTypes.string,
+  layout: PropTypes.oneOf(['fill', 'justified']),
+  variant: PropTypes.oneOf(['pills', 'tabs', 'underline', 'underline-border']),
+}
+
+CTabList.displayName = 'CTabList'

package/src/components/tabs/CTabPane.tsx

@@ -18,6 +18,12 @@ export interface CTabPaneProps extends HTMLAttributes<HTMLDivElement> {
    * Callback fired when the component requests to be shown.
    */
   onShow?: () => void
+  /**
+   * Enable fade in and fade out transition.
+   *
+   * @since 5.1.0
+   */
+  transition?: boolean
   /**
    * Toggle the visibility of component.
    */
@@ -25,7 +31,7 @@ export interface CTabPaneProps extends HTMLAttributes<HTMLDivElement> {
 }
 
 export const CTabPane = forwardRef<HTMLDivElement, CTabPaneProps>(
-  ({ children, className, onHide, onShow, visible, ...rest }, ref) => {
+  ({ children, className, onHide, onShow, transition = true, visible, ...rest }, ref) => {
     const tabPaneRef = useRef()
     const forkedRef = useForkedRef(ref, tabPaneRef)
 
@@ -35,9 +41,9 @@ export const CTabPane = forwardRef<HTMLDivElement, CTabPaneProps>(
           <div
             className={classNames(
               'tab-pane',
-              'fade',
               {
                 active: visible,
+                fade: transition,
                 show: state === 'entered',
               },
               className,
@@ -58,6 +64,7 @@ CTabPane.propTypes = {
   className: PropTypes.string,
   onHide: PropTypes.func,
   onShow: PropTypes.func,
+  transition: PropTypes.bool,
   visible: PropTypes.bool,
 }
 

package/src/components/tabs/CTabPanel.tsx

@@ -0,0 +1,98 @@
+import React, { HTMLAttributes, forwardRef, useContext, useEffect, useRef, useState } from 'react'
+import PropTypes from 'prop-types'
+import classNames from 'classnames'
+import { Transition } from 'react-transition-group'
+
+import { TabsContext } from './CTabs'
+import { useForkedRef } from '../../hooks'
+import { getTransitionDurationFromElement } from '../../utils'
+
+export interface CTabPanelProps extends HTMLAttributes<HTMLDivElement> {
+  /**
+   * A string of all className you want applied to the base component.
+   */
+  className?: string
+  /**
+   * Item key.
+   */
+  itemKey: number | string
+  /**
+   * Callback fired when the component requests to be hidden.
+   */
+  onHide?: () => void
+  /**
+   * Callback fired when the component requests to be shown.
+   */
+  onShow?: () => void
+  /**
+   * Enable fade in and fade out transition.
+   */
+  transition?: boolean
+  /**
+   * Toggle the visibility of component.
+   */
+  visible?: boolean
+}
+
+export const CTabPanel = forwardRef<HTMLDivElement, CTabPanelProps>(
+  ({ children, className, itemKey, onHide, onShow, transition = true, visible, ...rest }, ref) => {
+    const { _activeItemKey, id } = useContext(TabsContext)
+
+    const tabPaneRef = useRef()
+    const forkedRef = useForkedRef(ref, tabPaneRef)
+
+    const [_visible, setVisible] = useState(visible || _activeItemKey === itemKey)
+
+    useEffect(() => {
+      visible !== undefined && setVisible(visible)
+    }, [visible])
+
+    useEffect(() => {
+      setVisible(_activeItemKey === itemKey)
+    }, [_activeItemKey])
+
+    return (
+      <Transition
+        in={_visible}
+        nodeRef={tabPaneRef}
+        onEnter={onShow}
+        onExit={onHide}
+        timeout={tabPaneRef.current ? getTransitionDurationFromElement(tabPaneRef.current) : 0}
+      >
+        {(state) => (
+          <div
+            className={classNames(
+              'tab-pane',
+              {
+                active: _visible,
+                fade: transition,
+                show: state === 'entered',
+              },
+              className,
+            )}
+            id={`${id}${itemKey}-tab-pane`}
+            role="tabpanel"
+            aria-labelledby={`${id}${itemKey}-tab`}
+            tabIndex={0}
+            ref={forkedRef}
+            {...rest}
+          >
+            {children}
+          </div>
+        )}
+      </Transition>
+    )
+  },
+)
+
+CTabPanel.propTypes = {
+  children: PropTypes.node,
+  className: PropTypes.string,
+  itemKey: PropTypes.oneOfType([PropTypes.number, PropTypes.string]).isRequired,
+  onHide: PropTypes.func,
+  onShow: PropTypes.func,
+  transition: PropTypes.bool,
+  visible: PropTypes.bool,
+}
+
+CTabPanel.displayName = 'CTabPanel'

package/src/components/tabs/CTabs.tsx

@@ -0,0 +1,54 @@
+import React, { createContext, forwardRef, HTMLAttributes, useEffect, useId, useState } from 'react'
+import PropTypes from 'prop-types'
+import classNames from 'classnames'
+
+export interface CTabsProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+  /**
+   * The active item key.
+   */
+  activeItemKey: number | string
+  /**
+   * A string of all className you want applied to the base component.
+   */
+  className?: string
+  /**
+   * The callback is fired when the active tab changes.
+   */
+  onChange?: (value: number | string) => void
+}
+
+export interface TabsContextProps {
+  _activeItemKey?: number | string
+  setActiveItemKey: React.Dispatch<React.SetStateAction<number | string | undefined>>
+  id?: string
+}
+
+export const TabsContext = createContext({} as TabsContextProps)
+
+export const CTabs = forwardRef<HTMLDivElement, CTabsProps>(
+  ({ children, activeItemKey, className, onChange }, ref) => {
+    const id = useId()
+    const [_activeItemKey, setActiveItemKey] = useState(activeItemKey)
+
+    useEffect(() => {
+      _activeItemKey && onChange && onChange(_activeItemKey)
+    }, [_activeItemKey])
+
+    return (
+      <TabsContext.Provider value={{ _activeItemKey, setActiveItemKey, id }}>
+        <div className={classNames('tabs', className)} ref={ref}>
+          {children}
+        </div>
+      </TabsContext.Provider>
+    )
+  },
+)
+
+CTabs.propTypes = {
+  activeItemKey: PropTypes.oneOfType([PropTypes.number, PropTypes.string]).isRequired,
+  children: PropTypes.node,
+  className: PropTypes.string,
+  onChange: PropTypes.func,
+}
+
+CTabs.displayName = 'CTabs'